MD5_C_Linux

MIT-->MD5.c --> proven to be right!
/*
 **********************************************************************
 ** md5.h -- Header file for implementation of MD5                   **
 ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
 ** Created: 2/17/90 RLR                                             **
 ** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version              **
 ** Revised (for MD5): RLR 4/27/91                                   **
 **   -- G modified to have y&~z instead of y&z                      **
 **   -- FF, GG, HH modified to add in last register done            **
 **   -- Access pattern: round 2 works mod 5, round 3 works mod 3    **
 **   -- distinct additive constant for each step                    **
 **   -- round 4 added, working mod 7                                **
 **********************************************************************
 */
 
/*
 **********************************************************************
 ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
 **                                                                  **
 ** License to copy and use this software is granted provided that   **
 ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
 ** Digest Algorithm" in all material mentioning or referencing this **
 ** software or this function.                                       **
 **                                                                  **
 ** License is also granted to make and use derivative works         **
 ** provided that such works are identified as "derived from the RSA **
 ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
 ** material mentioning or referencing the derived work.             **
 **                                                                  **
 ** RSA Data Security, Inc. makes no representations concerning      **
 ** either the merchantability of this software or the suitability   **
 ** of this software for any particular purpose.  It is provided "as **
 ** is" without express or implied warranty of any kind.             **
 **                                                                  **
 ** These notices must be retained in any copies of any part of this **
 ** documentation and/or software.                                   **
 **********************************************************************
 */
 
/* typedef a 32 bit type */
typedef unsigned long int UINT4;
 
/* Data structure for MD5 (Message Digest) computation */
typedef struct {
  UINT4 i[2];                   /* number of _bits_ handled mod 2^64 */
  UINT4 buf[4];                                    /* scratch buffer */
  unsigned char in[64];                              /* input buffer */
  unsigned char digest[16];     /* actual digest after MD5Final call */
} MD5_CTX;
 
void MD5Init ();
void MD5Update ();
void MD5Final ();
 
/*
 **********************************************************************
 ** End of md5.h                                                     **
 ******************************* (cut) ********************************
 */
 
/*
 **********************************************************************
 ** md5.c                                                            **
 ** RSA Data Security, Inc. MD5 Message Digest Algorithm             **
 ** Created: 2/17/90 RLR                                             **
 ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version                  **
 **********************************************************************
 */
 
/*
 **********************************************************************
 ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
 **                                                                  **
 ** License to copy and use this software is granted provided that   **
 ** it is identified as the "RSA Data Security, Inc. MD5 Message     **
 ** Digest Algorithm" in all material mentioning or referencing this **
 ** software or this function.                                       **
 **                                                                  **
 ** License is also granted to make and use derivative works         **
 ** provided that such works are identified as "derived from the RSA **
 ** Data Security, Inc. MD5 Message Digest Algorithm" in all         **
 ** material mentioning or referencing the derived work.             **
 **                                                                  **
 ** RSA Data Security, Inc. makes no representations concerning      **
 ** either the merchantability of this software or the suitability   **
 ** of this software for any particular purpose.  It is provided "as **
 ** is" without express or implied warranty of any kind.             **
 **                                                                  **
 ** These notices must be retained in any copies of any part of this **
 ** documentation and/or software.                                   **
 **********************************************************************
 */
 
/* -- include the following line if the md5.h header file is separate -- */
/* #include "md5.h" */
 
/* forward declaration */
static void Transform ();
 
static 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
};
 
/* F, G and H are basic MD5 functions: selection, majority, parity */
#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))) 
 
/* ROTATE_LEFT rotates x left n bits */
#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) + (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); \
  }
 
void MD5Init (mdContext)
MD5_CTX *mdContext;
{
  mdContext->i[0] = mdContext->i[1] = (UINT4)0;
 
  /* Load magic initialization constants.
   */
  mdContext->buf[0] = (UINT4)0x67452301;
  mdContext->buf[1] = (UINT4)0xefcdab89;
  mdContext->buf[2] = (UINT4)0x98badcfe;
  mdContext->buf[3] = (UINT4)0x10325476;
}
 
void MD5Update (mdContext, inBuf, inLen)
MD5_CTX *mdContext;
unsigned char *inBuf;
unsigned int inLen;
{
  UINT4 in[16];
  int mdi;
  unsigned int i, ii;
 
  /* compute number of bytes mod 64 */
  mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
 
  /* update number of bits */
  if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0])
    mdContext->i[1]++;
  mdContext->i[0] += ((UINT4)inLen << 3);
  mdContext->i[1] += ((UINT4)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] = (((UINT4)mdContext->in[ii+3]) << 24) |
                (((UINT4)mdContext->in[ii+2]) << 16) |
                (((UINT4)mdContext->in[ii+1]) << 8) |
                ((UINT4)mdContext->in[ii]);
      Transform (mdContext->buf, in);
      mdi = 0;
    }
  }
}
 
void MD5Final (mdContext)
MD5_CTX *mdContext;
{
  UINT4 in[16];
  int mdi;
  unsigned int i, ii;
  unsigned int padLen;
 
  /* 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] = (((UINT4)mdContext->in[ii+3]) << 24) |
            (((UINT4)mdContext->in[ii+2]) << 16) |
            (((UINT4)mdContext->in[ii+1]) << 8) |
            ((UINT4)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);
  }
}
 
/* Basic MD5 step. Transform buf based on in.
 */
static void Transform (buf, in)
UINT4 *buf;
UINT4 *in;
{
  UINT4 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, 3614090360); /* 1 */
  FF ( d, a, b, c, in[ 1], S12, 3905402710); /* 2 */
  FF ( c, d, a, b, in[ 2], S13,  606105819); /* 3 */
  FF ( b, c, d, a, in[ 3], S14, 3250441966); /* 4 */
  FF ( a, b, c, d, in[ 4], S11, 4118548399); /* 5 */
  FF ( d, a, b, c, in[ 5], S12, 1200080426); /* 6 */
  FF ( c, d, a, b, in[ 6], S13, 2821735955); /* 7 */
  FF ( b, c, d, a, in[ 7], S14, 4249261313); /* 8 */
  FF ( a, b, c, d, in[ 8], S11, 1770035416); /* 9 */
  FF ( d, a, b, c, in[ 9], S12, 2336552879); /* 10 */
  FF ( c, d, a, b, in[10], S13, 4294925233); /* 11 */
  FF ( b, c, d, a, in[11], S14, 2304563134); /* 12 */
  FF ( a, b, c, d, in[12], S11, 1804603682); /* 13 */
  FF ( d, a, b, c, in[13], S12, 4254626195); /* 14 */
  FF ( c, d, a, b, in[14], S13, 2792965006); /* 15 */
  FF ( b, c, d, a, in[15], S14, 1236535329); /* 16 */
 
  /* Round 2 */
#define S21 5
#define S22 9
#define S23 14
#define S24 20
  GG ( a, b, c, d, in[ 1], S21, 4129170786); /* 17 */
  GG ( d, a, b, c, in[ 6], S22, 3225465664); /* 18 */
  GG ( c, d, a, b, in[11], S23,  643717713); /* 19 */
  GG ( b, c, d, a, in[ 0], S24, 3921069994); /* 20 */
  GG ( a, b, c, d, in[ 5], S21, 3593408605); /* 21 */
  GG ( d, a, b, c, in[10], S22,   38016083); /* 22 */
  GG ( c, d, a, b, in[15], S23, 3634488961); /* 23 */
  GG ( b, c, d, a, in[ 4], S24, 3889429448); /* 24 */
  GG ( a, b, c, d, in[ 9], S21,  568446438); /* 25 */
  GG ( d, a, b, c, in[14], S22, 3275163606); /* 26 */
  GG ( c, d, a, b, in[ 3], S23, 4107603335); /* 27 */
  GG ( b, c, d, a, in[ 8], S24, 1163531501); /* 28 */
  GG ( a, b, c, d, in[13], S21, 2850285829); /* 29 */
  GG ( d, a, b, c, in[ 2], S22, 4243563512); /* 30 */
  GG ( c, d, a, b, in[ 7], S23, 1735328473); /* 31 */
  GG ( b, c, d, a, in[12], S24, 2368359562); /* 32 */
 
  /* Round 3 */
#define S31 4
#define S32 11
#define S33 16
#define S34 23
  HH ( a, b, c, d, in[ 5], S31, 4294588738); /* 33 */
  HH ( d, a, b, c, in[ 8], S32, 2272392833); /* 34 */
  HH ( c, d, a, b, in[11], S33, 1839030562); /* 35 */
  HH ( b, c, d, a, in[14], S34, 4259657740); /* 36 */
  HH ( a, b, c, d, in[ 1], S31, 2763975236); /* 37 */
  HH ( d, a, b, c, in[ 4], S32, 1272893353); /* 38 */
  HH ( c, d, a, b, in[ 7], S33, 4139469664); /* 39 */
  HH ( b, c, d, a, in[10], S34, 3200236656); /* 40 */
  HH ( a, b, c, d, in[13], S31,  681279174); /* 41 */
  HH ( d, a, b, c, in[ 0], S32, 3936430074); /* 42 */
  HH ( c, d, a, b, in[ 3], S33, 3572445317); /* 43 */
  HH ( b, c, d, a, in[ 6], S34,   76029189); /* 44 */
  HH ( a, b, c, d, in[ 9], S31, 3654602809); /* 45 */
  HH ( d, a, b, c, in[12], S32, 3873151461); /* 46 */
  HH ( c, d, a, b, in[15], S33,  530742520); /* 47 */
  HH ( b, c, d, a, in[ 2], S34, 3299628645); /* 48 */
 
  /* Round 4 */
#define S41 6
#define S42 10
#define S43 15
#define S44 21
  II ( a, b, c, d, in[ 0], S41, 4096336452); /* 49 */
  II ( d, a, b, c, in[ 7], S42, 1126891415); /* 50 */
  II ( c, d, a, b, in[14], S43, 2878612391); /* 51 */
  II ( b, c, d, a, in[ 5], S44, 4237533241); /* 52 */
  II ( a, b, c, d, in[12], S41, 1700485571); /* 53 */
  II ( d, a, b, c, in[ 3], S42, 2399980690); /* 54 */
  II ( c, d, a, b, in[10], S43, 4293915773); /* 55 */
  II ( b, c, d, a, in[ 1], S44, 2240044497); /* 56 */
  II ( a, b, c, d, in[ 8], S41, 1873313359); /* 57 */
  II ( d, a, b, c, in[15], S42, 4264355552); /* 58 */
  II ( c, d, a, b, in[ 6], S43, 2734768916); /* 59 */
  II ( b, c, d, a, in[13], S44, 1309151649); /* 60 */
  II ( a, b, c, d, in[ 4], S41, 4149444226); /* 61 */
  II ( d, a, b, c, in[11], S42, 3174756917); /* 62 */
  II ( c, d, a, b, in[ 2], S43,  718787259); /* 63 */
  II ( b, c, d, a, in[ 9], S44, 3951481745); /* 64 */
 
  buf[0] += a;
  buf[1] += b;
  buf[2] += c;
  buf[3] += d;
}
 
/*
 **********************************************************************
 ** End of md5.c                                                     **
 ******************************* (cut) ********************************
 */
 
/*
 **********************************************************************
 ** md5driver.c -- sample routines to test                           **
 ** RSA Data Security, Inc. MD5 message digest algorithm.            **
 ** Created: 2/16/90 RLR                                             **
 ** Updated: 1/91 SRD                                                **
 **********************************************************************
 */
 
/*
 **********************************************************************
 ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
 **                                                                  **
 ** RSA Data Security, Inc. makes no representations concerning      **
 ** either the merchantability of this software or the suitability   **
 ** of this software for any particular purpose.  It is provided "as **
 ** is" without express or implied warranty of any kind.             **
 **                                                                  **
 ** These notices must be retained in any copies of any part of this **
 ** documentation and/or software.                                   **
 **********************************************************************
 */
 
#include
#include
#include
#include
/* -- include the following file if the file md5.h is separate -- */
/* #include "md5.h" */
 
/* Prints message digest buffer in mdContext as 32 hexadecimal digits.
   Order is from low-order byte to high-order byte of digest.
   Each byte is printed with high-order hexadecimal digit first.
 */
static void MDPrint (mdContext)
MD5_CTX *mdContext;
{
  int i;
 
  for (i = 0; i < 16; i++)
    printf ("%02x", mdContext->digest[i]);
}
 
/* size of test block */
#define TEST_BLOCK_SIZE 1000
 
/* number of blocks to process */
#define TEST_BLOCKS 10000
 
/* number of test bytes = TEST_BLOCK_SIZE * TEST_BLOCKS */
static long TEST_BYTES = (long)TEST_BLOCK_SIZE * (long)TEST_BLOCKS;
 
/* A time trial routine, to measure the speed of MD5.
   Measures wall time required to digest TEST_BLOCKS * TEST_BLOCK_SIZE
   characters.
 */
static void MDTimeTrial ()
{
  MD5_CTX mdContext;
  time_t endTime, startTime;
  unsigned char data[TEST_BLOCK_SIZE];
  unsigned int i;
 
  /* initialize test data */
  for (i = 0; i < TEST_BLOCK_SIZE; i++)
    data[i] = (unsigned char)(i & 0xFF);
 
  /* start timer */
  printf ("MD5 time trial. Processing %ld characters...\n", TEST_BYTES);
  time (&startTime);
 
  /* digest data in TEST_BLOCK_SIZE byte blocks */
  MD5Init (&mdContext);
  for (i = TEST_BLOCKS; i > 0; i--)
    MD5Update (&mdContext, data, TEST_BLOCK_SIZE);
  MD5Final (&mdContext);
 
  /* stop timer, get time difference */
  time (&endTime);
  MDPrint (&mdContext);
  printf (" is digest of test input.\n");
  printf
    ("Seconds to process test input: %ld\n", (long)(endTime-startTime));
  printf
    ("Characters processed per second: %ld\n",
     TEST_BYTES/(endTime-startTime));
}
 
/* Computes the message digest for string inString.
   Prints out message digest, a space, the string (in quotes) and a
   carriage return.
 */
static void MDString (inString)
char *inString;
{
  MD5_CTX mdContext;
  unsigned int len = strlen (inString);
 
  MD5Init (&mdContext);
  MD5Update (&mdContext, inString, len);
  MD5Final (&mdContext);
  MDPrint (&mdContext);
  printf (" \"%s\"\n\n", inString);
}
 
/* Computes the message digest for a specified file.
   Prints out message digest, a space, the file name, and a carriage
   return.
 */
static void MDFile (filename)
char *filename;
{
  FILE *inFile = fopen (filename, "rb");
  MD5_CTX mdContext;
  int bytes;
  unsigned char data[1024];
 
  if (inFile == NULL) {
    printf ("%s can't be opened.\n", filename);
    return;
  }
 
  MD5Init (&mdContext);
  while ((bytes = fread (data, 1, 1024, inFile)) != 0)
    MD5Update (&mdContext, data, bytes);
  MD5Final (&mdContext);
  MDPrint (&mdContext);
  printf (" %s\n", filename);
  fclose (inFile);
}
 
/* Writes the message digest of the data from stdin onto stdout,
   followed by a carriage return.
 */
static void MDFilter ()
{
  MD5_CTX mdContext;
  int bytes;
  unsigned char data[16];
 
  MD5Init (&mdContext);
  while ((bytes = fread (data, 1, 16, stdin)) != 0)
    MD5Update (&mdContext, data, bytes);
  MD5Final (&mdContext);
  MDPrint (&mdContext);
  printf ("\n");
}
 
/* Runs a standard suite of test data.
 */
static void MDTestSuite ()
{
  printf ("MD5 test suite results:\n\n");
  MDString ("");
  MDString ("a");
  MDString ("abc");
  MDString ("message digest");
  MDString ("abcdefghijklmnopqrstuvwxyz");
  MDString
    ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
  MDString
    ("1234567890123456789012345678901234567890\
1234567890123456789012345678901234567890");
  /* Contents of file foo are "abc" */
  MDFile ("foo");
}
 
void main (argc, argv)
int argc;
char *argv[];
{
  int i;
 
  /* For each command line argument in turn:
  ** filename          -- prints message digest and name of file
  ** -sstring          -- prints message digest and contents of string
  ** -t                -- prints time trial statistics for 1M characters
  ** -x                -- execute a standard suite of test data
  ** (no args)         -- writes messages digest of stdin onto stdout
  */
  if (argc == 1)
    MDFilter ();
  else
    for (i = 1; i < argc; i++)
      if (argv[i][0] == '-' && argv[i][1] == 's')
        MDString (argv[i] + 2);
      else if (strcmp (argv[i], "-t") == 0)
        MDTimeTrial ();
      else if (strcmp (argv[i], "-x") == 0)
        MDTestSuite ();
      else MDFile (argv[i]);
}
 
/*
 **********************************************************************
 ** End of md5driver.c                                               **
 ******************************* (cut) ********************************
 */

Another Instance --> has some problems i didnt cope with.
===========================================================================================================
/*******
*md5.h
*******/
#define md5byte     unsigned char

#define SIZEOF_UNSIGNED_LONG   4

#if SIZEOF_UNSIGNED_LONG==4
    #define UWORD32 unsigned long
#elif SIZEOF_UNSIGNED_INT==4
    #define UWORD32    unsigned int
#else
    #error I do not know what to use for a UWORD32.
#endif

typedef  struct MD5Context
{
    UWORD32 buf[4];
    UWORD32 bytes[2];
    UWORD32 in[16];
} MD5_CTX;

void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);
void MD5Final(unsigned char digest[16], struct MD5Context *context);
void MD5Transform(UWORD32 buf[4], UWORD32 const in[16]);

#define   STACK_SIZE   512
#define   MD5SUMS      "md5sums"

typedef struct md5arc
{
        char dirname[STACK_SIZE];
        char md5string[32];
}md5_arc;

typedef struct stack
{
    char file_dir[STACK_SIZE];
    int  top;
}str_dir;

static void MDString (char *string);
void md5_to_string(unsigned char *unx,char *string);
static void MDFile(const char *filename,char *store);

======================================================================================================
/*******
*MD5.c
*******/
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include      /* for ntohl() */
#include "md5.h"

void
byteSwap(UWORD32 *buf, unsigned words)
{
    md5byte *p = (md5byte *)buf;

    do {
        *buf++ = (UWORD32)((unsigned)p[3] << 8 | p[2]) << 16 |
            ((unsigned)p[1] << 8 | p[0]);
        p += 4;
    } while (--words);
}

//#define byteSwap(buf,words)

void
MD5Init(struct MD5Context *ctx)
{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;

    ctx->bytes[0] = 0;
    ctx->bytes[1] = 0;
}

void
MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)
{
    UWORD32 t;
   
    /* Update byte count */
   
    t = ctx->bytes[0];
    if ((ctx->bytes[0] = t + len) < t)
                            ctx->bytes[1]++;    /* Carry from low to high */
   
    t = 64 - (t & 0x3f);    /* Space available in ctx->in (at least 1) */
    if (t > len) {
        memcpy((md5byte *)ctx->in + 64 - t, buf, len);
        return;
    }
    /* First chunk is an odd size */
    memcpy((md5byte *)ctx->in + 64 - t, buf, t);
    byteSwap(ctx->in, 16);
    MD5Transform(ctx->buf, ctx->in);
    buf += t;
    len -= t;

    /* Process data in 64-byte chunks */
    while (len >= 64) {
        memcpy(ctx->in, buf, 64);
        byteSwap(ctx->in, 16);
        MD5Transform(ctx->buf, ctx->in);
        buf += 64;
        len -= 64;
    }
   
    /* Handle any remaining bytes of data. */
    memcpy(ctx->in, buf, len);
}

void
MD5Final(md5byte digest[16], struct MD5Context *ctx)
{
    int count = ctx->bytes[0] & 0x3f;   /* Number of bytes in ctx->in */
    md5byte *p = (md5byte *)ctx->in + count;

    /* Set the first char of padding to 0x80.  There is always room. */
    *p++ = 0x80;
    /* Bytes of padding needed to make 56 bytes (-8..55) */
    count = 56 - 1 - count;

    if (count < 0) {    /* Padding forces an extra block */
        memset(p, 0, count + 8);
        byteSwap(ctx->in, 16);
        MD5Transform(ctx->buf, ctx->in);
        p = (md5byte *)ctx->in;
        count = 56;
    }
    memset(p, 0, count);
    byteSwap(ctx->in, 14);
   
    /* Append length in bits and transform */
    ctx->in[14] = ctx->bytes[0] << 3;
    ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
    MD5Transform(ctx->buf, ctx->in);
   
    byteSwap(ctx->buf, 4);
    memcpy(digest, ctx->buf, 16);
    memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
}

#ifndef ASM_MD5

#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))

#define MD5STEP(f,w,x,y,z,in,s) \
         (w += f(x,y,z) + in, w = (w<>(32-s)) + x)
void
MD5Transform(UWORD32 buf[4], UWORD32 const in[16])
{
    register UWORD32 a, b, c, d;

    a = buf[0];
    b = buf[1];
    c = buf[2];
    d = buf[3];
   
    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);

    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);

    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);

    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);

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

#endif

/*******************
****main()*********
*******************/

static void MDPrint (unsigned char digest[1])
{
    unsigned int i;
    printf("\n");
    for(i = 0; i < 16; i++)
        printf("%02x", digest[i]);
}

int main ()// 打印出string的md5字符串
{
    char * string = "a";
    MD5_CTX  context;
    unsigned char digest[16];
    unsigned int len = strlen(string);
    MD5Init(&context);
    MD5Update(&context, string, len);
    MD5Final(digest, &context);
    printf("%s = ", string);
    MDPrint(digest);
    printf("\n");
}

========================================================================================================
/***********
*never try
***********/

1. void
2. md5_to_string(unsigned char *unx,char *string)
3. {
4.     int i;
5.     char temp[3];
6.     if(unx==NULL || string==NULL)
7.         return;
8.     
9.     for(i=0;i<16;i++)
10.     {
11.         if(i==0)
12.         {
13.             sprintf(temp,"%02x",unx[i]);
14.             strcpy(string,temp);
15.         }
16.         else
17.         {
18.             sprintf(temp,"%02x",unx[i]);
19.             strcat(string,temp);
20.         }
21.     }
22. }
23. 
    
24. static void MDFile(const char *filename,char *store)
25. {                      //计算文件filename的md5串，并保存到store中
26.     FILE    *fd;
27.     char    buffer[120];
28.     struct  stat  buf;
29.     int     size;
30.     int     blocknum;
31.     int     resize;
32.     int     i;
33.     
34.     unsigned char digest[16];
35.     MD5_CTX  context;
36.     
37.     if(lstat(filename,&buf)<0)
38.     {
39.         printf("stat file error: %s\n",filename);
40.         exit(1);
41.     }
42.     if(buf.st_size==0)
43.         size=buf.st_size;
44.     else
45.         size=buf.st_size-1;
46.     
47.     if((fd=fopen(filename,"r+"))==NULL)
48.     {
49.         printf("open file: %s error\n",filename);
50.         exit(1);
51.     }
52.     
53.     MD5Init(&context);
54.     
55.     if(size<=120)
56.     {
57.         fread(buffer,size,1,fd);
58. 
    
59.         MD5Update(&context,buffer,size);
60.         MD5Final(digest,&context);
61.         fclose(fd);
62.     }
63.     else
64.     {
65.         blocknum=size/120;
66.         resize=size-blocknum*120;
67.         for(i=0;i
68.         {
69.             fread(buffer,120,1,fd);
70.             MD5Update(&context,buffer,120);
71.         }
72.         
73.         fread(buffer,resize,1,fd);
74.         MD5Update(&context,buffer,resize);
75.         MD5Final(digest,&context);
76.         fclose(fd);
77.     }
78. 
    
79.  //   printf("filename2:%s\n",filename);
80.     
81.     md5_to_string(digest,store);
82. #ifdef _DEBUG_MESSAGE_
83.     MDPrint(digest);
84.     printf("\nin md5 file store is:%s\n",store);
85.     
86. #endif
87.  //   printf("filename3:%s\n",filename);
88. }
89. 
    
90. 
    
91. void
92. init_stack(str_dir *std)
93. {
94.   std->top=-1;
95. }
96. 
    
97. void
98. pushchar(str_dir *std,char *ar )
99. {
100.     if(std->top>=STACK_SIZE-1)
101.     {
102.         printf("stack is full\n");
103.         exit(0);
104.     }
105.     if(std->top<0)
106.         strcpy(std->file_dir,ar);
107.     else
108.         strcat(std->file_dir,ar);
109.     std->top+=strlen(ar);
110.     std->file_dir[std->top+1]='\0';
111. }
112. 
     
113. 
     
114. void
115. popchar(str_dir *std,int num)
116. {
117.     if (std->top==-1)
118.     {
119.         printf("stack is null\n");
120.         exit(0);
121.     }
122.     char buf[STACK_SIZE];
123.     strcpy(buf,std->file_dir);
124.     memset(std->file_dir,0,strlen(std->file_dir));
125.     memcpy(std->file_dir,buf,std->top-num+1);
126.     std->top-=num;
127.     std->file_dir[std->top+1]='\0';
128. 
     
129. }
130. 
     
131. 
     
132. void
133. trave_dir(char *dirname, str_dir *std,FILE *fd)
134. {                           //遍历计 算目录dirname中文件的md5串
135.     DIR * dp;               //并保存文件路径+该文件的md5串到fd中
136.     struct dirent * entry;
137.     struct stat statbuf;
138. 
     
139.     if ((dp=opendir(dirname))==NULL)
140.     {
141.         printf("can't open directory:%s\n",dirname);
142.         
143.         exit(1);
144.     }
145. #ifdef  _DEBUF_MESSAGE_
146.     char pwd[60];
147.     getcwd(pwd,60);
148.     printf("before chdir dir is: %s\n",pwd);
149. #endif
150.     
151.     chdir(dirname);
152. #ifdef  _DEBUG_MESSAGE_
153.     getcwd(pwd,60);
154.     printf("after chdir dir is: %s\n",pwd);
155. #endif
156.     while ((entry=readdir(dp))!=NULL)
157.     {
158.        if(strcmp(entry->d_name,"netpower")==0)
159.             continue;
160.         lstat(entry -> d_name,&statbuf);
161.         if (S_ISREG(statbuf.st_mode))
162.         {
163.              
164.             md5_arc *md5h;
165.             md5h=(md5_arc *)malloc(sizeof(md5_arc));
166.             
167.             pushchar(std,"/");
168.             pushchar(std,entry->d_name);
169. 
     
170.                                                                                                     
171.             strcpy(md5h->dirname,std->file_dir);
172.             
173.             MDFile(entry->d_name,md5h->md5string);
174.             
175.             fprintf(fd,"%s ",md5h->md5string);
176.             fprintf(fd,"%s\n",md5h->dirname);
177. #ifdef  _DEBUG_MESSAGE_
178.             printf("%s\n",std->file_dir);
179. #endif
180.             popchar(std,strlen(entry->d_name)+1);
181.             
182.          
183.         }
184.         else if(S_ISDIR(statbuf.st_mode))
185.         {
186.             if (strcmp(".",entry -> d_name)==0||strcmp("..",entry -> d_name)==0)
187.                 continue;
188.             pushchar(std,"/");
189.             pushchar(std,entry->d_name);
190.             trave_dir(entry->d_name,std,fd);
191.             popchar(std,strlen(entry->d_name)+1);
192.         }
193.         else 
194.             continue;
195.     }
196.     chdir("..");
197.     
198.     closedir(dp);
199. #ifdef  _DEBUG_MDSSAGE_
200.     char pwd2[60];
201.     getcwd(pwd2,60);
202.     printf("after read dir  is: %s\n",pwd2);
203. #endif
204. }
205. 
     
206. 
     
207. 
     
208. void 
209. readchar(FILE *fd,char *store,char end)
210. {
211.     char buf1[16];
212.     unsigned char buf2[16];
213.     char b;
214.     int i=0;
215.     while((b=fgetc(fd))!=end)
216.     {  
217.         if(feof(fd))
218.             return;
219.         store[i]=b;
220.         i++;
221.     }
222.         store[i]='\0';
223.          
224.         
225. }
226. 
     
227. void 
228. creat_md5sums(char *dirname,char *md5file)
229. //对一个目录dirname生成一个md5 文件
230. //里面保存着目录中的文件的路径及对应文件md5串。类似于:  
231. // home/test/test1  7c2008f71c02e6f08a40cd7244ee3e79  
232. // home/test/test2  f970e2767d0cfe75876ea857f92e319b    
233. {   
234.     FILE *fd;
235.     if((fd=fopen(md5file,"a+"))==NULL)
236.     {
237.         printf("open file error\n");
238. 
     
239.         exit(1);
240.     }
241.     str_dir  *std;
242.     std=(str_dir *)malloc(sizeof(str_dir));
243.     init_stack(std);
244.     pushchar(std,dirname);
245.     
246.     trave_dir(dirname,std,fd);
247.     free(std);
248.     fclose(fd);
249.                                             
250. }
251. 
     
252. int
253. check(char *md5file) //对目录进行md5检验
254. {
255.     FILE *fd;
256.     char md5string[32];
257.     char filedir[STACK_SIZE];
258.     char checkstring[32];
259.     char buf[STACK_SIZE];
260.     int  flag=1;
261. #ifdef  _DEBUG_MESSAGE
262.     printf("md5file :%s\n",md5file);
263. #endif
264.                       
265.     if((fd=fopen(md5file,"r"))==NULL)
266.     {
267.         printf("open md5sums error\n");
268.     }
269.     while(!feof(fd))
270.     {
271.         readchar(fd,md5string,' ');
272.         readchar(fd,filedir,'\n');
273.         if(feof(fd))
274.             break;
275. 
     
276.         strcpy(buf,filedir);
277.         MDFile(filedir,checkstring);
278.         if(strcmp(md5string,checkstring)==0)
279.             printf("check file:  %s      ......yes\n",buf);
280.         if(strcmp(md5string,checkstring)!=0)
281.         {
282.             printf("check file:  %s      ......no\n",buf);
283.             flag=0;
284.         }
285.     }
286.     fclose(fd);
287.     return flag;
288. 
     
289. }