献丑啦！
近来在学习分析软件加密算法，以前都是用的爆破 ：（ 水平菜，没法子啊
可也得提高啊，那就找个东西练手吧
目标锁定‘木马克星’
版本：木马克星 5.46 build 0524
地址：http://www.luosoft.com
声明：这个文章只是我的破解练习笔记，如果你觉得这个软件好，请支持原作者！
本文作者：hhkk [hhkkk@126.com]

初步分析，用dede加载马上可以找到这个位置
* Reference to control TForm7.tIceLock1 : tIceLock
|
00563591   8B83D0020000           mov     eax, [ebx+$02D0]

* Reference to: IceLock.Proc_004AFC30
|
00563597   E894C6F4FF             call    004AFC30
0056359C   8D95E4FEFFFF           lea     edx, [ebp+$FFFFFEE4]

* Reference to control TForm7.Edit1 : TEdit
|
005635A2   8B83D8020000           mov     eax, [ebx+$02D8]

* Reference to: controls.TControl.GetText(TControl):TCaption;
|
005635A8   E8E72CEDFF             call    00436294
005635AD   8B85E4FEFFFF           mov     eax, [ebp+$FFFFFEE4]
005635B3   50                     push    eax

* Reference to control TForm7.tIceLock1 : tIceLock
|
005635B4   8B83D0020000           mov     eax, [ebx+$02D0]

* Reference to field tIceLock.OFFS_0224
|
005635BA   8B8024020000           mov     eax, [eax+$0224]
005635C0   05EA040000             add     eax, +$000004EA
005635C5   99                     cdq
005635C6   33C2                   xor     eax, edx
005635C8   2BC2                   sub     eax, edx
005635CA   8D95E0FEFFFF           lea     edx, [ebp+$FFFFFEE0]

* Reference to: Unit_004083F8.Proc_00409438
|
005635D0   E8635EEAFF             call    00409438
005635D5   8B95E0FEFFFF           mov     edx, [ebp+$FFFFFEE0]               ////这个是真实的注册代码
005635DB   58                     pop     eax

* Reference to: system.@LStrCmp;                                             ////// 很明显是用的明文比较的方式
|
005635DC   E8F30CEAFF             call    004042D4     
005635E1   0F85E5000000           jnz     005636CC

看到这，要是爆破或者做内存注册机就可以马上做出来了。但我的目标是找出算法来！嘿嘿，有点画蛇添足吧。咱们继续。
怎么分析出加密用的算法？我是个菜菜鸟，以前没做过这样的事，这只是一次尝试，如果有好的思路，欢迎指教：hhkkk@126.com。我想到的是

采用逆向的方式来找算法的关键位置，高手如果有好的方法，还请告之 ：）
那个真实的注册码在一个call后出来了，那就跟进去吧
00409438   83C4F8                 add     esp, -$08
0040943B   6A00                   push    $00
0040943D   89442404               mov     [esp+$04], eax
00409441   C644240800             mov     byte ptr [esp+$08], $00
00409446   8D4C2404               lea     ecx, [esp+$04]
0040944A   8BC2                   mov     eax, edx

* Possible String Reference to: '%d'
|
0040944C   BA64944000             mov     edx, $00409464

* Reference to: Unit_004083F8.Proc_0040A6CC
|
00409451   E876120000             call    0040A6CC
00409456   59                     pop     ecx
00409457   5A                     pop     edx
00409458   C3                     ret

晕，没什么实际的操作，那就继续跟这个call，tmd call真的多，因为这个真实注册码以明文出现，在跟的时候我们就要注册寄存器的变化了

，看是不是出现了注册码的字样。哦，忘了说了，我用的跟踪工具是od
采用初步跟踪的方法发现出现注册代码的字样是在如下代码位置

0040A4CF  |>  8D75 9F       LEA     ESI,DWORD PTR SS:[EBP-61]
0040A4D2  |> |31D2          /XOR     EDX,EDX                   // edx=0;
0040A4D4  |. |F7F1          |DIV     ECX                       
0040A4D6  |. |80C2 30       |ADD     DL,30         
0040A4D9  |. |80FA 3A       |CMP     DL,3A
0040A4DC  |. |72 03         |JB      SHORT Iparmor.0040A4E1
0040A4DE  |. |80C2 07       |ADD     DL,7
0040A4E1  |> |4E            |DEC     ESI
0040A4E2  |. |8816          |MOV     BYTE PTR DS:[ESI],DL
0040A4E4  |. |09C0          |OR      EAX,EAX
0040A4E6  |.^|75 EA         \JNZ     SHORT Iparmor.0040A4D2
0040A4E8  |. |8D4D 9F       LEA     ECX,DWORD PTR SS:[EBP-61]     ////运行到这个地方的时候，已经可以看到esi后面就有注册码了，

而在上面这个循环之前，是无论如何也找不到注册码的。

仔细分析，这段循环代码用c表示为
        int ii=0;
        while(eax)
        {
                int tem=eax%0xa;
                tem+=0x30;
                if(tem>=0x3a)
                        tem=tem+0x7;
                reg[ii]=tem;

                ii++;
                eax=eax/0xa;

        }

看来eax里放的是个比较大的一个数了，注册码是根据这个数来产生的了。
很自然，接下来就是找到怎么来产生这个数了。这个数的查找可以用静态反汇编来分析出应该是在
005635C8   2BC2                   sub     eax, edx  
这个代码运行后生成的。用od运行可以验证！原来这个数最初是由某个算法生成后，再做了点点处理，代码如下，

005635B4   8B83D0020000           mov     eax, [ebx+$02D0]

* Reference to field tIceLock.OFFS_0224
|
005635BA   8B8024020000           mov     eax, [eax+$0224]
005635C0   05EA040000             add     eax, +$000004EA
005635C5   99                     cdq
005635C6   33C2                   xor     eax, edx
005635C8   2BC2                   sub     eax, edx
这个数又是怎么生成的？离目标不远啦，它首先是保存在 [ebx+$02D0]中。再看看这个代码是在点注册按钮后运行的呢，呵呵，就是闭上眼睛

也能找到位置了。是在如下位置出现的吧
00563597   E894C6F4FF             call    004AFC30
那就继续跟啊 呵呵 胜利在望 ：）
这个里面的call比较少，系统的function就不进去了
那就到这里来

004AFD7C   53                     push    ebx
004AFD7D   83C4B8                 add     esp, -$48
004AFD80   8BD8                   mov     ebx, eax
004AFD82   33C0                   xor     eax, eax

* Reference to field tIceLock.OFFS_0024
|
004AFD84   8A4324                 mov     al, byte ptr [ebx+$24]
004AFD87   40                     inc     eax
004AFD88   83F846                 cmp     eax, +$46
004AFD8B   7F0B                   jnle    004AFD98

004AFD8D   C64403242A             mov     byte ptr [ebx+eax+$24], $2A      ////如果小于46 就用0x2a填充  ebx+24为regname的位置
004AFD92   40                     inc     eax
004AFD93   83F847                 cmp     eax, +$47
004AFD96   75F5                   jnz     004AFD8D

004AFD98   33C0                   xor     eax, eax
004AFD9A   8BD4                   mov     edx, esp

004AFD9C   8A4C0324               mov     cl, byte ptr [ebx+eax+$24]    ///将regname 复制到stack中去
004AFDA0   880A                   mov     [edx], cl
004AFDA2   40                     inc     eax
004AFDA3   42                     inc     edx
004AFDA4   83F847                 cmp     eax, +$47
004AFDA7   75F3                   jnz     004AFD9C

004AFDA9   8BCC                   mov     ecx, esp

* Reference to field tIceLock.OFFS_022C
|
004AFDAB   8B932C020000           mov     edx, [ebx+$022C]
004AFDB1   8BC3                   mov     eax, ebx

* Reference to: Unit_004AFCA3.Proc_004AFD34
|
004AFDB3   E87CFFFFFF             call    004AFD34

* Reference to field tIceLock.OFFS_0224
|
004AFDB8   898324020000           mov     [ebx+$0224], eax
004AFDBE   33C0                   xor     eax, eax

* Reference to field tIceLock.OFFS_0124
|
004AFDC0   8A8324010000           mov     al, byte ptr [ebx+$0124]
004AFDC6   40                     inc     eax
004AFDC7   83F846                 cmp     eax, +$46
004AFDCA   7F0E                   jnle    004AFDDA
004AFDCC   C68403240100002A       mov     byte ptr [ebx+eax+$0124], $2A
004AFDD4   40                     inc     eax
004AFDD5   83F847                 cmp     eax, +$47
004AFDD8   75F2                   jnz     004AFDCC
004AFDDA   33C0                   xor     eax, eax
004AFDDC   8BD4                   mov     edx, esp
004AFDDE   8A8C0324010000         mov     cl, byte ptr [ebx+eax+$0124]
004AFDE5   880A                   mov     [edx], cl
004AFDE7   40                     inc     eax
004AFDE8   42                     inc     edx
004AFDE9   83F847                 cmp     eax, +$47
004AFDEC   75F0                   jnz     004AFDDE
004AFDEE   8BCC                   mov     ecx, esp

* Reference to field tIceLock.OFFS_0230
|
004AFDF0   8B9330020000           mov     edx, [ebx+$0230]
004AFDF6   8BC3                   mov     eax, ebx

* Reference to: Unit_004AFCA3.Proc_004AFD34
|
004AFDF8   E837FFFFFF             call    004AFD34

* Reference to field tIceLock.OFFS_0228
|
004AFDFD   898328020000           mov     [ebx+$0228], eax
004AFE03   83C448                 add     esp, +$48
004AFE06   5B                     pop     ebx
004AFE07   C3                     ret
到这里来就快了，嘿嘿。在将regname做扩充后，自然就应该是算出那个数字吧。动态跟，发现进入到这个call
//////////////////////////////////////////////////////////////////////////////////////
004AFD34   53                     push    ebx
004AFD35   56                     push    esi
004AFD36   57                     push    edi
004AFD37   83C4B8                 add     esp, -$48
004AFD3A   8BF1                   mov     esi, ecx
004AFD3C   8D3C24                 lea     edi, [esp]
004AFD3F   B911000000             mov     ecx, $00000011
004AFD44   F3                     rep
004AFD45   A5                     movsd
004AFD46   66A5                   movsw
004AFD48   A4                     movsb
004AFD49   B147                   mov     cl, $47
004AFD4B   8BC4                   mov     eax, esp
004AFD4D   8BDA                   mov     ebx, edx
004AFD4F   C1EB08                 shr     ebx, $08
004AFD52   81E3FFFFFF00           and     ebx, $00FFFFFF
004AFD58   0FB630                 movzx   esi, byte ptr [eax]
004AFD5B   33D6                   xor     edx, esi
004AFD5D   81E2FF000000           and     edx, $000000FF
004AFD63   8B149524F55600         mov     edx, [$56F524+edx*4]
004AFD6A   33DA                   xor     ebx, edx
004AFD6C   8BD3                   mov     edx, ebx
004AFD6E   40                     inc     eax
004AFD6F   FEC9                   dec     cl
004AFD71   75DA                   jnz     004AFD4D
004AFD73   8BC2                   mov     eax, edx
004AFD75   83C448                 add     esp, +$48
004AFD78   5F                     pop     edi
004AFD79   5E                     pop     esi
004AFD7A   5B                     pop     ebx
004AFD7B   C3                     ret

呵呵  最先发现到一个
004AFD63   8B149524F55600         mov     edx, [$56F524+edx*4]
怎么看56F524有点怪怪的，用d 56F524 一看，噢？怎么像个什么算法呢？找《加密与解密》一看 呵呵 就是crc了
原来是对regname做crc运算啊
好了，总的思路出来了
总结如下：
1）regname扩充到0x47位
2）初始值crc=0xefca99,对扩充后的regname做运算，得到大数（不知道怎么称呼好）
3）对大数一点点处理
           ////////crc为得到的大数         
       
        unsigned int iedx=ol>0?0:0xffffffff;
        crc=crc^iedx;
        crc=crc-iedx;

4）结合上面的代码得到注册码
        eax=crc;
        int ii=0;
        while(eax)
        {
                int tem=eax%0xa;
                tem+=0x30;
                if(tem>=0x3a)
                        tem=tem+0x7;
                reg[ii]=tem;

                ii++;
                eax=eax/0xa;

        }

5)收工

呵呵，基本搞定。总算写完了（作长叹气状），累，为了上面的一点点东西，花了我好三四天时间，要写出来又更加累。真的是做过才知道什

么叫做累。以前看前辈们的文章，没这个感觉，现在自己真的体会到了。在此感谢前辈们的无私奉献！没有你们的奉献，我也只能在黑暗中摸

索，谢谢！第一次写点点东东，不当之处或者还有好的解决方法，恳请指出！
谨以此文献给我深爱的庄庄！

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