MD5的C代码那不满天飞。你还上这里来找，真是!@#$%^&*

/*
* 示例代码中假设int型是32-bit的
*/

/************************************************************************
*                                                                      *
*                               Head File                              *
*                                                                      *
************************************************************************/

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

/************************************************************************
*                                                                      *
*                               Macro                                  *
*                                                                      *
************************************************************************/

/*
* F, G, H and I are basic MD5 functions
*/
#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 ) ) ) )

/*
* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4
* Rotation is separate from addition to prevent recomputation
*/
#define FF( a, b, c, d, x, s, ac ) \
{ \
    ( a ) += F( ( b ), ( c ), ( d ) ) + ( x ) + ( unsigned int )( ac ); \
    ( a )  = ROTATE_LEFT( ( a ), ( s ) ); \
    ( a ) += ( b ); \
}
#define GG( a, b, c, d, x, s, ac ) \
{ \
    ( a ) += G( ( b ), ( c ), ( d ) ) + ( x ) + ( unsigned int )( ac ); \
    ( a )  = ROTATE_LEFT( ( a ), ( s ) ); \
    ( a ) += ( b ); \
}
#define HH( a, b, c, d, x, s, ac ) \
{ \
    ( a ) += H( ( b ), ( c ), ( d ) ) + ( x ) + ( unsigned int )( ac ); \
    ( a )  = ROTATE_LEFT( ( a ), ( s ) ); \
    ( a ) += ( b ); \
}
#define II( a, b, c, d, x, s, ac ) \
{ \
    ( a ) += I( ( b ), ( c ), ( d ) ) + ( x ) + ( unsigned int )( ac ); \
    ( a )  = ROTATE_LEFT( ( a ), ( s ) ); \
    ( a ) += ( b ); \
}

/*
* Data structure for MD5 (Message-Digest) computation
*/
typedef struct
{
    /*
     * number of _bits_ handled mod 2^64
     */
    unsigned int  i[2];
    /*
     * scratch buffer
     */
    unsigned int  buf[4];
    /*
     * input buffer
     */
    unsigned char in[64];
    /*
     * actual digest after MD5Final call
     */
    unsigned char digest[16];
} MD5_CTX;

/************************************************************************
*                                                                      *
*                            Function Prototype                        *
*                                                                      *
************************************************************************/

static void md5       ( unsigned char *in, unsigned int insize,
                        unsigned char *out );
static void MD5Final  ( MD5_CTX *mdContext );
static void MD5Init   ( MD5_CTX *mdContext );
static void MD5Update ( MD5_CTX *mdContext, unsigned char *inBuf,
                        unsigned int inLen );
static void Transform ( unsigned int *buf, unsigned int *in );

/************************************************************************
*                                                                      *
*                            Static Global Var                         *
*                                                                      *
************************************************************************/

/************************************************************************/

static void md5 ( unsigned char *in, unsigned int insize, unsigned char *out )
{

#define MD5_BUFSIZE 4096

    unsigned char  buf[ MD5_BUFSIZE ];
    MD5_CTX        mdbuf;
    unsigned char *p;
    unsigned int   i, j;

    MD5Init( &mdbuf );
    i = insize;
    p = in;
    for ( ; ; )
    {
        if ( i > MD5_BUFSIZE )
        {
            for ( j = 0; j < MD5_BUFSIZE; j++ )
            {
                buf[j] = p[j];
            }
            MD5Update( &mdbuf, buf, MD5_BUFSIZE );
            i -= MD5_BUFSIZE;
            p += MD5_BUFSIZE;
        }
        else
        {
            for ( j = 0; j < i; j++ )
            {
                buf[j] = p[j];
            }
            MD5Update( &mdbuf, buf, i );
            break;
        }
    }  /* end of for */
    MD5Final( &mdbuf );
    for ( i = 0; i < 16; i++ )
    {
        out[i] = mdbuf.digest[i];
    }
    return;
}  /* end of md5 */

/*
* MD5Final terminates the message-digest computation and ends with the
* desired message digest in mdContext->digest[0..15]
*/
static void MD5Final ( MD5_CTX *mdContext )
{
    unsigned int  in[16];
    int           mdi;
    unsigned int  i, ii;
    unsigned int  padLen;
    unsigned char PADDING[64] =
    {
        0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    };

    /*
     * save number of bits
     */
    in[14] = mdContext->i[0];
    in[15] = mdContext->i[1];
    /*
     * compute number of bytes mod 64
     */
    mdi    = ( int )( ( mdContext->i[0] >> 3 ) & 0x3F );
    /*
     * pad out to 56 mod 64
     */
    padLen = ( mdi < 56 ) ? ( 56 - mdi ) : ( 120 - mdi );
    MD5Update( mdContext, PADDING, padLen );
    /*
     * append length in bits and transform
     */
    for ( i = 0, ii = 0; i < 14; i++, ii += 4 )
    {
        in[i] = ( ( ( unsigned int )mdContext->in[ii+3] ) << 24 ) |
                ( ( ( unsigned int )mdContext->in[ii+2] ) << 16 ) |
                ( ( ( unsigned int )mdContext->in[ii+1] ) << 8  ) |
                  ( ( unsigned int )mdContext->in[ii]   );
    }
    Transform ( mdContext->buf, in );
    /*
     * store buffer in digest
     */
    for ( i = 0, ii = 0; i < 4; i++, ii += 4 )
    {
        mdContext->digest[ii]   =
            ( unsigned char )( mdContext->buf[i] & 0xFF);
        mdContext->digest[ii+1] =
            ( unsigned char )( ( mdContext->buf[i] >> 8  ) & 0xFF );
        mdContext->digest[ii+2] =
            ( unsigned char )( ( mdContext->buf[i] >> 16 ) & 0xFF );
        mdContext->digest[ii+3] =
            ( unsigned char )( ( mdContext->buf[i] >> 24 ) & 0xFF );
    }  /* end of for */
    return;
}  /* end of MD5Final */

/*
* MD5Init initializes the message-digest context mdContext.
* All fields are set to zero
*/
static void MD5Init ( MD5_CTX *mdContext )
{
    mdContext->i[0]   = mdContext->i[1] = ( unsigned int )0;
    /*
     * Load magic initialization constants
     */
    mdContext->buf[0] = ( unsigned int )0x67452301;
    mdContext->buf[1] = ( unsigned int )0xefcdab89;
    mdContext->buf[2] = ( unsigned int )0x98badcfe;
    mdContext->buf[3] = ( unsigned int )0x10325476;
    return;
}  /* end of MD5Init */

/*
* MD5Update updates the message-digest context to account for the
* presence of each of the characters inBuf[0..inLen-1] in the message
* whose digest is being computed.
*/
static void MD5Update ( MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen )
{
    unsigned int in[16];
    int          mdi;
    unsigned int i, ii;

    /*
     * compute number of bytes mod 64
     */
    mdi = ( int )( ( mdContext->i[0] >> 3 ) & 0x3F );
    if ( ( mdContext->i[0] + ( ( unsigned int )inLen << 3 ) ) < mdContext->i[0] )
    {
        mdContext->i[1]++;
    }
    mdContext->i[0] += ( ( unsigned int )inLen << 3  );
    mdContext->i[1] += ( ( unsigned int )inLen >> 29 );
    while ( inLen-- )
    {
        /*
         * add new character to buffer, increment mdi
         */
        mdContext->in[ mdi++ ] = *inBuf++;
        /*
         * transform if necessary
         */
        if ( mdi == 0x40 )
        {
            for ( i = 0, ii = 0; i < 16; i++, ii += 4 )
            {
                in[i] = ( ( ( unsigned int )mdContext->in[ii+3] ) << 24 ) |
                        ( ( ( unsigned int )mdContext->in[ii+2] ) << 16 ) |
                        ( ( ( unsigned int )mdContext->in[ii+1] ) << 8  ) |
                          ( ( unsigned int )mdContext->in[ii]   );
            }  /* end of for */
            Transform( mdContext->buf, in );
            mdi = 0;
        }
    }  /* end of while */
    return;
}  /* end of MD5Update */

/*
* Basic MD5 step. Transforms buf based on in.
*/
static void Transform ( unsigned int *buf, unsigned int *in )
{
    unsigned int a = buf[0], b = buf[1], c = buf[2], d = buf[3];

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

    buf[0] += a;
    buf[1] += b;
    buf[2] += c;
    buf[3] += d;

    return;
}  /* end of Transform */

/*
* Validation sets:
*
* Plain : 61 62 63
* MD5   : 90 01 50 98 3c d2 4f b0 d6 96 3f 7d 28 e1 7f 72
*/

int main ( int argc, char * argv[] )
{
    int           i;
    unsigned char plain[] =
    {
        0x61, 0x62, 0x63,
    };
    /*
     * 无论数据源有多少字节，MD5固定产生128-bit的哈希值，16字节
     */
    unsigned char hash[16];

    md5( plain, sizeof( plain ), hash );
    printf( "md5: " );
    for ( i = 0; i < sizeof( hash ); i++ )
    {
        printf( "%02x%c", hash[i], i == ( sizeof( hash ) - 1 ) ? '\n' : ' ' );
    }

    return( EXIT_SUCCESS );
}  /* end of main */