C++实现MD5加密

最新推荐文章于 2024-01-31 10:04:04 发布

九日王朝

最新推荐文章于 2024-01-31 10:04:04 发布

阅读量5.3k

点赞数 4

分类专栏： C/C++ 文章标签： C++ MD5

本文链接：https://blog.csdn.net/sm9sun/article/details/53316621

版权

C/C++ 专栏收录该内容

49 篇文章 7 订阅

订阅专栏

MD5相信绝大数人都接触过，也有无数人问过我怎么做MD5解密。

当然，我们知道MD5自然没有办法解密，所以解密也不过是大量已知数据做成字典而已，MD5是不可能通过逆向计算解密的。

为什么呢？因为哈希冲突。

举个简单的例子：

比如说我给定10个位置来存放东西，假设我的对应方法是简单的求余%。

那么11%10，21%10的结果就会相同。这样就造成了冲突。

MD5也是如此，我们常用的MD5位数是32位，那么对于不同长度的数据，通过指定算法让他们变成32位，就必然存在这种冲突

这就是MD5无法逆向计算的原因，当然，大部分加密算法目的就是让你不可逆，否则就很难达到真正的安全。

简单说明一下MD5的处理步骤：

MD5以512位分组来处理输入文本，每一分组又划分为16个32位子分组。算法的输出由四个32位分组组成，将它们级联形成一个128位散列值。

①如果输入信息的长度(bit)对512求余的结果不等于448，就需要填充使得对512求余的结果等于448。填充的方法是填充一个1和n个0。填充完后，信息的长度就为N*512+448(bit)

也就是说我们将一组信息分成n个（512位）组，每组的计算都要引入前一组的结果值，这样就保证了所有的文本都参与了实际运算。

②记录信息长度：用64位来存储填充前信息长度。这64位加在第一步结果的后面，这样信息长度就变为N*512+448+64=(N+1)*512位，

这也解释了为什么第一步要求余448，因为要用最后的64位来存储填充信息长度

③初始的128位值为初试链接变量，这些参数用于第一轮的运算，以大端字节序来表示，他们分别为： A=0x01234567，B=0x89ABCDEF，C=0xFEDCBA98，D=0x76543210。
每一个变量给出的数值是高字节存于内存低地址，低字节存于内存高地址，即大端字节序。在程序中变量A、B、C、D的值分别为0x67452301，0xEFCDAB89，0x98BADCFE，0x10325476

④处理分组数据
每一分组的算法流程如下：第一分组需要将上面四个链接变量复制到另外四个变量中：A到a，B到b，C到c，D到d。从第二分组开始的变量为上一分组的运算结果，即A = a， B = b， C = c， D = d。主循环有四轮（MD4只有三轮），每轮循环都很相似。第一轮进行16次操作。每次操作对a、b、c和d中的其中三个作一次非线性函数运算，然后将所得结果加上第四个变量，文本的一个子分组和一个常数。再将所得结果向左环移一个不定的数，并加上a、b、c或d中之一。最后用该结果取代a、b、c或d中之一。

⑤输出a、b、c和d的级联。

四轮运算：

第一轮
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 )
所有这些完成之后，将a、b、c、d分别在原来基础上再加上A、B、C、D。
即a = a + A，b = b + B，c = c + C，d = d + D
然后用下一分组数据继续运行以上算法。

完整C++代码

文本加密：

#include   <stdio.h>  
#include   <stdlib.h> 
#include   <time.h>  
#include   <string.h>  

typedef   unsigned   char   *POINTER;  
typedef   unsigned   short   int   UINT2;  
typedef   unsigned   long   int   UINT4;  

typedef   struct    
{  
  UINT4   state[4];  
  UINT4   count[2];  
  unsigned   char   buffer[64];  
}   MD5_CTX;  

void   MD5Init(MD5_CTX   *);  
void   MD5Update(MD5_CTX   *,   unsigned   char   *,   unsigned   int);  
void   MD5Final(unsigned   char   [16],   MD5_CTX   *);  

#define   S11   7  
#define   S12   12  
#define   S13   17  
#define   S14   22  
#define   S21   5  
#define   S22   9  
#define   S23   14  
#define   S24   20  
#define   S31   4  
#define   S32   11  
#define   S33   16  
#define   S34   23  
#define   S41   6  
#define   S42   10  
#define   S43   15  
#define   S44   21  

static   unsigned   char   PADDING[64]   =   {  
  0x80,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0  
};  

#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)))  

#define   ROTATE_LEFT(x,   n)   (((x)   <<   (n))   |   ((x)   >>   (32-(n))))  

#define   FF(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   F   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }  
#define   GG(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   G   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }  
#define   HH(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   H   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);       }  
#define   II(a,   b,   c,   d,   x,   s,   ac)   {     (a)   +=   I   ((b),   (c),   (d))   +   (x)   +   (UINT4)(ac);     (a)   =   ROTATE_LEFT   ((a),   (s));     (a)   +=   (b);   }  


inline   void   Encode(unsigned   char   *output,   UINT4   *input,   unsigned   int   len)  
{  
  unsigned   int   i,   j;  
  
  for   (i   =   0,   j   =   0;   j   <   len;   i++,   j   +=   4)   {  
    output[j]   =   (unsigned   char)(input[i]   &   0xff);  
    output[j+1]   =   (unsigned   char)((input[i]   >>   8)   &   0xff);  
    output[j+2]   =   (unsigned   char)((input[i]   >>   16)   &   0xff);  
    output[j+3]   =   (unsigned   char)((input[i]   >>   24)   &   0xff);  
  }  
}  

inline   void   Decode(UINT4   *output,   unsigned   char   *input,   unsigned   int   len)  
{  
  unsigned   int   i,   j;  
  
  for   (i   =   0,   j   =   0;   j   <   len;   i++,   j   +=   4)  
    output[i]   =   ((UINT4)input[j])   |   (((UINT4)input[j+1])   <<   8)   |  
  (((UINT4)input[j+2])   <<   16)   |   (((UINT4)input[j+3])   <<   24);  
}  

inline   void   MD5Transform   (UINT4   state[4],   unsigned   char   block[64])  
{  
  UINT4   a   =   state[0],   b   =   state[1],   c   =   state[2],   d   =   state[3],   x[16];  
  Decode   (x,   block,   64);  
  FF   (a,   b,   c,   d,   x[   0],   S11,   0xd76aa478);   /*   1   */  
  FF   (d,   a,   b,   c,   x[   1],   S12,   0xe8c7b756);   /*   2   */  
  FF   (c,   d,   a,   b,   x[   2],   S13,   0x242070db);   /*   3   */  
  FF   (b,   c,   d,   a,   x[   3],   S14,   0xc1bdceee);   /*   4   */  
  FF   (a,   b,   c,   d,   x[   4],   S11,   0xf57c0faf);   /*   5   */  
  FF   (d,   a,   b,   c,   x[   5],   S12,   0x4787c62a);   /*   6   */  
  FF   (c,   d,   a,   b,   x[   6],   S13,   0xa8304613);   /*   7   */  
  FF   (b,   c,   d,   a,   x[   7],   S14,   0xfd469501);   /*   8   */  
  FF   (a,   b,   c,   d,   x[   8],   S11,   0x698098d8);   /*   9   */  
  FF   (d,   a,   b,   c,   x[   9],   S12,   0x8b44f7af);   /*   10   */  
  FF   (c,   d,   a,   b,   x[10],   S13,   0xffff5bb1);   /*   11   */  
  FF   (b,   c,   d,   a,   x[11],   S14,   0x895cd7be);   /*   12   */  
  FF   (a,   b,   c,   d,   x[12],   S11,   0x6b901122);   /*   13   */  
  FF   (d,   a,   b,   c,   x[13],   S12,   0xfd987193);   /*   14   */  
  FF   (c,   d,   a,   b,   x[14],   S13,   0xa679438e);   /*   15   */  
  FF   (b,   c,   d,   a,   x[15],   S14,   0x49b40821);   /*   16   */  
  GG   (a,   b,   c,   d,   x[   1],   S21,   0xf61e2562);   /*   17   */  
  GG   (d,   a,   b,   c,   x[   6],   S22,   0xc040b340);   /*   18   */  
  GG   (c,   d,   a,   b,   x[11],   S23,   0x265e5a51);   /*   19   */  
  GG   (b,   c,   d,   a,   x[   0],   S24,   0xe9b6c7aa);   /*   20   */  
  GG   (a,   b,   c,   d,   x[   5],   S21,   0xd62f105d);   /*   21   */  
  GG   (d,   a,   b,   c,   x[10],   S22,     0x2441453);   /*   22   */  
  GG   (c,   d,   a,   b,   x[15],   S23,   0xd8a1e681);   /*   23   */  
  GG   (b,   c,   d,   a,   x[   4],   S24,   0xe7d3fbc8);   /*   24   */  
  GG   (a,   b,   c,   d,   x[   9],   S21,   0x21e1cde6);   /*   25   */  
  GG   (d,   a,   b,   c,   x[14],   S22,   0xc33707d6);   /*   26   */  
  GG   (c,   d,   a,   b,   x[   3],   S23,   0xf4d50d87);   /*   27   */  
  GG   (b,   c,   d,   a,   x[   8],   S24,   0x455a14ed);   /*   28   */  
  GG   (a,   b,   c,   d,   x[13],   S21,   0xa9e3e905);   /*   29   */  
  GG   (d,   a,   b,   c,   x[   2],   S22,   0xfcefa3f8);   /*   30   */  
  GG   (c,   d,   a,   b,   x[   7],   S23,   0x676f02d9);   /*   31   */  
  GG   (b,   c,   d,   a,   x[12],   S24,   0x8d2a4c8a);   /*   32   */  
  HH   (a,   b,   c,   d,   x[   5],   S31,   0xfffa3942);   /*   33   */  
  HH   (d,   a,   b,   c,   x[   8],   S32,   0x8771f681);   /*   34   */  
  HH   (c,   d,   a,   b,   x[11],   S33,   0x6d9d6122);   /*   35   */  
  HH   (b,   c,   d,   a,   x[14],   S34,   0xfde5380c);   /*   36   */  
  HH   (a,   b,   c,   d,   x[   1],   S31,   0xa4beea44);   /*   37   */  
  HH   (d,   a,   b,   c,   x[   4],   S32,   0x4bdecfa9);   /*   38   */  
  HH   (c,   d,   a,   b,   x[   7],   S33,   0xf6bb4b60);   /*   39   */  
  HH   (b,   c,   d,   a,   x[10],   S34,   0xbebfbc70);   /*   40   */  
  HH   (a,   b,   c,   d,   x[13],   S31,   0x289b7ec6);   /*   41   */  
  HH   (d,   a,   b,   c,   x[   0],   S32,   0xeaa127fa);   /*   42   */  
  HH   (c,   d,   a,   b,   x[   3],   S33,   0xd4ef3085);   /*   43   */  
  HH   (b,   c,   d,   a,   x[   6],   S34,     0x4881d05);   /*   44   */  
  HH   (a,   b,   c,   d,   x[   9],   S31,   0xd9d4d039);   /*   45   */  
  HH   (d,   a,   b,   c,   x[12],   S32,   0xe6db99e5);   /*   46   */  
  HH   (c,   d,   a,   b,   x[15],   S33,   0x1fa27cf8);   /*   47   */  
  HH   (b,   c,   d,   a,   x[   2],   S34,   0xc4ac5665);   /*   48   */  
  II   (a,   b,   c,   d,   x[   0],   S41,   0xf4292244);   /*   49   */  
  II   (d,   a,   b,   c,   x[   7],   S42,   0x432aff97);   /*   50   */  
  II   (c,   d,   a,   b,   x[14],   S43,   0xab9423a7);   /*   51   */  
  II   (b,   c,   d,   a,   x[   5],   S44,   0xfc93a039);   /*   52   */  
  II   (a,   b,   c,   d,   x[12],   S41,   0x655b59c3);   /*   53   */  
  II   (d,   a,   b,   c,   x[   3],   S42,   0x8f0ccc92);   /*   54   */  
  II   (c,   d,   a,   b,   x[10],   S43,   0xffeff47d);   /*   55   */  
  II   (b,   c,   d,   a,   x[   1],   S44,   0x85845dd1);   /*   56   */  
  II   (a,   b,   c,   d,   x[   8],   S41,   0x6fa87e4f);   /*   57   */  
  II   (d,   a,   b,   c,   x[15],   S42,   0xfe2ce6e0);   /*   58   */  
  II   (c,   d,   a,   b,   x[   6],   S43,   0xa3014314);   /*   59   */  
  II   (b,   c,   d,   a,   x[13],   S44,   0x4e0811a1);   /*   60   */  
  II   (a,   b,   c,   d,   x[   4],   S41,   0xf7537e82);   /*   61   */  
  II   (d,   a,   b,   c,   x[11],   S42,   0xbd3af235);   /*   62   */  
  II   (c,   d,   a,   b,   x[   2],   S43,   0x2ad7d2bb);   /*   63   */  
  II   (b,   c,   d,   a,   x[   9],   S44,   0xeb86d391);   /*   64   */  
  state[0]   +=   a;  
  state[1]   +=   b;  
  state[2]   +=   c;  
  state[3]   +=   d;  
  memset   ((POINTER)x,   0,   sizeof   (x));  
  }  
   
inline   void   MD5Init(MD5_CTX   *context)  
{  
  context->count[0]   =   context->count[1]   =   0;  
  context->state[0]   =   0x67452301;  
  context->state[1]   =   0xefcdab89;  
  context->state[2]   =   0x98badcfe;  
  context->state[3]   =   0x10325476;  
}  

inline   void   MD5Update(MD5_CTX   *context,   unsigned   char   *input,   unsigned   int   inputLen)  
{  
  unsigned   int   i,   index,   partLen;  
  
  index   =   (unsigned   int)((context->count[0]   >>   3)   &   0x3F);  
  if   ((context->count[0]   +=   ((UINT4)inputLen   <<   3))  
    <   ((UINT4)inputLen   <<   3))  
    context->count[1]++;  
  context->count[1]   +=   ((UINT4)inputLen   >>   29);  
  
  partLen   =   64   -   index;  
  
  if   (inputLen   >=   partLen)   {  
    memcpy((POINTER)&context->buffer[index],   (POINTER)input,   partLen);  
    MD5Transform(context->state,   context->buffer);  
    
    for   (i   =   partLen;   i   +   63   <   inputLen;   i   +=   64)  
      MD5Transform   (context->state,   &input[i]);  
    index   =   0;  
  }  
  else  
    i   =   0;  
  
  memcpy((POINTER)&context->buffer[index],   (POINTER)&input[i],   inputLen-i);  
}  

inline   void   MD5Final(unsigned   char   digest[16],   MD5_CTX   *context)  
{  
  unsigned   char   bits[8];  
  unsigned   int   index,   padLen;  
  
  Encode   (bits,   context->count,   8);  
  index   =   (unsigned   int)((context->count[0]   >>   3)   &   0x3f);  
  padLen   =   (index   <   56)   ?   (56   -   index)   :   (120   -   index);  
  MD5Update   (context,   PADDING,   padLen);  
  MD5Update   (context,   bits,   8);  
  Encode   (digest,   context->state,   16);  
  memset   ((POINTER)context,   0,   sizeof   (*context));  
  }  

void   MD5Digest(char   *pszInput,   unsigned   long   nInputSize,   char   *pszOutPut)  
{  
  MD5_CTX   context;  
  unsigned   int   len   =   strlen   (pszInput);  
  
  MD5Init   (&context);  
  MD5Update   (&context,   (unsigned   char   *)pszInput,   len);  
  MD5Final   ((unsigned   char   *)pszOutPut,   &context);  
}  

int main()  
{ char szDigest[16];  
  char encrypt[200];  
  
  while(-1) 
  {
  gets(encrypt);
  MD5Digest(encrypt,strlen(encrypt),szDigest);  
  int i;
  for (i=0;i<16;i++) 
  printf ("%02X",(unsigned char)szDigest[i]);
  printf("\n"); 
  }
return 0;
}

文件加密：

#include<stdio.h>
#include   <stdlib.h> 
#include   <time.h>  
#include   <string.h>  

#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)))

#define RL(x, y) (((x) << (y)) | ((x) >> (32 - (y)))) //x向左循环移y位

#define PP(x) (x<<24)|((x<<8)&0xff0000)|((x>>8)&0xff00)|(x>>24) //将x高低位互换,例如PP(aabbccdd)=ddccbbaa

#define FF(a, b, c, d, x, s, ac) a = b + (RL((a + F(b,c,d) + x + ac),s))
#define GG(a, b, c, d, x, s, ac) a = b + (RL((a + G(b,c,d) + x + ac),s))
#define HH(a, b, c, d, x, s, ac) a = b + (RL((a + H(b,c,d) + x + ac),s))
#define II(a, b, c, d, x, s, ac) a = b + (RL((a + I(b,c,d) + x + ac),s))

unsigned A,B,C,D,a,b,c,d,i,len,flen[2],x[16]; //i临时变量,len文件长,flen[2]为64位二进制表示的文件初始长度
char filename[200]; //文件名
FILE *fp;

void md5() //MD5核心算法,供64轮
{

    a=A,b=B,c=C,d=D;
    /**//* Round 1 */
    FF (a, b, c, d, x[ 0], 7, 0xd76aa478); /**//* 1 */
    FF (d, a, b, c, x[ 1], 12, 0xe8c7b756); /**//* 2 */
    FF (c, d, a, b, x[ 2], 17, 0x242070db); /**//* 3 */
    FF (b, c, d, a, x[ 3], 22, 0xc1bdceee); /**//* 4 */
    FF (a, b, c, d, x[ 4], 7, 0xf57c0faf); /**//* 5 */
    FF (d, a, b, c, x[ 5], 12, 0x4787c62a); /**//* 6 */
    FF (c, d, a, b, x[ 6], 17, 0xa8304613); /**//* 7 */
    FF (b, c, d, a, x[ 7], 22, 0xfd469501); /**//* 8 */
    FF (a, b, c, d, x[ 8], 7, 0x698098d8); /**//* 9 */
    FF (d, a, b, c, x[ 9], 12, 0x8b44f7af); /**//* 10 */
    FF (c, d, a, b, x[10], 17, 0xffff5bb1); /**//* 11 */
    FF (b, c, d, a, x[11], 22, 0x895cd7be); /**//* 12 */
    FF (a, b, c, d, x[12], 7, 0x6b901122); /**//* 13 */
    FF (d, a, b, c, x[13], 12, 0xfd987193); /**//* 14 */
    FF (c, d, a, b, x[14], 17, 0xa679438e); /**//* 15 */
    FF (b, c, d, a, x[15], 22, 0x49b40821); /**//* 16 */

    /**//* Round 2 */
    GG (a, b, c, d, x[ 1], 5, 0xf61e2562); /**//* 17 */
    GG (d, a, b, c, x[ 6], 9, 0xc040b340); /**//* 18 */
    GG (c, d, a, b, x[11], 14, 0x265e5a51); /**//* 19 */
    GG (b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /**//* 20 */
    GG (a, b, c, d, x[ 5], 5, 0xd62f105d); /**//* 21 */
    GG (d, a, b, c, x[10], 9, 0x02441453); /**//* 22 */
    GG (c, d, a, b, x[15], 14, 0xd8a1e681); /**//* 23 */
    GG (b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /**//* 24 */
    GG (a, b, c, d, x[ 9], 5, 0x21e1cde6); /**//* 25 */
    GG (d, a, b, c, x[14], 9, 0xc33707d6); /**//* 26 */
    GG (c, d, a, b, x[ 3], 14, 0xf4d50d87); /**//* 27 */
    GG (b, c, d, a, x[ 8], 20, 0x455a14ed); /**//* 28 */
    GG (a, b, c, d, x[13], 5, 0xa9e3e905); /**//* 29 */
    GG (d, a, b, c, x[ 2], 9, 0xfcefa3f8); /**//* 30 */
    GG (c, d, a, b, x[ 7], 14, 0x676f02d9); /**//* 31 */
    GG (b, c, d, a, x[12], 20, 0x8d2a4c8a); /**//* 32 */

    /**//* Round 3 */
    HH (a, b, c, d, x[ 5], 4, 0xfffa3942); /**//* 33 */
    HH (d, a, b, c, x[ 8], 11, 0x8771f681); /**//* 34 */
    HH (c, d, a, b, x[11], 16, 0x6d9d6122); /**//* 35 */
    HH (b, c, d, a, x[14], 23, 0xfde5380c); /**//* 36 */
    HH (a, b, c, d, x[ 1], 4, 0xa4beea44); /**//* 37 */
    HH (d, a, b, c, x[ 4], 11, 0x4bdecfa9); /**//* 38 */
    HH (c, d, a, b, x[ 7], 16, 0xf6bb4b60); /**//* 39 */
    HH (b, c, d, a, x[10], 23, 0xbebfbc70); /**//* 40 */
    HH (a, b, c, d, x[13], 4, 0x289b7ec6); /**//* 41 */
    HH (d, a, b, c, x[ 0], 11, 0xeaa127fa); /**//* 42 */
    HH (c, d, a, b, x[ 3], 16, 0xd4ef3085); /**//* 43 */
    HH (b, c, d, a, x[ 6], 23, 0x04881d05); /**//* 44 */
    HH (a, b, c, d, x[ 9], 4, 0xd9d4d039); /**//* 45 */
    HH (d, a, b, c, x[12], 11, 0xe6db99e5); /**//* 46 */
    HH (c, d, a, b, x[15], 16, 0x1fa27cf8); /**//* 47 */
    HH (b, c, d, a, x[ 2], 23, 0xc4ac5665); /**//* 48 */

    /**//* Round 4 */
    II (a, b, c, d, x[ 0], 6, 0xf4292244); /**//* 49 */
    II (d, a, b, c, x[ 7], 10, 0x432aff97); /**//* 50 */
    II (c, d, a, b, x[14], 15, 0xab9423a7); /**//* 51 */
    II (b, c, d, a, x[ 5], 21, 0xfc93a039); /**//* 52 */
    II (a, b, c, d, x[12], 6, 0x655b59c3); /**//* 53 */
    II (d, a, b, c, x[ 3], 10, 0x8f0ccc92); /**//* 54 */
    II (c, d, a, b, x[10], 15, 0xffeff47d); /**//* 55 */
    II (b, c, d, a, x[ 1], 21, 0x85845dd1); /**//* 56 */
    II (a, b, c, d, x[ 8], 6, 0x6fa87e4f); /**//* 57 */
    II (d, a, b, c, x[15], 10, 0xfe2ce6e0); /**//* 58 */
    II (c, d, a, b, x[ 6], 15, 0xa3014314); /**//* 59 */
    II (b, c, d, a, x[13], 21, 0x4e0811a1); /**//* 60 */
    II (a, b, c, d, x[ 4], 6, 0xf7537e82); /**//* 61 */
    II (d, a, b, c, x[11], 10, 0xbd3af235); /**//* 62 */
    II (c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /**//* 63 */
    II (b, c, d, a, x[ 9], 21, 0xeb86d391); /**//* 64 */

    A += a;
    B += b;
    C += c;
    D += d;

}

main()
{
    while(1)
    {
        printf("Input file:");
        gets(filename); //用get函数,避免scanf以空格分割数据,
        if (filename[0]==34) filename[strlen(filename)-1]=0,strcpy(filename,filename+1); //支持文件拖曳,但会多出双引号,这里是处理多余的双引号
        if (!strcmp(filename,"exit")) exit(0); //输入exit退出
        if (!(fp=fopen(filename,"rb")))
        {
            printf("Can not open this file!\n"); //以二进制打开文件
            continue;
        }
        fseek(fp, 0, SEEK_END); //文件指针转到文件末尾
        if((len=ftell(fp))==-1)
        {
            printf("Sorry! Can not calculate files which larger than 2 GB!\n"); //ftell函数返回long,最大为2GB,超出返回-1
            fclose(fp);
            continue;
        }
        rewind(fp); //文件指针复位到文件头
        A=0x67452301,B=0xefcdab89,C=0x98badcfe,D=0x10325476; //初始化链接变量
        flen[1]=len/0x20000000; //flen单位是bit
        flen[0]=(len%0x20000000)*8;
        memset(x,0,64); //初始化x数组为0
        fread(&x,4,16,fp); //以4字节为一组,读取16组数据
        for(i=0; i<len/64; i++) //循环运算直至文件结束
        {
            md5();
            memset(x,0,64);
            fread(&x,4,16,fp);
        }
        ((char*)x)[len%64]=128; //文件结束补1,补0操作,128二进制即10000000
        if(len%64>55) md5(),memset(x,0,64);
        memcpy(x+14,flen,8); //文件末尾加入原文件的bit长度
        md5();
        fclose(fp);
        printf("MD5 Code:%08x%08x%08x%08x\n",PP(A),PP(B),PP(C),PP(D)); //高低位逆反输出
    }
}

九日王朝

关注

4
点赞
踩
12

收藏

觉得还不错? 一键收藏
1
评论
C++实现MD5加密

MD5相信绝大数人都接触过，也有无数人问过我怎么做MD5解密。当然，我们知道MD5自然没有办法解密，所以解密也不过是大量已知数据做成字典而已，MD5是不可能通过逆向计算解密的。为什么呢？因为哈希冲突。举个简单的例子：比如说我给定10个位置来存放东西，假设我的对应方法是简单的求余%。那么11%10，21%10的结果就会相同。这样就造成了冲突。MD5也是如此，我们常用的MD5位
复制链接

扫一扫