计算 md5

代码从polarssl中扒来的，略作改动，md5.h & md5.cpp 如下

 #ifndef POLARSSL_MD5_H
 #define POLARSSL_MD5_H

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

 class md5
 {
 public:
     void    string_md5(const unsigned char *input, size_t ilen, unsigned char output[]);

     // open file failed return -1;
     int        file_md5(const char *path, unsigned char output[]);

 private:
     typedef struct
     {
         uint32_t total[];          /*!< number of bytes processed  */
         uint32_t state[];          /*!< intermediate digest state  */
         unsigned char buffer[];   /*!< data block being processed */

         unsigned char ipad[];     /*!< HMAC: inner padding        */
         unsigned char opad[];     /*!< HMAC: outer padding        */
     }
     md5_context;

     void md5_init(md5_context *ctx);

     void md5_free(md5_context *ctx);

     void md5_starts(md5_context *ctx);

     void md5_update(md5_context *ctx, const unsigned char *input, size_t ilen);

     void md5_finish(md5_context *ctx, unsigned char output[]);

     void md5_process(md5_context *ctx, const unsigned char data[]);
 };

 #endif // POLARSSL_MD5_H

 #include "md5.h"
 #include <stdio.h>

 /*
 * 32-bit integer manipulation macros (little endian)
 */
 #ifndef GET_UINT32_LE
 #define GET_UINT32_LE(n,b,i)                            \
 {                                                       \
     (n) = ( (uint32_t) (b)[(i)    ]       )             \
         | ( (uint32_t) (b)[(i) + ] <<   )             \
         | ( (uint32_t) (b)[(i) + ] <<  )             \
         | ( (uint32_t) (b)[(i) + ] <<  );            \
 }
 #endif

 #ifndef PUT_UINT32_LE
 #define PUT_UINT32_LE(n,b,i)                            \
 {                                                       \
     (b)[(i)    ] = (unsigned char) ( (n)       );       \
     (b)[(i) + ] = (unsigned char) ( (n) >>   );       \
     (b)[(i) + ] = (unsigned char) ( (n) >>  );       \
     (b)[(i) + ] = (unsigned char) ( (n) >>  );       \
 }
 #endif

 void md5::md5_init(md5_context *ctx)
 {
     memset(ctx, , sizeof(md5_context));
 }

 void md5::md5_free(md5_context *ctx)
 {
     if (ctx == NULL)
         return;

     size_t    n = sizeof(md5_context);
     volatile unsigned char *p = (unsigned char*)ctx; while (n--) *p++ = ;
 }

 /*
 * MD5 context setup
 */
 void md5::md5_starts(md5_context *ctx)
 {
     ctx->total[] = ;
     ctx->total[] = ;

     ctx->state[] = 0x67452301;
     ctx->state[] = 0xEFCDAB89;
     ctx->state[] = 0x98BADCFE;
     ctx->state[] = 0x10325476;
 }

 void md5::md5_process(md5_context *ctx, const unsigned char data[])
 {
     uint32_t X[], A, B, C, D;

     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );
     GET_UINT32_LE(X[], data, );

 #define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))

 #define P(a,b,c,d,k,s,t)                                \
     {                                                       \
     a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           \
     }

     A = ctx->state[];
     B = ctx->state[];
     C = ctx->state[];
     D = ctx->state[];

 #define F(x,y,z) (z ^ (x & (y ^ z)))

     P(A, B, C, D, , , 0xD76AA478);
     P(D, A, B, C, , , 0xE8C7B756);
     P(C, D, A, B, , , 0x242070DB);
     P(B, C, D, A, , , 0xC1BDCEEE);
     P(A, B, C, D, , , 0xF57C0FAF);
     P(D, A, B, C, , , 0x4787C62A);
     P(C, D, A, B, , , 0xA8304613);
     P(B, C, D, A, , , 0xFD469501);
     P(A, B, C, D, , , 0x698098D8);
     P(D, A, B, C, , , 0x8B44F7AF);
     P(C, D, A, B, , , 0xFFFF5BB1);
     P(B, C, D, A, , , 0x895CD7BE);
     P(A, B, C, D, , , 0x6B901122);
     P(D, A, B, C, , , 0xFD987193);
     P(C, D, A, B, , , 0xA679438E);
     P(B, C, D, A, , , 0x49B40821);

 #undef F

 #define F(x,y,z) (y ^ (z & (x ^ y)))

     P(A, B, C, D, , , 0xF61E2562);
     P(D, A, B, C, , , 0xC040B340);
     P(C, D, A, B, , , 0x265E5A51);
     P(B, C, D, A, , , 0xE9B6C7AA);
     P(A, B, C, D, , , 0xD62F105D);
     P(D, A, B, C, , , 0x02441453);
     P(C, D, A, B, , , 0xD8A1E681);
     P(B, C, D, A, , , 0xE7D3FBC8);
     P(A, B, C, D, , , 0x21E1CDE6);
     P(D, A, B, C, , , 0xC33707D6);
     P(C, D, A, B, , , 0xF4D50D87);
     P(B, C, D, A, , , 0x455A14ED);
     P(A, B, C, D, , , 0xA9E3E905);
     P(D, A, B, C, , , 0xFCEFA3F8);
     P(C, D, A, B, , , 0x676F02D9);
     P(B, C, D, A, , , 0x8D2A4C8A);

 #undef F

 #define F(x,y,z) (x ^ y ^ z)

     P(A, B, C, D, , , 0xFFFA3942);
     P(D, A, B, C, , , 0x8771F681);
     P(C, D, A, B, , , 0x6D9D6122);
     P(B, C, D, A, , , 0xFDE5380C);
     P(A, B, C, D, , , 0xA4BEEA44);
     P(D, A, B, C, , , 0x4BDECFA9);
     P(C, D, A, B, , , 0xF6BB4B60);
     P(B, C, D, A, , , 0xBEBFBC70);
     P(A, B, C, D, , , 0x289B7EC6);
     P(D, A, B, C, , , 0xEAA127FA);
     P(C, D, A, B, , , 0xD4EF3085);
     P(B, C, D, A, , , 0x04881D05);
     P(A, B, C, D, , , 0xD9D4D039);
     P(D, A, B, C, , , 0xE6DB99E5);
     P(C, D, A, B, , , 0x1FA27CF8);
     P(B, C, D, A, , , 0xC4AC5665);

 #undef F

 #define F(x,y,z) (y ^ (x | ~z))

     P(A, B, C, D, , , 0xF4292244);
     P(D, A, B, C, , , 0x432AFF97);
     P(C, D, A, B, , , 0xAB9423A7);
     P(B, C, D, A, , , 0xFC93A039);
     P(A, B, C, D, , , 0x655B59C3);
     P(D, A, B, C, , , 0x8F0CCC92);
     P(C, D, A, B, , , 0xFFEFF47D);
     P(B, C, D, A, , , 0x85845DD1);
     P(A, B, C, D, , , 0x6FA87E4F);
     P(D, A, B, C, , , 0xFE2CE6E0);
     P(C, D, A, B, , , 0xA3014314);
     P(B, C, D, A, , , 0x4E0811A1);
     P(A, B, C, D, , , 0xF7537E82);
     P(D, A, B, C, , , 0xBD3AF235);
     P(C, D, A, B, , , 0x2AD7D2BB);
     P(B, C, D, A, , , 0xEB86D391);

 #undef F

     ctx->state[] += A;
     ctx->state[] += B;
     ctx->state[] += C;
     ctx->state[] += D;
 }

 /*
 * MD5 process buffer
 */
 void md5::md5_update(md5_context *ctx, const unsigned char *input, size_t ilen)
 {
     size_t fill;
     uint32_t left;

     if (ilen == )
         return;

     left = ctx->total[] & 0x3F;
     fill =  - left;

     ctx->total[] += (uint32_t)ilen;
     ctx->total[] &= 0xFFFFFFFF;

     if (ctx->total[] < (uint32_t)ilen)
         ctx->total[]++;

     if (left && ilen >= fill)
     {
         memcpy((void *)(ctx->buffer + left), input, fill);
         md5_process(ctx, ctx->buffer);
         input += fill;
         ilen -= fill;
         left = ;
     }

     while (ilen >= )
     {
         md5_process(ctx, input);
         input += ;
         ilen -= ;
     }

     if (ilen > )
     {
         memcpy((void *)(ctx->buffer + left), input, ilen);
     }
 }

 static const unsigned char md5_padding[] =
 {
     0x80, , , , , , , , , , , , , , , ,
     , , , , , , , , , , , , , , , ,
     , , , , , , , , , , , , , , , ,
     , , , , , , , , , , , , , , ,
 };

 /*
 * MD5 final digest
 */
 void md5::md5_finish(md5_context *ctx, unsigned char output[])
 {
     uint32_t last, padn;
     uint32_t high, low;
     unsigned char msglen[];

     high = (ctx->total[] >> )
         | (ctx->total[] << );
     low = (ctx->total[] << );

     PUT_UINT32_LE(low, msglen, );
     PUT_UINT32_LE(high, msglen, );

     last = ctx->total[] & 0x3F;
     padn = (last < ) ? ( - last) : ( - last);

     md5_update(ctx, md5_padding, padn);
     md5_update(ctx, msglen, );

     PUT_UINT32_LE(ctx->state[], output, );
     PUT_UINT32_LE(ctx->state[], output, );
     PUT_UINT32_LE(ctx->state[], output, );
     PUT_UINT32_LE(ctx->state[], output, );
 }

 /*
 * output = MD5( input buffer )
 */
 void md5::string_md5(const unsigned char *input, size_t ilen, unsigned char output[])
 {
     md5_context ctx;

     md5_init(&ctx);
     md5_starts(&ctx);
     md5_update(&ctx, input, ilen);
     md5_finish(&ctx, output);
     md5_free(&ctx);
 }

 /*
 * output = MD5( file contents )
 */
 int md5::file_md5(const char *path, unsigned char output[])
 {
     FILE *f;
     size_t n;
     md5_context ctx;
     unsigned char buf[];

     if ((f = fopen(path, "rb")) == NULL)
         return    -;

     md5_init(&ctx);
     md5_starts(&ctx);

     while ((n = fread(buf, , sizeof(buf), f)) > )
         md5_update(&ctx, buf, n);

     md5_finish(&ctx, output);
     md5_free(&ctx);

     if (ferror(f) != )
     {
         fclose(f);
         return    -;
     }

     fclose(f);
     return();
 }