MD5算法的C语言实现

1

 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include "md5.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

 #define ROTATELEFT(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))

 #define TO_HEX_FMT_L "%02x"
 #define TO_HEX_FMT_U "%02X"

 /**
  * @desc: convert message and mes_bkp string into integer array and store them in w
  */
 static void md5_process_part1(uint32_t *w, const char *message, uint32_t *pos, uint32_t mes_len, const unsigned char *mes_bkp)
 {
     uint32_t i; // used in for loop

     for(i = ; i <= ; i++)
     {
         int32_t count = ;
         while(*pos < mes_len && count <= )
         {
             w[i] += (((uint32_t)message[*pos]) << count);
             (*pos)++;
             count += ;
         }
         while(count <= )
         {
             w[i] += (((uint32_t)mes_bkp[*pos - mes_len]) << count);
             (*pos)++;
             count += ;
         }
     }
 }

 /**
  * @desc: start encryption based on w
  */
 static void md5_process_part2(uint32_t abcd[], uint32_t *w, const uint32_t k[], const uint32_t s[])
 {
     uint32_t i; // used in for loop

     uint32_t a = abcd[];
     uint32_t b = abcd[];
     uint32_t c = abcd[];
     uint32_t d = abcd[];
     uint32_t f = ;
     uint32_t g = ;

     for(i = ; i < ; i++)
     {
         if(i >=  && i <= )
         {
             f = (b & c) | ((~b) & d);
             g = i;
         }else if(i >=  && i <= )
         {
             f = (d & b) | ((~d) & c);
             g = ( * i + ) % ;
         }else if(i >=  && i <= )
         {
             f = b ^ c ^ d;
             g = ( * i + ) % ;
         }else if(i >=  && i <= )
         {
             f = c ^ (b | (~d));
             g = ( * i) % ;
         }
         uint32_t temp = d;
         d = c;
         c = b;
         b = ROTATELEFT((a + f + k[i] + w[g]), s[i]) + b;
         a = temp;
     }

     abcd[] += a;
     abcd[] += b;
     abcd[] += c;
     abcd[] += d;
 }

 /**
  * @desc: format the output, convert numbers to hexdecimal string and store them in result
  */
 static void format_output(char *result, size_t size, uint32_t *abcd, uint32_t flag)
 {
     uint32_t i; // used in for loop

     memset(result, , size);

     uint32_t ptr = ;
     for(i = ; i < ; i++)
     {
         ptr += snprintf(result + ptr, size - ptr, (flag == )?TO_HEX_FMT_U:TO_HEX_FMT_L, (abcd[i] & 0x000000FF));
         ptr += snprintf(result + ptr, size - ptr, (flag == )?TO_HEX_FMT_U:TO_HEX_FMT_L, (abcd[i] & 0x0000FF00) >>  );
         ptr += snprintf(result + ptr, size - ptr, (flag == )?TO_HEX_FMT_U:TO_HEX_FMT_L, (abcd[i] & 0x00FF0000) >> );
         ptr += snprintf(result + ptr, size - ptr, (flag == )?TO_HEX_FMT_U:TO_HEX_FMT_L, (abcd[i] & 0xFF000000) >> );
     }
 }

 /**
  * @input: result -- store the calculation result
  *         size   -- size of result. Make sure it's at least 33
  *                   since the result is a 32-byte hexdecimal string.
  *         message-- string to be encrypted
  *         flag   -- 0 means upper case output, 1 means lower case output
  * @return: 0 -- success
  *          1 -- result size less than 33
  *          2 -- calloc failed
  */
 int32_t cal_md5(char *result, size_t size, const char *message, uint32_t flag){
     if (result == NULL || size < )
     {
         return ;
     }

     uint32_t *w = (uint32_t *)calloc(, sizeof(uint32_t));
     if(w == NULL)
     {
         return ;
     }

     uint32_t i; // used in for loop

     uint32_t mes_len = strlen(message);
     uint32_t looptimes = (mes_len + ) /  + ;
     uint32_t abcd[] = {0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476};

     const uint32_t k[]={
         0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,
         0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,0x698098d8,
         0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,
         0xa679438e,0x49b40821,0xf61e2562,0xc040b340,0x265e5a51,
         0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
         0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,
         0xfcefa3f8,0x676f02d9,0x8d2a4c8a,0xfffa3942,0x8771f681,
         0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,
         0xbebfbc70,0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,
         0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,0xf4292244,
         0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,
         0xffeff47d,0x85845dd1,0x6fa87e4f,0xfe2ce6e0,0xa3014314,
         0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391
     };

     const uint32_t s[]={
         ,,,,,,,,,,,,,
         ,,,,,,,,,,,,,,,,,,,
         ,,,,,,,,,,,,,,,,,,
         ,,,,,,,,,,,,,
     };

     uint32_t pos = ; // position pointer for message string
     uint32_t bkp_len =  * looptimes - mes_len;
     unsigned char *bkp_mes = (unsigned char *)calloc(, bkp_len);
     if(bkp_mes == NULL)
     {
         free(w);
         return ;
     }

     bkp_mes[] = (unsigned char)(0x80);
     uint64_t mes_bit_len = ((uint64_t)mes_len) * ;
     for(i = ; i < ; i++)
     {
         bkp_mes[bkp_len-i-] = (unsigned char)((mes_bit_len & (0x00000000000000FF << ( * ( - i)))) >> ( * ( - i)));
     }

     for(i = ; i < looptimes; i++)
     {
         memset(w, ,  * sizeof(uint32_t));

         md5_process_part1(w, message, &pos, mes_len, bkp_mes); // compute w

         md5_process_part2(abcd, w, k, s); // calculate md5 and store the result in abcd
     }

     free(w);
     free(bkp_mes);

     format_output(result, size, abcd, flag);

     return ;
 }

 #ifdef __cplusplus
 }
 #endif

2

 /**
  * @author Horst Xu
  * @date 2015-07-10
  * @contact 271021733@qq.com
  */
 #ifndef __MD5_H__
 #define __MD5_H__

 #include <stdint.h>
 #include <stddef.h>

 #ifdef __cplusplus
 extern "C" {
 #endif

 /**
  * @input: result -- store the calculation result
  *         size   -- size of result. Make sure it's at least 33
  *                   since the result is a 32-byte hexdecimal string.
  *         message-- string to be encrypted
  *         flag   -- 0 means upper case output, 1 means lower case output
  * @return: 0 -- success
  *          1 -- result size less than 33
  *          2 -- calloc failed
  */
 int32_t cal_md5(char *result, size_t size, const char *message, uint32_t flag);

 #ifdef __cplusplus
 }
 #endif

 #endif //__MD5_H__

3

 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>

 #include "md5.h"

 int32_t main(void)
 {
     char result[];
     int32_t ret = -;

     //test 1
     ret = cal_md5(result, sizeof(result), "abcdegfhijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz123", );
     if(ret ==  &&  == strncmp(result, "dd2fc541b65e2202d55beae0ecaf6528", strlen(result)))
     {
         printf("test 1 successful!\n");
     }else
     {
         printf("test 1 failed!\n");
     }

     //test 2
     ret = cal_md5(result, sizeof(result), "abcdegfhijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz1234", );
     if(ret ==  &&  == strncmp(result, "27FF2E8344E7E3F36F9C7E18D0EC82DF", strlen(result)))
     {
         printf("test 2 successful!\n");
     }else
     {
         printf("test 2 failed!\n");
     }

     //test 3
     ret = cal_md5(result, sizeof(result), "abcdegfhijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz12345", );
     if(ret ==  &&  == strncmp(result, "7A7B1279343946E3A5949BEA1B3BF8AF", strlen(result)))
     {
         printf("test 3 successful!\n");
     }else
     {
         printf("test 3 failed!\n");
     }

     //test 4
     ret = cal_md5(result, sizeof(result), "", );
     if(ret ==  &&  == strncmp(result, "d41d8cd98f00b204e9800998ecf8427e", strlen(result)))
     {
         printf("test 4 successful!\n");
     }else
     {
         printf("test 4 failed!\n");
     }

     return ;
 }