md5 c语言实现（根据rfc1321）-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

苦海澜石

凯发app官方网站首页　| 　博文目录　| 　关于我

khls27

  • 博客访问： 753011
  • 博文数量： 144
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1150
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-17 14:32
个人简介

小公司研发总监，既当司令也当兵！

文章分类

全部博文（144）

推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
md5 c语言实现（根据rfc1321）

分类： linux

2016-01-02 22:24:35

md5 的rfc文档路径：
或者 

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

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

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

     第三步、装入标准的幻数（四个整数）：标准的幻数（物理顺序）是（a=(01234567)16，b=(89abcdef)16，c=(fedcba98)16，d=(76543210)16）。如果在程序中定义应该是（a=0x67452301l，b=0xefcdab89l，c=0x98badcfel，d=0x10325476l）。有点晕哈，其实想一想就明白了。

     第四步、四轮循环运算：循环的次数是分组的个数（n 1） 

     1）将每一512字节细分成16个小组，每个小组64位（8个字节）
     
     2）先认识四个线性函数(&是与,|是或,~是非,^是异或)
  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))
    
    3）设mj表示消息的第j个子分组（从0到15），<<
  ff(a,b,c,d,mj,s,ti)表示a=b((af(b,c,d)mjti)<<<s)
  gg(a,b,c,d,mj,s,ti)表示a=b((ag(b,c,d)mjti)<<<s)
  hh(a,b,c,d,mj,s,ti)表示a=b((ah(b,c,d)mjti)<<<s)
  ii(a,b,c,d,mj,s,ti)表示a=b((ai(b,c,d)mjti)<<<s)

    4）四轮运算
第一轮
a=ff(a,b,c,d,m0,7,0xd76aa478)
b=ff(d,a,b,c,m1,12,0xe8c7b756)
c=ff(c,d,a,b,m2,17,0x242070db)
d=ff(b,c,d,a,m3,22,0xc1bdceee)
a=ff(a,b,c,d,m4,7,0xf57c0faf)
b=ff(d,a,b,c,m5,12,0x4787c62a)
c=ff(c,d,a,b,m6,17,0xa8304613)
d=ff(b,c,d,a,m7,22,0xfd469501)
a=ff(a,b,c,d,m8,7,0x698098d8)
b=ff(d,a,b,c,m9,12,0x8b44f7af)
c=ff(c,d,a,b,m10,17,0xffff5bb1)
d=ff(b,c,d,a,m11,22,0x895cd7be)
a=ff(a,b,c,d,m12,7,0x6b901122)
b=ff(d,a,b,c,m13,12,0xfd987193)
c=ff(c,d,a,b,m14,17,0xa679438e)
d=ff(b,c,d,a,m15,22,0x49b40821)

第二轮
a=gg(a,b,c,d,m1,5,0xf61e2562)
b=gg(d,a,b,c,m6,9,0xc040b340)
c=gg(c,d,a,b,m11,14,0x265e5a51)
d=gg(b,c,d,a,m0,20,0xe9b6c7aa)
a=gg(a,b,c,d,m5,5,0xd62f105d)
b=gg(d,a,b,c,m10,9,0x02441453)
c=gg(c,d,a,b,m15,14,0xd8a1e681)
d=gg(b,c,d,a,m4,20,0xe7d3fbc8)
a=gg(a,b,c,d,m9,5,0x21e1cde6)
b=gg(d,a,b,c,m14,9,0xc33707d6)
c=gg(c,d,a,b,m3,14,0xf4d50d87)
d=gg(b,c,d,a,m8,20,0x455a14ed)
a=gg(a,b,c,d,m13,5,0xa9e3e905)
b=gg(d,a,b,c,m2,9,0xfcefa3f8)
c=gg(c,d,a,b,m7,14,0x676f02d9)
d=gg(b,c,d,a,m12,20,0x8d2a4c8a)

第三轮
a=hh(a,b,c,d,m5,4,0xfffa3942)
b=hh(d,a,b,c,m8,11,0x8771f681)
c=hh(c,d,a,b,m11,16,0x6d9d6122)
d=hh(b,c,d,a,m14,23,0xfde5380c)
a=hh(a,b,c,d,m1,4,0xa4beea44)
b=hh(d,a,b,c,m4,11,0x4bdecfa9)
c=hh(c,d,a,b,m7,16,0xf6bb4b60)
d=hh(b,c,d,a,m10,23,0xbebfbc70)
a=hh(a,b,c,d,m13,4,0x289b7ec6)
b=hh(d,a,b,c,m0,11,0xeaa127fa)
c=hh(c,d,a,b,m3,16,0xd4ef3085)
d=hh(b,c,d,a,m6,23,0x04881d05)
a=hh(a,b,c,d,m9,4,0xd9d4d039)
b=hh(d,a,b,c,m12,11,0xe6db99e5)
c=hh(c,d,a,b,m15,16,0x1fa27cf8)
d=hh(b,c,d,a,m2,23,0xc4ac5665)

第四轮
a=ii(a,b,c,d,m0,6,0xf4292244)
b=ii(d,a,b,c,m7,10,0x432aff97)
c=ii(c,d,a,b,m14,15,0xab9423a7)
d=ii(b,c,d,a,m5,21,0xfc93a039)
a=ii(a,b,c,d,m12,6,0x655b59c3)
b=ii(d,a,b,c,m3,10,0x8f0ccc92)
c=ii(c,d,a,b,m10,15,0xffeff47d)
d=ii(b,c,d,a,m1,21,0x85845dd1)
a=ii(a,b,c,d,m8,6,0x6fa87e4f)
b=ii(d,a,b,c,m15,10,0xfe2ce6e0)
c=ii(c,d,a,b,m6,15,0xa3014314)
d=ii(b,c,d,a,m13,21,0x4e0811a1)
a=ii(a,b,c,d,m4,6,0xf7537e82)
b=ii(d,a,b,c,m11,10,0xbd3af235)
c=ii(c,d,a,b,m2,15,0x2ad7d2bb)
d=ii(b,c,d,a,m9,21,0xeb86d391)

    5）每轮循环后，将a，b，c，d分别加上a，b，c，d，然后进入下一循环。

下面是c语言的一个实现：

头文件md5.h

点击(此处)折叠或打开

  1. #ifndef md5_h
  2. #define md5_h
  3.  
  4. typedef struct {
  5.   int state[4];                /* state (abcd) */
  6.   int count[2];                /* 记录处理bit数 */
  7.   unsigned char buffer[64]; /* input buffer */
  8. } md5_ctx;
  9.  

  11. #define s11 7
  12. #define s12 12
  13. #define s13 17
  14. #define s14 22

  16. #define s21 5
  17. #define s22 9
  18. #define s23 14
  19. #define s24 20

  21. #define s31 4
  22. #define s32 11
  23. #define s33 16
  24. #define s34 23

  26. #define s41 6
  27. #define s42 10
  28. #define s43 15
  29. #define s44 21

  31. #define f(x,y,z) (((x) & (y)) | (~(x) & (z)))
  32. #define g(x,y,z) (((x) & (z)) | ((y) & ~(z)))
  33. #define h(x,y,z) ((x) ^ (y )^ (z))
  34. #define i(x,y,z) ((y) ^ ((x) | ~(z)))

  36. //将x循环右移n位
  37. #define rotate_left(x,n) (((x) << (n)) | ((x) >> (32-(n))))

  39. #define ff(a,b,c,d,x,s,ac) \
  40.       do { \
  41.           a = f(b,c,d) x ac; \
  42.           a = rotate_left(a,s); \
  43.           a = b; \
  44.       } while(0)

  46. #define gg(a,b,c,d,x,s,ac) \
  47.     do { \
  48.           a = g(b,c,d) x ac; \
  49.           a = rotate_left(a,s); \
  50.           a = b; \
  51.     } while(0)

  53. #define hh(a,b,c,d,x,s,ac) \
  54.     do { \
  55.           a = h(b,c,d) x ac; \
  56.           a = rotate_left(a,s); \
  57.           a = b; \
  58.     } while(0)

  60. #define ii(a,b,c,d,x,s,ac) \
  61.     do { \
  62.           a = i(b,c,d) x ac; \
  63.           a = rotate_left(a,s); \
  64.           a = b; \
  65.     } while(0)


  68. void md5init(md5_ctx *context);
  69. void md5update(md5_ctx *context,unsigned char *input,unsigned int inputlen);
  70. void md5final(md5_ctx *context,unsigned char digest[16]);
  71. void md5transform(unsigned int state[4],unsigned char block[64]);
  72. void md5encode(unsigned char *output,unsigned int *input,unsigned int len);
  73. void md5decode(unsigned int *output,unsigned char *input,unsigned int len);
  74.  
  75. #endif

主要实现md5.c

点击(此处)折叠或打开

  1. #include <memory.h>
  2. #include "md5.h"
  3.  
  4. unsigned char padding[]={ // 16 bety one line, 64 bety in total
  5.     0x80,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, //填充数据第一个bit为1，其余为0
  6.      0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  7.        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  8.        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0
  9. };
  10.                          
  11. void md5init(md5_ctx *context)
  12. {
  13.      context->count[0] = 0;
  14.      context->count[1] = 0;
  15.      context->state[0] = 0x67452301;
  16.      context->state[1] = 0xefcdab89;
  17.      context->state[2] = 0x98badcfe;
  18.      context->state[3] = 0x10325476;
  19. }

  21. /*
  22. * 处理输入数据（同一批数据处理，可以多次调用）
  23. *
  24. * 1. 按64字节一个分组，循环处理输入数据；
  25. * 2. 如果上次处理有剩余数据（不足一个分组的数据被保留），新输入数据拼接其后，组成一个新分组优先处理；
  26. * 3. 如果处理后有不足一个分组的数据剩余，那么把这部分数据保留到缓冲区中，待后续数据或最终padding处理。
  27. */
  28. void md5update(md5_ctx *context, unsigned char *input, unsigned int inputlen)
  29. {
  30.     unsigned int i = 0;
  31.     unsigned int index = 0;
  32.     unsigned int partlen = 0;


  35.     index = (context->count[0] >> 3) & 0x3f; // 转换为字节数并对64取模，等价于 (count[0] >> 3) % 64
  36.     partlen = 64 - index; //待补齐的字节数（上次处理不足一个分组的部分被保留未处理，本次先补齐一个组）

  38.     context->count[0] = inputlen << 3; //新输入bit数

  40.     if(context->count[0] < (inputlen << 3)) //count[0]溢出，记录到count[1]中
  41.        context->count[1];

  43.     context->count[1] = inputlen >> 29; //新输入bit数溢出，记录到count[2]中
  44.     
  45.     if(inputlen >= partlen) // 至少可以凑足一个分组
  46.     {
  47.         // 优先使用缓冲中的数据拼接一个分组，并处理该分组
  48.         memcpy(&context->buffer[index],input,partlen);
  49.         md5transform(context->state,context->buffer);

  51.         // 按64字节一个分组循环处理输入数据
  52.         for(i = partlen;i64 <= inputlen;i=64)
  53.             md5transform(context->state,&input[i]);

  55.         index = 0; //缓冲区偏移index置0（缓冲区已经被处理）
  56.     }
  57.     else
  58.     {
  59.         i = 0;
  60.     }

  62.     // 将不足一个分组的数据保存到缓冲区中，等待后续数据补齐或最终padding处理
  63.     memcpy(&context->buffer[index],&input[i],inputlen-i);
  64. }

  66. /*
  67. * 处理缓冲区中的剩余数据，输出最终的数据特征码到digest
  68. */
  69. void md5final(md5_ctx *context, unsigned char digest[16])
  70. {
  71.     unsigned int index = 0;
  72.     unsigned int padlen = 0;
  73.     unsigned char bits[8];

  75.     index = (context->count[0] >> 3) & 0x3f;

  77.     /*
  78.     * 最后一个分组：（部分原数据） （填充数据） （长度信息[8字节]）
  79.     * 所以剩余部分原始数据长度如果超过56字节，那么填充数据和长度信息在本分组中无法容纳
  80.     * 那么需要再额外填充一个分组。
  81.     */
  82.     padlen = (index < 56) ? (56-index) : (120-index);
  83.     md5encode(bits, context->count, 8);
  84.     md5update(context, padding, padlen);
  85.     md5update(context, bits, 8);
  86.     md5encode(digest,context->state,16);
  87. }

  89. /*
  90. * 把输入的整形数组转换为字符数组
  91. *
  92. * todo：
  93. * 是否需要考虑大小端？
  94. */
  95. void md5encode(unsigned char *output,unsigned int *input,unsigned int len)
  96. {
  97.     unsigned int i = 0,j = 0;
  98.     while(j < len)
  99.     {
  100.          output[j] = input[i] & 0xff;
  101.          output[j1] = (input[i] >> 8) & 0xff;
  102.          output[j2] = (input[i] >> 16) & 0xff;
  103.          output[j3] = (input[i] >> 24) & 0xff;
  104.          i;
  105.          j=4;
  106.     }
  107. }

  109. /*
  110. * 把输入的char类型的数据转换为int类型，要求len是4的倍数
  111. *
  112. * todo：
  113. * 是否需要考虑大小端？
  114. */
  115. void md5decode(unsigned int *output,unsigned char *input,unsigned int len)
  116. {
  117.      unsigned int i = 0,j = 0;
  118.      while(j < len)
  119.      {
  120.            output[i] = (input[j]) |
  121.                        (input[j1] << 8) |
  122.                        (input[j2] << 16) |
  123.                        (input[j3] << 24);
  124.            i;
  125.            j=4;
  126.      }
  127. }


  130. /*
  131. * 处理一个分组
  132. */
  133. void md5transform(unsigned int state[4],unsigned char block[64])
  134. {
  135.      unsigned int a = state[0];
  136.      unsigned int b = state[1];
  137.      unsigned int c = state[2];
  138.      unsigned int d = state[3];
  139.      unsigned int x[64];

  141.      md5decode(x,block,64);

  143.      /* round 1*/
  144.      ff(a, b, c, d, x[ 0], 7,    0xd76aa478); /* 1 */
  145.      ff(d, a, b, c, x[ 1], 12,    0xe8c7b756); /* 2 */
  146.      ff(c, d, a, b, x[ 2], 17,    0x242070db); /* 3 */
  147.      ff(b, c, d, a, x[ 3], 22,    0xc1bdceee); /* 4 */
  148.      ff(a, b, c, d, x[ 4], 7,    0xf57c0faf); /* 5 */
  149.      ff(d, a, b, c, x[ 5], 12,    0x4787c62a); /* 6 */
  150.      ff(c, d, a, b, x[ 6], 17,    0xa8304613); /* 7 */
  151.      ff(b, c, d, a, x[ 7], 22,    0xfd469501); /* 8 */
  152.      ff(a, b, c, d, x[ 8], 7,    0x698098d8); /* 9 */
  153.      ff(d, a, b, c, x[ 9], 12,    0x8b44f7af); /* 10 */
  154.      ff(c, d, a, b, x[10], 17,    0xffff5bb1); /* 11 */
  155.      ff(b, c, d, a, x[11], 22,    0x895cd7be); /* 12 */
  156.      ff(a, b, c, d, x[12], 7,    0x6b901122); /* 13 */
  157.      ff(d, a, b, c, x[13], 12,    0xfd987193); /* 14 */
  158.      ff(c, d, a, b, x[14], 17,    0xa679438e); /* 15 */
  159.      ff(b, c, d, a, x[15], 22,    0x49b40821); /* 16 */
  160.  
  161.      /* round 2 */
  162.      gg(a, b, c, d, x[ 1], 5,    0xf61e2562); /* 17 */
  163.      gg(d, a, b, c, x[ 6], 9,    0xc040b340); /* 18 */
  164.      gg(c, d, a, b, x[11], 14,    0x265e5a51); /* 19 */
  165.      gg(b, c, d, a, x[ 0], 20,    0xe9b6c7aa); /* 20 */
  166.      gg(a, b, c, d, x[ 5], 5,    0xd62f105d); /* 21 */
  167.      gg(d, a, b, c, x[10], 9,    0x2441453); /* 22 */
  168.      gg(c, d, a, b, x[15], 14，    0xd8a1e681); /* 23 */
  169.      gg(b, c, d, a, x[ 4], 20,    0xe7d3fbc8); /* 24 */
  170.      gg(a, b, c, d, x[ 9], 5,    0x21e1cde6); /* 25 */
  171.      gg(d, a, b, c, x[14], 9,    0xc33707d6); /* 26 */
  172.      gg(c, d, a, b, x[ 3], 14,    0xf4d50d87); /* 27 */
  173.      gg(b, c, d, a, x[ 8], 20,    0x455a14ed); /* 28 */
  174.      gg(a, b, c, d, x[13], 5,    0xa9e3e905); /* 29 */
  175.      gg(d, a, b, c, x[ 2], 9,    0xfcefa3f8); /* 30 */
  176.      gg(c, d, a, b, x[ 7], 14,    0x676f02d9); /* 31 */
  177.      gg(b, c, d, a, x[12], 20,    0x8d2a4c8a); /* 32 */
  178.  
  179.      /* round 3 */
  180.      hh(a, b, c, d, x[ 5], 4,    0xfffa3942); /* 33 */
  181.      hh(d, a, b, c, x[ 8], 11,    0x8771f681); /* 34 */
  182.      hh(c, d, a, b, x[11], 16,    0x6d9d6122); /* 35 */
  183.      hh(b, c, d, a, x[14], 23,    0xfde5380c); /* 36 */
  184.      hh(a, b, c, d, x[ 1], 4,    0xa4beea44); /* 37 */
  185.      hh(d, a, b, c, x[ 4], 11,    0x4bdecfa9); /* 38 */
  186.      hh(c, d, a, b, x[ 7], 16,    0xf6bb4b60); /* 39 */
  187.      hh(b, c, d, a, x[10], 23,    0xbebfbc70); /* 40 */
  188.      hh(a, b, c, d, x[13], 4,    0x289b7ec6); /* 41 */
  189.      hh(d, a, b, c, x[ 0], 11,    0xeaa127fa); /* 42 */
  190.      hh(c, d, a, b, x[ 3], 16,    0xd4ef3085); /* 43 */
  191.      hh(b, c, d, a, x[ 6], 23,    0x4881d05); /* 44 */
  192.      hh(a, b, c, d, x[ 9], 4,    0xd9d4d039); /* 45 */
  193.      hh(d, a, b, c, x[12], 11,    0xe6db99e5); /* 46 */
  194.      hh(c, d, a, b, x[15], 16,    0x1fa27cf8); /* 47 */
  195.      hh(b, c, d, a, x[ 2], 23,    0xc4ac5665); /* 48 */
  196.  
  197.      /* round 4 */
  198.      ii(a, b, c, d, x[ 0], 6,    0xf4292244); /* 49 */
  199.      ii(d, a, b, c, x[ 7], 10,    0x432aff97); /* 50 */
  200.      ii(c, d, a, b, x[14], 15,    0xab9423a7); /* 51 */
  201.      ii(b, c, d, a, x[ 5], 21,    0xfc93a039); /* 52 */
  202.      ii(a, b, c, d, x[12], 6,    0x655b59c3); /* 53 */
  203.      ii(d, a, b, c, x[ 3], 10,    0x8f0ccc92); /* 54 */
  204.      ii(c, d, a, b, x[10], 15,    0xffeff47d); /* 55 */
  205.      ii(b, c, d, a, x[ 1], 21,    0x85845dd1); /* 56 */
  206.      ii(a, b, c, d, x[ 8], 6,    0x6fa87e4f); /* 57 */
  207.      ii(d, a, b, c, x[15], 10,    0xfe2ce6e0); /* 58 */
  208.      ii(c, d, a, b, x[ 6], 15,    0xa3014314); /* 59 */
  209.      ii(b, c, d, a, x[13], 21,    0x4e0811a1); /* 60 */
  210.      ii(a, b, c, d, x[ 4], 6,    0xf7537e82); /* 61 */
  211.      ii(d, a, b, c, x[11], 10,    0xbd3af235); /* 62 */
  212.      ii(c, d, a, b, x[ 2], 15,    0x2ad7d2bb); /* 63 */
  213.      ii(b, c, d, a, x[ 9], 21,    0xeb86d391); /* 64 */

  215.      state[0] = a;
  216.      state[1] = b;
  217.      state[2] = c;
  218.      state[3] = d;
  219. }


下面是测试main函数，main.c

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "md5.h"

  5. /*
  6. md5 test suite:
  7. md5 ("") = d41d8cd98f00b204e9800998ecf8427e
  8. md5 ("a") = 0cc175b9c0f1b6a831c399e269772661
  9. md5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
  10. md5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
  11. md5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
  12. md5 ("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f
  13. md5 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a
  14. */
  15. int main(int argc, char *argv[])
  16. {
  17.     int i;
  18.     unsigned char encrypt[] ="a";
  19.     unsigned char encrypt2[] ="bc";
  20.     //unsigned char encrypt[] ="admin";//21232f297a57a5a743894a0e4a801fc3
  21.     unsigned char decrypt[16];
  22.     md5_ctx md5;

  24.     md5init(&md5);

  26.     md5update(&md5,encrypt,strlen((char *)encrypt));
  27.     md5update(&md5,encrypt2,strlen((char *)encrypt2));

  29.     md5final(&md5, decrypt);

  31.     printf("加密前:%s\n加密后:",encrypt);
  32.     for(i=0;i<16;i)
  33.     {
  34.         printf("x",decrypt[i]);
  35.     }
  36.     
  37.     getchar();
  38.     
  39.     return 0;
  40. }

阅读(2646) | 评论(0) | 转发(0) |
0

上一篇：svn自动备份脚本和设置方法

下一篇：hash 算法--联系人查找

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图