看雪Re_翩若惊鸿

简介：

文章首发于云众可信：https://www.sec-in.com/article/661

看雪上一道Re的crackme题目，参考了lantie@15PB老师的帖子。是一个很有意思的程序，可以学到很多。

1. 初步试探

1.1 初步试探之——运行

1
2
3
运行程序，尝试各种用户名和密码组合，测试报错格式及关键字

弹框，MessageBoxA函数

1

1.2 初步试探之——查壳

1
2
3
4
基本信息：
	VC6.0编写的程序
	PE文件格式
	EXE32位文件

2

3

1
2
查看导入表信息：
	MFC程序动态链接库：MFC42.dll

4

1.3 初步试探之——定位

1
2
3
动态调试，找到程序入口点

对MessageBoxA函数下断，溯源

5

6

1
2
3
事件按钮函数与报错关键字

在该段开头即为程序OEP

7

1
按钮事件起始地址：00401410

2. 动静结合

2.1 IDA分析之——F5

1
2
3
4
IDA定位至起始地址：401410，查看可获取基本信息

只有sub_4015E0为自己所写函数，其余均为系统生成
同时看到username、password两个疑似用户名和密码的参数

8

1
2
3
4
可用OD动态调试，验证猜想

调用call 4015E0函数
栈中信息为用户名和密码

9

1
IDA分析4015E0处代码

10

1
2
3
4
data_start：解密的起始地址
len：解密长度
sub_4015A0：解密函数
sub_404550：求hash函数

2.2 OD调试之——代码跟踪

1
2
3
动态跟踪call 4015E0处的代码

动态跟踪call 402000的结果eax

11

1
2
3
4
5
402010为402000调用完之后返回解密的起始地址

eax=402010是代码地址，所以解密的是代码

查看反汇编和内存区段信息可以看出在代码段.text1中

12

1
2
3
4
5
6
7
.text1	如果足够了解PE结构，就可以发现这是一个专门添加的区段

继续分析，call 402AC0的返回地址为402AC0

由后续分析可以得知：
	402010：代码起始地址
	402AC0：代码结束地址

13

1
2
继续往下，运行至401614处，查看EBP寄存器值
AB0：待解密的空间大小

14

1
2
3
4
5
6
关键信息：
	起始地址：402010
	解密大小：0x0AB0
关键CALL：
	CALL 4015A0		//解密函数
	CALL 401550		//求hash值

2.3 IDA分析之——提取代码

1
2
3
4
解密函数：4015A0

可根据程序中的变量和类型进行参数及参数类型的修改
如：默认为v1、v2，可修改为username、password

15

1
2
3
4
5
6
求hash函数：401550

全局变量：
g_IsInit：dword_404550
函数：
InitHashTable：sub_401500

16

1
InitHashTable函数代码分析

17

1
2
3
确定变量g_hashTable的大小

从InitHashTable函数中可知，g_hashTable的大小应为数据段中g_hashTable的地址到g_IsInit的地址
1
g_hashTabe地址

18

1
g_IsInit地址

19

1
2
计算大小：404550-404150 = 0x400
伪代码中循环条件可设为：v1 < 0x400

2.4 代码分析之——暴力破解

1
2
3
4
5
6
7
8
9
10
编写代码注意事项：
循环条件：
	暴力破解hash值，需要先建立循环，循环的起始和结束条件很重要，因为完整的遍历4字节是非常慢的，由于这个值是密码的前4位，可知其应该是在数字、大小写字母中间，所以起始值是0x30303030，结束值是0x7A7A7A7A，刚好将数字、大小写字母全部包含进来

循环体逻辑：
	1、将源代码拷贝到新的缓冲区中
	2、解密缓冲区代码
	3、求缓冲区的hash值
	4、判断求出的hash值与0xAFFE390F是否一致，不是继续
	5、一致输出当前16进制以及字符信息，字符就是密码的前4位
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 1. 将源代码拷贝到新的缓冲区中
memcpy(g_deCode, g_byCode, 0xab0);
// 2. 解密缓冲区代码
decode_code(g_deCode, 0xab0, i);
// 3. 求缓冲区的hash值
DWORD dwHash = Calc_CRC32(0, g_deCode, 0x00000AB0);
// 4. 判断求出的hash值与 `0xAFFE390F` 是否一致，不是继续
if (0xAFFE390F == dwHash)
{ // 5. 一致输出当前16进制以及字符信息，字符就是密码的前4位
    printf("right ! 0x%08x \n", i);
    byte* pByte = (byte*)&i;
    printf("right ! %c %c %c %c \n", pByte[0], pByte[1], pByte[2], pByte[3]);
    getchar();
}
1
2
优化循环
在循环时每次值中的每一个字节如果>=0x3a且<=0x40是不需要判断的，这部分为标点符号

20

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
优化代码：

// 过滤掉该过滤的信息
if ( (i & 0xFF) >=0x3A && (i & 0xFF) <=0X40 ||
    (i & 0xFF) < 0x30 || (i & 0xFF) > 0x7A)
{
    continue;
} else if ((i>>8 & 0xFF) >= 0x3A && (i >> 8 & 0xFF) <= 0X40  ||
    (i >> 8 & 0xFF) < 0x30 || (i >> 8 & 0xFF) > 0x7A
 
    )
{
    continue;
}
else if (( i >> 16 & 0xFF) >= 0x3A && (i >> 16 & 0xFF) <= 0X40 ||
    (i >> 16 & 0xFF) < 0x30 || (i >> 16 & 0xFF) > 0x7A
    )
{
    continue;
}
else if ((i >> 24 & 0xFF) >= 0x3A && (i >> 24 & 0xFF) <= 0X40 ||
    (i >> 24 & 0xFF) < 0x30 || (i >> 24 & 0xFF) > 0x7A)
{
    continue;
}
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
完整暴力破解hash值代码

#include <windows.h>
#include<time.h>
// hash表数组
int g_hashTable[0x400] = {0};
// 是否初始化标志
bool g_IsInit = false;
// hash表的key
unsigned int g_key = 0xEDB88320;
// 用于放解密代码的缓冲区
byte g_deCode[0x00000AB0] = { 0 };
// 源程序 00402010处开始的代码，使用OD数据转换插件，拷贝出来
byte g_byCode[0x00000AB0] = {
        0x33, 0xc0, 0xc3, 0x68, 0x45, 0x7f, 0xab, 0xfb, 0xf8, 0x3f, 0xab, 0x9f, 0x59, 0x6f, 0xcf, 0x16,
}; // 此处省略完整数组代码
 
// 解密缓冲区函数
unsigned int __cdecl decode_code(byte *mem_code, unsigned int nLen, unsigned int password_left_4)
{
    unsigned int result; // eax@1
 
    result = 0;
    password_left_4 ^= 0xD9EE7A1B;
    if (nLen)
    {
        do
        {
            mem_code[result] ^= *((byte *)&password_left_4 + (result & 3));
            ++result;
        } while (result < nLen);
    }
    return result;
}
 
// 初始化hash表函数
unsigned int InitHashTable()
{
    int key; // ebp@1
    unsigned int v1; // edi@1
    int *pData; // ecx@1
    unsigned int result; // eax@2
    signed int v4; // esi@2
 
    key = g_key;
    g_IsInit = 1;
    v1 = 0;
    pData = g_hashTable;
    do
    {
        *pData = v1;
        result = v1;
        v4 = 8;
        do
        {
            result = ((result & 1) != 0 ? key : 0) ^ (result >> 1);
            --v4;
        } while (v4);
        *pData = result;
        ++pData;
        ++v1;
    } while (v1 < 0x400);
    return result;
}
 
// 计算CRC32
 int __cdecl Calc_CRC32(int nFlag, byte *mem_code, int nLen)
{
    int v3; // ecx@3
    unsigned int i; // eax@3
 
    if (!g_IsInit)
        InitHashTable();
    v3 = 0;
    for (i = ~nFlag; v3 < nLen; ++v3)
        i = g_hashTable[(unsigned __int8)i ^ mem_code[v3]] ^ (i >> 8);
    return ~i;
}
 
int main()
{
    clock_t start, finish;
    double totaltime;
    start = clock();
 
    for (unsigned int i = 0x30303030; i < 0x7A7A7A7A; i++)
    {
        // 过滤掉该过滤的信息
        if ( (i & 0xFF) >=0x3A && (i & 0xFF) <=0X40 ||
            (i & 0xFF) < 0x30 || (i & 0xFF) > 0x7A)
        {
            continue;
        } else if ((i>>8 & 0xFF) >= 0x3A && (i >> 8 & 0xFF) <= 0X40  ||
            (i >> 8 & 0xFF) < 0x30 || (i >> 8 & 0xFF) > 0x7A
 
            )
        {
            continue;
        }
        else if (( i >> 16 & 0xFF) >= 0x3A && (i >> 16 & 0xFF) <= 0X40 ||
            (i >> 16 & 0xFF) < 0x30 || (i >> 16 & 0xFF) > 0x7A
            )
        {
            continue;
        }
        else if ((i >> 24 & 0xFF) >= 0x3A && (i >> 24 & 0xFF) <= 0X40 ||
            (i >> 24 & 0xFF) < 0x30 || (i >> 24 & 0xFF) > 0x7A)
        {
            continue;
        }
        // 1. 将源代码拷贝到新的缓冲区中
        memcpy(g_deCode, g_byCode, 0xab0);
        // 2. 解密缓冲区代码
        decode_code(g_deCode, 0xab0, i);
        // 3. 求缓冲区的hash值
        DWORD dwHash = Calc_CRC32(0, g_deCode, 0x00000AB0);
        // 4. 判断求出的hash值与 `0xAFFE390F` 是否一致，不是继续
        if (0xAFFE390F == dwHash)
        { // 5. 一致输出当前16进制以及字符信息，字符就是密码的前4位
            printf("right ! 0x%08x \n", i);
            byte* pByte = (byte*)&i;
            printf("right ! %c %c %c %c \n", pByte[0], pByte[1], pByte[2], pByte[3]);
            finish = clock();
            totaltime = (double)(finish - start) / CLOCKS_PER_SEC;
            printf("此程序的运行时间为 %d 分， %d 秒 ! \n" , (long)totaltime/60, (int)totaltime%60);
 
            getchar();
        }
    }
 
    return 0;
}

21

3. 分析代码

3.1 OD调试之——dump内存

1
2
3
使用OD动态跟踪函数，当输入的密码前4位为BEEF时，内存中会正确解密代码，然后完成对用户名和密码前4位之后的验证和判断

验证函数起始地址：call 402010

22

3.2 动静结合之——函数解析

23

1
2
3
4
5
6
7
IDA结合OD，多次组合判断函数作用

402300处函数：自己定义的类的构造函数
402A40处函数：自己定义的类的成员函数（对ecx指向的空间进行赋值），功能是将传入的10进制字符串转换为16进制
402800处函数：对用户名的16进制形式进行二次修改，即为用户名计算值
4021A0处函数：对密码去除前4位之后的字符串进行修改，即为密码计算值
402330处函数：对象的memcmp，判断用户名计算值与密码计算值是否一致
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
402800处函数：对用户名的16进制数据和常量字符串201510261314的16进制数据进行混合计算

def CalcUser(num1,num2):
  n1 = num2;
  num3 = 0;
  num4 = 0;
  arr = [];
  while n1 != 0:
      n = n1 & 0xffffffff;
      #print hex(n);
      num3 = n * num1;
      num3 += num4;
      #print hex(num3);
      n = num3 & 0xffffffff;
      arr.insert(0, n);
      n1 >>= 32;
      num3 >>= 32;
      if num3 != 0:
          num4 = num3;
  return arr;
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
4021A0处函数：将传入的密码每两个字节转为一个16进制数据，并与0x86进行异或，传入的值不为0-F即返回0

def CalcPassAndXor(passwd):
  array = bytearray(passwd);
  size = len(array);
  arr = [];
  i = 0;
  while i < size:
      ch1 = array[i];
      if ch1 >= 0x30 and ch1 <= 0x39:
          ch1 -= 0x30;
      elif ch1 >= 0x61 and ch1 <=0x66:
          ch1 -= 0x57;
      elif ch1 >= 0x41 and ch1 <=0x46:
          ch1 -= 0x37;
      # print ch1;
      i+=1;
      if i == size:
          break;
      ch2 = array[i];
      if ch2 >= 0x30 and ch2 <= 0x39:
          ch2 -= 0x30;
      elif ch2 >= 0x61 and ch2 <= 0x66:
          ch2 -= 0x57;
      elif ch2 >= 0x41 and ch2 <= 0x46:
          ch2 -= 0x37;
 
      ch3 =  ch1 << 4 | ch2;
      ch3 ^= 0x86;
      arr.append(ch3);
      i += 1;
  return arr;

3.3 完整注册机编写

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
# -*- coding: utf-8 -*-
 
__author__="lantie@15PB"
 
#  将10进制字符串转为16进制
def calc(name,count=10):
    num = 0;
    array = bytearray(name);
    for i in range(0, len(name)):
        by = array[i] - 0x30;
        #print hex(by);
        if num > 0:
            num *= count;
        num += by;
    return num;
 
# 将10进制字符串转为16进制，或将16进制进行一些运算
def calc2(bytearr,count=0x10):
    num = 0;
    array = bytearray(bytearr);
    for i in range(0, len(bytearr)):
        if num > 0:
            num *= count;
        by = array[i];
        by -= 0x30;
        if by >=80:
            by = 256-by;
            print hex(by);
            if num > by:
                num -= by;
        else:
            num += by;
        if num == 0:
            num += by;
    return num;
 
# 对两个数进行计算，以4字节为单位
def CalcUser(num1,num2):
    n1 = num2;
    num3 = 0;
    num4 = 0;
    arr = [];
    while n1 != 0:
        n = n1 & 0xffffffff;
        #print hex(n);
        num3 = n * num1;
        num3 += num4;
        #print hex(num3);
        n = num3 & 0xffffffff;
        arr.insert(0, n);
        n1 >>= 32;
        num3 >>= 32;
        if num3 != 0:
            num4 = num3;
    return arr;
 
# 对密码进行转换。
def CalcPassAndXor(passwd):
    array = bytearray(passwd);
    size = len(array);
    arr = [];
    i = 0;
    while i < size:
        ch1 = array[i];
        if ch1 >= 0x30 and ch1 <= 0x39:
            ch1 -= 0x30;
        elif ch1 >= 0x61 and ch1 <=0x66:
            ch1 -= 0x57;
        elif ch1 >= 0x41 and ch1 <=0x46:
            ch1 -= 0x37;
        # print ch1;
        i+=1;
        if i == size:
            break;
        ch2 = array[i];
        if ch2 >= 0x30 and ch2 <= 0x39:
            ch2 -= 0x30;
        elif ch2 >= 0x61 and ch2 <= 0x66:
            ch2 -= 0x57;
        elif ch2 >= 0x41 and ch2 <= 0x46:
            ch2 -= 0x37;
 
        ch3 =  ch1 << 4 | ch2;
        ch3 ^= 0x86;
        arr.append(ch3);
        i += 1;
    return arr;
 
# 注册机
def CalcPass():
    username = raw_input('please input name: ');
    num1 = calc2(username,10);
    #print 'sum:' + hex(num1);
    num2 = calc2("201510261314",10);
    #print 'sum:' + hex(num2);
    arr = CalcUser(num1,num2)
    password = "BEEF";
    for i in range(len(arr)):
        dic = {'0': 'B6', '1': 'B7', '2': 'B4', '3': 'B5', '4': 'B2', '5': 'B3', '6': 'B0', '7': 'B1', '8': 'BE',
               '9': 'BF', 'A': 'BC', 'B': 'BD', 'C': 'BA', 'D': 'BB', 'E': 'B8', 'F': 'B9'}
 
        string1 = hex(arr[i]).upper();
        for i in range(2, len(string1)):
            ch = string1[i];
            if ch == 'L':
                continue;
            # print dic[ch];
            password += dic[ch];
    print "password: " + password;
 
 
if __name__ == '__main__':
    CalcPass();

24

4. 总结

这个题目从OD、IDA等分析工具的使用，到VS、python代码的编写，是一个很综合的题目。动态调试和静态分析可以说是完美的结合了起来，方方面面的能力都可以得到锻炼。强烈推荐自己去学习一遍。

5. 感谢

最后，非常感谢 lantie@15PB 师傅的帖子，写的异常详细，考虑到了各种问题。帖子的链接已放在文章下面，强推！！！

1
https://bbs.pediy.com/thread-221038.htm
本文作者： foxcookie
发布时间： 2020-11-18
最后更新： 2023-07-21
本文标题： 看雪Re_翩若惊鸿
本文链接： https://foxcookie.github.io/2020/11/18/看雪Re-翩若惊鸿/
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明出处！

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

歪比巴卜？