本文章中的所有内容仅供学习交流使用，不得用于任何其他目的。文中不会提供完整的代码、敏感网址、数据接口等信息，均已进行脱敏处理。严禁将本文内容用于商业或非法用途，否则由此产生的任何后果均与作者无关。如有侵权问题，请与作者联系，作者将立即删除相关内容。

本文旨在分享学习心得，供大家共同探讨交流。请各位读者在使用时遵守相关法律法规，合理合法地使用本文内容。

逆向目标

本篇分析V5验证码的wss协议，通过观察浏览器发现请求和响应一共9次

WebSocket讲解

WebSocket 使用详解

WebSocket 是一种在单个TCP连接上进行全双工通信的协议，允许服务端主动向客户端推送数据，非常适合实时应用。

WebSocket 基本使用流程

• 建立连接：客户端通过 new WebSocket(url) 创建连接
• 事件监听：通过回调函数处理连接状态和数据
• 发送数据：使用 send() 方法发送数据
• 接受数据：使用 message() 方法接受数据
• 关闭连接：使用 close() 方法

import websockets
import asyncio
async def get_crypto_prices():
    uri = "wss://echo.websocket.org"
    async with websockets.connect(uri) as websocket:
        while True:
            try:
                print('send ', 'Hello, WebSocket!')
                await  websocket.send("Hello, WebSocket!")
                data = await websocket.recv()
                print(f"message: {data}")
            except Exception as e:
                print(f"错误: {e}")
                break
if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(get_crypto_prices())

整体流程

整体流程

1. 用户验证
   用户点击按钮进行验证，系统将数据进行加密，并将其分割成3份发送到服务器。
2. 接收并解密数据
   第4次服务器返回的数据经过解密后，从中提取出 JSON 对象中的 u 字段，用于进行第五次请求。
3. 获取背景图和缺口图
   第五次请求后，第六次服务器返回的数据包含背景图和缺口图。使用 ddddocr 工具测量距离，并生成轨迹。
4. 发送环境和轨迹数据
   第七次和第八次将环境数据和轨迹数据进行加密，并分割成两份发送到服务器。
5. 返回结果
   第九次服务器处理完毕后，将结果返回

逆向分析

AES 加密

找到ws.send 的位置， 打上断点。

向上追栈，找到了加密的关键代码，主要是Y, E

a = Y(d, h);
a = E(b, a);
c[t](a);
var k = c.join("")
if (k) {
    var a = null;
    k.length > n ? (a = k.substr(0, n),
        k = k.substring(n)) : (a = k,
        k = null);
    a = m + "|" + q + "|" + p + "|" + a;
    p++;
    l(a, function () {
        f()
    })
}

d 和 h 是从页面上面获取到token

def v5_get_token():
    response = requests.get('https://www.xxxxx.com/demo', cookies=cookies, headers=headers)
    soup = BeautifulSoup(response.text, 'html.parser')
    div_tag = soup.find('div', attrs={'v5-config': True})
    if div_tag:
        v5_config_str = div_tag['v5-config']
        v5_config_str = v5_config_str.replace("'", '"')
        v5_config_str = v5_config_str.replace('id:', '"id":') \
            .replace('name:', '"name":') \
            .replace('host:', '"host":') \
            .replace('token:', '"token":')
        return json.loads(v5_config_str)['token']
token = v5_get_token()

Y 的加密位置

E 的加密位置

b是浏览器环境和轨迹组成的一个json串， a 是上面Y返回的结果

进去发现是AES的加密，iv采动态生成，将代码抠出来，放到node.js中运行

如果长度超过1024就进行截取，会进行3次截取发送到服务器，ws.message 会接收到一条数据进行解密。

浏览器环境 + 轨迹收集

{
    l: d,  //页面的token
    f: h,  // sha1加密  
    m: tc, // 直接扣
    j: Jb, // ES5
    tl: g[Pd] || 0,  //页面获取token时 有一个trustLevel
    o: e,   // json
    exfp: z, //  json
    aux: k  // 轨迹的收集
}

浏览器的基础环境

sha1 加密的代码

function d(a, d) {
    var m = (a & 65535) + (d & 65535);
    return (a >> 16) + (d >> 16) + (m >> 16) << 16 | m & 65535
}
function sha1(a) {
    for (var m = (a.length + 8 >> 6) + 1, n = Array(16 * m), f = 0; f < 16 * m; f++)
        n[f] = 0;
    for (f = 0; f < a.length; f++)
        n[f >> 2] |= a.charCodeAt(f) << 24 - 8 * (f & 3);
    n[f >> 2] |= 128 << 24 - 8 * (f & 3);
    n[16 * m - 1] = 8 * a.length;
    a = Array(80);
    m = 1732584193;
    f = -271733879;
    for (var r = -1732584194, p = 271733878, y = -1009589776, v = 0; v < n.length; v += 16) {
        for (var C = m, O = f, M = r, E = p, F = y, l = 0; 80 > l; l++) {
            var b = l;
            if (16 > l)
                var k = n[v + l];
            else
                k = a[l - 3] ^ a[l - 8] ^ a[l - 14] ^ a[l - 16],
                    k = k << 1 | k >>> 31;
            a[b] = k;
            b = d(d(m << 5 | m >>> 27, 20 > l ? f & r | ~f & p : 40 > l ? f ^ r ^ p : 60 > l ? f & r | f & p | r & p : f ^ r ^ p), d(d(y, a[l]), 20 > l ? 1518500249 : 40 > l ? 1859775393 : 60 > l ? -1894007588 : -899497514));
            y = p;
            p = r;
            r = f << 30 | f >>> 2;
            f = m;
            m = b
        }
        m = d(m, C);
        f = d(f, O);
        r = d(r, M);
        p = d(p, E);
        y = d(y, F)
    }
    n = [m, f, r, p, y];
    a = "";
    for (m = 0; m < 4 * n.length; m++)
        a += "0123456789abcdef".charAt(n[m >> 2] >> 8 * (3 - m % 4) + 4 & 15) + "0123456789abcdef".charAt(n[m >> 2] >> 8 * (3 - m % 4) & 15);
    return a
}

其他的值按照上面的方式把代码扣出来即可轨迹的收集

mouseTrackData_ = ''
function generateMouseTrackData(numPoints) {
    const mouseTrackData = {
        aux: {
            k: [],
            m: [],
            h: []
        }
    };
    let lastTimestamp = 0;
    for (let i = 0; i < numPoints; i++) {
        const y = Math.floor(Math.random() * 600);
        const x = Math.floor(Math.random() * y);
        lastTimestamp += 100;
        mouseTrackData.aux.m.push([3, x, y, lastTimestamp]);
    }
    for (let j = 0; j < 20; j++) {
        const hY = Math.floor(Math.random() * 600);
        const hX = Math.floor(Math.random() * (800 - hY) + hY);
        const hTimestamp = lastTimestamp + Math.floor(Math.random() * 1000) + 1000;
        mouseTrackData.aux.h.push([3, hX, hY, hTimestamp]);
    }
    mouseTrackData_ = mouseTrackData
}
generateMouseTrackData(20);
requestData['data']['aux'] = JSON.parse(JSON.stringify(mouseTrackData_['aux']))

AES 解密：

找到AES解密的位置

Y 、ja 解密位置

在控制台打印 ja(a, b);

至此，加密和解密的流程已经分析完成，后续的每一次请求响应都是按照上面的流程进行加解密的。缺口距离及轨迹

import ddddocr
slide = ddddocr.DdddOcr(det=False, ocr=False, show_ad=False)
code_s = 'path/to/slider_image.png'  # 滑块图像路径
code_l = 'path/to/background_image.png'  # 背景图像路径
res = slide.slide_match(code_s, code_l, simple_target=True)
print(f"滑块的距离为: {res['distance']}")

轨迹检测

import time
import random


def create_slider_path(total_distance):
    start_time = str(int(time.time() * 1000))
    end_time = str(int(time.time() * 1000) + 1000)
    path = [start_time]
    current_position = 0
    elapsed_time = 0
    base_y = -30
    # 使用不同的策略来生成轨迹
    while current_position < total_distance:
        if current_position < total_distance / 2:
            step = random.randint(1, 5)  # 前半段小步移动
        else:
            step = random.randint(5, 15)  # 后半段大步移动
        current_position += step
        if current_position > total_distance:
            current_position = total_distance  # 确保不超过总距离
        time_increment = int(step * random.uniform(20, 50))
        elapsed_time += time_increment
        y_offset = random.randint(-5, 5)  # 更大的y变化范围
        y_value = base_y + y_offset
        path.extend([str(elapsed_time), str(current_position), str(y_value)])
    if current_position != total_distance:
        elapsed_time += random.randint(10, 50)
        path.extend([str(elapsed_time), str(total_distance), str(base_y)])
    path.append(end_time)
    path_string = ",".join(path)
    return path_string

结果验证

返回true 验证通过