md5算法实现

md5算法简要叙述：
        md5以64Bytes分组来处理输入的信息，而每一分组又被划分为16个4Bytes子分组，经过一系列处理后，算法的输出为四个4Bytes分组的级联。
        拿到待加密信息后，首先需要在末尾填充一个0x80，以及无数个0x00，使得填充后信息的总长度（Bytes）对64求余的结果等于56。之后再填充一个以8Bytes表示的填充前信息长度（bits）。
        接下来进入主循环的四轮运算。每一轮都会调用16次相同的函数，但参数不同。每一轮所掉用的函数均不相同。下面直接来看看主循环所掉用的所有函数：
        第一轮：
        FF(a, b, c, d, *M[0], 7, 0xd76aa478);
        FF(d, a, b, c, *M[1], 12, 0xe8c7b756);
        FF(c, d, a, b, *M[2], 17, 0x242070db);
        FF(b, c, d, a, *M[3], 22, 0xc1bdceee);
        FF(a, b, c, d, *M[4], 7, 0xf57c0faf);
        FF(d, a, b, c, *M[5], 12, 0x4787c62a);
        FF(c, d, a, b, *M[6], 17, 0xa8304613);
        FF(b, c, d, a, *M[7], 22, 0xfd469501);
        FF(a, b, c, d, *M[8], 7, 0x698098d8);
        FF(d, a, b, c, *M[9], 12, 0x8b44f7af);
        FF(c, d, a, b, *M[10], 17, 0xffff5bb1);
        FF(b, c, d, a, *M[11], 22, 0x895cd7be);
        FF(a, b, c, d, *M[12], 7, 0x6b901122);
        FF(d, a, b, c, *M[13], 12, 0xfd987193);
        FF(c, d, a, b, *M[14], 17, 0xa679438e);
        FF(b, c, d, a, *M[15], 22, 0x49b40821);
        第二轮：
        GG(a, b, c, d, *M[1], 5, 0xf61e2562);
        GG(d, a, b, c, *M[6], 9, 0xc040b340);
        GG(c, d, a, b, *M[11], 14, 0x265e5a51);
        GG(b, c, d, a, *M[0], 20, 0xe9b6c7aa);
        GG(a, b, c, d, *M[5], 5, 0xd62f105d);
        GG(d, a, b, c, *M[10], 9, 0x02441453);
        GG(c, d, a, b, *M[15], 14, 0xd8a1e681);
        GG(b, c, d, a, *M[4], 20, 0xe7d3fbc8);
        GG(a, b, c, d, *M[9], 5, 0x21e1cde6);
        GG(d, a, b, c, *M[14], 9, 0xc33707d6);
        GG(c, d, a, b, *M[3], 14, 0xf4d50d87);
        GG(b, c, d, a, *M[8], 20, 0x455a14ed);
        GG(a, b, c, d, *M[13], 5, 0xa9e3e905);
        GG(d, a, b, c, *M[2], 9, 0xfcefa3f8);
        GG(c, d, a, b, *M[7], 14, 0x676f02d9);
        GG(b, c, d, a, *M[12], 20, 0x8d2a4c8a);
        第三轮：
        HH(a, b, c, d, *M[5], 4, 0xfffa3942);
        HH(d, a, b, c, *M[8], 11, 0x8771f681);
        HH(c, d, a, b, *M[11], 16, 0x6d9d6122);
        HH(b, c, d, a, *M[14], 23, 0xfde5380c);
        HH(a, b, c, d, *M[1], 4, 0xa4beea44);
        HH(d, a, b, c, *M[4], 11, 0x4bdecfa9);
        HH(c, d, a, b, *M[7], 16, 0xf6bb4b60);
        HH(b, c, d, a, *M[10], 23, 0xbebfbc70);
        HH(a, b, c, d, *M[13], 4, 0x289b7ec6);
        HH(d, a, b, c, *M[0], 11, 0xeaa127fa);
        HH(c, d, a, b, *M[3], 16, 0xd4ef3085);
        HH(b, c, d, a, *M[6], 23, 0x04881d05);
        HH(a, b, c, d, *M[9], 4, 0xd9d4d039);
        HH(d, a, b, c, *M[12], 11, 0xe6db99e5);
        HH(c, d, a, b, *M[15], 16, 0x1fa27cf8);
        HH(b, c, d, a, *M[2], 23, 0xc4ac5665);
        第四轮：
        II(a, b, c, d, *M[0], 6, 0xf4292244);
        II(d, a, b, c, *M[7], 10, 0x432aff97);
        II(c, d, a, b, *M[14], 15, 0xab9423a7);
        II(b, c, d, a, *M[5], 21, 0xfc93a039);
        II(a, b, c, d, *M[12], 6, 0x655b59c3);
        II(d, a, b, c, *M[3], 10, 0x8f0ccc92);
        II(c, d, a, b, *M[10], 15, 0xffeff47d);
        II(b, c, d, a, *M[1], 21, 0x85845dd1);
        II(a, b, c, d, *M[8], 6, 0x6fa87e4f);
        II(d, a, b, c, *M[15], 10, 0xfe2ce6e0);
        II(c, d, a, b, *M[6], 15, 0xa3014314);
        II(b, c, d, a, *M[13], 21, 0x4e0811a1);
        II(a, b, c, d, *M[4], 6, 0xf7537e82);
        II(d, a, b, c, *M[11], 10, 0xbd3af235);
        II(c, d, a, b, *M[2], 15, 0x2ad7d2bb);
        II(b, c, d, a, *M[9], 21, 0xeb86d391);
        可以看到，虽然有4种函数，但参数的种类均一致。下面就来说说每个参数的来历。
        · 前四个参数a，b，c，d。它们第一次进入主循环的初始值分别为（注意：这里为大端字节序表示，通常我们用的计算机为小端系统）：
          a = 0x1234567
          b = 0x89ABCDEF 
          c = 0xFEDCBA98
          d = 0x7654321
        之后再进入主循环时，它们的值为上一个64Bytes分组的计算结果。
        ·第五个参数*M[j]。它分别代表了每个子分组（这里我使用了数组指针 unsigned int *M[16]）。
        ·第六个参数是个常数，函数中控制数据循环左移多少位。
        ·第七个参数也是常数，不过他有来历。它是2^32*abs(sin(i))的整数部分，i从1~64。
        接下来再来看看每个函数是如何实现的。
        #defineFF(arg1,arg2, arg3, arg4, arg5, arg6, arg7)\
                           arg1 = arg2 + ((arg1 +F(arg2, arg3, arg4) + arg5 + arg7) << arg6)
        #defineGG(arg1,arg2, arg3, arg4, arg5, arg6, arg7) \
                            arg1 = arg2 + ((arg1 +G(arg2, arg3, arg4) + arg5 + arg7) << arg6)
        #defineHH(arg1,arg2, arg3, arg4, arg5, arg6, arg7) \
                            arg1 = arg2 + ((arg1 +H(arg2, arg3, arg4) + arg5 + arg7) << arg6)
        #define II(arg1,arg2, arg3, arg4, arg5, arg6, arg7) \
                         arg1 = arg2 + ((arg1 +I(arg2, arg3, arg4) + arg5 + arg7) << arg6)
        大部分都是一样的，区别只在于内部调用的F()、G()、H()、I()。
        最后再来看看F()、G()、H()、I()这四个函数是如何实现的。
        #define F(X, Y, Z) (((X) & (Y)) | ((~X) & (Z)))
        #define G(X, Y, Z) (((X) & (Z)) | ((Y) & (~Z)))
        #define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
        #define I(X, Y, Z) ((Y) ^ ((X) | (~Z)))
        经过主循环的这四轮运算，将a、b、c、d加回到上一个64Bytes分组的运算结果上（第一次进主循环的话，上一次的运算结果就是初始值），就得到了当前64Bytes分组的运算结果。
        所有分组计算完之后，最后的运算结果如果为大端系统，直接将a、b、c、d连在一起输出就好了；如果为小端系统，需要进行转换。


算法实现步骤：
1、初始化a、b、c、d。
2、从标准输入读取待加密字符串，每次读取64Bytes。
3、因为填充的信息在待加密信息的末尾，所以只要还没读到待加密信息末尾，前面的64Bytes分组（零个或多个）正常进行主循环运算。
4、当读到的待加密信息不足64Bytes时，需要对待加密信息进行填充。填充后继续进行主循环运算。
5、小端系统将运算结果转换后输出；大端系统直接级联输出。


算法实现注意事项：
1、对于小端系统，a、b、c、d的初始值为：
      a = 0x67452301
      b = 0xEFCDAB89
      c = 0x98BADCFE
      d = 0x10325476
2、填充到待加密信息末尾的填充前长度是以bit为单位的。比如填充前信息长度（也就是待加密信息的长度）为1Bytes，那么需要填充的值是8，而不是1。我在编码过程中就在这里摔过大马爬，-,.-。
3、在进行主循环的运算时，如果上一次的计算结果为A、B、C、D。那么运算的前后应该如下这样：
      unsigned int a = 0, b = 0, c = 0, d = 0;

      a = A; b = B; c = C; d = D;
      a、b、c、d进入主循环进行运算，在运算过程中它们的值会改变。
      A += a; B += b; C += c; D += d;
      新的A、B、C、D才是这次的运算结果，而不是a、b、c、d，-,.-。（好吧，我承认，当时我还把a、b、c、d保存起来作为下一次的运算结果，-,.-）
4、在主循环中，FF()、GG()、HH()、II()函数中的移位操作是循环左移！而不是左移，-,.-。
5、如果填充前的待加密信息总长度（Bytes）对64求余的结果正好是56，那还需不需要填充那个0x80和无数个0x00？回答是肯定的。实际情况是，填充一个0x80，然后填充63个0x00，最后再填充8Bytes的填充前长度（bits）。看起来像没事儿找事儿，不过这确实是必要的，-,.-。