3903 字
20 分钟
极验4滑块验证码

demo:https://nopecha.com/captcha/geetest?nocache#slide

主要逆向JS:https://static.geetest.com/v4/static/v1.9.6-1db46d/js/gcaptcha4.js

缺口定位

已有方案,使用的opencv实现的缺口识别,还挺准的:[https://github.com/chenwei-zhao/captcha-recognizer/blob/main/captcha_recognizer/slider.py](https://github.com/chenwei-zhao/captcha-recognizer/blob/main/captcha_recognizer/slider.py)

但是这次我要用yolo训练一个模型尝试,以此为例来个简单的先。

yolo:https://docs.ultralytics.com/zh/tasks/detect#%E6%A8%A1%E5%9E%8B

使用yolo自训练模型识别滑块缺口。默认的模型只能识别人和车,要识别其他物体,需要自行标注训练。

简单写一个脚本采集一点数据集图片

import json
from pathlib import Path
import requests
import time
import uuid
import re
# https://static.geetest.com/v4/static/v1.9.6-1db46d/js/gcaptcha4.js
cookies = {
'captcha_v4_user': '456cbdcb1d6e46f9a5e9fe26c9a86fd8',
}
headers = {
'Accept': '*/*',
'Accept-Language': 'zh-CN,zh;q=0.9',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
'Pragma': 'no-cache',
'Referer': 'https://nopecha.com/',
'Sec-Fetch-Dest': 'script',
'Sec-Fetch-Mode': 'no-cors',
'Sec-Fetch-Site': 'cross-site',
'Sec-Fetch-Storage-Access': 'active',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
'sec-ch-ua': '"Not;A=Brand";v="8", "Chromium";v="150", "Google Chrome";v="150"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
# 'Cookie': 'captcha_v4_user=456cbdcb1d6e46f9a5e9fe26c9a86fd8',
}
def load_captcha_data():
timestamp = int(time.time() * 1000)
callback = f'geetest_{timestamp}'
challenge = str(uuid.uuid4())
params = {
'callback': callback,
# 应该是分配到该网站服务的固定值
'captcha_id': '54088bb07d2df3c46b79f80300b0abbe',
'challenge': challenge,
'client_type': 'web',
'risk_type': 'slide',
'lang': 'eng',
}
response = requests.get('https://gcaptcha4.geetest.com/load', params=params, cookies=cookies, headers=headers)
resp = re.match(fr"{callback}\((.*)\)", response.text)
if resp:
json_data = json.loads(resp.group(1))
# print(json_data)
if json_data['status'] == 'success':
data = json_data['data']
# print(data)
slice = data['slice']
bg = data['bg']
print(f'slice: {slice}, bg: {bg}')
return slice, bg
# https://static.geetest.com/captcha_v4/e70fbf1d77/slide/0af8d91d43/2022-04-21T09/bg/f8f86da3311142528b03c94cbbcd8293.png
# captcha_v4/e70fbf1d77/slide/4b268eea89/2022-04-21T09/bg/390885a0970c4859979e5d02324e26b9.png
print(f'failed: {response.text}')
return None, None
def download_captcha(slice, bg):
dirs = [
Path("GeeTestSlide/slice_test"),
Path("GeeTestSlide/bg_test"),
]
# 创建文件夹
for dir in dirs:
dir.mkdir(parents=True, exist_ok=True)
for path, dir in zip([slice, bg], dirs):
url = f'https://static.geetest.com/{path}'
response = requests.get(url, cookies=cookies, headers=headers)
filename = url.split('/')[-1]
filepath = Path(dir, filename)
with open(filepath, 'wb') as f:
f.write(response.content)
print(f'downloaded: {filepath}')
def main():
for i in range(30):
print(f'round {i}')
slice, bg = load_captcha_data()
download_captcha(slice, bg)
if __name__ == '__main__':
main()

注册在线标注平台:https://platform.ultralytics.com/tiam/datasets/slidecode,上传图片,进行人工标注。

其中数据集划分为Train / Val / Test 三类,Train 学知识 → Val 改作业 → Test 模拟考试1

原始数据集 100%
│
├── Train 训练集 (70~80%)
│ └── 模型在这上面学习参数
│
├── Val 验证集 (10~20%)
│ └── 每轮训练后评估,用于调参 & 早停 & 选 best.pt
│
└── Test 测试集 (10~20%)
└── 训练完全结束后,最终评估一次

你需要标注Train和Val数据集,Test集无需标注。

我这里分配如图: image.png

完成标注后,点击右上角New Model训练新模型。

可以选择云端/本地训练, 云端设备训练收费,但是注册送了5美元额度,本次训练只消耗了6美分。

训练后如下参数:

Precision(精确率)= 98.3% ,模型说”这是缺口”的框里,有多少是真的缺口?这里说明已经标注的,98.3%都是对的。

Recall(召回率)= 89.5% ,所有真实缺口里,模型找到了多少个?这里说明有约10%的缺口,未能被发现。这里还可以提高补足。

mAP50 = 98.3% , 放宽标准:框和真实位置重叠 ≥ 50% 就算对

mAP50-95 = 96.4% ,严格标准:从 IoU=0.5 一直考到 IoU=0.95,取平均。

唯一的小短板是 Recall = 89.5%,说明大约 10% 的缺口没被检测到。改进方向:

  • 增加这些”漏掉”场景的训练样本
  • 降低推理时的 conf 阈值(默认 0.25),让模型多输出一些候选框
  • 尝试数据增强(模糊、亮度变化等)

image.png

导出PyTourch模型(后缀.pt)

测试模型标注情况,11个图片,有一个未标注缺口,其余均标注准确。

from pathlib import Path
from ultralytics import YOLO
# https://docs.ultralytics.com/zh/tasks/detect#%E8%AE%AD%E7%BB%83
#
# 数据标注:https://platform.ultralytics.com/home
# 默认的模型只能识别人和车,要识别其他物体,需要自行训练
model = YOLO("GeeTestSlide/slidecode.pt") # load a pretrained YOLO26n model
dir = Path("GeeTestSlide/bg_test")
for img in dir.glob("*.png"):
results = model(img.as_posix()) # run inference
# Access the results
for result in results:
xywh = result.boxes.xywh # center-x, center-y, width, height
xywhn = result.boxes.xywhn # normalized
xyxy = result.boxes.xyxy # top-left-x, top-left-y, bottom-right-x, bottom-right-y
xyxyn = result.boxes.xyxyn # normalized
names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # class name of each box
confs = result.boxes.conf # confidence score of each box
print(f'xywh: {xywh}, xywhn: {xywhn}, xyxy: {xyxy}, xyxyn: {xyxyn}, names: {names}, confs: {confs}')
respath = Path("GeeTestSlide/result", img.name)
result.save(respath.as_posix())

协议分析

[https://gcaptcha4.geetest.com/load](https://gcaptcha4.geetest.com/load) 接口的响应值中存在一个payload值,但是该payload值并未进行任何操作解密或参与计算等,按原样上传。
params = {
'callback': 'geetest_1785377348723',
'captcha_id': '54088bb07d2df3c46b79f80300b0abbe',
'client_type': 'web',
'lot_number': '3ae9ab78fc644e6a90a2d0ed5b971110',
'risk_type': 'slide',
'payload': 'AgFD8gWUUuHFx-XvpP7J2XHtSHNYnHdqutC-Jfx9qF6qMz24smIxEbjNA1lxc-Rl5zRd-41SW8lVy-nFDkOheeE_j6O7mX9Mo-juvnKVTLtymPPbWstiCRMGXEq5YHlF5JZYhSm8ap4TxgiyuQ71v0uYjbVmZfvl0zvjRCUk5YExQ2FKcXO1sGr56LQm_iVjbdvjq5cqZRyXuTPtKcKXyftt8LpsRyRrnfI4ZjHla1M7O55R3RRZ-jgELstPDa6jlonVmymJGSJV18EjMGO1NjQhlMZrNQ1fFUpIXcEtaxLSbjo0XQaHDPuw09eTrA6V38Gt4VXFpFClLUBC6ihjUI9uQ-gSmVIBIZsZLAhuHyMLP6DBICWDk5u1TZdTsNmK-pmIed4xF-WcNgCEw4QdR_lomR3-zsIi5zj3OBrfC_C4BLifmeRqveQXwRoTXp_DMhB78qlPF5vRgGQ_s0bmps7zjPGNmxlZJLn_MMADVCfNBIoEt8N4uLWZUsdDMLQScZxe6Zqhvf9Vppgn_EK0z6SBl_1o5onrxmPyMZzY_W5Odm1-viXVLSvpoaG9bjxYMLGLuxeROxPh_EoQ4ItLL7w49Wa9FJWYh-BlGboKZInTOP0o5uRx0rqnMj9M7iYr5iuZIXu-0Mqz9t_2x1hk0GbqQv4MOYXIT_SEmhq8P2xFayWcTK12DmBo3wzNl1DoRlyF9YrRvTQWOb5pBQ9Dl28VSEcRtgAvyUINgs6LBvKvEGb9SUmUxGbfcnNCeoHWEDbT_GIwr6crrdzXT6GgENrEGIA5qG-palkm3ZXgeuEFpWR11_tHFd97za9u0euTpQsN7OU1BdQZiAT6PpIVcHr7-LvmTR_XUnApJiOMgzdb_mW9gu-t_JhTi1DOC3QmJqEkI0W2QhSQgNKKPK_tiw==',
'process_token': '0845ffcb07ee52f11f40b54a8362cf8ff035bf6dffe4d46771bc94301c8cafbc',
'payload_protocol': '1',
'pt': '1',
'w': 'd55e5a7240d9fb91b0cab9742f123691bcabb4ed6b40f91c0569f143e3d58e19158e812e9f71af10ce282c213d0617c18381f0f88d814af947801620b2beb4d6b1a2161e50e45012b92a05e75d1f56d688f21c039cace28b29c59ebbbda731823293be052b9726637a67a5083613c98b604bb08dce0f2794eca56d9f70e9c8c6d62b173d46678f290e5d17f2af2c0769a2c7b08f50a1f541074bee5d303a40efc56c298888efca72061c7b4bcec957d6031533fcffe19614023511777a3aeff1694a9e7838604ad20738d372c5b8d4ec4d5f8a3577454ede5c8d948023aeacb702e7796821918f7f4d27b7afe6950879b54f66aac4a214664da732cd8123470b7cfd4b96eed314ea9f231b8fbd71965a37599d740dd9dadb11849762f9f51a23c1be3a39ede25e9b6cbdb7f7b990ad85579f689bd923baa85e502900cec1fd0ec2e734e884854322531964d607863780112aed1895bddc01a7877ab33c60283222c47afcb8ec9748aea22fd288a3827a36f1abca7a1819643b692c7e8f8218c0a5c609fb0e441e5e5cf1a4300453eb8fe7609264609c6769effd6a331e79e59e400f190c312c79c87880f0f8419f7363abf3d4c8710f40a68e95eff08fb8fb9828a1d11e12be5c181f14462790d9eef3609e19b66d76ae83d26e317ec1b274c79355ae323e6588b78eb63c6346895104477f5d0604a1bd0d924311b28b9ace254f7cd9dc389fd94f83fd1828b7d25a2bdc73b907b5a9251adc7f40b97f94138c641492a6ecf037dadc38de3103d4962721ec63b91d919d961d920d230a5e21df27a99d0bb51f3c5334123c794f2f7a52fbe971486fafa42d55a43194237e8efd7cf0d1708fb5e9cb6f4151f594d362e32df3f92fa03d899ecbbaba411da0601df02beef03347ce7f61ed66067b4bef5f1fb88632da1734623bda3870f2f3d94f4511548763e2fe663838d9449bfeba0f0d3fb94b0f979e7cb5d0a6330c683b7778e63a30a1753224abf03c00c38bc515550af7ac9a2079501df6e99ef40e177c',
}

使用https://github.com/kuizuo/js-deobfuscator 可以反混淆一部分,替换了变量名更易读。

w值签名加密位置, RSA+AES混合加密

在函数f228中,通过guid函数生成了一个随机16位长度的十六进制字符串。

new v_37.default().encrypt("27e499f65c351d84")实际调用了函数 f292 将16位字符加密为例一个256长度的字符串。这是一个标准的、使用 PKCS#1 v1.5 填充模式的 RSA 公钥加密函数。

将this中的分片数组转为pem密钥

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
from Crypto.Util.number import long_to_bytes
from cryptography.hazmat.primitives import serialization
import base64
# ── 1. 重组分片 n ──────────────────────────────────────────────
def reconstruct_n(parts: dict, t: int, bits_per_chunk: int = 28) -> int:
result = 0
for i in range(t - 1, -1, -1):
result = (result << bits_per_chunk) | parts[str(i)]
return result
raw = {
"0": 134982529, "1": 254232810, "2": 164556709, "3": 234907349,
"4": 134685994, "5": 35463984, "6": 258277946, "7": 12518857,
"8": 44638621, "9": 93783641, "10": 212253739, "11": 62792472,
"12": 186688352, "13": 109500232, "14": 182488077, "15": 261196188,
"16": 26354094, "17": 103248217, "18": 106891695, "19": 165771045,
"20": 41530993, "21": 263704736, "22": 111785174, "23": 12753611,
"24": 232116673, "25": 155524985, "26": 218291229, "27": 122452343,
"28": 248250238, "29": 118739550, "30": 251169095, "31": 129059733,
"32": 149835464, "33": 5498868, "34": 71719731, "35": 154456417,
"36": 49635,
}
e_val = 65537
n_val = reconstruct_n(raw, t=37, bits_per_chunk=28)
print(f"[*] n ({n_val.bit_length()} bits) = {n_val}")
# ── 2. 生成标准 PEM 字符串 ──────────────────────────────────────
def build_pem(n: int, e: int) -> str:
"""
通过 n 和 e 构造标准 PEM 公钥字符串
RSA.construct() → export_key("PEM") 即可被 import_key() 识别
"""
key = RSA.construct((n, e))
pem = key.export_key("PEM") # 默认导出 PKCS#8 SubjectPublicKeyInfo 格式
return pem.decode("utf-8")
rsa_public_key_pem = build_pem(n_val, e_val)
print("[*] 生成的 PEM 公钥:")
print(rsa_public_key_pem)
def get_rsa_params(pem_str):
public_key = serialization.load_pem_public_key(pem_str.encode())
numbers = public_key.public_numbers()
return (numbers.n, numbers.e)
n, e = get_rsa_params(rsa_public_key_pem)
print("[*] 解析得到的 RSA 参数:")
print(n, e)
# ── 3. 验证可以直接 import_key ──────────────────────────────────
rsa_key = RSA.import_key(rsa_public_key_pem)
cipher_rsa = PKCS1_v1_5.new(rsa_key)
# ── 4. 加密函数 ────────────────────────────────────────────────
def rsa_encrypt(plaintext: str | bytes):
if isinstance(plaintext, str):
plaintext = plaintext.encode("utf-8")
ciphertext = cipher_rsa.encrypt(plaintext)
return ciphertext
# ── 5. 测试 ────────────────────────────────────────────────────
msg = "aa883f3dd0530f6b"
ciphertext = rsa_encrypt(msg)
print(f"\n[*] 明文: {msg}")
print(f"[*] 密文(B64): {base64.b64encode(ciphertext).decode()}")
print(f"[*] 密文(HEX): {ciphertext.hex()}")

密钥结果为:

-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDB45NNFhRGWzMFPn9I7k7IexS5
XviJR3E9Je7L/350x5d9AtwdlFH3ndXRwQwprLaptNb7fQoCebZxnhdyVl8Jr2J3
FZGSIa75GJnK4IwNaG10iyCjYDviMYymvCtZcGWSqSGdC/Bcn2UCOiHSMwgHJSrg
Bm1Zzu+l8nSOqAurgQIDAQAB
-----END PUBLIC KEY-----

vP871.arrayToHex(v_36.default.encrypt(p873,"27e499f65c351d84"))

加密算法:标准AES-CBC

key: “27e499f65c351d84”

iv: “0000000000000000”

加密值示例(格式化后)

{
"setLeft": 149,
"passtime": 3148,
"userresponse": 150.1191845823503,
"device_id": "",
"lot_number": "18aade8b38a043a3b7de9d1fc34cc152",
"pow_msg": "1|8|sha256|2026-07-28T14:17:27.344346+08:00|54088bb07d2df3c46b79f80300b0abbe|18aade8b38a043a3b7de9d1fc34cc152||439c09a58dd3bfa7",
"pow_sign": "0069e32aa6bcf5c30161ebf2e3eee193073213ed75414cc040a4ed7d0efbd4e0",
"geetest": "captcha",
"lang": "zh",
"ep": "123",
"biht": "1426265548",
"gee_guard": {
"roe": {
"aup": "3",
"sep": "3",
"egp": "3",
"auh": "3",
"rew": "3",
"snh": "3",
"res": "3",
"cdc": "3"
}
},
"YYhg": "BjI0",
"8aad": "c34c",
"em": {
"ph": 0,
"cp": 0,
"ek": "11",
"wd": 1,
"nt": 0,
"si": 0,
"sc": 0
}
}

总结w值的算法:

data 为待加密的数据对象
data_str = json.dump(data)
# 随机16位长度的十六进制字符串
guid = random.choices('0123456789ABCDEF', k=16)
# AES加密
part1 = AES-CBC(
key=guid,
iv="0000000000000000",
input=data_str
)
# 使用 PKCS#1 v1.5 填充模式的 RSA 公钥加密函数, 256位长度的十六进制字符串
part2 = RSA-PKCS1.5(guid)
w = part1 + part2

对比两次发起值的差异

固定key:YYhg下有一对看似随机的KV值,每次都不一样。

实际key取值逻辑为lot_number的【1,4】位,value值为lot_number的【24,27】位。

pow_msg,pow_sign算法逻辑如下

# 固定值
captchaId: '54088bb07d2df3c46b79f80300b0abbe'
# load接口响应
"lot_number": "ba90470205bf4401be337a03f58b22bf",
"pow_detail": {
"version": "1",
"bits": 8,
"datetime": "2026-07-29T17:30:13.535900+08:00",
"hashfunc": "sha256"
},
guid: 043d256fa731eab3
pow_msg = '1|8|sha256|2026-07-29T17:30:13.535900+08:00|54088bb07d2df3c46b79f80300b0abbe|ba90470205bf4401be337a03f58b22bf||043d256fa731eab3'
pow_sign = SHA256(pow_msg)

这里的guid并不是完全随机的,必须满足pow_sign要求 hash 前 8 bit 为 0 → 前 2 个 hex 字符为 00

import hashlib, secrets
def solve_pow(version, bits, hashfunc, datetime, captcha_id, lot_number):
prefix = f"{version}|{bits}|{hashfunc}|{datetime}|{captcha_id}|{lot_number}||"
fn = {'md5': hashlib.md5, 'sha1': hashlib.sha1, 'sha256': hashlib.sha256}[hashfunc]
zeros, rem = divmod(bits, 4)
thresh = {1: 7, 2: 3, 3: 1}.get(rem)
target = '0' * zeros
while True:
nonce = secrets.token_hex(8)
msg = prefix + nonce
sign = fn(msg.encode()).hexdigest()
if sign.startswith(target):
if rem == 0 or int(sign[zeros], 16) <= thresh:
return msg, sign

setLeft: 滑块水平位移

passtime: 滑动耗时,单位毫秒

userresponse: 归一化响应值

vThis46.$_BHJK.$_JBD轨迹数组,但是实际该数组并没有上传,只上传了最终的水平位移距离和滑动耗时。应该是该滑块属于简单类的,实际应该会上传轨迹数组。

var vO43 = {
setLeft: vParseInt5,
passtime: v5828,
userresponse: vParseInt5 / vThis46[v5823(1472)] + 2
};

biht 计算自https://static.geetest.com/v4/gct/gct4.5a2e755576738ba0499d714db4f1c9e0.js

是一个DJB2 哈希算法

测试

整合所有值测试,但是一直没能通过。找了很久,发现是pow_sign的签名问题,必须满足pow_sign要求 hash 前 8 bit 为 0 → 前 2 个 hex 字符为 00。

还有就是轨迹的问题,没有发现上传轨迹数据的参数,但是应该是会上传的。最后确认确实没有上传轨迹参数。

修正完错误,完整代码如下:

import json
import math
import requests
import time
import uuid
import re
import random
# uv add pycryptodome
from Crypto.Cipher import AES, PKCS1_v1_5
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad
# uv add ultralytics
from ultralytics import YOLO
from loguru import logger
import hashlib, secrets
headers = {
'Accept': '*/*',
'Accept-Language': 'zh-CN,zh;q=0.9',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive',
'Pragma': 'no-cache',
'Referer': 'https://nopecha.com/',
'Sec-Fetch-Dest': 'script',
'Sec-Fetch-Mode': 'no-cors',
'Sec-Fetch-Site': 'cross-site',
'Sec-Fetch-Storage-Access': 'active',
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36',
'sec-ch-ua': '"Not;A=Brand";v="8", "Chromium";v="150", "Google Chrome";v="150"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
# 'Cookie': 'captcha_v4_user=456cbdcb1d6e46f9a5e9fe26c9a86fd8',
}
captcha_id = '54088bb07d2df3c46b79f80300b0abbe'
session = requests.Session()
def guid():
guid_list = random.choices('0123456789abcdef', k=16)
return "".join(guid_list)
def hybrid_encrypt(data, rsa_public_key_pem):
"""
:param data: 待加密的数据对象 (dict/list/str等)
:param rsa_public_key_pem: RSA公钥 (PEM格式字符串)
:return: 加密后的结果 w
"""
# 1. 序列化数据
data_str = json.dumps(data, separators=(',', ':'))
logger.debug(f"Serialized data: {data_str}")
# 2. 随机16位长度的十六进制字符串 (作为AES的Key)
guid1 = guid()
# 3. AES-CBC加密
# 注意: pycryptodome 的 key 和 iv 需要 bytes 类型
aes_key = guid1.encode('utf-8')
aes_iv = b"0000000000000000"
cipher_aes = AES.new(aes_key, AES.MODE_CBC, aes_iv)
# AES块大小为16字节,自动使用 PKCS7 填充 (与 PKCS5 兼容)
padded_data = pad(data_str.encode('utf-8'), AES.block_size)
part1 = cipher_aes.encrypt(padded_data)
# 4. RSA-PKCS1_v1_5 加密 guid
# 加载公钥
rsa_key = RSA.import_key(rsa_public_key_pem)
cipher_rsa = PKCS1_v1_5.new(rsa_key)
# 加密 guid 字符串
part2 = cipher_rsa.encrypt(guid1.encode('utf-8'))
# 5. 拼接 part1 和 part2
w = part1 + part2
return w.hex()
def parse_jsonp(response_text, callback):
resp = re.match(fr"{callback}\((.*)\)", response_text)
if resp:
json_data = json.loads(resp.group(1))
return json_data
return None
def load_captcha_data():
timestamp = int(time.time() * 1000)
callback = f'geetest_{timestamp}'
challenge = str(uuid.uuid4())
params = {
'callback': callback,
# 应该是分配到该网站服务的固定值
'captcha_id': captcha_id,
'challenge': challenge,
'client_type': 'web',
'risk_type': 'slide',
'lang': 'eng',
# 上一次verify返回的payload,可选。
# 'payload': 'AgFD8gWUUuHFx-=',
# 'process_token': '63e8f7e521723feb5148cc5dd4c17623923803458fde637e54da01290a55833c',
# 'payload_protocol': '1',
}
response = session.get('https://gcaptcha4.geetest.com/load', params=params, headers=headers)
# 解析Set-Cookie
json_data = parse_jsonp(response.text, callback)
# print(json_data)
if json_data and json_data['status'] == 'success':
data = json_data['data']
source_str = json.dumps(data, indent=2)
logger.debug('请求资源: \n{}', source_str)
return data
raise Exception(f'failed: {response.text}')
def verify(options, w):
timestamp = int(time.time() * 1000)
callback = f'geetest_{timestamp}'
params = {
'callback': callback,
'captcha_id': captcha_id,
'client_type': 'web',
'lot_number': options['lot_number'],
'risk_type': 'slide',
'payload': options['payload'],
'process_token': options['process_token'],
'payload_protocol': '1',
'pt': '1',
'w': w,
}
logger.debug("verify params: \n{}", json.dumps(params, indent=2))
logger.debug("cookies: {}", session.cookies)
response = session.get('https://gcaptcha4.geetest.com/verify', params=params, headers=headers)
# logger.debug('code: {}, response: {}', response.status_code, response.text)
json_data = parse_jsonp(response.text, callback)
return json_data
def solve_pow(version, bits, hashfunc, datetime, captcha_id, lot_number):
prefix = f"{version}|{bits}|{hashfunc}|{datetime}|{captcha_id}|{lot_number}||"
fn = {'md5': hashlib.md5, 'sha1': hashlib.sha1, 'sha256': hashlib.sha256}[hashfunc]
zeros, rem = divmod(bits, 4)
thresh = {1: 7, 2: 3, 3: 1}.get(rem)
target = '0' * zeros
while True:
nonce = secrets.token_hex(8)
msg = prefix + nonce
sign = fn(msg.encode()).hexdigest()
if sign.startswith(target):
if rem == 0 or int(sign[zeros], 16) <= thresh:
return msg, sign
def sign_w(slide, options):
lot_number = options['lot_number']
pow_detail = options['pow_detail']
# pow_msg = f"{pow_detail['version']}|{pow_detail['bits']}|{pow_detail['hashfunc']}|{pow_detail['datetime']}|{captcha_id}|{lot_number}||{guid1}"
# pow_sign = hashlib.sha256(pow_msg.encode()).hexdigest()
pow_msg, pow_sign = solve_pow(pow_detail['version'], pow_detail['bits'], pow_detail['hashfunc'], pow_detail['datetime'], captcha_id, lot_number)
key = lot_number[1:5]
value = lot_number[24:28]
body = {
**slide,
"device_id": "",
"lot_number": lot_number,
"pow_msg": pow_msg,
"pow_sign": pow_sign,
"geetest": "captcha",
"lang": "zh",
"ep": "123",
"biht": "1426265548",
"gee_guard": {
"roe": {
"aup": "3",
"sep": "3",
"egp": "3",
"auh": "3",
"rew": "3",
"snh": "3",
"res": "3",
"cdc": "3"
}
},
"YYhg": "BjI0",
key: value,
"em": {
"ph": 0,
"cp": 0,
"ek": "11",
"wd": 1,
"nt": 0,
"si": 0,
"sc": 0
}
}
logger.debug("body: \n{}", json.dumps(body, indent=2))
rsa_public_key_pem = """
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDB45NNFhRGWzMFPn9I7k7IexS5
XviJR3E9Je7L/350x5d9AtwdlFH3ndXRwQwprLaptNb7fQoCebZxnhdyVl8Jr2J3
FZGSIa75GJnK4IwNaG10iyCjYDviMYymvCtZcGWSqSGdC/Bcn2UCOiHSMwgHJSrg
Bm1Zzu+l8nSOqAurgQIDAQAB
-----END PUBLIC KEY-----
""".strip()
# pkcs8_pem = convert_pkcs1_to_pkcs8(rsa_public_key_pem)
# test_rsa_key = RSA.generate(2048)
# test_public_key_pem = test_rsa_key.publickey().export_key().decode('utf-8')
# 使用模拟的公钥:会出现下面报错
# {'status': 'error', 'code': '-50002', 'msg': 'param decrypt error', 'desc': {'type': 'defined error'}}
return hybrid_encrypt(body, rsa_public_key_pem)
def recognize(bg_path) -> int:
# 默认的模型只能识别人和车,要识别其他物体,需要自行训练
model = YOLO("GeeTestSlide/slidecode.pt")
url = f'https://static.geetest.com/{bg_path}'
# 提供URL时会自动缓存在当前目录
results = model(url) # run inference
# Access the results
for result in results:
xywh = result.boxes.xywh # center-x, center-y, width, height
xywhn = result.boxes.xywhn # normalized
xyxy = result.boxes.xyxy # top-left-x, top-left-y, bottom-right-x, bottom-right-y
xyxyn = result.boxes.xyxyn # normalized
names = [result.names[cls.item()] for cls in result.boxes.cls.int()] # class name of each box
confs = result.boxes.conf # confidence score of each box
logger.debug(f'xywh: {xywh}, xywhn: {xywhn}, xyxy: {xyxy}, xyxyn: {xyxyn}, names: {names}, confs: {confs}')
if len(names) == 0:
return 0
wh = xywh[0, 0].item()
xy = xyxy[0, 0].item()
return wh
return 0
def main():
# 某种转换比例
rate = 1.0059466666666665
options = {}
yolo_left = 0
for _ in range(3):
options = load_captcha_data()
yolo_left = recognize(options['bg'])
if yolo_left != 0:
break
if yolo_left == 0:
logger.error('failed to recognize')
return
# 计算set_left 减去滑块尺寸一半距离
set_left = math.floor((yolo_left - 40)/rate)
# logger.info(f'set_left: {set_left}, set_left1: {set_left1}')
# 耗时ms
passtime = random.randint(500, 2500)
# load 和 verify 之间的callback时间戳差值应该大于耗时passtime
time.sleep(passtime / 1000)
userresponse = set_left/rate +2
slide = {
'setLeft': set_left,
'passtime': passtime,
'userresponse': userresponse,
}
logger.info('slide: {}', slide)
w = sign_w(slide, options)
logger.info('w: {}', w)
result = verify(options, w)
logger.info('result: \n{}', json.dumps(result, indent=2))
fresult = result.get('data').get('result')
logger.log("SUCCESS" if fresult == "success" else "ERROR", 'fresult: {}', fresult)
# {'status': 'success', 'data': {'lot_number': 'ba36e8ac18e743feb5ffa433b0a71157', 'result': 'forbidden', 'fail_count': 0,
# {'status': 'success', 'data': {'lot_number': 'c3b146a5c6084431b31da61713b44899', 'result': 'fail', 'fail_count': 1,
if __name__ == '__main__':
main()

自动化

使用DrissionPage,可以直接绕过环境检测。且无需模拟人类轨迹也可以通过,但是普遍通过的score分数较低,只有一分。
import json
import math
import re
import time
from DrissionPage import Chromium
from loguru import logger
from ultralytics import YOLO
def recognize(bg_path) -> int:
# 默认的模型只能识别人和车,要识别其他物体,需要自行训练
model = YOLO("GeeTestSlide/slidecode.pt")
url = f"https://static.geetest.com/{bg_path}"
# 提供URL时会自动缓存在当前目录
results = model(url)
# Access the results
for result in results:
# 没识别出缺口 => IndexError: index 0 is out of bounds for dimension 0 with size 0
return result.boxes.xywh[0, 0].item()
raise ValueError("No results found")
def parse_jsonp(body):
resp = re.match(r"geetest_\d+\((.*)\)", body)
if resp:
return json.loads(resp.group(1))
raise ValueError(f"Invalid JSONP body: {body}")
def main():
# 启动或接管浏览器,并获取标签页对象
browser = Chromium()
tab = browser.latest_tab
# 'static.geetest.com/captcha_v4/'
tab.listen.start(
"gcaptcha4.geetest.com", method="GET"
) # 开始监听,指定获取包含该文本的数据包
tab.get("https://nopecha.com/captcha/geetest?nocache#slide")
tab.ele(".:geetest_btn_click").click()
arrow_selector = ".:geetest_arrow"
tab.wait.eles_loaded(arrow_selector, timeout=10)
res = tab.listen.wait(count=1, timeout=10)
logger.debug("body: {}", res.response.body)
json_data = parse_jsonp(res.response.body)
bg_path = json_data["data"]["bg"]
yolo_left = recognize(bg_path)
rate = 1.0059466666666665
set_left = math.floor((yolo_left - 40) / rate)
logger.debug("yolo_left: {}, set_left: {}", yolo_left, set_left)
# 动作链:按住箭头,向右移动set_left距离,松开箭头
tab.actions.hold(arrow_selector).move(set_left, 0).release(arrow_selector)
res = tab.listen.wait(count=1, timeout=10)
json_data = parse_jsonp(res.response.body)
logger.info("body:{}", json.dumps(json_data, indent=2))
time.sleep(5)
browser.quit()
if __name__ == "__main__":
main()

使用贝塞尔曲线,分数会提高一些。

def bezier_move(actions, offset_x: int, offset_y: int,
duration: float = 1.0, steps: int = 50):
"""
使用三阶贝塞尔曲线模拟人类鼠标移动
Args:
actions: DrissionPage 的 actions 对象
offset_x: x 轴总偏移量(向右为正)
offset_y: y 轴总偏移量(向下为正)
duration: 总移动时长(秒)
steps: 曲线分割步数,越大越平滑
"""
# ── 1. 生成随机控制点(模拟手部抖动)──────────────────────────
def get_control_points(ex, ey):
dist = math.hypot(ex, ey) or 1.0
offset_scale = random.uniform(0.2, 0.5)
t1 = random.uniform(0.25, 0.40)
cp1_x = ex * t1 + random.uniform(-dist * offset_scale, dist * offset_scale)
cp1_y = ey * t1 + random.uniform(-dist * offset_scale, dist * offset_scale)
t2 = random.uniform(0.60, 0.75)
cp2_x = ex * t2 + random.uniform(-dist * offset_scale, dist * offset_scale)
cp2_y = ey * t2 + random.uniform(-dist * offset_scale, dist * offset_scale)
return (cp1_x, cp1_y), (cp2_x, cp2_y)
# ── 2. 三阶贝塞尔曲线插值 ─────────────────────────────────────
def cubic_bezier(t, p0, p1, p2, p3):
u = 1 - t
x = u**3*p0[0] + 3*u**2*t*p1[0] + 3*u*t**2*p2[0] + t**3*p3[0]
y = u**3*p0[1] + 3*u**2*t*p1[1] + 3*u*t**2*p2[1] + t**3*p3[1]
return x, y
# ── 3. 非匀速时间分布(模拟加速-减速节奏)────────────────────
def ease_in_out(t):
return t * t * (3 - 2 * t)
# ── 4. 生成完整轨迹点 ─────────────────────────────────────────
p0 = (0.0, 0.0)
p3 = (float(offset_x), float(offset_y))
p1, p2 = get_control_points(*p3)
track = []
for i in range(1, steps + 1):
t_eased = ease_in_out(i / steps)
track.append(cubic_bezier(t_eased, p0, p1, p2, p3))
# ── 5. 将轨迹点转为相对偏移量并执行移动 ──────────────────────
step_duration = duration / steps
# ✅ 修复1:用「浮点数累计已移动量」来计算每步真实整数位移
actual_moved_x = 0
actual_moved_y = 0
for idx, (cur_x, cur_y) in enumerate(track):
is_last_step = (idx == len(track) - 1)
if is_last_step:
# 修复2:最后一步强制补齐,确保总位移精确等于目标值
dx = offset_x - actual_moved_x
dy = offset_y - actual_moved_y
else:
# 修复3:抖动只影响「视觉轨迹」,不影响累计计数
jitter_x = random.uniform(-0.8, 0.8)
jitter_y = random.uniform(-0.8, 0.8)
# 用浮点累计目标位移,round时误差留到下一步自然补偿
target_x = int(round(cur_x + jitter_x))
target_y = int(round(cur_y + jitter_y))
dx = target_x - actual_moved_x
dy = target_y - actual_moved_y
actual_moved_x = target_x
actual_moved_y = target_y
if is_last_step:
actual_moved_x += dx
actual_moved_y += dy
actions.move(dx, dy, duration=step_duration)
return actions

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