第一节 常见保护技巧

　　1、序列号方式

　　（1）序列号保护机制

　　数学算法一项都是密码加密的核心，但在一般的软件加密中，它似乎并不太为人们关心，因为大多数时候软件加密本身实现的都是一种编程的技巧。但近几年来随着序列号加密程序的普及，数学算法在软件加密中的比重似乎是越来越大了。

　　我们先来看看在网络上大行其道的序列号加密的工作原理。当用户从网络上下载某个shareware——共享软件后，一般都有使用时间上的限制，当过了共享软件的试用期后，你必须到这个软件的公司去注册后方能继续使用。注册过程一般是用户把自己的私人信息（一般主要指名字）连同信用卡号码告诉给软件公司，软件公司会根据用户的信息计算出一个序列码，在用户得到这个序列码后，按照注册需要的步骤在软件中输入注册信息和注册码，其注册信息的合法性由软件验证通过后，软件就会取消掉本身的各种限制，这种加密实现起来比较简单，不需要额外的成本，用户购买也非常方便，在互联网上的软件80%都是以这种方式来保护的。

　　我们注意到软件验证序列号的合法性过程，其实就是验证用户名和序列号之间的换算关系是否正确的过程。其验证最基本的有两种，一种是按用户输入的姓名来生成注册码，再同用户输入的注册码比较，公式表示如下：

　　序列号 = F（用户名）

　　但这种方法等于在用户软件中再现了软件公司生成注册码的过程，实际上是非常不安全的，不论其换算过程多么复杂，解密者只需把你的换算过程从程序中提取出来就可以编制一个通用的注册程序。

　　另外一种是通过注册码来验证用户名的正确性，公式表示如下：

　　用户名称 = F逆（序列号） （如ACDSEE,小楼注）

　　这其实是软件公司注册码计算过程的反算法，如果正向算法与反向算法不是对称算法的话，对于解密者来说，的确有些困难，但这种算法相当不好设计。

　　于是有人考虑到一下的算法：

　　F1（用户名称） = F2（序列号）

　　F1、F2是两种完全不同的的算法，但用户名通过F1算法的计算出的特征字等于序列号通过F2算法计算出的特征字，这种算法在设计上比较简单，保密性相对以上两种算法也要好的多。如果能够把F1、F2算法设计成不可逆算法的话，保密性相当的好；可一旦解密者找到其中之一的反算法的话，这种算法就不安全了。一元算法的设计看来再如何努力也很难有太大的突破，那么二元呢？

　　特定值 = F（用户名，序列号）

　　这个算法看上去相当不错，用户名称与序列号之间的关系不再那么清晰了，但同时也失去了用户名于序列号的一一对应关系，软件开发者必须自己维护用户名称与序列号之间的唯一性，但这似乎不是难以办到的事，建个数据库就好了。当然你也可以根据这一思路把用户名称和序列号分为几个部分来构造多元的算法。

　　特定值 = F（用户名1，用户名2，...序列号1，序列号2...）

　　现有的序列号加密算法大多是软件开发者自行设计的，大部分相当简单。而且有些算法作者虽然下了很大的功夫，效果却往往得不到它所希望的结果。其实现在有很多现成的加密算法可以用，如RSADES,MD4,MD5,只不过这些算法是为了加密密文或密码用的，于序列号加密多少有些不同。我在这里试举一例，希望有抛砖引玉的作用：

　　1、在软件程序中有一段加密过的密文S

　　2、密钥 = F（用户名、序列号） 用上面的二元算法得到密钥

　　3、明文D = F-DES（密文S、密钥） 用得到的密钥来解密密文得到明文D

　　4、CRC = F-CRC（明文D） 对得到的明文应用各种CRC统计

　　5、检查CRC是否正确。最好多设计几种CRC算法，检查多个CRC结果是否都正确

　　用这种方法，在没有一个已知正确的序列号情况下是永远推算不出正确的序列号的。

　　（2）如何攻击序列号保护

　　要找到序列号，或者修改掉判断序列号之后的跳转指令，最重要的是要利用各种工具定位判断序列号的代码段。这些常用的API包括 GetDlgItemInt, GetDlgItemTextA, GetTabbedTextExtentA, GetWindowTextA, Hmemcpy (仅仅Windows 9x), lstrcmp, lstrlen, memcpy (限于NT/2000)。

　　1）数据约束性的秘诀

　　这个概念是+ORC提出的，只限于用明文比较注册码的那种保护方式。在大多数序列号保护的程序中，那个真正的、正确的注册码或密码（Password）会于某个时刻出现在内存中，当然它出现的位置是不定的，但多数情况下它会在一个范围之内，即存放用户输入序列号的内存地址±0X90 字节的地方。这是由于加密者所用工具内部的一个Windows数据传输的约束条件决定的。

　　2）Hmemcpy函数（俗称万能断点）

　　函数Hmemcpy是Windows9x系统的内部函数，位于KERNEL32.DLL中，它的作用是将内存中的一块数据拷贝到另一个地方。由于Windows9x系统频繁使用该函数处理各种字串，因此用它作为断点很实用，它是Windows9x平台最常用的断点。在Windows NT/2K中没有这个断点，因为其内核和Windows9x完全不同。

　　3）S命令

　　由于S命令忽略不在内存中的页面，因此你可以使用32位平面地址数据段描述符30h在整个4GB（0~FFFFFFFFh ）空间查找，一般用在Windows9x下面。具体步骤为：先输入姓名或假的序列号（如： 78787878），按Ctrl+D切换到SoftICE下，下搜索命令：

　　s 30：0 L ffffffff '78787878'

　　会搜索出地址：ss：ssssssss（这些地址可能不止一个），然后用bpm断点监视搜索到的假注册码，跟踪一下程序如何处理输入的序列号，就有可能找到正确的序列号。

　　4）利用消息断点

　　在处理字串方面可以利用消息断点WM_GETTEXT和WM_COMMAND。前者用来读取某个控件中的文本，比如拷贝编辑窗口中的序列号到程序提供的一个缓冲区里；后者则是用来通知某个控件的父窗口的，比如当输入序列号之后点击OK按钮，则该按钮的父窗口将收到一个WM_COMMAND消息，以表明该按钮被点击。

　　BMSG xxxx WM_GETTEXT （拦截序列号）

　　BMSG xxxx WM_COMMAND (拦截OK按钮)

　　可以用SoftICE提供的HWND命令获得窗口句柄的信息，也可以利用Visual Studio中的Spy++实用工具得到相应窗口的句柄值，然后用BMSG设断点拦截。例：

　　BMSG 0129 WM_COMMAND

　　2、警告（NAG）窗口

　　Nag的本义是烦人的意思。Nag窗口是软件设计者用来不时提醒用户购买正式版本的窗口。软件设计者可能认为当用户受不了试用版中的这些烦人的窗口时就会考虑购买正式版本。它可能会在程序启动或退出时弹出来，或者在软件运行的某个时刻随机或定时地弹出来，确实比较烦人。

　　去除警告窗口常用的三种方法是：修改程序的资源、静态分析，动态分析。

　　去除警告窗口用资源修改工具是个不错的方法，可以将可执行文件中的警告窗口的属性改成透明、不可见，这样就变相去除了警告窗口。

　　如果是动态跟踪调试，只需找到创建此窗口的代码，跳过即可。常用的显示窗口的函数有MessageBoxA、MessageBoxExA、 MessageBeep 、DialogBoxParamA 、ShowWindow、CreateWindowExA等。然而某些警告窗口用这些断点不管用，就可试试利用消息设断点，一般都应能拦截下来。

　　例：利用消息断点拦截警告窗口：

　　切换到SOFTICE下命令： HWND

　　应看到如下的类似信息：

　　在这些列表中查找相关应用程序的窗口句柄。如果NAG窗口上有OK按钮，在class name查找“button”。如果NAG窗口上什么都没有，那可试验找出正确的句柄。句柄列表可能非常长，但通常NAG窗口的句柄一般在列表的前面。

　　注：在这里推荐用SMU Winspector工具协助破解NAG.它能显示你所需要的信息：Window-Handle, Window-Class Name, Window-Text, Parent Window-Handle, Parent-Window Class Name, Parent Window-Text, Module ...

　　一但找到NAG窗口的句柄，应用BMSG命令在Windows的消息上下断点。现在假设NAG窗口有OK按钮，你己找到正确的句柄（handle），这时下命令：BMSG 0084 WM_DESTROY0084是NAG窗口的句柄（handle）。这条命令是NAG窗口从屏幕上消失时，SoftICE将中断。此时将深入到一些不认识的API函数，可按F12返回程序。需要指出，跟踪的目的是发现NAG窗口在何处初始化（在返回的CALL用设断）。NAG窗口大多用 Created/Destroyed类似的CALL，因此如发现这些，就可按需要跟踪下去。

　　3、时间限制

　　（1） 定时器

　　有些程序的试用版每次运行都有时间限制，例如运行10分钟或20分钟就停止工作，必须重新运行该程序才能正常工作。这些程序里面自然有个定时器来统计程序运行的时间。

　　1）使用Settimer（）

　　常用的计数器是函数Settimer（），调用这个函数创建的定时器可以发出消息VM_TIMER，或者在定时期满时调用一个回调函数。 使用这个函数会使时间延时，精度不高。

　　2）使用timeSetEvent()

　　给Windows驱动程序最精确的周期性通知是由Windows的多媒体服务timeSetEvent()提供的。它的时间可以精确到1毫秒。

　　3）使用VXD

　　可以使用VMM的Set_Global_time_Out()服务来迫使回调函数的几个毫秒再执行，这就创造了一个“只有一次”的定时器。VXD可以在回调中再次调用Set_Global_time_Out()来开始下一个定时器，这样提供了一个连续运行的定时器了。

　　4）其它

　　GetTickCount()：精度不高；

　　timeGetTime()： 可以以毫秒级返回windows开始后的时间。

　　（2）时间限制

　　一般这类保护的软件都有时间上的限制，如试用30天等，当过了共享软件的试用期后，就不予运行，只有向软件作者付费注册之后才能得到一个无时间限制的注册版本。

　　这种类型程序很多，让你有10天、20天、30天等，它们在安装时，在你的系统某处做上时间标记，每次运行时用当前系统时间和安装时的时间比较，判断你还否能使用。

　　如最典型的30天限制的一种情况：

　　mov ecx,1E ;把1E (30天 十进制) 放入 ecx

　　mov eax,[esp+10] ;把用过天数放到eax

　　cmp eax,ecx ;在此比较

　　jl ...

　　如碰到这种情况，只需把"mov eax,[esp+10]"改成"mov eax,1" 。

　　要记住当前年份、月份的十六进制的一些表示方法，如：2000年的十六进制是07D0，然后用W32DASM反汇编你的程序，用查找字符串的方法找D007（在机器码中位置颠倒了一下）或其它类似时间的数字，有可能会找到有价值的线索。你别小看这种方法，对那些没怎么防范的程序，此招很有效。

　　如：一程序限定在2000年使用，可能有如下一代码：

　　:00037805 817C2404D0070000 cmp dword ptr [esp+04], 000007D0 比较是否在2000年。

　　（3）与时间相关函数

　　1、GetSystemTime 得当前系统时间

　　说明：

　　在一个SYSTEMTIME中载入当前系统时间，这个时间采用的是“协同世界时间”（即UTC，也叫做GMT）格式。

　　VOID GetSystemTime(

　　LPSYSTEMTIME lpSystemTime // SYSTEMTIME，随同当前时间载入的结构

　　);

　　2、GetLocalTime 得当前本地时间

　　VOID GetLocalTime(

　　LPSYSTEMTIME lpSystemTime // SYSTEMTIME，用于装载本地时间的结构

　　);

　　3、SystemTimeToFileTime 根据一个FILETIME结构的内容，载入一个SYSTEMTIME结构

　　BOOL SystemTimeToFileTime(

　　CONST SYSTEMTIME * lpst, // SYSTEMTIME，包含了系统时间信息的一个结构

　　LPFILETIME lpft //FILETIME，用于装载文件时间的一个结构

　　);

　　返回值 ：非零表示成功，零表示失败。

　　4、SetTimer 创建一定时器，在指定时间内暂停

　　UINT SetTimer(

　　HWND hwnd, // 时间信息句柄

　　UINT idtimer, // 定时器ID 标识符

　　UINT uTimeout, // 暂停时间

　　TIMERPROC tmprc // 处理定时过程的程序入口地址

　　);

第二节 反跟踪技术

　　1、Anti-Debug

　　1．MeltICE子类型

　　类型：检测SoftICE、TRW2000

　　平台：Windows9x、Windows NT

　　原理：用CreateFileA( )或_lopen( )函数试图获得SoftICE的驱动程序".SICE"（Windows9X版本）、".SIWDEBUG"、".NTICE"（Windows NT版本）、".SIWVID"等的句柄，如果成功则说明SoftICE驻留在内存中。

　　2．VWIN32_Int41Dispatch子类型

　　类型：检测SoftICE

　　平台：Windows9x

　　原理：VWIN32.VxD（其VxD ID为0x002A）提供一个名为VWIN32_Int41Dispatch的VxD service（其service ID为0x002A），系统内核使用此服务来与系统级调试器如WinDBG、SoftICE等进行通信。其中0x4F号子功能是用来查询调试器是否已经驻留内存并能否处理保护模式程序，如果是的话则调试器应返回0xF386。

　　3．给SoftICE发送命令

　　类型：检测SoftICE

　　平台：Windows9x、Windows NT

　　原理：通过调试中断int 3给SoftICE发送命令让其执行，其中SI和DI寄存器中放的分别是固定值0x4647("FG")和0x4A4D("JM")。AX中存放的是子功能号，值为0x0911则表示让SoftICE执行命令，此时DX指向一个命令字符串如"HBOOT"等。AX还可以为其它子功能号，比如让 SoftICE修改断点设置等。

　　4、BoundsChecker后门

　　类型：检测SoftICE

　　平台：Windows9x、Windows NT

　　原理：这是SoftICE为BoundsChecker留的一个公开的接口，入口参数EBP = 0x4243484B(即"BCHK")，AL =4，如果SoftICE在内存中则应返回AL = 0。

　　这种方法一般也要结合SEH?（结构异常处理）来实现，否则当SoftICE不存在时就会引起非法操作。

　　5．ICECream子类型

　　类型：检测SoftICE、TRW2000

　　平台：Windows9x

　　原理：调试器驻留后修改INT 1和INT 3的入口，指向它自己的处理程序，所以入口高位偏移与其他中断不同。其他所有中断入口高位偏移都相同。

　　6．INT 68h子类型

　　类型：检测SoftICE

　　平台：Windows9x

　　原理：

　　MOV AH, 43h

　　INT 68h

　　CMP AX, 0F386h ；检测此处是否被调试器设置0F386h

　　JZ SoftICE_is_here

　　7．搜索特征串

　　类型：检测SoftICE

　　平台：Windows9x

　　原理：通过在内存中搜索SoftICE的特征串来发现SoftICE，这一般要结合SEH一起使用，以防止引起内存保护出错而使得程序被终止。这种方法在DOS下是可行的。由于Windows95之后的操作系统中的每个ring 3进程的地址空间是独立的，使得这种方法受到限制。比如在内存中搜索"WINICE.BR"。

　　8．IsDebuggerPresent子类型

　　类型：检测SoftICE

　　平台：Windows NT

　　原理：调用kernel32.dll输出的函数IsDebuggerPresent()来检测是否有调试器存在。这个函数只能检查使用Debug API来跟踪程序的调试器，无法检测SoftICE之类的系统级调试器。

　　2、Anti-静态分析

　　1．死循环语句

　　类型：对付W32Dasm

　　平台：Windows9x 、Windows NT

　　原理：下面是故意在程序中插入的一个死循环，可能会使W32Dasm的某些版本停止响应：

　　0401000 JMP 00401005

　　……

　　00401005 JMP 00401000

　　对策：W32Dasm进入死循环后，用Bpx hmempcy设断，来到死循环代码处，将其跳出死循环，或用IDA来反汇编。

　　2．利用花指令

　　花指令是对付静态分析的重要手段。以下是一段汇编源程序：

　　start_:

　　xor eax,1

　　add eax,2

　　jmp label1

　　label1: xor eax,3

　　add eax,4

　　xor eax,5

　　end start_

　　此时把源程序进行编译，然后用W32Dasm进行反汇编，得到的反汇编结果完全正常。接着我们将上述源程序作如下修改：

　　start_:

　　xor eax,1

　　add eax,2

　　jnz label1 ；注意这里，用两句条件跳转代替了：jmp label1

　　jz label1

　　db 0E8h ；注意这个无用的字节和源程序的区别

　　label1: xor eax,3

　　add eax,4

　　xor eax,5

　　end start_

　　再把源程序进行编译，然后用W32Dasm进行反汇编，来看一下反汇编后的结果：

　　:00401000 83F001

　　:00401003 83C002

　　:00401006 7503

　　xor eax, 00000001

　　add eax, 00000002

　　jne 0040100B

　　3、CRC简介

　　CRC原理及其逆向破解方法：

　　介绍：

　　这篇短文包含CRC原理介绍和其逆向分析方法,很多程序员和破解者不是很清楚了解

　　CRC的工作原理,而且几乎没人知道如何逆向分析它的方法,事实上它是非常有用的.

　　首先,这篇教程教你一般如何计算CRC,你可以将它用在数据代码保护中.第二,主要是

　　介绍如何逆向分析CRC-32,你可以以此来分析程序中的CRC保护（象反病毒编码）.当然

　　有很多有效的工具用来对付CRC,但我怀疑它是否会说明原理.

　　我要告诉你,这篇短文里中应用了很多数学知识,这不会影响一些人,而且会被一般的

　　程序员与逆向分析者很好理解.为什么？那么如果你不知道数学是如何被应用在CRC中,

　　我建议你可以停止继续学习了.所以我假定你们（读者）都是具备二进制算术知识的.

　　第一部分：CRC 介绍,CRC是什么和计算CRC的方法.

　　循环冗余码 CRC

　　我们都知道CRC.甚至你没有印象,但当你想到那些来自诸如RAR,ZIP等压缩软件发给你

　　由于错误连接和其他一些意外原因导致的文件错误的恼人的消息时,你就会知道.CRC是块

　　数据的计算值,比如对每一个文件进行压缩.在一个解压缩过程中,程序会从新计算解压文件

　　的CRC值,并且将之与从文件中读取的CRC值进行比对,如果值相同,那么正确.在CRC-32中,

　　会有1/2^32的可能性发生对确认数据更改的校验错误.

　　很多人认为CRC就是循环冗余校验,假如CRC真的就是循环冗余校验,那么很多人都错用了

　　这个术语.你不能说"这个程序的CRC是12345678".人们也常说某一个程序有CRC校验,而不

　　说是 "循环冗余校验" 校验.结论：CRC 代表循环冗余码,而不是循环冗余校验.

　　计算是如何完成的呢？好,主要的想法就是将一个文件看成一个被一些数字分割的很长的

　　位字串,这里会有一个余数---CRC！你总会有一个余数(可以是0),它至多比除数小一.

　　(9/3=3 余数=0 ;(9+2)/3=3 余数=2)

　　(或者它本身就包含一个除数在其中).

　　在这里CRC计算方法与除法有一点点区别,除法就是将被减数重复的减去除数X次,然后留下

　　余数.如果你希望得到原值,那么你就要把除数乘上X次,然后加上余数.

　　CRC计算使用特殊的减法与加法完成的.也就是一种新的"算法".计算中每一位计算的进位值

　　被"遗忘"了.

　　看如下两个例子,1是普通减法,2和3是特殊的.

　　-+

　　(1) 1101 (2) 1010 1010 (3) 0+0=0 0-0=0

　　1010- 1111+ 1111- 0+1=1 *0-1=1

　　---- ---- ---- 1+0=1 1-0=1

　　0011 0101 0101 *1+1=0 1-1=0

　　在(1)中,右数第二列可以看成是0-1=-1,因此要从高位借1,就变成(10+0)-1=1.(这就象普通

　　的'by-paper'十进制减法).特例(2,3)中,1+1会有正常的结果10,'1'是计算后的进位.这个值

　　被忽略了.特殊情况0-1应该有正常结果'-1'就要退到下一位.这个值也被忽略了.假如你对编程

　　有一定了解,这就象,XOR 操作或者更好.

　　现在来看一个除法的例子:

　　在普通算法中:

　　1001/111100001 13 9/120

　　1001 - 09 -|

　　---- -- |

　　1100 30 |

　　1001 - 27 -

　　---- --

　　0110 3 -> 余数

　　0000 -

　　----

　　1100

　　1001 -

　　----

　　011 -> 3, 余数

　　在CRC算法中:

　　1001/111100010 9/120 余数为 6

　　1001 -

　　----

　　1100

　　1001 -

　　----

　　1010

　　1001 -

　　----

　　0110

　　0000 -

　　----

　　110 -> 余数

　　(例 3)

　　这个除法的商并不重要,也没必要去记住,因为他们仅仅是一组无关紧要的位串.真正

　　重要的是余数!它就是这个值,可以说比原文件还重要的值,他就是基本的CRC.

　　过度到真正的CRC码计算.

　　进行一个CRC计算我们需要选则一个除数,从现在起我们称之为"poly".宽度W就是最高位

　　的位置,所以这个poly 1001的W 是3,而不是4.注意最高位总是1,当你选定一个宽度,那么你只

　　需要选择低W各位的值.

　　假如我们想计算一个位串的CRC码,我们想确定每一个位都被处理过,因此,我们要在目标

　　位串后面加上W个0位.在此例中,我们假设位串为1111.请仔细分析下面一个例子:

　　Poly = 10011, 宽度 W=4

　　位串 Bitstring

　　Bitstring + W zeros = 110101101 + 0000

　　10011/11010110100000000101 (我们不关心此运算的商)

　　10011|||||||| -

　　-----||||||||

　　10011|||||||

　　10011||||||| -

　　-----|||||||

　　00001||||||

　　00000|||||| -

　　-----||||||

　　00010|||||

　　00000||||| -

　　-----|||||

　　00101||||

　　00000|||| -

　　-----||||

　　01010|||

　　00000||| -

　　-----|||

　　10100||

　　10011|| -

　　-----||

　　01110|

　　00000| -

　　-----|

　　11100

　　10011 -

　　-----

　　1111 -> 余数 -> the CRC!

　　(例 4)

　　重要两点声明如下:

　　1.只有当Bitstring的最高位为1,我们才将它与poly做XOR运算,否则我们只是将

　　Bitstring左移一位.

　　2.XOR运算的结果就是被操作位串bitstring与低W位进行XOR运算,因为最高位总为0.

　　算法设计:

　　你们都应知道基于位运算的算法是非常慢的而且效率低下.但如果将计算放在每一字节上

　　进行,那么效率将大大提高.不过我们只能接受poly的宽度是8的倍数(一个字节;).可以形

　　象的看成这样一个宽度为32的poly(W=32):

　　3 2 1 0 byte

　　+---+---+---+---+

　　Pop! <--| | | | |<-- bitstring with W zero bits added, in this case 32

　　+---+---+---+---+

　　1<--- 32 bits ---> this is the poly, 4*8 bits

　　(figure 1)

　　这是一个你用来存放暂时CRC结果的记存器,现在我称它为CRC记存器或者记存器.你从右

　　至左移动位串,当从左边移出的位是1,则整个记存器被与poly的低W位进行XOR运算.(此例

　　中为32).事实上,我们精确的完成了上面除法所做的事情.

　　移动前记存器值为:10110100

　　当从右边移入4位时,左边的高4位将被移出,此例中1011将被移出,而1101被移入.

　　情况如下:

　　当前8位CRC记存器 : 01001101

　　刚刚被移出的高4位 : 1011

　　我们用此poly : 101011100, 宽度 W=8

　　现在我们用如前介绍的方法来计算记存器的新值.

　　顶部 记存器

　　---- --------

　　1011 01001101 高四位和当前记存器值

　　1010 11100 + (*1) Poly 放在顶部最高位进行XOR运算 (因为那里是1)

　　-------------

　　0001 10101101 运算结果

　　现在我们仍有一位1在高4位:

　　0001 10101101 上一步结果

　　1 01011100+ (*2) Poly 放在顶部的最低位进行XOR运算 (因为那里是1)

　　-------------

　　0000 11110001 第二步运算结果

　　^^^^

　　现在顶部所有位均为0,所以我们不需要在与poly进行XOR运算

　　你可以得到相同的结果如果你先将(*1)与(*2)做XOR然后将结果与记存器值做XOR.

　　这就是标准XOR运算的特性:

　　(a XOR b) XOR c = a XOR (b XOR c) 由此,推出如下的运算顺序也是正确的.

　　1010 11100 poly (*1) 放在顶部最高位

　　1 01011100+ polys (*2) 放在顶部最低位

　　-------------

　　1011 10111100 (*3) XOR运算结果

　　The result (*3) 将(*3)与记存器的值做XOR运算

　　1011 10111100

　　1011 01001101+ 如右:

　　-------------

　　0000 11110001

　　你看到了吗?得到一样的结果!现在(*3)变的重要了,因为顶部为1010则(3)的值总是等于

　　10111100(当然是在一定的条件之下)这意味着你可以预先计算出任意顶部位结合的XOR值.

　　注意,顶部结果总是0,这就是组合XOR操作导致的结果.(翻译不准确,保留原文)

　　现在我们回到figure 1,对每一个顶部字节的值都做移出操作,我们可以预先计算出一个值.

　　此例中,它将是一个包含256个double word(32 bit)双字的表.

　　(翻译不准确,保留原文)

　　用伪语言表示我们的算法如下:

　　While (byte string is not exhausted)

　　Begin

　　Top = top_byte of register ;

　　Register = Register shifted 8 bits left ORred with a new byte from string ;

　　Register = Register XORred by value from precomputedTable at position Top ;

　　End

　　direct table算法:

　　上面提到的算法可以被优化.字节串中的字节在被用到之前没有必要经过整个记村器.用

　　这个新的算法,我们可以直接用一个字节去XOR一个字节串通过将此字节移出记存器.结果

　　指向预先计算的表中的一个值,这个值是用来被记存器的值做XOR运算的.

　　我不十分确切的知道为什么这会得到同样的结果(这需要了解XOR运算的特性),但是这又

　　极为便利,因为你无须在你的字节串后填充0字节/位.(如果你知道原理,请告诉我:)

　　让我们来实现这个算法:

　　+----< byte string (or file) 字节串,(或是文件)

　　|

　　v 3 2 1 0 byte 字节

　　| +---+---+---+---+

　　XOR---<| | | | | Register 记存器

　　| +---+---+---+---+

　　| |

　　| XOR

　　| ^

　　v +---+---|---+---+

　　| | | | | | Precomputed table 值表(用来进行操作)

　　| +---+---+---+---+

　　+--->-: : : : :

　　+---+---+---+---+

　　| | | | |

　　+---+---+---+---+

　　(figure 2)

　　'reflected' direct Table 算法:

　　由于这里有这样一个与之相对应的'反射'算法,事情显得复杂了.一个反射的值/记存器

　　就是将它的每一位以此串的中心位为标准对调形成的.例如:0111011001就是1001101110

　　的反射串.

　　他们提出'反射'是因为UART(一种操作IO的芯片)发送每一个字节时是先发最没用的0位,

　　最后再发最有意义的第七位.这与正常的位置是相逆的.

　　除了信息串不做反射以外,在进行下一步操作前,要将其于的数据都做反射处理.所以在

　　计算值表时,位向右移,且poly也是作过反射处理的.当然,在计算CRC时,记存器也要向右

　　移,而且值表也必须是反射过的.

　　byte string (or file) -->---+

　　| 1. 表中每一个入口都是反射的.

　　byte 3 2 1 0 V 2. 初始化记存器也是反射的.

　　+---+---+---+---+ | 3. 但是byte string中的数据不是反射的,

　　| | | | |>---XOR 因为其他的都做过反射处理了.

　　+---+---+---+---+ |

　　| |

　　XOR V

　　^ |

　　+---+---|---+---+ |

　　| | | | | | 值表

　　+---+---+---+---+ |

　　: : : : : <---+

　　+---+---+---+---+

　　| | | | |

　　+---+---+---+---+

　　(figure 3)

　　我们的算法如下:

　　1. 将记存器向右移动一个字节.

　　2. 将刚移出的哪个字节与byte string中的新字节做XOR运算,

　　得出一个指向值表table[0..255]的索引

　　3. 将索引所指的表值与记存器做XOR运算.

　　4. 如数据没有全部处理完,则跳到步骤1.

　　下面是这个算法的简单的可执行汇编源码:

　　完整的CRC-32标准所包含的内容:

　　Name : "CRC-32"

　　Width : 32

　　Poly : 04C11DB7

　　Initial value : FFFFFFFF

　　Reflected : True

　　XOR out with : FFFFFFFF

　　作为对你好奇心的奖励, 这里是CRC-16标准: :)

　　Name : "CRC-16"

　　Width : 16

　　Poly : 8005

　　Initial value : 0000

　　Reflected : True

　　XOR out with : 0000

　　'XOR out with' 是为了最终得到CRC而用来与记存器最后结果做XOR运算的值.

　　假如你想了解一些关于'reversed'逆向CRC poly的话,请看我的参考文章.

　　我是在16位DOS模式下用的32位编码,因此你会在这个程序中看到很多32位与16位混合

　　的编码...当然这是很容易转换成纯32位编码的.注意这个程序是经过完整测试并且能够

　　正常运行的.下面的Java 和 C 代码都是由这个汇编代码而来的.

　　底下的这段程序就是用来计算CRC-32 table的:

　　xor ebx, ebx ;ebx=0, 将被用做一个指针.

　　InitTableLoop:

　　xor eax, eax ;eax=0 为计算新的entry.

　　mov al, bl ;al<-bl

　　生成入口.

　　xor cx, cx

　　entryLoop:

　　test eax, 1

　　jz no_topbit

　　shr eax, 1

　　xor eax, poly

　　jmp entrygoon

　　no_topbit:

　　shr eax, 1

　　entrygoon:

　　inc cx

　　test cx, 8

　　jz entryLoop

　　mov dword ptr[ebx*4 + crctable], eax

　　inc bx

　　test bx, 256

　　jz InitTableLoop

　　注释: - crctable 是一个包含256个dword的数组.

　　- 由于使用反射算法,EAX被向右移.

　　- 因此最低的8位被处理了.

　　用Java和C写的代码如下(int is 32 bit):

　　for (int bx=0; bx<256; bx++){

　　int eax=0;

　　eax=eax&0xFFFFFF00+bx&0xFF; // 就是 'mov al,bl' 指令

　　for (int cx=0; cx<8; cx++){

　　if (eax&&0x1) {

　　eax>>=1;

　　eax^=poly;

　　}

　　else eax>>=1;

　　}

　　crctable[bx]=eax;

　　}

　　下面的汇编代码是用来计算CRC-32的:

　　computeLoop:

　　xor ebx, ebx

　　xor al, [si]

　　mov bl, al

　　shr eax, 8

　　xor eax, dword ptr[4*ebx+crctable]

　　inc si

　　loop computeLoop

　　xor eax, 0FFFFFFFFh

　　注释: - ds:si 指向将要被处理的byte string信息流.

　　- cx 信息流的长度.

　　- eax 是当前的CRC.

　　- crctable是用来计算CRC的值表.

　　- 此例中记存器的初始值为: FFFFFFFF.

　　- 要将中间值与FFFFFFFFh做XOR才能得到CRC

　　下面是Java和C写的代码:

　　for (int cx=0; cx>=8;

　　eax^=crcTable[ebx];

　　}

　　eax^=0xFFFFFFFF;

　　现在我们已经完成了本文的第一部分:CRC原理部分,所以如果你希望能够对CRC做更深

　　的研究,那么我建议你去读在本文最后给出连接上的资料,我读了.好了,终于到了本文最

　　有意思的部分,CRC的逆向分析!

第二节 反跟踪技术

　　1、Anti-Debug

　　1．MeltICE子类型

　　类型：检测SoftICE、TRW2000

　　平台：Windows9x、Windows NT

　　原理：用CreateFileA( )或_lopen( )函数试图获得SoftICE的驱动程序".SICE"（Windows9X版本）、".SIWDEBUG"、".NTICE"（Windows NT版本）、".SIWVID"等的句柄，如果成功则说明SoftICE驻留在内存中。

　　2．VWIN32_Int41Dispatch子类型

　　类型：检测SoftICE

　　平台：Windows9x

　　原理：VWIN32.VxD（其VxD ID为0x002A）提供一个名为VWIN32_Int41Dispatch的VxD service（其service ID为0x002A），系统内核使用此服务来与系统级调试器如WinDBG、SoftICE等进行通信。其中0x4F号子功能是用来查询调试器是否已经驻留内存并能否处理保护模式程序，如果是的话则调试器应返回0xF386。

　　3．给SoftICE发送命令

　　类型：检测SoftICE

　　平台：Windows9x、Windows NT

　　原理：通过调试中断int 3给SoftICE发送命令让其执行，其中SI和DI寄存器中放的分别是固定值0x4647("FG")和0x4A4D("JM")。AX中存放的是子功能号，值为0x0911则表示让SoftICE执行命令，此时DX指向一个命令字符串如"HBOOT"等。AX还可以为其它子功能号，比如让 SoftICE修改断点设置等。

　　4、BoundsChecker后门

　　类型：检测SoftICE

　　平台：Windows9x、Windows NT

　　原理：这是SoftICE为BoundsChecker留的一个公开的接口，入口参数EBP = 0x4243484B(即"BCHK")，AL =4，如果SoftICE在内存中则应返回AL = 0。

　　这种方法一般也要结合SEH?（结构异常处理）来实现，否则当SoftICE不存在时就会引起非法操作。

　　5．ICECream子类型

　　类型：检测SoftICE、TRW2000

　　平台：Windows9x

　　原理：调试器驻留后修改INT 1和INT 3的入口，指向它自己的处理程序，所以入口高位偏移与其他中断不同。其他所有中断入口高位偏移都相同。

　　6．INT 68h子类型

　　类型：检测SoftICE

　　平台：Windows9x

　　原理：

　　MOV AH, 43h

　　INT 68h

　　CMP AX, 0F386h ；检测此处是否被调试器设置0F386h

　　JZ SoftICE_is_here

　　7．搜索特征串

　　类型：检测SoftICE

　　平台：Windows9x

　　原理：通过在内存中搜索SoftICE的特征串来发现SoftICE，这一般要结合SEH一起使用，以防止引起内存保护出错而使得程序被终止。这种方法在DOS下是可行的。由于Windows95之后的操作系统中的每个ring 3进程的地址空间是独立的，使得这种方法受到限制。比如在内存中搜索"WINICE.BR"。

　　8．IsDebuggerPresent子类型

　　类型：检测SoftICE

　　平台：Windows NT

　　原理：调用kernel32.dll输出的函数IsDebuggerPresent()来检测是否有调试器存在。这个函数只能检查使用Debug API来跟踪程序的调试器，无法检测SoftICE之类的系统级调试器。

　　2、Anti-静态分析

　　1．死循环语句

　　类型：对付W32Dasm

　　平台：Windows9x 、Windows NT

　　原理：下面是故意在程序中插入的一个死循环，可能会使W32Dasm的某些版本停止响应：

　　0401000 JMP 00401005

　　……

　　00401005 JMP 00401000

　　对策：W32Dasm进入死循环后，用Bpx hmempcy设断，来到死循环代码处，将其跳出死循环，或用IDA来反汇编。

　　2．利用花指令

　　花指令是对付静态分析的重要手段。以下是一段汇编源程序：

　　start_:

　　xor eax,1

　　add eax,2

　　jmp label1

　　label1: xor eax,3

　　add eax,4

　　xor eax,5

　　end start_

　　此时把源程序进行编译，然后用W32Dasm进行反汇编，得到的反汇编结果完全正常。接着我们将上述源程序作如下修改：

　　start_:

　　xor eax,1

　　add eax,2

　　jnz label1 ；注意这里，用两句条件跳转代替了：jmp label1

　　jz label1

　　db 0E8h ；注意这个无用的字节和源程序的区别

　　label1: xor eax,3

　　add eax,4

　　xor eax,5

　　end start_

　　再把源程序进行编译，然后用W32Dasm进行反汇编，来看一下反汇编后的结果：

　　:00401000 83F001

　　:00401003 83C002

　　:00401006 7503

　　xor eax, 00000001

　　add eax, 00000002

　　jne 0040100B

　　3、CRC简介

　　CRC原理及其逆向破解方法：

　　介绍：

　　这篇短文包含CRC原理介绍和其逆向分析方法,很多程序员和破解者不是很清楚了解

　　CRC的工作原理,而且几乎没人知道如何逆向分析它的方法,事实上它是非常有用的.

　　首先,这篇教程教你一般如何计算CRC,你可以将它用在数据代码保护中.第二,主要是

　　介绍如何逆向分析CRC-32,你可以以此来分析程序中的CRC保护（象反病毒编码）.当然

　　有很多有效的工具用来对付CRC,但我怀疑它是否会说明原理.

　　我要告诉你,这篇短文里中应用了很多数学知识,这不会影响一些人,而且会被一般的

　　程序员与逆向分析者很好理解.为什么？那么如果你不知道数学是如何被应用在CRC中,

　　我建议你可以停止继续学习了.所以我假定你们（读者）都是具备二进制算术知识的.

　　第一部分：CRC 介绍,CRC是什么和计算CRC的方法.

　　循环冗余码 CRC

　　我们都知道CRC.甚至你没有印象,但当你想到那些来自诸如RAR,ZIP等压缩软件发给你

　　由于错误连接和其他一些意外原因导致的文件错误的恼人的消息时,你就会知道.CRC是块

　　数据的计算值,比如对每一个文件进行压缩.在一个解压缩过程中,程序会从新计算解压文件

　　的CRC值,并且将之与从文件中读取的CRC值进行比对,如果值相同,那么正确.在CRC-32中,

　　会有1/2^32的可能性发生对确认数据更改的校验错误.

　　很多人认为CRC就是循环冗余校验,假如CRC真的就是循环冗余校验,那么很多人都错用了

　　这个术语.你不能说"这个程序的CRC是12345678".人们也常说某一个程序有CRC校验,而不

　　说是 "循环冗余校验" 校验.结论：CRC 代表循环冗余码,而不是循环冗余校验.

　　计算是如何完成的呢？好,主要的想法就是将一个文件看成一个被一些数字分割的很长的

　　位字串,这里会有一个余数---CRC！你总会有一个余数(可以是0),它至多比除数小一.

　　(9/3=3 余数=0 ;(9+2)/3=3 余数=2)

　　(或者它本身就包含一个除数在其中).

　　在这里CRC计算方法与除法有一点点区别,除法就是将被减数重复的减去除数X次,然后留下

　　余数.如果你希望得到原值,那么你就要把除数乘上X次,然后加上余数.

　　CRC计算使用特殊的减法与加法完成的.也就是一种新的"算法".计算中每一位计算的进位值

　　被"遗忘"了.

　　看如下两个例子,1是普通减法,2和3是特殊的.

　　-+

　　(1) 1101 (2) 1010 1010 (3) 0+0=0 0-0=0

　　1010- 1111+ 1111- 0+1=1 *0-1=1

　　---- ---- ---- 1+0=1 1-0=1

　　0011 0101 0101 *1+1=0 1-1=0

　　在(1)中,右数第二列可以看成是0-1=-1,因此要从高位借1,就变成(10+0)-1=1.(这就象普通

　　的'by-paper'十进制减法).特例(2,3)中,1+1会有正常的结果10,'1'是计算后的进位.这个值

　　被忽略了.特殊情况0-1应该有正常结果'-1'就要退到下一位.这个值也被忽略了.假如你对编程

　　有一定了解,这就象,XOR 操作或者更好.

　　现在来看一个除法的例子:

　　在普通算法中:

　　1001/111100001 13 9/120

　　1001 - 09 -|

　　---- -- |

　　1100 30 |

　　1001 - 27 -

　　---- --

　　0110 3 -> 余数

　　0000 -

　　----

　　1100

　　1001 -

　　----

　　011 -> 3, 余数

　　在CRC算法中:

　　1001/111100010 9/120 余数为 6

　　1001 -

　　----

　　1100

　　1001 -

　　----

　　1010

　　1001 -

　　----

　　0110

　　0000 -

　　----

　　110 -> 余数

　　(例 3)

　　这个除法的商并不重要,也没必要去记住,因为他们仅仅是一组无关紧要的位串.真正

　　重要的是余数!它就是这个值,可以说比原文件还重要的值,他就是基本的CRC.

　　过度到真正的CRC码计算.

　　进行一个CRC计算我们需要选则一个除数,从现在起我们称之为"poly".宽度W就是最高位

　　的位置,所以这个poly 1001的W 是3,而不是4.注意最高位总是1,当你选定一个宽度,那么你只

　　需要选择低W各位的值.

　　假如我们想计算一个位串的CRC码,我们想确定每一个位都被处理过,因此,我们要在目标

　　位串后面加上W个0位.在此例中,我们假设位串为1111.请仔细分析下面一个例子:

　　Poly = 10011, 宽度 W=4

　　位串 Bitstring

　　Bitstring + W zeros = 110101101 + 0000

　　10011/11010110100000000101 (我们不关心此运算的商)

　　10011|||||||| -

　　-----||||||||

　　10011|||||||

　　10011||||||| -

　　-----|||||||

　　00001||||||

　　00000|||||| -

　　-----||||||

　　00010|||||

　　00000||||| -

　　-----|||||

　　00101||||

　　00000|||| -

　　-----||||

　　01010|||

　　00000||| -

　　-----|||

　　10100||

　　10011|| -

　　-----||

　　01110|

　　00000| -

　　-----|

　　11100

　　10011 -

　　-----

　　1111 -> 余数 -> the CRC!

　　(例 4)

　　重要两点声明如下:

　　1.只有当Bitstring的最高位为1,我们才将它与poly做XOR运算,否则我们只是将

　　Bitstring左移一位.

　　2.XOR运算的结果就是被操作位串bitstring与低W位进行XOR运算,因为最高位总为0.

　　算法设计:

　　你们都应知道基于位运算的算法是非常慢的而且效率低下.但如果将计算放在每一字节上

　　进行,那么效率将大大提高.不过我们只能接受poly的宽度是8的倍数(一个字节;).可以形

　　象的看成这样一个宽度为32的poly(W=32):

　　3 2 1 0 byte

　　+---+---+---+---+

　　Pop! <--| | | | |<-- bitstring with W zero bits added, in this case 32

　　+---+---+---+---+

　　1<--- 32 bits ---> this is the poly, 4*8 bits

　　(figure 1)

　　这是一个你用来存放暂时CRC结果的记存器,现在我称它为CRC记存器或者记存器.你从右

　　至左移动位串,当从左边移出的位是1,则整个记存器被与poly的低W位进行XOR运算.(此例

　　中为32).事实上,我们精确的完成了上面除法所做的事情.

　　移动前记存器值为:10110100

　　当从右边移入4位时,左边的高4位将被移出,此例中1011将被移出,而1101被移入.

　　情况如下:

　　当前8位CRC记存器 : 01001101

　　刚刚被移出的高4位 : 1011

　　我们用此poly : 101011100, 宽度 W=8

　　现在我们用如前介绍的方法来计算记存器的新值.

　　顶部 记存器

　　---- --------

　　1011 01001101 高四位和当前记存器值

　　1010 11100 + (*1) Poly 放在顶部最高位进行XOR运算 (因为那里是1)

　　-------------

　　0001 10101101 运算结果

　　现在我们仍有一位1在高4位:

　　0001 10101101 上一步结果

　　1 01011100+ (*2) Poly 放在顶部的最低位进行XOR运算 (因为那里是1)

　　-------------

　　0000 11110001 第二步运算结果

　　^^^^

　　现在顶部所有位均为0,所以我们不需要在与poly进行XOR运算

　　你可以得到相同的结果如果你先将(*1)与(*2)做XOR然后将结果与记存器值做XOR.

　　这就是标准XOR运算的特性:

　　(a XOR b) XOR c = a XOR (b XOR c) 由此,推出如下的运算顺序也是正确的.

　　1010 11100 poly (*1) 放在顶部最高位

　　1 01011100+ polys (*2) 放在顶部最低位

　　-------------

　　1011 10111100 (*3) XOR运算结果

　　The result (*3) 将(*3)与记存器的值做XOR运算

　　1011 10111100

　　1011 01001101+ 如右:

　　-------------

　　0000 11110001

　　你看到了吗?得到一样的结果!现在(*3)变的重要了,因为顶部为1010则(3)的值总是等于

　　10111100(当然是在一定的条件之下)这意味着你可以预先计算出任意顶部位结合的XOR值.

　　注意,顶部结果总是0,这就是组合XOR操作导致的结果.(翻译不准确,保留原文)

　　现在我们回到figure 1,对每一个顶部字节的值都做移出操作,我们可以预先计算出一个值.

　　此例中,它将是一个包含256个double word(32 bit)双字的表.

　　(翻译不准确,保留原文)

　　用伪语言表示我们的算法如下:

　　While (byte string is not exhausted)

　　Begin

　　Top = top_byte of register ;

　　Register = Register shifted 8 bits left ORred with a new byte from string ;

　　Register = Register XORred by value from precomputedTable at position Top ;

　　End

　　direct table算法:

　　上面提到的算法可以被优化.字节串中的字节在被用到之前没有必要经过整个记村器.用

　　这个新的算法,我们可以直接用一个字节去XOR一个字节串通过将此字节移出记存器.结果

　　指向预先计算的表中的一个值,这个值是用来被记存器的值做XOR运算的.

　　我不十分确切的知道为什么这会得到同样的结果(这需要了解XOR运算的特性),但是这又

　　极为便利,因为你无须在你的字节串后填充0字节/位.(如果你知道原理,请告诉我:)

　　让我们来实现这个算法:

　　+----< byte string (or file) 字节串,(或是文件)

　　|

　　v 3 2 1 0 byte 字节

　　| +---+---+---+---+

　　XOR---<| | | | | Register 记存器

　　| +---+---+---+---+

　　| |

　　| XOR

　　| ^

　　v +---+---|---+---+

　　| | | | | | Precomputed table 值表(用来进行操作)

　　| +---+---+---+---+

　　+--->-: : : : :

　　+---+---+---+---+

　　| | | | |

　　+---+---+---+---+

　　(figure 2)

　　'reflected' direct Table 算法:

　　由于这里有这样一个与之相对应的'反射'算法,事情显得复杂了.一个反射的值/记存器

　　就是将它的每一位以此串的中心位为标准对调形成的.例如:0111011001就是1001101110

　　的反射串.

　　他们提出'反射'是因为UART(一种操作IO的芯片)发送每一个字节时是先发最没用的0位,

　　最后再发最有意义的第七位.这与正常的位置是相逆的.

　　除了信息串不做反射以外,在进行下一步操作前,要将其于的数据都做反射处理.所以在

　　计算值表时,位向右移,且poly也是作过反射处理的.当然,在计算CRC时,记存器也要向右

　　移,而且值表也必须是反射过的.

　　byte string (or file) -->---+

　　| 1. 表中每一个入口都是反射的.

　　byte 3 2 1 0 V 2. 初始化记存器也是反射的.

　　+---+---+---+---+ | 3. 但是byte string中的数据不是反射的,

　　| | | | |>---XOR 因为其他的都做过反射处理了.

　　+---+---+---+---+ |

　　| |

　　XOR V

　　^ |

　　+---+---|---+---+ |

　　| | | | | | 值表

　　+---+---+---+---+ |

　　: : : : : <---+

　　+---+---+---+---+

　　| | | | |

　　+---+---+---+---+

　　(figure 3)

　　我们的算法如下:

　　1. 将记存器向右移动一个字节.

　　2. 将刚移出的哪个字节与byte string中的新字节做XOR运算,

　　得出一个指向值表table[0..255]的索引

　　3. 将索引所指的表值与记存器做XOR运算.

　　4. 如数据没有全部处理完,则跳到步骤1.

　　下面是这个算法的简单的可执行汇编源码:

　　完整的CRC-32标准所包含的内容:

　　Name : "CRC-32"

　　Width : 32

　　Poly : 04C11DB7

　　Initial value : FFFFFFFF

　　Reflected : True

　　XOR out with : FFFFFFFF

　　作为对你好奇心的奖励, 这里是CRC-16标准: :)

　　Name : "CRC-16"

　　Width : 16

　　Poly : 8005

　　Initial value : 0000

　　Reflected : True

　　XOR out with : 0000

　　'XOR out with' 是为了最终得到CRC而用来与记存器最后结果做XOR运算的值.

　　假如你想了解一些关于'reversed'逆向CRC poly的话,请看我的参考文章.

　　我是在16位DOS模式下用的32位编码,因此你会在这个程序中看到很多32位与16位混合

　　的编码...当然这是很容易转换成纯32位编码的.注意这个程序是经过完整测试并且能够

　　正常运行的.下面的Java 和 C 代码都是由这个汇编代码而来的.

　　底下的这段程序就是用来计算CRC-32 table的:

　　xor ebx, ebx ;ebx=0, 将被用做一个指针.

　　InitTableLoop:

　　xor eax, eax ;eax=0 为计算新的entry.

　　mov al, bl ;al<-bl

　　生成入口.

　　xor cx, cx

　　entryLoop:

　　test eax, 1

　　jz no_topbit

　　shr eax, 1

　　xor eax, poly

　　jmp entrygoon

　　no_topbit:

　　shr eax, 1

　　entrygoon:

　　inc cx

　　test cx, 8

　　jz entryLoop

　　mov dword ptr[ebx*4 + crctable], eax

　　inc bx

　　test bx, 256

　　jz InitTableLoop

　　注释: - crctable 是一个包含256个dword的数组.

　　- 由于使用反射算法,EAX被向右移.

　　- 因此最低的8位被处理了.

　　用Java和C写的代码如下(int is 32 bit):

　　for (int bx=0; bx<256; bx++){

　　int eax=0;

　　eax=eax&0xFFFFFF00+bx&0xFF; // 就是 'mov al,bl' 指令

　　for (int cx=0; cx<8; cx++){

　　if (eax&&0x1) {

　　eax>>=1;

　　eax^=poly;

　　}

　　else eax>>=1;

　　}

　　crctable[bx]=eax;

　　}

　　下面的汇编代码是用来计算CRC-32的:

　　computeLoop:

　　xor ebx, ebx

　　xor al, [si]

　　mov bl, al

　　shr eax, 8

　　xor eax, dword ptr[4*ebx+crctable]

　　inc si

　　loop computeLoop

　　xor eax, 0FFFFFFFFh

　　注释: - ds:si 指向将要被处理的byte string信息流.

　　- cx 信息流的长度.

　　- eax 是当前的CRC.

　　- crctable是用来计算CRC的值表.

　　- 此例中记存器的初始值为: FFFFFFFF.

　　- 要将中间值与FFFFFFFFh做XOR才能得到CRC

　　下面是Java和C写的代码:

　　for (int cx=0; cx>=8;

　　eax^=crcTable[ebx];

　　}

　　eax^=0xFFFFFFFF;

　　现在我们已经完成了本文的第一部分:CRC原理部分,所以如果你希望能够对CRC做更深

　　的研究,那么我建议你去读在本文最后给出连接上的资料,我读了.好了,终于到了本文最

　　有意思的部分,CRC的逆向分析!