如何解决魔改后的加密算法

题目来源：LockedSecret from GHCTF 2025 新生赛（公开赛道）官方 WP：GHCTF2025WP - Liv’s blog

出题人的提示

Reverse - LockedSecret Hint1: 如果加密函数 IDA 伪代码太乱看不懂，请尝试 Ghidra，或许能帮助你分析算法解出 Flag。 Ghidra 些许情况对比 IDA 有奇效。

用 DIE 查一下壳：

发现用了 UPX 壳（注意这里的 [modified]）

脱壳#

尝试使用 upx -d 直接脱壳，发现不行：

1
upx: .\LockedSecret.exe: CantUnpackException: file is modified/hacked/protected; take care!!!

Tip

对于 UPX 壳，大部分情况下应使用 upx -d 脱壳。

这下不知道怎么办了吧，哈哈！

后面查了一下报错信息，得到的答案是：程序的 UPX 特征被篡改过，导致 UPX 不敢直接脱壳。此时需要恢复程序的 UPX 特征。

为什么要修改 UPX 特征

UPX0 和 UPX1 是加 UPX 壳后的两个区段名。其中 UPX1 区段包含了需要解压的数据块。.rsrc 是程序资源信息区段名，这个区段含有原资源段的完整头部以及图标、Manifest、版本等未被压缩的资源，当然还有 UPX 自身需要的导入信息等（如果程序自身不含资源段，加壳后就是 UPX2）。UPX0 和 UPX1 可以被随意改成任何字符串，虽然这样改用处不大，但是也能起到伪装的作用。

——手动去upx特征 - whatday

用任意十六进制编辑器打开程序（我使用 ImHex）：

发现 .rsrc 段，那么 LIVV 就是修改后的 UPX 特征。

参考了几个遇到相似问题的文章，发现只需要将 LIVV 的前三个字母 LIV 改成 UPX 即可。

Warning

注意查一下字符串，下面还有 LIV。要把所有的 LIV 都替换成 UPX。

保存结果，再次使用 upx -d，发现成功脱壳。

解密#

将脱壳后的程序拖进 IDA：

1
int __cdecl main(int argc, const char **argv, const char **envp)
2
{
3
  char v4; // [esp+0h] [ebp-108h]
4
  char v5; // [esp+0h] [ebp-108h]
5
  int i; // [esp+0h] [ebp-108h]
6
  char input[256]; // [esp+4h] [ebp-104h] BYREF
7

8
  memset(input, 0, sizeof(input));
9
  printf("Input your flag:", v4);
10
  scanf("%32s", (char)input);
11
  if ( strlen(input) != 32 )
12
  {
13
    printf("Wrong length!\n", v5);
14
    system("pause");
15
    exit(0);
16
  }
17
  sub_401100();
18
  sub_401190(input);
19
  for ( i = 0; i < 32; ++i )
20
  {
21
    if ( flag[i] != input[i] )
22
    {
23
      printf("Wrong!\n", i);
24
      system("pause");
25
      exit(0);
26
    }
27
  }
28
  printf("Right!\n", i);
29
  system("pause");
30
  return 0;
31
}

（重命名了部分函数和对象）

尝试用 Findcrypt 查一下加密算法，结果是空的！这就不好玩了。

然后看一下 sub_401100：

1
int sub_401100()
2
{
3
  int i; // [esp+0h] [ebp-4h]
4

5
  srand(3246389708u);
6
  for ( i = 0; i < 8; ++i )
7
  {
8
    if ( i )
9
      dword_4043D8[i] = dword_4043D4[i] ^ rand();
10
    else
11
      dword_4043D8[0] = rand();
12
    dword_4043D8[i] %= 256;
13
  }
14
  return 0;
15
}

该函数利用伪随机初始化一个全局数组。

伪随机简介

这里的伪随机 (Pseudo-random) 是统计学意义上的：在给定的随机比特流样本中，1 的数量大致等于 0 的数量，满足这类要求的数字“一眼看上去”是随机的。

对于随机数的使用，一般是先播种，然后使用伪随机数函数来获取随机数。不播种会使用默认的种子。这种通过伪随机数函数得到的随机数，就是伪随机数，只要种子固定那么每次生成的随机数序列就会一样。

C 语言中的 srand、rand，C++ 的 mt19937、default_random_engine 等都是伪随机数函数。

具体到本例，第 5 行的 srand 负责伪随机数的初始化，即播种（IDA View 也给 3246389708 标注了 seed 注释）。之后的 rand 生成伪随机数。

请注意，C 的 rand 函数默认以 srand(1) 为种子生成伪随机数。在同一种子下，rand 生成的伪随机数列相同。由于标准做法¹不允许多次更换种子，因此只要知道了一个种子值，那么该程序下所有 rand 函数生成的伪随机数列均相同。Python 的 random 库也提供了这样的 rand 和 seed 函数。

（参考伪随机数问题浅析 - 天工实验室）

再往下面看：

1
int __cdecl sub_401190(int a1)
2
{
3
  unsigned int v1; // ecx
4
  unsigned int v2; // eax
5
  int result; // eax
6
  int v4; // [esp+0h] [ebp-7Ch]
7
  unsigned int v5; // [esp+4h] [ebp-78h]
8
  unsigned int v6; // [esp+14h] [ebp-68h]
9
  unsigned int v7; // [esp+18h] [ebp-64h]
10
  unsigned int v8; // [esp+1Ch] [ebp-60h]
11
  unsigned int v9; // [esp+20h] [ebp-5Ch]
12
  unsigned int v10; // [esp+24h] [ebp-58h]
13
  unsigned int v11; // [esp+28h] [ebp-54h]
14
  unsigned int v12; // [esp+30h] [ebp-4Ch]
15
  unsigned int v13; // [esp+38h] [ebp-44h]
16
  unsigned int v14; // [esp+3Ch] [ebp-40h]
17
  unsigned int v15; // [esp+40h] [ebp-3Ch]
18
  unsigned int v16; // [esp+44h] [ebp-38h]
19
  unsigned int v17; // [esp+48h] [ebp-34h]
20
  int i; // [esp+4Ch] [ebp-30h]
21
  int v19; // [esp+50h] [ebp-2Ch]
22
  int v20[4]; // [esp+54h] [ebp-28h] BYREF
23
  int Src[5]; // [esp+64h] [ebp-18h] BYREF
24

25
  strcpy((char *)Src, "IamTheKeyYouKnow");
26
  for ( i = 0; i < 15; ++i )
27
    *((_BYTE *)Src + i) ^= LOBYTE(dword_4043D8[i % 8]);
28
  memcpy(v20, Src, sizeof(v20));
29
  v19 = 4;
30
  do
31
  {
32
    v17 = *(_DWORD *)(a1 + 8 * (4 - v19) + 4);
33
    v16 = *(_DWORD *)(a1 + 8 * (4 - v19)) + ((v20[1] + (v17 >> 5)) ^ (v17 + 1579382783) ^ (v20[0] + 16 * v17));
34
    v15 = v17 + ((v20[3] + (v16 >> 5)) ^ (v16 + 1579382783) ^ (v20[2] + 16 * v16));
35
    v14 = v16 + ((v20[1] + (v15 >> 5)) ^ (v15 - 1136201730) ^ (v20[0] + 16 * v15));
36
    v13 = v15 + ((v20[3] + (v14 >> 5)) ^ (v14 - 1136201730) ^ (v20[2] + 16 * v14));
37
    v12 = v13
38
        + ((v20[3] + ((v14 + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13))) >> 5)) ^ (v14 + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13)) + 443181053) ^ (v20[2] + 16 * (v14 + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13)))));
39
    v1 = v14
40
       + ((v20[1] + (v13 >> 5)) ^ (v13 + 443181053) ^ (v20[0] + 16 * v13))
41
       + ((v20[1] + (v12 >> 5)) ^ (v12 + 2022563836) ^ (v20[0] + 16 * v12));
42
    v11 = v12 + ((v20[3] + (v1 >> 5)) ^ (v1 + 2022563836) ^ (v20[2] + 16 * v1));
43
    v10 = v1 + ((v20[1] + (v11 >> 5)) ^ (v11 - 693020677) ^ (v20[0] + 16 * v11));
44
    v9 = v11 + ((v20[3] + (v10 >> 5)) ^ (v10 - 693020677) ^ (v20[2] + 16 * v10));
45
    v8 = v10 + ((v20[1] + (v9 >> 5)) ^ (v9 + 886362106) ^ (v20[0] + 16 * v9));
46
    v7 = v9 + ((v20[3] + (v8 >> 5)) ^ (v8 + 886362106) ^ (v20[2] + 16 * v8));
47
    v6 = v8 + ((v20[1] + (v7 >> 5)) ^ (v7 - 1829222407) ^ (v20[0] + 16 * v7));
48
    v2 = v7 + ((v20[3] + (v6 >> 5)) ^ (v6 - 1829222407) ^ (v20[2] + 16 * v6));
49
    v5 = v2
50
       + ((v20[3] + ((v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2))) >> 5)) ^ (v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2)) - 249839624) ^ (v20[2] + 16 * (v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2)))));
51
    *(_DWORD *)(a1 + 8 * (4 - v19)) = (v6 + ((v20[1] + (v2 >> 5)) ^ (v2 - 249839624) ^ (v20[0] + 16 * v2))) ^ 0xF;
52
    *(_DWORD *)(a1 + 8 * (4 - v19) + 4) = v5 ^ 0xF;
53
    v4 = v19;
54
    result = --v19;
55
  }
56
  while ( v4 );
57
  return result;
58
}

被逆向气晕（

我们还是能看出点东西的。第 25-27 行将一串明文 key 与上一个函数初始化的值进行异或计算得到用于加密的 Key。但由于 IDA 的反编译器问题，加密过程反编译代码明显缺乏规律，让人看不出特征。

切换到 Ghidra（通过搜索字符串查找主函数，再跳转）：

1
void __cdecl FUN_00401190(int param_1)
2

3
{
4
  uint uVar1;
5
  uint uVar2;
6
  bool bVar3;
7
  uint local_34;
8
  int local_30;
9
  int local_2c;
10
  int local_28;
11
  int local_24;
12
  int local_20;
13
  byte local_1c [20];
14
  uint local_8;
15

16
  local_8 = DAT_00404000 ^ (uint)&stack0xfffffffc;
17
  local_1c[0] = 'I';
18
  local_1c[1] = 'a';
19
  local_1c[2] = 'm';
20
  local_1c[3] = 'T';
21
  local_1c[4] = 'h';
22
  local_1c[5] = 'e';
23
  local_1c[6] = 'K';
24
  local_1c[7] = 'e';
25
  local_1c[8] = 'y';
26
  local_1c[9] = 'Y';
27
  local_1c[10] = 'o';
28
  local_1c[0xb] = 'u';
29
  local_1c[0xc] = 'K';
30
  local_1c[0xd] = 'n';
31
  local_1c[0xe] = 'o';
32
  local_1c[0xf] = 'w';
33
  local_1c[0x10] = 0;
34
  for (local_34 = 0; (int)local_34 < 0xf; local_34 = local_34 + 1) {
35
    uVar1 = local_34 & 0x80000007;
36
    if ((int)uVar1 < 0) {
37
      uVar1 = (uVar1 - 1 | 0xfffffff8) + 1;
38
    }
39
    local_1c[local_34] = local_1c[local_34] ^ (byte)*(undefined4 *)(&DAT_004043d8 + uVar1 * 4);
40
  }
41
  local_2c = 0;
42
  local_28 = 0;
43
  local_24 = 0;
44
  local_20 = 0;
45
  memcpy(&local_2c,local_1c,0x10);
46
  local_30 = 4;
47
  do {
48
    uVar1 = *(uint *)(param_1 + 4 + (4 - local_30) * 8);
49
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x5e2377ff ^ (uVar1 >> 5) + local_28) +
50
            *(int *)(param_1 + (4 - local_30) * 8);
51
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x5e2377ff ^ (uVar2 >> 5) + local_20) + uVar1;
52
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0xbc46effe ^ (uVar1 >> 5) + local_28) + uVar2;
53
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0xbc46effe ^ (uVar2 >> 5) + local_20) + uVar1;
54
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x1a6a67fd ^ (uVar1 >> 5) + local_28) + uVar2;
55
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x1a6a67fd ^ (uVar2 >> 5) + local_20) + uVar1;
56
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x788ddffc ^ (uVar1 >> 5) + local_28) + uVar2;
57
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x788ddffc ^ (uVar2 >> 5) + local_20) + uVar1;
58
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0xd6b157fb ^ (uVar1 >> 5) + local_28) + uVar2;
59
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0xd6b157fb ^ (uVar2 >> 5) + local_20) + uVar1;
60
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x34d4cffa ^ (uVar1 >> 5) + local_28) + uVar2;
61
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x34d4cffa ^ (uVar2 >> 5) + local_20) + uVar1;
62
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0x92f847f9 ^ (uVar1 >> 5) + local_28) + uVar2;
63
    uVar1 = (uVar2 * 0x10 + local_24 ^ uVar2 + 0x92f847f9 ^ (uVar2 >> 5) + local_20) + uVar1;
64
    uVar2 = (uVar1 * 0x10 + local_2c ^ uVar1 + 0xf11bbff8 ^ (uVar1 >> 5) + local_28) + uVar2;
65
    *(uint *)(param_1 + (4 - local_30) * 8) = uVar2 ^ 0xf;
66
    *(uint *)(param_1 + 4 + (4 - local_30) * 8) =
67
         (uVar2 * 0x10 + local_24 ^ uVar2 + 0xf11bbff8 ^ (uVar2 >> 5) + local_20) + uVar1 ^ 0xf;
68
    bVar3 = local_30 != 0;
69
    local_30 = local_30 + -1;
70
  } while (bVar3);
71
  FUN_0040173b(local_8 ^ (uint)&stack0xfffffffc);
72
  return;
73
}

可以很清楚的看出就是 Tea 加密，不过用重复计算和不同的 sum 值来代替了循环加密。

将第二次计算的 bc46effe 减去 5e2377ff 会发现结果还是 5e2377ff，所以可以知道 5e2377ff 就是 delta 值，那么这就是一个完整的从 delta 值开始的 Tea 加密。

并且两两计算为一组，可以看出是 8 轮加密的 Tea，并且最后将加密完的值再异或上了 0xf。

解密脚本：

1
#include <iostream>
2
#include <Windows.h>
3

4
void tea_decrypt(uint32_t v[2], const uint32_t k[4])
5
{
6
    uint32_t v0 = v[0], v1 = v[1];
7

8
    uint32_t sum = 0x5E2377FF * 8;
9

10
    uint32_t delta = 0x5E2377FF;
11

12
    for (uint32_t i = 0; i < 8; i++)
13
    {
14
        v1 -= ((v0 << 4) + k[2]) ^ (v0 + sum) ^ ((v0 >> 5) + k[3]);
15
        v0 -= ((v1 << 4) + k[0]) ^ (v1 + sum) ^ ((v1 >> 5) + k[1]);
16
        sum -= delta;
17
    }
18

19
    v[0] = v0;
20
    v[1] = v1;
21
}
22

23
int main()
24
{
25
  unsigned char Key[] =
26
  {
27
        0x2D,0xF7,0x3D,0x42,0x01,0x9A,0xF5,0x05,0x1D,0xCF,0x3F,0x63,0x22,0x91,0xD1,0x77
28
  };
29
    unsigned char EncFlag[] = {
30
      0xDC,0x45,0x1E,0x03,0x89,
31
      0xE9,0x76,0x27,0x47,0x48,
32
      0x23,0x01,0x70,0xD2,0xCE,
33
      0x64,0xDA,0x7F,0x46,0x33,
34
      0xB1,0x03,0x49,0xA3,0x27,
35
      0x00,0xD1,0x2C,0x37,0xB3,
36
      0xBD,0x75 };
37
    for (int i = 0; i < 4; i++)
38
    {
39
        *(uint32_t*)(EncFlag + i * 8) ^= 0xf;
40
        *(uint32_t*)(EncFlag + i * 8 + 4) ^= 0xf;
41
        tea_decrypt((uint32_t*)(EncFlag + i * 8), (uint32_t*)Key);
42
    }
43

44
    printf("%.32s\n",EncFlag);
45
  return 0;
46
}

得到 Flag：NSSCTF{!!!Y0u_g3t_th3_s3cr3t!!!}

std::rand ↩

音乐

脱壳#

解密#

文章分享

评论区

如何解决魔改后的加密算法

脱壳#

解密#

Footnotes#

文章分享

评论区