顶级国际大比赛，难度很高，尽力了，别的方向题没做

谁懂BBbird

Reverse#

Birdhouse#

根据题目提示，需要用到开源项目https://github\.com/ares\-emulator/ares

下载之后需要在areas里加载game.z64

神秘小游戏来了

配置下键位看看，没什么用，应该不是正常通过游玩得到flag的

事已至此，那就把game.z64丢进IDA看

关键逻辑就在CODE段中，用AI辅助阅读ELF LOAD 数据即可

程序映射到RDRAM

1
RDRAM_BASE = 0x80000400

虚拟地址和 buffer 偏移的对应关系

1
offset = vaddr - 0x80000400

真正关键部分数据

1
VALIDATOR_DATA = 0x80057ca0

换算偏移

1
0x80057ca0 - 0x80000400 = 0x578a0

区域数据格式直接搓C还原就行

1
struct validator_data {
2
    uint16_t constraint_count_be;
3
    uint8_t  reserved[6];
4
    struct {
5
        uint16_t a_be;
6
        uint16_t b_be;
7
    } pairs[constraint_count];
8
    uint8_t encrypted_flag[32];
9
};

得到

1
constraint_count = 7464
2
encrypted_flag = fd364d4a685433acb6b55184392740db84c9c544d43f7e56ba58357d4fa4c11f

我们的密文就出现了，后续会用到

游戏方块属于三维grid 32*16*32

坐标关系等价C为

1
index = ((x * 16 + y) * 32 + z)

方块id有效范围为1-7

隐藏数据的约束含义为

1
value = grid[a]
2
if value == 0:
3
    fail()
4

5
if value != seq:
6
    other = grid[b]
7
    if other == 0 or other == value:
8
        fail()

grid[a]必须放方块，当前seq不等于grid[a]则对应的grid[b]也必须放方块，并且grid[b]的方块类型不能等于grid[a]，变成7色图着色求解

整体分布为 10 + 10 + 412 + 204 +108 +10 +179 = 933 所以要搭建933方块，在游戏里肯定搓不到

求出来grid后按约束复算一下hash seed

初始seed

1
0x6d2b79f5

使用的 xorshift32

1
def xorshift32(x):
2
    x &= 0xffffffff
3
    x ^= (x << 13) & 0xffffffff
4
    x ^= (x >> 17) & 0xffffffff
5
    x ^= (x << 5) & 0xffffffff
6
    return x & 0xffffffff

每遇到一个新的a时更新 seed

1
seed ^= (unique_i * 158 + grid[a]) & 0xffffffff
2
seed = xorshift32(seed)

得到seed

1
0xfe13cbb9

然后用该 seed 生成 32 字节 keystream

1
x = seed
2
stream = bytearray()
3
for _ in range(32):
4
    x = (x + 0x9e3779b9) & 0xffffffff
5
    x = xorshift32(x)
6
    stream.append((x >> 8) & 0xff)

和密文异或

1
fd364d4a685433acb6b55184392740db84c9c544d43f7e56ba58357d4fa4c11f

打穿了

bbb{r5p_gr4ph_c0l0r_0n_n64}

My Favorite Instructions#

程序不是直接比较字符串，而是先把输入转成348个三进制位数字trits

1
flag[0:4]     -> 20 trits
2
flag[4:20]    -> 82 trits
3
flag[20:36]   -> 82 trits
4
flag[36:44]   -> 41 trits
5
flag[44:52]   -> 41 trits
6
flag[52:68]   -> 82 trits

1
def flag_to_trits(flag: bytes):
2
    tr = []
3

4
    for c in flag[:4]:
5
        for _ in range(5):
6
            tr.append(c % 3)
7
            c //= 3
8

9
    for off, bits, digs in [
10
        (4, 128, 82),
11
        (20, 128, 82),
12
        (36, 64, 41),
13
        (44, 64, 41),
14
        (52, 128, 82),
15
    ]:
16
        n = int.from_bytes(flag[off:off + bits // 8], "little")
17
        for _ in range(digs):
18
            tr.append(n % 3)
19
            n //= 3
20

21
    assert len(tr) == 348
22
    return tr

然后就是我提到的两个最喜欢的指令指的就是x86汇编中的bsr bzhi

bsr的话

1
src = 0 -> 保留 old
2
src = 1 -> 0
3
src = 2 -> 1

等价

1
def bsr_tri(old, src):
2
    if src == 0:
3
        return old
4
    if src == 1:
5
        return 0
6
    if src == 2:
7
        return 1

如果src是普通整数就不能套用三值了，必须用bsr真实语义

1
src.bit_length() - 1

后面这个非常重要

然后再来说说bzhi

1
bzhi(a, b) = a & ((1 << b) - 1)

当然这个题大部分参与值都在0 1 2上，看为三值逻辑门正好对应bsr输入值三值

part1#

第一阶段依赖前20个trits

1
flag[0:4]

所以直接约束求解后就是bbb{

1
flag[0:4] = bbb{

part2#

1
flag[4:20]
2
flag[20:36]

程序把16字节快转为82-trit三进制整数做mask变换，密码也来支持了

1
N = 69315507563335000426881137137421870202776768428849895573283403915458679359157

丢给factordb

http://www\.factordb\.com/index\.php?query=69315507563335000426881137137421870202776768428849895573283403915458679359157

1
p = 312491767943139940981443826148003062019
2
q = 221815467394800111963839297593696124903

A = q, B = p

1
flag[4:36] = kQMM2FhlSBO4fEYFho5azaRrlTdxPsRx

part3#

对应了41个trits，8个字节

逆向得表

1
table  : 0x4e590
2
target : 0x67930

15*41*21个三值系数 15*21个目标trits 21个trits组成一个base-3整数做普通整数乘加

打格LLL还原41个trits

1
flag[36:44] = 6ue7npnj

part4#

也是41个trits，提取对应net后SAT求解

1
0x26400 -> 0x325bc

约束输出为2

1
flag[44:52] = ATDcm6d4

part5#

最后一段是16字节，也就是82个trits

1
0x325bc -> 0x3cd00    preloop
2
0x3cd00 -> 0x48c82    243-round loop
3
0x48c91 -> 0x4d881    final checker

跑angr符号执行就可以

计数器从0跑到 0xf3 = 243，最后一个阶段就是dump325bc angr符号执行合成242轮+final checker 检查也就拿到我们的最后一轮入口点的约束，从241轮一路像part4那样SAT反推到0轮

用初始化的preloop net求解原始的82个trits，转成16字节，收个尾，加上}的最终约束

1
flag[52:68] = hPe25PNGBdT9MK0}

这下从头开始拼接

最终合并flag#

1
bbb{
2
kQMM2FhlSBO4fEYFho5azaRrlTdxPsRx
3
6ue7npnj
4
ATDcm6d4
5
hPe25PNGBdT9MK0}

1
bbb{kQMM2FhlSBO4fEYFho5azaRrlTdxPsRx6ue7npnjATDcm6d4hPe25PNGBdT9MK0}

成功还原收工

bbb{kQMM2FhlSBO4fEYFho5azaRrlTdxPsRx6ue7npnjATDcm6d4hPe25PNGBdT9MK0}

Pixels and Nicotine#

Vapes are cheap. Easy to buy, easy to mod, easy

to leave somewhere. Nicotine optional. Reverse

engineering required :)

Note: You will need to wrap the flag with bbb{…} before submitting it.

[pixels-n-nicotine-8fe8fd754ee1fbc3577adeab4d95a844.tar.gz]

附件给了个bin文件，Pixels，题目与像素有关系

Vapes，电子烟固件逆向？ ~~🔇I Got Smoke🚭~~

需要个看二进制的工具来拼接，Mesen，以及YY-CHR，还有打表

实际上硬件dump取证+固件逆向+ROM逆向打满。。。

拿题目第一反应是我之前打过的阿里CTF，题目是pixelflow，考的il2cpp，unity逆向，不过和这道题不太一样，但是最后结果额都是像素分析，解xor和tile映射最后套flag

0x234000开始选中0x6000字节直到0x239FFF

提取，构建新文件新文件头4E 45 53 1A 01 01 00 00 00 00 00 00 00 00 00 00+复制过来的0x6000字节

模拟.nes，用Mesen打开恢复即可成功，我们得到了一份nes游戏的ROM（被修改过的）记一下，作为hidden.nes

同样的，base = 0x60000 length = 0x6000再扣一个.nes（未修改过的）未改变的，记一下original.nes

分析INES文件的PRG部分，这地方是重点，找0x0010 ~ 0x400F就行

1
CPU address = 0xC000 + (file_offset - 0x10)
2
反转
3
**file_offset = 0x10 + (CPU address - 0xC000)**
4
记一下这个换算

改版的ROM在PRG中增加了新的跳转和routine

1
; CPU $CA36
2
CA36: 4C CA E8     JMP $E8CA
3

4
; CPU $D090
5
D090: 4C C2 E7     JMP $E7C2

用Mesen看hidden.nes

跳E8CA看

1
E8CA: B1 CE        LDA ($CE),Y
2
E8CC: 45 CD        EOR $CD
3
E8CE: 5D 88 E7     EOR $E788,X
4
E8D1: BC 91 E7     LDY $E791,X
5
E8D4: 99 00 01     STA $0100,Y
6
E8D7: A0 00        LDY #$00
7
E8D9: 60           RTS

跳E7C2看

1
E7C2: B1 CE        LDA ($CE),Y
2
E7C4: 45 CD        EOR $CD
3
E7C6: 5D 88 E7     EOR $E788,X
4
E7C9: BC 91 E7     LDY $E791,X
5
E7CC: 99 10 01     STA $0110,Y
6
E7CF: A0 00        LDY #$00
7
E7D1: 60           RTS

汇编建议AI辅助观看，一坨

模拟出的逻辑炼出来是

1
decoded = encrypted_byte XOR RAM[$00CD] XOR key[x]
2
screen_position = perm[x]

其中

1
key  = bytes at CPU $E788 ~ $E790
2
perm = bytes at CPU $E791 ~ $E799

然后我们上面用到的CPU计算就用上了，换算iNES文件偏移

1
$E788 -> 0x2798
2
$E791 -> 0x27A1

可读

1
key  = 31 A4 5C 07 C9 22 E1 4B 98
2
perm = 04 09 01 07 03 08 05 02 06

断E8CA E7C2调试看RAM $00CD值为AA

1
DA3B: A5 17        LDA $17
2
DA3D: 45 09        EOR $09
3
DA3F: 85 CC        STA $CC
4
DA41: 49 3E        EOR #$3E
5
DA43: 85 CD        STA $CD

人工解码用到CD = AA

再找两组指针表

还是E8C4和E7C2

借助工具翻译一下知道是 $CE/$ CF指向的位置读字节

第一行

1
low table  = CPU $D22F ~ $D237
2
high table = CPU $D238 ~ $D240

字节

1
low  = A7 F0 D4 68 17 16 00 21 04
2
high = C4 E2 F7 C3 C4 E9 C0 EA C0

CPU指针

1
C4A7 E2F0 F7D4 C368 C417 E916 C000 EA21 C004

第二行

1
low table  = CPU $DBA0 ~ $DBA8
2
high table = CPU $DBA9 ~ $DBB1

字节

1
low  = 84 32 D1 2C 67 30 FD 97 FC
2
high = E3 F9 EB FB E1 E9 FE D5 E2

CPU指针

1
E384 F932 EBD1 FB2C E167 E930 FEFD D597 E2FC

最后表格解码

用前面得公式

1
tile = raw_byte_at_pointer XOR AA XOR key[x]

第一行：RAM[$0100 + perm[x]]

第二行：RAM[$0110 + perm[x]]

打表

第一行

第二行

CD = AA

打开hidden.nes看CHR，看tile图案

交给YY-CHR查tile对应字符

tile映射打表

第一行

内存顺序KX9H_A9CA

反向读AC9A_H9XK

第二行

内存顺序_____3YP_

反向读_PY3____

拼接AC9A_H9XK_PY3____

然后不行，要去一下padding，最后能得到AC9A_H9XK_PY3

套flag格式交了

打穿

bbb{AC9A_H9XK_PY3}