第一代攻击：固定坐标 + 匀速拖动
  → 防御：检测轨迹是否包含速度变化
  → 攻击升级：贝塞尔曲线 + 随机速度

第二代攻击：贝塞尔曲线 + 随机速度
  → 防御：检测加速度微校正密度 + 生理震颤
  → 攻击升级：录屏重放真实轨迹

第三代攻击：录屏重放
  → 防御：检测时间结构异常 + 震颤频带能量
  → 攻击升级：GAN 生成以假乱真的轨迹

第四代攻击：GAN 生成轨迹
  → 防御：？？？

┌─────────────────────────────────────────────────────────────┐
│  维度一：鼠标轨迹（必须）                                      │
│  - mousedown → mousemove → mouseup 的 (t, x, y) 序列         │
│  - 采样率：常见约 60-120Hz（约 8-16ms 间隔），取决于浏览器、    │
│    操作系统和鼠标硬件                                          │
│  - 数据量：约 50-80 个采样点（800ms 拖动）                     │
├─────────────────────────────────────────────────────────────┤
│  维度二：键盘事件（可选，但强烈推荐）                            │
│  - keydown/keyup 的 (t, key, type) 序列                      │
│  - 作用：检测"纯鼠标操作"（Tab 键导航到滑块是机器人的强信号）     │
│  - 数据量：0-5 个事件（真人通常不用键盘操作滑块）                │
├─────────────────────────────────────────────────────────────┤
│  维度三：时序特征（自动采集）                                   │
│  - 从页面加载到 mousedown 的延迟（反应时间）                    │
│  - 从 mousedown 到 mouseup 的总耗时（拖动时间）                 │
│  - mousemove 事件间隔的分布（采样间隔的波动性）                  │
│  - 数据量：自动计算，不需要额外采集                             │
├─────────────────────────────────────────────────────────────┤
│  维度四：环境指纹（必须）                                       │
│  - navigator: userAgent, platform, language, hardwareConcurrency│
│  - screen: width, height, colorDepth, pixelRatio             │
│  - timezone, touchSupport, canvas/webgl fingerprint          │
│  - 作用：检测 Selenium/Puppeteer/Playwright 的自动化环境       │
│  - 数据量：约 30 个键值对                                      │
├─────────────────────────────────────────────────────────────┤
│  维度五：行为上下文（推荐）                                     │
│  - 滑动前的鼠标移动（悬停、徘徊）                               │
│  - 失败重试的次数和间隔                                        │
│  - 页面滚动位置（是否在可视区域）                               │
│  - 数据量：约 10-20 个采样点                                   │
└─────────────────────────────────────────────────────────────┘

// behavior-collector.js —— 前端五维行为采集（约 200 行）
// 零依赖，兼容 IE11+

class BehaviorCollector {
    constructor(options = {}) {
        this.maxTrajectoryPoints = options.maxTrajectoryPoints || 200;
        this.sampleRate = options.sampleRate || 0; // 0 = 不限制，跟随浏览器事件频率
        this._lastSampleTime = 0;
        this.pageLoadTime = options.pageLoadTime || performance.now();
        this._reset();
    }
    
    _reset() {
        this.startTime = 0;
        this.trajectory = [];      // 维度一：鼠标轨迹
        this.keyEvents = [];       // 维度二：键盘事件
        this.preDragMoves = [];    // 维度五：滑动前的鼠标移动
        this.isDragging = false;
        // 注意：retryCount 属于会话级别，reset 时不应清零
    }
    
    // ============================================================
    // 维度一：鼠标轨迹采集
    // ============================================================
    
    attach(sliderElement) {
        this.slider = sliderElement;
        
        // mousedown：开始采集
        this.slider.addEventListener('mousedown', (e) => {
            this.isDragging = true;
            this.startTime = performance.now();
            this.dragStartTime = this.startTime;
            this.trajectory = [];
            this._recordMouse(e);
        });
        
        // mousemove：持续采集（节流控制）
        document.addEventListener('mousemove', (e) => {
            if (!this.isDragging) {
                // 维度五：滑动前的鼠标移动
                this._recordPreDrag(e);
                return;
            }
            
            // 节流：如果设置了采样率，限制采集频率
            const now = performance.now();
            if (this.sampleRate > 0 && 
                now - this._lastSampleTime < 1000 / this.sampleRate) {
                return;
            }
            this._lastSampleTime = now;
            
            this._recordMouse(e);
            
            // 防止轨迹数据过大（超过上限则丢弃最早的）
            if (this.trajectory.length > this.maxTrajectoryPoints) {
                this.trajectory.shift();
            }
        });
        
        // mouseup：结束采集
        document.addEventListener('mouseup', (e) => {
            if (!this.isDragging) return;
            this._recordMouse(e);
            this.isDragging = false;
        });
    }
    
    _recordMouse(e) {
        const rect = this.slider.getBoundingClientRect();
        this.trajectory.push({
            t: Math.round(performance.now() - this.startTime),
            x: Math.round(e.clientX - rect.left),
            y: Math.round(e.clientY - rect.top),
            // 附加信息：鼠标按键状态
            button: e.button,
            buttons: e.buttons
        });
    }
    
    _recordPreDrag(e) {
        // 只保留最近 10 个滑动前的鼠标位置
        if (this.preDragMoves.length > 10) {
            this.preDragMoves.shift();
        }
        this.preDragMoves.push({
            t: Math.round(performance.now()),
            x: Math.round(e.clientX),
            y: Math.round(e.clientY)
        });
    }
    
    // ============================================================
    // 维度二：键盘事件（可选）
    // ============================================================
    
    attachKeyboard() {
        document.addEventListener('keydown', (e) => {
            this.keyEvents.push({
                t: Math.round(performance.now()),
                type: 'down',
                key: e.key,
                code: e.code
            });
        });
        
        document.addEventListener('keyup', (e) => {
            this.keyEvents.push({
                t: Math.round(performance.now()),
                type: 'up',
                key: e.key,
                code: e.code
            });
        });
    }
    
    // ============================================================
    // 维度四：环境指纹
    // ============================================================
    
    collectEnvironment() {
        const nav = navigator;
        const screen = window.screen;
        
        return {
            // 浏览器信息
            userAgent: nav.userAgent,
            platform: nav.platform,
            language: nav.language,
            languages: nav.languages ? Array.from(nav.languages) : [],
            hardwareConcurrency: nav.hardwareConcurrency || 0,
            deviceMemory: nav.deviceMemory || 0,
            
            // 屏幕信息
            screenWidth: screen.width,
            screenHeight: screen.height,
            colorDepth: screen.colorDepth,
            pixelRatio: window.devicePixelRatio || 1,
            
            // 时区
            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
            timezoneOffset: new Date().getTimezoneOffset(),
            
            // 功能检测
            touchSupport: 'ontouchstart' in window,
            cookieEnabled: nav.cookieEnabled,
            doNotTrack: nav.doNotTrack,
            
            // WebDriver 检测（Selenium 标志）
            webdriver: nav.webdriver || false,
            
            // Chrome 自动化检测
            chrome: window.chrome ? {
                runtime: !!window.chrome.runtime,
                loadTimes: !!window.chrome.loadTimes
            } : null,
            
            // 插件检测
            plugins: Array.from(nav.plugins || []).map(p => p.name).slice(0, 10),
            
            // WebGL 指纹（简版）
            webglVendor: this._getWebGLInfo('VENDOR'),
            webglRenderer: this._getWebGLInfo('RENDERER'),
        };
    }
    
    _getWebGLInfo(param) {
        try {
            const canvas = document.createElement('canvas');
            const gl = canvas.getContext('webgl') || 
                       canvas.getContext('experimental-webgl');
            if (!gl) return null;
            const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
            if (!debugInfo) return null;
            return gl.getParameter(debugInfo[`UNMASKED_${param}_WEBGL`]);
        } catch (e) {
            return null;
        }
    }
    
    // ============================================================
    // 序列化输出
    // ============================================================
    
    getPayload() {
        return {
            // 维度一：轨迹
            trajectory: this.trajectory,
            
            // 维度二：键盘
            keyEvents: this.keyEvents,
            
            // 维度三：时序（自动计算）
            timing: {
                totalDuration: this.trajectory.length > 0 
                    ? this.trajectory[this.trajectory.length - 1].t 
                    : 0,
                pointCount: this.trajectory.length,
                retryCount: this.retryCount,
                dragStartTime: this.dragStartTime || 0,
            },
            
            // 维度四：环境
            environment: this.collectEnvironment(),
            
            // 维度五：上下文
            context: {
                preDragMoves: this.preDragMoves,
                pageScrollY: window.scrollY,
                viewportHeight: window.innerHeight,
            },
            
            // 元数据
            meta: {
                version: '1.0.0',
                timestamp: Date.now(),
                collector: 'behavior-collector-v1',
                pageLoadTime: this.pageLoadTime,
            }
        };
    }
    
    // 失败重试计数
    onFail() {
        this.retryCount++;
        this._reset();
    }
}

// 关键检测逻辑不使用明文字符串
const _detect = (function() {
    // 用 IIFE 创建闭包，防止外部访问内部变量
    const _SECRET = '\x77\x65\x62\x64\x72\x69\x76\x65\x72'; // "webdriver"
    
    return function() {
        // 检测 navigator.webdriver 属性
        if (navigator[_SECRET]) {
            return { automated: true, reason: 'webdriver_flag' };
        }
        
        // 检测 Chrome DevTools Protocol
        if (window.chrome && window.chrome.runtime && 
            navigator.userAgent.includes('Headless')) {
            return { automated: true, reason: 'headless_chrome' };
        }
        
        return { automated: false };
    };
})();

// 在页面加载时计算关键函数的哈希
(function() {
    const CRITICAL_FUNCTIONS = [
        '_recordMouse',
        'collectEnvironment',
        '_detect',
    ];
    
    const originalHashes = {
        // 部署时预计算的哈希值（通过构建工具生成）
        _recordMouse: 'a3f8b2c1...',
        collectEnvironment: 'd4e5f6a7...',
        _detect: 'b8c9d0e1...',
    };
    
    // 运行时校验
    function verifyIntegrity() {
        for (const fnName of CRITICAL_FUNCTIONS) {
            const fnStr = window._collector[fnName].toString();
            const hash = simpleHash(fnStr);
            if (hash !== originalHashes[fnName]) {
                // 函数被篡改，静默上报（不 alert，避免暴露检测逻辑）
                navigator.sendBeacon('/api/integrity-violation', JSON.stringify({
                    fn: fnName,
                    hash: hash,
                    expected: originalHashes[fnName],
                }));
            }
        }
    }
    
    function simpleHash(str) {
        let hash = 0;
        for (let i = 0; i < str.length; i++) {
            const char = str.charCodeAt(i);
            hash = ((hash << 5) - hash) + char;
            hash = hash & hash; // Convert to 32bit integer
        }
        return hash.toString(16);
    }
    
    // 延迟执行（避免影响首屏加载）
    setTimeout(verifyIntegrity, 1000 + Math.random() * 2000);
})();

// 检测鼠标事件是否由真实硬件触发
// 自动化工具触发的事件缺少 isTrusted 属性或为 false
function isRealMouseEvent(e) {
    // 1. isTrusted 必须为 true（真实用户交互）
    if (!e.isTrusted) return false;
    
    // 2. 自动化工具的事件通常缺少某些属性
    if (e.movementX === 0 && e.movementY === 0 && 
        e.type === 'mousemove') {
        // 单次静止的 mousemove 是可疑的，但需要累积判断
        return 'suspicious';
    }
    
    // 3. 检测事件的时间戳是否单调递增
    // 自动化工具重放时，时间戳可能倒退或完全一致
    if (!this._lastEventTime) {
        this._lastEventTime = e.timeStamp;
    } else {
        if (e.timeStamp < this._lastEventTime) {
            return false; // 时间戳倒退
        }
        if (e.timeStamp === this._lastEventTime && e.type === 'mousemove') {
            return false; // 同一时间戳的连续 mousemove
        }
        this._lastEventTime = e.timeStamp;
    }
    
    return true;
}

┌───────────────────────────────────────────────────────────────┐
│  14 维特征向量                                                  │
│                                                                │
│  轨迹特征（7 维，复用前文）                                       │
│  F1:  速度分布熵          → 速度多峰结构的复杂性                  │
│  F2:  加速度微校正密度     → 减速阶段的方向修正频率                │
│  F3:  Fitts' Law 偏差     → 完成时间与理论预测的偏离              │
│  F4:  急动度 RMS           → 轨迹平滑度                         │
│  F5:  生理震颤频带能量比   → 8-12 Hz 震颤信号                    │
│  F6:  轨迹曲率方差         → 方向变化的不均匀性                   │
│  F7:  时间结构异常度       → 采样间隔的周期性                     │
│                                                                │
│  键盘特征（2 维）                                                │
│  F8:  键盘事件密度         → 是否使用了键盘操作滑块                │
│  F9:  按键时间间隔熵       → 键盘操作的随机性                     │
│                                                                │
│  时序特征（2 维）                                                │
│  F10: 反应时间             → 页面加载到首次 mousedown 的延迟       │
│  F11: 失败重试次数         → 非零重试是机器人的弱信号               │
│                                                                │
│  环境特征（2 维）                                                │
│  F12: 自动化标志检测       → webdriver / headless / CDP 标志     │
│  F13: 环境一致性评分       → 屏幕/浏览器/时区参数的一致性          │
│                                                                │
│  上下文特征（1 维）                                              │
│  F14: 悬停前置时间         → mousedown 前鼠标在滑块上的悬停时长     │
└───────────────────────────────────────────────────────────────┘

def compute_keyboard_event_density(key_events: list[dict], 
                                   total_duration: float) -> float:
    """
    键盘事件密度 = 键盘事件数量 / 总时长（秒）
    
    设计决策：为什么键盘事件密度是反自动化特征？
    大多数真人操作滑块时不会使用键盘（Tab 导航到滑块）。
    自动化工具（Selenium）经常通过 Tab 键聚焦到滑块元素，
    然后使用 ActionChains 进行拖动。键盘事件密度 > 0 是
    自动化的可疑信号。
    
    但注意：残障用户可能通过键盘操作，且当前实现监听的是
    全局 document 键盘事件，用户在用户名/密码输入框的打字
    也可能被记录。因此键盘事件密度高不应该直接判定为机器人，
    而是作为"需要进一步验证"的信号，并建议结合焦点事件过滤。
    """
    if total_duration <= 0:
        return 0.0
    
    return len(key_events) / (total_duration / 1000.0)

def compute_reaction_time(
    page_load_time: float,     # 页面加载完成的时间戳
    first_mousedown_time: float  # 第一次 mousedown 的时间戳
) -> float:
    """
    反应时间 = 页面加载到首次 mousedown 的延迟（毫秒）
    
    设计决策：为什么反应时间是特征？
    人类在看到验证码后，通常需要一定的视觉感知和运动规划时间。
    经验上，从页面加载到首次交互的反应时间常在数百毫秒到数秒
    之间，具体分布与用户习惯、页面复杂度、验证码位置有关。
    
    机器人可以瞬间响应（< 100ms），或者因为脚本延迟而响应极慢（> 5s）。
    反应时间落在统计上的极端区间是可疑的，但阈值必须根据实际
    数据分布标定，不能照搬固定区间。
    
    这个特征在 Fitts' Law 偏差中没有覆盖，因为 Fitts' Law 只关注
    拖动阶段的时间，不包含拖动前的认知阶段。
    """
    if page_load_time <= 0 or first_mousedown_time <= 0:
        return 0.0
    
    return first_mousedown_time - page_load_time

def compute_environment_consistency(env: dict) -> float:
    """
    环境一致性评分：检测浏览器环境参数之间的自洽性
    
    原理：自动化工具的浏览器环境参数经常存在不一致。
    例如：userAgent 声称是 Chrome 120，但 navigator.plugins 为空
    （Chrome 应该有 PDF Viewer 等内置插件）。
    
    返回 0-1 的评分，0 = 完全一致，1 = 高度不一致（可疑）
    
    设计决策：为什么用规则而非机器学习？
    环境一致性检查是确定性的——如果 userAgent 声称是 Chrome 但
    缺少 Chrome 特有属性，这一定是假的。机器学习模型需要训练数据，
    但环境检测规则只需要浏览器知识。
    """
    score = 0.0
    checks = 0
    
    ua = env.get('userAgent', '').lower()
    
    # 检查 1：Chrome 必须有 navigator.plugins
    if 'chrome' in ua and 'edg' not in ua:
        checks += 1
        plugins = env.get('plugins', [])
        if len(plugins) == 0:
            score += 1.0  # Chrome 必然有内置插件
    
    # 检查 2：webdriver 标志
    checks += 1
    if env.get('webdriver'):
        score += 1.0  # 明确的自动化标志
    
    # 检查 3：屏幕分辨率与 window.devicePixelRatio 的一致性
    checks += 1
    screen_w = env.get('screenWidth', 0)
    screen_h = env.get('screenHeight', 0)
    ratio = env.get('pixelRatio', 1)
    if screen_w > 0 and screen_h > 0:
        # 检测不可能的组合：4K 屏幕 + 1x 像素比（无头浏览器常见）
        if screen_w > 3000 and ratio == 1.0:
            score += 0.5
        # 检测不可能的组合：极小屏幕 + 3x 像素比
        if screen_w < 500 and ratio > 2.0:
            score += 0.5
    
    # 检查 4：hardwareConcurrency
    checks += 1
    hw = env.get('hardwareConcurrency', 0)
    if hw == 0:
        score += 0.5  # 自动化工具可能不暴露硬件信息
    elif hw > 128:
        score += 0.3  # 异常高的核心数（服务器环境）
    
    # 检查 5：WebGL 信息
    checks += 1
    webgl_vendor = env.get('webglVendor', '')
    webgl_renderer = env.get('webglRenderer', '')
    if webgl_vendor == 'Google Inc.' and 'swiftshader' in webgl_renderer.lower():
        score += 0.8  # SwiftShader → 无头 Chrome 的标志
    
    return score / max(checks, 1)

# feature_extractor.py —— 14 维特征提取器
# 依赖：numpy, scipy

import numpy as np
from dataclasses import dataclass
from typing import List, Tuple, Dict, Optional

@dataclass
class FullFeatureVector:
    """14 维完整特征向量"""
    # 轨迹特征（F1-F7）
    velocity_entropy: float = 0.0
    acceleration_correction_density: float = 0.0
    fitts_deviation: float = 0.0
    jerk_rms: float = 0.0
    tremor_band_energy: float = 0.0
    curvature_variance: float = 0.0
    temporal_anomaly: float = 0.0
    
    # 键盘特征（F8-F9）
    keyboard_event_density: float = 0.0
    key_interval_entropy: float = 0.0
    
    # 时序特征（F10-F11）
    reaction_time: float = 0.0
    retry_count: int = 0
    
    # 环境特征（F12-F13）
    automation_flag: float = 0.0
    environment_consistency: float = 0.0
    
    # 上下文特征（F14）
    hover_duration: float = 0.0
    
    def to_array(self) -> np.ndarray:
        """转换为 numpy 数组（用于模型推理）"""
        return np.array([
            self.velocity_entropy,
            self.acceleration_correction_density,
            self.fitts_deviation,
            self.jerk_rms,
            self.tremor_band_energy,
            self.curvature_variance,
            self.temporal_anomaly,
            self.keyboard_event_density,
            self.key_interval_entropy,
            self.reaction_time,
            self.retry_count,
            self.automation_flag,
            self.environment_consistency,
            self.hover_duration,
        ])


class FullFeatureExtractor:
    """
    全维度特征提取器
    
    整合前文 TrajectoryAnalyzer 的 7 维轨迹特征 +
    新增 7 维（键盘/时序/环境/上下文）
    """
    
    def __init__(self, target_distance: float, target_width: float = 40.0):
        self.target_distance = target_distance
        self.target_width = target_width
        # 复用前文的 TrajectoryAnalyzer 提取轨迹特征
        from trajectory_analyzer import TrajectoryAnalyzer
        self._trajectory_analyzer = TrajectoryAnalyzer(
            target_distance, target_width
        )
    
    def extract(self, payload: dict) -> FullFeatureVector:
        """
        从完整 payload 中提取 14 维特征向量
        
        payload 结构（来自前端 BehaviorCollector.getPayload()）：
        {
            trajectory: [{t, x, y}, ...],
            keyEvents: [{t, type, key, code}, ...],
            timing: {totalDuration, pointCount, retryCount},
            environment: {...},
            context: {preDragMoves: [...], pageScrollY, viewportHeight},
            meta: {version, timestamp},
        }
        """
        features = FullFeatureVector()
        
        # === 轨迹特征（F1-F7） ===
        trajectory = [(p['t'], p['x'], p['y']) 
                      for p in payload.get('trajectory', [])]
        
        if len(trajectory) >= 5:
            traj_features = self._trajectory_analyzer.extract_features(trajectory)
            features.velocity_entropy = traj_features.velocity_entropy
            features.acceleration_correction_density = traj_features.acceleration_correction_density
            features.fitts_deviation = traj_features.fitts_deviation
            features.jerk_rms = traj_features.jerk_rms
            features.tremor_band_energy = traj_features.tremor_band_energy
            features.curvature_variance = traj_features.curvature_variance
            features.temporal_anomaly = traj_features.temporal_anomaly
        
        # === 键盘特征（F8-F9） ===
        key_events = payload.get('keyEvents', [])
        total_duration = payload.get('timing', {}).get('totalDuration', 0)
        
        features.keyboard_event_density = compute_keyboard_event_density(
            key_events, total_duration
        )
        features.key_interval_entropy = compute_key_interval_entropy(key_events)
        
        # === 时序特征（F10-F11） ===
        features.reaction_time = compute_reaction_time(
            payload.get('meta', {}).get('pageLoadTime', 0),
            trajectory[0][0] if trajectory else 0
        )
        features.retry_count = payload.get('timing', {}).get('retryCount', 0)
        
        # === 环境特征（F12-F13） ===
        env = payload.get('environment', {})
        features.automation_flag = 1.0 if env.get('webdriver') else 0.0
        features.environment_consistency = compute_environment_consistency(env)
        
        # === 上下文特征（F14） ===
        pre_drag = payload.get('context', {}).get('preDragMoves', [])
        drag_start_time = payload.get('timing', {}).get('dragStartTime', 0)
        features.hover_duration = compute_hover_duration(pre_drag, drag_start_time)
        
        return features


def compute_key_interval_entropy(key_events: list[dict]) -> float:
    """键盘操作间隔的熵"""
    if len(key_events) < 2:
        return 0.0
    
    intervals = []
    for i in range(1, len(key_events)):
        dt = key_events[i]['t'] - key_events[i-1]['t']
        if dt > 0:
            intervals.append(dt)
    
    if not intervals:
        return 0.0
    
    intervals = np.array(intervals)
    counts, _ = np.histogram(intervals, bins=min(10, len(intervals)))
    probs = counts / counts.sum()
    probs = probs[probs > 0]
    entropy = -np.sum(probs * np.log2(probs))
    max_entropy = np.log2(len(probs)) if len(probs) > 0 else 1.0
    
    return entropy / max_entropy if max_entropy > 0 else 0.0


def compute_hover_duration(pre_drag_moves: list[dict],
                          drag_start_time: float = 0) -> float:
    """
    计算 mousedown 前鼠标在滑块上的悬停时长
    
    原理：真人在按下鼠标前，通常会有一个短暂的悬停（视觉确认）。
    这个悬停时长通常在 200-800ms（经验值，实际分布与交互设计有关）。
    机器人可能直接按下（0ms）或悬停过久（脚本等待）。
    """
    if not pre_drag_moves or drag_start_time <= 0:
        return 0.0
    
    # 最后一个 pre-drag 移动事件到 mousedown 的时间差
    return drag_start_time - pre_drag_moves[-1]['t']

# model_comparison.py —— 四种模型的对比实验

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, IsolationForest
from sklearn.metrics import roc_auc_score, f1_score, classification_report
import time
import pickle

class RuleBasedDetector:
    """
    方法一：规则引擎（作为 Baseline）
    
    设计决策：为什么规则引擎是 Baseline？
    规则引擎不需要训练数据，可解释性最强，且不受数据分布漂移影响。
    如果规则引擎的 AUC 已经足够高，ML 模型的额外复杂度就不值得。
    但规则引擎的局限在于：无法自动学习特征间的非线性交互。
    """
    
    def __init__(self, thresholds: dict = None):
        self.thresholds = thresholds or {
            'velocity_entropy_max': 0.45,          # 速度熵 < 0.45 → 机器人
            'acceleration_density_min': 2.0,       # 微校正密度 < 2.0 → 机器人
            'fitts_deviation_max': 0.55,           # Fitts 偏差 > 0.55 → 机器人
            'tremor_energy_min': 0.002,            # 震颤能量 < 0.002 → 机器人
            'automation_flag': 0.5,                # webdriver 标志
            'environment_consistency_max': 0.3,    # 环境一致性 > 0.3 → 机器人
        }
    
    def predict(self, features: FullFeatureVector) -> float:
        """
        规则引擎评分
        
        设计决策：为什么用"触发规则数 / 总规则数"作为分数？
        简单的"任一规则触发 → 判定机器人"会产生大量误判。
        触发规则的比例反映了"机器人特征的强度"——触发 4/6 规则的
        比触发 1/6 规则的更像机器人。
        """
        score = 0.0
        triggers = 0
        total_rules = 6
        
        if features.velocity_entropy < self.thresholds['velocity_entropy_max']:
            triggers += 1
        if features.acceleration_correction_density < self.thresholds['acceleration_density_min']:
            triggers += 1
        if features.fitts_deviation > self.thresholds['fitts_deviation_max']:
            triggers += 1
        if features.tremor_band_energy < self.thresholds['tremor_energy_min']:
            triggers += 1
        if features.automation_flag > self.thresholds['automation_flag']:
            triggers += 1
        if features.environment_consistency > self.thresholds['environment_consistency_max']:
            triggers += 1
        
        return triggers / total_rules


class LogisticRegressionDetector:
    """
    方法二：逻辑回归
    
    优势：可解释性强（每个特征的权重清晰），训练快，推理快
    劣势：只能学习线性决策边界
    """
    
    def __init__(self):
        self.model = LogisticRegression(
            C=1.0,
            max_iter=1000,
            class_weight='balanced'  # 处理类别不平衡
        )
        self._fitted = False
    
    def fit(self, X: np.ndarray, y: np.ndarray):
        self.model.fit(X, y)
        self._fitted = True
    
    def predict_proba(self, X: np.ndarray) -> np.ndarray:
        return self.model.predict_proba(X)[:, 1]  # 类别 1（机器人）的概率


class RandomForestDetector:
    """
    方法三：随机森林
    
    优势：能学习非线性特征交互，对异常值鲁棒
    劣势：模型较大（~1MB），推理延迟较高
    """
    
    def __init__(self):
        self.model = RandomForestClassifier(
            n_estimators=100,
            max_depth=10,
            min_samples_leaf=10,
            class_weight='balanced',
            random_state=42,
            n_jobs=-1
        )
        self._fitted = False
    
    def fit(self, X: np.ndarray, y: np.ndarray):
        self.model.fit(X, y)
        self._fitted = True
    
    def predict_proba(self, X: np.ndarray) -> np.ndarray:
        return self.model.predict_proba(X)[:, 1]


class IsolationForestDetector:
    """
    方法四：孤立森林（无监督）
    
    优势：不需要标注数据，天然适合异常检测
    劣势：需要调整 contamination 参数，对特征分布敏感
    
    设计决策：为什么孤立森林适合验证码场景？
    验证码的"机器人"样本是少数且异常——孤立森林的核心假设
    是"异常点是少数且容易被隔离的"。这完美匹配验证码的
    数据分布：真人占多数（正常），机器人占少数（异常）。
    
    无监督学习还有一个关键优势：不需要标注数据，可以
    直接在生产环境中部署，随着数据积累自动适应。
    """
    
    def __init__(self, contamination: float = 0.1):
        self.model = IsolationForest(
            n_estimators=100,
            contamination=contamination,
            random_state=42,
            n_jobs=-1
        )
        self._fitted = False
    
    def fit(self, X: np.ndarray):
        self.model.fit(X)
        self._fitted = True
    
    def predict_proba(self, X: np.ndarray) -> np.ndarray:
        """
        孤立森林返回 -1（异常）或 1（正常）。
        使用 decision_function 转换为概率。
        """
        scores = self.model.decision_function(X)
        # Sigmoid 转换为概率
        return 1.0 / (1.0 + np.exp(scores))

# 运行对比实验
def run_comparison():
    # 加载数据
    X_train, X_test, y_train, y_test = load_dataset()
    # X_train: (1400, 14), X_test: (600, 14)
    
    results = {}
    
    # 方法一：规则引擎
    rule_detector = RuleBasedDetector()
    start = time.time()
    y_pred_rule = np.array([
        rule_detector.predict(FullFeatureVector(*x)) 
        for x in X_test
    ])
    rule_time = time.time() - start
    results['rule_engine'] = {
        'auc': roc_auc_score(y_test, y_pred_rule),
        'f1': f1_score(y_test, y_pred_rule > 0.5),
        'latency_p50': rule_time / len(X_test) * 1000,
        'size': 0,  # 规则引擎无需存储模型
    }
    
    # 方法二：逻辑回归
    lr = LogisticRegressionDetector()
    lr.fit(X_train, y_train)
    start = time.time()
    y_pred_lr = lr.predict_proba(X_test)
    lr_time = time.time() - start
    results['logistic_regression'] = {
        'auc': roc_auc_score(y_test, y_pred_lr),
        'f1': f1_score(y_test, y_pred_lr > 0.5),
        'latency_p50': lr_time / len(X_test) * 1000,
        'size': len(pickle.dumps(lr.model)),
        'feature_importance': dict(zip(
            [f'F{i+1}' for i in range(14)],
            np.abs(lr.model.coef_[0])
        )),
    }
    
    # 方法三：随机森林
    rf = RandomForestDetector()
    rf.fit(X_train, y_train)
    start = time.time()
    y_pred_rf = rf.predict_proba(X_test)
    rf_time = time.time() - start
    results['random_forest'] = {
        'auc': roc_auc_score(y_test, y_pred_rf),
        'f1': f1_score(y_test, y_pred_rf > 0.5),
        'latency_p50': rf_time / len(X_test) * 1000,
        'size': len(pickle.dumps(rf.model)),
        'feature_importance': dict(zip(
            [f'F{i+1}' for i in range(14)],
            rf.model.feature_importances_
        )),
    }
    
    # 方法四：孤立森林（只用正常样本训练）
    X_normal = X_train[y_train == 0]  # 只使用真人样本
    iforest = IsolationForestDetector()
    iforest.fit(X_normal)
    start = time.time()
    y_pred_if = iforest.predict_proba(X_test)
    if_time = time.time() - start
    results['isolation_forest'] = {
        'auc': roc_auc_score(y_test, y_pred_if),
        'f1': f1_score(y_test, y_pred_if > 0.5),
        'latency_p50': if_time / len(X_test) * 1000,
        'size': len(pickle.dumps(iforest.model)),
    }
    
    return results

┌──────────────────────────────────────────────────────────────┐
│  模型选择决策流程                                              │
│                                                              │
│  Q1: 是否有标注数据？                                          │
│    ├── 否 → Q2: 是否了解机器人行为模式？                         │
│    │         ├── 是 → 规则引擎（快速启动）                        │
│    │         └── 否 → 孤立森林（无监督，自适应）                   │
│    │                                                          │
│    └── 是 → Q3: 标注数据量是否 > 1000？                          │
│              ├── 否 → 逻辑回归（小样本下泛化好）                    │
│              │                                              │
│              └── 是 → Q4: 推理延迟要求？                         │
│                        ├── < 0.1ms → 逻辑回归                  │
│                        ├── < 1ms   → 随机森林（推荐）            │
│                        └── 无要求  → XGBoost/LightGBM（最高精度） │
│                                                              │
└──────────────────────────────────────────────────────────────┘

# decision_engine.py —— 后端决策引擎

from dataclasses import dataclass
from enum import Enum
import time
import json

class Verdict(Enum):
    PASS = "pass"                # 通过
    CHALLENGE = "challenge"      # 需要额外验证（如短信验证码）
    REJECT = "reject"            # 拒绝
    SHADOW_BAN = "shadow_ban"    # 静默标记（不拒绝但记录，用于数据分析）

@dataclass
class DecisionContext:
    """决策上下文"""
    model_score: float           # 模型评分（0-1）
    retry_count: int             # 当前会话的失败重试次数
    user_credit_score: float     # 用户信用分（0-1，1 = 最高信用）
    session_duration: float      # 会话持续时间（秒）
    ip_risk_score: float         # IP 风险评分（0-1）
    device_fingerprint: str      # 设备指纹
    hour_of_day: int             # 当前小时（0-23）


class DecisionEngine:
    """
    后端决策引擎
    
    设计决策：为什么模型评分和业务决策分离？
    模型评分是"这个行为像不像机器人"（技术判断）。
    业务决策是"基于当前风险水位，是否应该拒绝"（业务判断）。
    
    两者的关注点不同：
    - 模型关注：特征分布、AUC、F1
    - 业务关注：通过率、误判率、用户体验、风控水位
    
    分离后，可以独立调整模型和决策策略。
    """
    
    # 分层阈值（基于业务风险偏好）
    THRESHOLDS = {
        'strict': {    # 严格模式（如支付场景）
            'pass': 0.30,
            'challenge': 0.55,
            'reject': 0.70,
        },
        'normal': {    # 正常模式（如登录场景）
            'pass': 0.40,
            'challenge': 0.65,
            'reject': 0.80,
        },
        'loose': {     # 宽松模式（如浏览场景）
            'pass': 0.55,
            'challenge': 0.75,
            'reject': 0.90,
        },
    }
    
    def __init__(self, mode: str = 'normal'):
        self.mode = mode
        self.thresholds = self.THRESHOLDS[mode]
    
    def decide(self, ctx: DecisionContext) -> tuple[Verdict, dict]:
        """
        综合决策
        
        设计决策：为什么阈值不是固定的？
        同一个模型分数 0.55，在不同场景下有不同的含义：
        - 支付场景：高度可疑，应该拒绝
        - 浏览场景：轻微可疑，可以通过
        
        分层阈值允许在不改变模型的情况下，独立调整业务策略。
        """
        score = ctx.model_score
        
        # 1. 基础模型评分判定
        if score <= self.thresholds['pass']:
            verdict = Verdict.PASS
        elif score <= self.thresholds['challenge']:
            verdict = Verdict.CHALLENGE
        elif score <= self.thresholds['reject']:
            verdict = Verdict.REJECT
        else:
            verdict = Verdict.REJECT
        
        # 2. 上下文调整
        # 规则 2.1：高信用用户提升通过阈值
        if ctx.user_credit_score > 0.8 and verdict == Verdict.CHALLENGE:
            verdict = Verdict.PASS
        
        # 规则 2.2：多次重试逐步收紧
        if ctx.retry_count >= 3:
            # 提升一个等级
            if verdict == Verdict.PASS:
                verdict = Verdict.CHALLENGE
            elif verdict == Verdict.CHALLENGE:
                verdict = Verdict.REJECT
        
        # 规则 2.3：IP 高风险 + 设备指纹异常 → 直接拒绝
        if ctx.ip_risk_score > 0.8 and verdict != Verdict.REJECT:
            verdict = Verdict.CHALLENGE
        
        # 3. 构建决策解释
        explanation = {
            'verdict': verdict.value,
            'model_score': round(score, 4),
            'thresholds': self.thresholds,
            'adjustments': self._get_adjustments(ctx),
            'timestamp': int(time.time()),
        }
        
        return verdict, explanation
    
    def _get_adjustments(self, ctx: DecisionContext) -> list[str]:
        """获取决策调整原因（用于日志和调试）"""
        adjustments = []
        if ctx.user_credit_score > 0.8:
            adjustments.append(f'high_credit_user({ctx.user_credit_score:.2f})')
        if ctx.retry_count >= 3:
            adjustments.append(f'high_retry_count({ctx.retry_count})')
        if ctx.ip_risk_score > 0.8:
            adjustments.append(f'high_ip_risk({ctx.ip_risk_score:.2f})')
        return adjustments

class ScoreCalibrator:
    """
    分数校准器：保持阈值的语义一致
    
    设计决策：为什么需要分数校准？
    模型在训练集上学习到的分数分布，与生产环境中的分布可能不同。
    例如：训练集中机器人占 50%，但生产环境中只占 5%。
    这会导致模型分数整体偏高或偏低，使固定阈值失效。
    
    校准方法：Platt Scaling（逻辑回归校准）
    将模型原始分数映射到真实概率。
    """
    
    def __init__(self, window_size: int = 10000):
        self.window_size = window_size
        self._scores = []  # 滑动窗口：最近 N 个分数
        self._calibrator = None
    
    def add_score(self, score: float, label: int = None):
        """添加分数到滑动窗口（label 为 None 表示未标注）"""
        self._scores.append((score, label))
        if len(self._scores) > self.window_size:
            self._scores.pop(0)
    
    def calibrate(self, score: float) -> float:
        """
        校准分数
        
        如果校准器未训练，返回原始分数
        """
        if self._calibrator is None:
            return score
        
        # Platt Scaling: P(y=1|score) = 1 / (1 + exp(A * score + B))
        calibrated = self._calibrator.predict_proba([[score]])[0][1]
        return calibrated
    
    def fit(self):
        """使用标注数据拟合校准器"""
        annotated = [(s, l) for s, l in self._scores if l is not None]
        if len(annotated) < 100:
            return  # 标注数据不足
        
        X = np.array([[s] for s, _ in annotated])
        y = np.array([l for _, l in annotated])
        
        from sklearn.linear_model import LogisticRegression
        self._calibrator = LogisticRegression()
        self._calibrator.fit(X, y)

class ABTestManager:
    """
    A/B 实验管理器
    
    设计决策：为什么用请求 ID 哈希而非用户 ID 分流？
    验证码场景中，用户在验证通过前还没有身份标识。
    使用请求 ID 哈希（或 session ID）可以保证：
    1. 同一会话内的多次重试使用同一个模型版本
    2. 不需要用户登录即可分流
    3. 分流比例精确可控
    """
    
    def __init__(self):
        self.experiments = {}
    
    def create_experiment(self, name: str, variants: dict, 
                          traffic_ratio: float = 0.1):
        """
        创建实验
        
        variants: {"control": model_v1, "treatment": model_v2}
        traffic_ratio: 实验流量比例（0.1 = 10%）
        """
        self.experiments[name] = {
            'variants': variants,
            'traffic_ratio': traffic_ratio,
            'results': {name: {'pass': 0, 'reject': 0, 'total': 0} 
                       for name in variants},
        }
    
    def get_variant(self, experiment_name: str, 
                    session_id: str) -> tuple[str, object]:
        """根据 session_id 哈希决定使用哪个变体"""
        exp = self.experiments[experiment_name]
        
        # 哈希分流
        hash_val = hash(session_id) % 10000
        if hash_val >= exp['traffic_ratio'] * 10000:
            return 'control', exp['variants']['control']
        
        # 在实验组内均匀分配
        treatment_variants = [
            (k, v) for k, v in exp['variants'].items() 
            if k != 'control'
        ]
        idx = hash_val % len(treatment_variants)
        return treatment_variants[idx]
    
    def record_result(self, experiment_name: str, variant: str, 
                      passed: bool):
        """记录实验结果"""
        exp = self.experiments[experiment_name]
        exp['results'][variant]['total'] += 1
        if passed:
            exp['results'][variant]['pass'] += 1
        else:
            exp['results'][variant]['reject'] += 1

// 原始代码（攻击者可以阅读）
function isWebDriverPresent() {
    return navigator.webdriver || false;
}

// 虚拟机保护后的代码（攻击者需要逆向 VM 才能理解）
// 实际部署时由构建工具自动生成；下面是一个可运行的简化示意。
var _vm = {
    'stack': [],
    'pc': 0,
    'code': [
        /* 0 */ {op: 'LOAD_GLOBAL', arg: 'navigator'},
        /* 1 */ {op: 'GET_PROP', arg: '_decode_0'}, // 运行时解码为 "webdriver"
        /* 2 */ {op: 'DUP'},
        /* 3 */ {op: 'JUMP_IF_TRUE', arg: 7},
        /* 4 */ {op: 'POP'},
        /* 5 */ {op: 'LOAD_CONST', arg: false},
        /* 6 */ {op: 'RETURN'},
        /* 7 */ {op: 'RETURN'},
    ],
    'run': function() {
        while (this.pc < this.code.length) {
            var inst = this.code[this.pc++];
            switch (inst.op) {
                case 'LOAD_GLOBAL': 
                    this.stack.push(window[inst.arg]); break;
                case 'GET_PROP':
                    this.stack.push(this.stack.pop()[this._decode(inst.arg)]); break;
                case 'DUP':
                    this.stack.push(this.stack[this.stack.length - 1]); break;
                case 'JUMP_IF_TRUE':
                    if (this.stack.pop()) this.pc = inst.arg; break;
                case 'POP':
                    this.stack.pop(); break;
                case 'LOAD_CONST':
                    this.stack.push(inst.arg); break;
                case 'RETURN':
                    return this.stack.pop();
            }
        }
    },
    '_decode': function(token) {
        // 简化的运行时字符串解码表；生产环境应使用更复杂的混淆/加密
        var table = {
            '_decode_0': 'webdriver'
        };
        return table[token] || token;
    }
};

# 后端环境指纹校验
ENVIRONMENT_CHECKS = {
    # 检查 1：WebDriver 标志
    'webdriver': lambda env: env.get('webdriver', False),
    
    # 检查 2：Chrome DevTools Protocol 运行时
    'cdp_runtime': lambda env: (
        env.get('chrome', {}).get('runtime') is True and
        'Headless' in env.get('userAgent', '')
    ),
    
    # 检查 3：navigator.plugins 数量
    # 普通 Chrome 通常有少量内置插件（如 PDF Viewer），数量随版本变化。
    # 无头 Chrome 常将 plugins 置空或数量极少，但这不是绝对规则。
    'plugins_count': lambda env: len(env.get('plugins', [])) < 2,
    
    # 检查 4：window.chrome.loadTimes（已废弃）
    # loadTimes 在较新 Chrome 中已被移除，正常浏览器也可能返回 undefined。
    # 该检查仅作为历史兼容性参考，不建议作为核心判定依据。
    'load_times': lambda env: (
        env.get('chrome', {}).get('loadTimes') is not None and
        len(env.get('chrome', {}).get('loadTimes', {})) == 0
    ),
    
    # 检查 5：WebGL 渲染器
    # SwiftShader → 软件渲染（无头模式）
    'swiftshader': lambda env: 'swiftshader' in (
        env.get('webglRenderer', '') or ''
    ).lower(),
    
    # 检查 6：屏幕分辨率异常
    'screen_anomaly': lambda env: (
        env.get('screenWidth', 0) == 0 or
        env.get('screenHeight', 0) == 0
    ),
    
    # 检查 7：通知权限（无头 Chrome 不支持）
    # 注意：当前 collectEnvironment() 未采集 notificationPermission，
    # 若要用此检查，需先在前端补充对应字段。
    'notification_permission': lambda env: (
        env.get('notificationPermission') == 'denied' and
        'Headless' in env.get('userAgent', '')
    ),
}

# 多样性校验：即使轨迹特征正常，其他维度也可能暴露机器人
def diversity_check(features: FullFeatureVector) -> dict:
    """
    多维度交叉校验
    
    原理：攻击者可能通过 GAN 伪造了完美的轨迹（F1-F7 正常），
    但无法同时伪造键盘事件密度（F8）、环境一致性（F13）、
    反应时间（F10）等额外维度。
    """
    issues = []
    
    # 轨迹正常 + 键盘密度异常 = 机器人（自动化工具）
    if (features.velocity_entropy > 0.6 and  # 轨迹看起来像人
        features.keyboard_event_density > 0.5):  # 但键盘操作异常多
        issues.append('high_keyboard_activity_with_human_trajectory')
    
    # 轨迹正常 + 环境异常 = 机器人（高级伪造）
    if (features.velocity_entropy > 0.6 and
        features.environment_consistency > 0.5):
        issues.append('human_trajectory_in_automated_environment')
    
    # 轨迹正常 + 反应时间异常 = 机器人（脚本延迟）
    if (features.velocity_entropy > 0.6 and
        (features.reaction_time < 100 or features.reaction_time > 5000)):
        issues.append('human_trajectory_with_abnormal_reaction_time')
    
    return {
        'issues': issues,
        'is_diverse_anomaly': len(issues) > 0,
    }

┌─────────────────────────────────────────────────────────────────────┐
│                        行为验证码全链路架构                              │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  第一层：前端埋点（Browser）                                      │  │
│  │  BehaviorCollector: 轨迹 + 键盘 + 环境 + 时序 + 上下文            │  │
│  │  反篡改: 代码混淆 + 完整性校验 + 事件真实性检测                     │  │
│  └────────────────────────────┬──────────────────────────────────┘  │
│                               │ HTTPS POST /verify                  │
│                               ▼                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  第二层：特征工程（Server）                                        │  │
│  │  FullFeatureExtractor: 14 维特征向量                              │  │
│  │  轨迹(7) + 键盘(2) + 时序(2) + 环境(2) + 上下文(1)                │  │
│  └────────────────────────────┬──────────────────────────────────┘  │
│                               │ (14,) numpy array                   │
│                               ▼                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  第三层：模型推理（Server）                                        │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────────┐   │  │
│  │  │ 规则引擎  │  │ 逻辑回归  │  │ 随机森林  │  │  孤立森林     │   │  │
│  │  │ (Baseline)│  │ (低延迟)  │  │ (推荐)    │  │  (无监督)    │   │  │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────────┘   │  │
│  │  A/B 实验框架: 分流 → 推理 → 记录结果                            │  │
│  └────────────────────────────┬──────────────────────────────────┘  │
│                               │ model_score (0-1)                    │
│                               ▼                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  第四层：决策引擎（Server）                                        │  │
│  │  DecisionEngine: 分层阈值 + 上下文调整 + 分数校准                  │  │
│  │  Verdict: PASS / CHALLENGE / REJECT / SHADOW_BAN                │  │
│  └────────────────────────────┬──────────────────────────────────┘  │
│                               │ verdict + explanation                │
│                               ▼                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │  第五层：数据反馈（Server）                                        │  │
│  │  日志记录 → 标注回流 → 模型更新 → 分数校准                         │  │
│  └───────────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────────┘