“金山杯2007逆向分析挑战赛”第一阶段第一题分析

　　题目来自于如下网址：

　　http://www.pediy.com/kssd/

　　第13篇 论坛活动 \ 金山杯2007逆向分析挑战赛 \ 第一阶段 \ 第一题 \ 题目 \ [第一阶段 第一题]；

 

　　现将此题目概述粘贴如下：
 

　　CrackMe.exe 是一个简单的注册程序，见附件，请写一个注册机，要求：

　　1. 注册机是KeyGen，不是内存注册机或文件Patch;

　　2. 注册机可以使用 ASM，VC，BC，VB，Delphi等语言书写，其他谢绝使用;

　　3. 注册机必须可以运行在 Windows 系统上;

　　......

 

　　昨天我偶然浏览到这里，看到这个题目，于是看了下，题目早就已经是过去时了，但今天依然可以看看，大概用了半天时间求解此题目（本来以为挺简单，但实际上还是少有点难度的）。把附件下载下来可以看到，CrackMe.exe 是一个仅有 1.85 KB 的 Windows 对话框程序。界面也非常简单，只有两个文本框用于获取用户名，注册码，和一个注册按钮，当点击注册按钮时，如果注册码正确，会弹出 MessageBox 显示 "OK!!"，否则会显示 "Fail!" 。

 

　　

 

　　很显然，如果我们直接修改这个 exe，跳过其注册码检测或者修改里面的跳转逻辑，修改调用 DecryptText 的参数，修改栈上的密文数据等等，有 无数种方法可以直接令这个程序显示 “OK!!” 消息框。但是，这显然不是这个题目的目的（因为这太简单了，也无需理解那些验证用的汇编代码）。根据题目要求，可以看出出题者的要求是，原程序是不能修改的，解题的人通过阅读和分析验证注册码的汇编代码，得出其验证思路，然后根据此写出注册机（KeyGen），实现给出任意的 UserName，得出 SerialNo = f (UserName) ，也就是要求找出 f 关系，并用编程语言实现注册机。

 

　　用 IDA 反汇编这个极小的程序，可以看到它的组成非常简单，下面给出一些主要的汇编代码，并部分的翻译成 C 语言。

　　首先是，当点击“注册"按钮，程序将会检测注册码是否正确。在对话框的窗口过程[参考补充说明2]中，可以找到一段重要代码，现在把它提取出来作为一个注册机要用到的重要函数，即根据用户名字符串得到一个整数特征值，汇编代码省略，这里把这个函数翻译为 C 语言如下：

 

//根据用户名，计算出用户特征值

int GetUserValue(const char* pUserName)

{

    int nUserVal= 0x13572468;

    int i;

    int len = strlen(pUserName);

    for(i = 0; i < len; i++)

    {

        nUserVal = nUserVal + pUserName[i];

        nUserVal = nUserVal * 0x03721273;

        nUserVal = nUserVal + 0x24681357;

        nUserVal = (nUserVal << 25) | (nUserVal >> 7);

    }

    return nUserVal;

}

 

　　接下来，程序将会调用一个校验注册码的函数，在这个函数中同时会弹出 MessageBox，这个函数由几块功能组成，也是此题目必须要分析的重点，这个函数的原型可以推测出为形如：

 

　　void CheckSerialNo(int nUserVal, char* pSerialNo);

 

　　通过这个函数，我们可以很容易看到它是如何弹出显示着 “Fail!!" 的消息框的，该函数首先在栈上放置成功和失败的文本密文，然后通过检测结果，把相应的密文地址传送到解密函数（这里称之为 DecryptText），解密函数把解密后的明文放入栈上的缓冲区，然后以此调用 MessageBox，非常明显，这是模拟软件的常规保护方法，在实际软件中都会将关键和敏感信息进行隐藏，当然这也不是这道题目的重点，因为很容易就找到密文的位置，为紧靠 EBP 附近的两个字节数组。

 

　　在代码段（.text） 的第一个函数就是解密函数，其原型形如：void DecrptText(const BYTE* pSecret, char* pPlainTextBuffer);  这个加解密非常简单，只是把一个数组用另一个事先拟定好的 key 数组线性的异或了一下而已，所以这不是本题重点，在此暂时省略不提（其 C 语言代码版本见本文结尾 [1] ）。

 

　　下面给出的是这个程序的关键汇编代码，也就是 CheckSerialNo 的完整代码，此题目的本意正是要求读懂这个函数的逻辑，并找出注册机算法。这个函数较长，但分开割裂不太好，所以完整粘贴如下（注：主体来自于 IDA 反汇编结果，为了更好的显示和更好的可读性，我整理和调整了反汇编结果的部分细节，以及对部分地址标号进行了重命名）（前面有一大段花里胡哨的稀奇古怪的指令，一些变量赋值操作也通过隔开少许的 PUSH / POP 来完成，最恶劣的是 DWORD 指针竟然地址不对齐，仿佛是人为故意设置的障碍）：

 

.text:004002CC CheckSerialNo   proc near

.text:004002CC

.text:004002CC Text            = byte ptr -128h       ; char Text[260];

.text:004002CC var_24          = byte ptr -24h        ; BYTE var_24[12]; //nUserBits

.text:004002CC var_18          = byte ptr -18h        ; BYTE var_18[12]; //Secret_OK

.text:004002CC var_C           = byte ptr -0Ch        ; BYTE var_C[12]; //Secret_Fail

.text:004002CC CurSerialChar   = byte ptr -1

.text:004002CC nUserValue      = dword ptr  8         ; (uint nUserVal,

.text:004002CC szSerialNo      = dword ptr  0Ch       ; const char *pSerialNo)

.text:004002CC

.text:004002CC                 push    ebp

.text:004002CD                 mov     ebp, esp

.text:004002CF                 sub     esp, 128h       ; alloc 296 bytes on stack

.text:004002D5                 and     byte ptr [ebp+var_24], 0 ; var_24[0] = 0;

.text:004002D9                 push    ebx

.text:004002DA                 push    esi

.text:004002DB                 push    edi

.text:004002DC                 xor     eax, eax

.text:004002DE                 lea     edi, [ebp+var_24+1]

.text:004002E1                 stosd ;var_24[1~4]=0

.text:004002E2                 and     [ebp+Text], 0   ; Text[0] = 0;

.text:004002E9                 push    40h

.text:004002EB                 stosd   ;var_24[5~8]=0

.text:004002EC                 stosb   ;var_24[9]=0

.text:004002ED                 pop     ecx

.text:004002EE                 xor     eax, eax

.text:004002F0                 lea     edi, [ebp-127h] ; 非常古怪，edi未对齐到 DWORD

.text:004002F6                 or      [ebp+var_C], 0FFh ; Secret_Fail[0] = 0xFF

.text:004002FA                 rep stosd              ;Text[1~256]=0

.text:004002FC                 or      [ebp+var_18], 0FFh ; Secret_OK[0] = 0xFF

.text:00400300                 or      ecx, 0FFFFFFFFh ; 计算序列号长度

.text:00400303                 stosw

.text:00400305                 stosb

.text:00400306                 mov     edi, [ebp+szSerialNo]

.text:00400309                 xor     eax, eax

.text:0040030B                 repne scasb

.text:0040030D                 not     ecx

.text:0040030F                 push    1

.text:00400311                 dec     ecx             ; ecx = strlen(szSerialNo)

.text:00400312                 pop     ebx             ; ebx = 1 (此函数中 EBX 恒为 1)

.text:00400313                 mov     byte ptr [ebp-0Bh], 63h ; Init Secret_Fail[1~10]

.text:00400317                 mov     [ebp-0Ah], 0FBh ; "Fail!"的密文: var_C

.text:0040031B                 mov     [ebp-09h], 9Ah

.text:0040031F                 mov     [ebp-08h], 3

.text:00400323                 mov     [ebp-07h], 0A3h

.text:00400327                 mov     [ebp-06h], 0DAh

.text:0040032B                 mov     [ebp-05h], 72h

.text:0040032F                 mov     [ebp-04h], 0FEh

.text:00400333                 mov     [ebp-03h], 0C9h

.text:00400337                 mov     [ebp-02h], 0B7h

.text:0040033B                 mov     byte ptr [ebp-17h], 6Ah ; Init Secret_OK[1~10]

.text:0040033F                 mov     [ebp-16h], 0D1h ; "OK!!"的密文: var_18

.text:00400343                 mov     [ebp-15h], 0D2h

.text:00400347                 mov     [ebp-14h], 4Eh

.text:0040034B                 mov     [ebp-13h], 82h

.text:0040034F                 mov     [ebp-12h], 0DAh

.text:00400353                 mov     [ebp-11h], 72h

.text:00400357                 mov     [ebp-10h], 0FEh

.text:0040035B                 mov     [ebp-0Fh], 0C9h

.text:0040035F                 mov     [ebp-0Eh], 0B7h

.text:00400363                 mov     esi, ecx        ; esi = strlen(szSerialNo)

.text:00400365                 mov     edi, ebx        ; EDI = 1; 循环起始值

.text:00400367

.text:00400367 loc_400367:

.text:00400367                 mov     eax, [ebp+nUserValue] ; ----初始化 var_24[] 内容-----

.text:00400367                                         ; for (edi = 1; edi < 9; ++edi) {

.text:0040036A                 mov     ecx, edi        ; ecx = edi;

.text:0040036C                 shr     eax, cl         ; eax = ((uint)nUserVal >> edi);

.text:0040036E                 and     al, bl          ; al = al & 1

.text:00400370                 mov     byte ptr [ebp+edi+var_24], al ; var_24[edi] = (nUserVal >> edi) & 1;

.text:00400374                 inc     edi

.text:00400375                 cmp     edi, 9

.text:00400378                 jl      short loc_400367 ; }---循环尾部----

.text:0040037A                 xor     edi, edi         ; edi = 0

.text:0040037C                 mov     [ebp+var_1B], bl ; var_24[9] = 1

.text:0040037F                 test    esi, esi         ; esi = strlen(szSerial)

.text:00400381                 jle     short loc_4003EE ; for(edi=0; edi<strlen(szSerialNo);edi++) {

.text:00400383

.text:00400383 loc_400383:

.text:00400383                 mov     eax, [ebp+szSerialNo]

.text:00400386                 mov     al, [edi+eax]  ;al=szSerialNo[edi];

.text:00400389                 cmp     al, 30h

.text:0040038B                 mov     [ebp+CurSerialChar], al

.text:0040038E                 jl      AlertFail

.text:00400394                 cmp     al, 39h

.text:00400396                 jg      AlertFail       ; if(szSerial[edi] < '0' || szSerial[edi] > '9')

.text:00400396                                         ;    goto AlertFail;

.text:0040039C                 mov     eax, edi        ; 准备计算 edi % 31

.text:0040039E                 push    1Fh

.text:004003A0                 cdq

.text:004003A1                 pop     ecx             ;

.text:004003A2                 idiv    ecx             ; edx = edi % 31;

.text:004003A4                 mov     eax, [ebp+nUserValue]

.text:004003A7                 push    0Ah

.text:004003A9                 mov     ecx, edx        ; ecx = edi % 31;

.text:004003AB                 xor     edx, edx

.text:004003AD                 shr     eax, cl         ; eax = nUserVal >> (EDI % 31);

.text:004003AF                 pop     ecx             ; ecx = 10;

.text:004003B0                 div     ecx             ; edx = (nUserVal >> (EDI % 31)) % 10;

.text:004003B2                 movsx   eax, [ebp+CurSerialChar] ; eax = szSerial[edi]

.text:004003B6                 lea     eax, [edx+eax-30h] ; eax = EDX + (szSerial[i] - '0');

.text:004003BA                 xor     edx, edx

.text:004003BC                 div     ecx             ; edx = (edx + szSerial[i] - '0') % 10;

.text:004003BE                 cmp     edx, ebx        ; if(ebx == 1) {

.text:004003C0                 jnz     short EdxIsNotOne_ ; else goto ...

.text:004003C2                 xor     byte ptr [ebp+var_24+1], bl ; var_24[1] ^ = 1; switching var_24[1]

.text:004003C5                 jmp     short ContinueLoop ; continue; }

.text:004003C7 ; --------------------

.text:004003C7

.text:004003C7 EdxIsNotOne_:

.text:004003C7                 cmp     [ebp+edx+var_24-1], bl ; else {

.text:004003C7                                         ;    if(var_24[edx-1] != 1)

.text:004003C7                                         ;        goto AlertFail;

.text:004003C7                                         ; var_24[edx-1] 必须为1

.text:004003CB                 jnz     short AlertFail

.text:004003CD                 lea     eax, [edx-2]    ; //检查 [1, edx-2] 元素是否都是 0.

.text:004003D0                 mov     ecx, ebx        ; for(ecx = 1;

.text:004003D2                 cmp     eax, ebx        ;     ecx <= edx-2; ecx++) {

.text:004003D4                 jl      short SwitchingBit_

.text:004003D6

.text:004003D6 loc_4003D6:

.text:004003D6                 cmp     byte ptr [ebp+ecx+var_24], bl

.text:004003D6                                         ;     if(var_24[ecx] == 1)

.text:004003D6                                         ;         goto AlertFail;

.text:004003DA                 jz      short AlertFail 

.text:004003DC                 inc     ecx             ; }

.text:004003DD                 cmp     ecx, eax

.text:004003DF                 jle     short loc_4003D6

.text:004003E1

.text:004003E1 SwitchingBit_:

.text:004003E1                 xor     byte ptr [ebp+edx+var_24], bl ; var_24[edx]^=1; switching var_24[edx]

.text:004003E5                 lea     eax, [ebp+edx+var_24] ;

.text:004003E9

.text:004003E9 ContinueLoop:

.text:004003E9                 inc     edi             ; for(_;_; ++edi)

.text:004003EA                 cmp     edi, esi

.text:004003EC                 jl      short loc_400383 ; } --序列号循环的尾部--

.text:004003EE

.text:004003EE loc_4003EE:

.text:004003EE                 mov     eax, ebx        ; for(eax = 1; eax < 10; eax++) {

.text:004003F0

.text:004003F0 loc_4003F0:

.text:004003F0                 cmp     byte ptr [ebp+eax+var_24], bl

.text:004003F0                                         ;    if(var_24[eax] == 1)

.text:004003F4                 jz      short AlertFail ; goto AlertFail;

.text:004003F6                 inc     eax

.text:004003F7                 cmp     eax, 0Ah

.text:004003FA                 jl      short loc_4003F0 ; } --检测序列号是否正确

.text:004003FC                 lea     eax, [ebp+Text]

.text:00400402                 push    eax

.text:00400403                 lea     eax, [ebp+var_18] ; DecryptText(Secret_OK, Text);

.text:00400406

.text:00400406 loc_400406:

.text:00400406                 push    eax

.text:00400407                 call    DecryptText     ; 把密文解密存放到 Text 中

.text:0040040C                 pop     ecx

.text:0040040D                 lea     eax, [ebp+Text]

.text:00400413                 pop     ecx

.text:00400414                 push    0               ; uType

.text:00400416                 push    offset Caption  ; lpCaption

.text:0040041B                 push    eax             ; lpText

.text:0040041C                 push    0               ; hWnd

.text:0040041E                 call    MessageBoxA     ; MessageBox(NULL, Text, "", MB_OK);

.text:00400424                 pop     edi

.text:00400425                 mov     eax, ebx        ; return 1;

.text:00400427                 pop     esi

.text:00400428                 pop     ebx

.text:00400429                 leave

.text:0040042A                 retn

.text:0040042B ;--------------------

.text:0040042B

.text:0040042B AlertFail:

.text:0040042B

.text:0040042B                 lea     eax, [ebp+Text]

.text:00400431                 push    eax

.text:00400432                 lea     eax, [ebp+var_C] ; DecryptText(Secret_Fail, Text);

.text:00400435                 jmp     short loc_400406

.text:00400435 CheckSerialNo   endp

 

　　在汇编代码右侧，我已经大致写了一定的注释，下面把这个校验注册码的函数翻译到 C 语言如下（为了使代码的文本紧凑，部分使用了起始大括号不换行的代码风格），然后根据代码推断注册机算法。

 

int CheckSerialNo(UINT uintUserVal, char* pSerialNo)

{

    char CurrentSerialChar; //Secret_Fail[11]: 当前字符

    BYTE Secret_Fail[] = {

        0xFF, 0x63, 0xFB, 0x9A,

        0x03, 0xA3, 0xDA, 0x72, 

        0xFE, 0xC9, 0xB7

    }; //"Fail!" 密文 (EBP-0Ch)



    BYTE Secret_OK[] = {

        0xFF, 0x6A, 0xD1, 0xD2,

        0x4E, 0x82, 0xDA, 0x72,

        0xFE, 0xC9, 0xB7

    }; //"OK!!" 密文 (EBP-18h)



    BYTE nUserBits[10] = { 0 }; //即上面汇编代码中的 var_24 char Text[260] = { 0 }; //存放解密后的明文，送给 MessageBox



    int i; //EDI: 序列号索引

    int k; //ECX / EAX: nUserBits 索引 int nWhichBit; // EDX: 要修改的 nUserBits 索引

    nUserBits[0] = 0; //初始化 BYTE nUserBits[10] for(i = 1; i < 9; i++)

    {

        nUserBits[i] = (uintUserVal >> i ) & 1;

    }

    nUserBits[9] = 1; //最高位手工设1，保证序列号具有较大长度



    BOOL bShowFail = FALSE; // 是否显示 "Fail!" int SerialLen = strlen(pSerialNo);



    //线性遍历注册码字符串

    for(i = 0; i < SerialLen; i++)

    {

        CurrentSerialChar = pSerialNo[i];



        //注册码必须是数字

        if(CurrentSerialChar < '0' || CurrentSerialChar > '9')

        {

            bShowFail = TRUE;

            break;

        } //最初发表时此处遗漏了 break，2014-4-29 补充

        

        nWhichBit = ((uintUserVal >> (i % 31)) + CurrentSerialChar - '0') % 10;



        //修改最低位时，无须做任何校验。否则需检测是否满足可修改条件

        if(nWhichBit == 1)

        {

            nUserBits[1] ^= 1;

        }

        else

        {

            //紧邻的低位是 1 吗？如果不是，则注册失败

            if(nUserBits[nWhichBit - 1] != 1)

            {

                bShowFail = TRUE;

                break;

            }



            //其余低位都是 0 吗？如果不是，则注册失败

            for(k = 1; k <= nWhichBit - 2; k++)

            {

                if(nUserBits[k] != 0)

                {

                    bShowFail = TRUE;

                    break;

                }

            }



            if(bShowFail) break;



            //对当前位取反（0-1 切换）

            nUserBits[ nWhichBit ] ^= 1;

        }

    }



    //查验 nUserBits 是否都为 0，是则成功，否则失败

    if( !bShowFail ) {

        for(k = 1; k < 10; k++) {

            if(nUserBits[k] == 1) {

                bShowFail = TRUE;

                break;

            }

        }

    }



    //解密密文到 Text 中

    DecryptText(bShowFail? Secret_Fail : Secret_OK, Text);

    MessageBox(NULL, Text, "", MB_OK);

    return 1;

}

 

　　在高级语言版本中，我使用了一些语言方法，来避免在高级语言代码把汇编中的那些相对跳转直译为 goto，大体上将是等效的。从上面的代码中可以看出检查注册码的重要标准，如果我们把注册码看做输入，实际上在扫描注册码的过程中，就是 nUserBits 这个元素为二元的数组变化的过程，nUserBits 是根据用户填写的用户名计算得到的数组，所以它的元素和用户名相关，是不确定的，注册码扫描结束后，这个数组必须所有元素都为 0。因此，相当于以注册码为驱动。

 

　　从上面的代码逻辑中我们还能看到很重要的一点，要修改 nUserBits 的某一位（假设为 nWhichBit），那么必须满足以下条件，nUserBits 必须处于如下状态：

 

Index：	1	2	3	...	5	6	7	8	9	...
Value：	0	0	0	...	0	1	nWhichBit	x	x	...

 

　　也就是说，当我们要切换某一位的状态时，从这一位向低位方向（左侧）看去，应该是 【0】* N + 【1】 的组合（紧邻的低位为 1， 其余均为 0）。最低位（索引 1 ）可以随时修改，因为左边已经没有位了，当然就没必要向左看了。这里把上述逻辑用数学语言表述如下：

 

　　有一个数组x，可以把它理解为一个二进制数，每个数组元素表示一个bit。x = f (UserName) 。能够切换 x[i] （i = 1, 2, 3, ..., n ）的准许条件是：

 

　　（1）对任何 1 <= j <= i - 2，有 x [ j ] = 0; 并且

　　（2）如果 i > 1, 有 x [ i - 1 ] = 1;

 

　　这时可以执行对 x [ i ] 的切换动作（对该位取反）。注册码正确的标准是，根据注册码执行一系列动作（注册码的每一位对应于切换 x 的哪一位）后，x 的所有元素为0。在 x 初始化时，已经将 x 的最高位固定设置为1，以防止 x 的初始值恰好都是 0 的特殊情况。

 

　　所以这样就提示注册机算法，可以用递归函数 ( 下面代码中的 SetBit 函数 ) 来求解。注册码是由一系列的 nWhichBit （要切换状态的位索引）组成，这个索引是根据注册码的当前位得到的。换句话说，求注册码相当于找出这样一个有序序列，{ b1, b2, b3, ...,  } ，每一步都是合法切换，处理后 nUserBits 所有位都为 0。

 

　　这样注册机算法就算呼之欲出了，还有一个简单问题是，我们的目标是把  nUserBits 中的每一位都变为 0，那么应该先从哪一位入手呢，应该按照从左（低位）向右（高位）的顺序依次清零，还是从右（高位）向左（低位）？不难得出答案应该采用后者，因为在设置某一位为 0 时，其所有低位都会动态变化，而高位则不受影响可以保持静态不动。所以我们应该先把高位清零，然后在逐一向低位方向推进。程序中显式的把最高位（索引为9）设置为 1，也暗示了这一求解顺序。

 

　　这里给出一个例子来说明，以校验的索引范围为从 1 到 4 ，假设 nUserBits 的初始状态为 { 0, 0, 0, 1 } （索引从 1 开始），则如何经过一系列上述规则允许的元素切换，把它变为 { 0, 0, 0, 0 }，参考下表（整个过程让我想起了汉诺塔，可以很容易看出，整体解中包含了形式相同的规模更小的子问题的解）：

 

Index (1-based)	[1]	[2]	[3]	[4]	nWhichBit to be switched
nUserBits[]:	0	0	0	1	Initial State
	1	0	0	1	[1]
	1	1	0	1	[2]
	0	1	0	1	[1]
	0	1	1	1	[3]
	1	1	1	1	[1]
	1	0	1	1	[2]
	0	0	1	1	[1]
	0	0	1	0	[4]
	1	0	1	0	[1]
	1	1	1	0	[2]
	0	1	1	0	[1]
	0	1	0	0	[3]
	1	1	0	0	[1]
	1	0	0	0	[2]
	0	0	0	0	[1]

 

　　把最右侧一列的索引值连在一起，就是一个我们需要设计的位置序列 { 121312141213121 }，依次对这些位置进行开关切换（把 nUserBits 每一个元素想象成一个开关）后，就可以让 nUserBits 数组变为全为 0 的状态（注册码正确的条件）。如果不需要和用户特征值关联到一起的话，那这这个序列就是注册码。但原程序中是通过注册码和用户特征值（nUserVal）混编后得到这个调整序列，所以我们只需要对这个调整序列做个逆运算，“剔除”其中的用户特征值成分，即可得到实际注册码。

 

　　为此我们给出注册机的如下多个函数，即为题目要求的注册机，显然，注册码如果不限长度，可以有无数多个，但我们当然选择生成简短的。

//用户特征值（注意有时候需要使用其无符号形式，根据CrackMe的指令而定）

int g_UserVal;



//用户特征位数组，由9个位组成 [1,... 9] 仅索引1~9有效

int g_UserBits[10];



//序列号

TCHAR g_SerialNo[4096];



////如果把序列号看着stack，这是栈顶

int g_Top;



//注册机算法：

void Push(int index);

BOOL CanModify(int index);

void SetBit(int index, int nDesiredVal);

int GetUserValue(LPCTSTR szUser);

void InitUserBits();



//index 即需要修改的 UserBits 索引。这个索引变换后，追加到序列号

void Push(int index)

{

    //注意汇编中的右移指令是 SHR，所以需要转为无符号数字（否则为 SAR)

    UINT uintUserVal = g_UserVal;

    

    int nMapped =  index - (uintUserVal >> (g_Top % 31)) % 10;



    if(nMapped < 0)

        nMapped += 10;



    //把数字转换成字符，这样 SerialNo 就是字符串。

    g_SerialNo[g_Top] = nMapped + _T('0');

    ++g_Top;

}



//是否可以直接修改 Bits[ index ]

//要求必须满足 [0 0 0 ... 0 1 Index...



BOOL CanModify(int index)

{

    int i;

    if(index > 1)

    {

        if(g_UserBits[index - 1] != 1)

            return FALSE;

    }

    for(i = 1; i <= index - 2; i++)

    {

        if(g_UserBits[i] != 0)

            return FALSE;

    }

    return TRUE;

}



//递归函数，把索引为index的位设置为 nDesiredVal。



void SetBit(int index, int nDesiredVal)

{

    int i;

    if(g_UserBits[index] != nDesiredVal)

    {

        //能立即修改吗？如果不能，调整低位。

        if(!CanModify(index))

        {

            SetBit(index - 1, 1);

            for(i = index - 2; i >= 1; i--)

            {

                SetBit(i, 0);

            }

        }



        //现在可以修改这一位了！

        g_UserBits[index] = nDesiredVal;

        Push(index);

    }

}



//根据用户名，计算出用户特征值

int GetUserValue(LPCTSTR szUser)

{

    int nUserVal= 0x13572468;

    int i;

    int len = _tcslen(szUser);

    for(i = 0; i < len; i++)

    {

        nUserVal = nUserVal + szUser[i];

        nUserVal = nUserVal * 0x03721273;

        nUserVal = nUserVal + 0x24681357;

        nUserVal = (nUserVal << 25) | (nUserVal >> 7);

    }

    return nUserVal;

}



//

void InitUserBits()

{

    //下面指令中用到 SHR （逻辑右移），所以需要无符号数



    UINT uintUserVal = g_UserVal;

    int i;

    for(i = 1; i < 9; i++)

    {

        g_UserBits[i] = (uintUserVal >> i) & 1;

    }



    //最高位被置为1，保证注册码必然具有相当长度。

    g_UserBits[9] = 1;

}



BOOL GetSerialNo(LPCTSTR szUserName)

{

    int i;



    if(_tcslen(szUserName) == 0)

        return FALSE;



    g_UserVal = GetUserValue(szUserName);

    memset(g_UserBits, 0, sizeof(g_UserBits));

    InitUserBits();



    g_Top = 0;



    for(i = 9; i >= 1; i--)

        SetBit(i, 0);



    //字符串的 null-terminator;

    g_SerialNo[g_Top] = 0;

    ++g_Top;

}

 

　　这里，附上原题目程序，我写的注册机的源码以及可执行文件的压缩包下载：

　　http://files.cnblogs.com/hoodlum1980/CrackMe_1_1.zip

 

　　注册机截图，用 VC 写的一个对话框程序（写成 Console 程序更容易，但 Windows 程序对用户来说更熟悉）：

 

　　

 

　　最后，随便给出一个注册机计算出的注册码作为结束（由于注册码太长，所以插入了换行和缩进）：

 

　　User:   hoodlum1980  Serial:

　　3299167863423793371021417400742237107415

　　4242840289212146582658628926588332475377

　　0031219490849267008495623294423911312678

　　1668321916686352376337402131741074023730

　　7405425284528981213658365842894658733257

　　5347006121849094924700049552320442991171

　　2668167832991688634237733710216174007412

　　3710742542428462892121865826585289265893

　　3247535700312114908492570084957232944209

　　1131260816683209166863623763372021317430

　　740237207405426284528931213658

 

---

 

　　【1】关于 DecryptText 函数，用于加/解密字符串（对称），其等效 C 语言代码如下：

 

void DecryptText(const BYTE *pSecret, char *pTextBuf)

{

    int i;

    BYTE key[] = 

    {

        0x25, 0x9A, 0xF3, 0x6F,

        0x82, 0xDA, 0x72, 0xFE,

        0xC9, 0xB7

    };



    if(pSecret[0] == 0xFF)

    {

        for(i = 0; i < 10; i++)

            pTextBuf[i] = pSecret[i + 1] ^ key[i];

    }

    else

    {

        strcpy(pTextBuf, (const char*)pSecret);

    }

}

 

　　【2】关于对话框的窗口过程，是非常简单的。但它在栈上为临时变量分配空间使用的不是常规的（ sub esp, ....） 语句，而是调用了函数（loc_400540）来完成分配临时空间，这个函数可以总结为等效于（ sub esp, eax ），只需要把这个函数理解成分配栈上空间即可。（2014年5月4日 补充 --hoodlum1980）