3505 字
18 分钟
极验3滑块验证码

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

直接集成第三方库,方便快捷。

http://47.94.198.97/

# pip install captcha-recognizer
from 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, confidence

Ddddocr: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 ddddocr
import 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-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDB45NNFhRGWzMFPn9I7k7IexS5
XviJR3E9Je7L/350x5d9AtwdlFH3ndXRwQwprLaptNb7fQoCebZxnhdyVl8Jr2J3
FZGSIa75GJnK4IwNaG10iyCjYDviMYymvCtZcGWSqSGdC/Bcn2UCOiHSMwgHJSrg
Bm1Zzu+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.CICC._CICC._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.CICC._CICC._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 接口下发的值 Snapzy_2026-08-08_16-53-24_215.png

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

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

image.png

这里返回的score分数我试了浏览器人工通过也是只有1分。

这个极验3比极验4协议更难,主要是需要模拟轨迹数组上传,还有一个前置的行为安全验证。

整体流程主要断点日志如图,最初找逻辑时可以先使用断点,等逻辑还原确定后,就可以改为日志点,既不会阻塞运行,也方便观察参数信息,还可以随时定位找回逻辑位置。 Snapzy_2026-08-08_22-55-22_223.png

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

极验3滑块验证码
https://blog.tiamix.cn/posts/极验3滑块验证码/
作者
Tiam
发布于
2026-08-08
许可协议
CC BY-NC-SA 4.0