git.sur5r.net Git - openldap/blob - libraries/liblutil/md5.c

   1 /*
   2  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
   3  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   4  */
   5 /*
   6  * Modified by Kurt D. Zeilenga for inclusion into OpenLDAP
   7  * I hereby disclaim copyright in any changes I have made; this
   8  * code remains in the public domain.
   9  */
  10
  11 /*
  12  * This code implements the MD5 message-digest algorithm.
  13  * The algorithm is due to Ron Rivest.  This code was
  14  * written by Colin Plumb in 1993, no copyright is claimed.
  15  * This code is in the public domain; do with it what you wish.
  16  *
  17  * Equivalent code is available from RSA Data Security, Inc.
  18  * This code has been tested against that, and is equivalent,
  19  * except that you don't need to include two pages of legalese
  20  * with every copy.
  21  *
  22  * To compute the message digest of a chunk of bytes, declare an
  23  * MD5Context structure, pass it to MD5Init, call MD5Update as
  24  * needed on buffers full of bytes, and then call MD5Final, which
  25  * will fill a supplied 16-byte array with the digest.
  26  */
  27
  28 /* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
  29    not require an integer type which is exactly 32 bits.  This work
  30    draws on the changes for the same purpose by Tatu Ylonen
  31    <ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
  32    that code, there is no copyright issue.  I hereby disclaim
  33    copyright in any changes I have made; this code remains in the
  34    public domain.  */
  35
  36 #include "portable.h"
  37
  38 #include <ac/string.h>
  39
  40 /* include socket.h to get sys/types.h and/or winsock2.h */
  41 #include <ac/socket.h>
  42
  43 #include <lutil_md5.h>
  44
  45 /* Little-endian byte-swapping routines.  Note that these do not
  46    depend on the size of datatypes such as uint32, nor do they require
  47    us to detect the endianness of the machine we are running on.  It
  48    is possible they should be macros for speed, but I would be
  49    surprised if they were a performance bottleneck for MD5.  */
  50
  51 static uint32
  52 getu32( const unsigned char *addr )
  53 {
  54         return (((((unsigned long)addr[3] << 8) | addr[2]) << 8)
  55                 | addr[1]) << 8 | addr[0];
  56 }
  57
  58 static void
  59 putu32( uint32 data, unsigned char *addr )
  60 {
  61         addr[0] = (unsigned char)data;
  62         addr[1] = (unsigned char)(data >> 8);
  63         addr[2] = (unsigned char)(data >> 16);
  64         addr[3] = (unsigned char)(data >> 24);
  65 }
  66
  67 /*
  68  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  69  * initialization constants.
  70  */
  71 void
  72 lutil_MD5Init( struct lutil_MD5Context *ctx )
  73 {
  74         ctx->buf[0] = 0x67452301;
  75         ctx->buf[1] = 0xefcdab89;
  76         ctx->buf[2] = 0x98badcfe;
  77         ctx->buf[3] = 0x10325476;
  78
  79         ctx->bits[0] = 0;
  80         ctx->bits[1] = 0;
  81 }
  82
  83 /*
  84  * Update context to reflect the concatenation of another buffer full
  85  * of bytes.
  86  */
  87 void
  88 lutil_MD5Update(
  89     struct lutil_MD5Context     *ctx,
  90     const unsigned char         *buf,
  91     unsigned int                len
  92 )
  93 {
  94         uint32 t;
  95
  96         /* Update bitcount */
  97
  98         t = ctx->bits[0];
  99         if ((ctx->bits[0] = (t + ((uint32)len << 3)) & 0xffffffff) < t)
 100                 ctx->bits[1]++; /* Carry from low to high */
 101         ctx->bits[1] += len >> 29;
 102
 103         t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
 104
 105         /* Handle any leading odd-sized chunks */
 106
 107         if ( t ) {
 108                 unsigned char *p = ctx->in + t;
 109
 110                 t = 64-t;
 111                 if (len < t) {
 112                         memcpy(p, buf, len);
 113                         return;
 114                 }
 115                 memcpy(p, buf, t);
 116                 lutil_MD5Transform(ctx->buf, ctx->in);
 117                 buf += t;
 118                 len -= t;
 119         }
 120
 121         /* Process data in 64-byte chunks */
 122
 123         while (len >= 64) {
 124                 memcpy(ctx->in, buf, 64);
 125                 lutil_MD5Transform(ctx->buf, ctx->in);
 126                 buf += 64;
 127                 len -= 64;
 128         }
 129
 130         /* Handle any remaining bytes of data. */
 131
 132         memcpy(ctx->in, buf, len);
 133 }
 134
 135 /*
 136  * Final wrapup - pad to 64-byte boundary with the bit pattern
 137  * 1 0* (64-bit count of bits processed, MSB-first)
 138  */
 139 void
 140 lutil_MD5Final( unsigned char *digest, struct lutil_MD5Context *ctx )
 141 {
 142         unsigned count;
 143         unsigned char *p;
 144
 145         /* Compute number of bytes mod 64 */
 146         count = (ctx->bits[0] >> 3) & 0x3F;
 147
 148         /* Set the first char of padding to 0x80.  This is safe since there is
 149            always at least one byte free */
 150         p = ctx->in + count;
 151         *p++ = 0x80;
 152
 153         /* Bytes of padding needed to make 64 bytes */
 154         count = 64 - 1 - count;
 155
 156         /* Pad out to 56 mod 64 */
 157         if (count < 8) {
 158                 /* Two lots of padding:  Pad the first block to 64 bytes */
 159                 memset(p, 0, count);
 160                 lutil_MD5Transform(ctx->buf, ctx->in);
 161
 162                 /* Now fill the next block with 56 bytes */
 163                 memset(ctx->in, 0, 56);
 164         } else {
 165                 /* Pad block to 56 bytes */
 166                 memset(p, 0, count-8);
 167         }
 168
 169         /* Append length in bits and transform */
 170         putu32(ctx->bits[0], ctx->in + 56);
 171         putu32(ctx->bits[1], ctx->in + 60);
 172
 173         lutil_MD5Transform(ctx->buf, ctx->in);
 174         putu32(ctx->buf[0], digest);
 175         putu32(ctx->buf[1], digest + 4);
 176         putu32(ctx->buf[2], digest + 8);
 177         putu32(ctx->buf[3], digest + 12);
 178         memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
 179 }
 180
 181 #ifndef ASM_MD5
 182
 183 /* The four core functions - F1 is optimized somewhat */
 184
 185 /* #define F1(x, y, z) (x & y | ~x & z) */
 186 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 187 #define F2(x, y, z) F1(z, x, y)
 188 #define F3(x, y, z) (x ^ y ^ z)
 189 #define F4(x, y, z) (y ^ (x | ~z))
 190
 191 /* This is the central step in the MD5 algorithm. */
 192 #define MD5STEP(f, w, x, y, z, data, s) \
 193         ( w += f(x, y, z) + data, w &= 0xffffffff, w = w<<s | w>>(32-s), w += x )
 194
 195 /*
 196  * The core of the MD5 algorithm, this alters an existing MD5 hash to
 197  * reflect the addition of 16 longwords of new data.  MD5Update blocks
 198  * the data and converts bytes into longwords for this routine.
 199  */
 200 void
 201 lutil_MD5Transform( uint32 *buf, const unsigned char *inraw )
 202 {
 203         register uint32 a, b, c, d;
 204         uint32 in[16];
 205         int i;
 206
 207         for (i = 0; i < 16; ++i)
 208                 in[i] = getu32 (inraw + 4 * i);
 209
 210         a = buf[0];
 211         b = buf[1];
 212         c = buf[2];
 213         d = buf[3];
 214
 215         MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478,  7);
 216         MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
 217         MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
 218         MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
 219         MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf,  7);
 220         MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
 221         MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
 222         MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
 223         MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8,  7);
 224         MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
 225         MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
 226         MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
 227         MD5STEP(F1, a, b, c, d, in[12]+0x6b901122,  7);
 228         MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
 229         MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
 230         MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
 231
 232         MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562,  5);
 233         MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340,  9);
 234         MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
 235         MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
 236         MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d,  5);
 237         MD5STEP(F2, d, a, b, c, in[10]+0x02441453,  9);
 238         MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
 239         MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
 240         MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6,  5);
 241         MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6,  9);
 242         MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
 243         MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
 244         MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905,  5);
 245         MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8,  9);
 246         MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
 247         MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
 248
 249         MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942,  4);
 250         MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
 251         MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
 252         MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
 253         MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44,  4);
 254         MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
 255         MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
 256         MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
 257         MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6,  4);
 258         MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
 259         MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
 260         MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
 261         MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039,  4);
 262         MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
 263         MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
 264         MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
 265
 266         MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244,  6);
 267         MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
 268         MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
 269         MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
 270         MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3,  6);
 271         MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
 272         MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
 273         MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
 274         MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f,  6);
 275         MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
 276         MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
 277         MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
 278         MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82,  6);
 279         MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
 280         MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
 281         MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
 282
 283         buf[0] += a;
 284         buf[1] += b;
 285         buf[2] += c;
 286         buf[3] += d;
 287 }
 288 #endif
 289
 290 #ifdef TEST
 291 /* Simple test program.  Can use it to manually run the tests from
 292    RFC1321 for example.  */
 293 #include <stdio.h>
 294
 295 int
 296 main (int  argc, char **argv )
 297 {
 298         struct lutil_MD5Context context;
 299         unsigned char checksum[16];
 300         int i;
 301         int j;
 302
 303         if (argc < 2)
 304         {
 305                 fprintf (stderr, "usage: %s string-to-hash\n", argv[0]);
 306                 return EXIT_FAILURE;
 307         }
 308         for (j = 1; j < argc; ++j)
 309         {
 310                 printf ("MD5 (\"%s\") = ", argv[j]);
 311                 lutil_MD5Init (&context);
 312                 lutil_MD5Update (&context, argv[j], strlen (argv[j]));
 313                 lutil_MD5Final (checksum, &context);
 314                 for (i = 0; i < 16; i++)
 315                 {
 316                         printf ("%02x", (unsigned int) checksum[i]);
 317                 }
 318                 printf ("\n");
 319         }
 320         return EXIT_SUCCESS;
 321 }
 322 #endif /* TEST */