翻译

本文另有 英文版本。

乱七八糟的考试终于结束了，这次是时隔半年重新回来和 AAA 的队友们一起打比赛，又回归了熬夜的生活。这次比赛 6 个 Reverse 做出 5 个，剩下的一个 RL_Env 貌似是个机器学习题，真不愧是自由而无用的灵魂，我甚至都没有看懂题目在做什么。

stream

Rust 题目，还好有符号，拖到 IDA 里打开，std::rt::lang_start_internal 的第一个参数是 Rust 里的主函数。

 1
 2
 3
 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

do
{
    v5 = v1;
    v6 = v2 % v1;
    *((_BYTE *)&v13 + (v4 & 0x1F)) = *(_BYTE *)(v3 + v6);
    *(_OWORD *)&v9[16] = v14;
    *(_OWORD *)v9 = v13;
    rand_chacha::guts::init_chacha::ha09fa0e953c784d5(v19, v9, "", 8LL);
    *(_OWORD *)&v9[40] = v20;
    *(_OWORD *)&v9[24] = v19[1];
    *(_OWORD *)&v9[8] = v19[0];
    v15 = *(_OWORD *)v9;
    v16 = *(_OWORD *)&v9[16];
    v17 = *(_OWORD *)&v9[32];
    v18 = *((_QWORD *)&v20 + 1);
    v21 = 64LL;
    v22[15] = 0LL;
    v22[14] = 0LL;
    v22[13] = 0LL;
    v22[12] = 0LL;
    v22[11] = 0LL;
    v22[10] = 0LL;
    v22[9] = 0LL;
    v22[8] = 0LL;
    v22[7] = 0LL;
    v22[6] = 0LL;
    v22[5] = 0LL;
    v22[4] = 0LL;
    v22[3] = 0LL;
    v22[2] = 0LL;
    v22[1] = 0LL;
    v22[0] = 0LL;
    v24 = *((_QWORD *)&v20 + 1);
    v23[2] = *(_OWORD *)&v9[32];
    v23[1] = *(_OWORD *)&v9[16];
    v23[0] = *(_OWORD *)v9;
    rand_chacha::guts::refill_wide::h2ceeff1c2be61c9f((char *)v23 + 8, 10LL, v22);
    v21 = 1LL;
    *(_BYTE *)(v3 + v6) ^= LOBYTE(v22[0]);
    ++v4;
    v2 += 7LL;
    v1 = v5;
}
while (v5 != v4);

读入文件后主要加密过程在这个循环中完成。试着写了两行 Rust，发现 rand_chacha::guts::{init_chacha, refill_wide} 两个函数都不是 pub 的，说明并非直接调用这两个函数，而是编译时内联了进来。看 guts.rs 的源码可知 refill_wide 的第二个参数是 round，可以发现 10 轮的是同一个包里的 ChaCha20Rng。IDA 调试一下可知生成的随机字节填充在 v22 的 buffer 里，最后 *(_BYTE *)(v3 + v6) ^= LOBYTE(v22[0]); 表示只用了第一个字节异或到原先的明文上。上面的 init_chacha 是 ChaCha20Rng::from_seed 展开而成，key 是 v9 开始的 32 字节。*((_BYTE *)&v13 + (v4 & 0x1F)) = *(_BYTE *)(v3 + v6); 表示每次从明文取一个字节，循环放入 key 中，最终生成的伪随机字节重新和这个字节异或，那么每轮只有 256 种可能性，可以爆破。从明文取字节的顺序是 4,11,18……最开始的时候 key 全为 0，只放入一个明文字节爆破第一个字节后继续爆破第二个，依次类推，最后有多解情况，把 flag 限制在 ASCII 内减少尝试。

由于我不会 Rust，又没有找到合适的等价实现，就用 Rust 包装了一个随机数生成程序，主程序用 Python 实现。

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

use std::env;
use rand_chacha::rand_core::{RngCore,SeedableRng};
use rand_chacha::ChaCha20Rng;

fn main() {
    let mut key:[u8;32]=[0;32];
    let args: Vec<String> = env::args().collect();
    let arg1=&args[1];
    for i in 0..32 {
        let x = u8::from_str_radix(&arg1[i*2..i*2+2], 16).unwrap();
        key[i]=x;
    }
    let mut result=[0u8;256];
    let mut rng=ChaCha20Rng::from_seed(key);
    rng.fill_bytes(&mut result);
    println!("{}",result[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

import copy
import os

TARGET = [154, 122, 66, 146, 60, 227, 27, 164, 184, 114, 150, 47, 1, 152, 94, 41, 34, 245, 154, 20, 13, 76,
          24, 42, 56, 65, 212, 243, 169, 232, 96, 238, 218, 3, 220, 28, 161, 134, 18, 254, 24, 66, 137, 128, 145, 220]

def do_rust(key):
    s = ''.join(map(lambda x: '{:02x}'.format(x), key))
    p = os.popen('./target/debug/st {}'.format(s), 'r')
    return int(p.readline())

def solve(s, index, pos, key):
    if(index == 46):
        print(''.join(map(chr, s)))
        return
    for x in range(256):
        newkey = copy.copy(key)
        newkey[index % 32] = x
        r = do_rust(newkey)
        if(x ^ r == TARGET[pos % 46]):
            print(index)
            news = copy.copy(s)
            news[pos % 46] = x
            solve(news, index+1, pos+7, newkey)

solve([0]*46, 0, 4, [0]*32)

flag: *ctf{EbXZCOD56vEHNSofFvRHG7XtgFJXcUXUGnaaaaaa}

wherekey

从网上找到一个 libc 2.31 的 signature 安上去，主函数花指令处 jnz 改为 jmp 可以反汇编。发现这个程序中间还有一个 listen 和 send，自己给自己发送数据来增加工作量。

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

v2[dword_4C8570 / 64] |= 1LL << (dword_4C8570 % 64);
v2[dword_4C8520 / 64] |= 1LL << (dword_4C8520 % 64);
sub_44E080(1024LL, v2, 0LL, 0LL, 0LL);
if ((v2[dword_4C8520 / 64] & (1LL << (dword_4C8520 % 64))) != 0)
    sub_40223C();
if ((v2[dword_4C8570 / 64] & (1LL << (dword_4C8570 % 64))) != 0)
{
    v0 = ((__int64 (__fastcall *)(void *))((char *)&sub_401D44 + 1))(&unk_4C5120);
    sub_411D40(v0);
    sub_402072();
    v1 = ((__int64 (__fastcall *)(void *))((char *)&sub_401D44 + 1))(&unk_4C5130);
    sub_411D40(v1);
}

上面的或操作是宏 FD_SET(fd, set) 展开后的代码，下面的与操作是 FD_ISSET 宏，都是和 select 一起使用的。tty 收到数据后交给 sub_402072() 处理，看出发送的数据包应该是 5 个 5 字节的。看 sub_40223C() 处理 socket 收到的数据包，该数据包又交给 sub_4022DE(__int64 a1) 处理，每 5 个字节和 'flag{are_you_sure_friend}' 抠出来的字节相乘，实际上是一个线性方程组，常量字符串是系数矩阵，共有 5 组线性方程组。去掉花指令后找到比较对象是 unk_4C5150。翻出自己的陈年老代码用高斯消去法找出逆矩阵，再分别和 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

FL = 'flag{are_you_sure_friend}'

EP = [[ord(FL[5*i+j]) for i in range(5)]for j in range(5)]

INV = [0 for i in range(257)]

for i in range(257):
    for j in range(257):
        if (i*j) % 257 == 1:
            INV[i] = j
            break

EXT = [EP[i]+[1 if i == j else 0 for j in range(5)]for i in range(5)]

def show(martix):
    for i in range(5):
        print(martix[i])

def add(martix, k, line1, line2):
    for i in range(10):
        martix[line2][i] = (k*martix[line1][i]+martix[line2][i]) % 257

def mul(martix, x, line):
    for i in range(10):
        martix[line][i] = (martix[line][i]*x) % 257

def swap(martix, line1, line2):
    for i in range(20):
        martix[line1][i], martix[line2][i] = martix[line2][i], martix[line1][i]

def mulline(martix, x):
    y = [0]*5
    for i in range(5):
        for j in range(5):
            y[i] += martix[i][j]*x[j]
        y[i] = (y[i]) % 257
    return y

for i in range(5):
    if INV[EXT[i][i]] == 0:
        for k in range(i+1, 5):
            if INV[EXT[k][i]] != 0:
                swap(EXT, i, k)
                break
        else:
            raise ValueError
    mul(EXT, INV[EXT[i][i]], i)
    for j in range(5):
        if j == i:
            continue
        add(EXT, (-EXT[j][i]) % 257, i, j)

DP = [EXT[i][5:] for i in range(5)]

show(DP)

QUESTION = [0x38, 0x6D, 0x4B, 0x4B, 0xB9, 0x8A, 0xF9, 0x8A, 0xBB, 0x5C, 0x8A, 0x9A,
            0xBA, 0x6B, 0xD2, 0xC6, 0xBB, 0x05, 0x90, 0x56, 0x93, 0xE6, 0x12, 0xBD, 0x4F]

s = ''
for i in range(5):
    q = QUESTION[i*5:i*5+5]
    s += ''.join(map(chr, mulline(DP, q)))
print(s)

flag: *CTF{Ha23_f0n_9nd_G0od-1uck-OH}

ChineseGame

同样是静态链接，找到 libc 和 libstdc++ 的 signature 安上。有一个 10 元素的链表，链表节点存放了一个数，只需要关心这个数是否大于 100，若将大于 100 简记作 +，小于 100 为 -，初始状态是 +-++++++++，最后要求全为 -。输入内容是 01 字符串，分别用来选两种操作，冥冥之中感觉像是九连环游戏。每种操作都有一个位置参数，从 dword_5D5140 开始取。两种操作的内容是：如果该位置后面节点的状态是 +---…（或者根本没有后面的节点），则将该位置变为 +/-，否则什么都不干。经队友提示，发现 dword_5D5140 的位置参数恰好是正确解法需要操作的位置，所以只需找出进行此操作时是由 + 翻转到 - 还是 - 翻转到 + 即可。

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

a = [1, 3, 1, 2, 1, 5, 1, 2, 1, 3, 1, 2, 1, 4, 1, 2, 1, 3,
     ...
     1, 2, 1, 3, 1, 2, 1]

s = ''
init = [1, 0]+[1]*8
for x in a:
    x = 10-x
    if(init[x] == 1):
        s += '0'
    else:
        s += '1'
    init[x] = 1-init[x]
print(init,s)

flag: *CTF{4ncient_G4me_Fr0m_4ncient_Ch1na!}

Favourite Architecure flag0

加入此题之前，队友已经逆向了一部分。flag 长度为 0x59，前 0x29 字节进行 Chacha20 加密（从函数的密钥扩展中的常量字符串 'expand 32-byte k' 看出。同样由 D. J. Bernstein 设计的 Salsa20、Ed25519、Ed448 都有特殊的字符串），提取固定的 key 和 ciphertext 解密即可。后 0x30 字节是 TEA 加密，但被修改成了 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

#include <stdint.h>

void encrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], sum=0, i; /* set up */
    uint32_t delta=0x9e3779b9; /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
    for (i=0; i < 32; i++) { /* basic cycle start */
        sum += delta;
        v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
    } /* end cycle */
    v[0]=v0; v[1]=v1;
}

void decrypt (uint32_t* v, uint32_t* k) {
    uint32_t v0=v[0], v1=v[1], sum=0xC6EF3720, i; /* set up */
    uint32_t delta=0x9e3779b9; /* a key schedule constant */
    uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
    for (i=0; i<32; i++) { /* basic cycle start */
        v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
        v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1);
        sum -= delta;
    } /* end cycle */
    v[0]=v0; v[1]=v1;
}

decrypt 中的 sum=0xC6EF3720 是加密时 sum 每轮加上 delta 得出的累积值，若轮数减少为 16 轮，则 sum=(0x9e3779b9*16)&0xffffffff=0xe3779b90，修改后解密即可。

flag: flag{have_you_tried_ghidra9.2_decompiler_if_you_have_hexriscv_plz_share_it_with_me_thx:P}

1rep

这是一个 perlcc 编译 Perl 产生的程序，自己搞了一个 Perl 脚本试着编译了一下，发现所有的这种程序的主函数都依次调用如下函数：

1
2
3
4
5
6

perl_init(v20);
perl_init1(v20);
dl_init(v20);
perl_init2(v20);
*((_DWORD *)&_0 - 28) = perl_run(v20);
destruct_main(v20);

从自己编译的源码中看出，v20 是一个 PerlInterpreter*，说明这种编译器实际上不是像 Cython 那样把脚本代码转为等价的 C 代码，而是预先设置好变量、字节码之后，整体交给 Perl 虚拟机运行，此处的 Perl 虚拟机实例就是这个 PerlInterpreter 对象。最初的解题思路是借助调试器的 appcall 机制，设法从这个虚拟机实例里提取字节码。发现 libperl 里有一个 perl_dump_all()，gdb 在 perl_run 设好断点后，将 rip 改为 perl_dump_all 的地址并继续，结果 dump 出一大堆 optree，依旧没法看。后来发现 Perl 的 B::Deparse 模块有反编译功能，参考 StackOverflow 上的提问，利用 Perl_eval_pv 向 PerlInterpreter 里注入代码运行。

1

use B::Deparse; B::Deparse->compile->()

但是注入以上代码后，只反编译了开始的一小点检查。flag 去掉外壳后，里面 16 字节交给 kwvIJu 检查。再注入 B::Deparse 的其他功能反编译特定函数：

1
2
3
4

use B::Deparse;
$deparse = B::Deparse->new("-sC");
$body = $deparse->coderef2text(\&func);
print "$body\n";

不知道为什么 kwvIJu 没法反编译，但是试着反编译别的函数发现，所有函数都是检查当前 flag 的首字符（位于 0-f 范围），然后根据此字符 switch 到 16 个不同的分支，每个分支再调用不同的其他函数，调用的函数用来处理去掉首字符后剩下的 flag。观察 IDA 中存放字符串的地方，发现 .rodata:00000000032E6CAF 夹杂着一个 Correct，试着反汇编上方的 afRNDz，发现这个函数是打印 Correct，所以需要找出是哪个函数经 switch 语句调用了 afRNDz。试着再反汇编上方的 xmecUK，发现它调用了 afRNDz，再继续往上翻找，可以确定 flag 的最后 14 字节，但是后面再往上就找不到调用这一串函数的函数了，只好爆破最前面两字节，侥幸拿到 flag。

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

from pwn import *

for x in range(16):
    for y in range(16):
        s = '*ctf{'+hex(x)[2:]+hex(y)[2:]+'4bb0982b39baa2}'
        assert(len(s) == 22)
        r = process('./bin')
        r.sendline(s)
        t = r.recvall()
        print(t)
        if 'Correct' in t:
            print(s)

flag: *ctf{7a4bb0982b39baa2}