您的位置:首页精文荟萃破解文章 → 如何破解Opera 4.0 Final

如何破解Opera 4.0 Final

时间:2004/10/15 1:00:00来源:本站整理作者:蓝点我要评论(0)

 

 


                   
Opera 4.0 Final的注册码与4.0 beta 5相比,差别不大,但是和以前的版本相比,注册码判断算法有根本的变化,找注册码等价于写注册机。不过我觉得这种只改变算法的策略并不能很好地保护其软件。

首先,我们用bpx GetDlgItemTextA设断点,它会调用该函数3次,分别读入Name、Company、Code。由于Name、Company与Code无关,故我们只要在它最后一次调用GetDlgItemTexA时拦住即可。如下:

:004420A6 8B6C2410                mov ebp, dword ptr [esp+10]
:004420AA BB2B010000              mov ebx, 0000012B
:004420AF 57                      push edi

* Reference To: USER32.GetDlgItemTextA, Ord:0104h
                                  |
:004420B0 8B3D5C555300            mov edi, dword ptr [0053555C]
:004420B6 8D8638010000            lea eax, dword ptr [esi+00000138]
:004420BC 53                      push ebx
:004420BD 50                      push eax
:004420BE 68BD2B0000              push 00002BBD
:004420C3 55                      push ebp
:004420C4 FFD7                    call edi                          //读取Name
:004420C6 8D8664020000            lea eax, dword ptr [esi+00000264]
:004420CC 53                      push ebx
:004420CD 50                      push eax
:004420CE 68BE2B0000              push 00002BBE
:004420D3 55                      push ebp
:004420D4 FFD7                    call edi                        //读取Company
:004420D6 8D8690030000            lea eax, dword ptr [esi+00000390]
:004420DC 53                      push ebx
:004420DD 50                      push eax
:004420DE 68BF2B0000              push 00002BBF
:004420E3 55                      push ebp
:004420E4 FFD7                    call edi                        //读取Code

查阅一下API手册,可以知道传递给GetDlgItemTextA( )的第3个参数是缓冲区的首址。看一下上面的代码,发现在3次调用GetDlgItemTextA( )时使用的缓冲区首址是esi+00000390,于是等它执行完CS:004420E4处的call edi指令后,马上用BPR esi+390 esi+390+len rw作为断点监视你输入的假注册码,看它如何处理你输入的假注册码,其中len是假注册码的长度。然后按F5执行,马上在下面的地方又中断下来:

:0050E680 F7C703000000            test edi, 00000003
:0050E686 7514                    jne 0050E69C
:0050E688 C1E902                  shr ecx, 02
:0050E68B 83E203                  and edx, 00000003
:0050E68E 83F908                  cmp ecx, 00000008
:0050E691 7229                    jb 0050E6BC
:0050E693 F3                      repz
:0050E694 A5                      movsd                          //在这里中断
:0050E695 FF2495A8E75000          jmp dword ptr [4*edx+0050E7A8]

很显然,它要把我们的假注册码搬到内存的另一个地方去。清除所有断点,直接按一下F12,回到上一层,我们准备从更高的调用层次上来分析一下程序大致流程,免得过早地陷入细节分析中去。如无特殊说明,以后就只按F10了。

:0043CF6C 68BC040000              push 000004BC
:0043CF71 56                      push esi
:0043CF72 57                      push edi
:0043CF73 E8E8160D00              call 0050E660                    //刚才是在这里面

...............................................

:0043D00C FF750C                  push [ebp+0C]
:0043D00F 894514                  mov dword ptr [ebp+14], eax
:0043D012 E849110D00              call 0050E160                  //求注册码长度
:0043D017 83F80C                  cmp eax, 0000000C              //长度等于12吗?
:0043D01A 59                      pop ecx
:0043D01B 753C                    jne 0043D059
:0043D01D 56                      push esi
:0043D01E E8A40F0D00              call 0050DFC7
:0043D023 BE00010000              mov esi, 00000100
:0043D028 56                      push esi
:0043D029 E8D30F0D00              call 0050E001
:0043D02E 59                      pop ecx
:0043D02F 8BF8                    mov edi, eax
:0043D031 59                      pop ecx
:0043D032 56                      push esi
:0043D033 57                      push edi

* Possible Reference to String Resource ID=22005: "Invalid registration number. "
                                                  "You have probably entered a previous"
                                  |
:0043D034 68F5550000              push 000055F5
:0043D039 8B0DB8205600            mov ecx, dword ptr [005620B8]
:0043D03F E8E6500800              call 004C212A
:0043D044 6A10                    push 00000010
:0043D046 FF7514                  push [ebp+14]
:0043D049 57                      push edi
:0043D04A FF7508                  push [ebp+08]

* Reference To: USER32.MessageBoxA, Ord:01BEh
                                  |
:0043D04D FF1574565300            Call dword ptr [00535674]

上述代码检查你输入的假注册码长度是否为12,若为12则认为是老版本的注册码,否则继续检查你输入的假注册码的前12位是否和旧版本的相同。

:0043D086 8D45C4                  lea eax, dword ptr [ebp-3C]  //字符串1
:0043D089 50                      push eax
:0043D08A 8D857CFFFFFF            lea eax, dword ptr [ebp-84]  //字符串2
:0043D090 50                      push eax
:0043D091 E87A0F0D00              call 0050E010                //比较字符串
:0043D096 83C420                  add  esp, 20
:0043D099 85C0                    test eax, eax
:0043D09B 7521                    jne 0043D0BE
:0043D09D 56                      push esi
:0043D09E E8240F0D00              call 0050DFC7
:0043D0A3 BE00010000              mov esi, 00000100
:0043D0A8 56                      push esi
:0043D0A9 E8530F0D00              call 0050E001
:0043D0AE 59                      pop ecx
:0043D0AF 8BF8                    mov edi, eax
:0043D0B1 59                      pop ecx
:0043D0B2 56                      push esi
:0043D0B3 57                      push edi

* Possible Reference to String Resource ID=22006: "Invalid registration number."
                                                  "You have entered a 3.5x or 3.6x"
                                  |
:0043D0B4 68F6550000              push 000055F6
:0043D0B9 E97BFFFFFF              jmp 0043D039

如果不相同,则马上到了关键的判断(由于W32Dasm犯傻,故改用SoftICE反汇编出来的代码),总算是有点盼头了。

015F:0043D0CF  8D8790030000        LEA      EAX,[EDI+00000390]
015F:0043D0D5  50                  PUSH      EAX                          //假注册码
015F:0043D0D6  E812040000          CALL      0043D4ED                    //核心判断
015F:0043D0DB  59                  POP      ECX
015F:0043D0DC  84C0                TEST      AL,AL
015F:0043D0DE  59                  POP      ECX
015F:0043D0DF  7507                JNZ      0043D0E8
015F:0043D0E1  C745FC01000000      MOV      DWORD PTR [EBP-04],00000001  //设good标志位

按F8跟进call 0043D4ED中去,可以看到这个函数写得简明扼要:

:0043D4ED 55                      push ebp
:0043D4EE 8BEC                    mov ebp, esp
:0043D4F0 83EC18                  sub esp, 00000018
:0043D4F3 E8319FFDFF              call 00417429              //准备性的计算工作,不必跟进去
:0043D4F8 84C0                    test al, al
:0043D4FA 7530                    jne 0043D52C              //这里是绝对不会跳的
:0043D4FC FF7508                  push [ebp+08]
:0043D4FF 8D45E8                  lea eax, dword ptr [ebp-18]
:0043D502 50                      push eax
:0043D503 E8EC690B00              call 004F3EF4              //重要,必须跟进去
:0043D508 59                      pop ecx
:0043D509 84C0                    test al, al
:0043D50B 59                      pop ecx
:0043D50C 751E                    jne 0043D52C
:0043D50E 8D45E8                  lea eax, dword ptr [ebp-18]
:0043D511 50                      push eax
:0043D512 E8889FFDFF              call 0041749F            //重要,必须跟进去
:0043D517 84C0                    test al, al
:0043D519 59                      pop ecx
:0043D51A 7510                    jne 0043D52C
:0043D51C 8D45E8                  lea eax, dword ptr [ebp-18]
:0043D51F 50                      push eax
:0043D520 E8D56B0B00              call 004F40FA            //重要,必须跟进去
:0043D525 84C0                    test al, al
:0043D527 59                      pop ecx
:0043D528 7502                    jne 0043D52C
:0043D52A C9                      leave
:0043D52B C3                      ret
:0043D52C 0CFF                    or al, FF                //bad guy
:0043D52E C9                      leave
:0043D52F C3                      ret

由此可知,要点在上述的3个call中。下面得改按F8,逐一分析这3个call。先跟进call 004F3EF4:

:004F3EF4 55                      push ebp
:004F3EF5 8BEC                    mov ebp, esp
:004F3EF7 51                      push ecx
:004F3EF8 53                      push ebx
:004F3EF9 56                      push esi
:004F3EFA 8B750C                  mov esi, dword ptr [ebp+0C]
:004F3EFD B02D                    mov al, 2D
:004F3EFF 57                      push edi
:004F3F00 384601                  cmp byte ptr [esi+01], al    //第1个字符为'-'吗?
:004F3F03 0F85A4000000            jne 004F3FAD
:004F3F09 384607                  cmp byte ptr [esi+07], al    //第7个字符为'-'吗?
:004F3F0C 0F859B000000            jne 004F3FAD
:004F3F12 38460D                  cmp byte ptr [esi+0D], al    //第13个字符为'-'吗?
:004F3F15 0F8592000000            jne 004F3FAD
:004F3F1B 384613                  cmp byte ptr [esi+13], al    //第19个字符为'-'吗?
:004F3F1E 0F8589000000            jne 004F3FAD
:004F3F24 384619                  cmp byte ptr [esi+19], al    //第25个字符为'-'吗?
:004F3F27 0F8580000000            jne 004F3FAD

:004F3F2D 56                      push esi
:004F3F2E E82DA20100              call 0050E160                //求注册码长度
:004F3F33 83F81F                  cmp eax, 0000001F            //长度为31吗?
:004F3F36 59                      pop ecx
:004F3F37 7574                    jne 004F3FAD

到了这里,我们就知道注册码应包含31个字符,且第1、7、13、19、25个均为横杠字符'-'。于是将假注册码改成
w-RSuhU-8bbTm-taXah-v3uMt-EDrKv(这个是可用的,呵呵),重复上面的步骤,到如下的地方。

下面是一个两重循环,在这个两重循环中,它要把你输入的假注册码的后5部分转换成5个长整数。根据其转换过程,我们知道注册码的后5部分可以看作是5个五十进制数。即RSuhU、8bbTm、taXah、v3uMt、EDrKv为5个五十进制的数,只不过最低位
在最左边。它所使用的五十进制数的表格为"abcdefhijkmnprstuvwxyzABCDEFHJKLMNPQRSTUVWXY345678"。

  下面举个例子,看它如何把注册码的第2部分即五十进制数“RSuhU”转换为对应的十六进制数。
  1、首先取五十进制数的最低位,即R,查表,发现R在该表中的下标为36,即五十进制中的R对应十进制中的36。用
      用36乘以50的0次方,得到36。
  2、再取五十进制数RSuhU的次低位,即S,查表,发现S在该表中的下标为37,即五十进制中的S对应十进制中的37。
      用37乘以50的1次方,得到1850。
  3、取五十进制数RSuhU的u位,查表,发现五十进制的u对应十进制的16。
      用16乘以50的2次方,得到40000。
  4、取五十进制数RSuhU的h位,查表,发现五十进制的h对应十进制的6。
      用6乘以50的3次方,得到750000。
  5、取五十进制数RSuhU的U位,查表,发现五十进制的U对应十进制的39。
      用39乘以50的4次方,得到243750000。
  将上述5个乘积累加,得到244541886。十进制数244541886的十六进制形式为0E9369BE,故五十进制数RSuhU对应的十六进制数为0E9369BE(当然前提是遵循Opera的作者所制定的转换规则,即使用上面的那张表)。
  同理可把8bbTm、taXah、v3uMt、EDrKv转换为对应的十六进制数:04023177、023DCE97、05D430D9、068EFB70。
  除了转换之外,它还限制转换后的十六进制数不得大于0x0FFFFFFF,即最高4 bit必须为0,这点在后面会用到。

:004F3F39 8B4508                  mov eax, dword ptr [ebp+08]
:004F3F3C 8A0E                    mov cl, byte ptr [esi]          //注册码的第1部分
:004F3F3E 8365FC00                and dword ptr [ebp-04], 00000000
:004F3F42 8D7E02                  lea edi, dword ptr [esi+02]
:004F3F45 8808                    mov byte ptr [eax], cl          //把注册码的第1部分搬到另外的地方
:004F3F47 83C004                  add eax, 00000004
:004F3F4A 894508                  mov dword ptr [ebp+08], eax

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F3FA7(C)
|
:004F3F4D 33DB                    xor ebx, ebx                      //累加和清0
:004F3F4F C7450C01000000          mov [ebp+0C], 00000001            //50的0次方
:004F3F56 33F6                    xor esi, esi                      //循环控制变量清0

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F3F8A(C)
|
:004F3F58 0FBE0437                movsx eax, byte ptr [edi+esi]        //取五十进制数的一位
:004F3F5C 50                      push eax
:004F3F5D FF3584D35300            push dword ptr [0053D384]
:004F3F63 E888AA0100              call 0050E9F0                        //查表
:004F3F68 59                      pop ecx
:004F3F69 85C0                    test eax, eax
:004F3F6B 59                      pop ecx
:004F3F6C 743F                    je 004F3FAD
:004F3F6E 2A0584D35300            sub al, byte ptr [0053D384]
:004F3F74 0FB6C0                  movzx eax, al                      //查表所得的下标
:004F3F77 0FAF450C                imul eax, dword ptr [ebp+0C]      //乘以50的n次方
:004F3F7B 03D8                    add ebx, eax                      //累加到ebx中
:004F3F7D 8B450C                  mov eax, dword ptr [ebp+0C]
:004F3F80 6BC032                  imul eax, 00000032                //50的n次方再乘以50
:004F3F83 46                      inc esi                            //循环控制变量++
:004F3F84 89450C                  mov dword ptr [ebp+0C], eax
:004F3F87 83FE05                  cmp esi, 00000005                  //5位全转换完了?
:004F3F8A 7CCC                    jl 004F3F58                        //内循环
:004F3F8C F7C3000000F0            test ebx, F0000000                //转换结果不得大于0x0FFFFFFF
:004F3F92 7519                    jne 004F3FAD                      //jump if bad guy
:004F3F94 8B4508                  mov eax, dword ptr [ebp+08]
:004F3F97 FF45FC                  inc [ebp-04]
:004F3F9A 83450804                add dword ptr [ebp+08], 00000004
:004F3F9E 83C706                  add edi, 00000006
:004F3FA1 837DFC05                cmp dword ptr [ebp-04], 00000005  //注册码的后5部分全转换完了?
:004F3FA5 8918                    mov dword ptr [eax], ebx
:004F3FA7 7CA4                    jl 004F3F4D                      //外循环
:004F3FA9 32C0                    xor al, al                        //good guy
:004F3FAB EB02                    jmp 004F3FAF

经过上面的转换,注册码的后5部分被转换成了5个十六进制数。显然上面的转换是可逆的,即给定一个十六进制数,我们可以写出其五十进制的表示。这对写注册机是有用的。下面我们继续看它如何处理这5个数。用数组a[5]表示这5个数,则下面的汇编代码可以翻译为对应的C程序:
      for(k = 0; k < 4; k++)
      {
            a[k] ^= a[k+1];
      }

* Referenced by a CALL at Address:
|:004174A3 
|
:004174F3 8B442404                mov eax, dword ptr [esp+04]
:004174F7 56                      push esi
:004174F8 6A04                    push 00000004                  //循环4次
:004174FA 83C004                  add eax, 00000004
:004174FD 5A                      pop edx
:004174FE 8B7004                  mov esi, dword ptr [eax+04]    //取出a[k+1]
:00417501 8D4804                  lea ecx, dword ptr [eax+04]
:00417504 3130                    xor dword ptr [eax], esi      //与a[k]异或
:00417506 4A                      dec edx
:00417507 8BC1                    mov eax, ecx
:00417509 75F3                    jne 004174FE                  //循环
:0041750B 32C0                    xor al, al
:0041750D 5E                      pop esi
:0041750E C3                      ret

由于异或运算是可逆的,因此上面的变换也可逆。我们继续看它如何处理异或过的这5个数。接下来将是一个大的异或变换,不过不用担心,这个变换仍是可逆的。如下:

* Referenced by a CALL at Address:
|:004174B4 
|
:004174C4 56                      push esi
:004174C5 57                      push edi
:004174C6 33FF                    xor edi, edi                  //循环控制变量edi清0

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004174EC(C)
|
:004174C8 6A05                    push 00000005
:004174CA 8BC7                    mov eax, edi
:004174CC 33D2                    xor edx, edx
:004174CE 59                      pop ecx
:004174CF F7F1                    div ecx                      //循环控制变量edi对5求余
:004174D1 8B44240C                mov eax, dword ptr [esp+0C]
:004174D5 6A00                    push 00000000
:004174D7 8D749004                lea esi, dword ptr [eax+4*edx+04]
:004174DB E870FFFFFF              call 00417450                //取常数数列的下一项
:004174E0 25FFFFFF0F              and eax, 0FFFFFFF            //屏蔽掉高4个bit
:004174E5 59                      pop ecx
:004174E6 3106                    xor dword ptr [esi], eax      //与a[edi % 5]异或
:004174E8 47                      inc edi                      //循环控制变量加1
:004174E9 83FF65                  cmp edi, 00000065           
:004174EC 72DA                    jb 004174C8                  //继续循环
:004174EE 5F                      pop edi
:004174EF 32C0                    xor al, al
:004174F1 5E                      pop esi
:004174F2 C3                      ret


上面的汇编代码可翻译为如下的伪码:
            for(edi = 0; edi < 0x65; edi++)
            {
                  NextNumber = GetNumberFromSequence( );
                  NextNumber &= 0x0FFFFFFF;
                  a[edi % 5] ^= NextNumber;
            }
即用一个常数数列的前0x65项来分别与我们在上一步所得到的5个数进行异或。这个循环的异或过程可以等价于:
            a[0] ^= 常数1;
            a[1] ^= 常数2;
            a[2] ^= 常数3;
            a[3] ^= 常数4;
            a[4] ^= 常数5;
其中上述5个常数是可以求出来的,因为所用到的常数数列是确定的,跟进call 00417450就可以看清常数数列的计算过程。
用Sequence[n]表示该数列的第n项,则call 00417450的作用就是根据Sequence[n]计算出Sequence[n+1]来,相当于数列的递推公式,如下所示。

:0041745C 8B0D50625400            mov ecx, dword ptr [00546250]  //取出Sequence[n]
:00417462 8BC1                    mov eax, ecx
:00417464 8D1409                  lea edx, dword ptr [ecx+ecx]
:00417467 24FE                    and al, FE
:00417469 33C2                    xor eax, edx
:0041746B 8BD1                    mov edx, ecx
:0041746D D1E0                    shl eax, 1
:0041746F 83E2FC                  and edx, FFFFFFFC
:00417472 33C2                    xor eax, edx
:00417474 8BD1                    mov edx, ecx
:00417476 C1E002                  shl eax, 02
:00417479 83E2F0                  and edx, FFFFFFF0
:0041747C 33C2                    xor eax, edx
:0041747E 8BD1                    mov edx, ecx
:00417480 C1E002                  shl eax, 02
:00417483 83E2C0                  and edx, FFFFFFC0
:00417486 33C2                    xor eax, edx
:00417488 8BD1                    mov edx, ecx
:0041748A C1E019                  shl eax, 19
:0041748D 81E200000080            and edx, 80000000
:00417493 33C2                    xor eax, edx
:00417495 D1E9                    shr ecx, 1
:00417497 0BC1                    or eax, ecx
:00417499 A350625400              mov dword ptr [00546250], eax  //保存Sequence[n+1]
:0041749E C3                      ret

看一下DS:[00546250]中存放的初始值,就知道Sequence[0] = 0x01A26A75。根据异或运算的结合律,可以知道:
    常数1 = (Sequence[1] ^ Sequence[6]  ^ ... ^ Sequence[96] ^ Sequence[101]) & 0x0FFFFFFF
    常数2 = (Sequence[2] ^ Sequence[7]  ^ ... ^ Sequence[97])                & 0x0FFFFFFF
    常数3 = (Sequence[3] ^ Sequence[8]  ^ ... ^ Sequence[98])                & 0x0FFFFFFF
    常数4 = (Sequence[4] ^ Sequence[9]  ^ ... ^ Sequence[99])                & 0x0FFFFFFF
    常数5 = (Sequence[5] ^ Sequence[10] ^ ... ^ Sequence[100])                & 0x0FFFFFFF

经过了上面的循环异或后,我们再来看看它下面是怎么处理的。运算了半天,总该判断一下了吧。
在如下的代码中,它要判断注册码的第2部分。

* Referenced by a CALL at Address:
|:004F4107 
|
:004F3FB4 55                      push ebp
:004F3FB5 8BEC                    mov ebp, esp
:004F3FB7 83EC18                  sub esp, 00000018
:004F3FBA 8B4508                  mov eax, dword ptr [ebp+08]
:004F3FBD 56                      push esi
:004F3FBE 8B750C                  mov esi, dword ptr [ebp+0C]
:004F3FC1 57                      push edi
:004F3FC2 BA000000F0              mov edx, F0000000            //掩码,用来提取一个数的高4bit(即28~31 bit)
:004F3FC7 8B4E08                  mov ecx, dword ptr [esi+08]  //取出a[1]
:004F3FCA 89480C                  mov dword ptr [eax+0C], ecx
:004F3FCD 8B4E0C                  mov ecx, dword ptr [esi+0C]  //取出a[2]
:004F3FD0 894810                  mov dword ptr [eax+10], ecx
:004F3FD3 8B4E10                  mov ecx, dword ptr [esi+10]  //取出a[3]
:004F3FD6 894814                  mov dword ptr [eax+14], ecx
:004F3FD9 8B4E14                  mov ecx, dword ptr [esi+14]  //取出a[4]
:004F3FDC 894818                  mov dword ptr [eax+18], ecx
:004F3FDF 8B4E04                  mov ecx, dword ptr [esi+04]  //取出a[0]
:004F3FE2 C1E104                  shl ecx, 04                  //a[0]左移4位
:004F3FE5 8BF9                    mov edi, ecx
:004F3FE7 23FA                    and edi, edx                //与掩码相与
:004F3FE9 09780C                  or dword ptr [eax+0C], edi  //把a[0]的4个bit分给a[1]
:004F3FEC C1E104                  shl ecx, 04                  //a[0]再左移4位
:004F3FEF 8BF9                    mov edi, ecx
:004F3FF1 23FA                    and edi, edx                //与掩码相与
:004F3FF3 097810                  or dword ptr [eax+10], edi  //把a[0]的4个bit分给a[2]
:004F3FF6 C1E104                  shl ecx, 04                  //a[0]再左移4位
:004F3FF9 8BF9                    mov edi, ecx
:004F3FFB 23FA                    and edi, edx                //与掩码相与
:004F3FFD 097814                  or dword ptr [eax+14], edi  //把a[0]的4个bit分给a[3]
:004F4000 C1E104                  shl ecx, 04                //a[0]再左移4位
:004F4003 8BF9                    mov edi, ecx
:004F4005 23FA                    and edi, edx                //与掩码相与
:004F4007 BA000F0000              mov edx, 00000F00          //另一个掩码,用来提取一个数的第8~11 bit
:004F400C 097818                  or dword ptr [eax+18], edi  //把a[0]的4个bit分给a[4]
:004F400F C1E910                  shr ecx, 10                //a[0]再右移16位
:004F4012 8BF9                    mov edi, ecx
:004F4014 23FA                    and edi, edx                //与掩码相与,
:004F4016 3BFA                    cmp edi, edx                //与掩码比较!
:004F4018 752E                    jne 004F4048                //jump if bad guy
:004F401A 8BD1                    mov edx, ecx
:004F401C 83E101                  and ecx, 00000001          //与另一掩码相与,提取最低bit(即第0 bit)
:004F401F D1EA                    shr edx, 1                  //右移一位,等于去掉了原来的第0 bit
:004F4021 6A06                    push 00000006
:004F4023 83E27F                  and edx, 0000007F          //与掩码7F相与,提取出最低的7个bit
:004F4026 8908                    mov dword ptr [eax], ecx    //保存第0个bit,以后再判断
:004F4028 59                      pop ecx
:004F4029 8D7DE8                  lea edi, dword ptr [ebp-18]
:004F402C 895008                  mov dword ptr [eax+08], edx //保存7个bit,以后再判断
:004F402F F3                      repz
:004F4030 A5                      movsd

上面有很多位运算,实际上是在对a[0]进行五马分尸,要把a[0]的28个bit共拆分为7个部分(a[0]的最高4个bit均为0,故不考虑在内)。详细说明如下:
假定十六进制表示为:
a[0] = 0MNYZUVW,a[1] = 0xxxxxxx,a[2] = 0yyyyyyy,a[3] = 0zzzzzzz,a[4] = 0kkkkkkk。
则将a[0]拆分为7部分后,变为:
a[1] = Mxxxxxxx,a[2] = Nyyyyyyy,a[3] = Yzzzzzzz,a[4] = Zkkkkkkk。
即a[0]给了a[1]、a[2]、a[3]、a[4]各4个bit(即M、N、Y、Z)作为他们的最高4个bit。另外,a[0]的最低8个bit(即VW)被拆分为两部分,一部分只有一个bit,另外一部分有7个bit,并分别保存起来,后面它要对这两部分进行判断,此为后话。
a[0]的另外4个bit(即U)在上面的CS:004F4016处进行了判断,如果满足a[0] & 00000F00 = 00000F00,则OK,由此可知 a[0]的第8~11 bit均应为1(即U = F)。

经过这一番折腾,它把a[0]瓜分了,显然是想分散我们的注意力,只要我们漏过a[0]的7部分中的任一部分,有效的注册码就找不到。

还记不记得注册码的第1部分只有一个字符?接下来它就要对注册码的第1部分进行查表变换。

:004F4031 0FB655E8                movzx edx, byte ptr [ebp-18]      //取出注册码的第1部分
:004F4035 33C9                    xor ecx, ecx                      //下标清0

:004F4037 0FBEB180D35300          movsx esi, byte ptr [ecx+0053D380]//查表,从表"emuw"中取出一个字符
:004F403E 3BF2                    cmp esi, edx                      //和注册码的第一部分相等?
:004F4040 740A                    je 004F404C                      //相等则将下标记下来
:004F4042 41                      inc ecx                          //下标加1
:004F4043 83F903                  cmp ecx, 00000003                //该表中仅4个字符
:004F4046 7EEF                    jle 004F4037                    //循环,遍历该表

:004F4048 0CFF                    or al, FF                        //bad guy
:004F404A EB05                    jmp 004F4051
:004F404C 894804                  mov dword ptr [eax+04], ecx      //保存此时的下标
:004F404F 32C0                    xor al, al                        //good guy
:004F4051 5F                      pop edi
:004F4052 5E                      pop esi
:004F4053 C9                      leave
:004F4054 C3                      ret

由上可见,如果你输入的假注册码的第一个字符如果不是e或m或u或w,则bye-bye了。否则它就记下该下标,此后要对这个下标进行判断,耐心等等,后面还会提到。

接下来,它要根据a[1]、a[2]、a[3]计算出一个数来,然后和a[4]进行比较。至此我们知道a[4]是根据a[1]、a[2]、a[3]计算出来的,这对写注册机很重要。计算没什么特别的地方,照搬到我们的注册机中,稍加改动即可。计算过程如下:

* Referenced by a CALL at Address:
|:004F411A 
|
:004F4055 55                      push ebp
:004F4056 8BEC                    mov ebp, esp
:004F4058 83EC0C                  sub esp, 0000000C
:004F405B 8B4D08                  mov ecx, dword ptr [ebp+08]
:004F405E 53                      push ebx
:004F405F 56                      push esi
:004F4060 33F6                    xor esi, esi
:004F4062 8B4104                  mov eax, dword ptr [ecx+04]
:004F4065 57                      push edi
:004F4066 40                      inc eax
:004F4067 C745FC79786573          mov [ebp-04], 73657879
:004F406E C745F865626162          mov [ebp-08], 62616265
:004F4075 8945F4                  mov dword ptr [ebp-0C], eax

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40DF(C)
|
:004F4078 8BC6                    mov eax, esi
:004F407A 6A03                    push 00000003
:004F407C 99                      cdq
:004F407D 5F                      pop edi
:004F407E F7FF                    idiv edi
:004F4080 46                      inc esi
:004F4081 6A03                    push 00000003
:004F4083 8BC6                    mov eax, esi
:004F4085 5B                      pop ebx
:004F4086 8B7C910C                mov edi, dword ptr [ecx+4*edx+0C]
:004F408A 99                      cdq
:004F408B F7FB                    idiv ebx
:004F408D 8B45F4                  mov eax, dword ptr [ebp-0C]
:004F4090 85C0                    test eax, eax
:004F4092 8B54910C                mov edx, dword ptr [ecx+4*edx+0C]
:004F4096 7E37                    jle 004F40CF
:004F4098 8B5DFC                  mov ebx, dword ptr [ebp-04]
:004F409B 894508                  mov dword ptr [ebp+08], eax

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40AA(C)
|
:004F409E 8BC3                    mov eax, ebx
:004F40A0 0FAFC3                  imul eax, ebx
:004F40A3 33C7                    xor eax, edi
:004F40A5 FF4D08                  dec [ebp+08]
:004F40A8 8BD8                    mov ebx, eax
:004F40AA 75F2                    jne 004F409E
:004F40AC 895DFC                  mov dword ptr [ebp-04], ebx

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40D2(U)
|
:004F40AF 8B4108                  mov eax, dword ptr [ecx+08]
:004F40B2 83C003                  add eax, 00000003
:004F40B5 85C0                    test eax, eax
:004F40B7 7E1B                    jle 004F40D4
:004F40B9 894508                  mov dword ptr [ebp+08], eax
:004F40BC 8B45F8                  mov eax, dword ptr [ebp-08]

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40CB(C)
|
:004F40BF 8BF8                    mov edi, eax
:004F40C1 0FAFF8                  imul edi, eax
:004F40C4 33FA                    xor edi, edx
:004F40C6 FF4D08                  dec [ebp+08]
:004F40C9 8BC7                    mov eax, edi
:004F40CB 75F2                    jne 004F40BF
:004F40CD EB0A                    jmp 004F40D9

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F4096(C)
|
:004F40CF 8B5DFC                  mov ebx, dword ptr [ebp-04]
:004F40D2 EBDB                    jmp 004F40AF

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40B7(C)
|
:004F40D4 8B45F8                  mov eax, dword ptr [ebp-08]
:004F40D7 EB03                    jmp 004F40DC

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40CD(U)
|
:004F40D9 8945F8                  mov dword ptr [ebp-08], eax

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F40D7(U)
|
:004F40DC 83FE1F                  cmp esi, 0000001F
:004F40DF 7C97                    jl 004F4078
:004F40E1 81E3F0F0F000            and ebx, 00F0F0F0            //最高4 bit被干掉了
:004F40E7 250F0F0F0F              and eax, 0F0F0F0F            //最高4 bit被干掉了
:004F40EC 0BD8                    or ebx, eax
:004F40EE 8B450C                  mov eax, dword ptr [ebp+0C]
:004F40F1 5F                      pop edi
:004F40F2 5E                      pop esi
:004F40F3 8918                    mov dword ptr [eax], ebx      //保存计算的结果
:004F40F5 32C0                    xor al, al
:004F40F7 5B                      pop ebx
:004F40F8 C9                      leave
:004F40F9 C3                      ret

注意上面的注释!在CS:004F40E1和CS:004F40E7这两处,最高4个bit都被变为0了,这意味着计算出来的这个数的最高4 bit全部为0。但是它又要拿这个计算出来的数和a[4]进行比较,那说明此时a[4]的最高4 bit也必须为0。
还记不记得此时a[4]的最高4 bit是从a[0]中分来的(十六进制形式为Zkkkkkkk)!至此我们又搞定a[0]的7部分
中的一部分。

下面是和a[4]进行比较:

:004F4112 8D4508                  lea eax, dword ptr [ebp+08]
:004F4115 50                      push eax
:004F4116 8D45E4                  lea eax, dword ptr [ebp-1C]
:004F4119 50                      push eax
:004F411A E836FFFFFF              call 004F4055              //根据a[1]、a[2]、a[3]计算
:004F411F 59                      pop ecx
:004F4120 84C0                    test al, al
:004F4122 59                      pop ecx
:004F4123 7528                    jne 004F414D
:004F4125 8B45FC                  mov eax, dword ptr [ebp-04]
:004F4128 3B4508                  cmp eax, dword ptr [ebp+08] //和a[4]比较
:004F412B 7520                    jne 004F414D

紧跟着它要判断a[1]、a[2]、a[3]了,如下:


* Referenced by a CALL at Address:
|:004F4131 
|
:004F4155 8B442404                mov eax, dword ptr [esp+04]
:004F4159 56                      push esi
:004F415A BE74D35300              mov esi, 0053D374
:004F415F 8D480C                  lea ecx, dword ptr [eax+0C]

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004F4178(C)
|
:004F4162 8B01                    mov eax, dword ptr [ecx]    //取出a[k],k=1,2,3
:004F4164 33D2                    xor edx, edx
:004F4166 F736                    div dword ptr [esi]        //分别除以常数
:004F4168 85D2                    test edx, edx              //余数不为0则bad guy
:004F416A 7512                    jne 004F417E
:004F416C 83C604                  add esi, 00000004
:004F416F 83C104                  add ecx, 00000004          //余数为0则继续比较
:004F4172 81FE80D35300            cmp esi, 0053D380
:004F4178 7CE8                    jl 004F4162                //循环
:004F417A 32C0                    xor al, al                  //a[1]、a[2]、a[3]均通过检查则OK
:004F417C 5E                      pop esi
:004F417D C3                      ret

由上可知,此时的a[1]、a[2]、a[3]应为常数的整数倍,执行上面的那条除法指令时敲dd esi,可以看见常数分别为00114BCF, 0x0013D39F, 0x003687A9。至于究竟是多少倍,我们写注册机的时候可以用随机数(我用GetTickCount模拟随机数),这也说明这个软件有很多个注册码。注意到此时的a[1]、a[2]、a[3]的最高4 bit都是从a[0]中分来的一杯羹,于是我们又搞定了a[0]的7部分之中的3部分。

至此,我们已经可以写程序生成a[1]、a[2]、a[3],然后再生成a[4],现在只剩下a[0]的7部分中的两部分(即最低8bit位,分成7个bit和1个bit共两部分)和注册码的第一部分(即查表后的下标)了。

下面就是对这3个东西的判断:

:004F412D 8D45E4                  lea eax, dword ptr [ebp-1C]
:004F4130 50                      push eax
:004F4131 E81F000000              call 004F4155                    //这里头检查a[1]、a[2]、a[3]
:004F4136 84C0                    test al, al
:004F4138 59                      pop ecx
:004F4139 7512                    jne 004F414D
:004F413B 837DE400                cmp dword ptr [ebp-1C], 00000000  //a[0]的最低bit,即第0bit
:004F413F 750C                    jne 004F414D
:004F4141 837DE803                cmp dword ptr [ebp-18], 00000003  //注册码的第1部分所对应的下标
:004F4145 7506                    jne 004F414D
:004F4147 837DEC02                cmp dword ptr [ebp-14], 00000002  //a[0]的第1~7bit
:004F414B 7404                    je 004F4151

根据上面的比较可知,注册码的第一部分在表格"emuw"中的下标应为3,即注册码的第一个字符固定为w;
a[0]的最低8个bit用十六进制表示为0x04,结合前面我们得到的关于a[0]的信息,就可以把a[0]表示出来了。

至此可以写出注册机。(累死了,呵呵)

为保持完整性,把注册机再贴一下:

//keygen for Opera 4.0 Final
//compiled with Visual C++ 5

#include
#include

unsigned long  Sequence;
const unsigned long  factor[3] = { 0x00114BCF, 0x0013D39F, 0x003687A9 };
const char table[50] = "abcdefhijkmnprstuvwxyzABCDEFHJKLMNPQRSTUVWXY345678";
int k, m;
unsigned long  a[5];
long EBP_04, EBP_08, EBP_0C, EBP_p08;

void main(void)
{
 
  printf("Key generator for Opera 4.0 final.\n");
  printf("http://www.opera.com.\n");
  printf("coded by dr0, 2000.6.30.\n");
 
  for (k = 1; k <= 3; k++)
  {
      a[k] = factor[k-1] * (GetTickCount( ) % (0xFFFFFFFFL / factor[k-1] + 1));     
  }

  _asm
  {
              push      eax
              push      ebx
              push      ecx
              push      edx
              push      esi
              push      edi

              mov      ecx, offset a

              XOR      ESI,ESI
              MOV      EAX,0x03
              INC      EAX
              MOV      DWORD PTR [EBP_04],0x73657879L
              MOV      DWORD PTR [EBP_08],0x62616265L
              MOV      [EBP_0C],EAX
    _004F4078: MOV      EAX,ESI
              PUSH      0x03
              CDQ
              POP      EDI
              IDIV      EDI
              INC      ESI
              PUSH      0x03
              MOV      EAX,ESI
              POP      EBX
              MOV      EDI,[EDX*4+ECX+4]
              CDQ
              IDIV      EBX
              MOV      EAX,[EBP_0C]
              TEST      EAX,EAX
              MOV      EDX,[EDX*4+ECX+4]
              JLE      _004F40CF
              MOV      EBX,[EBP_04]
              MOV      [EBP_p08],EAX
  _004F409E:  MOV      EAX,EBX
              IMUL      EAX,EBX
              XOR      EAX,EDI
              DEC      DWORD PTR [EBP_p08]
              MOV      EBX,EAX
              JNZ      _004F409E
              MOV      [EBP_04],EBX
  _004F40AF:  MOV      EAX,0x02
              ADD      EAX,0x03
              TEST      EAX,EAX
              JLE      _004F40D4
              MOV      [EBP_p08],EAX
              MOV      EAX,[EBP_08]
  _004F40BF:  MOV      EDI,EAX
              IMUL      EDI,EAX
              XOR      EDI,EDX
              DEC      DWORD PTR [EBP_p08]
              MOV      EAX,EDI
              JNZ      _004F40BF
              JMP      _004F40D9
  _004F40CF:  MOV      EBX,[EBP_04]
              JMP      _004F40AF
  _004F40D4:  MOV      EAX,[EBP_08]
              JMP      _004F40DC
  _004F40D9:  MOV      [EBP_08],EAX
  _004F40DC:  CMP      ESI,0x1F
              JL        _004F4078
              AND      EBX,0x00F0F0F0L
              AND      EAX,0x0F0F0F0FL
              OR        EBX,EAX

              mov      [ecx+4*4], ebx

              pop      edi
              pop      esi
              pop      edx
              pop      ecx
              pop      ebx
              pop      eax
  }

  a[0] = 0;
  for (k = 1; k <= 3; k++)
  {
      a[0] |= a[k] >> 28;
      a[0] <<= 4;
  }
  a[0] <<= 12;
  a[0] |= 0x00000F04L;

  for (k = 0; k < 4; k++)
  {
      a[k] &= 0x0FFFFFFFL;
  }

  Sequence = 0x01A26A75;
  for(k = 0; k < 0x65; k++)
  {
    _asm
    {
            push eax
            push ecx
            push edx
           
            MOV      ECX, [Sequence]
            MOV      EAX, ECX
            LEA      EDX, [ECX+ECX]
            AND      AL,  0xFE
            XOR      EAX, EDX
            MOV      EDX, ECX
            SHL      EAX, 1
            AND      EDX, -0x04
            XOR      EAX

相关阅读 Windows错误代码大全 Windows错误代码查询激活windows有什么用Mac QQ和Windows QQ聊天记录怎么合并 Mac QQ和Windows QQ聊天记录Windows 10自动更新怎么关闭 如何关闭Windows 10自动更新windows 10 rs4快速预览版17017下载错误问题Win10秋季创意者更新16291更新了什么 win10 16291更新内容windows10秋季创意者更新时间 windows10秋季创意者更新内容kb3150513补丁更新了什么 Windows 10补丁kb3150513是什么

文章评论
发表评论

热门文章 去除winrar注册框方法

最新文章 比特币病毒怎么破解 比去除winrar注册框方法 华为无线路由器HG522-C破解教程(附超级密码JEB格式文件京东电子书下载和阅读限制破解教UltraISO注册码全集(最新)通过Access破解MSSQL获得数据

人气排行 华为无线路由器HG522-C破解教程(附超级密码JEB格式文件京东电子书下载和阅读限制破解教UltraISO注册码全集(最新)qq相册密码破解方法去除winrar注册框方法(适应任何版本)怎么用手机破解收费游戏华为无线猫HG522破解如何给软件脱壳基础教程