demo:https://demos.geetest.com/slide-float.html
缺口识别
使用OpenCV 边缘检测 + 模板匹配import cv2
def find_gap_by_template(bg_path, slider_path): """ OpenCV 边缘检测 + 模板匹配 """ # 1. 读取图片 bg = cv2.imread(bg_path) slider = cv2.imread(slider_path)
# 2. 灰度化 bg_gray = cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY) slider_gray = cv2.cvtColor(slider, cv2.COLOR_BGR2GRAY)
# 3. Canny 边缘检测 bg_edge = cv2.Canny(bg_gray, 100, 200) slider_edge = cv2.Canny(slider_gray, 100, 200)
# 4. 模板匹配 result = cv2.matchTemplate(bg_edge, slider_edge, cv2.TM_CCOEFF_NORMED)
# 5. 取最佳匹配位置 min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result) x, y = max_loc h, w = slider_gray.shape
gap_center_x = x + w // 2 gap_center_y = y + h // 2 return gap_center_x直接集成第三方库,方便快捷。
# pip install captcha-recognizerfrom captcha_recognizer.slider import Slider
def find_gap_by_cr(bg_path, slider_path): # source传入待识别图片,支持数据类型为 Union[str, Path, bytes, np.ndarray] # show为布尔值,默认值为False, 为True表示展示图片识别效果,线上环境请缺省,或设置为False box, confidence = Slider().identify(source=bg_path, show=False) print(f'缺口坐标: {box}') print('置信度', confidence) return box, confidenceDdddocr:https://github.com/sml2h3/ddddocr#%E7%AE%97%E6%B3%951%E8%BE%B9%E7%BC%98%E5%8C%B9%E9%85%8D
# pip install ddddocrimport ddddocr
def find_gap_by_ddddocr(bg_path, slider_path): ocr = ddddocr.DdddOcr(det=False, ocr=False) with open(bg_path, 'rb') as f: bg_bytes = f.read() with open(slider_path, 'rb') as f: slider_bytes = f.read()
res = ocr.slide_match(slider_bytes, bg_bytes) # {'target': [110, 79], 'target_x': 110, 'target_y': 79, 'confidence': 0.48331642150878906} # 只有中心位置坐标 print(res) return res更复杂的可以使用自训练模型yolo识别。
协议分析
下发的图片是错乱的 ,然后根据某种规则重组为了一个正常的背景图canvas。
既然是canvas,就可以通过添加画布事件监听断点,在画canvas时自动断点,找到重组时的逻辑。

Python还原如下
def recombine(bg_path): # 重组错乱的验证码图像 bg_url = f"https://static.geetest.com/{bg_path}" response = requests.get(bg_url) original = Image.open(BytesIO(response.content)).convert("RGB")
# 准备 canvas target_width = 260 # 26 * 10 target_height = original.height canvas = Image.new("RGB", (target_width, target_height), (255, 255, 255)) Ut = [ 39, 38, 48, 49, 41, 40, 46, 47, 35, 34, 50, 51, 33, 32, 28, 29, 27, 26, 36, 37, 31, 30, 44, 45, 43, 42, 12, 13, 23, 22, 14, 15, 21, 20, 8, 9, 25, 24, 6, 7, 3, 2, 0, 1, 11, 10, 4, 5, 19, 18, 16, 17, ] # 拼接逻辑 for idx in range(52): src_x = (Ut[idx] % 26) * 12 + 1 src_y = 0 if Ut[idx] < 26 else target_height // 2 box = (src_x, src_y, src_x + 10, src_y + target_height // 2) chunk = original.crop(box) dst_x = (idx % 26) * 10 dst_y = 0 if idx < 26 else target_height // 2 canvas.paste(chunk, (dst_x, dst_y))
# 保存或显示结果 canvas.save("reconstructed.png") # canvas.show() return canvas搜索定位w加密位置。
加密值示例
{ "lang": "zh-cn", "userresponse": "c6c66cc6c6417", "passtime": 432, "imgload": 153, "aa": "R52.03-!)!)(!K!Tss))()y(n)ss(((_!!(d7:??7::99:$)9$)/$f))", "ep": { "v": "7.9.3", "$_BIT": false, "me": true, "tm": { "a": 1785915271526, "b": 1785915271824, "c": 1785915271824, "d": 0, "e": 0, "f": 1785915271536, "g": 1785915271544, "h": 1785915271636, "i": 1785915271636, "j": 1785915271740, "k": 1785915271672, "l": 1785915271740, "m": 1785915271815, "n": 1785915271815, "o": 1785915271826, "p": 1785915276835, "q": 1785915276835, "r": 1785915276837, "s": 1785915276838, "t": 1785915276838, "u": 1785915276838 }, "td": -1 }, "h9s9": "1816378497", "rp": "0615923a420101706fb42f984f52132d"}
根据this公钥对象,还原pem格式公钥
- n → 模数(BigInteger,分块存储,每块30位)
- e → 公钥指数 65537
- t → 块数量(37块)
- s → 符号位(0=正数)
-----BEGIN PUBLIC KEY-----MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDB45NNFhRGWzMFPn9I7k7IexS5XviJR3E9Je7L/350x5d9AtwdlFH3ndXRwQwprLaptNb7fQoCebZxnhdyVl8Jr2J3FZGSIa75GJnK4IwNaG10iyCjYDviMYymvCtZcGWSqSGdC/Bcn2UCOiHSMwgHJSrgBm1Zzu+l8nSOqAurgQIDAQAB-----END PUBLIC KEY-----
w参数核心算法依旧是 AES+RSA算法加密,新增对AES的结果使用了自定义base64,而不是转为十六进制。
def custom_encode(input: bytes) -> str: """自定义 base64 编码""" TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789()" MASKS = [0x6F0000, 0x90B400, 0x4B14, 0xEB] PAD = '.'
def extract_bits(chunk: int, mask: int) -> int: """按掩码提取并压缩有效位""" return sum( ((chunk >> i) & 1) << idx for idx, i in enumerate(i for i in range(24) if (mask >> i) & 1) )
# input = bytes.fromhex(input)
res = []
for i in range(0, len(input), 3): group = input[i:i+3] # 不足3字节时补0 chunk = int.from_bytes(group.ljust(3, b'\x00'), 'big') pad_len = 3 - len(group) char_count = 4 - pad_len # 实际有效编码字符数
res.extend(TABLE[extract_bits(chunk, m)] for m in MASKS[:char_count])
res.append(PAD * (3 - len(input) % 3) if len(input) % 3 else '')
result = ''.join(res) return result
对比同一验证码的两次请求参数,发现只有userresponse、passtime、aa、rp四个参数每次不一致。
当更换验证码时,新增了 imgload、ep.tm 两个值的变化。
aa 是加密的轨迹数组
passtime 是响应时间

rp 逻辑为,将主要参数哈希
md5(gt + challenge[0:32] + passtime)
userresponse 由水平偏移距离和challenge参与了计算,生成了一个10位字符串,且带有随机属性,每次计算结果不固定。还原时hook Math.random() 函数,使其每次返回固定值,对比验证还原算法值是否一致。
// 备份原函数(可选,用于恢复)const originalRandom = Math.random;
// 重写为固定返回值Math.random = function() { return 0.123456789; // 每次调用都返回这个固定值};
// 伪装成原生函数Math.random.toString = function() { return "function random() { [native code] }";};def encode_token(seed: int, charset: str) -> str: """ 根据种子数值和字符集字符串,生成一个随机编码字符串。
:param seed: 数值种子,例如 126 :param charset: 编码字符串,末尾2位为36进制偏移量,例如 "5489362478aa93cd157a03c36e70859449" :return: 随机编码结果,例如 "c333c99824" """
# ── 1. 解析末尾2位,得到偏移量(36进制) ───────────────────── tail = charset[-2:] # "49" decoded = [] for ch in tail: code = ord(ch) decoded.append(code - 87 if code > 57 else code - 48) offset = decoded[0] * 36 + decoded[1] # 4*36+9 = 153
# ── 2. 计算目标值 ────────────────────────────────────────── target = int(math.fabs(seed)) + offset # abs(126)+153 = 279
# ── 3. 去掉末尾2位,对剩余字符去重后轮流分配到5个桶 ────────── body = charset[:-2] # "5489362478aa93cd157a03c36e708594"
char_buckets = [[], [], [], [], []] seen_chars = {} bucket_index = 0
for ch in body: if ch not in seen_chars: seen_chars[ch] = True char_buckets[bucket_index].append(ch) bucket_index = (bucket_index + 1) % 5
# ── 4. 贪心分解 target,每步从对应桶随机取字符 ─────────────── denominations = [1, 2, 5, 10, 50] denom_index = len(denominations) - 1 # 从最大面额50开始 remaining = target result = ""
while remaining > 0: if remaining - denominations[denom_index] >= 0: # 当前面额可用,随机取对应桶中一个字符 rand_pos = int(random.random() * len(char_buckets[denom_index])) result += char_buckets[denom_index][rand_pos] remaining -= denominations[denom_index] else: # 当前面额太大,移除并降级 char_buckets.pop(denom_index) denominations.pop(denom_index) denom_index -= 1
return result
aa 的值由轨迹数组和下发的c、s值加密而成
var v2856 = vThis63[v2841(986)][v2843(1024)](vThis63[v2843(986)][v2843(1060)](), vThis63[v2841(75)][v2843(1080)], vThis63[v2843(75)][v2841(385)]);
// 简化vThis63.$_CICC.$_BBEl(vThis63.$_CICC.$_FDd(), vThis63.$_CJQ.c, vThis63.$_CJQ.s)vThis63._FDd() 会加密轨迹,返回一段字符串。还原算法如下
c 和 s 的值为接口下发值。
import math
def process(points): CHARSET = "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqr" DIRECTIONS = "stuvwxyz~" DIRECTION_MAP = [[1,0],[2,0],[1,-1],[1,1],[0,1],[0,-1],[3,0],[2,-1],[2,1]]
def encode(n): base = len(CHARSET) # 66 v = math.floor(abs(n)) hi = min(v // base, base - 1) # 负数前缀用单个"!",大数前缀标志用"~" prefix = ("!" if n < 0 else "") + ("$" + CHARSET[hi] if hi else "") return prefix + CHARSET[v % base]
def direction_char(dx, dy): for i, (mx, my) in enumerate(DIRECTION_MAP): if dx == mx and dy == my: return DIRECTIONS[i] return None
# 差分 + 合并纯时间段(dx/dy 不取绝对值,dt 取绝对值) segments, acc = [], 0 dx = dy = dt = 0 for i in range(len(points) - 1): dx = points[i+1][0] - points[i][0] # 不取绝对值 dy = points[i+1][1] - points[i][1] # 不取绝对值 dt = math.floor(abs(points[i+1][2] - points[i][2])) # 时间取绝对值 if dx == 0 and dy == 0: acc += dt elif dx or dy or dt: segments.append((dx, dy, dt + acc)) acc = 0 if acc: segments.append((dx, dy, acc))
xs, ys, ts = [], [], [] for dx, dy, dt in segments: dc = direction_char(dx, dy) if dc: ys.append(dc) else: xs.append(encode(dx)) ys.append(encode(dy)) ts.append(encode(dt))
return "!!".join(["".join(xs), "".join(ys), "".join(ts)])
# 测试trajectory = [ [-26,-37,0],[0,0,0],[0,0,123],[1,0,145],[1,0,160], [7,0,179],[10,0,190],[19,1,202],[23,1,226],[30,2,239], [43,3,258],[44,3,269],[53,3,281],[60,3,306],[62,3,316], [67,3,336],[70,3,349],[74,3,365],[75,3,387],[76,3,398], [77,3,427],[77,3,438],[77,4,465],[77,4,481],[78,4,498], [78,4,518],[79,4,531],[79,4,548],[79,4,565],[80,4,584], [80,4,598],[81,4,618],[81,4,631],[81,4,1307]]
print(process(trajectory))# G/2-0620.-(!!Rs(y)())s((t(y(ssswssss(!!($*8O45E6@45F3A69C4JSNNgO$3T
还原最外层的函数vThis63._BBEl算法
def decrypt(text, keys, hex_str): if not keys or not hex_str: return text
key_a, key_b, key_c = keys[0], keys[2], keys[4] original_len = len(text) result = text
for i in range(0, len(hex_str), 2): chunk = hex_str[i:i+2] if not chunk: break
char_code = int(chunk, 16) char = chr(char_code)
# 二次函数计算插入位置,模原始长度保证位置不越界 insert_pos = (key_a * char_code ** 2 + key_b * char_code + key_c) % original_len
result = result[:insert_pos] + char + result[insert_pos:]
return result
# 测试text = 'G/2-0620.-(!!Rs(y)())s((t(y(ssswssss(!!($*8O45E6@45F3A69C4JSNNgO$3T'keys = [12, 58, 98, 36, 43, 95, 62, 15, 12]hex_str = '54346853'
print(decrypt(text, keys, hex_str))
tm值为window.performance.timing映射健名后,就是网页加载时各个阶段的性能情况。

imgload 根据名字应该就可以猜测是图片的加载耗时,
这里定位到是从this中取值的,代码中搜索索引707,定位到另一处,找到其赋值位置,确实是Date.now() - start的计算逻辑。
这里使用相同的索引707,虽然使用的不同的函数,实际最终指向的是相同的解码器,所以属性名是相同的。

最终整合了全部算法,开始发起请求测试。但是一直没能通过,重新对比了所有算法的输入输出值没啥问题。
还有个就是最初时的点击安全校验也有w参数,但是我发现不携带也可以返回success,就没有携带。
在浏览器中调试时,断点将w参数移除掉不携带,也同样出现问题,即使正确滑动滑动也无法通过。那问题就是出现在这里。
当出现异常时,还会触发上报异常
https://api.geevisit.com/reset.php
https://monitor.geetest.com/monitor/send
或许通过这些信息,可能被怀疑在调试,然后被拉黑设备或IP
这次接口的逻辑在JS:https://static.geetest.com/static/js/fullpage.9.2.0-guwyxh.js
先反混淆:https://webcrack.netlify.app/
也是先搜索了一波定位,找个几处位置w的位置。但是最后确定不是。
然后在网络-启动器-网上跟调用堆栈,找到在this中赋值,同样搜索索引 即可找到另一处赋值的位置。

找到加密值如下示例, 应该是一些浏览器环境相关信息。
{ "lang": "zh-cn", "type": "fullpage", "tt": "M)K8M-.*M)A-gB:ACuf7.4M:-9-N(N_..8N-A//-)CK7)(F*(,jB.,(dc,-N-3Z9D1m3*M)(U/((,M).-:@((po)TdZ9N(?C)M)1*-j/(Lqb", "light": "SPAN_0", "s": "c7c3e21112fe4f741921cb3e4ff9f7cb", "h": "321f9af1e098233dbd03f250fd2b5e21", "hh": "39bd9cad9e425c3a8f51610fd506e3b3", "hi": "09eb21b3ae9542a9bc1e8b63b3d9a467", "vip_order": -1, "ct": -1, "ep": { "v": "9.2.0-guwyxh", "te": false, "$_BBn": true, "ven": "Google Inc. (Apple)", "ren": "ANGLE (Apple, ANGLE Metal Renderer: Apple M1, Unspecified Version)", "fp": [ "move", 708, 239, 1786081619710, "pointermove" ], "lp": [ "up", 863, 109, 1786081622770, "pointerup" ], "em": { "ph": 0, "cp": 0, "ek": "11", "wd": 1, "nt": 0, "si": 0, "sc": 0 }, "tm": { "a": 1786081592249, "b": 1786081592299, "c": 1786081592299, "d": 0, "e": 0, "f": 1786081592250, "g": 1786081592250, "h": 1786081592250, "i": 1786081592250, "j": 1786081592250, "k": 0, "l": 1786081592254, "m": 1786081592290, "n": 1786081592291, "o": 1786081592301, "p": 1786081596810, "q": 1786081596810, "r": 1786081596812, "s": 1786081596813, "t": 1786081596813, "u": 1786081596813 }, "dnf": "dnf", "by": 0 }, "passtime": 30796, "rp": "8ea5e5d26565d6ad64cfebea35147be4", "captcha_token": "1373170622", "tsfq": "xovrayel"}对比两次值,查找不同的参数
tt 、fp、lp、tm、passtime 、rp
其中passtime应该是某种耗时,rp应该算法一致,tm就是window.performance.timing
fp和Ip应该是某个情况下鼠标位置信息,tt未知,应该也是被加密了。

继续向上跟值, 找到tt的生成位置,是加密了一个轨迹数组而来。整体算法如下。本质上是一个自定义的高效轨迹数据序列化与压缩编码方案
import math
CHARSET = "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"
EVENT_MAP = { "move": 0, "down": 1, "up": 2, "scroll": 3, "focus": 4, "blur": 5, "unload": 6, "unknown": 7}
def to_bin(num, length): return bin(num)[2:].zfill(length)
def base64_encode(bits): bits += "0" * (-len(bits) % 6) return "".join(CHARSET[int(bits[i:i+6], 2)] for i in range(0, len(bits), 6))
def serialize_events(events): tokens, i, n = [], 0, len(events) while i < n: cur, run = events[i], 0 while run < 16 and i + run + 1 < n and events[i + run + 1] == cur: run += 1 if run: tokens += [cur | 8, run - 1] else: tokens.append(cur) i += run + 1
return to_bin(n | 32768, 16) + "".join(to_bin(v, 4) for v in tokens)
def serialize_values(values, extract_sign=False): # 限幅 values = [max(-32767, min(32767, x)) for x in values]
# 游程压缩 compressed, i, n = [], 0, len(values) while i < n: s, run = values[i], 1 a = abs(s) while i + run < n and values[i + run] == s and a < 127 and run < 127: run += 1 compressed.append((49152 if s < 0 else 32768) | (run << 7) | a if run > 1 else s) i += run
# 变长编码 widths, vals = [], [] for v in compressed: a = abs(v) t = max(1, math.ceil(math.log2(a + 1) / 4)) if a else 1 widths.append(to_bin(t - 1, 2)) vals.append(to_bin(a, t * 4))
# 符号位 signs = "" if extract_sign: signs = "".join( ("1" if v < 0 else "0") for v in compressed if v != 0 and (v >> 15) != 1 )
return to_bin(len(compressed) | 32768, 16) + "".join(widths) + "".join(vals) + signs
def generate_track_hash(events): types, times, xs, ys = [], [], [], []
for e in events: types.append(EVENT_MAP[e[0]]) if len(e) == 3: xs.append(e[1][0]) ys.append(e[1][1]) times.append(e[2]) elif len(e) == 2: times.append(e[1])
bits = (serialize_events(types) + serialize_values(times) + serialize_values(xs, extract_sign=True) + serialize_values(ys, extract_sign=True))
return base64_encode(bits)
理清整个流程,对比w的输入输出,使用相同的AES+自定义Base64算法加密,只是参数不一样了。
tt 是一段鼠标的轨迹,
fp 是该轨迹的起始位,lp是该轨迹的结束位置。

然后发现这次的w值,后面并没有添加rsa加密的密钥,那可能其他地方将密钥上发给了服务器。
查看网络包,前有一个接口也携带w值,并尾部存在rsa加密的密钥,猜测验证其使用的密钥相同。所以第二次接口中的w就直接没有携带密钥上发。
{ "gt": "019924a82c70bb123aae90d483087f94", "challenge": "52f49a8a56b078de362f2f3494464170", "offline": false, "new_captcha": true, "product": "float", "width": "300px", "https": true, "api_server": "apiv6.geetest.com", "protocol": "https://", "type": "fullpage", "static_servers": [ "static.geetest.com/", "static.geevisit.com/" ], "click": "/static/js/click.3.1.2.js", "beeline": "/static/js/beeline.1.0.1.js", "voice": "/static/js/voice.1.2.6.js", "fullpage": "/static/js/fullpage.9.2.0-guwyxh.js", "slide": "/static/js/slide.7.9.3.js", "geetest": "/static/js/geetest.6.0.9.js", "aspect_radio": { "slide": 103, "click": 128, "voice": 128, "beeline": 50 }, "cc": 8, "ww": true, "i": "-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1!!-1"}
对比两次参数,只有challenge一个参数不一致,其余均可固定。
其余大部分值为 gettype 接口下发的值

还有个细节,所有的challenge看起来一样,但是获取验证码的接口返回的challenge后面额外携带了两个字符,并参与了userresponse的计算。

出现”message”: “forbidden”,多半是轨迹参数等不够拟人。 “message”: “fail” 可能是某处参数算法错误, 而 w 的计算错误会导致 “error”: “param decrypt error”, 服务端那边无法获取解密参数。 rsa公钥错误也会导致该响应。 最后也是成功通过了。

这里返回的score分数我试了浏览器人工通过也是只有1分。
这个极验3比极验4协议更难,主要是需要模拟轨迹数组上传,还有一个前置的行为安全验证。
整体流程主要断点日志如图,最初找逻辑时可以先使用断点,等逻辑还原确定后,就可以改为日志点,既不会阻塞运行,也方便观察参数信息,还可以随时定位找回逻辑位置。

关于算法还原,应该还是了解一些常见算法的明显特征,以便定位后能识别对应算法,然后对比标准算法的输入输出以确定。若是自定义的一些算法逻辑,只能断点一步一步慢慢扣了。但是借助现在AI的能力,以前的chat可以定位到具体的混淆函数后直接让AI还原更快捷。现在Agent甚至还可以全自动完成整个逆向。