inti

geetest/trajectory.py

@@ -0,0 +1,628 @@
+import random
+import math
+from typing import Any, Optional
+
+
+# 生成类人的鼠标轨迹
+def generate_realistic_trajectory(start_x:int, start_y:int, end_x:int, end_y:int, start_time:int) -> list[Any]:
+    """生成类人的鼠标轨迹"""
+    trajectory = []
+
+    # 计算距离和步数
+    distance = ((end_x - start_x) ** 2 + (end_y - start_y) ** 2) ** 0.5
+    steps = int(distance / 2) + random.randint(5, 15)  # 根据距离动态调整步数
+
+    current_time = start_time
+    current_x, current_y = start_x, start_y
+
+    for i in range(steps):
+        # 使用贝塞尔曲线模拟自然移动
+        progress = i / steps
+
+        # 添加缓动函数（开始快，中间慢，结束快）
+        if progress < 0.3:
+            eased = progress / 0.3 * 0.2
+        elif progress < 0.7:
+            eased = 0.2 + (progress - 0.3) / 0.4 * 0.5
+        else:
+            eased = 0.7 + (progress - 0.7) / 0.3 * 0.3
+
+        # 计算目标位置（添加随机抖动）
+        target_x = start_x + (end_x - start_x) * eased
+        target_y = start_y + (end_y - start_y) * eased
+
+        # 添加微小的随机偏移（模拟手抖）
+        jitter_x = random.uniform(-0.5, 0.5)
+        jitter_y = random.uniform(-0.5, 0.5)
+
+        current_x = int(target_x + jitter_x)
+        current_y = int(target_y + jitter_y)
+
+        # 随机时间间隔（3-25ms，符合人类反应）
+        time_delta = random.choices(
+            [3, 4, 5, 6, 7, 8, 10, 12, 15, 20, 24],
+            weights=[5, 8, 10, 12, 10, 8, 5, 3, 2, 1, 1]
+        )[0]
+        current_time += time_delta
+
+        trajectory.append([
+            "move",
+            current_x,
+            current_y,
+            current_time,
+            "pointermove"
+        ])
+
+        # 偶尔在同一位置停留（模拟视觉确认）
+        if random.random() < 0.15:
+            trajectory.append([
+                "move",
+                current_x,
+                current_y,
+                current_time + random.randint(5, 15),
+                "pointermove"
+            ])
+            current_time += random.randint(5, 15)
+
+    # 到达目标后的悬停
+    hover_time = random.randint(50, 150)
+    for _ in range(random.randint(2, 5)):
+        current_time += random.randint(8, 25)
+        trajectory.append([
+            "move",
+            end_x + random.randint(-1, 1),
+            end_y + random.randint(-1, 1),
+            current_time,
+            "pointermove"
+        ])
+
+    current_time += hover_time
+
+    # 点击事件
+    trajectory.append([
+        "down",
+        end_x,
+        end_y,
+        current_time,
+        "pointerdown"
+    ])
+
+    trajectory.append([
+        "focus",
+        current_time + 1
+    ])
+
+    click_duration = random.randint(80, 130)
+    trajectory.append([
+        "up",
+        end_x,
+        end_y,
+        current_time + click_duration,
+        "pointerup"
+    ])
+
+    return trajectory
+
+# 处理原始轨迹数组
+def process_mouse_trajectory(events:list[Any], max_records: Optional[int] = None) -> dict[str,Any]:
+    """
+    处理鼠标/触摸轨迹数据，将绝对坐标转换为相对坐标和时间差
+
+    参数:
+        events: 原始事件数据列表
+        max_records: 最大保留记录数（None表示保留全部）
+
+    返回:
+        处理后的事件列表
+    """
+    if not events or len(events) == 0:
+        return []
+
+    # 初始化变量
+    prev_x = 0  # 上一个X坐标
+    prev_y = 0  # 上一个Y坐标
+    prev_time = 0  # 上一个时间戳
+    result = []  # 结果数组
+    first_event = None  # 第一个事件
+    last_event = None  # 最后一个事件
+
+    # 移动类事件（包含坐标信息）
+    MOVE_EVENTS = ["move", "mousemove", "touchmove", "pointermove"]
+
+    # 点击类事件（仅时间信息）
+    CLICK_EVENTS = ["down", "up", "click", "mousedown", "mouseup",
+                    "touchstart", "touchend", "pointerdown", "pointerup"]
+
+    # 特殊事件（仅时间信息）
+    TIME_ONLY_EVENTS = ["focus", "blur", "keydown", "keyup"]
+
+    # 如果设置了最大记录数，只处理最后N条
+    start_index = 0
+    if max_records and len(events) > max_records:
+        start_index = len(events) - max_records
+
+    # 遍历事件
+    for i in range(start_index, len(events)):
+        event = events[i]
+        event_type = event[0]
+
+        # 处理移动类事件（包含X, Y坐标）
+        if event_type in MOVE_EVENTS:
+            x = event[1]
+            y = event[2]
+            timestamp = event[3]
+
+            # 记录第一个和最后一个事件
+            if first_event is None:
+                first_event = event
+            last_event = event
+
+            # 计算相对坐标差值
+            delta_x = x - prev_x
+            delta_y = y - prev_y
+
+            # 计算时间差
+            if prev_time == 0:
+                time_diff = 0  # 第一个事件时间差为0
+            else:
+                time_diff = timestamp - prev_time
+
+            # 添加到结果数组
+            result.append([
+                event_type,
+                [delta_x, delta_y],
+                time_diff
+            ])
+
+            # 更新上一次的值
+            prev_x = x
+            prev_y = y
+            prev_time = timestamp
+
+        # 处理点击类事件（包含坐标但只记录时间差）
+        elif event_type in CLICK_EVENTS:
+            timestamp = event[3] if len(event) > 3 else event[1]
+
+            # 计算时间差
+            if prev_time == 0:
+                time_diff = 0
+            else:
+                time_diff = timestamp - prev_time
+
+            # 添加到结果数组（坐标差为[0,0]）
+            result.append([
+                event_type,
+                [0, 0],
+                time_diff
+            ])
+
+            prev_time = timestamp
+
+        # 处理仅时间类事件（如focus）
+        elif event_type in TIME_ONLY_EVENTS:
+            timestamp = event[1]
+
+            # 计算时间差
+            if prev_time == 0:
+                time_diff = 0
+            else:
+                time_diff = timestamp - prev_time
+
+            # 添加到结果数组（仅包含时间差）
+            result.append([
+                event_type,
+                time_diff
+            ])
+
+            prev_time = timestamp
+
+    return {
+        "data": result,
+        "first_event": first_event,
+        "last_event": last_event,
+        "total_events": len(result)
+    }
+
+def compress_trajectory(e:list[Any]) -> str:
+    """
+    压缩轨迹数据的完整实现
+
+    Args:
+        e: 轨迹数据列表
+
+    Returns:
+        压缩后的 Base64 编码字符串
+    """
+    # 事件类型映射
+    p = {
+        "move": 0,
+        "down": 1,
+        "up": 2,
+        "scroll": 3,
+        "focus": 4,
+        "blur": 5,
+        "unload": 6,
+        "unknown": 7
+    }
+
+    def h(e, t):
+        """
+        填充二进制字符串
+
+        Args:
+            e: 数值
+            t: 目标长度
+
+        Returns:
+            填充后的二进制字符串
+        """
+        n = bin(e)[2:]  # 转为二进制并去掉 '0b' 前缀
+        r = ""
+        o = len(n) + 1
+        while o <= t:
+            r += "0"
+            o += 1
+        return r + n
+
+    def f(e):
+        """
+        压缩事件类型数组
+
+        Args:
+            e: 事件类型列表
+
+        Returns:
+            压缩后的二进制字符串
+        """
+        t = []
+        n = len(e)
+        r = 0
+
+        # 游程编码（Run-Length Encoding）
+        while r < n:
+            o = e[r]
+            i = 0
+            while True:
+                if 16 <= i:
+                    break
+                s = r + i + 1
+                if n <= s:
+                    break
+                if e[s] != o:
+                    break
+                i += 1
+
+            r = r + 1 + i
+            a = p[o]
+            if i != 0:
+                t.append(8 | a)  # 设置重复标志位
+                t.append(i - 1)
+            else:
+                t.append(a)
+
+        # 编码长度信息
+        _ = h(32768 | n, 16)
+        c = ""
+        for l in range(len(t)):
+            c += h(t[l], 4)
+
+        return _ + c
+
+    def c(e, t):
+        """
+        对数组每个元素应用函数
+
+        Args:
+            e: 输入数组
+            t: 转换函数
+
+        Returns:
+            转换后的数组
+        """
+        n = []
+        for r in range(len(e)):
+            n.append(t(e[r]))
+        return n
+
+    def d(e, t):
+        """
+        压缩数值数组（游程编码 + 变长编码）
+
+        Args:
+            e: 数值数组
+            t: 是否为坐标数据（需要过滤符号位）
+
+        Returns:
+            压缩后的二进制字符串
+        """
+
+        # 第一步：限制数值范围到 [-32767, 32767]
+        def limit_value(val):
+            limit = 32767
+            return max(-limit, min(limit, val))
+
+        e = c(e, limit_value)
+
+        # 第二步：游程编码（Run-Length Encoding）
+        n = len(e)
+        r = 0
+        o = []
+
+        while r < n:
+            i = 1
+            s = e[r]
+            a = abs(s)
+
+            # 统计连续相同的值
+            while r + i < n and e[r + i] == s and a < 127 and i < 127:
+                i += 1
+
+            if i > 1:
+                # 重复值编码格式：
+                # 位15: 符号标志 (1=负数49152, 0=正数32768)
+                # 位14-7: 重复次数 (i)
+                # 位6-0: 绝对值 (a)
+                o.append((49152 if s < 0 else 32768) | (i << 7) | a)
+            else:
+                o.append(s)
+
+            r += i
+
+        e = o
+
+        # 第三步：变长编码
+        r = []  # 存储每个数字的十六进制位数
+        o = []  # 存储实际数值
+
+        for val in e:
+            # 计算需要多少个十六进制位（每位4 bit）
+            if val == 0:
+                bits = 1
+            else:
+                # 方法1：使用对数（与原JS一致）
+                bits = math.ceil(math.log(abs(val) + 1) / math.log(16))
+                # 方法2：直接计算（更快）
+                # bits = len(format(abs(val), 'x'))
+
+                bits = max(1, bits)
+
+            r.append(h(bits - 1, 2))  # 2位十六进制存储位数信息
+            o.append(h(abs(val), 4 * bits))  # 实际值
+
+        i = "".join(r)  # 元数据
+        s = "".join(o)  # 数据
+
+        # 第四步：符号位编码（仅用于坐标数据）
+        if t:
+            # 过滤掉：0值 和 已编码符号的压缩值（位15=1）
+            filtered = [x for x in e if x != 0 and (x >> 15) != 1]
+            n = "".join(["1" if x < 0 else "0" for x in filtered])
+        else:
+            n = ""
+
+        # 最终格式：[头部16位][元数据][数据][符号位]
+        # 头部：最高位置1 + 数组长度
+        return h(32768 | len(e), 16) + i + s + n
+
+    # 主函数：数据分离
+    t = []  # 事件类型
+    n = []  # 时间差
+    r = []  # X坐标
+    o = []  # Y坐标
+
+    for i in range(len(e)):
+        a = e[i]
+        length = len(a)
+
+        t.append(a[0])
+        n.append(a[1] if length == 2 else a[2])
+
+        if length == 3:
+            r.append(a[1][0])
+            o.append(a[1][1])
+
+    # 压缩各部分
+    c_str = f(t) + d(n, False) + d(r, True) + d(o, True)
+
+    # 填充到6的倍数
+    l = len(c_str)
+    if l % 6 != 0:
+        c_str += h(0, 6 - l % 6)
+
+    # Base64编码
+    def u(e):
+        """Base64编码"""
+        t = ""
+        n = len(e) // 6
+        base64_chars = "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~"
+
+        for r in range(n):
+            # 每次取6位二进制
+            binary_str = e[6 * r: 6 * (r + 1)]
+            index = int(binary_str, 2)
+            t += base64_chars[index]
+
+        return t
+
+    return u(c_str)
+
+class TrajectoryEncoder:
+    def __init__(self) -> None:
+        self.CHARSET = "()*,-./0123456789:?@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqr"
+        self.BASE = len(self.CHARSET)  # 64
+        self.DIRECTION_CHARS = "stuvwxyz~"
+        self.DIRECTION_PATTERNS = [
+            [1, 0],  # s
+            [2, 0],  # t
+            [1, -1],  # u
+            [1, 1],  # v
+            [0, 1],  # w
+            [0, -1],  # x
+            [3, 0],  # y
+            [2, -1],  # z
+            [2, 1]  # ~
+        ]
+
+    def encode_number(self, num):
+        """编码单个数值为64进制"""
+        abs_num = abs(num)
+        high_index = abs_num // self.BASE
+        low_index = abs_num % self.BASE
+
+        result = ""
+
+        # 负数标记
+        if num < 0:
+            result += "!"
+
+        # 高位（当值>=64时）
+        if high_index > 0 and high_index < self.BASE:
+            result += "$"
+            result += self.CHARSET[high_index]
+
+        # 低位
+        result += self.CHARSET[low_index]
+
+        return result
+
+    def compress_trajectory(self, points):
+        """压缩轨迹：计算相邻点差值"""
+        compressed = []
+        time_accumulator = 0
+
+        for i in range(len(points) - 1):
+            dx = points[i + 1][0] - points[i][0]  # 不要用abs
+            dy = points[i + 1][1] - points[i][1]  # 不要用abs
+            dt = abs(points[i + 1][2] - points[i][2])  # 时间可以用abs
+
+            # 跳过完全相同的点
+            if dx == 0 and dy == 0 and dt == 0:
+                continue
+
+            # 位置不变只累积时间
+            if dx == 0 and dy == 0:
+                time_accumulator += dt
+            else:
+                compressed.append([dx, dy, dt + time_accumulator])
+                time_accumulator = 0
+
+        # 处理剩余时间
+        if time_accumulator != 0:
+            compressed.append([0, 0, time_accumulator])
+
+        return compressed
+
+    def get_direction_code(self, dx, dy):
+        """识别是否匹配方向模式"""
+        for i, pattern in enumerate(self.DIRECTION_PATTERNS):
+            if dx == pattern[0] and dy == pattern[1]:
+                return self.DIRECTION_CHARS[i]
+        return None
+
+    def encode(self, trajectory):
+        """
+        编码轨迹
+        trajectory: [[x, y, timestamp], ...]
+        返回: 编码后的字符串
+        """
+        compressed = self.compress_trajectory(trajectory)
+
+        x_encoded = []
+        y_encoded = []
+        t_encoded = []
+
+        for dx, dy, dt in compressed:
+            direction_code = self.get_direction_code(dx, dy)
+
+            if direction_code:
+                # 匹配到方向模式，只记录y
+                y_encoded.append(direction_code)
+            else:
+                # 不匹配，完整编码x和y
+                x_encoded.append(self.encode_number(dx))
+                y_encoded.append(self.encode_number(dy))
+
+            # 时间总是编码
+            t_encoded.append(self.encode_number(dt))
+
+        # 拼接：x坐标 !! y坐标 !! 时间戳
+        return "".join(x_encoded) + "!!" + "".join(y_encoded) + "!!" + "".join(t_encoded)
+
+    def encrypt_string(self,e, t, n):
+        """
+        JS加密函数的Python实现
+
+        参数:
+        e: 原始字符串
+        t: 加密参数数组
+        n: 十六进制字符串
+        """
+        if not t or not n:
+            return e
+
+        o = 0  # 偏移量
+        i = e  # 结果字符串
+        s = t[0]  # 12
+        a = t[2]  # 98
+        _ = t[4]  # 43
+
+        # 每次读取2个字符（十六进制）
+        while o < len(n):
+            r = n[o:o + 2]  # 取2个字符
+            if len(r) < 2:
+                break
+            o += 2
+
+            # 解析十六进制
+            c = int(r, 16)
+
+            # 转换为字符
+            l = chr(c)
+
+            # 计算插入位置: (s * c^2 + a * c + _) % len(e)
+            u = (s * c * c + a * c + _) % len(e)
+
+            # 在位置u插入字符
+            i = i[:u] + l + i[u:]
+
+        return i
+
+def H(t:int, e:str) -> str:
+    # 解析后缀
+    n = e[-2:]
+    r = []
+    for char in n:
+        o = ord(char)
+        r.append(o - 87 if o > 57 else o - 48)
+    n = 36 * r[0] + r[1]
+
+    # 计算目标值
+    a = round(t) + n
+
+    # 构建字符池
+    _ = [[], [], [], [], []]
+    c = {}
+    u = 0
+    for char in e[:-2]:
+        if char not in c:
+            c[char] = 1
+            _[u].append(char)
+            u = (u + 1) % 5
+
+    # 生成结果
+    f = a
+    d = 4
+    p = ""
+    g = [1, 2, 5, 10, 50]
+
+    while f > 0:
+        if f >= g[d]:
+            h = int(random.random() * len(_[d]))
+            p += _[d][h]
+            f -= g[d]
+        else:
+            _.pop(d)
+            g.pop(d)
+            d -= 1
+
+    return p