首页
社区
课程
招聘
问答 CTF 排行榜 知识库 工具下载 看雪峰会 看雪商城 证书查询
  1. 看雪社区
  2. ¥付费问答
    3. 发新帖
[已解决] 一段解密代码，求帮分析是什么算法 50.00雪花
2024-1-8 23:14 4641

[已解决] 一段解密代码，求帮分析是什么算法 50.00雪花

我不是一支笔 活跃值
2024-1-8 23:14
4641
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
bool __fastcall JiaJieMi_(_DWORD *Data, int Length, __int64 *Key)
{
  _DWORD *EncryptData; // rdi
  unsigned int EncryptLen; // ebx
  __int64 v7[5]; // [rsp+20h] [rbp-28h] BYREF
 
  EncryptData = Data + 1;
  v7[0] = *Key;
  v7[1] = Key[1];
  EncryptLen = Length - 4;
  v7[2] = Key[2];
  v7[3] = Key[3];
  sub_140044000(Key);
  sub_140044290(EncryptData, EncryptData, EncryptLen);
  sub_140044770(EncryptData, (int)EncryptLen, v7);
  return *Data == (unsigned int)sub_1411E3580(0i64, EncryptData, EncryptLen);
}
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
__int64 __fastcall sub_140044000(__int64 a1)
{
  unsigned __int128 v2; // rax
  __int64 v3; // rax
  int v4; // r8d
  __int64 v5; // r9
  __int64 v6; // r11
  int v7; // edx
  int v8; // eax
  _DWORD *v9; // rdx
  int v10; // eax
  __int128 *v11; // rbx
  unsigned int v12; // eax
  _DWORD *v13; // rbx
  __int64 result; // rax
  int v15; // [rsp+38h] [rbp+10h] BYREF
  unsigned int v16; // [rsp+40h] [rbp+18h] BYREF
 
  xmmword_1430C27E0 = xmmword_141E9CBB0;
  xmmword_1430C27F0 = xmmword_141E9CBC0;
  xmmword_1430C2800 = xmmword_141E9CBD0;
  qword_1430C2820 = 0x8979FB1B9216D5D9ui64;
  xmmword_1430C2810 = xmmword_141E9CBE0;
  memcpy(&unk_1430C2828, &unk_141E9CC10, 0x1000ui64);
  v2 = 8 * (unsigned __int128)4ui64;
  if ( !is_mul_ok(8ui64, 4ui64) )
    *(_QWORD *)&v2 = -1i64;
  v3 = sub_14004F030(v2, *((_QWORD *)&v2 + 1));
  v4 = 2;
  v5 = 0i64;
  v6 = v3;
  v7 = 2;
  do
  {
    HIBYTE(v15) = *(_BYTE *)((v7 - 2) % 32 + a1);
    BYTE2(v15) = *(_BYTE *)((v7 - 1) % 32 + a1);
    BYTE1(v15) = *(_BYTE *)(v7 % 32 + a1);
    v8 = (v7 + 1) % 32;
    ++v5;
    v7 += 4;
    LOBYTE(v15) = *(_BYTE *)(v8 + a1);
    *(_DWORD *)(v6 + 4 * v5 - 4) = v15;
  }
  while ( v5 < 8 );
  v9 = (_DWORD *)&xmmword_1430C27E0 + 2;
  do
  {
    *(v9 - 2) ^= *(_DWORD *)(v6 + 4i64 * ((v4 - 2) % 8));
    *(v9 - 1) ^= *(_DWORD *)(v6 + 4i64 * ((v4 - 1) % 8));
    *v9 ^= *(_DWORD *)(v6 + 4i64 * (v4 % 8));
    v9[1] ^= *(_DWORD *)(v6 + 4i64 * ((v4 + 1) % 8));
    v9[2] ^= *(_DWORD *)(v6 + 4i64 * ((v4 + 2) % 8));
    v10 = (v4 + 3) % 8;
    v4 += 6;
    v9 += 6;
    *(v9 - 3) ^= *(_DWORD *)(v6 + 4i64 * v10);
  }
  while ( v4 - 2 < 18 );
  sub_14004F040(v6);
  v15 = 0;
  v16 = 0;
  v11 = &xmmword_1430C27E0;
  do
  {
    sub_140044470(&v15, &v16);
    v12 = v16;
    *(_DWORD *)v11 = v15;
    *((_DWORD *)v11 + 1) = v12;
    v11 = (__int128 *)((char *)v11 + 8);
  }
  while ( (__int64)v11 < (__int64)&unk_1430C2828 );
  v13 = &unk_1430C282C;
  do
  {
    sub_140044470(&v15, &v16);
    result = v16;
    *(v13 - 1) = v15;
    *v13 = result;
    v13 += 2;
  }
  while ( (__int64)v13 < (__int64)&unk_1430C382C );
  return result;
}
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
void *__fastcall sub_140044290(int *a1, int *a2, int a3)
{
  unsigned __int64 v3; // rdi
  int *v4; // rbx
  void *result; // rax
  int v6; // r10d
  unsigned __int64 i; // r11
  __int64 *v8; // rdi
  int v9; // ecx
  int v10; // ecx
  int v11; // ecx
  int v12; // edx
  int v13; // ecx
 
  v3 = a3;
  v4 = a1;
  if ( a1 != a2 )
    result = memcpy(a1, a2, a3);
  v6 = 0;
  for ( i = v3 >> 3; v6 < i; result = (void *)v6 )
  {
    v8 = &qword_1430C2820;
    do
    {
      *v4 ^= *((_DWORD *)v8 + 1);
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      v9 = *v4;
      *v4 = v4[1];
      v4[1] = v9;
      *v4 ^= *(_DWORD *)v8;
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      v10 = *v4;
      *v4 = v4[1];
      v4[1] = v10;
      *v4 ^= *((_DWORD *)v8 - 1);
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      v11 = *v4;
      *v4 = v4[1];
      v4[1] = v11;
      *v4 ^= *((_DWORD *)v8 - 2);
      v8 -= 2;
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      v12 = *v4;
      *v4 = v4[1];
      v4[1] = v12;
    }
    while ( (__int64)v8 > (__int64)&xmmword_1430C27E0 );
    v13 = *v4;
    *v4 = v12;
    ++v6;
    v4[1] = v13;
    v4 += 2;
    *(v4 - 1) = v13 ^ DWORD1(xmmword_1430C27E0);
    *(v4 - 2) ^= xmmword_1430C27E0;
  }
  return result;
}
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
65
66
67
68
69
70
71
72
73
74
75
__int64 __fastcall sub_140044770(__int64 *a1, unsigned __int64 a2, const char *a3)
{
  int v5; // ecx
  __int64 result; // rax
  unsigned __int64 v7; // rsi
  __int64 v8; // rbp
  char *v9; // rsi
  int v10; // r11d
  int v11; // r10d
  int v12; // r9d
  int v13; // eax
  int v14; // r8d
  int v15; // r9d
  int v16; // r9d
  int v17; // edi
  int v18; // edx
  int v19; // r11d
  int v20; // r10d
  unsigned int v21; // [rsp+20h] [rbp-88h]
  char v22[48]; // [rsp+24h] [rbp-84h] BYREF
  unsigned __int64 v23; // [rsp+54h] [rbp-54h]
  __int64 v24; // [rsp+5Ch] [rbp-4Ch]
 
  if ( strlen(a3) <= 0x20 )
    v5 = strlen(a3);
  else
    v5 = 32;
  v21 = v5;
  memcpy(v22, a3, v5);
  result = sub_140044620(v22, v21);
  if ( a1 )
  {
    v7 = a2 >> 4;
    if ( (int)v7 > 0 )
    {
      v8 = (unsigned int)v7;
      do
      {
        v9 = (char *)&unk_1430C0DC0;
        v23 = *a1;
        v10 = HIDWORD(v23);
        v24 = a1[1];
        v11 = HIDWORD(v24);
        v12 = v24 - dword_1430C0DCC;
        v13 = v23 - dword_1430C0DC8;
        do
        {
          v14 = v11;
          v11 = v12;
          v15 = v10;
          v10 = v13;
          v16 = v15 - *((_DWORD *)v9 + 1);
          v9 -= 8;
          v17 = __ROL4__(v11 * (2 * v11 + 1), 5);
          v18 = __ROL4__(v13 * (2 * v13 + 1), 5);
          v12 = v17 ^ __ROR4__(v16, v18 & 0x1F);
          v13 = v18 ^ __ROR4__(v14 - *((_DWORD *)v9 + 2), v17 & 0x1F);
        }
        while ( (__int64)v9 >= (__int64)&unk_1430C0D28 );
        v19 = v10 - dword_1430C0D20;
        v20 = v11 - dword_1430C0D24;
        v23 = __PAIR64__(v19, v13);
        LODWORD(v24) = v12;
        *a1 = __PAIR64__(v19, v13);
        HIDWORD(v24) = v20;
        result = v24;
        a1[1] = v24;
        a1 += 2;
        --v8;
      }
      while ( v8 );
    }
  }
  return result;
}

[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课

收藏
点赞・0
打赏
分享
最新回复 (17)
gailium
雪    币： 533
活跃值： (805)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
gailium 2024-1-9 10:08
(+15.00雪花)
2 楼
0
https://bbs.kanxue.com/thread-56068.htm
看看这个
myller
雪    币： 5219
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
myller 2024-1-9 10:10
(+5.00雪花)
3 楼
0
搜下  qword_1430C2820 = 0x8979FB1B9216D5D9  这个常量
相关的算法有 BCrypt 和 Blowfish 
但你给的代码不完整  得有完整的才能分析
gailium
雪    币： 533
活跃值： (805)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
gailium 2024-1-9 10:15
4 楼
0
myller 搜下 qword_1430C2820 = 0x8979FB1B9216D5D9 这个常量 相关的算法有 BCrypt 和 Blowfish 但你给的代码不完整 得有完整的才能分析
直接放程序罢，全局变量都没解析出来
微启宇
雪    币： 2112
活跃值： (5642)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
微启宇 2024-1-9 10:58
(+5.00雪花)
5 楼
0

楼上的兄弟，chatgpt也是这样怼的。。。

以下是chatgpt的回复：
从反汇编的代码中很难确定确切的加密算法，因为这可能是一个定制的加密实现，而不是广泛使用的标准算法。然而，可以根据代码中出现的一些特征和操作来进行一些猜测。

以下是可能的加密算法特征：

异或运算： 异或运算在许多加密算法中都被广泛使用，包括简单的XOR加密。这段代码中包含了大量的异或运算，表明它可能是其中的一部分。

位运算： 代码中使用了左移(__ROL4__)和右移(__ROR4__)等位运算，这些操作在一些加密算法中用于混淆数据位。

密钥处理： 代码中对密钥进行了一系列的处理，包括异或、位运算等。这表明该算法可能涉及到对密钥进行变换或混淆。

循环结构： 代码中包含了很多循环，这可能是用于多轮加密或处理的一部分。

尽管上述特征可能使人联想到一些经典的加密算法，但需要强调的是，这只是一种猜测，因为实际加密算法可能具有不同的变种和优化。如果没有算法的具体文档或者更多上下文信息，很难确切地确定这段代码使用的是哪种标准加密算法。


顺便附加chatgpt对代码的解释


下面是对 sub_140044770 函数的详细注释：

__int64 __fastcall sub_140044770(__int64 *a1, unsigned __int64 a2, const char *a3)
{
  int v5; // ecx
  __int64 result; // rax
  unsigned __int64 v7; // rsi
  __int64 v8; // rbp
  char *v9; // rsi
  int v10; // r11d
  int v11; // r10d
  int v12; // r9d
  int v13; // eax
  int v14; // r8d
  int v15; // r9d
  int v16; // r9d
  int v17; // edi
  int v18; // edx
  int v19; // r11d
  int v20; // r10d
  unsigned int v21; // [rsp+20h] [rbp-88h]
  char v22[48]; // [rsp+24h] [rbp-84h] BYREF
  unsigned __int64 v23; // [rsp+54h] [rbp-54h]
  __int64 v24; // [rsp+5Ch] [rbp-4Ch]

  // 根据输入字符串长度设置处理长度
  if (strlen(a3) <= 0x20)
    v5 = strlen(a3);
  else
    v5 = 32;
  v21 = v5;
  // 复制输入字符串到本地数组 v22
  memcpy(v22, a3, v5);

  // 调用子函数 sub_140044620 对输入字符串进行处理
  result = sub_140044620(v22, v21);
  if (a1)
  {
    // 获取处理长度（除以16得到的整数部分）
    v7 = a2 >> 4;
    if ((int)v7 > 0)
    {
      v8 = (unsigned int)v7;
      do
      {
        // 初始化 v9 为固定数组 unk_1430C0DC0 的末尾
        v9 = (char *)&unk_1430C0DC0;
        v23 = *a1; // 取 a1 所指向的 64 位数据
        v10 = HIDWORD(v23); // 高 32 位
        v24 = a1[1]; // 取 a1 所指向的下一个 64 位数据
        v11 = HIDWORD(v24); // 高 32 位
        v12 = v24 - dword_1430C0DCC;
        v13 = v23 - dword_1430C0DC8;
        do
        {
          v14 = v11;
          v11 = v12;
          v15 = v10;
          v10 = v13;
          v16 = v15 - *((_DWORD *)v9 + 1);
          v9 -= 8;
          // 一系列异或和位运算
          v17 = __ROL4__(v11 * (2 * v11 + 1), 5);
          v18 = __ROL4__(v13 * (2 * v13 + 1), 5);
          v12 = v17 ^ __ROR4__(v16, v18 & 0x1F);
          v13 = v18 ^ __ROR4__(v14 - *((_DWORD *)v9 + 2), v17 & 0x1F);
        }
        while ((__int64)v9 >= (__int64)&unk_1430C0D28);
        v19 = v10 - dword_1430C0D20;
        v20 = v11 - dword_1430C0D24;
        v23 = __PAIR64__(v19, v13);
        LODWORD(v24) = v12;
        *a1 = __PAIR64__(v19, v13);
        HIDWORD(v24) = v20;
        result = v24;
        a1[1] = v24;
        a1 += 2;
        --v8;
      }
      while (v8);
    }
  }
  return result;
}

此函数的主要功能是对输入数据进行一系列的处理，包括字符串长度的检查、字符串的复制和调用子函数 sub_140044620 进行处理。随后，它对输入数据进行一系列的异或、位运算和循环操作，最终将处理结果存储到输出数组中。由于缺少子函数 sub_140044620 的具体代码，整个算法的详细作用和目的仍然不明确。



下面是对 sub_140044290 函数的详细注释：

void *__fastcall sub_140044290(int *a1, int *a2, int a3)
{
  unsigned __int64 v3; // 存储长度
  int *v4; // 源数据指针
  void *result; // 返回结果
  int v6; // 计数器
  unsigned __int64 i; // 循环控制变量
  __int64 *v8; // 用于异或运算

  v3 = a3; // 数据长度
  v4 = a1; // 目标数据指针
  // 如果目标和源不一致，则进行数据复制
  if (a1 != a2)
    result = memcpy(a1, a2, a3);
  v6 = 0;
  for (i = v3 >> 3; v6 < i; result = (void *)v6)
  {
    v8 = &qword_1430C2820; // 初始化异或运算使用的数据
    do
    {
      // 一系列的异或运算
      *v4 ^= *((_DWORD *)v8 + 1);
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      int v9 = *v4;
      *v4 = v4[1];
      v4[1] = v9;
      *v4 ^= *(_DWORD *)v8;
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      int v10 = *v4;
      *v4 = v4[1];
      v4[1] = v10;
      *v4 ^= *((_DWORD *)v8 - 1);
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      int v11 = *v4;
      *v4 = v4[1];
      v4[1] = v11;
      *v4 ^= *((_DWORD *)v8 - 2);
      v8 -= 2;
      v4[1] ^= *((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)*v4 + 786)
             + (*((_DWORD *)&xmmword_1430C27E0 + (unsigned __int8)BYTE1(*v4) + 530) ^ (*((_DWORD *)&xmmword_1430C27E0
                                                                                       + (unsigned __int8)BYTE2(*v4)
                                                                                       + 274)
                                                                                     + *((_DWORD *)&xmmword_1430C27E0
                                                                                       + HIBYTE(*v4)
                                                                                       + 18)));
      int v12 = *v4;
      *v4 = v4[1];
      v4[1] = v12;
    }
    while ((__int64)v8 > (__int64)&xmmword_1430C27E0);
    int v13 = *v4;
    *v4 = v12;
    ++v6;
    v4[1] = v13;
    v4 += 2;
    *(v4 - 1) = v13 ^ DWORD1(xmmword_1430C27E0);
    *(v4 - 2) ^= xmmword_1430C27E0;
  }
  return result;
}

此函数的主要目的是对输入数据进行一系列的异或和位运算。在每个循环中，它通过固定的异或值进行操作，包括对源数据的异或、位运算等，最终将处理结果存储到目标数据中。这种操作可能是用于混淆或加密数据的一部分，但具体的算法细节需要参考其他相关代码或上下文信息。



以下是对 sub_140044000 函数的详细注释：

__int64 __fastcall sub_140044000(__int64 a1)
{
  unsigned __int128 v2; // 用于存储一个128位整数
  __int64 v3; // 用于存储计算结果的临时变量
  int v4; // 计数器
  __int64 v5; // 用于存储中间计算结果
  __int64 v6; // 用于存储中间计算结果
  int v7; // 计数器
  int v8; // 用于存储中间计算结果
  _DWORD *v9; // 指向 xmmword_1430C27E0 数组的指针
  
  int v10; // eax
  __int128 *v11; // rbx
  unsigned int v12; // eax
  _DWORD *v13; // rbx
  __int64 result; // rax
  int v15; // [rsp+38h] [rbp+10h] BYREF
  unsigned int v16; // [rsp+40h] [rbp+18h] BYREF
  
  xmmword_1430C27E0 = xmmword_141E9CBB0; // 初始化 xmmword_1430C27E0
  xmmword_1430C27F0 = xmmword_141E9CBC0;
  xmmword_1430C2800 = xmmword_141E9CBD0;
  qword_1430C2820 = 0x8979FB1B9216D5D9ui64; // 初始化 qword_1430C2820
  xmmword_1430C2810 = xmmword_141E9CBE0;
  memcpy(&unk_1430C2828, &unk_141E9CC10, 0x1000ui64); // 复制数据到 unk_1430C2828

  unsigned __int128 v2 = 8 * (unsigned __int128)4ui64;
  if (!is_mul_ok(8ui64, 4ui64))
    *(_QWORD *)&v2 = -1i64;
  // 调用子函数 sub_14004F030 进行一些计算
  v3 = sub_14004F030(v2, *((_QWORD *)&v2 + 1));

  int v4 = 2;
  int v5 = 0i64;
  int v6 = v3;
  int v7 = 2;
  // 循环处理数据
  do
  {
    HIBYTE(v15) = *(_BYTE *)((v7 - 2) % 32 + a1);
    BYTE2(v15) = *(_BYTE *)((v7 - 1) % 32 + a1);
    BYTE1(v15) = *(_BYTE *)(v7 % 32 + a1);
    int v8 = (v7 + 1) % 32;
    ++v5;
    v7 += 4;
    LOBYTE(v15) = *(_BYTE *)(v8 + a1);
    *(_DWORD *)(v6 + 4 * v5 - 4) = v15;
  } while (v5 < 8);

  _DWORD *v9 = (_DWORD *)&xmmword_1430C27E0 + 2;
  // 循环进行异或运算
  do
  {
    *(v9 - 2) ^= *(_DWORD *)(v6 + 4i64 * ((v4 - 2) % 8));
    *(v9 - 1) ^= *(_DWORD *)(v6 + 4i64 * ((v4 - 1) % 8));
    *v9 ^= *(_DWORD *)(v6 + 4i64 * (v4 % 8));
    v9[1] ^= *(_DWORD *)(v6 + 4i64 * ((v4 + 1) % 8));
    v9[2] ^= *(_DWORD *)(v6 + 4i64 * ((v4 + 2) % 8));
    v10 = (v4 + 3) % 8;
    v4 += 6;
    v9 += 6;
    *(v9 - 3) ^= *(_DWORD *)(v6 + 4i64 * v10);
  } while (v4 - 2 < 18);

  // 调用子函数 sub_14004F040 进行进一步处理
  sub_14004F040(v6);

  v15 = 0;
  v16 = 0;
  __int128 *v11 = &xmmword_1430C27E0;
  // 循环进行子函数 sub_140044470 的调用和数据存储
  do
  {
    sub_140044470(&v15, &v16);
    v17 = v16;
    *(_DWORD *)v11 = v15;
    *((_DWORD *)v11 + 1) = v17;
    v11 = (__int128 *)((char *)v11 + 8);
  } while ((__int64)v11 < (__int64)&unk_1430C2828);

  _DWORD *v18 = &unk_1430C282C;
// 循环进行子函数 sub_140044470 的调用和数据存储
  do
  {
    sub_140044470(&v15, &v16);
    result = v16;
    *(v18 - 1) = v15;
    *v18 = result;
    v18 += 2;
  } while ((__int64)v18 < (__int64)&unk_1430C382C);  return result;
}

在该函数中，首先对一系列数据进行初始化，然后通过多次异或和位运算的操作，对数据进行混淆。最后，调用了两次 sub_140044470 函数，将其结果存储到相应的位置。整个函数的作用可能是对输入数据进行一定的变换和混淆，具体的算法细节需要查看 sub_140044470 和 sub_14004F030 的实现。

最后于 2024-1-9 11:13 被微启宇编辑 ，原因：
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-9 22:39
6 楼
0
我不是太清楚放出程序来会不会涉及侵权什么的被删帖。。。
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-9 23:13
7 楼
0
https://wwi.lanzoup.com/iiHOT1kmw26j
程序地址
SmilemOon
雪    币： 363
活跃值： (1035)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
SmilemOon 2024-1-10 09:09
(+15.00雪花)
8 楼
1

BlowFish 算法


sub_140044000 函数是用key 初始化 p-array 和 s-box


特征1


memcpy(&unk_1430C2828, &unk_141E9CC10, 0x1000ui64);
unk_141E9CC10 为 s-box 常量，
A6 0B 31 D1 AC B5 DF 98 DB 72 FD 2F B7 DF 1A D0
blowfish 特征值
static const uint32_t ORIG_S[4][256] = {
{   0xD1310BA6L, 0x98DFB5ACL, 0x2FFD72DBL, 0xD01ADFB7L,
0xB8E1AFEDL, 0x6A267E96L, 0xBA7C9045L, 0xF12C7F99L,
0x24A19947L, 0xB3916CF7L, 0x0801F2E2L, 0x858EFC16L,
0x636920D8L, 0x71574E69L, 0xA458FEA3L, 0xF4933D7EL,
0x0D95748FL, 0x728EB658L, 0x718BCD58L, 0x82154AEEL,


特征2

v4 = 2;
v5 = 0i64;
v6 = v3;
v7 = 2;
do
{
HIBYTE(v15) = *(_BYTE *)((v7 - 2) % 32 + a1);
BYTE2(v15) = *(_BYTE *)((v7 - 1) % 32 + a1);
BYTE1(v15) = *(_BYTE *)(v7 % 32 + a1);
v8 = (v7 + 1) % 32;
++v5;
v7 += 4;
LOBYTE(v15) = *(_BYTE *)(v8 + a1);
*(_DWORD *)(v6 + 4 * v5 - 4) = v15;
}
while ( v5 < 8 );
v9 = (_DWORD *)&xmmword_1430C27E0 + 2;
do
{
*(v9 - 2) ^= *(_DWORD *)(v6 + 4i64 * ((v4 - 2) % 8));
*(v9 - 1) ^= *(_DWORD *)(v6 + 4i64 * ((v4 - 1) % 8));
*v9 ^= *(_DWORD *)(v6 + 4i64 * (v4 % 8));
v9[1] ^= *(_DWORD *)(v6 + 4i64 * ((v4 + 1) % 8));
v9[2] ^= *(_DWORD *)(v6 + 4i64 * ((v4 + 2) % 8));
v10 = (v4 + 3) % 8;
v4 += 6;
v9 += 6;
*(v9 - 3) ^= *(_DWORD *)(v6 + 4i64 * v10);
}
while ( v4 - 2 < 18 );
v4从 0到 17遍历 为初始化p-array




参考地址

https://github.com/Rupan/blowfish/blob/master/blowfish.c


TkBinary
雪    币： 2392
活跃值： (9220)
能力值： ( LV13，RANK：385 )
在线值：
发帖
回帖
粉丝
私信
TkBinary 5 2024-1-10 09:48
(+5.00雪花)
9 楼
0
参考下我写的 看有帮助吗 https://www.cnblogs.com/iBinary/p/14883752.html
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-10 21:07
10 楼
0
目前已知的是Key为{98, 120, 117, 115, 110, 102, 117, 115, 105, 106, 115, 100, 97, 118, 107, 117, 109, 103, 98, 108, 112, 113, 117, 120, 120, 111, 111, 101, 115, 99, 103, 98}

加密后的字符数组为{240, 234, 187, 107, 97, 233, 15, 100, 201, 78, 101, 30, 174, 54, 241, 37, 200, 69, 176, 207, 23, 104, 77, 115, 95, 129, 68, 225, 66, 248, 125, 131, 146, 229, 187, 63, 165, 46, 93, 215, 12, 21, 226, 102, 77, 223, 116, 156, 249, 19, 19, 37, 128, 83, 166, 125, 245, 143, 47, 195, 170, 30, 190, 209, 129, 4, 200, 176, 221, 81, 91, 143, 48, 46, 249, 114, 226, 99, 98, 11, 24, 31, 24, 220, 76, 129, 138, 145, 162, 130, 216, 43, 44, 123, 238, 3, 162, 233, 100, 90, 27, 196, 69, 103, 233, 51, 173, 41, 15, 31, 43, 201, 102, 43, 18, 13, 200, 246, 79, 24, 5, 110, 178, 74, 75, 148, 76, 109, 159, 1, 220, 128, 179, 45, 244, 0, 219, 216, 205, 184, 134, 130, 225, 66, 4, 252, 32, 110, 1, 244, 253, 58, 84, 44, 61, 170, 57, 55, 137, 61, 140, 17, 132, 31, 10, 135, 158, 250, 54, 180, 71, 92, 191, 255, 125, 53, 117, 36, 144, 40, 134, 117, 130, 224, 185, 86, 241, 199, 78, 26, 43, 241, 7, 208, 67, 44, 63, 137, 73, 102, 250, 164, 6, 202, 207, 235, 201, 130, 199, 255, 205, 10}

解密后的结果中含有231, 4, 0, 0这四个字符

不知道是不是各位所说的BlowFish算法
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-10 22:44
11 楼
0
我试了试用BlowFish算法解密 但是没发现有231, 4  不知道是不是我代码写的有问题，大佬们可以帮忙校验下吗
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-11 18:30
12 楼
0
myller 搜下 qword_1430C2820 = 0x8979FB1B9216D5D9 这个常量 相关的算法有 BCrypt 和 Blowfish 但你给的代码不完整 得有完整的才能分析
0x8979FB1B9216D5D9  请问这个常量是干什么用的？
mb_ldbucrik
雪    币： 6
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
mb_ldbucrik 2024-1-11 19:36
(+5.00雪花)
13 楼
0
我不是一支笔 0x8979FB1B9216D5D9 请问这个常量是干什么用的？
https://www.coder.work/article/7704598可以看看这个
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-14 05:17
14 楼
0
上面的几位大哥谁能留个QQ或者加我79123626

我结贴给你
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-14 14:42
15 楼
0
经过验证后确实是有BlowFish算法，但是这里是两个算法，sub_140044770函数看起来是RC5算法，但是经过我验证，结果却不同

通过BlowFIsh解密确实可以得到RC5加密后的结果，但是用RC5解密无法正确得到原始数据

加密流程：原始数据->RC5->BlowFish

密钥:
"hxadmnjyqqvxkhunmzzxyosdycqqzhbz"
[104, 120, 97, 100, 109, 110, 106, 121, 113, 113, 118, 120, 107, 104, 117, 110, 109, 122, 122, 120, 121, 111, 115, 100, 121, 99, 113, 113, 122, 104, 98, 122]

BlowFish加密后：
B1 41 9A 64 9F AE 43 93 F7 2E D5 FE 12 78 96 F4 CC 77 C9 93 2B CE 02 B0 4A E2 BD 51 D1 2D 26 70 4A FD 14 9C DE 4E A5 9F 0E 53 D8 40 15 2D AD AA DF DC ED 78 AA FD 0B 30 13 91 59 6A F9 16 89 06 16 90 39 1E DE 17 71 55 76 D0 A5 A5 75 EE 52 E1 CE ED D7 8E 32 95 62 9D 96 D3 A8 FC 1A D0 57 DB D0 85 49 A9 92 AB 4C 2D F1 ED 4F C5 EB 71 4B 34 09 9C D4 74 B3 65 EF 55 D9 27 9C E2 DF 44 5D CC B7 2A CB A5 2F F2 EA D8 AF 5C CC 16 27 10 6A FA 53 F0 44 8D 56 0F 5A 2E 8D 50 45 4C E7 7B 91 E6 20 F2 9B E8 99 12 53 13 88 AF 16 DA A5 3B 74 E8 89 41 A5 50 C9 98 EF 34 14 6F 7E 10 74 BB 3F 5D 2E 50 C9 F3 A5 DD 4D A0 65 6A 25 AC FC 73 2A 32 6D 49 E8 D1
{159, 174, 67, 147, 247, 46, 213, 254, 18, 120, 150, 244, 204, 119, 201, 147, 43, 206, 2, 176, 74, 226, 189, 81, 209, 45, 38, 112, 74, 253, 20, 156, 222, 78, 165, 159, 14, 83, 216, 64, 21, 45, 173, 170, 223, 220, 237, 120, 170, 253, 11, 48, 19, 145, 89, 106, 249, 22, 137, 6, 22, 144, 57, 30, 222, 23, 113, 85, 118, 208, 165, 165, 117, 238, 82, 225, 206, 237, 215, 142, 50, 149, 98, 157, 150, 211, 168, 252, 26, 208, 87, 219, 208, 133, 73, 169, 146, 171, 76, 45, 241, 237, 79, 197, 235, 113, 75, 52, 9, 156, 212, 116, 179, 101, 239, 85, 217, 39, 156, 226, 223, 68, 93, 204, 183, 42, 203, 165, 47, 242, 234, 216, 175, 92, 204, 22, 39, 16, 106, 250, 83, 240, 68, 141, 86, 15, 90, 46, 141, 80, 69, 76, 231, 123, 145, 230, 32, 242, 155, 232, 153, 18, 83, 19, 136, 175, 22, 218, 165, 59, 116, 232, 137, 65, 165, 80, 201, 152, 239, 52, 20, 111, 126, 16, 116, 187, 63, 93, 46, 80, 201, 243, 165, 221, 77, 160, 101, 106, 37, 172, 252, 115, 42, 50, 109, 73, 232, 209}

RC5加密后：
B1 41 9A 64 04 72 CF 0D 49 E5 DA 3A E6 8F AD F0 1B 0A 64 44 E0 F7 A5 E8 FE 72 94 59 56 09 03 82 06 FD 38 7E FF 60 DC 87 A4 7A 0F 19 18 91 D4 81 0E FF 34 2B A7 C1 51 1A AD E3 B8 AC AE FD C6 E7 B9 7C 6D 51 5F 10 C4 24 C7 FD FB 58 20 0F D3 95 85 DB 0A DC DA 96 8A 74 28 8B AD 09 F4 9A 56 49 1D 9D 78 B6 A7 72 3F 44 34 08 F2 D0 BE 1F 5D E6 BF A0 0D 4F 7B 9A CA 3F E2 78 D5 7B D5 D1 F7 89 E6 FC 64 A5 39 41 E9 4C 7A EC 7F 78 67 13 36 DA 66 91 BF 90 E9 A3 3D 37 C9 7B 54 6E F3 3E FE CD 8A 0B 0B B6 89 65 9B B4 1B 46 B4 A3 D1 DD F2 8B 06 17 C4 72 02 7D BB 3D C6 68 1A 43 98 BA D8 43 77 11 1F 76 39 E6 9D 81 42 98 45 CD B7 21 C8 FB 07 8D D5 D7
{4, 114, 207, 13, 73, 229, 218, 58, 230, 143, 173, 240, 27, 10, 100, 68, 224, 247, 165, 232, 254, 114, 148, 89, 86, 9, 3, 130, 6, 253, 56, 126, 255, 96, 220, 135, 164, 122, 15, 25, 24, 145, 212, 129, 14, 255, 52, 43, 167, 193, 81, 26, 173, 227, 184, 172, 174, 253, 198, 231, 185, 124, 109, 81, 95, 16, 196, 36, 199, 253, 251, 88, 32, 15, 211, 149, 133, 219, 10, 220, 218, 150, 138, 116, 40, 139, 173, 9, 244, 154, 86, 73, 29, 157, 120, 182, 167, 114, 63, 68, 52, 8, 242, 208, 190, 31, 93, 230, 191, 160, 13, 79, 123, 154, 202, 63, 226, 120, 213, 123, 213, 209, 247, 137, 230, 252, 100, 165, 57, 65, 233, 76, 122, 236, 127, 120, 103, 19, 54, 218, 102, 145, 191, 144, 233, 163, 61, 55, 201, 123, 84, 110, 243, 62, 254, 205, 138, 11, 11, 182, 137, 101, 155, 180, 27, 70, 180, 163, 209, 221, 242, 139, 6, 23, 196, 114, 2, 125, 187, 61, 198, 104, 26, 67, 152, 186, 216, 67, 119, 17, 31, 118, 57, 230, 157, 129, 66, 152, 69, 205, 183, 33, 200, 251, 7, 141, 213, 215}

原始数据：
B1 41 9A 64 00 00 00 00 00 00 00 00 00 00 00 00 00 B8 D3 64 00 00 00 00 89 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 C4 09 00 00 00 00 00 00 88 13 00 00 00 00 00 00 00 18 73 04 00 00 00 00 FF FF FF 7F 0A 00 88 13 89 03 00 00 00 00 00 00 BE 19 A3 65 8E 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 B0 7D 00 00 00 00 00 00 01 01 01 00 00 01 00 00 00 00 02 00 02 02 01 00 00 01 09 FF 02 00 B0 7D 90 3E E7 04 00 00 00 00 00 00 8E 00 00 00 00 00 00 00 3E 00 90 3E 00 00 00 00 2E 00 00 00 00 00 00 00 70 56 BA 43 01 00 00 00 B8 70 09 05 00 00 00 00 0C 00 33 00 02 00 00 00 01 01 09 17 00 00 00 00 45 EC 3A 40 01 00 00 00
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 184, 211, 100, 0, 0, 0, 0, 137, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 196, 9, 0, 0, 0, 0, 0, 0, 136, 19, 0, 0, 0, 0, 0, 0, 0, 24, 115, 4, 0, 0, 0, 0, 255, 255, 255, 127, 10, 0, 136, 19, 137, 3, 0, 0, 0, 0, 0, 0, 190, 25, 163, 101, 142, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 176, 125, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 2, 0, 2, 2, 1, 0, 0, 1, 9, 255, 2, 0, 176, 125, 144, 62, 231, 4, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 0, 0, 0, 0, 62, 0, 144, 62, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 112, 86, 186, 67, 1, 0, 0, 0, 184, 112, 9, 5, 0, 0, 0, 0, 12, 0, 51, 0, 2, 0, 0, 0, 1, 1, 9, 23, 0, 0, 0, 0, 69, 236, 58, 64, 1, 0, 0, 0}
我不是一支笔
雪    币： 7
能力值： ( LV1，RANK：0 )
在线值：
发帖
回帖
粉丝
私信
我不是一支笔 2024-1-14 14:42
16 楼
0
Hex中的B1 41 9A 64可以忽略或删除掉，与密文无关，忘了删了
底层劳动者
雪    币： 2
活跃值： (162)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
底层劳动者 2024-1-31 19:02
17 楼
0
用得着去分析具体的过程么？要加密就直接调用它的加密函数，要解密就直接调用它的解密函数。
mb_rreehwfg
雪    币： 281
活跃值： (198)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
mb_rreehwfg 2024-3-1 03:31
18 楼
0
用得着去分析具体的过程么？要加密就直接调用它的加密函数，要解密就直接调用它的解密函数。＋1
游客
登录 | 注册 方可回帖
　回帖　 表情 雪币赚取及消费
高级回复
返回