-
-
[原创]wrar501 注册文件破解之一
-
发表于: 2014-3-24 01:48
-
最后一个算法没整明白。。我希望以后有时间能把他整明白。感觉自个好菜。
。希望论坛里面有大神能够指点迷津。。没整出来心里总是不舒服。
下面是上个礼拜整理的。。
上个帖子叫wrar501的爆破过程，里面提到两个函数说到004A74D0，00420B40
分析了可以发现函数004A74D0是调用了函数00420B40的。而且对其两个函数下断，先断下来的是004A74D0
所以重点分析函数004A74D0。（函数很长，过程很累很迷茫。。。）
0012B428 004B1A76 返回到 WinRAR.004B1A76 来自 WinRAR.004A74D0
0012B42C 00000000
上面注解了4步。首先第一步，它是查找文件。在目录C:\Documents and Settings\Administrator\Application Data\WinRAR
和程序目录C:\Program Files\WinRAR下查找rarreg.* 类的文件。比如rarreg.key 就能查找出来。具体第一步调用FindFirstFileW和调用FindNextFileW来遍历文件我就不分析了，
重点在于获取了相关文件后对文件的处理
在第一步跟下去会发现如下调用语句：
其实就是调用函数00420B40
函数004204E0才是关键。这个函数也是第四步调用的函数。。。先不管
继续上面四个步骤
第二步。往里跟会发现它在读一个注册表HKEY_LOCAL_MACHINE\software\WinRAR下的键rarkey的值
而第三步，在第二步的基础上，如果第二步读取失败就进行第三步。。。读的注册表项是HKEY_CURRENT_USER\software\WinRAR下的键rarkey的值
如果第二、三步都失败，则不进行第四步。
第四步就简单了。。就是把读取出来的值调用函数004204E0进行运算了。运算结果 决定了软件是否注册。
既然函数004204E0很重要，那就分析它吧。。但分析前，需要自己先构建出 rarreg.key 文件(或注册表项，作用是等价的)
OD重载对函数004204E0下断
00125344 00420BF2 返回到 WinRAR.00420BF2 来自 WinRAR.004204E0
00125348 00B7C6A0 ASCII "A=1234567890abcdefghijklmnopqrstuvwzyx",CR,LF,"B=123WERWEFAWF2ERWEFWEFWEF",CR,LF,"C=123WEQR32R4E2EWDF",CR,LF,"D=123123WEDSFWRSDF",CR,LF,"F=SDDFDF324343245DSFWFD"
0012534C 00000084
00125350 00000000
函数004204E0三个参数
第一个是指向文件内容的指针，第二个是文件大小，第三个为0、、、、（函数004204E0很长很恐怖，唉）
首先会调用一个函数
地址004D90F8的值是固定的。。函数00428520是个算法这个算法会返回一个值。当然内容固定返回的值也是固定的。。
先说下这个函数00428520式非常重要的，后面很多地方都用到了。
-->注意这里停断一下，去分析函数00428520了-->函数被我注释为get_4byte 哈哈
这个算法函数涉及好几个表4F82D0、4F86D0、4F8AD0、4F92D0、4F96D0、4F9AD0、4F8ED0、4F9ED0。（好晕，不想分析这个函数。。唉）
表的数据就不复制出来了。。
主要思路是在上面注解中写明了。。主要就是在表中取数据异或。
调用完函数00428520进行比较判断，接下来调用子函数004C2670
子函数应该是初始化数据的函数，这里初始化了004F3CC8数据为0
没办法只好分析子函数00420460 比较简单，代码不贴了。这个函数主要用来通过0xD 0xA来区分数据 并把数据复制在不同的地方
主要有四个数据:
004F3CC8 42 3D 31 32 33 57 45 52 57 45 46 41 57 46 32 45 B=123WERWEFAWF2E
004F3CD8 52 57 45 46 57 45 46 57 45 46 RWEFWEFWEF
004F3DC8 43 3D 31 32 33 57 45 51 52 33 32 52 34 45 32 45 C=123WEQR32R4E2E
004F3DD8 57 44 46 00 WDF.
00124A40 44 3D 31 32 33 31 32 33 57 45 44 53 46 57 52 53 D=123123WEDSFWRS
00124A50 44 46 00 DF.
00124640 46 3D 53 44 44 46 44 46 33 32 34 33 34 33 32 34 F=SDDFDF32434324
00124650 35 44 53 46 57 46 44 00 5DSFWFD.
这四块数据是很重要的，都是从文件读出来的。。
---(注意这是伪造的数据都是错误的以后为了让程序继续运行下去，我会动态的修改内存数据，大家看的时候要不认数据只认地址)
(当然都是我伪造的)伪造数据如下：
A=1234567890abcdefghijklmnopqrstuvwzyx
B=123WERWEFAWF2ERWEFWEFWEF
C=123WEQR32R4E2EWDF
D=123123WEDSFWRSDF
F=SDDFDF324343245DSFWFD
子函数0047F8A0代码，比较简单
上述函数 首先操作的数据是00124640 。地址00124640里面的前10个字节分成(2+3+3+2)四个部分
取出每个字节判断是否为 数字，如果是数字运算一下 把结果存放起来。。这样就获得四个数值。。这是个数值正是后面要用的。。
它把前面获取的四个数值 分别作为长度 分段地址00124640，后10个字节的数据，并且存放在
004F3EC8 、 004F41C8 、004F40C8 、004F3FC8 四个地址中。。(记住四个地址也很重要)
对地址00124640分段后的数据继续调用函数 004C4250获取一个数值 存放在4F42C8 。。获取的这个值很重要。。后面分析
拿004F3DC8、004F3CC8、004F3EC8 、 004F41C8 、004F40C8 、004F3FC8 六处的数据 给子函数00428520运算
然后获取的值与4F42C8进行比较，如果不相等就注册失败了。
这段代码主要用来对地址004F3DC8的内容进行循环。。查找Version:(VersMax:) 和DataMax:
这里有判断版本号 和时间的一些地方。如果不正确就注册失败。
这是函数的最后 涉及到一个局部变量：byte ptr [esp+D58]。然后是两个子函数的调用：00431680 和 00431490
好累。脑子像个浆糊似得。(请允许我蛋疼一会儿......)
现在流程大概明白了，差几点：
函数004C3FF6怎么生成数值.调用的地方有5处 A1 B1 B2 B3 B4
变量byte ptr [esp+D58]
子函数00431490有做了什么运算
子函数00431680 做了什么
接下来。首先了解变量byte ptr [esp+D58] 什么地方赋的值 因为这是个esp寻址 (不好找)
运行到地址004209EF时
堆栈 ss:[00125350]=00
Jumps from 004207F4, 004209E6
他其实是调用函数004204E0时的第三个参数。。先不管这个参数的值是怎么来的。。分析一下 函数004C3FF6
这个函数 会通过一个全局变量58A7A4 判断。。内存搜索58A7A4 发现没有对其赋值的地方 而且它的初始值是0。先不管
继而调用函数004C3FF6
函数004C3FF6
这个函数代码很长。。其实可以忽略好多东西，函数004C3FF6把字符串形式的十进制数据变为十六进制返回。。
比如我们要这个函数返回0x26E831B8。。只需传入字符串"652751288" 0x26E831B8=652751288
Ok。这个时候我们要运行到你
004209EF > \80BC24 580D00>cmp byte ptr [esp+D58], 0
这条语句时才能接着分析函数00431490、00431680
具体怎么能运行到地址004209EF，我就不用语言组织了。。。。我准备另开一贴，把生成注册文件的代码贴出来。。
现在我给出了能运行到地址004209EF的一个key文件内容。。(保存文件名为rarreg.key 到程序目录或者是C:\Documents and Settings\Administrator\Application Data\WinRAR下)
A=1234567890abcdefghijklmnopqrstuvwzyx
B=123WERWEFAWF2ERWEFWEFWEF
VersMax: 5.1 DateMax: 2015.12.23
D=123123WEDSFWRSDF
1212r12d10aaaaaaaaaaaabbbbbbbbbbbbccccccccccccdddddddddd2978471197
在
004209FD . B8 C83D4F00 mov eax, 004F3DC8 ; ASCII "VersMax: 5.1 DateMax: 2015.12.23"
处下断
F9 运行走起。。。不一会儿断在了地址004209FD
分析函数00431680发现函数00431680转而调用函数00431680 。。又是一个搞得好晕的函数。。唉
惭愧函数00431680 和 函数 函数00431490 没整明白。。应该是一个算法。。
想想还是先贴出来，让有兴趣的童鞋研究一下。
。附件里有 程序的udd文件注释的不好。不要见怪。
有时间我会继续努力弄明白的。。
我的wrar安装目录是 C:\Program Files\WinRAR1
。希望论坛里面有大神能够指点迷津。。没整出来心里总是不舒服。下面是上个礼拜整理的。。
上个帖子叫wrar501的爆破过程，里面提到两个函数说到004A74D0，00420B40
分析了可以发现函数004A74D0是调用了函数00420B40的。而且对其两个函数下断，先断下来的是004A74D0
所以重点分析函数004A74D0。（函数很长，过程很累很迷茫。。。）
0012B428 004B1A76 返回到 WinRAR.004B1A76 来自 WinRAR.004A74D0
0012B42C 00000000
可以看到给这个函数004A74D0传的参数是0(其实这个参数不是0就是1)
004A74D0 /$ B8 04100000 mov eax, 1004 ; 22
004A74D5 |. E8 66A70100 call 004C1C40
004A74DA |. A1 B4C04E00 mov eax, dword ptr [4EC0B4]
004A74DF |. 33C4 xor eax, esp
004A74E1 |. 898424 001000>mov dword ptr [esp+1000], eax
004A74E8 |. 56 push esi
004A74E9 |. 8BB424 0C1000>mov esi, dword ptr [esp+100C]
004A74F0 |. 56 push esi
004A74F1 |. E8 4A97F7FF call 00420C40 ; 第一步
004A74F6 |. 84C0 test al, al
004A74F8 |. 74 1A je short 004A7514
004A74FA |. B0 01 mov al, 1
004A74FC |. 5E pop esi
004A74FD |. 8B8C24 001000>mov ecx, dword ptr [esp+1000]
004A7504 |. 33CC xor ecx, esp
004A7506 |. E8 17A70100 call 004C1C22
004A750B |. 81C4 04100000 add esp, 1004
004A7511 |. C2 0400 retn 4
004A7514 |> 68 FF0F0000 push 0FFF
004A7519 |. 6A 00 push 0
004A751B |. 8D4424 0C lea eax, dword ptr [esp+C]
004A751F |. 50 push eax
004A7520 |. 68 ACBC4D00 push 004DBCAC ; r
004A7525 |. 68 A8AD4D00 push 004DADA8 ; s
004A752A |. 68 02000080 push 80000002
004A752F |. E8 7C54FCFF call 0046C9B0 ; 第二步
004A7534 |. 85C0 test eax, eax
004A7536 |. 75 38 jnz short 004A7570
004A7538 |. 68 00100000 push 1000
004A753D |. 50 push eax
004A753E |. 8D4C24 0C lea ecx, dword ptr [esp+C]
004A7542 |. 51 push ecx
004A7543 |. 68 ACBC4D00 push 004DBCAC ; r
004A7548 |. 68 FC894D00 push 004D89FC
004A754D |. E8 AE59FCFF call 0046CF00 ; 第三步
004A7552 |. 85C0 test eax, eax
004A7554 |. 75 1A jnz short 004A7570
004A7556 |. 32C0 xor al, al
004A7558 |. 5E pop esi
004A7559 |. 8B8C24 001000>mov ecx, dword ptr [esp+1000]
004A7560 |. 33CC xor ecx, esp
004A7562 |. E8 BBA60100 call 004C1C22
004A7567 |. 81C4 04100000 add esp, 1004
004A756D |. C2 0400 retn 4
004A7570 |> 56 push esi ; 第四步
004A7571 |. 50 push eax
004A7572 |. 8D5424 0C lea edx, dword ptr [esp+C]
004A7576 |. 52 push edx
004A7577 |. E8 648FF7FF call 004204E0
004A757C |. 8B8C24 041000>mov ecx, dword ptr [esp+1004]
004A7583 |. 5E pop esi
004A7584 |. 33CC xor ecx, esp
004A7586 |. E8 97A60100 call 004C1C22
004A758B |. 81C4 04100000 add esp, 1004
004A7591 \. C2 0400 retn 4
上面注解了4步。首先第一步，它是查找文件。在目录C:\Documents and Settings\Administrator\Application Data\WinRAR
和程序目录C:\Program Files\WinRAR下查找rarreg.* 类的文件。比如rarreg.key 就能查找出来。具体第一步调用FindFirstFileW和调用FindNextFileW来遍历文件我就不分析了，
重点在于获取了相关文件后对文件的处理
在第一步跟下去会发现如下调用语句：
00420D40 > /8B8424 7C4000>mov eax, dword ptr [esp+407C]
00420D47 . |50 push eax
00420D48 . |8D4C24 1C lea ecx, dword ptr [esp+1C]
00420D4C . |51 push ecx
00420D4D . |E8 EEFDFFFF call 00420B40
其实就是调用函数00420B40
然后继续跟函数00420B40，会发现
00420BE3 |. 8B8C24 481000>mov ecx, dword ptr [esp+1048]
00420BEA |. 51 push ecx
00420BEB |. 50 push eax
00420BEC |. 56 push esi
00420BED |. E8 EEF8FFFF call 004204E0
00420BF2 |. 84C0 test al, al
函数004204E0才是关键。这个函数也是第四步调用的函数。。。先不管
继续上面四个步骤
第二步。往里跟会发现它在读一个注册表HKEY_LOCAL_MACHINE\software\WinRAR下的键rarkey的值
而第三步，在第二步的基础上，如果第二步读取失败就进行第三步。。。读的注册表项是HKEY_CURRENT_USER\software\WinRAR下的键rarkey的值
如果第二、三步都失败，则不进行第四步。
第四步就简单了。。就是把读取出来的值调用函数004204E0进行运算了。运算结果 决定了软件是否注册。
既然函数004204E0很重要，那就分析它吧。。但分析前，需要自己先构建出 rarreg.key 文件(或注册表项，作用是等价的)
OD重载对函数004204E0下断
00125344 00420BF2 返回到 WinRAR.00420BF2 来自 WinRAR.004204E0
00125348 00B7C6A0 ASCII "A=1234567890abcdefghijklmnopqrstuvwzyx",CR,LF,"B=123WERWEFAWF2ERWEFWEFWEF",CR,LF,"C=123WEQR32R4E2EWDF",CR,LF,"D=123123WEDSFWRSDF",CR,LF,"F=SDDFDF324343245DSFWFD"
0012534C 00000084
00125350 00000000
函数004204E0三个参数
第一个是指向文件内容的指针，第二个是文件大小，第三个为0、、、、（函数004204E0很长很恐怖，唉）
函数004204E0开始：
004204E0 $ 81EC 3C0D0000 sub esp, 0D3C ; 关键函数
004204E6 . A1 B4C04E00 mov eax, dword ptr [4EC0B4]
004204EB . 33C4 xor eax, esp
004204ED . 898424 380D00>mov dword ptr [esp+D38], eax
004204F4 . 8B8424 400D00>mov eax, dword ptr [esp+D40]
004204FB . 6A 40 push 40
004204FD . 68 F8904D00 push 004D90F8 ; 70c2441db366d92ea7be1342b3bf629026ba92bb675f06e684bdd34511097434
00420502 . 6A FF push -1
00420504 . 894424 0C mov dword ptr [esp+C], eax
00420508 . E8 13800000 call 00428520
0042050D . 3D B831E826 cmp eax, 26E831B8
首先会调用一个函数
地址004D90F8的值是固定的。。函数00428520是个算法这个算法会返回一个值。当然内容固定返回的值也是固定的。。
先说下这个函数00428520式非常重要的，后面很多地方都用到了。
-->注意这里停断一下，去分析函数00428520了-->函数被我注释为get_4byte 哈哈
参数
001245FC FFFFFFFF |Arg1 = FFFFFFFF
00124600 004D90F8 |Arg2 = 004D90F8 ASCII "70c2441db366d92ea7be1342b3bf629026ba92bb675f06e684bdd34511097434"
00124604 00000040 \Arg3 = 00000040
子函数00428520：
00428520 /$ 8B4C24 08 mov ecx, dword ptr [esp+8] ; get_4bytes
00428524 |. 8B4424 04 mov eax, dword ptr [esp+4]
00428528 |. 56 push esi
00428529 |. 8B7424 10 mov esi, dword ptr [esp+10]
0042852D |. 57 push edi
0042852E |. 85F6 test esi, esi
00428530 |. 76 1D jbe short 0042854F
00428532 |> F6C1 07 /test cl, 7 ; 指示应该是test si,7啊
00428535 |. 74 18 |je short 0042854F
00428537 |. 0FB611 |movzx edx, byte ptr [ecx] ; 这段循环代码不会执行吧 ecx是我们要操作的地址，
0042853A |. 0FB6F8 |movzx edi, al ; 然后低一字节拿来跟0x7比较。为毛要这么做
0042853D |. 33D7 |xor edx, edi
0042853F |. C1E8 08 |shr eax, 8
00428542 |. 330495 D0824F>|xor eax, dword ptr [edx*4+4F82D0]
00428549 |. 4E |dec esi
0042854A |. 41 |inc ecx
0042854B |. 85F6 |test esi, esi
0042854D |.^ 77 E3 \ja short 00428532
0042854F |> 83FE 08 cmp esi, 8 ; 先判断数据长度是否小于8
00428552 |. 0F82 90000000 jb 004285E8
00428558 |. 8BFE mov edi, esi
0042855A |. 53 push ebx
0042855B |. C1EF 03 shr edi, 3 ; 这个开始数据8个字节8个字节来使用
0042855E |. 55 push ebp ; 设这个八个字节分别为a0 a1 a2 a3 a4 a5 a6 a7
0042855F |. 90 nop
00428560 |> 8B51 04 /mov edx, dword ptr [ecx+4]
00428563 |. 3301 |xor eax, dword ptr [ecx] ; 先前四个字节跟eax异或，其实eax是参数-1
00428565 |. 8BDA |mov ebx, edx
00428567 |. C1EB 10 |shr ebx, 10
0042856A |. 0FB6DB |movzx ebx, bl
0042856D |. 8B1C9D D0864F>|mov ebx, dword ptr [ebx*4+4F86D0] ; a6 作为 表4F86D0的下标
00428574 |. 894C24 14 |mov dword ptr [esp+14], ecx
00428578 |. 8BEA |mov ebp, edx
0042857A |. C1ED 18 |shr ebp, 18
0042857D |. 331CAD D0824F>|xor ebx, dword ptr [ebp*4+4F82D0] ; a7 作为表4F82DO的下标
00428584 |. 8BCA |mov ecx, edx
00428586 |. C1E9 08 |shr ecx, 8
00428589 |. 0FB6E9 |movzx ebp, cl
0042858C |. 331CAD D08A4F>|xor ebx, dword ptr [ebp*4+4F8AD0] ; a5 作为表4F8ADO 下标
00428593 |. 8BE8 |mov ebp, eax
00428595 |. C1ED 18 |shr ebp, 18
00428598 |. 331CAD D0924F>|xor ebx, dword ptr [ebp*4+4F92D0] ; a3 作为表4f92d0的下标
0042859F |. 8BC8 |mov ecx, eax
004285A1 |. C1E9 10 |shr ecx, 10
004285A4 |. 0FB6E9 |movzx ebp, cl
004285A7 |. 331CAD D0964F>|xor ebx, dword ptr [ebp*4+4F96D0] ; a2 作为4F96D0的下标
004285AE |. 8BC8 |mov ecx, eax
004285B0 |. C1E9 08 |shr ecx, 8
004285B3 |. 0FB6E9 |movzx ebp, cl
004285B6 |. 331CAD D09A4F>|xor ebx, dword ptr [ebp*4+4F9AD0] ; a1 作为表4F9AD0的下标
004285BD |. 8B4C24 14 |mov ecx, dword ptr [esp+14]
004285C1 |. 0FB6D2 |movzx edx, dl
004285C4 |. 331C95 D08E4F>|xor ebx, dword ptr [edx*4+4F8ED0] ; a4 作为表4F8ED0的下标
004285CB |. 0FB6C0 |movzx eax, al
004285CE |. 331C85 D09E4F>|xor ebx, dword ptr [eax*4+4F9ED0] ; a0作为4F9ED0的下标
004285D5 |. 83EE 08 |sub esi, 8
004285D8 |. 83C1 08 |add ecx, 8
004285DB |. 83EF 01 |sub edi, 1
004285DE |. 8BC3 |mov eax, ebx ; 所有异或的值又给了eax
004285E0 |.^ 0F85 7AFFFFFF \jnz 00428560
004285E6 |. 5D pop ebp
004285E7 |. 5B pop ebx
004285E8 |> 85F6 test esi, esi
004285EA |. 76 1C jbe short 00428608
004285EC |. 8D6424 00 lea esp, dword ptr [esp] ; 这里处理剩余的字节(不够的八字节)
004285F0 |> 0FB611 /movzx edx, byte ptr [ecx]
004285F3 |. 0FB6F8 |movzx edi, al
004285F6 |. 33D7 |xor edx, edi
004285F8 |. C1E8 08 |shr eax, 8
004285FB |. 330495 D0824F>|xor eax, dword ptr [edx*4+4F82D0]
00428602 |. 4E |dec esi
00428603 |. 41 |inc ecx
00428604 |. 85F6 |test esi, esi
00428606 |.^ 77 E8 \ja short 004285F0
00428608 |> 5F pop edi
00428609 |. 5E pop esi
0042860A \. C2 0C00 retn 0C
这个算法函数涉及好几个表4F82D0、4F86D0、4F8AD0、4F92D0、4F96D0、4F9AD0、4F8ED0、4F9ED0。（好晕，不想分析这个函数。。唉）
表的数据就不复制出来了。。
主要思路是在上面注解中写明了。。主要就是在表中取数据异或。
OK，回到函数004204E0：
0042050D . 3D B831E826 cmp eax, 26E831B8
00420512 . /74 19 je short 0042052D
00420514 . |32C0 xor al, al
00420516 . |8B8C24 380D00>mov ecx, dword ptr [esp+D38]
0042051D . |33CC xor ecx, esp
0042051F . |E8 FE160A00 call 004C1C22
00420524 . |81C4 3C0D0000 add esp, 0D3C
0042052A . |C2 0C00 retn 0C
0042052D > \53 push ebx
0042052E . 56 push esi
0042052F . 68 04060000 push 604
00420534 . 6A 00 push 0
00420536 . 68 C83C4F00 push 004F3CC8
0042053B . E8 30210A00 call 004C2670
00420540 . 83C4 0C add esp, 0C
调用完函数00428520进行比较判断，接下来调用子函数004C2670
子函数应该是初始化数据的函数，这里初始化了004F3CC8数据为0
接下来一系列调用函数00420460的操作：
00420543 . 68 00040000 push 400
00420548 . 8D4C24 44 lea ecx, dword ptr [esp+44]
0042054C . 51 push ecx
0042054D . 8D8424 540D00>lea eax, dword ptr [esp+D54] ; 大小
00420554 . 8D7424 10 lea esi, dword ptr [esp+10] ; 指向数据
00420558 . E8 03FFFFFF call 00420460
0042055D . 84C0 test al, al
0042055F . 74 26 je short 00420587
00420561 . B3 23 mov bl, 23 ; # 应该是注释
00420563 > 385C24 40 cmp byte ptr [esp+40], bl
00420567 . 75 1E jnz short 00420587
00420569 . 68 00040000 push 400
0042056E . 8D5424 44 lea edx, dword ptr [esp+44]
00420572 . 52 push edx
00420573 . 8D8424 540D00>lea eax, dword ptr [esp+D54]
0042057A . 8D7424 10 lea esi, dword ptr [esp+10]
0042057E . E8 DDFEFFFF call 00420460
00420583 . 84C0 test al, al
00420585 .^ 75 DC jnz short 00420563
00420587 > 57 push edi
00420588 . 68 00010000 push 100
0042058D . 68 C83C4F00 push 004F3CC8
00420592 . 8D8424 580D00>lea eax, dword ptr [esp+D58]
00420599 . 8D7424 14 lea esi, dword ptr [esp+14]
0042059D . E8 BEFEFFFF call 00420460
004205A2 . 68 00010000 push 100
004205A7 . 68 C83D4F00 push 004F3DC8
004205AC . 8D8424 580D00>lea eax, dword ptr [esp+D58]
004205B3 . E8 A8FEFFFF call 00420460
004205B8 . 68 80000000 push 80
004205BD . 8D8424 480400>lea eax, dword ptr [esp+448]
004205C4 . 50 push eax
004205C5 . 8D8424 580D00>lea eax, dword ptr [esp+D58]
004205CC . E8 8FFEFFFF call 00420460
004205D1 . 33FF xor edi, edi
004205D3 > B9 00040000 mov ecx, 400 ; 这里有个循环 覆盖了第一次复制出的数据
004205D8 . 2BCF sub ecx, edi
004205DA . 51 push ecx
004205DB . 8D543C 48 lea edx, dword ptr [esp+edi+48]
004205DF . 52 push edx
004205E0 . 8D8424 580D00>lea eax, dword ptr [esp+D58]
004205E7 . 8D7424 14 lea esi, dword ptr [esp+14]
004205EB . E8 70FEFFFF call 00420460
004205F0 . 83C7 36 add edi, 36
004205F3 . 81FF 7A010000 cmp edi, 17A ; 17A/36 == 7
004205F9 .^ 7C D8 jl short 004205D3
没办法只好分析子函数00420460 比较简单，代码不贴了。这个函数主要用来通过0xD 0xA来区分数据 并把数据复制在不同的地方
主要有四个数据:
004F3CC8 42 3D 31 32 33 57 45 52 57 45 46 41 57 46 32 45 B=123WERWEFAWF2E
004F3CD8 52 57 45 46 57 45 46 57 45 46 RWEFWEFWEF
004F3DC8 43 3D 31 32 33 57 45 51 52 33 32 52 34 45 32 45 C=123WEQR32R4E2E
004F3DD8 57 44 46 00 WDF.
00124A40 44 3D 31 32 33 31 32 33 57 45 44 53 46 57 52 53 D=123123WEDSFWRS
00124A50 44 46 00 DF.
00124640 46 3D 53 44 44 46 44 46 33 32 34 33 34 33 32 34 F=SDDFDF32434324
00124650 35 44 53 46 57 46 44 00 5DSFWFD.
这四块数据是很重要的，都是从文件读出来的。。
---(注意这是伪造的数据都是错误的以后为了让程序继续运行下去，我会动态的修改内存数据，大家看的时候要不认数据只认地址)
(当然都是我伪造的)伪造数据如下：
A=1234567890abcdefghijklmnopqrstuvwzyx
B=123WERWEFAWF2ERWEFWEFWEF
C=123WEQR32R4E2EWDF
D=123123WEDSFWRSDF
F=SDDFDF324343245DSFWFD
接下来 (函数004204E0)：
004205F9 .^\7C D8 jl short 004205D3
004205FB . 33F6 xor esi, esi
004205FD . 33FF xor edi, edi
004205FF . 90 nop
00420600 > 0FBE443C 44 movsx eax, byte ptr [esp+edi+44] ; 第一个字节
00420605 . 50 push eax
00420606 . E8 95F20500 call 0047F8A0
0042060B . 84C0 test al, al
0042060D . 74 12 je short 00420621
0042060F . 0FBE543C 44 movsx edx, byte ptr [esp+edi+44]
00420614 . 47 inc edi
00420615 . 83FF 02 cmp edi, 2
00420618 . 8D0CB6 lea ecx, dword ptr [esi+esi*4]
0042061B . 8D744A D0 lea esi, dword ptr [edx+ecx*2-30] ; 运算后的值放在esi中
0042061F .^ 7C DF jl short 00420600
00420621 > 55 push ebp
00420622 . 33ED xor ebp, ebp ; ebp 初始化为0
00420624 . 33FF xor edi, edi
00420626 . EB 08 jmp short 00420630
00420628 . 8DA424 000000>lea esp, dword ptr [esp]
0042062F . 90 nop
00420630 > 0FBE443C 4A movsx eax, byte ptr [esp+edi+4A]
00420635 . 50 push eax
00420636 . E8 65F20500 call 0047F8A0
0042063B . 84C0 test al, al
0042063D . 74 13 je short 00420652
0042063F . 0FBE543C 4A movsx edx, byte ptr [esp+edi+4A] ; 越过1个字节
00420644 . 47 inc edi
00420645 . 83FF 03 cmp edi, 3
00420648 . 8D4CAD 00 lea ecx, dword ptr [ebp+ebp*4]
0042064C . 8D6C4A D0 lea ebp, dword ptr [edx+ecx*2-30] ; 值放在 EBP中
00420650 .^ 7C DE jl short 00420630
00420652 > 33DB xor ebx, ebx
00420654 . 33FF xor edi, edi
00420656 . EB 08 jmp short 00420660
00420658 . 8DA424 000000>lea esp, dword ptr [esp]
0042065F . 90 nop
00420660 > 0FBE443C 4D movsx eax, byte ptr [esp+edi+4D] ; 又越过2个字节。
00420665 . 50 push eax
00420666 . E8 35F20500 call 0047F8A0
0042066B . 84C0 test al, al
0042066D . 74 12 je short 00420681
0042066F . 0FBE543C 4D movsx edx, byte ptr [esp+edi+4D]
00420674 . 47 inc edi
00420675 . 83FF 03 cmp edi, 3 ; 这次也比较了3次 值放在 ebx
00420678 . 8D0C9B lea ecx, dword ptr [ebx+ebx*4]
0042067B . 8D5C4A D0 lea ebx, dword ptr [edx+ecx*2-30]
0042067F .^ 7C DF jl short 00420660
00420681 > 33FF xor edi, edi
00420683 . 897C24 10 mov dword ptr [esp+10], edi
00420687 . EB 07 jmp short 00420690
00420689 . 8DA424 000000>lea esp, dword ptr [esp]
00420690 > 8B4424 10 mov eax, dword ptr [esp+10]
00420694 . 0FBE4C04 50 movsx ecx, byte ptr [esp+eax+50] ; 又越过3个字节
00420699 . 51 push ecx
0042069A . E8 01F20500 call 0047F8A0
0042069F . 84C0 test al, al
004206A1 . 74 1A je short 004206BD
004206A3 . 8B4424 10 mov eax, dword ptr [esp+10]
004206A7 . 0FBE4C04 50 movsx ecx, byte ptr [esp+eax+50]
004206AC . 40 inc eax
004206AD . 83F8 02 cmp eax, 2 ; 两次
004206B0 . 8D14BF lea edx, dword ptr [edi+edi*4]
004206B3 . 8D7C51 D0 lea edi, dword ptr [ecx+edx*2-30] ; 值放在edi
004206B7 . 894424 10 mov dword ptr [esp+10], eax
004206BB .^ 7C D3 jl short 00420690
004206BD > 81FD 00010000 cmp ebp, 100
004206C3 . 0F8F 90010000 jg 00420859
004206C9 . 81FB 00010000 cmp ebx, 100
004206CF . 0F8F 84010000 jg 00420859
子函数0047F8A0代码，比较简单
0047F8A0 /$ 8B4424 04 mov eax, dword ptr [esp+4] ; 比较是否为数字0-9(0x30-0x39) 如果是数字返回1 否则返回0
0047F8A4 |. 83C0 D0 add eax, -30
0047F8A7 |. B9 09000000 mov ecx, 9
0047F8AC |. 3BC8 cmp ecx, eax
0047F8AE |. 1BC0 sbb eax, eax ; 带借位减法
0047F8B0 |. 40 inc eax
0047F8B1 \. C2 0400 retn 4
上述函数 首先操作的数据是00124640 。地址00124640里面的前10个字节分成(2+3+3+2)四个部分
取出每个字节判断是否为 数字，如果是数字运算一下 把结果存放起来。。这样就获得四个数值。。这是个数值正是后面要用的。。
接下来（函数004204E0）:
004206CF . /0F8F 84010000 jg 00420859
004206D5 . |56 push esi
004206D6 . |8D5424 56 lea edx, dword ptr [esp+56] ; 越过前10个字节 （2+3+3+2）
004206DA . |52 push edx
004206DB . |68 C83E4F00 push 004F3EC8
004206E0 . |E8 3B360A00 call 004C3D20 ; 这个函数是复制数据
004206E5 . |55 push ebp
004206E6 . |8D7434 62 lea esi, dword ptr [esp+esi+62]
004206EA . |56 push esi
004206EB . |68 C8414F00 push 004F41C8
004206F0 . |E8 2B360A00 call 004C3D20
004206F5 . |53 push ebx
004206F6 . |03F5 add esi, ebp
004206F8 . |56 push esi
004206F9 . |68 C8404F00 push 004F40C8
004206FE . |E8 1D360A00 call 004C3D20
00420703 . |57 push edi
00420704 . |03F3 add esi, ebx
00420706 . |56 push esi
00420707 . |68 C83F4F00 push 004F3FC8
0042070C . |E8 0F360A00 call 004C3D20
它把前面获取的四个数值 分别作为长度 分段地址00124640，后10个字节的数据，并且存放在
004F3EC8 、 004F41C8 、004F40C8 、004F3FC8 四个地址中。。(记住四个地址也很重要)
接下来 (函数004204E0):
00420711 . 6A 0A push 0A ; |Arg3 = 0000000A
00420713 . 6A 00 push 0 ; |Arg2 = 00000000
00420715 . 03FE add edi, esi ; |
00420717 . 57 push edi ; |Arg1
00420718 . E8 333B0A00 call 004C4250 ; \剩下的数据传入这个函数 获取一个值赋给了4F42C8
0042071D . A3 C8424F00 mov dword ptr [4F42C8], eax ; 函数004C4250最终指向函数004C3FF6(PS：这个后面有关)
;调用函数004C3FF6 标为A1
对地址00124640分段后的数据继续调用函数 004C4250获取一个数值 存放在4F42C8 。。获取的这个值很重要。。后面分析
接下来 (函数004204E0)：
00420722 . B8 C83D4F00 mov eax, 004F3DC8 ;
00420727 . 83C4 3C add esp, 3C ; 接下来处理004F3DC8里面的数据
0042072A . 8D48 01 lea ecx, dword ptr [eax+1]
0042072D . 8D49 00 lea ecx, dword ptr [ecx]
00420730 > 8A10 mov dl, byte ptr [eax]
00420732 . 40 inc eax
00420733 . 84D2 test dl, dl
00420735 .^ 75 F9 jnz short 00420730
00420737 . 2BC1 sub eax, ecx ; 计算不为的0字节长度
00420739 . 50 push eax
0042073A . 68 C83D4F00 push 004F3DC8 ;
0042073F . 6A FF push -1
00420741 . E8 DA7D0000 call 00428520 ; 我擦、、这个函数还是蛮关键的。。
00420746 . B9 C83C4F00 mov ecx, 004F3CC8 ;
0042074B . 8D71 01 lea esi, dword ptr [ecx+1]
0042074E . 8BFF mov edi, edi
00420750 > 8A11 mov dl, byte ptr [ecx]
00420752 . 41 inc ecx
00420753 . 84D2 test dl, dl
00420755 .^ 75 F9 jnz short 00420750
00420757 . 2BCE sub ecx, esi
00420759 . 51 push ecx
0042075A . 68 C83C4F00 push 004F3CC8 ;
0042075F . 50 push eax
00420760 . E8 BB7D0000 call 00428520
00420765 . B9 C83E4F00 mov ecx, 004F3EC8
0042076A . 8D71 01 lea esi, dword ptr [ecx+1]
0042076D . 8D49 00 lea ecx, dword ptr [ecx]
00420770 > 8A11 mov dl, byte ptr [ecx]
00420772 . 41 inc ecx
00420773 . 84D2 test dl, dl
00420775 .^ 75 F9 jnz short 00420770
00420777 . 2BCE sub ecx, esi
00420779 . 51 push ecx
0042077A . 68 C83E4F00 push 004F3EC8
0042077F . 50 push eax
00420780 . E8 9B7D0000 call 00428520
00420785 . B9 C8414F00 mov ecx, 004F41C8
0042078A . 8D71 01 lea esi, dword ptr [ecx+1]
0042078D . 8D49 00 lea ecx, dword ptr [ecx]
00420790 > 8A11 mov dl, byte ptr [ecx]
00420792 . 41 inc ecx
00420793 . 84D2 test dl, dl
00420795 .^ 75 F9 jnz short 00420790
00420797 . 2BCE sub ecx, esi
00420799 . 51 push ecx
0042079A . 68 C8414F00 push 004F41C8
0042079F . 50 push eax
004207A0 . E8 7B7D0000 call 00428520
004207A5 . B9 C8404F00 mov ecx, 004F40C8
004207AA . 8D71 01 lea esi, dword ptr [ecx+1]
004207AD . 8D49 00 lea ecx, dword ptr [ecx]
004207B0 > 8A11 mov dl, byte ptr [ecx]
004207B2 . 41 inc ecx
004207B3 . 84D2 test dl, dl
004207B5 .^ 75 F9 jnz short 004207B0
004207B7 . 2BCE sub ecx, esi
004207B9 . 51 push ecx
004207BA . 68 C8404F00 push 004F40C8
004207BF . 50 push eax
004207C0 . E8 5B7D0000 call 00428520
004207C5 . B9 C83F4F00 mov ecx, 004F3FC8 ;
004207CA . 8D71 01 lea esi, dword ptr [ecx+1]
004207CD . 8D49 00 lea ecx, dword ptr [ecx]
004207D0 > 8A11 mov dl, byte ptr [ecx]
004207D2 . 41 inc ecx
004207D3 . 84D2 test dl, dl
004207D5 .^ 75 F9 jnz short 004207D0
004207D7 . 2BCE sub ecx, esi
004207D9 . 51 push ecx
004207DA . 68 C83F4F00 push 004F3FC8 ;
004207DF . 50 push eax
004207E0 . E8 3B7D0000 call 00428520
004207E5 . 3B05 C8424F00 cmp eax, dword ptr [4F42C8] ; 到这儿看见了吧，跟4F42C8的值相比较的。4F42C8前面提到了
004207EB . /75 6C jnz short 00420859 ; 不相等直接跳到注册失败
拿004F3DC8、004F3CC8、004F3EC8 、 004F41C8 、004F40C8 、004F3FC8 六处的数据 给子函数00428520运算
然后获取的值与4F42C8进行比较，如果不相等就注册失败了。
接下来 (函数004204E0)：
004207ED . 803D C83D4F00>cmp byte ptr [4F3DC8], 0
004207F4 . 0F84 F5010000 je 004209EF
004207FA . BE D13D4F00 mov esi, 004F3DD1 ; ASCII "32R4E2EWDF"
004207FF . 897424 10 mov dword ptr [esp+10], esi
00420803 > 6A 09 push 9 ; 这里其实是个循环找version:(versMax:) 和dataMax:
00420805 . 8D7E F7 lea edi, dword ptr [esi-9]
00420808 . 68 E8904D00 push 004D90E8 ; version:
0042080D . 57 push edi
0042080E . 897C24 24 mov dword ptr [esp+24], edi
00420812 . E8 C9EF0500 call 0047F7E0 ; 比较字符串的函数
00420817 . 85C0 test eax, eax
00420819 . 74 19 je short 00420834
0042081B . 6A 09 push 9
0042081D . 68 DC904D00 push 004D90DC ; versmax:
00420822 . 57 push edi
00420823 . E8 B8EF0500 call 0047F7E0
00420828 . 85C0 test eax, eax
0042082A . 0F85 DC000000 jnz 0042090C
00420830 . 8B7424 10 mov esi, dword ptr [esp+10]
00420834 > 803E 00 cmp byte ptr [esi], 0
00420837 . C64424 17 00 mov byte ptr [esp+17], 0
0042083C . 74 1B je short 00420859
0042083E . 8BFF mov edi, edi
00420840 > 807E FF 20 cmp byte ptr [esi-1], 20
00420844 . 75 0D jnz short 00420853
00420846 . 0FBE06 movsx eax, byte ptr [esi]
00420849 . 50 push eax
0042084A . E8 51F00500 call 0047F8A0
0042084F . 84C0 test al, al
00420851 . 75 23 jnz short 00420876
00420853 > 46 inc esi
00420854 . 803E 00 cmp byte ptr [esi], 0
00420857 .^ 75 E7 jnz short 00420840
00420859 > 32C0 xor al, al
0042085B > 8B8C24 480D00>mov ecx, dword ptr [esp+D48]
00420862 . 5D pop ebp
00420863 . 5F pop edi
00420864 . 5E pop esi
00420865 . 5B pop ebx
00420866 . 33CC xor ecx, esp
00420868 . E8 B5130A00 call 004C1C22
0042086D . 81C4 3C0D0000 add esp, 0D3C
00420873 . C2 0C00 retn 0C
00420876 > 56 push esi
00420877 . E8 E8360A00 call 004C3F64 ; 函数004C3F64最终指向 函数004C3FF6。。调用函数004C3FF6 标为B1
0042087C . 6A 2E push 2E
0042087E . 56 push esi
0042087F . 8BD8 mov ebx, eax
00420881 . E8 FA180A00 call 004C2180
00420886 . 8BF0 mov esi, eax
00420888 . 83C4 0C add esp, 0C
0042088B . 85F6 test esi, esi
0042088D . 74 37 je short 004208C6
0042088F . 807E 01 2A cmp byte ptr [esi+1], 2A
00420893 . 8D7E 01 lea edi, dword ptr [esi+1]
00420896 . 74 2E je short 004208C6
00420898 . 57 push edi ; /Arg1
00420899 . E8 C6360A00 call 004C3F64 ; \又来了 调用函数004C3FF6 标为B2
0042089E . 0FBE0F movsx ecx, byte ptr [edi]
004208A1 . 83C4 04 add esp, 4
004208A4 . 51 push ecx
004208A5 . 8BE8 mov ebp, eax
004208A7 . E8 F4EF0500 call 0047F8A0
004208AC . 84C0 test al, al
004208AE . 74 19 je short 004208C9
004208B0 . 0FBE56 02 movsx edx, byte ptr [esi+2]
004208B4 . 52 push edx
004208B5 . E8 E6EF0500 call 0047F8A0
004208BA . 84C0 test al, al
004208BC . 75 0B jnz short 004208C9
004208BE . 8D6CAD 00 lea ebp, dword ptr [ebp+ebp*4]
004208C2 . 03ED add ebp, ebp
004208C4 . EB 03 jmp short 004208C9
004208C6 > 83CD FF or ebp, FFFFFFFF
004208C9 > 83FB 05 cmp ebx, 5 ; 这里比较。。猜测函数004C3FF6只是取了个数值。
004208CC . 75 1C jnz short 004208EA
004208CE . 83FD FF cmp ebp, -1
004208D1 . 74 13 je short 004208E6
004208D3 . B8 67666666 mov eax, 66666667
004208D8 . F7ED imul ebp
004208DA . C1FA 02 sar edx, 2
004208DD . 8BC2 mov eax, edx
004208DF . C1E8 1F shr eax, 1F
004208E2 . 03C2 add eax, edx
004208E4 . 75 04 jnz short 004208EA
004208E6 > B0 01 mov al, 1
004208E8 . EB 04 jmp short 004208EE
004208EA > 8A4424 17 mov al, byte ptr [esp+17] ; 根据版本号给al赋了个值
004208EE > 8B4C24 10 mov ecx, dword ptr [esp+10]
004208F2 . 8079 FB 4D cmp byte ptr [ecx-5], 4D
004208F6 . 75 0C jnz short 00420904
004208F8 . 83FB 05 cmp ebx, 5
004208FB . 7F 0F jg short 0042090C
004208FD . 75 05 jnz short 00420904
004208FF . 83FD 01 cmp ebp, 1
00420902 . 7D 08 jge short 0042090C
00420904 > 84C0 test al, al ; 这里的代码其实判断了一下给的版本号是不是5 如果不是5 注册失败
00420906 .^ 0F84 4DFFFFFF je 00420859
0042090C > 8B5424 18 mov edx, dword ptr [esp+18]
00420910 . 6A 09 push 9
00420912 . 68 D0904D00 push 004D90D0 ; datemax:
00420917 . 52 push edx
00420918 . E8 C3EE0500 call 0047F7E0
0042091D . 85C0 test eax, eax
0042091F . 0F85 B4000000 jnz 004209D9
00420925 . 8B7424 10 mov esi, dword ptr [esp+10]
00420929 . 3806 cmp byte ptr [esi], al
0042092B .^ 0F84 28FFFFFF je 00420859 ; 注意 有DateMax:段时，他后面必须跟个数字
00420931 > 807E FF 20 cmp byte ptr [esi-1], 20
00420935 . 75 0D jnz short 00420944
00420937 . 0FBE06 movsx eax, byte ptr [esi]
0042093A . 50 push eax ; 越过空格看是否为数字
0042093B . E8 60EF0500 call 0047F8A0
00420940 . 84C0 test al, al
00420942 . 75 0B jnz short 0042094F
00420944 > 46 inc esi
00420945 . 803E 00 cmp byte ptr [esi], 0
00420948 .^ 75 E7 jnz short 00420931
0042094A .^ E9 0AFFFFFF jmp 00420859
0042094F > BF 01000000 mov edi, 1
00420954 . 56 push esi
00420955 . 8BDF mov ebx, edi
00420957 . E8 08360A00 call 004C3F64 ;调用函数004C3FF6 标为B2
0042095C . 6A 2E push 2E
0042095E . 56 push esi
0042095F . 8BE8 mov ebp, eax
00420961 . E8 1A180A00 call 004C2180
00420966 . 83C4 0C add esp, 0C
00420969 . 85C0 test eax, eax
0042096B . 74 26 je short 00420993
0042096D . 8D70 01 lea esi, dword ptr [eax+1]
00420970 . 56 push esi
00420971 . E8 EE350A00 call 004C3F64 ;调用函数004C3FF6 标为B3
00420976 . 6A 2E push 2E
00420978 . 56 push esi
00420979 . 8BF8 mov edi, eax
0042097B . E8 00180A00 call 004C2180
00420980 . 83C4 0C add esp, 0C
00420983 . 85C0 test eax, eax
00420985 . 74 0C je short 00420993
00420987 . 40 inc eax
00420988 . 50 push eax ; /Arg1
00420989 . E8 D6350A00 call 004C3F64 ; 调用函数004C3FF6 标为B4
0042098E . 83C4 04 add esp, 4
00420991 . 8BD8 mov ebx, eax
00420993 > 8D4C24 1C lea ecx, dword ptr [esp+1C]
00420997 . E8 64250600 call 00482F00
0042099C . 8D4C24 1C lea ecx, dword ptr [esp+1C]
004209A0 . E8 AB240600 call 00482E50 ; 获取系统时间
004209A5 . 8D4C24 24 lea ecx, dword ptr [esp+24]
004209A9 . 51 push ecx ; /Arg1
004209AA . 8D4C24 20 lea ecx, dword ptr [esp+20] ; |
004209AE . E8 5D250600 call 00482F10 ; \WinRAR.00482F10
004209B3 . 8B4424 24 mov eax, dword ptr [esp+24]
004209B7 . 3BE8 cmp ebp, eax
004209B9 . 77 1E ja short 004209D9
004209BB ^ 0F85 98FEFFFF jnz 00420859
004209C1 8B4424 28 mov eax, dword ptr [esp+28]
004209C5 3BF8 cmp edi, eax ; 比较时间的。。
004209C7 77 10 ja short 004209D9
004209C9 ^ 0F85 8AFEFFFF jnz 00420859
004209CF 3B5C24 2C cmp ebx, dword ptr [esp+2C]
004209D3 ^ 0F82 80FEFFFF jb 00420859
004209D9 > 8B4424 10 mov eax, dword ptr [esp+10]
004209DD . 40 inc eax ; 这段代码 循环增量
004209DE . 8078 F7 00 cmp byte ptr [eax-9], 0
004209E2 . 894424 10 mov dword ptr [esp+10], eax
004209E6 . 74 07 je short 004209EF
004209E8 . 8BF0 mov esi, eax
004209EA .^ E9 14FEFFFF jmp 00420803 ; 跳转
这段代码主要用来对地址004F3DC8的内容进行循环。。查找Version:(VersMax:) 和DataMax:
这里有判断版本号 和时间的一些地方。如果不正确就注册失败。
最后 (函数004204E0):
004209EF > \80BC24 580D00>cmp byte ptr [esp+D58], 0 ; 这个局部变量干啥的呢。。调试时为0 为0跳转直接成功了。。先nop 看后续代码
004209F7 0F84 39010000 je 00420B36
004209FD . B8 C83D4F00 mov eax, 004F3DC8 ;
00420A02 . 8D50 01 lea edx, dword ptr [eax+1]
00420A05 > 8A08 mov cl, byte ptr [eax]
00420A07 . 40 inc eax
00420A08 . 84C9 test cl, cl
00420A0A .^ 75 F9 jnz short 00420A05
00420A0C . 68 C8414F00 push 004F41C8
00420A11 . 68 F8904D00 push 004D90F8 ; 70c2441db366d92ea7be1342b3bf629026ba92bb675f06e684bdd34511097434
00420A16 . 2BC2 sub eax, edx
00420A18 . 50 push eax
00420A19 . 68 C83D4F00 push 004F3DC8 ;
00420A1E . E8 5D0C0100 call 00431680
00420A23 . 85C0 test eax, eax
00420A25 ^ 0F84 2EFEFFFF je 00420859
00420A2B . 33C0 xor eax, eax
00420A2D . 8D49 00 lea ecx, dword ptr [ecx]
00420A30 > 8A88 C83C4F00 mov cl, byte ptr [eax+4F3CC8]
00420A36 . 888C04 480500>mov byte ptr [esp+eax+548], cl
00420A3D . 40 inc eax
00420A3E . 84C9 test cl, cl
00420A40 .^ 75 EE jnz short 00420A30
00420A42 . B8 C83E4F00 mov eax, 004F3EC8
00420A47 . 8BD0 mov edx, eax
00420A49 . 8DA424 000000>lea esp, dword ptr [esp]
00420A50 > 8A08 mov cl, byte ptr [eax]
00420A52 . 40 inc eax
00420A53 . 84C9 test cl, cl
00420A55 .^ 75 F9 jnz short 00420A50
00420A57 . 8DBC24 480500>lea edi, dword ptr [esp+548]
00420A5E . 2BC2 sub eax, edx
00420A60 . 4F dec edi
00420A61 > 8A4F 01 mov cl, byte ptr [edi+1]
00420A64 . 47 inc edi
00420A65 . 84C9 test cl, cl
00420A67 .^ 75 F8 jnz short 00420A61
00420A69 . 8BC8 mov ecx, eax
00420A6B . C1E9 02 shr ecx, 2
00420A6E . 8BF2 mov esi, edx
00420A70 . F3:A5 rep movs dword ptr es:[edi], dword ptr [esi]
00420A72 . 8BC8 mov ecx, eax
00420A74 . 83E1 03 and ecx, 3
00420A77 . F3:A4 rep movs byte ptr es:[edi], byte ptr [esi]
00420A79 . 33C0 xor eax, eax
00420A7B . EB 03 jmp short 00420A80
00420A7D 8D49 00 lea ecx, dword ptr [ecx]
00420A80 > 8A8C04 480500>mov cl, byte ptr [esp+eax+548]
00420A87 . 888C04 480900>mov byte ptr [esp+eax+948], cl
00420A8E . 40 inc eax
00420A8F . 84C9 test cl, cl
00420A91 .^ 75 ED jnz short 00420A80
00420A93 . 8D8424 480500>lea eax, dword ptr [esp+548]
00420A9A . 8D50 01 lea edx, dword ptr [eax+1]
00420A9D . 8D49 00 lea ecx, dword ptr [ecx]
00420AA0 > 8A08 mov cl, byte ptr [eax]
00420AA2 . 40 inc eax
00420AA3 . 84C9 test cl, cl
00420AA5 .^ 75 F9 jnz short 00420AA0
00420AA7 . 68 C8404F00 push 004F40C8
00420AAC . 2BC2 sub eax, edx
00420AAE . 68 F8904D00 push 004D90F8 ; 70c2441db366d92ea7be1342b3bf629026ba92bb675f06e684bdd34511097434
00420AB3 . 8BF0 mov esi, eax
00420AB5 . 56 push esi
00420AB6 . 8D9424 540500>lea edx, dword ptr [esp+554]
00420ABD . 52 push edx
00420ABE . E8 BD0B0100 call 00431680
00420AC3 . 85C0 test eax, eax
00420AC5 ^ 0F84 8EFDFFFF je 00420859
00420ACB . 33C0 xor eax, eax
00420ACD . 8D49 00 lea ecx, dword ptr [ecx]
00420AD0 > 8A8C04 480900>mov cl, byte ptr [esp+eax+948]
00420AD7 . 888C04 480500>mov byte ptr [esp+eax+548], cl
00420ADE . 40 inc eax
00420ADF . 84C9 test cl, cl
00420AE1 .^ 75 ED jnz short 00420AD0
00420AE3 . 8D8424 480400>lea eax, dword ptr [esp+448]
00420AEA . 50 push eax
00420AEB . 68 C83F4F00 push 004F3FC8 ;
00420AF0 . 56 push esi
00420AF1 . 8D8C24 540500>lea ecx, dword ptr [esp+554]
00420AF8 . 51 push ecx
00420AF9 . E8 92090100 call 00431490 ; 这个也要分析。。唉
00420AFE . 33C0 xor eax, eax
00420B00 > 8A8C04 480900>mov cl, byte ptr [esp+eax+948]
00420B07 . 888C04 480500>mov byte ptr [esp+eax+548], cl
00420B0E . 40 inc eax
00420B0F . 84C9 test cl, cl
00420B11 .^ 75 ED jnz short 00420B00
00420B13 . 8D9424 480400>lea edx, dword ptr [esp+448]
00420B1A . 52 push edx
00420B1B . 68 C83E4F00 push 004F3EC8
00420B20 . 56 push esi
00420B21 . 8D8424 540500>lea eax, dword ptr [esp+554]
00420B28 . 50 push eax
00420B29 . E8 520B0100 call 00431680
00420B2E . 85C0 test eax, eax
00420B30 ^ 0F84 23FDFFFF je 00420859
00420B36 > B0 01 mov al, 1
00420B38 .^ E9 1EFDFFFF jmp 0042085B
这是函数的最后 涉及到一个局部变量：byte ptr [esp+D58]。然后是两个子函数的调用：00431680 和 00431490
好累。脑子像个浆糊似得。(请允许我蛋疼一会儿......)
现在流程大概明白了，差几点：
函数004C3FF6怎么生成数值.调用的地方有5处 A1 B1 B2 B3 B4
变量byte ptr [esp+D58]
子函数00431490有做了什么运算
子函数00431680 做了什么
接下来。首先了解变量byte ptr [esp+D58] 什么地方赋的值 因为这是个esp寻址 (不好找)
运行到地址004209EF时
堆栈 ss:[00125350]=00
Jumps from 004207F4, 004209E6
他其实是调用函数004204E0时的第三个参数。。先不管这个参数的值是怎么来的。。分析一下 函数004C3FF6
函数004C4250：
参数：
001245B8 0042071D 返回到 WinRAR.0042071D 来自 WinRAR.004C4250
001245BC 0012466A ASCII "guojichongyungaga"
001245C0 00000000
001245C4 0000000A
004C4250 /$ 8BFF mov edi, edi
004C4252 |. 55 push ebp
004C4253 |. 8BEC mov ebp, esp
004C4255 |. 833D A4A75800>cmp dword ptr [58A7A4], 0
004C425C |. 6A 01 push 1
004C425E |. FF75 10 push dword ptr [ebp+10]
004C4261 |. FF75 0C push dword ptr [ebp+C]
004C4264 |. FF75 08 push dword ptr [ebp+8]
004C4267 |. 75 07 jnz short 004C4270
004C4269 |. 68 30CD4E00 push 004ECD30
004C426E |. EB 02 jmp short 004C4272
004C4270 |> 6A 00 push 0
004C4272 |> E8 7FFDFFFF call 004C3FF6
004C4277 |. 83C4 14 add esp, 14
004C427A |. 5D pop ebp
004C427B \. C3 retn
这个函数 会通过一个全局变量58A7A4 判断。。内存搜索58A7A4 发现没有对其赋值的地方 而且它的初始值是0。先不管
继而调用函数004C3FF6
函数004C3FF6
这个函数代码很长。。其实可以忽略好多东西，函数004C3FF6把字符串形式的十进制数据变为十六进制返回。。
比如我们要这个函数返回0x26E831B8。。只需传入字符串"652751288" 0x26E831B8=652751288
Ok。这个时候我们要运行到你
004209EF > \80BC24 580D00>cmp byte ptr [esp+D58], 0
这条语句时才能接着分析函数00431490、00431680
具体怎么能运行到地址004209EF，我就不用语言组织了。。。。我准备另开一贴，把生成注册文件的代码贴出来。。
现在我给出了能运行到地址004209EF的一个key文件内容。。(保存文件名为rarreg.key 到程序目录或者是C:\Documents and Settings\Administrator\Application Data\WinRAR下)
A=1234567890abcdefghijklmnopqrstuvwzyx
B=123WERWEFAWF2ERWEFWEFWEF
VersMax: 5.1 DateMax: 2015.12.23
D=123123WEDSFWRSDF
1212r12d10aaaaaaaaaaaabbbbbbbbbbbbccccccccccccdddddddddd2978471197
在
004209FD . B8 C83D4F00 mov eax, 004F3DC8 ; ASCII "VersMax: 5.1 DateMax: 2015.12.23"
处下断
F9 运行走起。。。不一会儿断在了地址004209FD
分析函数00431680发现函数00431680转而调用函数00431680 。。又是一个搞得好晕的函数。。唉
分析函数00431680
参数：
01D35EA4 0043169D 返回到 WinRAR.0043169D 来自 WinRAR.004314B0
01D35EA8 004F3DC8 ASCII "VersMax: 5.1 DateMax: 2015.12.23"
01D35EAC 00000000
01D35EB0 00000020
01D35EB4 00000000
01D35EB8 004D90F8 ASCII "70c2441db366d92ea7be1342b3bf629026ba92bb675f06e684bdd34511097434"
01D35EBC 004F41C8 ASCII "bbbbbbbbbbbb"
惭愧
函数00431680 和 函数 函数00431490 没整明白。。应该是一个算法。。想想还是先贴出来，让有兴趣的童鞋研究一下。
。附件里有 程序的udd文件注释的不好。不要见怪。有时间我会继续努力弄明白的。。
我的wrar安装目录是 C:\Program Files\WinRAR1
[注意]传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！
