modules/crypto/md5/md5c.c

   1 /*
   2  *  Copyright Droids Corporation, Microb Technology, Eirbot (2005)
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  *  Revision : $Id: md5c.c,v 1.3.4.1 2006-11-26 21:06:02 zer0 Exp $
  19  *
  20  */
  21
  22 /* From MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm */
  23
  24 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
  25 rights reserved.
  26
  27 License to copy and use this software is granted provided that it
  28 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
  29 Algorithm" in all material mentioning or referencing this software
  30 or this function.
  31
  32 License is also granted to make and use derivative works provided
  33 that such works are identified as "derived from the RSA Data
  34 Security, Inc. MD5 Message-Digest Algorithm" in all material
  35 mentioning or referencing the derived work.
  36
  37 RSA Data Security, Inc. makes no representations concerning either
  38 the merchantability of this software or the suitability of this
  39 software for any particular purpose. It is provided "as is"
  40 without express or implied warranty of any kind.
  41
  42 These notices must be retained in any copies of any part of this
  43 documentation and/or software.
  44 */
  45
  46 #include <string.h>
  47 #include "md5.h"
  48
  49 /* POINTER defines a generic pointer type */
  50 typedef unsigned char *POINTER;
  51
  52 /* Constants for MD5Transform routine.
  53  */
  54 #define S11 7
  55 #define S12 12
  56 #define S13 17
  57 #define S14 22
  58 #define S21 5
  59 #define S22 9
  60 #define S23 14
  61 #define S24 20
  62 #define S31 4
  63 #define S32 11
  64 #define S33 16
  65 #define S34 23
  66 #define S41 6
  67 #define S42 10
  68 #define S43 15
  69 #define S44 21
  70
  71 static void MD5Transform (uint32_t [4], const unsigned char [64]);
  72
  73 #if BYTE_ORDER == LITTLE_ENDIAN
  74 #define Encode memcpy
  75 #define Decode memcpy
  76 #else /* BIG_ENDIAN */
  77 static void Encode (unsigned char *, uint32_t *, unsigned int);
  78 static void Decode (uint32_t *, const unsigned char *, unsigned int);
  79 #endif /* LITTLE_ENDIAN */
  80
  81 static unsigned char PADDING[64] = {
  82         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  83         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  84         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  85 };
  86
  87 /* F, G, H and I are basic MD5 functions.
  88  */
  89 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  90 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  91 #define H(x, y, z) ((x) ^ (y) ^ (z))
  92 #define I(x, y, z) ((y) ^ ((x) | (~z)))
  93
  94 /* ROTATE_LEFT rotates x left n bits.
  95  */
  96 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  97
  98 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
  99    Rotation is separate from addition to prevent recomputation.
 100 */
 101 #define FF(a, b, c, d, x, s, ac) { \
 102  (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
 103  (a) = ROTATE_LEFT ((a), (s)); \
 104  (a) += (b); \
 105   }
 106 #define GG(a, b, c, d, x, s, ac) { \
 107  (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
 108  (a) = ROTATE_LEFT ((a), (s)); \
 109  (a) += (b); \
 110   }
 111 #define HH(a, b, c, d, x, s, ac) { \
 112  (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
 113  (a) = ROTATE_LEFT ((a), (s)); \
 114  (a) += (b); \
 115   }
 116 #define II(a, b, c, d, x, s, ac) { \
 117  (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
 118  (a) = ROTATE_LEFT ((a), (s)); \
 119  (a) += (b); \
 120   }
 121
 122 #if BYTE_ORDER != LITTLE_ENDIAN
 123 /* Encodes input (uint32_t) into output (unsigned char). Assumes len is
 124    a multiple of 4.
 125 */
 126 static void Encode (output, input, len)
 127      unsigned char *output;
 128      uint32_t *input;
 129      unsigned int len;
 130 {
 131         unsigned int i, j;
 132
 133         for (i = 0, j = 0; j < len; i++, j += 4) {
 134                 output[j] = (unsigned char)(input[i] & 0xff);
 135                 output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 136                 output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 137                 output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 138         }
 139 }
 140
 141 /* Decodes input (unsigned char) into output (uint32_t). Assumes len is
 142    a multiple of 4.
 143 */
 144 static void Decode (output, input, len)
 145      uint32_t *output;
 146      const unsigned char *input;
 147      unsigned int len;
 148 {
 149         unsigned int i, j;
 150
 151         for (i = 0, j = 0; j < len; i++, j += 4)
 152                 output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) |
 153                         (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24);
 154 }
 155 #endif /* !LITTLE_ENDIAN */
 156
 157 /* MD5 initialization. Begins an MD5 operation, writing a new context.
 158  */
 159 void MD5Init (context)
 160      MD5_CTX *context;                                        /* context */
 161 {
 162         context->count[0] = context->count[1] = 0;
 163         /* Load magic initialization constants.  */
 164         context->state[0] = 0x67452301;
 165         context->state[1] = 0xefcdab89;
 166         context->state[2] = 0x98badcfe;
 167         context->state[3] = 0x10325476;
 168 }
 169
 170 /* MD5 block update operation. Continues an MD5 message-digest
 171    operation, processing another message block, and updating the
 172    context.
 173 */
 174 void MD5Update (context, input, inputLen)
 175      MD5_CTX *context;                                        /* context */
 176      const unsigned char *input;                                /* input block */
 177      unsigned int inputLen;                     /* length of input block */
 178 {
 179         unsigned int i, index, partLen;
 180
 181         /* Compute number of bytes mod 64 */
 182         index = (unsigned int)((context->count[0] >> 3) & 0x3F);
 183
 184         /* Update number of bits */
 185         if ((context->count[0] += ((uint32_t)inputLen << 3))
 186             < ((uint32_t)inputLen << 3))
 187                 context->count[1]++;
 188         context->count[1] += ((uint32_t)inputLen >> 29);
 189
 190         partLen = 64 - index;
 191
 192         /* Transform as many times as possible.  */
 193         if (inputLen >= partLen) {
 194                 memcpy ((POINTER)&context->buffer[index], (POINTER)input, partLen);
 195                 MD5Transform (context->state, context->buffer);
 196
 197                 for (i = partLen; i + 63 < inputLen; i += 64)
 198                         MD5Transform (context->state, &input[i]);
 199
 200                 index = 0;
 201         }
 202         else
 203                 i = 0;
 204
 205         /* Buffer remaining input */
 206         memcpy((POINTER)&context->buffer[index], (POINTER)&input[i],
 207                  inputLen-i);
 208 }
 209
 210 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 211    the message digest and zeroizing the context.
 212 */
 213 void MD5Final (digest, context)
 214      unsigned char digest[16];                         /* message digest */
 215      MD5_CTX *context;                                       /* context */
 216 {
 217         unsigned char bits[8];
 218         unsigned int index, padLen;
 219
 220         /* Save number of bits */
 221         Encode (bits, context->count, 8);
 222
 223         /* Pad out to 56 mod 64.  */
 224         index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 225         padLen = (index < 56) ? (56 - index) : (120 - index);
 226         MD5Update (context, PADDING, padLen);
 227
 228         /* Append length (before padding) */
 229         MD5Update (context, bits, 8);
 230         /* Store state in digest */
 231         Encode (digest, context->state, 16);
 232
 233         /* Zeroize sensitive information.  */
 234         memset ((POINTER)context, 0, sizeof (*context));
 235 }
 236
 237 /* MD5 basic transformation. Transforms state based on block.
 238  */
 239 static void MD5Transform (state, block)
 240      uint32_t state[4];
 241      const unsigned char block[64];
 242 {
 243         uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 244
 245         Decode (x, block, 64);
 246
 247         /* Round 1 */
 248         FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 249         FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 250         FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 251         FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 252         FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 253         FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 254         FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 255         FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 256         FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 257         FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 258         FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 259         FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 260         FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 261         FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 262         FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 263         FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 264
 265         /* Round 2 */
 266         GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 267         GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 268         GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 269         GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 270         GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 271         GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 272         GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 273         GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 274         GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 275         GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 276         GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 277         GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 278         GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 279         GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 280         GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 281         GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 282
 283         /* Round 3 */
 284         HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 285         HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 286         HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 287         HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 288         HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 289         HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 290         HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 291         HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 292         HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 293         HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 294         HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 295         HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 296         HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 297         HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 298         HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 299         HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 300
 301         /* Round 4 */
 302         II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 303         II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 304         II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 305         II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 306         II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 307         II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 308         II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 309         II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 310         II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 311         II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 312         II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 313         II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 314         II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 315         II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 316         II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 317         II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 318
 319         state[0] += a;
 320         state[1] += b;
 321         state[2] += c;
 322         state[3] += d;
 323
 324         /* Zeroize sensitive information.  */
 325         memset ((POINTER)x, 0, sizeof (x));
 326 }
 327