♧ Godown 安全知识树

逆向自实现的类 RC4 分组加密:定位 20 轮异或+字节置换的轮函数,从 .rodata 取密钥常量后写逆运算程序直接还原明文

ctf/reverse · verified

一句话结论

CTF 里自实现的“类 RC4”加密通常是:把密文(或密钥)常量放在 .rodata,用一个 20 轮的轮函数反复做“异或 + 按字节值查表做置换”。这类结构无需爆破密钥——只要在动态调试时停在比较点、把参与比较的输入与常量都 dump 出来,把轮函数按相反顺序逐轮反过来(异或自反、置换按记录的交换序列回退),就能写出一个 exp.c 直接算出明文,而不用破解算法设计者的意图。

原理

  • 轮函数结构:形如 for (i = 0; i < 20; i++) { a ^= key[i]; swap_bytes(a, table[key[i] & 0xff]); a ^= key[i]; a ^= b; swap(a,b); }。异或两次等于没做,真正提供“不可逆感”的是中间的字节置换;而置换本身有确定的交换顺序,记录后即可反向执行。
  • 可逆的三个关键点:① 异或与自身互逆;② 字节置换是若干个 swap,逆置换就是把这些 swap 按相反顺序再做一遍;③ 每轮的中间量 b(上一轮的 a)在正运算中被保留下来,逆运算时同样可以把当前状态“倒推”回去。
  • 密钥/常量来源:key[] 这类 20 个 dword 的数组通常直接以立即数写在 .rodata(如 0xBBDBD183、0x05340F2E、0xBEEFDEAD 循环),用 IDA 在数据交叉引用处一次取全;table[] 往往是 i & 3 之类的简单映射,反而是“看起来神秘但实际上无害”的部分。
  • 为什么先动态调试再静态读:算法常被内联/向量化(vmovups、vxorps、vzeroupper),静态看是一堆 SSE/AVX 搬移;把断点下在最终 memcmp/逐字节比较处,直接读出“参与比较的 4 个 dword 与 20 个 key dword”,比硬啃汇编快得多。
  • 与真正密码的区别:没有 S 盒初始化、没有密钥扩展、轮数固定 20、置换与密钥同源,这些特征说明它只是“混淆”,不含密码学强度;因此目标是“还原一个可运行的逆运算”,而不是攻击密钥空间。

触发条件

  • 目标是 CTF 逆向/密码题,二进制里存在“输入 → 加密 → 与常量比较”的结构。
  • 轮函数只有异或、加/减、固定字节置换、轮常量这类可逆操作(没有哈希/截断/取模丢信息)。
  • 能动态调试或在比较处下断点读取内存。
  • 已知密文常量(.rodata 里的 dword 序列)与轮常量。

利用步骤

  1. 运行程序,用任意输入触发比较,定位 memcmp/逐字符比较的地址;在比较前下断点,dump 左右两侧内存。
  2. 右侧就是密文常量(多个 dword,注意按小端拼回 4 字节);同时反查轮常量的数据交叉引用(如 sub_xxx+14D),把 .rodata 里连续的 dword 全部取出。
  3. 静态读轮函数:确认轮数(20)、每轮做几次异或、置换表怎么来的(本例 table[i] = i & 3)、以及 a/b 的交换顺序。
  4. 写出逆运算:从最后一轮往前做——先撤销 b 交换,再撤销第二次异或,再按“相反顺序”把置换里的 swap 反向执行,最后撤销第一次异或。
  5. 编译运行 exp.c,把结果按字符串打印(注意末尾补 \0,若结果是 flag 会有可读前缀)。
  6. 用正运算程序验证:把还原出的明文再正向加密一次,输出应等于原密文常量;这一步能防止“方向搞反”的低级错误。
  7. 若结果仍乱码,检查三点:dword 是否按小端拆分、轮常量是否取全(20 个)、置换索引是按字节取还是按位取。

PoC

/* 逆运算骨架:结构与正向加密同构,差别只有“轮序反向 + 换序反向” */
#include <stdint.h>
#include <stdio.h>

#define ROUNDS 20          /* 静态确认的轮数 */

int main(void) {
    uint32_t ct[2] = { 0x11111111, 0x22222222 };   /* 比较点 dump 到的两个 dword(小端拼回) */
    uint32_t rk[ROUNDS];                           /* .rodata 里按 xref 取全的轮常量 */
    int table[256];
    for (int i = 0; i < 256; i++) table[i] = i & 3; /* 实测置换表,可能来自被逆函数 */

    uint32_t a = ct[1], b = ct[0];
    for (int j = ROUNDS - 1; j >= 0; j--) {        /* ① 轮序反向 */
        uint32_t c = a;                            /* ② 撤销 b/a 交换:先存下正向的上一轮 a */
        a ^= rk[j];
        for (int k = 3; k >= 0; k--) {             /* ③ 置换按记录的交换序列倒着撤销 */
            int t = table[(rk[j] >> (k * 8)) & 0xff];
            uint32_t tmp = (a >> (k * 8)) & 0xff;
            *(((uint8_t *)&a) + k) = *(((uint8_t *)&a) + t);
            *(((uint8_t *)&a) + t) = tmp;
        }
        a ^= rk[j];                                /* ④ 异或自反 */
        a ^= b;
        b = c;
    }
    ct[0] = a; ct[1] = b;
    printf("%s\n", (char *)ct);                    /* 明文通常含可读前缀 */
    return 0;
}

验证方式:把还原出的明文喂回正向加密程序(或按上式反着写一遍),输出应逐字节等于原密文常量;不等就说明轮序、置换方向或 dword 字节序有一处搞反了。

变体与关联

  • 轮数/常量变体:轮数是 8/16/32 时同样处理;常量可能取反、右移或与 0xFFFFFFFF 相加,一律按“正向代码怎么写,逆运算就反过来写”处理。
  • 置换变体:置换索引可能来自密钥字节、也可以是 S 盒下标(s[ a & 0xff ]);后者逆运算需要先建反查表 inv[s[i]] = i。
  • 不可逆操作的处理:出现 a = (a >> 1) | (a << 31)(循环移位)时逆运算是反向循环移位;出现 a % 常量 或截断到 8 位时信息已丢失,只能改为“逐字节爆破 + 正向验证”。
  • 关联:[[ctf-pwn-stack-chk-fail-got-leave-ret-jmp-rsp-shellcode]] 是同篇题解里的 pwn 题,思路对照可见“先动态拿运行时事实、再静态补全逻辑”这一共性。
  • 边界:算法若含密钥扩展且密钥不在二进制里、或比较发生在服务端,则本条只能做到“理解算法”,无法离线还原明文。

检测与防御

  • 对 CTF 出题:想在逆向题里提高难度,应避免把轮常量与密文都放在可读的 .rodata;可增加密钥扩展、非线性 S 盒与数据相关置换,并减少“可一眼反推”的对称结构。
  • 对真实软件:自实现的混淆式加密不能当密码学使用——把固定密钥/轮常量硬编码在二进制里,逆向者可按上式离线还原;应采用标准算法(AES/ChaCha20)与标准库、密钥由 KMS 管理。
  • 对分析与取证:需要判定“样本自带的自定义加密能否离线解密”时,按可逆性逐条检查轮函数操作,可逆即说明加密强度为零,可直接出解密器。