第16章：漏洞挖掘与利用生成

   输入种子库
       ↓
   ┌─────────────┐
   │  LLM语义    │ ← 程序源码/二进制
   │  理解模块    │
   └─────────────┘
       ↓
   ┌─────────────┐
   │ 智能变异器  │ ← 覆盖率反馈
   └─────────────┘
       ↓
   ┌─────────────┐
   │ 约束求解器  │ ← 路径约束
   └─────────────┘
       ↓
   目标程序执行
       ↓
   崩溃检测与分类

输入：HTTP请求格式
LLM理解：

- 请求行格式：METHOD URI VERSION
- 头部字段语义
- 特殊字符处理规则

智能变异策略：

1. 结构保持变异：
   - 超长URI路径：GET /{"A"*8192}/index.html HTTP/1.1
   - 畸形编码序列：%00%01%fe%ff混合正常字符
   - 头部注入：Host: target.com\r\nX-Injected: malicious

2. 语义违反变异：
   - 矛盾头部：Content-Length: 100 配合空body
   - 协议降级：HTTP/0.9 风格请求混入HTTP/1.1特性
   - 方法混淆：GET请求带POST body

3. 时序攻击变异：
   - 分片发送：将请求分成多个TCP包
   - 管道化混乱：Pipeline请求的顺序扰乱
   - Keep-Alive滥用：大量持久连接耗尽资源

PDF文件结构理解：
├─ Header (%PDF-1.x)
├─ Body (Objects)
│  ├─ Stream对象（可能包含JavaScript）
│  └─ 引用关系图
├─ Xref表
└─ Trailer

LLM针对性变异：

1. 嵌入恶意JavaScript在Stream中
2. 构造循环引用导致解析器死循环  
3. Xref表项指向越界偏移
4. 多个%%EOF标记混淆解析器

-- 基础输入
SELECT * FROM users WHERE id = ?

-- LLM生成的变异
1' OR '1'='1    -- 认证绕过
1'; DROP TABLE users--    -- 破坏性注入
1 UNION SELECT password FROM admin--    -- 数据窃取
SLEEP(10)--    -- 时间盲注探测

崩溃堆栈示例：
#0  0x00007f8d9c6a5428 in __memcpy_avx_unaligned () 
#1  0x0000000000401234 in process_input (buf=0x7ffd6b8a5000)
#2  0x0000000000401567 in handle_request ()
#3  0x0000000000401890 in main ()

LLM提取的指纹：

- 崩溃函数：memcpy（内存操作类）
- 调用链特征：main→handle_request→process_input
- 崩溃类型推断：可能的缓冲区溢出

漏洞分类决策树：
├─ 内存错误
│  ├─ 缓冲区溢出（SIGSEGV in strcpy/memcpy）
│  ├─ Use-After-Free（访问已释放内存）
│  ├─ Double-Free（重复释放）
│  └─ 内存泄露（资源未释放）
├─ 逻辑错误  
│  ├─ 整数溢出（算术运算异常）
│  ├─ 类型混淆（类型转换错误）
│  └─ 条件竞争（多线程访问）
└─ 控制流错误
   ├─ 空指针解引用
   └─ 非法指令（代码注入成功）

评分矩阵：
┌────────────────┬────────┬────────┬────────┐
│ 漏洞类型        │ 可控性  │ 影响力  │ 利用难度│
├────────────────┼────────┼────────┼────────┤
│ 栈溢出         │ 高     │ 高     │ 中     │
│ 堆溢出         │ 中     │ 高     │ 高     │
│ Use-After-Free │ 高     │ 高     │ 中     │
│ 格式化字符串    │ 高     │ 高     │ 低     │
│ 整数溢出       │ 低     │ 中     │ 高     │
└────────────────┴────────┴────────┴────────┘

可利用性得分计算：
Score = α·可控性 + β·影响力 - γ·利用难度

def smart_dedup(crashes):
    clusters = []
    for crash in crashes:
        # 提取语义特征
        features = llm_extract_features(crash)
        # 计算与现有类簇的相似度
        max_sim = 0
        best_cluster = None
        for cluster in clusters:
            sim = semantic_similarity(features, cluster.centroid)
            if sim > max_sim:
                max_sim = sim
                best_cluster = cluster

        # 相似度阈值判断
        if max_sim > 0.85:
            best_cluster.add(crash)
        else:
            # 创建新类簇
            clusters.append(new_cluster(crash))
    return clusters

// 传统污点分析可能遗漏的隐式流
if (tainted_input > 100) {
    safe_var = 1;  // safe_var实际被污染
}

// LLM识别的高级隐式流模式
// 1. 通过异常传播污点
try {
    array[tainted_index];  // 可能越界
} catch (OutOfBoundsException e) {
    leaked_bit = 1;  // 信息泄露
}

// 2. 通过时间侧信道
if (tainted_data == secret) {
    complex_computation();  // 时间差异泄露信息
}

// 3. 通过内存布局
struct_array[tainted_index].field = value;  // 缓存行泄露

class ContextAwareTaint:
    def __init__(self):
        self.taint_map = {}
        self.context_stack = []

    def propagate(self, src, dst, context):
        # LLM判断传播类型
        prop_type = llm.classify_propagation(src, dst, context)

        if prop_type == "DIRECT":
            self.taint_map[dst] = self.taint_map[src]
        elif prop_type == "SANITIZED":
            # 识别净化函数
            self.taint_map[dst] = CLEAN
        elif prop_type == "AMPLIFIED":
            # 污点放大（如格式化字符串）
            self.taint_map[dst] = CRITICAL
        elif prop_type == "CONDITIONAL":
            # 条件传播
            self.taint_map[dst] = self.eval_condition(src, context)

状态空间探索决策树
    │
    ├─ 具体执行（快速探索）
    │     ↓
    │   复杂约束检测
    │   ├─ 非线性约束？
    │   ├─ 加密函数？
    │   └─ 哈希校验？
    │     ↓ 是
    └─ 符号执行（精确求解）
          ↓
       约束求解器选择
       ├─ Z3（通用SMT）
       ├─ CVC4（字符串）
       └─ Boolector（位向量）
          ↓
       新输入生成

class HybridExecutor:
    def __init__(self):
        self.concrete_state = ConcreteState()
        self.symbolic_state = SymbolicState()
        self.llm_advisor = LLMAdvisor()

    def execute_instruction(self, inst):
        # LLM评估指令复杂度
        complexity = self.llm_advisor.assess_complexity(inst)

        if complexity.score < 0.3:
            # 简单指令，具体执行
            return self.concrete_execute(inst)
        elif complexity.score > 0.7:
            # 复杂约束，符号执行
            return self.symbolic_execute(inst)
        else:
            # 混合策略
            concrete_result = self.concrete_execute(inst)
            if self.is_interesting_path(concrete_result):
                # 回溯并符号执行
                self.symbolic_state.sync(self.concrete_state)
                return self.symbolic_execute(inst)
            return concrete_result

    def is_interesting_path(self, result):
        # LLM判断路径价值
        features = {
            'new_coverage': result.coverage_delta,
            'proximity_to_sink': result.sink_distance,
            'constraint_complexity': result.constraint_count,
            'loop_bound': result.loop_iterations
        }
        return self.llm_advisor.evaluate_path(features) > 0.5

// 原始代码
void process(char* input, int len) {
    char hash[32];
    compute_md5(input, hash);  // 复杂，符号执行困难

    if (memcmp(hash, expected, 32) == 0) {
        if (len > BUFFER_SIZE) {  // 简单约束
            overflow_here();      // 漏洞点
        }
    }
}

// LLM指导的执行策略
// 1. 对MD5计算使用具体值
// 2. 对长度检查使用符号值
// 3. 混合约束求解

泄露策略选择：

1. 部分覆写返回地址（利用部分地址不随机化）
2. 格式化字符串泄露栈地址
3. UAF读取堆元数据

目标：在特定地址放置特定对象
LLM生成的操作序列：

1. 分配填充块，占据空洞
2. 触发合并，创建大块
3. 精确分配，放置目标对象
4. 触发漏洞，实现利用

补丁分析流程：

1. 代码差异提取
2. 语义变化理解
3. 安全影响评估
4. 绕过可能性分析

// 漏洞模式
function withdraw(uint amount) {
    require(balances[msg.sender] >= amount);
    msg.sender.call.value(amount)("");  // 外部调用
    balances[msg.sender] -= amount;     // 状态更新在后
}

// LLM生成的攻击合约
contract Attacker {
    function attack() {
        victim.withdraw(1 ether);
    }

    fallback() external payable {
        if (victim.balance > 0) {
            victim.withdraw(1 ether);  // 重入
        }
    }
}

// 漏洞：乘法后除法可能溢出
uint result = (a * b) / c;

// LLM识别的攻击向量
// 当 a * b > 2^256 时发生溢出

攻击步骤：

1. 闪电贷借入大量代币A
2. 在DEX中大量卖出A，压低价格
3. 以被操纵的价格在目标协议中执行操作
4. 买回代币A，恢复价格
5. 归还闪电贷，保留利润

// 权限检查遗漏
function criticalFunction() public {
    // 缺少 require(msg.sender == owner)
    // LLM识别：任何人都可调用
}

Gadget类型树：
├─ 数据移动
│  ├─ 寄存器间移动 (mov rax, rbx)
│  ├─ 内存加载 (mov rax, [rbx])
│  └─ 内存存储 (mov [rax], rbx)
├─ 算术运算
│  ├─ 加法族 (add, inc)
│  └─ 逻辑运算 (xor, and)
├─ 控制流
│  ├─ 间接跳转 (jmp rax)
│  └─ 条件分支 (jz, jnz)
└─ 系统调用
   └─ syscall/int 0x80

minimize: Σ cost(gadget_i)
subject to:

  - 状态转换约束：state_i+1 = apply(gadget_i, state_i)
  - 目标约束：final_state ⊨ goal
  - 可达性约束：gadget_i ∈ available_gadgets
  - 栈平衡约束：Σ stack_delta_i = 0

def generate_rop_chain(goal, gadgets):
    solver = z3.Solver()

    # 状态变量
    states = [z3.BitVec(f'state_{i}', 64) for i in range(MAX_LEN)]

    # Gadget选择变量
    choices = [z3.Int(f'choice_{i}') for i in range(MAX_LEN)]

    # 添加转换约束
    for i in range(MAX_LEN-1):
        for j, gadget in enumerate(gadgets):
            solver.add(z3.Implies(
                choices[i] == j,
                states[i+1] == gadget.apply(states[i])
            ))

    # 目标约束
    solver.add(states[-1] == goal)

    if solver.check() == z3.sat:
        return extract_chain(solver.model())

x86_64 ←→ ARM64 映射：

- pop rdi ←→ ldr x0, [sp], #8
- call rax ←→ blr x0
- syscall ←→ svc #0

第一阶段：信息泄露
├─ 触发内存泄露漏洞
├─ 读取代码段
└─ 动态发现gadgets

第二阶段：链构造
├─ 实时分析gadgets
├─ 构造ROP链
└─ 触发执行

竞态条件检测：

1. 识别共享资源访问
2. 分析锁机制完整性
3. 构造并发触发序列

状态机形式化：
M = (S, Σ, δ, s₀, F)

- S: 状态集合
- Σ: 输入符号集
- δ: 转换函数
- s₀: 初始状态
- F: 终止状态集

漏洞模式：

- 未预期的状态转换
- 状态回退攻击
- 状态去同步

发现漏洞
    ↓
风险评估（CVSS评分）
    ↓
┌─────────────┬─────────────┐
│  低/中危     │    高/严重   │
│     ↓       │      ↓      │
│  公开披露    │  私密通知   │
│  (90天)     │   厂商      │
└─────────────┴─────────────┘