【三万字记录】AI攻克极验证4代滑块并交付运行实录

介绍地址：https://xjbedu.site/token注册地址：https://xjbtoken.site/register淘宝搜索【小肩膀网络科技】购买AI Token欢迎重度claude code opus 4.6 thinking用户来体验尝鲜。可加下方群聊

用户浏览器    │    ├─── [1] GET /load ──────────────────► gcaptcha4.geetest.com    │    参数: captcha_id, challenge,       │    │          client_type, risk_type, lang │    │    ◄─────────── JSONP 响应 ──────────┘    │    返回: lot_number, payload, process_token,    │          pt, bg(背景图路径), slice(滑块图路径),    │          ypos, pow_detail, 公钥等    │    ├─── [2] GET 背景图 ─────────────────► static.geetest.com    │    ◄─────────── PNG 图片 ────────────┘    │    ├─── [3] GET 滑块碎片图 ─────────────► static.geetest.com    │    ◄─────────── PNG 图片 ────────────┘    │    │   [本地处理]    │    ├── 识别缺口位置 (OCR/图像处理)    │    ├── 计算缩放比与滑动距离    │    ├── 生成拟人化轨迹    │    ├── 计算 PoW 工作量证明    │    ├── 构建 payload JSON    │    └── 加密生成 w 参数    │    └─── [4] GET /verify ────────────────► gcaptcha4.geetest.com         参数: captcha_id, challenge,       │               lot_number, w, payload,      │               process_token, pt 等         │         ◄─────────── JSONP 响应 ──────────┘         返回: result="success"/"fail",               pass_token, gen_time 等

// 源码行 2132: JSONP 请求发起// (0, _v1912.jsonp)(_v2177, "verify", u, _v2170).$_JAN(function (_v2189) {//     var _v2194 = _v2179.resultAdapt(_v2189);//     ...// });//// 通信流程：// 1. 生成唯一回调函数名: geetest_1776962556467// 2. 在 window 上注册该回调// 3. 创建 <script src="https://gcaptcha4.geetest.com/verify?callback=geetest_xxx&...">// 4. 服务端返回的JS: geetest_xxx({status:"success", data:{...}})// 5. 浏览器执行脚本，自动触发回调函数

def parse_jsonp(text):    """    解析 JSONP 响应，提取内部 JSON 对象    JSONP 格式: geetest_1776962556467({"status":"success","data":{...}})    需要去掉外层的函数调用包装，提取括号内的 JSON    """    match = re.search(r'\((\{.*\})\)', text, re.DOTALL)  # 匹配最外层括号内的JSON    if match:        return json.loads(match.group(1))    return json.loads(text)  # 如果不是JSONP格式，尝试直接解析为纯JSON

geetest_ctf/├── geetest_solver.py      # Python 主控脚本：编排整个8步验证流程├── trajectory.py           # 拟人化轨迹生成器：三段式加速模型 + 回弹├── pow_solver.py           # PoW 工作量证明计算：暴力搜索 nonce├── gap_detector.py         # 图片缺口识别：调用 OCR 平台 API└── node_env/    ├── package.json        # Node.js 依赖配置    └── generate_w.js       # 加密参数 w 的生成                            # 包含：轨迹差分编码、Base64、AES-128-CBC、                            # RSA-1024 PKCS#1v1.5、SM4-CBC、SM2

| 参数名 | 含义 | 来源 | 示例值 ||--------|------|------|--------|| `captcha_id` | 验证码实例ID（每个网站唯一） | 页面嵌入的JS | `24f56dc13c40dc4a02fd0318567caef5` || `challenge` | 本次挑战的唯一令牌 | 客户端用 guid() 生成 | `a3b1c2d4e5f67890` (16位hex) || `lot_number` | 服务端批次号 | load 响应 | `72ce10e53aea4ac6b0b3217285a2a503` || `pt` | 加密方式指示 | load 响应 | `"0"`=Base64, `"1"`=RSA+AES, `"2"`=SM2+SM4 || `payload` | 服务端加密过的会话数据 | load 响应 | 不透明字符串，原样回传 || `process_token` | 会话令牌 | load 响应 | 不透明字符串，原样回传 || `setLeft` | 滑块滑动的像素距离（显示坐标） | 客户端计算 | `128` || `passtime` | 操作总耗时(ms) | 轨迹末尾时间戳 | `1507` || `userresponse` | 原图坐标系的位移+偏移 | `setLeft/scale+2` | `129.24` || `aa` | 轨迹编码字符串 | 差分压缩+自定义编码 | `s!!tuv0!!(/1,` || `w` | 加密后的完整验证数据 | AES加密payload+RSA加密密钥 | 1280字符的hex串 || `pow_msg` | PoW 消息串 | 客户端暴力计算 | `1\|0\|md5\|2026...\|lot...\|cap...\|nonce\|nonce` || `pow_sign` | PoW 哈希签名 | 客户端计算 | md5 hex digest |

// guid() 函数：生成16位随机hex密钥// 内部函数 e() 生成4位hex（取 65536 范围内随机数的十六进制后4位）// 调用4次 e() 拼接成 16 位var p = function () {    function e() {        return (65536 * (1 + Math.random()) | 0)  // 生成 65536~131071 的整数            .toString(16)                           // 转十六进制（如"1a3f5"，5位）            .substring(1);                          // 去掉首位"1"，剩余4位hex    }    return function () {        return e() + e() + e() + e();               // 4×4 = 16位hex    };}();_v80.guid = p;

def guid_python():    """    生成16位随机hex字符串，与JS中的guid()逻辑一致    每次调用内部函数e()生成4位hex，调用4次拼接    """    def e():        # 模拟 JS 的 (65536 * (1 + Math.random()) | 0).toString(16).substring(1)        return format((int(65536 * (1 + random.random())) | 0), 'x')[-4:]    return e() + e() + e() + e()

GET https://gcaptcha4.geetest.com/load    ?callback=geetest_1776962556467     # JSONP回调函数名    &captcha_id=24f56dc13c40dc4a02fd0318567caef5    &challenge=a3b1c2d4e5f67890         # 客户端生成的16位hex    &client_type=web                    # 客户端类型    &risk_type=slide                    # 验证码类型：滑块    &lang=zh                            # 语言

def call_load(session, captcha_id, challenge):    """    调用极验 load 接口，获取验证码配置    返回 JSONP 格式的响应，解析后得到 lot_number、图片路径、PoW参数等    """    callback = generate_callback()        # 生成 geetest_{timestamp} 格式的回调名    params = {        'callback': callback,             # JSONP 回调函数名        'captcha_id': captcha_id,         # 验证码实例ID        'challenge': challenge,           # 本次挑战令牌        'client_type': 'web',             # 客户端类型        'risk_type': 'slide',             # 风险类型：滑块        'lang': 'zh',                     # 语言：中文    }    resp = session.get(        f"https://{API_SERVER}/load",        params=params,        headers=HEADERS,        timeout=15    )    return parse_jsonp(resp.text)          # 解析 JSONP 包装，返回纯 JSON 对象

{  "status": "success",  "data": {    "lot_number": "72ce10e53aea4ac6b0b3217285a2a503",  // 批次号，后续所有请求都要带上    "payload": "eyJ...(base64加密的服务端数据)...",       // 不透明数据，原样回传给verify    "process_token": "d3a1b2c3...",                     // 会话令牌，原样回传    "pt": "1",                                          // 加密方式: "1" = RSA+AES    "payload_protocol": 1,                              // payload协议版本    "captcha_type": "slide",                            // 验证码类型    "bg": "pictures/gt/..../bg.png",                    // 背景图路径（含缺口）    "slice": "pictures/gt/..../slice.png",              // 滑块碎片图路径    "ypos": 78,                                         // 滑块碎片的Y坐标    "guard": true,                                      // 是否启用 geeGuard 指纹    "check_device": false,                              // 是否检查设备指纹    "pow_detail": {                                     // PoW 工作量证明参数      "version": "1",                                   // PoW 版本      "bits": 0,                                        // 难度位数（0=不需要PoW）      "hashfunc": "md5",                                // 哈希算法      "datetime": "2026-04-28T12:00:00+08:00",         // 服务端时间戳      "nonce": ""                                       // nonce前缀（通常为空）    }  }}

# 从 load 响应中提取所有需要的参数data = load_resp['data']lot_number = data['lot_number']             # 批次号payload = data['payload']                   # 不透明数据，原样回传process_token = data['process_token']       # 会话令牌pt = str(data.get('pt', '1'))              # 加密方式payload_protocol = data.get('payload_protocol', 1)pow_detail = data.get('pow_detail', {})     # PoW 参数bg_path = data.get('bg', '')               # 背景图相对路径slice_path = data.get('slice', '')         # 滑块图相对路径ypos = data.get('ypos', 0)                 # 滑块Y坐标（本实现未使用）

def get_image_size(png_data):    """    从 PNG 文件的二进制数据中提取图片尺寸    PNG 文件格式：      - 字节 0-7: PNG 签名 (89 50 4E 47 ...)      - 字节 8-15: IHDR chunk length + type      - 字节 16-19: 宽度（大端序 uint32）      - 字节 20-23: 高度（大端序 uint32）    """    if png_data[:4] == b'\x89PNG':                       # 检查 PNG 魔数        w = struct.unpack('>I', png_data[16:20])[0]      # 大端序读取宽度        h = struct.unpack('>I', png_data[20:24])[0]      # 大端序读取高度        return w, h    return 300, 200  # 非PNG格式的备用默认值# === 下载图片 ===bg_url = f"{STATIC_SERVER}/{bg_path}"           # 拼接完整的背景图URLbg_resp = session.get(bg_url, timeout=15)       # 下载背景图bg_w, bg_h = get_image_size(bg_resp.content)    # 提取原始尺寸，如 344x212if slice_path:    slice_url = f"{STATIC_SERVER}/{slice_path}" # 拼接滑块碎片图URL    slice_resp = session.get(slice_url, timeout=15)    sl_w, sl_h = get_image_size(slice_resp.content)

import base64import jsonimport requestsdef detect_gap(image_path=None, image_bytes=None, question_type='框出正确位置'):    """    识别滑块验证码背景图中的缺口位置    :param image_path:     图片文件路径（与 image_bytes 二选一）    :param image_bytes:    图片二进制数据    :param question_type:  识别问题类型，告诉OCR模型要找什么    :return:               缺口左边缘的X坐标（像素，原图坐标系）    """    if image_bytes is None:        if image_path is None:            raise ValueError("必须提供 image_path 或 image_bytes")        with open(image_path, 'rb') as f:            image_bytes = f.read()    # 构建 OCR 平台请求    payload = {        'base64Image': base64.b64encode(image_bytes).decode('utf-8'),  # 图片转base64        'modelName': '普通模型',     # 使用的识别模型        'keyCode': 'vRkfuMQl',      # API 鉴权密钥        'question': question_type,   # 识别任务描述        'system': ''    }    # 调用 OCR API    response = requests.post(        'http://gpu1.xinyuocr.xyz:8889/api/qrcode/predict',        json=payload,        timeout=30    )    result = response.json()    if result.get('err'):        raise RuntimeError(f"OCR识别错误: {result['err']}")    # 解析响应：提取缺口区域的左上角X坐标    # 返回格式示例：    #   result['msg'] = '[{"label":"1","box":[[223.0,115.0,296.0,187.0]]}]'    # 其中 box 是 [[x1,y1,x2,y2]]，(x1,y1)=左上角，(x2,y2)=右下角    json_obj = json.loads(result['msg'])    gap_x = json_obj[0]['box'][0][0]       # 取第一个检测结果的左边缘X坐标    return gap_x                            # 返回值是原图坐标系中的像素值

// 行 7083: 获取容器宽度（通常为 340px）_v7624 = parseInt(_v7627.width || _v7627.nextWidth || this.$_BGC_, 10);// 行 7084: 如果使用 rem 适配，计算实际显示宽度上限var o = _v7627.rem ? 340 * _v7627.rem : 340;o < _v7624 && (_v7624 = o);        // 如果容器比 340*rem 还大，则限制为 340*rem// 行 7086: ★★★ 核心缩放公式 ★★★var a = this.$_BHEH = .8876 * _v7624 / _v7628.wrap_w;// 含义：//   _v7624     = 容器显示宽度（通常 340px）//   _v7628.wrap_w = 背景图原始宽度（通常 344px）//   0.8876     = 极验的固定缩放系数（可能是因为图片实际显示区域占容器的88.76%）//   a ($BHEH)  = 最终缩放比，后续所有坐标转换都用它

// setImgs 函数中：wrap_w 从背景图的原始宽度获取// _v7688[0].$_CFy.width 就是 <img> 元素的 naturalWidth// 也就是背景图的原始像素宽度（如 344）

CONTAINER_WIDTH = 340                          # 极验验证码容器的固定宽度（像素）# 计算缩放比：与 JS 源码行 7086 完全对应# scale = 0.8876 * 容器宽度 / 原图宽度scale = 0.8876 * CONTAINER_WIDTH / bg_w        # 例: 0.8876 * 340 / 344 = 0.877488...

背景图（原图坐标系）：┌─────────────────────────────────────────────┐│                    ┌──┐                      ││                    │缺│← gap_x = 143px       ││                    │口│                      ││                    └──┘                      │├─────────────────────────────────────────────┤│ ┌──┐                                        ││ │滑│← 初始位置约 15px                        ││ │块│                                        ││ └──┘                                        ││ ◄── 实际滑动距离 = 143 - 15 = 128px ──────► │└─────────────────────────────────────────────┘

SLIDER_OFFSET = 15                             # 滑块初始偏移量（像素，原图坐标系）# 完整的坐标换算流程gap_x = detect_gap(image_bytes=bg_resp.content)               # OCR识别缺口X(原图)，如143adjusted_gap_x = gap_x - SLIDER_OFFSET                        # 减去滑块偏移，如128slide_distance = adjusted_gap_x * scale                        # 转为显示坐标系，如128.76setLeft = int(slide_distance)                                  # 取整，如128userresponse = setLeft / scale + 2                             # 转回原图坐标+2，如129.24

// mouseup 事件处理函数 $_BGIM:// _v7662 = 鼠标释放时的X偏移像素（显示坐标系）var _v7665 = parseInt(_v7662, 10);     // setLeft: 取整的显示坐标位移var _v7666 = {    setLeft: _v7665,                     // 显示坐标系的滑动像素数（整数）    passtime: _v7663,                    // 从mousedown到mouseup的总耗时（毫秒）    userresponse: _v7665 / _v7659.$_BHEH + 2    //             ↑                ↑       ↑    //           setLeft          scale   固定偏移+2    // 含义：把显示坐标转回原图坐标系，再加上2    // 为什么+2？可能是服务端验证时的容差补偿};

Step 1: 计算缩放比    scale = 0.8876 × 340 / 344 = 0.877488Step 2: 减去滑块偏移    adjusted_gap_x = 143 - 15 = 128Step 3: 转为显示坐标    slide_distance = 128 × 0.877488 = 112.32    setLeft = int(112.32) = 112Step 4: 计算 userresponse    userresponse = 112 / 0.877488 + 2 = 129.66Step 5: 轨迹目标距离    轨迹生成的目标距离 = int(slide_distance) = 112 像素（显示坐标系）

// ===== mousedown 事件 (行 7097-7110) =====// 函数名：$_BGFT$_BGFT: function (_v7634) {    var _v7639 = this;    _v7639.$_BGAW = (0, _v7504.now)();   // 记录起始时间戳    // 获取背景图和按钮的位置信息    var _v7644 = _v7640(".bg_" + _v7641).$_EAh();     // 背景图的 getBoundingClientRect    var _v7645 = _v7640(".btn_" + _v7641).$_EAh();    // 按钮的 getBoundingClientRect    // ★ 创建轨迹记录器，初始点为 [负偏移X, 负偏移Y, 0]    // 这个初始点表示：鼠标按下位置相对于滑块按钮的偏移（原图坐标系）    _v7639.$_BHJf = new _v7505.default([        Math.round((_v7643 - _v7639.$_BHGl) / _v7639.$_BHEH),   // (btnLeft - mouseX) / scale        Math.round((_v7642 - _v7639.$_BHIt) / _v7639.$_BHEH),   // (btnTop - mouseY) / scale        0                                                         // 时间=0（起始点）    ])    .$_JEJ([0, 0, 0]);    // ★ 紧接着追加一个 [0,0,0] 作为原点标记    // 初始偏移点通常是负数，如 [-25, 3, 0]    // 代表鼠标按下时的位置在按钮左上角更偏左偏下的位置},// ===== mousemove 事件 (行 7112-7118) =====// 函数名：$_BGHI$_BGHI: function (_v7646) {    var _v7652 = _v7646.$_CGf() - _v7651.$_BHGl;   // 当前X - 起始X = X位移    _v7651.$_BHJf.$_JEJ([        Math.round(_v7652 / _v7651.$_BHEH),           // X位移 / scale → 原图坐标        Math.round(_v7653 / _v7651.$_BHEH),           // Y位移 / scale → 原图坐标        (0, _v7504.now)() - _v7651.$_BGAW             // 相对于mousedown的时间差(ms)    ]);},// ===== mouseup 事件 (行 7120-7136) =====// 函数名：$_BGIM$_BGIM: function (_v7654) {    // 追加最后一个轨迹点    _v7659.$_BHJf.$_JEJ([        Math.round(_v7662 / _v7659.$_BHEH),           // 最终X位移 / scale        Math.round(_v7664 / _v7659.$_BHEH),           // 最终Y位移 / scale        _v7659.passtime                                 // 总耗时    ]);    // 构建验证参数    var _v7665 = parseInt(_v7662, 10);                  // setLeft = 显示坐标取整    var _v7666 = {        setLeft: _v7665,        passtime: _v7663,        userresponse: _v7665 / _v7659.$_BHEH + 2       // 原图坐标 + 2    };}

[  [-25, 3, 0],         ← 初始偏移点：鼠标按下位置相对于按钮的偏移（原图坐标）  [0, 0, 0],           ← 原点标记  [5, 0, 32],          ← 第1个移动点: X移动5px, Y不动, 经过32ms  [12, 1, 48],         ← 第2个移动点  [25, -1, 65],        ← ...  ...  [128, 2, 1450],      ← 最终位置（原图坐标）  [128, 2, 1507],      ← mouseup 时的最终确认点]

import randomimport mathdef generate_trajectory(distance, scale=1.0):    """    生成拟人化的滑块轨迹    模拟真实人手的运动特征：    1. 三段式速度模型：加速→匀速→减速    2. 过冲与回弹：滑过目标后回退（手指惯性）    3. Y轴随机抖动：真人的手不可能完全水平滑动    4. 不均匀时间间隔：每一步的时间间隔随机波动    :param distance: 需要滑动的像素距离（显示坐标系）    :param scale:    缩放比（未使用，保留参数）    :return:         list of [x, y, timestamp]，绝对坐标轨迹    """    if distance <= 0:        return [[0, 0, 0]]    tracks = []    current_x = 0.0    current_y = 0.0    current_t = 0    # === 过冲设计 ===    # 真人操作时，手指惯性会导致滑过目标2~5像素，然后回退    overshoot = random.uniform(2, 5)    target = distance + overshoot              # 实际要滑到的位置（含过冲）    # === 三段式速度模型的分界点 ===    phase1_end = target * 0.4                  # 加速段：0% ~ 40%    phase2_end = target * 0.7                  # 匀速段：40% ~ 70%    # 减速段：70% ~ 100%    tracks.append([0, 0, 0])                    # 起始点    while current_x < target:        remaining = target - current_x        if current_x < phase1_end:            # === 加速段（0~40%）===            # 速度从慢到快，模拟手指从静止开始加速            progress = current_x / phase1_end if phase1_end > 0 else 1            base_step = 1 + progress * 4        # 步长从1逐渐增大到5        elif current_x < phase2_end:            # === 匀速段（40%~70%）===            # 保持中等速度            base_step = random.uniform(3, 6)    # 随机步长3~6        else:            # === 减速段（70%~100%）===            # 速度逐渐降低，模拟手指精确定位            progress = (current_x - phase2_end) / (target - phase2_end) \                       if (target - phase2_end) > 0 else 1            base_step = max(0.5, 4 * (1 - progress))   # 步长从4逐渐减小到0.5        # 添加微小随机扰动，避免步长完全规律        step_x = base_step + random.uniform(-0.5, 0.5)        step_x = min(step_x, remaining)         # 不超过剩余距离        step_x = max(0.3, step_x)               # 最小步长0.3，避免原地不动        # === Y轴抖动 ===        # 真人的手不可能完全水平移动，每步有±2px的上下抖动        step_y = random.uniform(-2, 2)        current_y += step_y        current_y = max(-5, min(5, current_y))   # 限制Y轴偏移在±5px以内        current_x += step_x        # === 不均匀的时间间隔 ===        # 加速段：间隔较长（手指刚开始动，反应时间）        # 匀速段：间隔较短（手指快速滑动）        # 减速段：间隔较长（手指精确微调）        if current_x < phase1_end:            dt = random.randint(12, 25)          # 加速段: 12~25ms        elif current_x < phase2_end:            dt = random.randint(8, 18)           # 匀速段: 8~18ms        else:            dt = random.randint(15, 35)          # 减速段: 15~35ms        current_t += dt        tracks.append([round(current_x), round(current_y), current_t])    # === 回弹模拟 ===    # 滑过目标后，手指会回退2~4次    for i in range(random.randint(2, 4)):        current_x -= random.uniform(0.5, 2)      # 每次回退0.5~2px        current_y += random.uniform(-1, 1)        current_t += random.randint(20, 40)        tracks.append([round(current_x), round(current_y), current_t])    # === 精确定位 ===    # 最终确保停在精确的目标位置    current_t += random.randint(30, 60)    tracks.append([round(distance), round(current_y), current_t])    # === 松手前的短暂停顿 ===    # 真人在松手前会有一个微小的停顿（确认位置正确）    current_t += random.randint(50, 150)    tracks.append([round(distance), round(current_y), current_t])    return tracksdef get_passtime(tracks):    """从轨迹中提取总耗时（最后一个点的时间戳）"""    return tracks[-1][2] if tracks else 0

# 生成显示坐标系的轨迹track_display = generate_trajectory(int(slide_distance))   # 参数是显示坐标的距离passtime = get_passtime(track_display)                     # 总耗时(ms)# 转换为原图坐标系（除以 scale）# 与 JS 源码行 7118 中 Math.round(_v7652 / _v7651.$_BHEH) 对应track = [[round(p[0] / scale), round(p[1] / scale), p[2]] for p in track_display]# 插入初始偏移点（模拟鼠标按下位置的随机偏移）# 与 JS 源码行 7107 中的初始点对应initial_offset = [random.randint(-30, -10), random.randint(-10, 10), 0]track.insert(0, initial_offset)# 最终轨迹格式: [[-25, 3, 0], [0, 0, 0], [5, 0, 32], [12, 1, 48], ...]

// 差分压缩：把绝对坐标轨迹转为增量 [dx, dy, dt]// 输入: [[0,0,0], [5,0,32], [12,1,48], [25,-1,65], ...]// 输出: [[5,0,32], [7,1,16], [13,-2,17], ...]$_BACB: function (_v1754) {    for (var t, s, n, i = [], r = 0, o = 0, a = _v1754.length - 1; o < a; o += 1)        t = Math.round(_v1754[o + 1][0] - _v1754[o][0]),    // dx = 下一点X - 当前点X        s = Math.round(_v1754[o + 1][1] - _v1754[o][1]),    // dy = 下一点Y - 当前点Y        n = Math.round(_v1754[o + 1][2] - _v1754[o][2]),    // dt = 下一点T - 当前点T        // 过滤掉完全没有变化的点 (dx=0, dy=0, dt=0)        0 === t && 0 === s && 0 === n || (            0 === t && 0 === s            ? r += n                      // 如果只有时间变化，累积到下一个有效点            : (i.push([t, s, n + r]),     // 有位移变化时，输出 [dx, dy, dt+累积时间]               r = 0)                     // 重置累积时间        );    return 0 !== r && i.push([t, s, r]),  // 尾部累积的时间单独输出           i;}

// 差分压缩: 绝对坐标 -> [dx, dy, dt] 增量function trackDiff(trackPoints) {    var i = [], r = 0;                            // i=结果数组, r=累积时间    for (var o = 0, a = trackPoints.length - 1; o < a; o += 1) {        var t = Math.round(trackPoints[o + 1][0] - trackPoints[o][0]);   // dx        var s = Math.round(trackPoints[o + 1][1] - trackPoints[o][1]);   // dy        var n = Math.round(trackPoints[o + 1][2] - trackPoints[o][2]);   // dt        if (!(0 === t && 0 === s && 0 === n)) {   // 过滤完全无变化的点            if (0 === t && 0 === s) {                r += n;                            // 仅时间变化，累积            } else {                i.push([t, s, n + r]);             // 有位移变化，输出并带上累积时间                r = 0;            }        }    }    if (0 !== r) i.push([t, s, r]);                // 尾部累积时间    return i;}

// 方向映射表：9种常见运动方向 → 单字符function i(_v1763) {    var t = [        [1, 0],     // 右移1        → 's'        [2, 0],     // 右移2        → 't'        [1, -1],    // 右移1+下移1  → 'u'        [1, 1],     // 右移1+上移1  → 'v'        [0, 1],     // 上移1        → 'w'        [0, -1],    // 下移1        → 'x'        [3, 0],     // 右移3        → 'y'        [2, -1],    // 右移2+下移1  → 'z'        [2, 1]      // 右移2+上移1  → '~'    ];    var chars = "stuvwxyz~";    for (var s = 0, n = t.length; s < n; s += 1)        if (_v1763[0] === t[s][0] && _v1763[1] === t[s][1])            return chars[s];              // 匹配到预定义方向，返回对应字符    return 0;                             // 不在预定义方向中，返回0表示需要数值编码}

// 编码单个轨迹点的运动方向// 如果运动方向在9种预定义方向中，返回对应的单字符// 否则返回0，需要用数值编码function encodeDirection(point) {    var dirs = [[1, 0], [2, 0], [1, -1], [1, 1], [0, 1],                [0, -1], [3, 0], [2, -1], [2, 1]];    var chars = "stuvwxyz~";    for (var s = 0; s < dirs.length; s++) {        if (point[0] === dirs[s][0] && point[1] === dirs[s][1]) return chars[s];    }    return 0;}

function a(_v1765) {    // 自定义字符集（64个字符）    var t = "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqr",        s = t.length,         // 64        n = "",        i = Math.abs(_v1765), // 取绝对值        r = parseInt(i / s, 10);  // 高位 = 值 / 64    s <= r && (r = s - 1);    // 如果高位超过64，截断为63（最大编码范围 64*64-1 = 4095）    r && (n = t.charAt(r));   // 高位不为0时，输出高位字符    var o = "";    return _v1765 < 0 && (o += "!"),   // 负数前缀 "!"           n && (o += "$"),             // 有高位时前缀 "$"           o + n + t.charAt(i %= s);   // 拼接：[!][$][高位字符][低位字符]}

// 编码单个数值（dx/dy/dt）// 使用自定义64字符集的变长编码function encodeValue(val) {    var charset = "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqr";    var base = charset.length;                     // 64    var n = "";    var i = Math.abs(val);                         // 取绝对值    var r = parseInt(i / base, 10);                // 计算高位    if (base <= r) r = base - 1;                   // 防溢出    if (r) n = charset.charAt(r);                  // 高位字符    var o = "";    if (val < 0) o += "!";                         // 负数标记    if (n) o += "$";                               // 多位标记    return o + n + charset.charAt(i % base);       // 拼接最终编码}

// 差分压缩后，把轨迹编码为三段式字符串$_BADe: function () {    var s = this.$_BACB(this.$_JBb);         // 差分压缩    var n = [], r = [], o = [];               // X部分、Y部分、T部分    forEach(s, function (_v1767) {        var dirChar = i(_v1767);              // 尝试方向编码        if (dirChar) {            r.push(dirChar);                  // 方向编码只影响 Y 部分        } else {            n.push(a(_v1767[0]));            // X部分：编码 dx            r.push(a(_v1767[1]));            // Y部分：编码 dy        }        o.push(a(_v1767[2]));                // T部分：始终编码 dt    });    // ★ 三段用 "!!" 分隔    return n.join("") + "!!" + r.join("") + "!!" + o.join("");}

xDeltas!!yDeltas!!tDeltas例: 0-1$)3!!stuv(!x0!!(/1,0-,+

// 完整的轨迹编码：差分压缩 → 分类编码 → 三段拼接function encodeTrack(trackPoints) {    var diffed = trackDiff(trackPoints);       // Step1: 差分压缩    var xParts = [];                           // X增量编码部分    var yParts = [];                           // Y增量编码部分（含方向字符）    var tParts = [];                           // 时间增量编码部分    for (var idx = 0; idx < diffed.length; idx++) {        var point = diffed[idx];        var dirChar = encodeDirection(point);   // Step2: 尝试方向编码        if (dirChar) {            // 如果匹配预定义方向，Y部分用单字符表示，X部分不输出            yParts.push(dirChar);        } else {            // 否则，X和Y都用数值编码            xParts.push(encodeValue(point[0]));            yParts.push(encodeValue(point[1]));        }        // T部分始终用数值编码        tParts.push(encodeValue(point[2]));    }    // 三段用 "!!" 连接    return xParts.join("") + "!!" + yParts.join("") + "!!" + tParts.join("");}

// PoW 求解函数// 参数含义：//   _v2536 = captcha_id     验证码实例ID//   _v2537 = lot_number     批次号//   _v2538 = hashfunc       哈希算法名("md5"/"sha1"/"sha256")//   _v2539 = version        版本号("1")//   _v2540 = bits           难度位数//   _v2541 = datetime       服务端时间戳//   _v2542 = nonce_prefix   nonce前缀(通常为空)function n(_v2536, _v2537, _v2538, _v2539, _v2540, _v2541, _v2542) {    var a = _v2540 % 4,                              // 余数位（用于非4整除的难度判定）        _ = parseInt(_v2540 / 4, 10),                 // 需要前导零的hex字符数        u = "0".repeat(_),                            // 构建前导零前缀字符串    // ★ 消息格式（注意字段顺序！）：    // "version|bits|hashfunc|datetime|lot_number|captcha_id|nonce_prefix|"        c = _v2539 + "|" + _v2540 + "|" + _v2538 + "|" +            _v2541 + "|" + _v2537 + "|" + _v2536 + "|" + _v2542 + "|";    // 暴力搜索循环    while (1) {        var h = guid(),                               // 生成16位随机hex作为nonce            p = c + h,                                // 消息 = 前缀 + nonce            l = undefined;        // 根据指定的哈希算法计算摘要        switch (_v2538) {            case "md5":                l = new _v2528.default.MD5().hex(p);                break;            case "sha1":                l = new _v2528.default.SHA1().hex(p);                break;            case "sha256":                l = new _v2528.default.SHA256().hex(p);                break;        }        // 难度判定        if (0 == a) {            // bits 是4的整数倍：直接检查前导零            if (0 === l.indexOf(u)) return {                pow_msg: c + h,                       // ★ 返回的pow_msg包含完整消息(含nonce)                pow_sign: l                           // 哈希值            };        } else if (0 === l.indexOf(u)) {            // bits 不是4的整数倍：检查前导零后，还需检查下一个字符            var f = undefined,                d = l[_];                             // 零前缀后的第一个字符            // 根据余数位确定阈值            switch (a) {                case 1: f = 7; break;     // 1位：下一个字符 ≤ '7' (二进制首位为0)                case 2: f = 3; break;     // 2位：下一个字符 ≤ '3' (二进制前两位为0)                case 3: f = 1; break;     // 3位：下一个字符 ≤ '1' (二进制前三位为0)            }            if (d <= f) return {                pow_msg: c + h,                pow_sign: l            };        }    }}

import hashlibimport randomdef generate_guid():    """    生成16位随机hex字符串    与JS中的guid()一致：4次生成4位hex并拼接    """    return ''.join(random.choices('0123456789abcdef', k=16))def solve_pow(pow_config):    """    解决极验的PoW工作量证明    :param pow_config: dict 包含以下字段：        - version:    PoW版本号（通常为"1"）        - bits:       难度位数（0=无难度要求，即任意nonce都满足）        - hashfunc:   哈希算法名（"md5"/"sha1"/"sha256"）        - datetime:   服务端返回的时间戳字符串        - lot_number: 批次号        - captcha_id: 验证码实例ID        - nonce:      nonce前缀（通常为空字符串）    :return: dict {pow_msg: str, pow_sign: str}    消息格式: "version|bits|hashfunc|datetime|lot_number|captcha_id|nonce_prefix|nonce"    """    version = pow_config.get('version', '1')    bits = pow_config.get('bits', 0)    hashfunc = pow_config.get('hashfunc', 'md5')    datetime_str = pow_config.get('datetime', '')    lot_number = pow_config.get('lot_number', '')    captcha_id = pow_config.get('captcha_id', '')    nonce_prefix = pow_config.get('nonce', '')    # === 难度参数计算 ===    full_bits = bits % 4              # 余数位（0~3）    prefix_len = int(bits / 4)        # 需要的前导零hex字符数    prefix = '0' * prefix_len         # 前导零字符串    # === 暴力搜索循环 ===    while True:        nonce = generate_guid()       # 生成随机16位hex nonce        # 构建完整的 PoW 消息        # 格式严格对应 JS 源码行 2462        pow_msg = f"{version}|{bits}|{hashfunc}|{datetime_str}|" \                  f"{lot_number}|{captcha_id}|{nonce_prefix}|{nonce}"        # 计算哈希        if hashfunc == 'md5':            pow_sign = hashlib.md5(pow_msg.encode()).hexdigest()        elif hashfunc == 'sha1':            pow_sign = hashlib.sha1(pow_msg.encode()).hexdigest()        elif hashfunc == 'sha256':            pow_sign = hashlib.sha256(pow_msg.encode()).hexdigest()        else:            pow_sign = hashlib.md5(pow_msg.encode()).hexdigest()        # === 难度判定 ===        if full_bits == 0:            # bits 是4的整数倍（包括 bits=0 的情况）            # bits=0 时 prefix="" ，任何哈希都满足            if pow_sign.startswith(prefix):                return {'pow_msg': pow_msg, 'pow_sign': pow_sign}        else:            # bits 不是4的整数倍            if pow_sign.startswith(prefix):                next_char = pow_sign[prefix_len]      # 前导零后的第一个hex字符                # 阈值映射（与JS源码行 2486-2493 对应）                threshold_map = {1: '7', 2: '3', 3: '1'}                threshold = threshold_map.get(full_bits, 'f')                if next_char <= threshold:             # hex字符比较                    return {'pow_msg': pow_msg, 'pow_sign': pow_sign}

# === 在 geetest_solver.py 中 ===# 从 load 响应中提取 PoW 参数pow_config = {    'version': pow_detail.get('version', '1'),    'bits': pow_detail.get('bits', 0),          # 典型值: 0（无难度要求）    'hashfunc': pow_detail.get('hashfunc', 'md5'),    'datetime': pow_detail.get('datetime', ''),    'lot_number': lot_number,                    # load 响应中的批次号    'captcha_id': captcha_id,                    # 页面配置的验证码ID    'nonce': pow_detail.get('nonce', ''),        # 通常为空}pow_result = solve_pow(pow_config)# pow_result 包含:#   pow_msg:  "1|0|md5|2026-04-28T12:00:00+08:00|72ce...|24f5...||abc123def456"#   pow_sign: "d41d8cd98f00b204e9800998ecf8427e"

// w 参数加密入口函数// _v3885 = payload JSON 字符串（明文）// _v3886.options = 配置对象，包含 pt 等参数functioni(_v3885, _v3886) {    var s = _v3886.options;    // ===== pt="0": 无加密，直接 Base64 URL-safe 编码 =====    if(!s.pt || "0" === s.pt)        return _v3876.default.urlsafe_encode(_v3885);    // 生成16位随机hex密钥    var n = (0, _v3881.guid)();    // 加密方案映射表    var r = {        1: {            symmetrical: _v3877.default,   // AES-128-CBC（对称加密）            asymmetric: new _v3878.default() // RSA-1024（非对称加密）        },        2: {            symmetrical: new _v3879.default({  // SM4-CBC（国密对称加密）                key: n, mode: "cbc", iv: "0000000000000000"            }),            asymmetric: _v3880.default     // SM2（国密非对称加密）        }    };    if("1" === s.pt || "2" === s.pt) {        var o = "1" === s.pt;        var a = s.pt;        // 用非对称算法加密随机密钥        var _ = r[a].asymmetric.encrypt(n);        // 对于 RSA (pt=1)，密文必须是256字符(128字节hex)        // 如果长度不对就重新生成密钥（极少发生）        while(o && (!_ || 256 !== _.length))            n = (0, _v3881.guid)(),            _ = new _v3878.default().encrypt(n);        // 用对称算法加密 payload        var u = r[a].symmetrical.encrypt(_v3885, n);        // ★ 最终格式: arrayToHex(对称密文) + 非对称密文        return(0, _v3881.arrayToHex)(u) + _;    }}

| pt 值 | 对称加密 | 非对称加密 | w 格式 ||-------|---------|-----------|--------|| `"0"` | 无 | 无 | `Base64_urlsafe(payload)` || `"1"` | AES-128-CBC | RSA-1024 | `hex(AES(payload, key))` + `RSA(key)` || `"2"` | SM4-CBC | SM2 | `hex(SM4(payload, key))` + `SM2(key)` |

// 将字节数组转换为十六进制字符串// 输入: [72, 101, 108, 108, 111]// 输出: "48656c6c6f"_v80.arrayToHex = function _v168(_v167) {    // 第一步：将十进制字节值打包到32位整数数组中（每4字节一个int）    for (var t = [], s = 0, n = 0; n < 2 * _v167.length; n += 2)        t[n >>> 3] |= parseInt(_v167[s], 10) << 24 - n % 8 * 4,        s++;    // 第二步：从32位整数中逐字节提取，转为两位hex    for (var i = [], r = 0; r < _v167.length; r++) {        var o = t[r >>> 2] >>> 24 - r % 4 * 8 & 255;   // 提取单字节        i.push((o >>> 4).toString(16));                  // 高4位转hex        i.push((15 & o).toString(16));                   // 低4位转hex    }    return i.join("");};

function arrayToHex(arr) {    var t = [], s = 0;    for (var n = 0; n < 2 * arr.length; n += 2) {        t[n >>> 3] |= parseInt(arr[s], 10) << 24 - n % 8 * 4;        s++;    }    var i = [];    for (var r = 0; r < arr.length; r++) {        var o = t[r >>> 2] >>> 24 - r % 4 * 8 & 255;        i.push((o >>> 4).toString(16));        i.push((15 & o).toString(16));    }    return i.join("");}

// 标准 Base64 字符集var CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";// URL-safe Base64 字符集（将 +/ 替换为 -_）var URLSAFE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

var Base64 = (function() {    var CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";    var URLSAFE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";    // 字符串转 UTF-8 字节数组    function strToBytes(str) {        var bytes = [];        for (var i = 0; i < str.length; i++) {            var code = str.charCodeAt(i);            if (code < 128) {                bytes.push(code);                          // ASCII: 单字节            } else if (code < 2048) {                bytes.push(192 | code >> 6);               // 2字节 UTF-8                bytes.push(128 | 63 & code);            } else {                bytes.push(224 | code >> 12);              // 3字节 UTF-8                bytes.push(128 | (code >> 6 & 63));                bytes.push(128 | 63 & code);            }        }        return bytes;    }    function encode(str, urlsafe) {        var chars = urlsafe ? URLSAFE_CHARS : CHARS;        var bytes = strToBytes(str);        var result = [];        // 每3字节编码为4个 Base64 字符        for (var i = 0; i < bytes.length; i += 3) {            var b1 = bytes[i];            var b2 = i + 1 < bytes.length ? bytes[i + 1] : 0;            var b3 = i + 2 < bytes.length ? bytes[i + 2] : 0;            result.push(chars.charAt(b1 >> 2));                             // 取b1高6位            result.push(chars.charAt((3 & b1) << 4 | b2 >> 4));           // b1低2位+b2高4位            result.push(i + 1 < bytes.length                ? chars.charAt((15 & b2) << 2 | b3 >> 6)                  // b2低4位+b3高2位                : (urlsafe ? "" : "="));                                    // 填充            result.push(i + 2 < bytes.length                ? chars.charAt(63 & b3)                                     // b3低6位                : (urlsafe ? "" : "="));                                    // 填充        }        return result.join("");    }    return {        encode: function(str) { return encode(str, false); },        urlsafe_encode: function(str) { return encode(str, true); }        // pt="0"时使用    };})();

const nodeCrypto = require('crypto');var AES = {    encrypt: function(plaintext, key) {        // key 是 16 位 hex 字符串（如 "a3b1c2d4e5f67890"）        // 以 Latin1 编码转为 16 字节 Buffer → AES-128 密钥        var keyBuf = Buffer.from(key, 'latin1');        // IV 固定为 "0000000000000000" 的 Latin1 编码        // 注意：这不是 16 字节的零，而是 ASCII '0'(0x30) 重复 16 次        var ivBuf = Buffer.from('0000000000000000', 'latin1');        var cipher = nodeCrypto.createCipheriv('aes-128-cbc', keyBuf, ivBuf);        // 加密并返回字节数组（不是 hex 字符串）        var encrypted = cipher.update(plaintext, 'utf8');        var final = cipher.final();        var combined = Buffer.concat([encrypted, final]);        return Array.from(combined);  // 转为普通数组，后续用 arrayToHex 转hex    }};

0x00 | 0x02 | [随机非零字节填充] | 0x00 | [明文消息]  1B    1B     至少8字节            1B     N字节

var RSA_N = "00C1E3934D1614465B33053E7F48EE4EC87B14B95EF88947713D25EECBFF7E74C7977D02DC1D9451F79DD5D1C10C29ACB6A9B4D6FB7D0A0279B6719E1772565F09AF627715919221AEF91899CAE08C0D686D748B20A3603BE2318CA6BC2B59706592A9219D0BF05C9F65023A21D2330807252AE0066D59CEEFA5F2748EA80BAB81";var RSA_E = "10001";var RSA = {    encrypt: function(plaintext) {        var n = BigInt('0x' + RSA_N);        var e = BigInt('0x' + RSA_E);        // 密钥长度（字节）：去掉前导00后的实际长度        var keyLen = (RSA_N.length - (RSA_N.startsWith('00') ? 2 : 0)) / 2;  // 128        var msgBytes = Buffer.from(plaintext, 'utf8');        if (msgBytes.length + 11 > keyLen) {            console.error("Message too long for RSA");            return null;        }        // === PKCS#1 v1.5 Type 2 填充 ===        var padded = Buffer.alloc(keyLen);       // 128 字节        padded[0] = 0;                           // 0x00        padded[1] = 2;                           // 0x02 (公钥加密)        // 随机非零字节填充        var paddingLen = keyLen - msgBytes.length - 3;        var randomBytes = nodeCrypto.randomBytes(paddingLen);        for (var i = 0; i < paddingLen; i++) {            while (randomBytes[i] === 0) {        // 确保非零                randomBytes[i] = nodeCrypto.randomBytes(1)[0];            }            padded[2 + i] = randomBytes[i];        }        padded[2 + paddingLen] = 0;               // 0x00 分隔符        msgBytes.copy(padded, 3 + paddingLen);     // 复制明文        // === 大数幂模运算：c = m^e mod n ===        var m = BigInt('0x' + padded.toString('hex'));        var c = modPow(m, e, n);        var hex = c.toString(16);        if (hex.length % 2 !== 0) hex = '0' + hex;  // 确保偶数长度        return hex;                                   // 返回 256 字符的 hex    }};// 快速幂模运算（平方-乘法 算法）function modPow(base, exp, mod) {    var result = 1n;    base = base % mod;    while (exp > 0n) {        if (exp % 2n === 1n) {            result = (result * base) % mod;       // 奇数指数：乘以基数        }        exp = exp / 2n;                           // 指数减半        base = (base * base) % mod;               // 基数平方    }    return result;}

// SM4 S-box 替换表（256字节）var SM4_SBOX = [    0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, /* ... 完整256字节 ... */];// 32个固定密钥（CK常数）var SM4_CK = [    0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,    /* ... 完整32个 ... */];// 系统参数（FK常数）var SM4_FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc];// 循环左移function sm4_rotl(x, n) { return ((x << n) | (x >>> (32 - n))) >>> 0; }// 非线性变换 τ：4字节 S-box 替换function sm4_tau(A) {    return (SM4_SBOX[(A >>> 24) & 0xff] << 24 |            SM4_SBOX[(A >>> 16) & 0xff] << 16 |            SM4_SBOX[(A >>> 8) & 0xff] << 8 |            SM4_SBOX[A & 0xff]) >>> 0;}// 线性变换 L（加密用）function sm4_L(B) {    return (B ^ sm4_rotl(B, 2) ^ sm4_rotl(B, 10) ^            sm4_rotl(B, 18) ^ sm4_rotl(B, 24)) >>> 0;}// 线性变换 L'（密钥扩展用）function sm4_L_prime(B) {    return (B ^ sm4_rotl(B, 13) ^ sm4_rotl(B, 23)) >>> 0;}// SM4 构造函数：执行密钥扩展function SM4(config) {    var keyBytes = strToBytes(config.key);    var ivBytes = config.iv ? strToBytes(config.iv) : new Array(16).fill(0);    this.key = keyBytes;    this.iv = ivBytes;    this.mode = config.mode || "cbc";    // 密钥扩展：生成32个轮密钥    this.encryptRoundKeys = new Array(32);    var MK = this.toUint32Block(this.key);    var K = [        MK[0] ^ SM4_FK[0], MK[1] ^ SM4_FK[1],        MK[2] ^ SM4_FK[2], MK[3] ^ SM4_FK[3]    ];    for (var i = 0; i < 32; i++) {        var tmp = K[i + 1] ^ K[i + 2] ^ K[i + 3] ^ SM4_CK[i];        tmp = sm4_tau(tmp);        tmp = sm4_L_prime(tmp);        K.push((K[i] ^ tmp) >>> 0);        this.encryptRoundKeys[i] = K[i + 4];    }}// 16字节 → 4个 uint32SM4.prototype.toUint32Block = function(bytes, offset) {    offset = offset || 0;    return [        (bytes[offset]<<24 | bytes[offset+1]<<16 | bytes[offset+2]<<8 | bytes[offset+3]) >>> 0,        (bytes[offset+4]<<24 | bytes[offset+5]<<16 | bytes[offset+6]<<8 | bytes[offset+7]) >>> 0,        (bytes[offset+8]<<24 | bytes[offset+9]<<16 | bytes[offset+10]<<8 | bytes[offset+11]) >>> 0,        (bytes[offset+12]<<24 | bytes[offset+13]<<16 | bytes[offset+14]<<8 | bytes[offset+15]) >>> 0    ];};// 单块加密（32轮迭代）SM4.prototype.doBlockCrypt = function(block, roundKeys) {    var X = block.slice();    for (var i = 0; i < 32; i++) {        var tmp = X[i+1] ^ X[i+2] ^ X[i+3] ^ roundKeys[i];        tmp = sm4_tau(tmp);        tmp = sm4_L(tmp);        X.push((X[i] ^ tmp) >>> 0);    }    return [X[35], X[34], X[33], X[32]];       // 反序输出};// PKCS7 填充SM4.prototype.padding = function(bytes) {    var padLen = 16 - bytes.length % 16;    var padded = bytes.slice();    for (var i = 0; i < padLen; i++) padded.push(padLen);    return padded;};// CBC 模式加密SM4.prototype.encrypt = function(plaintext) {    var bytes = strToBytes(plaintext);    var padded = this.padding(bytes);    var blockCount = padded.length / 16;    var result = new Array(padded.length);    var prev = this.toUint32Block(this.iv);          // 初始向量    for (var i = 0; i < blockCount; i++) {        var offset = 16 * i;        var block = this.toUint32Block(padded, offset);        // CBC: 明文块 ⊕ 前一密文块（或IV）        block[0] ^= prev[0]; block[1] ^= prev[1];        block[2] ^= prev[2]; block[3] ^= prev[3];        var encrypted = this.doBlockCrypt(block, this.encryptRoundKeys);        prev = encrypted;        // uint32 → 字节数组        for (var c = 0; c < 16; c++) {            result[offset + c] = encrypted[parseInt(c/4)] >> (3-c)%4*8 & 255;        }    }    return result;};

9a4ea935b2576f37516d9b29cd8d8cc9bffe548ba6853253ba20f4ba44fba8c9e97a398882769aa0dd1e3e1b5601429287303880ca17bd244ed73bf702a68fc7

var SM2_PUBLIC_KEY = "9a4ea935b2576f37516d9b29cd8d8cc9bffe548ba6853253" +                     "ba20f4ba44fba8c9e97a398882769aa0dd1e3e1b56014292" +                     "87303880ca17bd244ed73bf702a68fc7";var SM2 = {    encrypt: function(plaintext, publicKey) {        publicKey = publicKey || SM2_PUBLIC_KEY;        var smCrypto = require('sm-crypto');        // '04' 前缀表示非压缩格式的公钥        // 第二个参数 1 表示使用 C1C3C2 密文格式        var result = smCrypto.sm2.doEncrypt(plaintext, '04' + publicKey, 1);        return result;    }};

function encryptW(payloadJson, pt) {    pt = pt || "0";    // === pt="0": 纯 Base64 URL-safe 编码 ===    if (!pt || pt === "0") {        return Base64.urlsafe_encode(payloadJson);    }    // 生成16位随机hex密钥    var key = guid();    if (pt === "1") {        // === pt="1": RSA + AES 混合加密 ===        // 1. 用 RSA 加密随机密钥        var rsaEncryptedKey = RSA.encrypt(key);        // 确保 RSA 密文长度为 256 字符（128字节hex）        while (!rsaEncryptedKey || rsaEncryptedKey.length !== 256) {            key = guid();            rsaEncryptedKey = RSA.encrypt(key);        }        // 2. 用 AES-128-CBC 加密 payload        var aesCiphertext = AES.encrypt(payloadJson, key);        // 3. 拼接：AES密文hex + RSA密文hex        return arrayToHex(aesCiphertext) + rsaEncryptedKey;    }    if (pt === "2") {        // === pt="2": SM2 + SM4 混合加密 ===        var sm2EncryptedKey = SM2.encrypt(key);        var sm4 = new SM4({ key: key, mode: "cbc", iv: "0000000000000000" });        var sm4Ciphertext = sm4.encrypt(payloadJson);        return arrayToHex(sm4Ciphertext) + sm2EncryptedKey;    }    // 未知 pt 值，降级为 Base64    return Base64.urlsafe_encode(payloadJson);}

w = hex(AES_CBC(payload_json, random_key)) + RSA_1024(random_key)    └── 可变长度（取决于payload大小）──┘   └── 固定256字符 ──┘总长度约为 1024~1280 字符

// 行 2097-2101: 合并基础字段(0, _v1911.$_BBF)(_v2160, {    device_id: _v2169.deviceId,        // 设备ID（通常为空）    lot_number: _v2169.lotNumber,      // 批次号    pow_msg: _v2167.options.powMsg,    // PoW 消息    pow_sign: _v2167.options.powSign   // PoW 签名});// 行 2102: 调用 gee_guard 指纹采集_v2167.$_BBEb(_v2160);// 行 2108-2109: 合并 gee_guard 和 _lib 数据(0, _v1911.$_BBF)(_v2176, {    gee_guard: _v2177.geeGuard         // ★ 当 geeGuard 为 undefined 时，                                        //   JSON.stringify 会跳过这个字段});(0, _v1911.$_BBF)(_v2176, window._lib ? window._lib : {});// window._lib = {"1a8R": "daC2"}      // 全局注入的字段// 行 2111-2117: lot_number 混淆映射// window.lib._abo = {"n[3:5]+n[9:11]": "n[7:12]"}// 这个映射用 lot_number 的子串作为 key，设置 payload 中的嵌套属性var i = getStringByIndexes(_v2177.lot, _v2177.lotNumber);var r = getStringByIndexes(_v2177.lotRes, _v2177.lotNumber);// 例如 lot_number = "72ce10e53aea4ac6b0b3217285a2a503"//   lot 解析 "n[3:5]+n[9:11]" → lot_number[3:5] + "." + lot_number[9:11]//   lotRes 解析 "n[7:12]" → lot_number[7:12]// 产生动态字段，嵌套设置到 payload 中// 行 2117: 设置 em = {} 并清空设备指纹_v2176.em = {};// 行 2118: 最终加密var _v2181 = (0, _v1921.default)(    _v1918.default.stringify(_v2176),    // payload → JSON 字符串    _v2179                               // 配置对象(含 pt));

function processInput(jsonStr) {    var params = JSON.parse(jsonStr);    // 构建 payload 对象    // 字段顺序按照 JS 源码的合并顺序    var payload = {        setLeft: params.setLeft,                 // 滑动距离（显示坐标，整数）        passtime: params.passtime,               // 操作耗时（毫秒）        userresponse: params.userresponse         // 原图坐标位移+2            || (params.setLeft / (params.scale || 1) + 2),        device_id: params.device_id || "",        // 设备ID（空字符串）        lot_number: params.lot_number || "",      // 批次号        pow_msg: params.pow_msg || "",            // PoW 消息        pow_sign: params.pow_sign || "",          // PoW 签名        em: params.em || {},                      // 设备指纹（空对象）    };    // ★ 注意：不包含 gee_guard 字段    //    JS 源码中 geeGuard 为 undefined 时，JSON.stringify 会自动跳过    //    如果我们设 gee_guard: null，JSON 会输出 "gee_guard":null，导致校验失败！    // 轨迹编码    if (params.track && params.track.length > 0) {        payload.aa = encodeTrack(params.track);   // 差分压缩 + 自定义编码    }    // JSON 序列化并加密    var payloadJson = JSON.stringify(payload);    var pt = params.pt || "1";    var w = encryptW(payloadJson, pt);    // 返回加密后的 w 和调试用的明文 payload    process.stdout.write(JSON.stringify({        w: w,        payload_debug: payload    }));}

{    "setLeft": 128,    "passtime": 1507,    "userresponse": 129.24,    "device_id": "",    "lot_number": "72ce10e53aea4ac6b0b3217285a2a503",    "pow_msg": "1|0|md5|2026-04-28T12:00:00+08:00|72ce...|24f5...||abc123",    "pow_sign": "d41d8cd98f00b204e9800998ecf8427e",    "em": {},    "aa": "0-1$)3!!stuv(!x0!!(/1,0-,+"}

GET https://gcaptcha4.geetest.com/verify    ?callback=geetest_1776962556789    &captcha_id=24f56dc13c40dc4a02fd0318567caef5    &challenge=a3b1c2d4e5f67890    &client_type=web    &lot_number=72ce10e53aea4ac6b0b3217285a2a503    &risk_type=slide    &payload=eyJ...                        # load 返回的不透明数据，原样回传    &process_token=d3a1b2c3...             # load 返回的会话令牌，原样回传    &payload_protocol=1    &pt=1                                   # 加密方式    &w=a3b1c2d4...（1280字符的加密数据）     # 核心加密参数

def call_verify(session, captcha_id, challenge, verify_params):    """    调用极验 verify 接口，提交验证数据    :param verify_params: dict 包含：        - lot_number:       批次号        - payload:          load 返回的不透明数据        - process_token:    会话令牌        - payload_protocol: 协议版本        - pt:               加密方式        - w:                加密后的验证数据    """    callback = generate_callback()    params = {        'callback': callback,        'captcha_id': captcha_id,        'challenge': challenge,        'client_type': 'web',        'lot_number': verify_params['lot_number'],        'risk_type': 'slide',        'payload': verify_params['payload'],        'process_token': verify_params['process_token'],        'payload_protocol': verify_params.get('payload_protocol', 1),        'pt': verify_params.get('pt', '1'),        'w': verify_params['w'],    }    resp = session.get(        f"https://{API_SERVER}/verify",        params=params,        headers=HEADERS,        timeout=15    )    return parse_jsonp(resp.text)

{    "status": "success",    "data": {        "result": "success",        "seccode": {            "pass_token": "a1b2c3d4e5f6...",            "gen_time": "2026-04-28 12:00:05",            "lot_number": "72ce10e53aea4ac6b0b3217285a2a503",            "captcha_output": "..."        }    }}

{    "status": "success",    "data": {        "result": "fail",        "score": "0"    }}

status = result.get('status', 'unknown')res_data = result.get('data', {})inner_result = res_data.get('result', 'unknown')if status == 'success' and inner_result == 'success':    print("验证通过!")    seccode = res_data.get('seccode', {})    pass_token = seccode.get('pass_token', '')      # 验证成功的凭证    gen_time = seccode.get('gen_time', '')           # 生成时间else:    print("验证未通过!")

"""极验 GeeTest v4 滑块验证码自动求解器完整流程：load → 下载图片 → 识别缺口 → 生成轨迹 → PoW → 加密w → verify"""import jsonimport reimport timeimport randomimport subprocessimport osimport structimport requestsfrom trajectory import generate_trajectory, get_passtime   # 轨迹生成模块from pow_solver import solve_pow                            # PoW 求解模块from gap_detector import detect_gap                         # 缺口识别模块# Node.js 加密脚本的绝对路径NODE_SCRIPT = os.path.join(    os.path.dirname(os.path.abspath(__file__)),    'node_env', 'generate_w.js')# ===== 配置常量 =====CAPTCHA_ID = "24f56dc13c40dc4a02fd0318567caef5"     # 极验演示站的验证码IDAPI_SERVER = "gcaptcha4.geetest.com"                 # 极验API服务器STATIC_SERVER = "https://static.geetest.com"         # 极验静态资源CDNCONTAINER_WIDTH = 340                                # 验证码容器宽度（像素）# 模拟 Chrome 浏览器的请求头HEADERS = {    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '                  'AppleWebKit/537.36 (KHTML, like Gecko) '                  'Chrome/120.0.0.0 Safari/537.36',    'Accept': '*/*',    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',    'Referer': 'https://www.geetest.com/adaptive-captcha',}SEP = "=" * 60  # 分隔线def generate_callback():    """生成 JSONP 回调函数名：geetest_{毫秒时间戳}"""    return f"geetest_{int(time.time() * 1000)}"def guid_python():    """    生成16位随机hex字符串（Python版）    与 JS 的 guid() 函数等价    """    def e():        return format((int(65536 * (1 + random.random())) | 0), 'x')[-4:]    return e() + e() + e() + e()def parse_jsonp(text):    """    解析 JSONP 响应    输入: 'geetest_123({"status":"success","data":{...}})'    输出: {"status":"success","data":{...}}    """    match = re.search(r'\((\{.*\})\)', text, re.DOTALL)    if match:        return json.loads(match.group(1))    return json.loads(text)def get_image_size(png_data):    """    从 PNG 二进制数据中提取宽高    PNG IHDR chunk: 字节16-19=宽度, 字节20-23=高度（大端序uint32）    """    if png_data[:4] == b'\x89PNG':        w = struct.unpack('>I', png_data[16:20])[0]        h = struct.unpack('>I', png_data[20:24])[0]        return w, h    return 300, 200def call_load(session, captcha_id, challenge):    """    Step 1: 调用 load 接口获取验证码配置    返回: lot_number, 图片路径, PoW参数等    """    callback = generate_callback()    params = {        'callback': callback,        'captcha_id': captcha_id,        'challenge': challenge,        'client_type': 'web',        'risk_type': 'slide',        'lang': 'zh',    }    resp = session.get(        f"https://{API_SERVER}/load",        params=params, headers=HEADERS, timeout=15    )    return parse_jsonp(resp.text)def call_verify(session, captcha_id, challenge, verify_params):    """    Step 8: 调用 verify 接口提交验证数据    """    callback = generate_callback()    params = {        'callback': callback,        'captcha_id': captcha_id,        'challenge': challenge,        'client_type': 'web',        'lot_number': verify_params['lot_number'],        'risk_type': 'slide',        'payload': verify_params['payload'],        'process_token': verify_params['process_token'],        'payload_protocol': verify_params.get('payload_protocol', 1),        'pt': verify_params.get('pt', '1'),        'w': verify_params['w'],    }    resp = session.get(        f"https://{API_SERVER}/verify",        params=params, headers=HEADERS, timeout=15    )    return parse_jsonp(resp.text)def generate_w_via_node(params):    """    调用 Node.js 子进程生成加密参数 w    通过 stdin 传入 JSON 参数，stdout 接收加密结果    """    input_json = json.dumps(params)    result = subprocess.run(        ['node', NODE_SCRIPT],        input=input_json,        capture_output=True,        text=True,        timeout=30    )    if result.returncode != 0:        raise RuntimeError(f"Node.js error: {result.stderr}")    output = json.loads(result.stdout)    return output['w'], output.get('payload_debug', {})def solve_captcha(captcha_id=None):    """    主流程：完成极验 v4 滑块验证码的自动求解    返回 verify 接口的响应结果    """    captcha_id = captcha_id or CAPTCHA_ID    session = requests.Session()    session.headers.update(HEADERS)    challenge = guid_python()                          # 生成本次挑战的唯一令牌    # === Step 1: 调用 load 接口 ===    load_resp = call_load(session, captcha_id, challenge)    if load_resp.get('status') != 'success':        return None    data = load_resp['data']    lot_number = data['lot_number']    payload = data['payload']    process_token = data['process_token']    pt = str(data.get('pt', '1'))    payload_protocol = data.get('payload_protocol', 1)    pow_detail = data.get('pow_detail', {})    bg_path = data.get('bg', '')    slice_path = data.get('slice', '')    # === Step 2: 下载背景图和滑块碎片图 ===    bg_url = f"{STATIC_SERVER}/{bg_path}"    bg_resp = session.get(bg_url, timeout=15)    bg_w, bg_h = get_image_size(bg_resp.content)       # 获取原图尺寸（如344x212）    # === Step 3: 识别缺口位置 ===    try:        gap_x = detect_gap(image_bytes=bg_resp.content)    except Exception:        gap_x = random.randint(100, 250)                # OCR失败时的备用方案    # === 坐标换算 ===    SLIDER_OFFSET = 15                                  # 滑块初始偏移（像素）    scale = 0.8876 * CONTAINER_WIDTH / bg_w             # 缩放比    adjusted_gap_x = gap_x - SLIDER_OFFSET              # 减去滑块偏移    slide_distance = adjusted_gap_x * scale             # 转为显示坐标系    setLeft = int(slide_distance)                       # 取整    userresponse = setLeft / scale + 2                  # 转回原图坐标+2    # === Step 4: 模拟思考延时 ===    delay = random.uniform(1.5, 3.0)    time.sleep(delay)    # === Step 5: 生成拟人化轨迹 ===    track_display = generate_trajectory(int(slide_distance))    passtime = get_passtime(track_display)    # 显示坐标→原图坐标系    track = [[round(p[0] / scale), round(p[1] / scale), p[2]]             for p in track_display]    # 插入初始偏移点    initial_offset = [random.randint(-30, -10), random.randint(-10, 10), 0]    track.insert(0, initial_offset)    # === Step 6: 计算 PoW ===    pow_config = {        'version': pow_detail.get('version', '1'),        'bits': pow_detail.get('bits', 0),        'hashfunc': pow_detail.get('hashfunc', 'md5'),        'datetime': pow_detail.get('datetime', ''),        'lot_number': lot_number,        'captcha_id': captcha_id,        'nonce': pow_detail.get('nonce', ''),    }    pow_result = solve_pow(pow_config)    # === Step 7: 调用 Node.js 生成加密参数 w ===    w_params = {        'setLeft': setLeft,        'passtime': passtime,        'userresponse': userresponse,        'device_id': '',        'lot_number': lot_number,        'pow_msg': pow_result['pow_msg'],        'pow_sign': pow_result['pow_sign'],        'em': {},        'track': track,        'pt': pt,        'scale': scale,    }    w, payload_debug = generate_w_via_node(w_params)    # === Step 8: 提交 verify 请求 ===    result = call_verify(session, captcha_id, challenge, {        'lot_number': lot_number,        'payload': payload,        'process_token': process_token,        'payload_protocol': payload_protocol,        'pt': pt,        'w': w,    })    # 判定验证结果    status = result.get('status', 'unknown')    res_data = result.get('data', {})    inner_result = res_data.get('result', 'unknown')    if status == 'success' and inner_result == 'success':        print("验证通过!")    else:        print("验证未通过!")    return resultif __name__ == "__main__":    solve_captcha()

'use strict';const nodeCrypto = require('crypto');   // Node.js 内置加密模块// ============================// guid() - 生成16位随机hex密钥// 对应源码: gcaptcha4_deobfuscated.js 行 457-464// 用途: 生成对称加密的随机密钥（AES/SM4的key）// ============================function guid() {    function e() {        // 生成 65536~131071 范围的整数，取十六进制后4位        return (65536 * (1 + Math.random()) | 0).toString(16).substring(1);    }    return e() + e() + e() + e();   // 4×4 = 16位hex}// ============================// arrayToHex() - 字节数组转hex字符串// 对应源码: 行 306-312// 用途: 将 AES/SM4 加密输出的字节数组转为hex字符串// 示例: [72, 101, 108] → "48656c"// ============================function arrayToHex(arr) {    // 第一步：将字节值打包到32位整数数组中    var t = [], s = 0;    for (var n = 0; n < 2 * arr.length; n += 2) {        t[n >>> 3] |= parseInt(arr[s], 10) << 24 - n % 8 * 4;        s++;    }    // 第二步：逐字节提取，转为两位hex字符    var i = [];    for (var r = 0; r < arr.length; r++) {        var o = t[r >>> 2] >>> 24 - r % 4 * 8 & 255;   // 提取单字节        i.push((o >>> 4).toString(16));                  // 高4位        i.push((15 & o).toString(16));                   // 低4位    }    return i.join("");}