加密解密、信息摘要常用算法收集~~

MD5算法研究 
综述  

　　md5的全称是message-digest algorithm 5（信息-摘要算法），在90年代初由mit laboratory for computer science和rsa data security inc的ronald l. rivest开发出来，经md2、md3和md4发展而来。它的作用是让大容量信息在用数字签名软件签署私人密匙前被"压缩"成一种保密的格式（就是把一个任意长度的字节串变换成一定长的大整数）。不管是md2、md4还是md5，它们都需要获得一个随机长度的信息并产生一个128位的信息摘要。虽然这些算法的结构或多或少有些相似，但md2的设计与md4和md5完全不同，那是因为md2是为8位机器做过设计优化的，而md4和md5却是面向32位的电脑。这三个算法的描述和c语言源代码在internet rfcs 1321中有详细的描述（http://www.ietf.org/rfc/rfc1321.txt），这是一份最权威的文档，由ronald l. rivest在1992年8月向ieft提交。

　　rivest在1989年开发出md2算法。在这个算法中，首先对信息进行数据补位，使信息的字节长度是16的倍数。然后，以一个16位的检验和追加到信息末尾。并且根据这个新产生的信息计算出散列值。后来，rogier和chauvaud发现如果忽略了检验和将产生md2冲突。md2算法的加密后结果是唯一的--既没有重复。

　　为了加强算法的安全性，rivest在1990年又开发出md4算法。md4算法同样需要填补信息以确保信息的字节长度加上448后能被512整除（信息字节长度mod 512 = 448）。然后，一个以64位二进制表示的信息的最初长度被添加进来。信息被处理成512位damg?rd/merkle迭代结构的区块，而且每个区块要通过三个不同步骤的处理。den boer和bosselaers以及其他人很快的发现了攻击md4版本中第一步和第三步的漏洞。dobbertin向大家演示了如何利用一部普通的个人电脑在几分钟内找到md4完整版本中的冲突（这个冲突实际上是一种漏洞，它将导致对不同的内容进行加密却可能得到相同的加密后结果）。毫无疑问，md4就此被淘汰掉了。

　　尽管md4算法在安全上有个这么大的漏洞，但它对在其后才被开发出来的好几种信息安全加密算法的出现却有着不可忽视的引导作用。除了md5以外，其中比较有名的还有sha-1、ripe-md以及haval等。

　　一年以后，即1991年，rivest开发出技术上更为趋近成熟的md5算法。它在md4的基础上增加了"安全-带子"（safety-belts）的概念。虽然md5比md4稍微慢一些，但却更为安全。这个算法很明显的由四个和md4设计有少许不同的步骤组成。在md5算法中，信息-摘要的大小和填充的必要条件与md4完全相同。den boer和bosselaers曾发现md5算法中的假冲突（pseudo-collisions），但除此之外就没有其他被发现的加密后结果了。

　　van oorschot和wiener曾经考虑过一个在散列中暴力搜寻冲突的函数（brute-force hash function），而且他们猜测一个被设计专门用来搜索md5冲突的机器（这台机器在1994年的制造成本大约是一百万美元）可以平均每24天就找到一个冲突。但单从1991年到2001年这10年间，竟没有出现替代md5算法的md6或被叫做其他什么名字的新算法这一点，我们就可以看出这个瑕疵并没有太多的影响md5的安全性。上面所有这些都不足以成为md5的在实际应用中的问题。并且，由于md5算法的使用不需要支付任何版权费用的，所以在一般的情况下（非绝密应用领域。但即便是应用在绝密领域内，md5也不失为一种非常优秀的中间技术），md5怎么都应该算得上是非常安全的了。

　　算法的应用

　　md5的典型应用是对一段信息（message）产生信息摘要（message-digest），以防止被篡改。比如，在unix下有很多软件在下载的时候都有一个文件名相同，文件扩展名为.md5的文件，在这个文件中通常只有一行文本，大致结构如：

　　　md5 (tanajiya.tar.gz) = 0ca175b9c0f726a831d895e269332461

　　这就是tanajiya.tar.gz文件的数字签名。md5将整个文件当作一个大文本信息，通过其不可逆的字符串变换算法，产生了这个唯一的md5信息摘要。如果在以后传播这个文件的过程中，无论文件的内容发生了任何形式的改变（包括人为修改或者下载过程中线路不稳定引起的传输错误等），只要你对这个文件重新计算md5时就会发现信息摘要不相同，由此可以确定你得到的只是一个不正确的文件。如果再有一个第三方的认证机构，用md5还可以防止文件作者的"抵赖"，这就是所谓的数字签名应用。

　　md5还广泛用于加密和解密技术上。比如在unix系统中用户的密码就是以md5（或其它类似的算法）经加密后存储在文件系统中。当用户登录的时候，系统把用户输入的密码计算成md5值，然后再去和保存在文件系统中的md5值进行比较，进而确定输入的密码是否正确。通过这样的步骤，系统在并不知道用户密码的明码的情况下就可以确定用户登录系统的合法性。这不但可以避免用户的密码被具有系统管理员权限的用户知道，而且还在一定程度上增加了密码被破解的难度。

　　正是因为这个原因，现在被黑客使用最多的一种破译密码的方法就是一种被称为"跑字典"的方法。有两种方法得到字典，一种是日常搜集的用做密码的字符串表，另一种是用排列组合方法生成的，先用md5程序计算出这些字典项的md5值，然后再用目标的md5值在这个字典中检索。我们假设密码的最大长度为8位字节（8 bytes），同时密码只能是字母和数字，共26+26+10=62个字符，排列组合出的字典的项数则是p(62,1)+p(62,2)….+p(62,8)，那也已经是一个很天文的数字了，存储这个字典就需要tb级的磁盘阵列，而且这种方法还有一个前提，就是能获得目标账户的密码md5值的情况下才可以。这种加密技术被广泛的应用于unix系统中，这也是为什么unix系统比一般操作系统更为坚固一个重要原因。

　　算法描述

　　对md5算法简要的叙述可以为：md5以512位分组来处理输入的信息，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。

　　在md5算法中，首先需要对信息进行填充，使其字节长度对512求余的结果等于448。因此，信息的字节长度（bits length）将被扩展至n*512+448，即n*64+56个字节（bytes），n为一个正整数。填充的方法如下，在信息的后面填充一个1和无数个0，直到满足上面的条件时才停止用0对信息的填充。然后，在在这个结果后面附加一个以64位二进制表示的填充前信息长度。经过这两步的处理，现在的信息字节长度=n*512+448+64=(n+1)*512，即长度恰好是512的整数倍。这样做的原因是为满足后面处理中对信息长度的要求。

　　md5中有四个32位被称作链接变量（chaining variable）的整数参数，他们分别为：a=0x01234567，b=0x89abcdef，c=0xfedcba98，d=0x76543210。

　　当设置好这四个链接变量后，就开始进入算法的四轮循环运算。循环的次数是信息中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的单位是弧度。(4294967296等于2的32次方) 
所有这些完成之后，将a、b、c、d分别加上a、b、c、d。然后用下一分组数据继续运行算法，最后的输出是a、b、c和d的级联。

　　当你按照我上面所说的方法实现md5算法以后，你可以用以下几个信息对你做出来的程序作一个简单的测试，看看程序有没有错误。

　　　md5 ("") = d41d8cd98f00b204e9800998ecf8427e 
　　　md5 ("a") = 0cc175b9c0f1b6a831c399e269772661 
　　　md5 ("abc") = 900150983cd24fb0d6963f7d28e17f72 
　　　md5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0 
　　　md5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b 
　　　md5 ("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789") = 
d174ab98d277d9f5a5611c2c9f419d9f 
　　　md5 ("123456789012345678901234567890123456789012345678901234567890123456789 
01234567890") = 57edf4a22be3c955ac49da2e2107b67a

　　如果你用上面的信息分别对你做的md5算法实例做测试，最后得出的结论和标准答案完全一样，那我就要在这里象你道一声祝贺了。要知道，我的程序在第一次编译成功的时候是没有得出和上面相同的结果的。

　　md5的安全性

　　md5相对md4所作的改进：

　　　1. 增加了第四轮；

　　　2. 每一步均有唯一的加法常数；

　　　3. 为减弱第二轮中函数g的对称性从(x&y)|(x&z)|(y&z)变为(x&z)|(y&(~z))；

　　　4. 第一步加上了上一步的结果，这将引起更快的雪崩效应；

　　　5. 改变了第二轮和第三轮中访问消息子分组的次序，使其更不相似；

　　　6. 近似优化了每一轮中的循环左移位移量以实现更快的雪崩效应。各轮的位移量互不相同。

[06/22-12:58:29] 
加密算法之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采用比特长的密钥，其他实体使用比特的密钥。

[06/22-12:58:37] 
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算法在应用上的误区，留下了被人攻击、被人破译的极大隐患。

[06/22-12:58:52] 
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算法却作不到。

[06/22-12:59:06] 
加密算法之ElGamal算法 
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算法演 
变而来。

[06/22-12:59:27] 
BLOWFISH算法

作　者：夜月 
联　系：[email protected] 
时　间：2001年10月6日 
范　例：BlowFish's CrackMe1 
注册机：Bfkeygen

一、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 [email protected] 
;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 WORD,WORD,WORD,WORD 
_Math PROTO WORD,WORD,WORD 
BlowFish_En PROTO WORD,WORD 
BlowFish_Fun PROTO WORD 
BlowFish_Init PROTO WORD,WORD

.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,BfNumWORD 
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,highbfWORD,lowbfWORD 
LOCAL num WORD 
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,PWDWORD,len_PWDWORD 
LOCAL pbox_num18WORD 
LOCAL pbox_num4 WORD 
LOCAL snum WORD 
;初始化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,hWndWORD,wMsgWORD,wParamWORD,lParamWORD 
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

[06/22-12:59:35] 
ASProtect的加密算法初步分析

原来ASProtect的几个函数的作用对保护强度提高不小。一改以前我见过的壳重技巧轻算法的毛病，的确在有些方面值得学习。

其利用的原理如下： 
1)程序在编程时可以根据需要选择使用ASProtect提供的几个函数。 
比如： 
SetRegistrationKey(...), 
GetRegistrationInformation(...), 
GetHardwareID(...)

这几个函数由于使用了导出方式的声明所以会在ExportTable中出现，ASProtect在加壳时可以通过分析ExportTable识别出程序使用了哪些其提供的函数，从而对这些函数的入口进行挂钩，从而使其加壳后的外壳代码可以象回调函数一样调用这些函数与程序进行通信。 
比如见以下代码： 
0041333E loc_41333E: ; CODE XREF: sub_413253+B0j 
0041333E mov eax, ds:4155CCh 
00413343 cmp dword ptr [eax+0Ch], 0 
00413347 jz short loc_413360 
00413349 mov eax, ds:41555Ch 
0041334E mov eax, [eax] 
00413350 call @System@@LStrToPChar$qqrv ; System __linkproc__ LStrToPChar(void) 
00413355 push eax 
00413356 mov eax, ds:4155CCh 
0041335B mov eax, [eax+0Ch] 
0041335E call eax 
00413360 
00413360 loc_413360: ; CODE XREF: sub_413253+F4j 
00413360 mov eax, ds:4155CCh 
00413365 cmp dword ptr [eax+30h], 0 ; eax 是一内部结构指针 
00413369 jz short loc_413389 
0041336B push 41105Ch 
00413370 mov eax, ds:4155CCh 
00413375 mov eax, [eax+30h] 
00413378 call eax ; 这里将调用 GetDecryptProc(...) 
0041337A push 41105Ch 
0041337F mov eax, ds:4155CCh

2)程序在编程时还可以加入ASProtect提供的两个宏定义，这两个宏定义实际上将起到特殊的标志作用，有点类似"块开始"和"块结束"的作用。在ASProtect将在加壳时将对"这些块"中的代码进行加密。对这些代码块的加、解密使用了的密码学算法。目前还不十分清楚其使用的算法，初步分析这里可能用到了TWOFISH。因为发现了一些特征：

初始化部分有以下常数设置： 
0040C4AE mov dword ptr [ebx+48h], 67452301h 
0040C4B5 mov dword ptr [ebx+4Ch], 0EFCDAB89h 
0040C4BC mov dword ptr [ebx+50h], 98BADCFEh 
0040C4C3 mov dword ptr [ebx+54h], 10325476h 
0040C4CA mov dword ptr [ebx+58h], 0C3D2E1F0h 
0040C4D1 mov dword ptr [ebx+5Ch], 76543210h 
0040C4D8 mov dword ptr [ebx+60h], 0FEDCBA98h 
0040C4DF mov dword ptr [ebx+64h], 89ABCDEFh 
0040C4E6 mov dword ptr [ebx+68h], 1234567h 
0040C4ED mov dword ptr [ebx+6Ch], 3C2D1E0Fh

而运算部分有大量类似MD5算法的运算。由于代码太长，不列举了。

3)在ASProtect中我们看到其提供了Registration_Keys加密方式。ASProtect可以对你提供的"Registration_Information"进行加密，形成"Registeration_Key"，(按照帮助中介绍的你还可以使用自己的"加解密算法"，但是RegKey必须至少173个字符，才有安全性)。这个"RegKey"将以注册表文件(.reg)文件方式保存。在加壳后的外壳代码运行时将解密"RegKey"从而得到"RegInfo"，当然这分为两种方式：一种方式，程序编程时使用了其提供的回调函数SetRegistrationKey(...)，那么外壳代码运行时将调用该函数从而得到"RegKey"来解密出"RegInfo"，如果程序没有使用这个函数，外壳代码将从注册表中相应键名处提取键值作为"RegKey"来解密出"RegInfo"。初步分析其可能使用了RSA算法。

其解密部分的代码： 
0040B4D4 loc_40B4D4: ; CODE XREF: license+156j 
0040B4D4 ; license+15Fj 
0040B4D4 lea edi, [ebp+lpInterBlock] 
0040B4DA inc edi 
0040B4DB mov esi, edi 
0040B4DD push esi 
0040B4DE lea eax, [ebp+lpInterStruct+8] 
0040B4E4 push eax 
0040B4E5 lea eax, [ebp+lpInterStruct+88h] 
0040B4EB push eax 
0040B4EC push esi 
0040B4ED call decrypt_engine ; Criper Text to Plain Text...

从 decrypt_engine 函数的入口参数看有四个： 
1)加密数据地址指针....(函数按每一块进行解密).....即 m 
2)可能是RSA.N 
3)可能是RSA.E 
4)用于输出解密数据地址指针....

目前还有几个问题还没有来得及分析： 
1)还没有见到TEA算法，不过在CASPR中介绍中至少提到这个算法，不知道这个算法在哪里，用于作什么？

2)在我了解了ASProtect会利用宏定义定义出"代码块"以后，我想象ASProtect中其会把"代码块"挖出来"，与"RegInfo"一起加密形式成"RegKey"。不过实际发现这些"代码块"并没有被"挖"出来，而是使用一种算法(可能是TWOFISH)解密，不知道这个KEY到底保存在哪里？不知道是否保存在"RegKey"中。我想大概如此。^_^

我想我们可以把ASProtect看成一个"软锁"。"锁"中的数据包括用于解密的代码块的KEY和用于解密"RegInfo"的KEY，即我们所见到的字符串形式的"RegKey"。在外壳代码运行时ASProtect将提取"锁"中的数据用于解密。

如果某程序分为"注册版本"和"试用版本"，其使用ASProtect外壳+内部函数组合方式加密。其注册版本将提供.reg注册表文件形式的"RegKey"作为开锁的"钥匙"，那么我们能否在没有"钥匙"的情况下破门而入呢？

由于RegKey中包含了用于解密程序中提取出来的"代码块"的KEY，那么在没有RegKey的情况下自然我们也就缺少了这个KEY，因此程序中的被提取出来的"代码块"就无法正确解密。如果在此情况下脱壳，那么那些加密了的代码块中的数据依然是无用的数据，因此脱壳的软件就成了破碎的脱壳版本了。因此在没有钥匙的情况下看来破门而入的想法不太乐观。

[06/22-13:00:07] 
Hash 算法及其应用

--------------- 
什么是 Hash 
Hash 的重要特性 
Hash 函数的实现 
主要的 Hash 算法 
Hash 算法的安全问题 
Hash 算法的应用 
结 论 
---------------

Hash，一般翻译做“散列”，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。

数学表述为：h = H(M) ，其中H( )--单向散列函数，M--任意长度明文，h--固定长度散列值。

在信息安全领域中应用的Hash算法，还需要满足其他关键特性：

第一当然是单向性(one-way)，从预映射，能够简单迅速的得到散列值，而在计算上不可能构造一个预映射，使其散列结果等于某个特定的散列值，即构造相应的M=H-1(h)不可行。这样，散列值就能在统计上唯一的表征输入值，因此，密码学上的 Hash 又被称为"消息摘要(message digest)"，就是要求能方便的将"消息"进行"摘要"，但在"摘要"中无法得到比"摘要"本身更多的关于"消息"的信息。

第二是抗冲突性(collision-resistant)，即在统计上无法产生2个散列值相同的预映射。给定M，计算上无法找到M'，满足H(M)=H(M') ，此谓弱抗冲突性；计算上也难以寻找一对任意的M和M'，使满足H(M)=H(M') ，此谓强抗冲突性。要求"强抗冲突性"主要是为了防范所谓"生日攻击(birthday attack)"，在一个10人的团体中，你能找到和你生日相同的人的概率是2.4%，而在同一团体中，有2人生日相同的概率是11.7%。类似的，当预映射的空间很大的情况下，算法必须有足够的强度来保证不能轻易找到"相同生日"的人。

第三是映射分布均匀性和差分分布均匀性，散列结果中，为 0 的 bit 和为 1 的 bit ，其总数应该大致相等；输入中一个 bit 的变化，散列结果中将有一半以上的 bit 改变，这又叫做"雪崩效应(avalanche effect)"；要实现使散列结果中出现 1bit 的变化，则输入中至少有一半以上的 bit 必须发生变化。其实质是必须使输入中每一个 bit 的信息，尽量均匀的反映到输出的每一个 bit 上去；输出中的每一个 bit，都是输入中尽可能多 bit 的信息一起作用的结果。

Damgard 和 Merkle 定义了所谓“压缩函数(compression function)”，就是将一个固定长度输入，变换成较短的固定长度的输出，这对密码学实践上 Hash 函数的设计产生了很大的影响。Hash函数就是被设计为基于通过特定压缩函数的不断重复“压缩”输入的分组和前一次压缩处理的结果的过程，直到整个消息都被压缩完毕，最后的输出作为整个消息的散列值。尽管还缺乏严格的证明，但绝大多数业界的研究者都同意，如果压缩函数是安全的，那么以上述形式散列任意长度的消息也将是安全的。这就是所谓 Damgard/Merkle 结构：

在下图中，任意长度的消息被分拆成符合压缩函数输入要求的分组，最后一个分组可能需要在末尾添上特定的填充字节，这些分组将被顺序处理，除了第一个消息分组将与散列初始化值一起作为压缩函数的输入外，当前分组将和前一个分组的压缩函数输出一起被作为这一次压缩的输入，而其输出又将被作为下一个分组压缩函数输入的一部分，直到最后一个压缩函数的输出，将被作为整个消息散列的结果。

MD5 和 SHA1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。

1) MD4 
MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。它的安全性不像RSA那样基于数学假设，尽管 Den Boer、Bosselaers 和 Dobbertin 很快就用分析和差分成功的攻击了它3轮变换中的 2 轮，证明了它并不像期望的那样安全，但它的整个算法并没有真正被破解过，Rivest 也很快进行了改进。

下面是一些MD4散列结果的例子：

MD4 ("") = 31d6cfe0d16ae931b73c59d7e0c089c0 
MD4 ("a") = bde52cb31de33e46245e05fbdbd6fb24 
MD4 ("abc") = a448017aaf21d8525fc10ae87aa6729d 
MD4 ("message digest") = d9130a8164549fe818874806e1c7014b 
MD4 ("abcdefghijklmnopqrstuvwxyz") = d79e1c308aa5bbcdeea8ed63df412da9 
MD4 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = 043f8582f241db351ce627e153e7f0e4 
MD4 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = e33b4ddc9c38f2199c3e7b164fcc0536

2) MD5 
MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。它较MD4所做的改进是：

1) 加入了第四轮 
2) 每一步都有唯一的加法常数； 
3) 第二轮中的G函数从((X ∧ Y) ∨ (X ∧ Z) ∨ (Y ∧ Z)) 变为 ((X ∧ Z) ∨ (Y ∧ ～Z))以减小其对称性； 
4) 每一步都加入了前一步的结果，以加快"雪崩效应"； 
5) 改变了第2轮和第3轮中访问输入子分组的顺序，减小了形式的相似程度； 
6) 近似优化了每轮的循环左移位移量，以期加快"雪崩效应"，各轮的循环左移都不同。 
尽管MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好。

消息首先被拆成若干个512位的分组，其中最后512位一个分组是“消息尾+填充字节(100…0)+64 位消息长度”，以确保对于不同长度的消息，该分组不相同。64位消息长度的限制导致了MD5安全的输入长度必须小于264bit，因为大于64位的长度信息将被忽略。而4个32位寄存器字初始化为A=0x01234567，B=0x89abcdef，C=0xfedcba98，D=0x76543210，它们将始终参与运算并形成最终的散列结果。

接着各个512位消息分组以16个32位字的形式进入算法的主循环，512位消息分组的个数据决定了循环的次数。主循环有4轮，每轮分别用到了非线性函数

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) = X ⊕ (Y ∨ ～Z) 
这4轮变换是对进入主循环的512位消息分组的16个32位字分别进行如下操作：将A、B、C、D的副本a、b、c、d中的3个经F、G、H、I运算后的结果与第4个相加，再加上32位字和一个32位字的加法常数，并将所得之值循环左移若干位，最后将所得结果加上a、b、c、d之一，并回送至ABCD，由此完成一次循环。

所用的加法常数由这样一张表T[i]来定义，其中i为1…64，T[i]是i的正弦绝对值之4294967296次方的整数部分，这样做是为了通过正弦函数和幂函数来进一步消除变换中的线性性。

当所有512位分组都运算完毕后，ABCD的级联将被输出为MD5散列的结果。下面是一些MD5散列结果的例子：

MD5 ("") = d41d8cd98f00b204e9800998ecf8427e 
MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661 
MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72 
MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0 
MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b 
MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f 
MD5 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a 
参考相应RFC文档可以得到MD4、MD5算法的详细描述和算法的C源代码。

3) SHA1 及其他 
SHA1是由NIST NSA设计为同DSA一起使用的，访问http://www.itl.nist.gov/fipspubs可以得到它的详细规范--[/url]"FIPS PUB 180-1 SECURE HASH STANDARD"。它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。因为它将产生160bit的散列值，因此它有5个参与运算的32位寄存器字，消息分组和填充方式与MD5相同，主循环也同样是4轮，但每轮进行20次操作，非线性运算、移位和加法运算也与MD5类似，但非线性函数、加法常数和循环左移操作的设计有一些区别，可以参考上面提到的规范来了解这些细节。下面是一些SHA1散列结果的例子：

SHA1 ("abc") = a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d 
SHA1 ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e44 1c3bd26e baae4aa1 f95129e5 e54670f1
其他一些知名的Hash算法还有MD2、N-Hash、RIPE-MD、HAVAL等等。上面提到的这些都属于"纯"Hash算法。还有另2类Hash算法，一类就是基于对称分组算法的单向散列算法，典型的例子是基于DES的所谓Davies-Meyer算法，另外还有经IDEA改进的Davies-Meyer算法，它们两者目前都被认为是安全的算法。另一类是基于模运算/离散对数的，也就是基于公开密钥算法的，但因为其运算开销太大，而缺乏很好的应用前景。

没有通过分析和差分攻击考验的算法，大多都已经夭折在实验室里了，因此，如果目前流行的Hash算法能完全符合密码学意义上的单向性和抗冲突性，就保证了只有穷举，才是破坏Hash运算安全特性的唯一方法。为了对抗弱抗冲突性，我们可能要穷举个数和散列值空间长度一样大的输入，即尝试2^128或2^160个不同的输入，目前一台高档个人电脑可能需要10^25年才能完成这一艰巨的工作，即使是最高端的并行系统，这也不是在几千年里的干得完的事。而因为"生日攻击"有效的降低了需要穷举的空间，将其降低为大约1.2*2^64或1.2*2^80，所以，强抗冲突性是决定Hash算法安全性的关键。

在NIST新的 Advanced Encryption Standard (AES)中，使用了长度为128、192、256bit 的密钥，因此相应的设计了 SHA256、SHA384、SHA512，它们将提供更好的安全性。

Hash算法在信息安全方面的应用主要体现在以下的3个方面：

1) 文件校验 
我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。

MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。它常被用在下面的2种情况下：

第一是文件传送后的校验，将得到的目标文件计算 md5 checksum，与源文件的md5 checksum 比对，由两者 md5 checksum 的一致性，可以从统计上保证2个文件的每一个码元也是完全相同的。这可以检验文件传输过程中是否出现错误，更重要的是可以保证文件在传输过程中未被恶意篡改。一个很典型的应用是ftp服务，用户可以用来保证多次断点续传，特别是从镜像站点下载的文件的正确性。

更出色的解决方法是所谓的代码签名，文件的提供者在提供文件的同时，提供对文件Hash值用自己的代码签名密钥进行数字签名的值，及自己的代码签名证书。文件的接受者不仅能验证文件的完整性，还可以依据自己对证书签发者和证书拥有者的信任程度，决定是否接受该文件。浏览器在下载运行插件和java小程序时，使用的就是这样的模式。

第二是用作保存二进制文件系统的数字指纹，以便检测文件系统是否未经允许的被修改。不少系统管理/系统安全软件都提供这一文件系统完整性评估的功能，在系统初始安装完毕后，建立对文件系统的基础校验和数据库，因为散列校验和的长度很小，它们可以方便的被存放在容量很小的存储介质上。此后，可以定期或根据需要，再次计算文件系统的校验和，一旦发现与原来保存的值有不匹配，说明该文件已经被非法修改，或者是被病毒感染，或者被木马程序替代。TripWire就提供了一个此类应用的典型例子。

更完美的方法是使用"MAC"。"MAC" 是一个与Hash密切相关的名词，即信息鉴权码(Message Authority Code)。它是与密钥相关的Hash值，必须拥有该密钥才能检验该Hash值。文件系统的数字指纹也许会被保存在不可信任的介质上，只对拥有该密钥者提供可鉴别性。并且在文件的数字指纹有可能需要被修改的情况下，只有密钥的拥有者可以计算出新的散列值，而企图破坏文件完整性者却不能得逞。

2) 数字签名 
Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。

在这种签名协议中，双方必须事先协商好双方都支持的Hash函数和签名算法。

签名方先对该数据文件进行计算其散列值，然后再对很短的散列值结果--如Md5是16个字节，SHA1是20字节，用非对称算法进行数字签名操作。对方在验证签名时，也是先对该数据文件进行计算其散列值，然后再用非对称算法验证数字签名。

对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点：

首先，数据文件本身可以同它的散列值分开保存，签名验证也可以脱离数据文件本身的存在而进行。

再者，有些情况下签名密钥可能与解密密钥是同一个，也就是说，如果对一个数据文件签名，与对其进行非对称的解密操作是相同的操作，这是相当危险的，恶意的破坏者可能将一个试图骗你将其解密的文件，充当一个要求你签名的文件发送给你。因此，在对任何数据文件进行数字签名时，只有对其Hash值进行签名才是安全的。

3) 鉴权协议 
如下的鉴权协议又被称作"挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。

需要鉴权的一方，向将被鉴权的一方发送随机串（“挑战”），被鉴权方将该随机串和自己的鉴权口令字一起进行 Hash 运算后，返还鉴权方，鉴权方将收到的Hash值与在己端用该随机串和对方的鉴权口令字进行 Hash 运算的结果相比较（“认证”），如相同，则可在统计上认为对方拥有该口令字，即通过鉴权。

POP3协议中就有这一应用的典型例子：

S: +OK POP3 server ready <[email protected]> 
C: APOP mrose c4c9334bac560ecc979e58001b3e22fb 
S: +OK maildrop has 1 message (369 octets) 
在上面的一段POP3协议会话中，双方都共享的对称密钥（鉴权口令字）是tanstaaf，服务器发出的挑战是<[email protected]>，客户端对挑战的应答是MD5("<[email protected]>tanstaaf") = c4c9334bac560ecc979e58001b3e22fb，这个正确的应答使其通过了认证。

散列算法长期以来一直在计算机科学中大量应用，随着现代密码学的发展，单向散列函数已经成为信息安全领域中一个重要的结构模块，我们有理由深入研究其设计理论和应用方法。