第一节 常见保护技巧
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
应看到如下的类似信息：
| Window-Handle | hQueue | SZ | QOwner | Class-Name | Window-Procedure |
| 0080 (0) | 2057 | 32 | MSGSVR32 | #32711 (switch_win) | 17EF:00004B6E |
| 0084 (1) | 2057 | 32 | EXPLORER | shell_trayWnd | 1487:0000016C |
| ... | ... | ... | ... | ... | ... |
在这些列表中查找相关应用程序的窗口句柄。如果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_DESTROY
0084是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，包含了系统时间信息的一个结构 |
4、SetTimer 创建一定时器，在指定时间内暂停
| UINT SetTimer( HWND hwnd, // 时间信息句柄 UINT idtimer, // 定时器ID 标识符 UINT uTimeout, // 暂停时间 TIMERPROC tmprc // 处理定时过程的程序入口地址 |
4、Key File保护
Key File（注册文件）是一种利用文件来注册软件的保护方式。Key File一般是一个小文件，可以是纯文本文件，也可以是包含不可显示字符的二进制文件，其内容是一些加密过或未加密的数据，其中可能有用户名、注册码等信息。文件格式则由软件作者自己定义。试用版软件没有注册文件，当用户向作者付费注册之后，会收到作者寄来的注册文件，其中可能包含用户的个人信息。用户只要将该文件放入指定的目录，就可以让软件成为正式版。该文件一般是放在软件的安装目录中或系统目录下。软件每次启动时，从该文件中读取数据，然后利用某种算法进行处理，根据处理的结果判断是否为正确的注册文件，如果正确则以注册版模式来运行。
（1）破解Key File一般思路
1. 最好分析Key File的工具是十六进制工具，普通的文本编辑工具不太适合。
2. 对付这类程序，你首先建立一假的Key File文件。一般的软件容许Key File有不同的大小和文件名，你建立的文件内容必须易读，跟据情况调整Key File的大小和文件名。为什么要易读呢？因为目标程序从Key File中读取数据，然后进行处理，易读有利于你分析其运算过程。
3. Key File文件在大多数情况下，是以'*.key'形式存在的。
4. Key File文件名可用W32DASM或十六进制工具打开程序用查找字符串方式确定；
5. 读用户手册（有时作者可能会提到）；
6. 用Filemon 这一工具，它能实时监视系统各文件的状态，因此运行程序时，如它去读指定文件名的Key File时，会在Filemon显示Key File文件名。一但你发现Key File文件名，就建立一假的Key File到要被crack软件目录下,然后去crack。
（2）Windows下破解Key File几个常用的函数：
| 函数ReadFile BOOL ReadFile( |
| 函数CreateFileA HANDLE CreateFileA( LPCTSTR lpFileName, // String，要打开的文件的名字 |
| 函数_lopen( ) HFILE _lopen( LPCSTR lpPathName, // 欲打开文件的名字 |
| 函数FindFirstFileA( ) HANDLE FindFirstFile( LPCTSTR lpFileName, // 欲搜索的文件名。可包含通配符，并可包含一个路径或相对路径名 |
5、功能限制的程序
这种程序一般是DEMO版或菜单中部分选项是灰色。有些DEMO版本的部分功能里面根本就没有。而有些程序功能全有，只要注册后就正常了。
你使用这些DEMO程序部分被禁止的功能时，会跳出提示框，说这是DEMO版等话，它们一般都是调用MessageBox[A]或DialogBox[A]等函数。你可在W32DASM反汇编它，一般能找到如下字符串："Function Not Avaible in Demo" 或 "Command Not Avaible" 或 "Can't save in Shareware/Demo"等，这些CALL会被相应的调用，可作为你破解的一指示器。
另外，就是菜单中部分选项是灰色的不能用，一般它们是通过如下两种函数实现的：
（1）EnableMenuItem
| 允许、禁止或变灰指定的菜单条目 |
| BOOL EnableMenuItem( HMENU hMenu, // 菜单句柄 UINT uIDEnableItem, // 菜单ID，形式为：充许,禁止,或灰 UINT uEnable //菜单项目旗帜 ); Returns |
| 在ASM代码形式如下: PUSH uEnable //uEnable=0 则菜单选项允许 PUSH uIDEnableItem PUSHhWnd CALL [KERNEL32!EnableMenuItem] |
（2）EnableWindow
| 允许或禁止鼠标和键盘控制指定窗口和条目（禁止时菜单变灰） |
| BOOL EnableWindow( HWND hWnd, // 窗口句柄 BOOL bEnable // 允许/禁止输入 ); Returns 如窗口以前被禁止则返回一TRUE，否则返回 FALSE。 |
6、CD-check
最简单也最常见的光盘保护就是程序在启动时判断光驱中的光盘上是否存在特定的文件，如果不存在则认为用户没有正版光盘，拒绝运行。在程序运行的过程当中一般不再检查光盘的存在与否。Windows下的具体实现一般是这样的：先用GetLogicalDriveStrings( )或GetLogicalDrives( )得到系统中安装的所有驱动器的列表，然后再用GetDriveType( )检查每一个驱动器，如果是光驱则用CreateFileA( )或FindFirstFileA( )等函数检查特定的文件存在与否，并可能进一步地检查文件的属性、大小、内容等。 这种光盘检查是比较容易被破解的，解密者只要利用上述函数设断点找到程序启动时检查光驱的地方，修改判断指令就可以跳过光盘检查。
（1）可将游戏（或其它程序）的光盘拿出，运行游戏，将出现一些错误提示，如： Please insert the - CD, or: You need the CD to play the - . 利用这提示可在W32DASM中利用串式数据参考功能查找相应的代码进行分析。
（2）相关函数
1、GetDrivetype(a) 判断一个磁盘驱动器的类型
| UINT GetDriveType( LPCTSTR lpRootPathName // String，包含了驱动器根目录路径的一个字串 | |
| 返回值 | |
|
0
| 驱动器不能识别 |
|
1
| 指定的目录不存在 |
|
2
| DriveRemoveable |
|
3
| A Fixed Disk (HardDrive) |
|
4
| Remote Drive(Network) |
|
5
| Cd-Rom驱动器 |
|
6
| RamDisk |
如果是普通的程序，你可将EAX由5改成3即可。
注意：有些程序可能检测光盘根目录相关文件，CD的卷标也可能被检测。
2、GetLogicalDrives 判断系统中存在哪些逻辑驱动器字母
| 这函数没有参数 |
| 返回值 |
| 这个结构中的二进制位标志着存在哪些驱动器。其中，位0设为1表示驱动器A:存在于系统中；位1设为1表示存在B:驱动器；以次类推 |
3、GetLogicalDriveStrings 获取一个字串，其中包含了当前所有逻辑驱动器的根驱动器路径
| DWORD GetLogicalDriveStrings( DWORD nBufferLength, // 字串的长度 |
| 返回值 |
| 装载到lpBuffer的字符数量（排除空中止字符）。如缓冲区的长度不够，不能容下路径，则返回值就变成要求的缓冲区大小。零表示失败。会设置GetLastError |
4、GetFileAttributesA 判断指定文件的属性
| DWORD GetFileAttributes( LPCTSTR lpFileName //指定欲获取属性的一个文件的名字 |
5、GetFileSize 判断文件长度
| DWORD GetFileSize( HANDLE hFile, // 文件的句柄 |
| 返回值 |
| 返回文件长度。&HFFFFFFFF表示出错。注意如lpFileSizeHigh不为NULL，且结果为&HFFFFFFFF，那么必须调用GetLastError，判断是否实际发生了一个错误，因为这是一个有效的结果 |
6、GetLastError 针对之前调用的api函数，用这个函数取得扩展错误信息
| 返回值 | |
| 由api函数决定。请参考api32.txt文件，其中列出了一系列错误常数；都以ERROR_前缀起头。常用的错误代码见下表 | |
| ERROR_INVALID_HANDLE | 无效的句柄作为一个参数传递 |
| ERROR_CALL_NOT_IMPLEMENTED | 在win 95下调用专为win nt设计的win32 api函数 |
| ERROR_INVALID_PARAMETER | 函数中有个参数不正确 |
7、ReadFile 从文件中读出数据
具体参考KEYFILE一节。
8、其它一些CDROM信息
中断2F是mscdex中断，可用bpint 2f, al=0 ah=15检测Mmscdex是否安装。
也可试着用文件存取设断
第二节 反跟踪技术
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．利用花指令
花指令是对付静态分析的重要手段。以下是一段汇编源程序：
|
此时把源程序进行编译，然后用W32Dasm进行反汇编，得到的反汇编结果完全正常。接着我们将上述源程序作如下修改：
|
再把源程序进行编译，然后用W32Dasm进行反汇编，来看一下反汇编后的结果：
| :00401000 83F001 :00401003 83C002 :00401006 7503 :00401008 7401 :0040100A E883F00383 :0040100F C00483F0 | xor eax, 00000001 add eax, 00000002 jne 0040100B je 0040100B call 83440092 rol byte ptr [ebx+4*eax], F0 |
结果令人很吃惊，会发现W32Dasm反汇编的结果和事先写的汇编指令不一样，从反汇编的结果中已经无法理解程序的"真实"的功能了，W32Dasm给出了一个意想不到的答案。 这是因为上述改动是为了在W32Dasm的反汇编工作中做点手脚，从而使得它犯下错误。那么W32Dasm为什么会因此而犯下这样的错误呢？
不同的机器指令包含的字节数并不相同，有的是单字节指令，有的是多字节指令。对于多字节指令来说，反汇编软件需要确定指令的第一个字节的起始位置，也就是操作码的位置，这样才能正确地反汇编这条指令，否则它就可能反汇编成另外一条指令了。 如果在程序中加入一些无用的字节来干扰反汇编软件的判断，从而使得它错误地确定指令的起始位置，那么也就达到了干扰W32Dasm反汇编工作的目的。
通过前面的介绍，知道由于"无用的字节"干扰了W32Dasm对指令起始位置的判断，从而导致反汇编的错误结果，所以如果能让W32Dasm正确地识别出指令起始位置，也就达到了去除花指令的目的了。比如可以把那些无用的字节都替换成单字节指令，最常见的一种替换方法是把无用的字节替换成 NOP 指令，即十六进制数 90。
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/1111000/1101 13 9/120/13
1001 - 09 -|
---- -- |
1100 30 |
1001 - 27 -
---- --
0110 3 -> 余数
0000 -
----
1100
1001 -
----
011 -> 3, 余数
在CRC算法中:
1001/1111000/1110 9/120/14 余数为 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/1101011010000/110000101 (我们不关心此运算的商)
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的逆向分析!
第二部分 CRC的逆向分析:
我遇到了很多障碍,当我思考如何破解CRC时.我试图使用一些特殊顺序的字节使CRC无效.
但我没有做到...后来我意识到这种方法是行不同的,因为CRC内建了一些处理过程,无论你
改变任何位它都不会出问题,真正的CRC就是在不断变化的,总是在变化的.找一些CRC程序,
你可以自己尝试一下.
现在我知道我只能'纠正'在CRC后面的那些我想改变的字节.所以我要构造一个字节序列,
它可以将CRC转化成任何我想要的样子!
具体实现这个想法
一个字节串? 01234567890123456789012345678901234567890123456789012
You want to change from ^ this byte to ^ this one.
就是位置9->26.
同时我们需要额外的4个字节用来在最后恢复原始字节串.
当你计算CRC-32时,从0-8都没有问题,直到第9位,修补过的字节串会使CRC发生根本的改变.
即使当走过了第26位,以后的字节都没有改变,你也不可能在得到原始的CRC了,不可能了!你读
过后面的段落时就会明白为什么.间而言之,当你修改一个字节串时,要保证CRC不变.
1. 计算并保存从1~9位的CRC.
2. 继续计算直到第27位还有额外的4字节并保存结果.
3. 用1的值来计算新的字节串和额外4字节的CRC(对应patch后的新的CRC值),并将之保存.
4. 现在我们得到了一个新的CRC,但是我们希望将它还原成原先的CRC,所以我们用逆向算法
来计算那额外的4字节.
1~3就是实际的情况,下面你将学到最关键的部分4.
'反转'CRC-16
我想,先来介绍计算逆CRC-16对于你来说会简单些.好的,我们现在处在一个恰当的位置,
在以修改代码后面,就是你想将CRC还原的地方.我们知道原始的CRC(是在patch代码之前计
算出来的)还有这个当前的记存器值.现在我们的目的就是计算可以改变当前记存器值到原
始记存器值的两个字节.首先,我们用正常的方法计算这两个未知字节的CRC.我们设他们为
X,Y.设记存器为a1,a0,只有0不能用来作为变量(00).:)在来看一下我们的CRC算法,figure
3,更好的理解下面我要做的.
好,我们开始:
用这两字节串'X Y' 字节是从左边开始被处理的.
记存器现在是a1 a0.
用'+'来表示XOR运算(和第一部分中用的一样)
处理第一个字节, X:
a0+X 这是顶部字节的计算结果 (1)
b1 b0 这是(1)在表中索引对象.
00 a1 向右移动记存器.
00+b1 a1+b0 上面两行对应位做XOR运算.
现在记存器为: (b1) (a1+b0)
处理第二个字, Y:
(a1+b0)+Y 此轮顶部字节的计算结果(2)
c1 c0 这是(2)在表中的索引对象.
00 b1 向右移动记存器.
00+c1 b1+c0 上面两行对应位做XOR运算.
最后记存器就是: (c1) (b1+c0)
我用一点不同的方法来表示:
a0 + X =(1) 在表中指向b1 b0.
a1 + b0 + Y =(2) 在表中指向c1 c0.
b1 + c0=d0 记存器中新的低位字节.
c1=d1 记存器中新的高位字节.
(1) (2)
Wow! 请大家暂时记住上面的信息:)
别着急, 下面给出一个有具体值的例子.
如果你想要的记存器的值是d1 d0(是原始的CRC),而且你知道在变换之前的记存器的值
(a1 a0)...那么你将要送如什么样的2个字节进记存器来做CRC计算呢?
好了,现在我们的工作应该从幕后走到台前来了.d0一定是bi+c0,并且d1一定是c1...
但是这到底是怎么回事,我听到你这样问了,你能知道b1和c0的值吗???你还记得哪个值表
吗?你只需要在表中查找c0 c1这个字的值就可以了因为你知道c1.所以你需要编写一个查
找程序.假如你找到了这个值,一定要记住这个值的索引,因为这就是找出未知的两个顶部
字节,举例来说:(1)和(2)!
所以,现在你找到了c1 c0,那么如何来得到b1 b0呢?如果b1+c0=d0那么b1=d0+c0!如前所
述,现在你用哪个查找程序在表中查b1 b0的值.现在我们得到了所有计算X和Y所需要的值.
Cool huh?
a1+b0+Y=(2) so Y=a1+b0+(2)
a0+X=(1) so X=a0+(1)
实例.
让我们来看看这个具体值的例子:
-register before: (a1=)DE (a0=)AD
-wanted register: (d1=)12 (d0=)34
在附录的CRC-16的表中查找以12开头值的入口.这里入口38h的值为12C0.试这找一找是否还
有以12开头的值的入口.你不可能在找到的,因为我们计算每一中顶部字节组合而得的值的
入口,一共是256个值,记住!
现在我们知道(2)=38,c1=12,c0=C0,所以b1=C0+34=F4,现在查找以F4开头的b1的入口.这里
入口4Fh的值是F441.
我们还知道 (1)=4F,b1=F4,b0=41,现在所有我们需要的都已经清楚了,接下来我们计算X,Y.
Y=a1+b0+(2)=DE+41+38=A7
X=a0+(1) =AD+4F =E2
结论:将CRC 记存器的值从 DEAD 变为 1234 我们需要这两个字节 E2 A7 (以此顺序).
你看,破解CRC校验你需要反向计算,还有要记住的就是计算过程中的值.当你在用汇编编写
查找表程序时,要注意intel在小模式中是反向存储值的.现在你可能已经明白如何去破解这个
CRC-16了...下面介绍如何在CRC-32中实现.
破解 CRC-32
现在我们来看CRC-32,和CRC-16是一样容易的(可能一样的不容易你认为).这里你操作的对象
是4个字节的而不是2字节的.继续向下看,将它与上面CRC-16版本做对比.
设4字节串 X Y Z W , 从左边开始处理.
设记存器为 a3 a2 a1 a0
注意a3是MSB,而a0是LSB
处理第一个字节, X:
a0+X 这是顶部字节的计算结果(1).
b3 b2 b1 b0 这是(1)在表中索引对象序列.
00 a3 a2 a1 右移记存器.
00+b3 a3+b2 a2+b1 a1+b0 上面两行对应位做XOR运算.
现在记存器是: (b3) (a3+b2) (a2+b1) (a1+b0)
Processing second byte, Y:
(a1+b0)+Y 这是顶部字节的计算结果(2).
c3 c2 c1 c0 这是(2)在表中索引对象序列.
00 b3 a3+b2 a2+b1 右移记存器.
00+c3 b3+c2 a3+b2+c1 a2+b1+c0 上面两行对应位做XOR运算.
现在记存器是: (c3) (b3+c2) (a3+b2+c1) (a2+b1+c0)
Processing third byte, Z:
(a2+b1+c0)+Z 这是顶部字节的计算结果(3).
d3 d2 d1 d0 这是(3)在表中索引对象序列.
00 c3 b3+c2 a3+b2+c1 右移记存器.
00+d3 c3+d2 b3+c2+d1 a3+b2+c1+d0 上面两行对应位做XOR运算.
现在记存器是: (d3) (c3+d2) (b3+c2+d1) (a3+b2+c1+d0)
Processing fourth byte, W:
(a3+b2+c1+d0)+W 这是顶部字节的计算结果(4).
e3 e2 e1 e0 这是(4)在表中索引对象序列.
00 d3 c3+d2 b3+c2+d1 右移记存器.
00+e3 d3+e2 c3+d2+e1 b3+c2+d1+e0 上面两行对应位做XOR运算.
最后,记存器为: (e3) (d3+e2) (c3+d2+e1) (b3+c2+d1+e0)
我用一个不同一点的方法来表示:
a0 + X =(1) 在表中指向 b3 b2 b1 b0
a1 + b0 + Y =(2) 在表中指向 c3 c2 c1 c0
a2 + b1 + c0 + Z =(3) 在表中指向 d3 d2 d1 d0
a3 + b2 + c1 + d0 + W =(4) 在表中指向 e4 e3 e2 e1
b3 + c2 + d1 + e0 =f0
c3 + d2 + e1 =f1
d3 + e2 =f2
e3 =f3
(1) (2) (3) (4)
(figure 4)
这里是用的与CRC-16同样的方法来实现的,我会给出一个具体值的例子.查找用附录中
CRC-32的值表.
Take for CRC register before, a3 a2 a1 a0 -> AB CD EF 66
Take for CRC register after, f3 f2 f1 f0 -> 56 33 14 78 (wanted value)
我们开始:
First byte of entries entry value
e3=f3 =56 -> 35h=(4) 56B3C423 for e3 e2 e1 e0
d3=f2+e2 =33+B3 =E6 -> 4Fh=(3) E6635C01 for d3 d2 d1 d0
c3=f1+e1+d2 =14+C4+63 =B3 -> F8h=(2) B3667A2E for c3 c2 c1 c0
b3=f0+e0+d1+c2=78+23+5C+66=61 -> DEh=(1) 616BFFD3 for b3 b2 b1 b0
Now we have all needed values, then
X=(1)+ a0= DE+66=B8
Y=(2)+ b0+a1= F8+D3+EF=C4
Z=(3)+ c0+b1+a2= 4F+2E+FF+CD=53
W=(4)+d0+c1+b2+a3=35+01+7A+6B+AB=8E
(final computation)
结论:要将 CRC-32 的记存器的值从 ABCDEF66 改变到 56331478 我们需要这样一个字节
序列: B8 C4 53 8E
CRC-32的破解算法
假如你考虑手动计算这个可以还原CRC记存器的字节序列,那么这将很难变成一个
简洁的算法.
看看下面这个最后计算的附加版本:
Position
X =(1) + a0 0
Y =(2) + b0 + a1 1
Z =(3) + c0 + b1 + a2 2
W =(4) + d0 + c1 + b2 + a3 3
f0= e0 + d1 + c2 + b3 4
f1= e1 + d2 + c3 5
f2= e2 + d3 6
f3= e3 7
(figure 5)
它就等同于figure 4,只不过是一些值/字节被交换了.这种方法可以帮助我们构造一个
简洁的算法.这里我们用一个8字节的缓冲区,0-3位我们放置a0到a3,4-7位我们放置f0到
f3.象以前一样,我们用这个已知值e3(由figure 5中得知)在表中查出(e3 e2 e1 e0),并且
象图5(figure 5)中所示,将它们放到第4位(position 4),我们马上得到了d3的值.因为f2=
e2+d3,所以f2+e2=d3.又因为(4)已知(入口值),我们照样把它也放到位置3.然后在用d3查表
得到(d3 d2 d1 d0),同上也将他们放到图中所述位置.同样,由于有f1+e1+d2=c3在位置5上.
我们继续做直到将b3 b2 b1 b0放到位置1,对了，就是它! Et voila!
此时,缓冲区的第3-第0字节中已经包含全部元素,用来计算X~W!
算法总结如下:
1.对于这个8字节的缓冲区,0~3字节放入a0...a3(CRC记存器起始值),4~7字节放入f0...f3
(目标记存器的值).
2.取出位置7的已知值,查表得到相应值.
3.将查出值放如图5相应位置,其实就是做XOR运算.(为了直观,可以拟定此图)
4.将入口字节放入图中.也是做XOR运算.
5.继续做2,3两步3次,同时每次降低1个位置 position 5 to 4, 4 to 3 and so on.
算法的实现:
现在是时候给出代码了.下面就是用汇编写成的可执行的CRC-32算法(用其他语言也一样
简单,对于其他的CRC-32标准也一样).注意在汇编中(计算机里)双字在读写操作中顺序都是
反着的.就是逆向顺序.
crcBefore dd (?)
wantedCrc dd (?)
buffer db 8 dup (?)
mov eax, dword ptr[crcBefore] ;/*
mov dword ptr[buffer], eax
mov eax, dword ptr[wantedCrc] ; Step 1
mov dword ptr[buffer+4], eax ;*/
mov di, 4
computeReverseLoop:
mov al, byte ptr[buffer+di+3] ;/*
call GetTableEntry ; Step 2 */
xor dword ptr[buffer+di], eax ; Step 3
xor byte ptr[buffer+di-1], bl ; Step 4
dec di ;/*
jnz computeReverseLoop ; Step 5 */
Notes:
-Registers eax, di bx are used
Implementation of GetTableEntry
crctable dd 256 dup (?) ;should be defined globally somewhere & initialized of course
mov bx, offset crctable-1
getTableEntryLoop:
add bx, 4 ;points to (crctable-1)+k*4 (k:1..256)
cmp [bx], al ;must always find the value somewhere
jne getTableEntryLoop
sub bx, 3
mov eax, [bx]
sub bx, offset crctable
shr bx, 2
ret
On return eax contains a table entry, bx contains the entry number.
Outtro
.
SEH技术
结构化异常处理
当某一线程发生异常时，程序的控制权会立即进入Ring0异常处理程序，这是属于操作系统的部分，
如果发生的异常是如页异常之类的异常，Ring0处理程序可以处理完它后重新回到程序中执行，而被中断
过的进程可能根本就不知道发生过异常。
但事情并不总是如此，有时进程会发生一些始料不及的异常，例如访问不存在的内存，被0除等，
这些异常Ring0处理程序不知该如何处理它，而进程本身也可能想自己处理这些情况，这是就要用到结构化异常处理（SEH）。在C/C++中也有异常处理的语句如_try,_catch等，这些语句的实现也与SEH紧密联
系。
当系统遇到一个它不知道如何处理的异常时，它就查找异常处理链表，注意每个线程都有它自己的异
常处理链表。异常链表以FS:[0]所指向的位置为链表头。
异常处理开始时，系统把一些与当前线程和与异常有关的内容传给链头所指向的处理程序；处理程序
由用户编写或编译器生成，它的返回值可以是告诉系统：异常处理以完成，可以继续执行程序，或未处理
异常，可由链表的下一个处理程序处理等，可以一次传递下去。
下面给出一个例子：
-------------------------------------------------------------------------------------------
.386
.model flat,stdcall
option casemap:none
include kernel32.inc
include user32.inc
include windows.inc
includelib kernel32.lib
includelib user32.lib
.data
szCaption db "SEH",0
szTextSEH db "SEH 程序正在运行",0
szText db "SEH 程序没有运行",0
.code
start:
lea eax,[esp-4*2]
xchg fs:[0],eax ;这一行编译错误，哪位大虾指点一下正确格式
mov ebx,offset SEH
push ebx
push eax
mov esi,0
mov eax,[esi]
invoke MessageBox,0,offset szText,offset szCaption,MB_OK
jmp Exit
SEH:
invoke MessageBox,0,offset szTextSEH,offset szCaption,MB_OK
Exit:
invoke ExitProcess,0
end start
end
第三节 加密算法
1、RSA算法
它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, Adi Shamir 和Leonard Adleman。但RSA的安全性一直未能得到理论上的证明。它经历了各种攻击，至今未被完全攻破。
一、RSA算法:
首先, 找出三个数, p, q, r,
其中 p, q 是两个相异的质数, r 是与 (p-1)(q-1) 互质的数......
p, q, r 这三个数便是 private key
接著, 找出 m, 使得 rm == 1 mod (p-1)(q-1).....
这个 m 一定存在, 因为 r 与 (p-1)(q-1) 互质, 用辗转相除法就可以得到了.....
再来, 计算 n = pq.......
m, n 这两个数便是 public key
编码过程是, 若资料为 a, 将其看成是一个大整数, 假设 a < n....
如果 a >= n 的话, 就将 a 表成 s 进位 (s <= n, 通常取 s = 2^t),
则每一位数均小於 n, 然後分段编码......
接下来, 计算 b == a^m mod n, (0 <= b < n),
b 就是编码後的资料......
解码的过程是, 计算 c == b^r mod pq (0 <= c < pq),
於是乎, 解码完毕...... 等会会证明 c 和 a 其实是相等的 :)
如果第三者进行窃听时, 他会得到几个数: m, n(=pq), b......
他如果要解码的话, 必须想办法得到 r......
所以, 他必须先对 n 作质因数分解.........
要防止他分解, 最有效的方法是找两个非常的大质数 p, q,
使第三者作因数分解时发生困难.........
<定理>
若 p, q 是相异质数, rm == 1 mod (p-1)(q-1),
a 是任意一个正整数, b == a^m mod pq, c == b^r mod pq,
则 c == a mod pq
证明的过程, 会用到费马小定理, 叙述如下:
m 是任一质数, n 是任一整数, 则 n^m == n mod m
(换另一句话说, 如果 n 和 m 互质, 则 n^(m-1) == 1 mod m)
运用一些基本的群论的知识, 就可以很容易地证出费马小定理的........
<证明>
因为 rm == 1 mod (p-1)(q-1), 所以 rm = k(p-1)(q-1) + 1, 其中 k 是整数
因为在 modulo 中是 preserve 乘法的
(x == y mod z and u == v mod z => xu == yv mod z),
所以, c == b^r == (a^m)^r == a^(rm) == a^(k(p-1)(q-1)+1) mod pq
1. 如果 a 不是 p 的倍数, 也不是 q 的倍数时,
则 a^(p-1) == 1 mod p (费马小定理) => a^(k(p-1)(q-1)) == 1 mod p
a^(q-1) == 1 mod q (费马小定理) => a^(k(p-1)(q-1)) == 1 mod q
所以 p, q 均能整除 a^(k(p-1)(q-1)) - 1 => pq | a^(k(p-1)(q-1)) - 1
即 a^(k(p-1)(q-1)) == 1 mod pq
=> c == a^(k(p-1)(q-1)+1) == a mod pq
2. 如果 a 是 p 的倍数, 但不是 q 的倍数时,
则 a^(q-1) == 1 mod q (费马小定理)
=> a^(k(p-1)(q-1)) == 1 mod q
=> c == a^(k(p-1)(q-1)+1) == a mod q
=> q | c - a
因 p | a
=> c == a^(k(p-1)(q-1)+1) == 0 mod p
=> p | c - a
所以, pq | c - a => c == a mod pq
3. 如果 a 是 q 的倍数, 但不是 p 的倍数时, 证明同上
4. 如果 a 同时是 p 和 q 的倍数时,
则 pq | a
=> c == a^(k(p-1)(q-1)+1) == 0 mod pq
=> pq | c - a
=> c == a mod pq
Q.E.D.
这个定理说明 a 经过编码为 b 再经过解码为 c 时, a == c mod n (n = pq)....
但我们在做编码解码时, 限制 0 <= a < n, 0 <= c < n,
所以这就是说 a 等於 c, 所以这个过程确实能做到编码解码的功能.....
二、RSA 的安全性
RSA的安全性依赖于大数分解，但是否等同于大数分解一直未能得到理论上的证明，因为没有证明破解 RSA就一定需要作大数分解。假设存在一种无须分解大数的算法，那它肯定可以修改成为大数分解算法。目前， RSA 的一些变种算法已被证明等价于大数分解。不管怎样，分解n是最显然的攻击方法。现在，人们已能分解多个十进制位的大素数。因此，模数n 必须选大一些，因具体适用情况而定。
三、RSA的速度
由于进行的都是大数计算，使得RSA最快的情况也比DES慢上倍，无论是软件还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。
四、RSA的选择密文攻击
RSA在选择密文攻击面前很脆弱。一般攻击者是将某一信息作一下伪装( Blind)，让拥有私钥的实体签署。然后，经过计算就可得到它所想要的信息。实际上，攻击利用的都是同一个弱点，即存在这样一个事实：乘幂保留了输入的乘法结构：
( XM )^d = X^d *M^d mod n
前面已经提到，这个固有的问题来自于公钥密码系统的最有用的特征--每个人都能使用公钥。但从算法上无法解决这一问题，主要措施有两条：一条是采用好的公钥协议，保证工作过程中实体不对其他实体任意产生的信息解密，不对自己一无所知的信息签名；另一条是决不对陌生人送来的随机文档签名，签名时首先使用One-Way HashFunction 对文档作HASH处理，或同时使用不同的签名算法。在中提到了几种不同类型的攻击方法。
五、RSA的公共模数攻击
若系统中共有一个模数，只是不同的人拥有不同的e和d，系统将是危险的。最普遍的情况是同一信息用不同的公钥加密，这些公钥共模而且互质，那末该信息无需私钥就可得到恢复。设P为信息明文，两个加密密钥为e1和e2，公共模数是n，则：
C1 = P^e1 mod n
C2 = P^e2 mod n
密码分析者知道n、e1、e2、C1和C2，就能得到P。
因为e1和e2互质，故用Euclidean算法能找到r和s，满足：
r * e1 + s * e2 = 1
假设r为负数，需再用Euclidean算法计算C1^(-1)，则
( C1^(-1) )^(-r) * C2^s = P mod n
另外，还有其它几种利用公共模数攻击的方法。总之，如果知道给定模数的一对e和d，一是有利于攻击者分解模数，一是有利于攻击者计算出其它成对的e’和d’，而无需分解模数。解决办法只有一个，那就是不要共享模数n。
RSA的小指数攻击。 有一种提高 RSA速度的建议是使公钥e取较小的值，这样会使加密变得易于实现，速度有
所提高。但这样作是不安全的，对付办法就是e和d都取较大的值。
RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何，而且密码学界多数人士倾向于因子分解不是NPC问题。 RSA的缺点主要有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。B)分组长度太大，为保证安全性，n 至少也要 600 bits 以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。目前，SET( Secure Electronic Transaction )协议中要求CA采用比特长的密钥，其他实体使用比特的密钥。
2、DES算法
一、DES算法
美国国家标准局1973年开始研究除国防部外的其它部门的计算机系统的数据加密标准，于1973年5月15日和1974年8月27日先后两次向公众发出了征求加密算法的公告。加密算法要达到的目的（通常称为DES 密码算法要求）主要为以下四点：
| ☆提供高质量的数据保护，防止数据未经授权的泄露和未被察觉的修改； | |
| ☆具有相当高的复杂性，使得破译的开销超过可能获得的利益，同时又要便于理解和掌握； | |
| ☆DES密码体制的安全性应该不依赖于算法的保密，其安全性仅以加密密钥的保密为基础； | |
| ☆实现经济，运行有效，并且适用于多种完全不同的应用。 |
1977年1月，美国政府颁布：采纳IBM公司设计的方案作为非机密数据的正式数据加密标准（DES棗Data Encryption Standard）。
目前在国内，随着三金工程尤其是金卡工程的启动，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收费站等领域被广泛应用，以此来实现关键数据的保密，如信用卡持卡人的PIN的加密传输，IC卡与POS间的双向认证、金融交易数据包的MAC校验等，均用到DES算法。
DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密。
DES算法是这样工作的：如Mode为加密，则用Key 去把数据Data进行加密， 生成Data的密码形式（64位）作为DES的输出结果；如Mode为解密，则用Key去把密码形式的数据Data解密，还原为Data的明码形式（64位）作为DES的输出结果。在通信网络的两端，双方约定一致的Key，在通信的源点用Key对核心数据进行DES加密，然后以密码形式在公共通信网（如电话网）中传输到通信网络的终点，数据到达目的地后，用同样的Key对密码数据进行解密，便再现了明码形式的核心数据。这样，便保证了核心数据（如PIN、MAC等）在公共通信网中传输的安全性和可靠性。
通过定期在通信网络的源端和目的端同时改用新的Key，便能更进一步提高数据的保密性，这正是现在金融交易网络的流行做法。
DES算法详述
DES算法把64位的明文输入块变为64位的密文输出块，它所使用的密钥也是64位，整个算法的主流程图如下：
其功能是把输入的64位数据块按位重新组合，并把输出分为L0、R0两部分，每部分各长32位，其置换规则见下表：
58,50,12,34,26,18,10,2,60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,
57,49,41,33,25,17, 9,1,59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7,
即将输入的第58位换到第一位，第50位换到第2位，...，依此类推，最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0 是右32位，例：设置换前的输入值为D1D2D3......D64，则经过初始置换后的结果为：L0=D58D50...D8；R0=D57D49...D7。
经过16次迭代运算后。得到L16、R16，将此作为输入，进行逆置换，即得到密文输出。逆置换正好是初始置的逆运算，例如，第1位经过初始置换后，处于第40位，而通过逆置换，又将第40位换回到第1位，其逆置换规则如下表所示：
40,8,48,16,56,24,64,32,39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58 26,33,1,41, 9,49,17,57,25,
放大换位表
32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10,11,
12,13,12,13,14,15,16,17,16,17,18,19,20,21,20,21,
22,23,24,25,24,25,26,27,28,29,28,29,30,31,32, 1,
单纯换位表
16,7,20,21,29,12,28,17, 1,15,23,26, 5,18,31,10,
2,8,24,14,32,27, 3, 9,19,13,30, 6,22,11, 4,25,
在f(Ri,Ki)算法描述图中，S1,S2...S8为选择函数，其功能是把6bit数据变为4bit数据。下面给出选择函数Si(i=1,2......8)的功能表：
选择函数Si
S1:
14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,
0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,
4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,
15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13,
S2:
15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9,
S3:
10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12,
S4:
7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14,
S5:
2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,
4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3,
S6:
12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13,
S7:
4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,
13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12,
S8:
13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11,
在此以S1为例说明其功能，我们可以看到：在S1中，共有4行数据，命名为0，1、2、3行；每行有16列，命名为0、1、2、3，......，14、15列。
现设输入为： D＝D1D2D3D4D5D6
令：列＝D2D3D4D5
行＝D1D6
然后在S1表中查得对应的数，以4位二进制表示，此即为选择函数S1的输出。下面给出子密钥Ki(48bit)的生成算法
从子密钥Ki的生成算法描述图中我们可以看到：初始Key值为64位，但DES算法规定，其中第8、16、......64位是奇偶校验位，不参与DES运算。故Key 实际可用位数便只有56位。即：经过缩小选择换位表1的变换后，Key 的位数由64 位变成了56位，此56位分为C0、D0两部分，各28位，然后分别进行第1次循环左移，得到C1、D1，将C1（28位）、D1（28位）合并得到56位，再经过缩小选择换位2，从而便得到了密钥K0（48位）。依此类推，便可得到K1、K2、......、K15，不过需要注意的是，16次循环左移对应的左移位数要依据下述规则进行：
循环左移位数
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1
以上介绍了DES算法的加密过程。DES算法的解密过程是一样的，区别仅仅在于第一次迭代时用子密钥K15，第二次K14、......，最后一次用K0，算法本身并没有任何变化。
二、DES算法理论图解
DES的算法是对称的，既可用于加密又可用于解密。下图是它的算法粗框图。其具体运算过程有如下七步。
三、DES算法的应用误区
DES算法具有极高安全性，到目前为止，除了用穷举搜索法对DES算法进行攻击外，还没有发现更有效的办法。而56位长的密钥的穷举空间为256，这意味着如果一台计算机的速度是每一秒种检测一百万个密钥，则它搜索完全部密钥就需要将近2285年的时间，可见，这是难以实现的，当然，随着科学技术的发展，当出现超高速计算机后，我们可考虑把DES密钥的长度再增长一些，以此来达到更高的保密程度。
由上述DES算法介绍我们可以看到：DES算法中只用到64位密钥中的其中56位，而第8、16、24、......64位8个位并未参与DES运算，这一点，向我们提出了一个应用上的要求，即DES的安全性是基于除了8，16，24，......64位外的其余56位的组合变化256才得以保证的。因此，在实际应用中，我们应避开使用第8，16，24，......64位作为有效数据位，而使用其它的56位作为有效数据位，才能保证DES算法安全可靠地发挥作用。如果不了解这一点，把密钥Key的8，16，24，..... .64位作为有效数据使用，将不能保证DES加密数据的安全性，对运用DES来达到保密作用的系统产生数据被破译的危险，这正是DES算法在应用上的误区，留下了被人攻击、被人破译的极大隐患。
3、ElGamal算法
ElGamal算法既能用于数据加密也能用于数字签名，其安全性依赖于计算有限域上离散对数这一难题。
密钥对产生办法。首先选择一个素数p，两个随机数, g 和x，g, x < p, 计算 y = g^x ( mod p )，则其公钥为 y, g 和p。私钥是x。g和p可由一组用户共享。
ElGamal用于数字签名。被签信息为M，首先选择一个随机数k, k与 p - 1互质，计算
a = g^k ( mod p )
再用扩展 Euclidean 算法对下面方程求解b：
M = xa + kb ( mod p - 1 )
签名就是( a, b )。随机数k须丢弃。
验证时要验证下式：
y^a * a^b ( mod p ) = g^M ( mod p )
同时一定要检验是否满足1<= a < p。否则签名容易伪造。
ElGamal用于加密。被加密信息为M，首先选择一个随机数k，k与 p - 1互质，计算
a = g^k ( mod p )
b = y^k M ( mod p )
( a, b )为密文，是明文的两倍长。解密时计算
M = b / a^x ( mod p )
ElGamal签名的安全性依赖于乘法群(IFp)* 上的离散对数计算。素数p必须足够大，且p-1至少包含一个大素数
因子以抵抗Pohlig & Hellman算法的攻击。M一般都应采用信息的HASH值(如SHA算法)。ElGamal的安全性主要依赖于p和g，若选取不当则签名容易伪造，应保证g对于p-1的大素数因子不可约。D.Bleichenbache“GeneratingElGamal Signatures Without Knowing the Secret Key”中提到了一些攻击方法和对策。ElGamal的一个不足之处是它的密文成倍扩张。
美国的DSS(Digital Signature Standard)的DSA(Digital Signature Algorithm)算法是经ElGamal算法演
变而来。
4、DSA算法
Digital Signature Algorithm (DSA)是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。算法中应用了下述参数：
p：L bits长的素数。L是64的倍数，范围是512到1024；
q：p - 1的160bits的素因子；
g：g = h^((p-1)/q) mod p，h满足h < p - 1, h^((p-1)/q) mod p > 1；
x：x < q，x为私钥 ；
y：y = g^x mod p ，( p, q, g, y )为公钥；
H( x )：One-Way Hash函数。DSS中选用SHA( Secure Hash Algorithm )。
p, q, g可由一组用户共享，但在实际应用中，使用公共模数可能会带来一定的威胁。签名及验证协议如下：
1. P产生随机数k，k < q；
2. P计算 r = ( g^k mod p ) mod q
s = ( k^(-1) (H(m) + xr)) mod q
签名结果是( m, r, s )。
3. 验证时计算 w = s^(-1)mod q
u1 = ( H( m ) * w ) mod q
u2 = ( r * w ) mod q
v = (( g^u1 * y^u2 ) mod p ) mod q
若v = r，则认为签名有效。
DSA是基于整数有限域离散对数难题的，其安全性与RSA相比差不多。DSA的一个重要特点是两个素数公开，这
样，当使用别人的p和q时，即使不知道私钥，你也能确认它们是否是随机产生的，还是作了手脚。RSA算法却作不到。
5、MD5算法
| 在一些初始化处理后，MD5以512位分组来处理输入文本，每一分组又划分为16个32位子分组。算法的输出由四个32位分组组成，将它们级联形成一个128位散列值。 首先填充消息使其长度恰好为一个比512位的倍数仅小64位的数。填充方法是附一个1在消息后面，后接所要求的多个0，然后在其后附上64位的消息长度（填充前）。这两步的作用是使消息长度恰好是512位的整数倍（算法的其余部分要求如此），同时确保不同的消息在填充后不相同。 四个32位变量初始化为： A=0x01234567 B=0x89abcdef C=0xfedcba98 D=0x76543210 它们称为链接变量（chaining variable） 接着进行算法的主循环，循环的次数是消息中512位消息分组的数目。 将上面四个变量复制到别外的变量中：A到a，B到b，C到c，D到d。 主循环有四轮（MD4只有三轮），每轮很相拟。第一轮进行16次操作。每次操作对a，b，c和d中的其中三个作一次非线性函数运算，然后将所得结果加上第四个变量，文本的一个子分组和一个常数。再将所得结果向右环移一个不定的数，并加上a，b，c或d中之一。最后用该结果取代a，b，c或d中之一。 以一下是每次操作中用到的四个非线性函数（每轮一个）。 F(X,Y,Z)=(X&Y)|((~X)&Z) G(X,Y,Z)=(X&Z)|(Y&(~Z)) H(X,Y,Z)=X^Y^Z I(X,Y,Z)=Y^(X|(~Z)) (&是与,|是或,~是非,^是异或) 这些函数是这样设计的：如果X、Y和Z的对应位是独立和均匀的，那么结果的每一位也应是独立和均匀的。 函数F是按逐位方式操作：如果X，那么Y，否则Z。函数H是逐位奇偶操作符。 设Mj表示消息的第j个子分组（从0到15），<< FF(a,b,c,d,Mj,s,ti)表示a=b+((a+(F(b,c,d)+Mj+ti)<< GG(a,b,c,d,Mj,s,ti)表示a=b+((a+(G(b,c,d)+Mj+ti)<< HH(a,b,c,d,Mj,s,ti)表示a=b+((a+(H(b,c,d)+Mj+ti)<< II(a,b,c,d,Mj,s,ti)表示a=b+((a+(I(b,c,d)+Mj+ti)<< 这四轮（64步）是： 第一轮 FF(a,b,c,d,M0,7,0xd76aa478) FF(d,a,b,c,M1,12,0xe8c7b756) FF(c,d,a,b,M2,17,0x242070db) FF(b,c,d,a,M3,22,0xc1bdceee) FF(a,b,c,d,M4,7,0xf57c0faf) FF(d,a,b,c,M5,12,0x4787c62a) FF(c,d,a,b,M6,17,0xa8304613) FF(b,c,d,a,M7,22,0xfd469501) FF(a,b,c,d,M8,7,0x698098d8) FF(d,a,b,c,M9,12,0x8b44f7af) FF(c,d,a,b,M10,17,0xffff5bb1) FF(b,c,d,a,M11,22,0x895cd7be) FF(a,b,c,d,M12,7,0x6b901122) FF(d,a,b,c,M13,12,0xfd987193) FF(c,d,a,b,M14,17,0xa679438e) FF(b,c,d,a,M15,22,0x49b40821) 第二轮 GG(a,b,c,d,M1,5,0xf61e2562) GG(d,a,b,c,M6,9,0xc040b340) GG(c,d,a,b,M11,14,0x265e5a51) GG(b,c,d,a,M0,20,0xe9b6c7aa) GG(a,b,c,d,M5,5,0xd62f105d) GG(d,a,b,c,M10,9,0x02441453) GG(c,d,a,b,M15,14,0xd8a1e681) GG(b,c,d,a,M4,20,0xe7d3fbc8) GG(a,b,c,d,M9,5,0x21e1cde6) GG(d,a,b,c,M14,9,0xc33707d6) GG(c,d,a,b,M3,14,0xf4d50d87) GG(b,c,d,a,M8,20,0x455a14ed) GG(a,b,c,d,M13,5,0xa9e3e905) GG(d,a,b,c,M2,9,0xfcefa3f8) GG(c,d,a,b,M7,14,0x676f02d9) GG(b,c,d,a,M12,20,0x8d2a4c8a) 第三轮 HH(a,b,c,d,M5,4,0xfffa3942) HH(d,a,b,c,M8,11,0x8771f681) HH(c,d,a,b,M11,16,0x6d9d6122) HH(b,c,d,a,M14,23,0xfde5380c) HH(a,b,c,d,M1,4,0xa4beea44) HH(d,a,b,c,M4,11,0x4bdecfa9) HH(c,d,a,b,M7,16,0xf6bb4b60) HH(b,c,d,a,M10,23,0xbebfbc70) HH(a,b,c,d,M13,4,0x289b7ec6) HH(d,a,b,c,M0,11,0xeaa127fa) HH(c,d,a,b,M3,16,0xd4ef3085) HH(b,c,d,a,M6,23,0x04881d05) HH(a,b,c,d,M9,4,0xd9d4d039) HH(d,a,b,c,M12,11,0xe6db99e5) HH(c,d,a,b,M15,16,0x1fa27cf8) HH(b,c,d,a,M2,23,0xc4ac5665) 第四轮 II(a,b,c,d,M0,6,0xf4292244) II(d,a,b,c,M7,10,0x432aff97) II(c,d,a,b,M14,15,0xab9423a7) II(b,c,d,a,M5,21,0xfc93a039) II(a,b,c,d,M12,6,0x655b59c3) II(d,a,b,c,M3,10,0x8f0ccc92) II(c,d,a,b,M10,15,0xffeff47d) II(b,c,d,a,M1,21,0x85845dd1) II(a,b,c,d,M8,6,0x6fa87e4f) II(d,a,b,c,M15,10,0xfe2ce6e0) II(c,d,a,b,M6,15,0xa3014314) II(b,c,d,a,M13,21,0x4e0811a1) II(a,b,c,d,M4,6,0xf7537e82) II(d,a,b,c,M11,10,0xbd3af235) II(c,d,a,b,M2,15,0x2ad7d2bb) II(b,c,d,a,M9,21,0xeb86d391) 常数ti可以如下选择： 在第i步中，ti是4294967296*abs(sin(i))的整数部分,i的单位是弧度。 (2的32次方) 所有这些完成之后，将A，B，C，D分别加上a，b，c，d。然后用下一分组数据继续运行算法，最后的输出是A，B，C和D的级联。 MD5的安全性 MD5相对MD4所作的改进： |
6、BLOWFISH算法
一、BlowFish算法说明（文中数据类型以Tc2.0为准）
BlowFish算法用来加密64Bit长度的字符串。
BlowFish算法使用两个“盒”——ungigned long pbox[18]和unsigned long sbox[4,256]。
BlowFish算法中，有一个核心加密函数:BF_En(后文详细介绍）。该函数输入64位信息，运算后， 以64位密文的形式输出。 用BlowFish算法加密信息，需要两个过程：
1.密钥预处理
2.信息加密
分别说明如下：
密钥预处理：
BlowFish算法的源密钥——pbox和sbox是固定的。我们要加密一个信息，需要自己选择一个key， 用这个key对pbox和sbox进行变换，得到下一步信息加密所要用的key_pbox和key_sbox。具体的变化算法如下：
1)用sbox填充key_sbox
2)用自己选择的key8个一组地去异或pbox，用异或的结果填充key_pbox。key可以循环使用。
比如说：选的key是"abcdefghijklmn"。则异或过程为：
key_pbox[0]=pbox[0]^abcdefgh
key_pbox[1]=pbox[1]^ijklmnab
…………
…………
如此循环，直到key_box填充完毕。
3)用BF_En加密一个全0的64位信息，用输出的结果替换key_pbox[0]和key_pbox[1]。i=0
4)用BF_En加密替换后的key_pbox[i],key_pbox[i+1],用输出替代key_pbox[i+2]和key_pbox[i+3]
5)i+2，继续第4步，直到key_pbox全部被替换
6)用key_pbox[16]和key_pbox[17]做首次输入（相当于上面的全0的输入），用类似的方法，替换key_sbox 信息加密。信息加密就是用函数把待加密信息x分成32位的两部分:xL,xR BF_En对输入信息进行变换，BF_En函数详细过程如下：
对于i=1至16
xL=xL^Pi
xR=F(xL)^xR
交换xL和xR(最后一轮取消该运算)
xR=xR^P17
xL=xL^P18
重新合并xL和xR
函数F见下图:
8位 32位
|-----------S盒1-----------
| |加
| 8位 32位 |----
|-----------S盒2----------- |
| |
| |异或----
32位-| | |
| 8位 32位 | |
|-----------S盒3--------------- |加
| |-----------------32位
| |
| |
| 8位 32位 |
|-----------S盒4-----------------------
把xL分成4个8位分组:a,b,c和d
输出为：F(xL)=((((S[1,a]+S[2,b])MOD 4294967296)^s[3,c])+S[4,d])MOD 4294967296
(2的32次方) (2的32次方)
重新合并后输出的结果就是我们需要的密文。
用BlowFish算法解密，同样也需要两个过程。
1.密钥预处理
2.信息解密
密钥预处理的过程与加密时完全相同
信息解密的过程就是把信息加密过程的key_pbox逆序使用即可。
可以看出，选择不同的key，用BlowFish算法加密同样的信息，可以得出不同的结果。
要破解BlowFish算法，就是要得到BlowFish算法的key。所以，使用BlowFish算法进行加密，最重要的也就是key的选择以及key的保密。其中key的选择可以使用bf_sdk中的_WeakKey函数进行检验。以下是该函数的说明：
源文：
---------------------------------------------------------------------------------------
_WeakKey
Function : Test if the generated Boxes are weak
Argument : none
Return : AX = Status (1=weak, 0=good)
Affects : AX, BX, CX, DX, SI, DI, direction Flag
Description: After "_InitCrypt" you should test the Boxes with this function.
If they provide a weakness which a cryptoanalyst could use to
break the cipher a "1" is returned. In this case you should
reload the original boxes and let the user choose a different
password.
---------------------------------------------------------------------------------------
译文：
---------------------------------------------------------------------------------------
_WeakKey
功能：测试产生的box是否安全
参数：无
返回：AX=1 不安全；AX=0 安全
影响：AX, BX, CX, DX, SI, DI, 方向标志
描述：使用"_InitCrypt"函数产生用于加密的Boxes后，你应该用这个函数测试产生的Boxes是否安全。如果该key产生的Boxes不安全——可以被密码分析者通过分析Boxes得到key，那么，你应该采用另外一个key产生一个安全的Boxes用来加密。
---------------------------------------------------------------------------------------
二、BlowFish's CrackMe1分析
由于该CrackMe主要是测试你的密码学知识，所以没有在其他方面设关卡。为了减小文件体积，缩短大家下载的时间，用upx加了壳，直接用Trw2000的"PNewSec+Makepe"很方便地就能脱掉壳。
用常规的方法，很快找到下面关键比较处：
:004015D9 51 push ecx
:004015DA 52 push edx
:004015DB 6880894000 push 00408980
:004015E0 E8EBFAFFFF call 004010D0 //BF_De(sn)
:004015E5 8B442464 mov eax, dword ptr [esp+64]
:004015E9 8B0DF0994000 mov ecx, dword ptr [004099F0]
:004015EF 83C41C add esp, 0000001C
:004015F2 3BC1 cmp eax, ecx //比较
:004015F4 7529 jne 0040161F
:004015F6 8B4C244C mov ecx, dword ptr [esp+4C]
:004015FA A1EC994000 mov eax, dword ptr [004099EC]
:004015FF 3BC8 cmp ecx, eax //比较
:00401601 751C jne 0040161F
:00401603 6A30 push 00000030
由于BlowFish算法加密，解密输出的信息都是64Bit的，所以要进行两次比较。
我们既然知道了他对我们的sn进行的变换是BF_De，那么，很显然，我们要找到程序初始化key_pbox和key_sbox的地方。跟进4015E0的Call，找到key_pbox在408980处，下bpm，然后跟踪，分析，找到程序初始化key_pbox和key_sbox的地方，如下：
:004016C0 50 push eax
* Possible StringData Ref from Data Obj ->"CrackingForFun"
|
:004016C1 6844804000 push 00408044
:004016C6 6880894000 push 00408980
:004016CB E860FAFFFF call 00401130 //初始化Boxes
由此我们知道了BF_De(sn)的key是"CrackingForFun"。
问题的一半已经解决了。下面我们来看用来比较的另外的64Bit的数是从何而来。
bpm 4099EC w
跟踪分析后，发现这个用来比较的数是由BF_En(ComputerID,key="ChinaCrackingGroup")生成。
至此，我们可以写出注册机的算法：
sn=BF_En((BF_En(ComputerID,key="ChinaCrackingGroup"),key="CrackingForFun")
只要你编程够强，密码学也还过得去，写出这个东西的注册机就不是困难的事情了。
附：
ComputerID的产生
如果你对这个CrackMe很有兴趣，还想研究一下他的ComputerID是如何产生的，也可以继续跟踪，分析，在这里，我给处我分析的结果：
ComputerID=BF_En(0776f6c62h, 068736966h,key=PW_1)
其中，PW_1就是你的Windows版本号，可以在“系统属性”里头看到，也就是注册表中的
H_L_M/Software/Microsoft/Windows/CurrentVersion 中的ProductId项。在我的机器上是：
"25001-OEM-0080247-46673"
注册机源码里头有一些语句没有派上用场，用“;”屏蔽了，如果你有兴趣，可以把前面的;号去掉然后把.data段里头的PW_1换成你机器的ComputerID,再按照程序中的说明自己修改一下源程序，用Masm32V6重新编译，直接按Generate，也能得到正确的序列号。
三、注册机源码
;BlowFish's Crackme's KeyGen Writen By 夜月[CCG]
;Any Questions,Please E-Mail To luoyi.ly@yeah.net
;Thancks To Garfield,BlowFish,Toye
;软件流程：
;1.GetVersion得到机器Windows版本号。PW_1
;2.固定字符串"ChinaCrackingGroup"。PW_2
;3.固定字符串"CrackingForFun"。PW_3
;4.你输入的字符串。sn
;BF_En(0776f6c62h, 068736966h,key=PW_1)得到Computer ID
;BF_En(ComputerID,key=PW_2)得到MagicNum
;IF(BF_De(sn,key=PW_3)==MagicNum) Then Registed OK!
.386
.model flat,stdcall
option casemap:none
include windows.inc
include user32.inc
include kernel32.inc
include comctl32.inc
include comdlg32.inc
include masm32.inc
includelib masm32.lib
includelib user32.lib
includelib kernel32.lib
includelib comctl32.lib
includelib comdlg32.lib
DLG_MAIN equ 100
IDGEN equ 10
Edit1 equ 11
Edit2 equ 12
len_PW_1 equ offset data1_p - offset PW_1
_ProcDlgMain PROTO :DWORD,:DWORD,:DWORD,:DWORD
_Math PROTO :DWORD,:DWORD,:DWORD
BlowFish_En PROTO :DWORD,:DWORD
BlowFish_Fun PROTO :DWORD
BlowFish_Init PROTO :DWORD,:DWORD
.data?
hInstance dd ?
.data
;如果你直接用ComputerID产生序列号，你应该把PW_1换成你自己机器的Windows版本号
;PW_1 db "25001-OEM-0080247-46673"
PW_2 db "ChinaCrackingGroup"
PW_3 db "CrackingForFun"
szID db 20 dup(0)
szText db 9 dup(0)
data1_p dd 0776f6c62h, 068736966h
key dd 1058 dup (0)
BFLOW dd 0
BFHIGH dd 0
MYBFLOW DD 0
MYBFHIGH DD 0
pbox dd 0243f6a88h, 085a308d3h, 013198a2eh, 003707344h, 0a4093822h, 0299f31d0h
dd 0082efa98h, 0ec4e6c89h, 0452821e6h, 038d01377h, 0be5466cfh, 034e90c6ch
dd 0c0ac29b7h, 0c97c50ddh, 03f84d5b5h, 0b5470917h, 09216d5d9h, 08979fb1bh
sbox1 dd 0d1310ba6h, 098dfb5ach, 02ffd72dbh, 0d01adfb7h, 0b8e1afedh, 06a267e96h
dd 0ba7c9045h, 0f12c7f99h, 024a19947h, 0b3916cf7h, 00801f2e2h, 0858efc16h
dd 0636920d8h, 071574e69h, 0a458fea3h, 0f4933d7eh, 00d95748fh, 0728eb658h
dd 0718bcd58h, 082154aeeh, 07b54a41dh, 0c25a59b5h, 09c30d539h, 02af26013h
dd 0c5d1b023h, 0286085f0h, 0ca417918h, 0b8db38efh, 08e79dcb0h, 0603a180eh
dd 06c9e0e8bh, 0b01e8a3eh, 0d71577c1h, 0bd314b27h, 078af2fdah, 055605c60h
dd 0e65525f3h, 0aa55ab94h, 057489862h, 063e81440h, 055ca396ah, 02aab10b6h
dd 0b4cc5c34h, 01141e8ceh, 0a15486afh, 07c72e993h, 0b3ee1411h, 0636fbc2ah
dd 02ba9c55dh, 0741831f6h, 0ce5c3e16h, 09b87931eh, 0afd6ba33h, 06c24cf5ch
dd 07a325381h, 028958677h, 03b8f4898h, 06b4bb9afh, 0c4bfe81bh, 066282193h
dd 061d809cch, 0fb21a991h, 0487cac60h, 05dec8032h, 0ef845d5dh, 0e98575b1h
dd 0dc262302h, 0eb651b88h, 023893e81h, 0d396acc5h, 00f6d6ff3h, 083f44239h
dd 02e0b4482h, 0a4842004h, 069c8f04ah, 09e1f9b5eh, 021c66842h, 0f6e96c9ah
dd 0670c9c61h, 0abd388f0h, 06a51a0d2h, 0d8542f68h, 0960fa728h, 0ab5133a3h
dd 06eef0b6ch, 0137a3be4h, 0ba3bf050h, 07efb2a98h, 0a1f1651dh, 039af0176h
dd 066ca593eh, 082430e88h, 08cee8619h, 0456f9fb4h, 07d84a5c3h, 03b8b5ebeh
dd 0e06f75d8h, 085c12073h, 0401a449fh, 056c16aa6h, 04ed3aa62h, 0363f7706h
dd 01bfedf72h, 0429b023dh, 037d0d724h, 0d00a1248h, 0db0fead3h, 049f1c09bh
dd 0075372c9h, 080991b7bh, 025d479d8h, 0f6e8def7h, 0e3fe501ah, 0b6794c3bh
dd 0976ce0bdh, 004c006bah, 0c1a94fb6h, 0409f60c4h, 05e5c9ec2h, 0196a2463h
dd 068fb6fafh, 03e6c53b5h, 01339b2ebh, 03b52ec6fh, 06dfc511fh, 09b30952ch
dd 0cc814544h, 0af5ebd09h, 0bee3d004h, 0de334afdh, 0660f2807h, 0192e4bb3h
dd 0c0cba857h, 045c8740fh, 0d20b5f39h, 0b9d3fbdbh, 05579c0bdh, 01a60320ah
dd 0d6a100c6h, 0402c7279h, 0679f25feh, 0fb1fa3cch, 08ea5e9f8h, 0db3222f8h
dd 03c7516dfh, 0fd616b15h, 02f501ec8h, 0ad0552abh, 0323db5fah, 0fd238760h
dd 053317b48h, 03e00df82h, 09e5c57bbh, 0ca6f8ca0h, 01a87562eh, 0df1769dbh
dd 0d542a8f6h, 0287effc3h, 0ac6732c6h, 08c4f5573h, 0695b27b0h, 0bbca58c8h
dd 0e1ffa35dh, 0b8f011a0h, 010fa3d98h, 0fd2183b8h, 04afcb56ch, 02dd1d35bh
dd 09a53e479h, 0b6f84565h, 0d28e49bch, 04bfb9790h, 0e1ddf2dah, 0a4cb7e33h
dd 062fb1341h, 0cee4c6e8h, 0ef20cadah, 036774c01h, 0d07e9efeh, 02bf11fb4h
dd 095dbda4dh, 0ae909198h, 0eaad8e71h, 06b93d5a0h, 0d08ed1d0h, 0afc725e0h
dd 08e3c5b2fh, 08e7594b7h, 08ff6e2fbh, 0f2122b64h, 08888b812h, 0900df01ch
dd 04fad5ea0h, 0688fc31ch, 0d1cff191h, 0b3a8c1adh, 02f2f2218h, 0be0e1777h
dd 0ea752dfeh, 08b021fa1h, 0e5a0cc0fh, 0b56f74e8h, 018acf3d6h, 0ce89e299h
dd 0b4a84fe0h, 0fd13e0b7h, 07cc43b81h, 0d2ada8d9h, 0165fa266h, 080957705h
dd 093cc7314h, 0211a1477h, 0e6ad2065h, 077b5fa86h, 0c75442f5h, 0fb9d35cfh
dd 0ebcdaf0ch, 07b3e89a0h, 0d6411bd3h, 0ae1e7e49h, 000250e2dh, 02071b35eh
dd 0226800bbh, 057b8e0afh, 02464369bh, 0f009b91eh, 05563911dh, 059dfa6aah
dd 078c14389h, 0d95a537fh, 0207d5ba2h, 002e5b9c5h, 083260376h, 06295cfa9h
dd 011c81968h, 04e734a41h, 0b3472dcah, 07b14a94ah, 01b510052h, 09a532915h
dd 0d60f573fh, 0bc9bc6e4h, 02b60a476h, 081e67400h, 008ba6fb5h, 0571be91fh
dd 0f296ec6bh, 02a0dd915h, 0b6636521h, 0e7b9f9b6h, 0ff34052eh, 0c5855664h
dd 053b02d5dh, 0a99f8fa1h, 008ba4799h, 06e85076ah
sbox2 dd 04b7a70e9h, 0b5b32944h
dd 0db75092eh, 0c4192623h, 0ad6ea6b0h, 049a7df7dh, 09cee60b8h, 08fedb266h
dd 0ecaa8c71h, 0699a17ffh, 05664526ch, 0c2b19ee1h, 0193602a5h, 075094c29h
dd 0a0591340h, 0e4183a3eh, 03f54989ah, 05b429d65h, 06b8fe4d6h, 099f73fd6h
dd 0a1d29c07h, 0efe830f5h, 04d2d38e6h, 0f0255dc1h, 04cdd2086h, 08470eb26h
dd 06382e9c6h, 0021ecc5eh, 009686b3fh, 03ebaefc9h, 03c971814h, 06b6a70a1h
dd 0687f3584h, 052a0e286h, 0b79c5305h, 0aa500737h, 03e07841ch, 07fdeae5ch
dd 08e7d44ech, 05716f2b8h, 0b03ada37h, 0f0500c0dh, 0f01c1f04h, 00200b3ffh
dd 0ae0cf51ah, 03cb574b2h, 025837a58h, 0dc0921bdh, 0d19113f9h, 07ca92ff6h
dd 094324773h, 022f54701h, 03ae5e581h, 037c2dadch, 0c8b57634h, 09af3dda7h
dd 0a9446146h, 00fd0030eh, 0ecc8c73eh, 0a4751e41h, 0e238cd99h, 03bea0e2fh
dd 03280bba1h, 0183eb331h, 04e548b38h, 04f6db908h, 06f420d03h, 0f60a04bfh
dd 02cb81290h, 024977c79h, 05679b072h, 0bcaf89afh, 0de9a771fh, 0d9930810h
dd 0b38bae12h, 0dccf3f2eh, 05512721fh, 02e6b7124h, 0501adde6h, 09f84cd87h
dd 07a584718h, 07408da17h, 0bc9f9abch, 0e94b7d8ch, 0ec7aec3ah, 0db851dfah
dd 063094366h, 0c464c3d2h, 0ef1c1847h, 03215d908h, 0dd433b37h, 024c2ba16h
dd 012a14d43h, 02a65c451h, 050940002h, 0133ae4ddh, 071dff89eh, 010314e55h
dd 081ac77d6h, 05f11199bh, 0043556f1h, 0d7a3c76bh, 03c11183bh, 05924a509h
dd 0f28fe6edh, 097f1fbfah, 09ebabf2ch, 01e153c6eh, 086e34570h, 0eae96fb1h
dd 0860e5e0ah, 05a3e2ab3h, 0771fe71ch, 04e3d06fah, 02965dcb9h, 099e71d0fh
dd 0803e89d6h, 05266c825h, 02e4cc978h, 09c10b36ah, 0c6150ebah, 094e2ea78h
dd 0a5fc3c53h, 01e0a2df4h, 0f2f74ea7h, 0361d2b3dh, 01939260fh, 019c27960h
dd 05223a708h, 0f71312b6h, 0ebadfe6eh, 0eac31f66h, 0e3bc4595h, 0a67bc883h
dd 0b17f37d1h, 0018cff28h, 0c332ddefh, 0be6c5aa5h, 065582185h, 068ab9802h
dd 0eecea50fh, 0db2f953bh, 02aef7dadh, 05b6e2f84h, 01521b628h, 029076170h
dd 0ecdd4775h, 0619f1510h, 013cca830h, 0eb61bd96h, 00334fe1eh, 0aa0363cfh
dd 0b5735c90h, 04c70a239h, 0d59e9e0bh, 0cbaade14h, 0eecc86bch, 060622ca7h
dd 09cab5cabh, 0b2f3846eh, 0648b1eafh, 019bdf0cah, 0a02369b9h, 0655abb50h
dd 040685a32h, 03c2ab4b3h, 0319ee9d5h, 0c021b8f7h, 09b540b19h, 0875fa099h
dd 095f7997eh, 0623d7da8h, 0f837889ah, 097e32d77h, 011ed935fh, 016681281h
dd 00e358829h, 0c7e61fd6h, 096dedfa1h, 07858ba99h, 057f584a5h, 01b227263h
dd 09b83c3ffh, 01ac24696h, 0cdb30aebh, 0532e3054h, 08fd948e4h, 06dbc3128h
dd 058ebf2efh, 034c6ffeah, 0fe28ed61h, 0ee7c3c73h, 05d4a14d9h, 0e864b7e3h
dd 042105d14h, 0203e13e0h, 045eee2b6h, 0a3aaabeah, 0db6c4f15h, 0facb4fd0h
dd 0c742f442h, 0ef6abbb5h, 0654f3b1dh, 041cd2105h, 0d81e799eh, 086854dc7h
dd 0e44b476ah, 03d816250h, 0cf62a1f2h, 05b8d2646h, 0fc8883a0h, 0c1c7b6a3h
dd 07f1524c3h, 069cb7492h, 047848a0bh, 05692b285h, 0095bbf00h, 0ad19489dh
dd 01462b174h, 023820e00h, 058428d2ah, 00c55f5eah, 01dadf43eh, 0233f7061h
dd 03372f092h, 08d937e41h, 0d65fecf1h, 06c223bdbh, 07cde3759h, 0cbee7460h
dd 04085f2a7h, 0ce77326eh, 0a6078084h, 019f8509eh, 0e8efd855h, 061d99735h
dd 0a969a7aah, 0c50c06c2h, 05a04abfch, 0800bcadch, 09e447a2eh, 0c3453484h
dd 0fdd56705h, 00e1e9ec9h, 0db73dbd3h, 0105588cdh, 0675fda79h, 0e3674340h
dd 0c5c43465h, 0713e38d8h, 03d28f89eh, 0f16dff20h, 0153e21e7h, 08fb03d4ah
dd 0e6e39f2bh, 0db83adf7h
sbox3 dd 0e93d5a68h, 0948140f7h, 0f64c261ch, 094692934h
dd 0411520f7h, 07602d4f7h, 0bcf46b2eh, 0d4a20068h, 0d4082471h, 03320f46ah
dd 043b7d4b7h, 0500061afh, 01e39f62eh, 097244546h, 014214f74h, 0bf8b8840h
dd 04d95fc1dh, 096b591afh, 070f4ddd3h, 066a02f45h, 0bfbc09ech, 003bd9785h
dd 07fac6dd0h, 031cb8504h, 096eb27b3h, 055fd3941h, 0da2547e6h, 0abca0a9ah
dd 028507825h, 0530429f4h, 00a2c86dah, 0e9b66dfbh, 068dc1462h, 0d7486900h
dd 0680ec0a4h, 027a18deeh, 04f3ffea2h, 0e887ad8ch, 0b58ce006h, 07af4d6b6h
dd 0aace1e7ch, 0d3375fech, 0ce78a399h, 0406b2a42h, 020fe9e35h, 0d9f385b9h
dd 0ee39d7abh, 03b124e8bh, 01dc9faf7h, 04b6d1856h, 026a36631h, 0eae397b2h
dd 03a6efa74h, 0dd5b4332h, 06841e7f7h, 0ca7820fbh, 0fb0af54eh, 0d8feb397h
dd 0454056ach, 0ba489527h, 055533a3ah, 020838d87h, 0fe6ba9b7h, 0d096954bh
dd 055a867bch, 0a1159a58h, 0cca92963h, 099e1db33h, 0a62a4a56h, 03f3125f9h
dd 05ef47e1ch, 09029317ch, 0fdf8e802h, 004272f70h, 080bb155ch, 005282ce3h
dd 095c11548h, 0e4c66d22h, 048c1133fh, 0c70f86dch, 007f9c9eeh, 041041f0fh
dd 0404779a4h, 05d886e17h, 0325f51ebh, 0d59bc0d1h, 0f2bcc18fh, 041113564h
dd 0257b7834h, 0602a9c60h, 0dff8e8a3h, 01f636c1bh, 00e12b4c2h, 002e1329eh
dd 0af664fd1h, 0cad18115h, 06b2395e0h, 0333e92e1h, 03b240b62h, 0eebeb922h
dd 085b2a20eh, 0e6ba0d99h, 0de720c8ch, 02da2f728h, 0d0127845h, 095b794fdh
dd 0647d0862h, 0e7ccf5f0h, 05449a36fh, 0877d48fah, 0c39dfd27h, 0f33e8d1eh
dd 00a476341h, 0992eff74h, 03a6f6eabh, 0f4f8fd37h, 0a812dc60h, 0a1ebddf8h
dd 0991be14ch, 0db6e6b0dh, 0c67b5510h, 06d672c37h, 02765d43bh, 0dcd0e804h
dd 0f1290dc7h, 0cc00ffa3h, 0b5390f92h, 0690fed0bh, 0667b9ffbh, 0cedb7d9ch
dd 0a091cf0bh, 0d9155ea3h, 0bb132f88h, 0515bad24h, 07b9479bfh, 0763bd6ebh
dd 037392eb3h, 0cc115979h, 08026e297h, 0f42e312dh, 06842ada7h, 0c66a2b3bh
dd 012754ccch, 0782ef11ch, 06a124237h, 0b79251e7h, 006a1bbe6h, 04bfb6350h
dd 01a6b1018h, 011caedfah, 03d25bdd8h, 0e2e1c3c9h, 044421659h, 00a121386h
dd 0d90cec6eh, 0d5abea2ah, 064af674eh, 0da86a85fh, 0bebfe988h, 064e4c3feh
dd 09dbc8057h, 0f0f7c086h, 060787bf8h, 06003604dh, 0d1fd8346h, 0f6381fb0h
dd 07745ae04h, 0d736fccch, 083426b33h, 0f01eab71h, 0b0804187h, 03c005e5fh
dd 077a057beh, 0bde8ae24h, 055464299h, 0bf582e61h, 04e58f48fh, 0f2ddfda2h
dd 0f474ef38h, 08789bdc2h, 05366f9c3h, 0c8b38e74h, 0b475f255h, 046fcd9b9h
dd 07aeb2661h, 08b1ddf84h, 0846a0e79h, 0915f95e2h, 0466e598eh, 020b45770h
dd 08cd55591h, 0c902de4ch, 0b90bace1h, 0bb8205d0h, 011a86248h, 07574a99eh
dd 0b77f19b6h, 0e0a9dc09h, 0662d09a1h, 0c4324633h, 0e85a1f02h, 009f0be8ch
dd 04a99a025h, 01d6efe10h, 01ab93d1dh, 00ba5a4dfh, 0a186f20fh, 02868f169h
dd 0dcb7da83h, 0573906feh, 0a1e2ce9bh, 04fcd7f52h, 050115e01h, 0a70683fah
dd 0a002b5c4h, 00de6d027h, 09af88c27h, 0773f8641h, 0c3604c06h, 061a806b5h
dd 0f0177a28h, 0c0f586e0h, 0006058aah, 030dc7d62h, 011e69ed7h, 02338ea63h
dd 053c2dd94h, 0c2c21634h, 0bbcbee56h, 090bcb6deh, 0ebfc7da1h, 0ce591d76h
dd 06f05e409h, 04b7c0188h, 039720a3dh, 07c927c24h, 086e3725fh, 0724d9db9h
dd 01ac15bb4h, 0d39eb8fch, 0ed545578h, 008fca5b5h, 0d83d7cd3h, 04dad0fc4h
dd 01e50ef5eh, 0b161e6f8h, 0a28514d9h, 06c51133ch, 06fd5c7e7h, 056e14ec4h
dd 0362abfceh, 0ddc6c837h, 0d79a3234h, 092638212h, 0670efa8eh, 0406000e0h
sbox4 dd 03a39ce37h, 0d3faf5cfh, 0abc27737h, 05ac52d1bh, 05cb0679eh, 04fa33742h
dd 0d3822740h, 099bc9bbeh, 0d5118e9dh, 0bf0f7315h, 0d62d1c7eh, 0c700c47bh
dd 0b78c1b6bh, 021a19045h, 0b26eb1beh, 06a366eb4h, 05748ab2fh, 0bc946e79h
dd 0c6a376d2h, 06549c2c8h, 0530ff8eeh, 0468dde7dh, 0d5730a1dh, 04cd04dc6h
dd 02939bbdbh, 0a9ba4650h, 0ac9526e8h, 0be5ee304h, 0a1fad5f0h, 06a2d519ah
dd 063ef8ce2h, 09a86ee22h, 0c089c2b8h, 043242ef6h, 0a51e03aah, 09cf2d0a4h
dd 083c061bah, 09be96a4dh, 08fe51550h, 0ba645bd6h, 02826a2f9h, 0a73a3ae1h
dd 04ba99586h, 0ef5562e9h, 0c72fefd3h, 0f752f7dah, 03f046f69h, 077fa0a59h
dd 080e4a915h, 087b08601h, 09b09e6adh, 03b3ee593h, 0e990fd5ah, 09e34d797h
dd 02cf0b7d9h, 0022b8b51h, 096d5ac3ah, 0017da67dh, 0d1cf3ed6h, 07c7d2d28h
dd 01f9f25cfh, 0adf2b89bh, 05ad6b472h, 05a88f54ch, 0e029ac71h, 0e019a5e6h
dd 047b0acfdh, 0ed93fa9bh, 0e8d3c48dh, 0283b57cch, 0f8d56629h, 079132e28h
dd 0785f0191h, 0ed756055h, 0f7960e44h, 0e3d35e8ch, 015056dd4h, 088f46dbah
dd 003a16125h, 00564f0bdh, 0c3eb9e15h, 03c9057a2h, 097271aech, 0a93a072ah
dd 01b3f6d9bh, 01e6321f5h, 0f59c66fbh, 026dcf319h, 07533d928h, 0b155fdf5h
dd 003563482h, 08aba3cbbh, 028517711h, 0c20ad9f8h, 0abcc5167h, 0ccad925fh
dd 04de81751h, 03830dc8eh, 0379d5862h, 09320f991h, 0ea7a90c2h, 0fb3e7bceh
dd 05121ce64h, 0774fbe32h, 0a8b6e37eh, 0c3293d46h, 048de5369h, 06413e680h
dd 0a2ae0810h, 0dd6db224h, 069852dfdh, 009072166h, 0b39a460ah, 06445c0ddh
dd 0586cdecfh, 01c20c8aeh, 05bbef7ddh, 01b588d40h, 0ccd2017fh, 06bb4e3bbh
dd 0dda26a7eh, 03a59ff45h, 03e350a44h, 0bcb4cdd5h, 072eacea8h, 0fa6484bbh
dd 08d6612aeh, 0bf3c6f47h, 0d29be463h, 0542f5d9eh, 0aec2771bh, 0f64e6370h
dd 0740e0d8dh, 0e75b1357h, 0f8721671h, 0af537d5dh, 04040cb08h, 04eb4e2cch
dd 034d2466ah, 00115af84h, 0e1b00428h, 095983a1dh, 006b89fb4h, 0ce6ea048h
dd 06f3f3b82h, 03520ab82h, 0011a1d4bh, 0277227f8h, 0611560b1h, 0e7933fdch
dd 0bb3a792bh, 0344525bdh, 0a08839e1h, 051ce794bh, 02f32c9b7h, 0a01fbac9h
dd 0e01cc87eh, 0bcc7d1f6h, 0cf0111c3h, 0a1e8aac7h, 01a908749h, 0d44fbd9ah
dd 0d0dadecbh, 0d50ada38h, 00339c32ah, 0c6913667h, 08df9317ch, 0e0b12b4fh
dd 0f79e59b7h, 043f5bb3ah, 0f2d519ffh, 027d9459ch, 0bf97222ch, 015e6fc2ah
dd 00f91fc71h, 09b941525h, 0fae59361h, 0ceb69cebh, 0c2a86459h, 012baa8d1h
dd 0b6c1075eh, 0e3056a0ch, 010d25065h, 0cb03a442h, 0e0ec6e0eh, 01698db3bh
dd 04c98a0beh, 03278e964h, 09f1f9532h, 0e0d392dfh, 0d3a0342bh, 08971f21eh
dd 01b0a7441h, 04ba3348ch, 0c5be7120h, 0c37632d8h, 0df359f8dh, 09b992f2eh
dd 0e60b6f47h, 00fe3f11dh, 0e54cda54h, 01edad891h, 0ce6279cfh, 0cd3e7e6fh
dd 01618b166h, 0fd2c1d05h, 0848fd2c5h, 0f6fb2299h, 0f523f357h, 0a6327623h
dd 093a83531h, 056cccd02h, 0acf08162h, 05a75ebb5h, 06e163697h, 088d273cch
dd 0de966292h, 081b949d0h, 04c50901bh, 071c65614h, 0e6c6c7bdh, 0327a140ah
dd 045e1d006h, 0c3f27b9ah, 0c9aa53fdh, 062a80f00h, 0bb25bfe2h, 035bdd2f6h
dd 071126905h, 0b2040222h, 0b6cbcf7ch, 0cd769c2bh, 053113ec0h, 01640e3d3h
dd 038abbd60h, 02547adf0h, 0ba38209ch, 0f746ce76h, 077afa1c5h, 020756060h
dd 085cbfe4eh, 08ae88dd8h, 07aaaf9b0h, 04cf9aa7eh, 01948c25ch, 002fb8a8ch
dd 001c36ae4h, 0d6ebe1f9h, 090d4f869h, 0a65cdea0h, 03f09252dh, 0c208e69fh
dd 0b74e6132h, 0ce77e25bh, 0578fdfe3h, 03ac372e6h
.code
;s盒变换函数
BlowFish_Fun proc uses ebx edi esi edx ecx,BfNum:DWORD
MOV ECX,BfNum
MOV AL,CL
AND EAX,0FFh
SHR ECX,08
MOV EDX,EAX
MOV AL,CL
MOV EDI,offset key
AND EAX,0FFh
SHR ECX,08
MOV ESI,EAX
MOV EAX,ECX
SHR EAX,08
AND EAX,0FFh
AND ECX,0FFh
AND ESI,0FFFFh
AND EDX,0FFFFh
MOV EAX,[EDI+EAX*4+48h]
MOV EBX,[EDI+ECX*4+0448h]
MOV ECX,[EDI+ESI*4+0848h]
ADD EAX,EBX
XOR EAX,ECX
MOV ECX,[EDI+EDX*4+0C48h]
ADD EAX,ECX
RET
BlowFish_Fun endp
;BlowFish加密算法函数
BlowFish_En proc uses ebx edi esi edx ecx,highbf:DWORD,lowbf:DWORD
LOCAL num :DWORD
MOV EAX,highbf
MOV ECX,lowbf
MOV EAX,[EAX]
MOV ESI,[ECX]
MOV EDI,offset key
MOV num,10h
MOV EBX,EDI
loc_40108E:
XOR EAX,[EBX]
MOV EDX,EAX
invoke BlowFish_Fun,EAX
MOV ECX,num
XOR EAX,ESI
ADD EBX,4
DEC ECX
MOV ESI,EDX
MOV num,ECX
JNZ loc_40108E
MOV ECX,[EDI+40h]
MOV EDX,[EDI+44h]
XOR ECX,EAX
XOR EDX,ESI
MOV [BFHIGH],EDX
MOV [BFLOW],ECX
RET
BlowFish_En endp
;BlowFish初始化函数
BlowFish_Init proc uses ebx edi esi edx ecx,PWD:DWORD,len_PWD:DWORD
LOCAL pbox_num18:DWORD
LOCAL pbox_num4 :DWORD
LOCAL snum :DWORD
;初始化s盒
MOV ESI,offset key
MOV EAX,offset sbox1
LEA ECX,[ESI+48h]
loc_401141:
MOV EDX,0100h
loc_401146:
MOV EDI,[EAX]
ADD EAX,4
MOV [ECX],EDI
ADD ECX,4
DEC EDX
JNZ loc_401146
CMP EAX,offset sbox1+1000h
JL loc_401141
;初始化p盒
;第一步：原p盒与PWD逐项异或
MOV EDX,PWD
MOV EDI,offset pbox
XOR EAX,EAX
SUB EDI,ESI
MOV pbox_num18,12h
loc_401173:
XOR ECX,ECX
MOV pbox_num4,04
loc_40117D:
XOR EBX,EBX
MOV BL,[EAX+EDX]
SHL ECX,08
OR ECX,EBX
INC EAX
CMP EAX,len_PWD
JL loc_40118E
XOR EAX,EAX
loc_40118E:
MOV EBX,pbox_num4
DEC EBX
MOV pbox_num4,EBX
JNZ loc_40117D
MOV EBX,[EDI+ESI]
ADD ESI,4
XOR EBX,ECX
MOV ECX,pbox_num18
MOV [ESI-04],EBX
DEC ECX
MOV pbox_num18,ECX
JNZ loc_401173
;用连续的blowfish算法填充p盒
MOV EBX,offset key
XOR EAX,EAX
MOV BFLOW,EAX
MOV BFHIGH,EAX
MOV ESI,EBX
MOV EDI,09
loc_4011C4:
LEA EAX,BFLOW
LEA ECX,BFHIGH
invoke BlowFish_En,ECX,EAX
MOV EAX,BFHIGH
MOV ECX,BFLOW
MOV [ESI],EAX
MOV [ESI+04],ECX
ADD ESI,8
DEC EDI
JNZ loc_4011C4
;用连续的blowfish算法填充s盒
LEA ESI,[EBX+4Ch]
MOV snum,04 ;4个s盒。
loc_4011F2:
MOV EDI,80H ;每个盒填充80h=128次（每次填充两个数）。
loc_4011F7:
LEA ECX,BFLOW
LEA EDX,BFHIGH
invoke BlowFish_En,EDX,ECX
MOV ECX,BFHIGH
MOV EDX,BFLOW
MOV [ESI-04],ECX
MOV [ESI],EDX
ADD ESI,8
DEC EDI
JNZ loc_4011F7
DEC snum
JNZ loc_4011F2
RET
BlowFish_Init endp
;消息处理函数
_ProcDlgMain proc uses ebx edi esi edx ecx,hWnd:DWORD,wMsg:DWORD,wParam:DWORD,lParam:DWORD
mov eax,wMsg
.if eax==WM_CLOSE
invoke EndDialog,hWnd,NULL
.elseif eax==WM_COMMAND
mov eax,wParam
and eax,0ffffh
.if eax==IDGEN
;如果你直接用ComputerID产生序列号，从这里到mov MYBFLOW,ebx一段应该屏蔽
invoke GetDlgItemText,hWnd,Edit1,offset szID,17
xor ebx,ebx
xor eax,eax
mov esi,offset szID
mov ecx,8
@@33:
or ebx,eax
xor eax,eax
lodsb
cmp eax,39h
jle @@3
sub eax,7
@@3:
sub eax,30h
shl ebx,4
loop @@33
or ebx,eax
mov MYBFHIGH,ebx
mov esi,offset szID+8
mov ecx,8
xor eax,eax
xor ebx,ebx
@@44:
or ebx,eax
lodsb
cmp eax,39h
jle @@4
sub eax,7
@@4:
sub eax,30h
shl ebx,4
loop @@44
or ebx,eax
mov MYBFLOW,ebx
;…………………………………………………………………………………………………………
;如果你直接用ComputerID产生序列号，这里后面的所有语句你都应将其激活
; invoke BlowFish_Init,offset PW_1,23
; invoke BlowFish_En,offset data1_p,offset data1_p+4
; MOV EAX,BFHIGH
; MOV MYBFHIGH,EAX
; MOV EAX,BFLOW
; MOV MYBFLOW,EAX
invoke BlowFish_Init,offset PW_2,18
invoke BlowFish_En,offset MYBFHIGH,offset MYBFLOW
MOV EAX,BFHIGH
MOV MYBFHIGH,EAX
MOV EAX,BFLOW
MOV MYBFLOW,EAX
invoke BlowFish_Init,offset PW_3,14
invoke BlowFish_En,offset MYBFHIGH,offset MYBFLOW
mov ebx,BFHIGH
mov eax,ebx
mov edi,offset szText
mov ecx,8
@@12:
mov eax,ebx
shl ebx,4
shr eax,28
cmp eax,9
jle @@11
add eax,7
@@11: add eax,30h
and eax,0ffh
stosb
loop @@12
mov ebx,BFLOW
mov eax,ebx
mov edi,offset szText+8
mov ecx,8
@@22:
mov eax,ebx
shl ebx,4
shr eax,28
cmp eax,9
jle @@21
add eax,7
@@21: add eax,30h
and eax,0ffh
stosb
loop @@22
xor eax,eax
mov [edi],eax
invoke SetDlgItemText,hWnd,Edit2,offset szText
mov eax,FALSE
ret
.elseif eax==IDCLOSE
invoke EndDialog,hWnd,NULL
.endif
.else
mov eax,FALSE
ret
.endif
mov eax,TRUE
ret
_ProcDlgMain endp
;主程序
start:
invoke InitCommonControls
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke DialogBoxParam,hInstance,DLG_MAIN,NULL,offset _ProcDlgMain,0
invoke ExitProcess,NULL
end start
end
;资源文件：rsrc.rc
;#include
;#define IDGEN 10
;#define DLG_MAIN 100
;#define EDIT1 11
;#define EDIT2 12
;
;DLG_MAIN DIALOGEX 100,150,250,60
;STYLE DS_MODALFRAME.|WS_POPUP|WS_VISIBLE|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME.
;CAPTION "BlowFish's CrackMe KenGen By 夜月[CCG] "
;FONT 9,"宋体"
;
;BEGIN
;CONTROL " ID:",-1,"Static",SS_LEFT,10,13,40,17
;CONTROL "SN:" ,-2,"Static",SS_CENTER,10,40,20,17
;CONTROL "" ,11,"Edit",ES_LEFT,30,13,150,10
;CONTROL "" ,12,"Edit",ES_LEFT,30,40,150,10
;CONTROL "GENERATE",IDGEN,"BUTTON",BS_PUSHBUTTON,200,11,40,15
;CONTROL "EXIT",IDCLOSE,"BUTTON",BS_PUSHBUTTON,200,36,41,14
;END
=========================================================
=
= BlowFish's CrackMe1 验证算法分析
= DiKeN/OCG
=========================================================
* Possible Reference to Dialog: DialogID_0065, CONTROL_ID:03EB, ""
|
:004015A4 68EB030000 push 000003EB
:004015A9 56 push esi
* Reference To: USER32.GetDlgItemTextA, Ord:0000h
|
:004015AA FF151C614000 Call dword ptr [0040611C]
:004015B0 85C0 test eax, eax
:004015B2 0F8432010000 je 004016EA
:004015B8 8D4C244C lea ecx, dword ptr [esp+4C]
:004015BC 8D542448 lea edx, dword ptr [esp+48]
:004015C0 51 push ecx
:004015C1 52 push edx
:004015C2 8D44240C lea eax, dword ptr [esp+0C]
* Possible StringData Ref from Data Obj ->"%08lX%08lX"
|
:004015C6 686C804000 push 0040806C
:004015CB 50 push eax
:004015CC E81F020000 call 004017F0
:004015D1 8D4C245C lea ecx, dword ptr [esp+5C]
:004015D5 8D542458 lea edx, dword ptr [esp+58]
:004015D9 51 push ecx=========>[ecx]=0x90ABCDEF=xr
:004015DA 52 push edx=========>[edx]=0x12345678=xl
:004015DB 6880894000 push 00408980====>P-Box(密钥盒)
:004015E0 E8EBFAFFFF call 004010D0====>计算Blowfish_Dec(long *xl,long *xr)
======================================BF_Dec过程分析============================
:004010D0 8B442408 mov eax, dword ptr [esp+08]
:004010D4 8B4C240C mov ecx, dword ptr [esp+0C]
:004010D8 53 push ebx
:004010D9 55 push ebp
:004010DA 8B00 mov eax, dword ptr [eax]====>xl
:004010DC 56 push esi
:004010DD 8B31 mov esi, dword ptr [ecx]====>xr
:004010DF 57 push edi
:004010E0 8B7C2414 mov edi, dword ptr [esp+14]
:004010E4 C744241410000000 mov [esp+14], 00000010
:004010EC 8D5F44 lea ebx, dword ptr [edi+44]==>P-Box(FORM. 18 to 1<==因此使用的Dec)
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040110D(C)
|
:004010EF 3303 xor eax, dword ptr [ebx]
:004010F1 50 push eax
:004010F2 57 push edi
:004010F3 8BE8 mov ebp, eax
:004010F5 E806FFFFFF call 00401000
================================================================================
================================函数F(xl)
================================================================================
:00401000 8B4C2408 mov ecx, dword ptr [esp+08]
:00401004 53 push ebx
:00401005 8AC1 mov al, cl
:00401007 56 push esi
:00401008 25FF000000 and eax, 000000FF
:0040100D 57 push edi
:0040100E C1E908 shr ecx, 08
:00401011 8BD0 mov edx, eax
:00401013 8AC1 mov al, cl
:00401015 8B7C2410 mov edi, dword ptr [esp+10]
:00401019 25FF000000 and eax, 000000FF
:0040101E C1E908 shr ecx, 08
:00401021 8BF0 mov esi, eax
:00401023 8BC1 mov eax, ecx
:00401025 C1E808 shr eax, 08
:00401028 25FF000000 and eax, 000000FF
:0040102D 81E1FF000000 and ecx, 000000FF
:00401033 81E6FFFF0000 and esi, 0000FFFF
:00401039 81E2FFFF0000 and edx, 0000FFFF
:0040103F 8B448748 mov eax, dword ptr [edi+4*eax+48]
:00401043 8B9C8F48040000 mov ebx, dword ptr [edi+4*ecx+00000448]
:0040104A 8B8CB748080000 mov ecx, dword ptr [edi+4*esi+00000848]
:00401051 03C3 add eax, ebx
:00401053 33C1 xor eax, ecx
:00401055 8B8C97480C0000 mov ecx, dword ptr [edi+4*edx+00000C48]
:0040105C 5F pop edi
:0040105D 5E pop esi
:0040105E 03C1 add eax, ecx
:00401060 5B pop ebx
:00401061 C3 ret
================================================================================
================================end 函数F(xl)
================================================================================
:004010FA 8B4C241C mov ecx, dword ptr [esp+1C]
:004010FE 83C408 add esp, 00000008
:00401101 33C6 xor eax, esi
:00401103 83EB04 sub ebx, 00000004
:00401106 49 dec ecx
:00401107 8BF5 mov esi, ebp
:00401109 894C2414 mov dword ptr [esp+14], ecx
:0040110D 75E0 jne 004010EF
:0040110F 8B4F04 mov ecx, dword ptr [edi+04]
:00401112 8B17 mov edx, dword ptr [edi]
:00401114 33C8 xor ecx, eax
:00401116 8B442418 mov eax, dword ptr [esp+18]
:0040111A 33D6 xor edx, esi
:0040111C 5F pop edi
:0040111D 8910 mov dword ptr [eax], edx
:0040111F 8B542418 mov edx, dword ptr [esp+18]
:00401123 5E pop esi
:00401124 5D pop ebp
:00401125 890A mov dword ptr [edx], ecx
:00401127 5B pop ebx
:00401128 C3 ret
=========================BF_Dec过程分析完毕====================================
:004015E5 8B442464 mov eax, dword ptr [esp+64]
:004015E9 8B0DF0994000 mov ecx, dword ptr [004099F0]
:004015EF 83C41C add esp, 0000001C
:004015F2 3BC1 cmp eax, ecx=============>
:004015F4 7529 jne 0040161F
:004015F6 8B4C244C mov ecx, dword ptr [esp+4C]
:004015FA A1EC994000 mov eax, dword ptr [004099EC]=======>我们的找到这个数据的来源，
======================================================================>我们定义为Yl,Yr
==========================================================>我们定义输入的注册码为Ml,Mr
==============================================>即有Blowfish_Dec(Ml,Mr)=Yl,Yr
==============================================>所以Blowfish_Enc(Yl,Yr)=Ml,Mr
==========================================================>我们还需要key
:004015FF 3BC8 cmp ecx, eax=============>两次比较
:00401601 751C jne 0040161F
:00401603 6A30 push 00000030
...........
刚分析了BF_Dec过程，再来分析一个Enc过程：
======================================================================
其实BF_Enc过程与BF_Dec完全一样，只是使用P-Box顺序到过来了
======================================================================
:00401070 8B442408 mov eax, dword ptr [esp+08]
:00401074 8B4C240C mov ecx, dword ptr [esp+0C]
:00401078 53 push ebx
:00401079 55 push ebp
:0040107A 8B00 mov eax, dword ptr [eax]
:0040107C 56 push esi
:0040107D 8B31 mov esi, dword ptr [ecx]
:0040107F 57 push edi
:00401080 8B7C2414 mov edi, dword ptr [esp+14]
:00401084 C744241410000000 mov [esp+14], 00000010
:0040108C 8BDF mov ebx, edi
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004010AC(C)
|
:0040108E 3303 xor eax, dword ptr [ebx]
:00401090 50 push eax
:00401091 57 push edi
:00401092 8BE8 mov ebp, eax
:00401094 E867FFFFFF call 00401000<=========函数F(xl)，参见上面的分析
:00401099 8B4C241C mov ecx, dword ptr [esp+1C]
:0040109D 83C408 add esp, 00000008
:004010A0 33C6 xor eax, esi
:004010A2 83C304 add ebx, 00000004
:004010A5 49 dec ecx
:004010A6 8BF5 mov esi, ebp
:004010A8 894C2414 mov dword ptr [esp+14], ecx
:004010AC 75E0 jne 0040108E
:004010AE 8B4F40 mov ecx, dword ptr [edi+40]
:004010B1 8B5744 mov edx, dword ptr [edi+44]
:004010B4 33C8 xor ecx, eax
:004010B6 8B442418 mov eax, dword ptr [esp+18]
:004010BA 33D6 xor edx, esi
:004010BC 5F pop edi
:004010BD 8910 mov dword ptr [eax], edx
:004010BF 8B542418 mov edx, dword ptr [esp+18]
:004010C3 5E pop esi
:004010C4 5D pop ebp
:004010C5 890A mov dword ptr [edx], ecx
:004010C7 5B pop ebx
:004010C8 C3 ret
========================BF_Enc分析完毕================================
最后再来一个Init_Key的过程分析:
======================================================================
:00401130 51 push ecx
:00401131 53 push ebx
:00401132 55 push ebp
:00401133 56 push esi
:00401134 8B742414 mov esi, dword ptr [esp+14]
:00401138 57 push edi
:00401139 B898614000 mov eax, 00406198
:0040113E 8D4E48 lea ecx, dword ptr [esi+48]
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401158(C)
|
:00401141 BA00010000 mov edx, 00000100
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401151(C)
|
:00401146 8B38 mov edi, dword ptr [eax]==========>S-Box
:00401148 83C004 add eax, 00000004
:0040114B 8939 mov dword ptr [ecx], edi
:0040114D 83C104 add ecx, 00000004
:00401150 4A dec edx
:00401151 75F3 jne 00401146
:00401153 3D98714000 cmp eax, 00407198
:00401158 7CE7 jl 00401141
:0040115A 8B6C2420 mov ebp, dword ptr [esp+20]
:0040115E 8B54241C mov edx, dword ptr [esp+1C]
:00401162 BF50614000 mov edi, 00406150
:00401167 33C0 xor eax, eax
:00401169 2BFE sub edi, esi
:0040116B C744241012000000 mov [esp+10], 00000012
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004011AD(C)
|
:00401173 33C9 xor ecx, ecx
:00401175 C744242004000000 mov [esp+20], 00000004
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401197(C)
|
:0040117D 33DB xor ebx, ebx
:0040117F 8A1C10 mov bl, byte ptr [eax+edx]
:00401182 C1E108 shl ecx, 08
:00401185 0BCB or ecx, ebx
:00401187 40 inc eax
:00401188 3BC5 cmp eax, ebp
:0040118A 7C02 jl 0040118E
:0040118C 33C0 xor eax, eax
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040118A(C)
|
:0040118E 8B5C2420 mov ebx, dword ptr [esp+20]
:00401192 4B dec ebx
:00401193 895C2420 mov dword ptr [esp+20], ebx
:00401197 75E4 jne 0040117D
:00401199 8B1C37 mov ebx, dword ptr [edi+esi]
:0040119C 83C604 add esi, 00000004
:0040119F 33D9 xor ebx, ecx
:004011A1 8B4C2410 mov ecx, dword ptr [esp+10]
:004011A5 895EFC mov dword ptr [esi-04], ebx
:004011A8 49 dec ecx
:004011A9 894C2410 mov dword ptr [esp+10], ecx
:004011AD 75C4 jne 00401173
:004011AF 8B5C2418 mov ebx, dword ptr [esp+18]
:004011B3 33C0 xor eax, eax
:004011B5 89442420 mov dword ptr [esp+20], eax
:004011B9 8944241C mov dword ptr [esp+1C], eax
:004011BD 8BF3 mov esi, ebx
:004011BF BF09000000 mov edi, 00000009
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004011E8(C)
|
:004011C4 8D44241C lea eax, dword ptr [esp+1C]
:004011C8 8D4C2420 lea ecx, dword ptr [esp+20]
:004011CC 50 push eax
:004011CD 51 push ecx
:004011CE 53 push ebx
:004011CF E89CFEFFFF call 00401070================>BF_Enc(0,0,key)
:004011D4 8B54242C mov edx, dword ptr [esp+2C]
:004011D8 8B442428 mov eax, dword ptr [esp+28]
:004011DC 8916 mov dword ptr [esi], edx
:004011DE 894604 mov dword ptr [esi+04], eax
:004011E1 83C40C add esp, 0000000C
:004011E4 83C608 add esi, 00000008
:004011E7 4F dec edi
:004011E8 75DA jne 004011C4
:004011EA 8D734C lea esi, dword ptr [ebx+4C]
:004011ED BD04000000 mov ebp, 00000004
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040121E(C)
|
:004011F2 BF80000000 mov edi, 00000080
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0040121B(C)
|
:004011F7 8D4C241C lea ecx, dword ptr [esp+1C]
:004011FB 8D542420 lea edx, dword ptr [esp+20]
:004011FF 51 push ecx
:00401200 52 push edx
:00401201 53 push ebx
:00401202 E869FEFFFF call 00401070================>BF_Enc(xl,xr,key)
:00401207 8B44242C mov eax, dword ptr [esp+2C]
:0040120B 8B4C2428 mov ecx, dword ptr [esp+28]
:0040120F 8946FC mov dword ptr [esi-04], eax
:00401212 890E mov dword ptr [esi], ecx
:00401214 83C40C add esp, 0000000C
:00401217 83C608 add esi, 00000008
:0040121A 4F dec edi
:0040121B 75DA jne 004011F7
:0040121D 4D dec ebp
:0040121E 75D2 jne 004011F2
:00401220 5F pop edi
:00401221 5E pop esi
:00401222 5D pop ebp
:00401223 5B pop ebx
:00401224 59 pop ecx
:00401225 C3 ret
======================Init_Key过程分析完毕============================ ======================================================================
======================================================================
======================================================================
=============================分析详细总结=============================
======================================================================
======================================================================
=====>BF_Enc(ComputerID,key="ChinaCrackingGroup");
* Possible StringData Ref from Data Obj ->"ChinaCrackingGroup"
:00401434 6830804000 push 00408030
:00401439 6880894000 push 00408980
:0040143E E8EDFCFFFF call 00401130===>Init_Key
...........
:00401667 68EC994000 push 004099EC
:0040166C 68F0994000 push 004099F0
:00401671 6880894000 push 00408980
:00401676 E8F5F9FFFF call 00401070===>BF_Enc
=====>BF_Enc(ComputerID,key="ChinaCrackingGroup");
======================================================================
======================================================================
=====>BF_Dec(Code,key="CrackingForFun")
* Possible StringData Ref from Data Obj ->"CrackingForFun"
|
:004016C1 6844804000 push 00408044
:004016C6 6880894000 push 00408980
:004016CB E860FAFFFF call 00401130===>Init_Key
...........
:004015D9 51 push ecx
:004015DA 52 push edx
:004015DB 6880894000 push 00408980
:004015E0 E8EBFAFFFF call 004010D0===>BF_Dec
=====>BF_Dec(Code,key="CrackingForFun")
======================================================================
======================================================================
=====>BF_Enc("blowfish",key=ProductID)
:0040131F 6880894000 push 00408980
:00401324 E807FEFFFF call 00401130===>Init_Key
:00401329 68EC994000 push 004099EC
:0040132E 68F0994000 push 004099F0
:00401333 6880894000 push 00408980
:00401338 C705F0994000626C6F77 mov dword ptr [004099F0], 776F6C62
:00401342 C705EC99400066697368 mov dword ptr [004099EC], 68736966
:0040134C E81FFDFFFF call 00401070===>BF_Enc
=====>BF_Enc("blowfish",key=ProductID)
======================================================================
======================================================================
=====>最后分析结果
ComputerID=BF_Enc("blowfish",key=ProductID)
x=BF_Dec(Code,key="CrackingForFun")
y=BF_Enc(ComputerID,key="ChinaCrackingGroup")
x=y则注册成功；
我们要得到正确的注册码，那么
Code=BF_Enc(x,key="CrackingForFun");
=BF_Enc(y,key="CrackingForFun");
=BF_Enc(BF_Enc(ComputerID,key="ChinaCrackingGroup"),key="CrackingForFun");
如果更进一步，那么
=BF_Enc(BF_Enc(BF_Enc("blowfish",
key=ProductID),
key="ChinaCrackingGroup"),
key="CrackingForFun");
这样我们便可以编写它的keygen了
=====>
======================================================================
第四节 软件保护建议
本节将给出关于软件保护的一般性建议，这些都是无数人经验的总结。程序员在设计自己的保护方式时最好能够遵守这里给出的准则，这样会提高软件的保护强度。
（1）软件最终发行之前一定要将可执行程序进行加壳/压缩，使得解密者无法直接修改程序。如果时间允许并且有相应的技术能力，最好是设计自己的加壳/压缩方法。如果采用现成的加壳工具，最好不要选择流行的工具，因为这些工具已被广泛深入地加以研究，有了通用的脱壳/解压办法。另外，最好采用两种以上的不同的工具来对程序进行加壳/压缩，并尽可能地利用这些工具提供的反跟踪特性。
（2）增加对软件自身的完整性检查。这包括对磁盘文件和内存映像的检查，以防止有人未经允许修改程序以达到破解的目的。DLL和EXE之间可以互相检查完整性。
（3）不要采用一目了然的名字来命名函数和文件，如IsLicensedVersion( )、key.dat等。所有与软件保护相关的字符串都不能以明文形式直接存放在可执行文件中，这些字符串最好是动态生成。
（4）尽可能少地给用户提示信息，因为这些蛛丝马迹都可能导致解密者直接深入到保护的核心。比如，当检测到破解企图之后，不要立即给用户提示信息，而是在系统的某个地方做一个记号，随机地过一段时间后使软件停止工作，或者装作正常工作但实际上却在所处理的数据中加入了一些垃圾。
（5）将注册码、安装时间记录在多个不同的地方。
（7）检查注册信息和时间的代码越分散越好。不要调用同一个函数或判断同一个全局标志，因为这样做的话只要修改了一个地方则全部都被破解了。
（8）不要依赖于GetLocalTime( )、GetSystemTime( )这样众所周知的函数来获取系统时间，可以通过读取关键的系统文件的修改时间来得到系统时间的信息。
（9）如果有可能的话，可以采用联网检查注册码的方法，且数据在网上传输时要加密。
（10）除了加壳/压缩之外，还需要自己编程在软件中嵌入反跟踪的代码，以增加安全性。
（11）在检查注册信息的时候插入大量无用的运算以误导解密者，并在检查出错误的注册信息之后加入延时。
（12）给软件保护加入一定的随机性，比如除了启动时检查注册码之外，还可以在软件运行的某个时刻随机地检查注册码。随机值还可以很好地防止那些模拟工具，如软件狗模拟程序。
（13）如果采用注册码的保护方式，最好是一机一码，即注册码与机器特征相关，这样一台机器上的注册码就无法在另外一台机器上使用，可以防止有人散播注册码，并且机器号的算法不要太迷信硬盘序列号，因用相关工具可以修改其值。
（14）如果试用版与正式版是分开的两个版本，且试用版的软件没有某项功能，则不要仅仅使相关的菜单变灰，而是彻底删除相关的代码，使得编译后的程序中根本没有相关的功能代码。
（15）如果软件中包含驱动程序，则最好将保护判断加在驱动程序中。因为驱动程序在访问系统资源时受到的限制比普通应用程序少得多，这也给了软件设计者发挥的余地。
（16）如果采用keyfile的保护方式，则keyfile的尺寸不能太小，可将其结构设计得比较复杂，在程序中不同的地方对keyfile的不同部分进行复杂的运算和检查。
（17）自己设计的检查注册信息的算法不能过于简单，最好是采用比较成熟的密码学算法。可以在网上找到大量的源码。
3818
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
