Source/charon/transforms/hashers/hasher_md5.c

   1 /**
   2  * @file hasher_md5.c
   3  *
   4  * @brief Implementation of hasher_md5_t.
   5  *
   6  */
   7
   8 /*
   9  * Copyright (C) 2005 Jan Hutter, Martin Willi
  10  * Hochschule fuer Technik Rapperswil
  11  * Copyright (C) 1991-1992, RSA Data Security, Inc. Created 1991.
  12  * All rights reserved.
  13  *
  14  * Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm.
  15  * Ported to fulfill hasher_t interface.
  16  *
  17  * This program is free software; you can redistribute it and/or modify it
  18  * under the terms of the GNU General Public License as published by the
  19  * Free Software Foundation; either version 2 of the License, or (at your
  20  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  21  *
  22  * This program is distributed in the hope that it will be useful, but
  23  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  24  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  25  * for more details.
  26  */
  27
  28 #include "hasher_md5.h"
  29
  30 #include <definitions.h>
  31 #include <utils/allocator.h>
  32
  33 #define BLOCK_SIZE_MD5 16
  34
  35
  36 /* Constants for MD5Transform routine. */
  37 #define S11 7
  38 #define S12 12
  39 #define S13 17
  40 #define S14 22
  41 #define S21 5
  42 #define S22 9
  43 #define S23 14
  44 #define S24 20
  45 #define S31 4
  46 #define S32 11
  47 #define S33 16
  48 #define S34 23
  49 #define S41 6
  50 #define S42 10
  51 #define S43 15
  52 #define S44 21
  53
  54 static u_int8_t PADDING[64] = {
  55   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  56   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  57   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  58 };
  59
  60 /*
  61  * ugly macro stuff
  62  */
  63 /* F, G, H and I are basic MD5 functions.
  64  */
  65 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  66 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  67 #define H(x, y, z) ((x) ^ (y) ^ (z))
  68 #define I(x, y, z) ((y) ^ ((x) | (~z)))
  69
  70 /* ROTATE_LEFT rotates x left n bits.
  71  */
  72 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
  73
  74 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
  75 Rotation is separate from addition to prevent recomputation.
  76  */
  77 #define FF(a, b, c, d, x, s, ac) { \
  78  (a) += F ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
  79  (a) = ROTATE_LEFT ((a), (s)); \
  80  (a) += (b); \
  81   }
  82 #define GG(a, b, c, d, x, s, ac) { \
  83  (a) += G ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
  84  (a) = ROTATE_LEFT ((a), (s)); \
  85  (a) += (b); \
  86   }
  87 #define HH(a, b, c, d, x, s, ac) { \
  88  (a) += H ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
  89  (a) = ROTATE_LEFT ((a), (s)); \
  90  (a) += (b); \
  91   }
  92 #define II(a, b, c, d, x, s, ac) { \
  93  (a) += I ((b), (c), (d)) + (x) + (u_int32_t)(ac); \
  94  (a) = ROTATE_LEFT ((a), (s)); \
  95  (a) += (b); \
  96   }
  97
  98
  99
 100 typedef struct private_hasher_md5_t private_hasher_md5_t;
 101
 102 /**
 103  * private data structure with hasing context
 104  */
 105 struct private_hasher_md5_t {
 106         /**
 107          * public interface for this hasher
 108          */
 109         hasher_md5_t public;
 110
 111         /*
 112          * state of the hasher
 113          */
 114         u_int32_t state[5];
 115     u_int32_t count[2];
 116     u_int8_t buffer[64];
 117 };
 118
 119
 120 #if BYTE_ORDER != LITTLE_ENDIAN
 121
 122 /* Encodes input (u_int32_t) into output (u_int8_t). Assumes len is
 123  * a multiple of 4.
 124  */
 125 static void Encode (u_int8_t *output, u_int32_t *input, size_t *len)
 126 {
 127         size_t i, j;
 128
 129         for (i = 0, j = 0; j < len; i++, j += 4)
 130         {
 131                 output[j] = (u_int8_t)(input[i] & 0xff);
 132                 output[j+1] = (u_int8_t)((input[i] >> 8) & 0xff);
 133                 output[j+2] = (u_int8_t)((input[i] >> 16) & 0xff);
 134                 output[j+3] = (u_int8_t)((input[i] >> 24) & 0xff);
 135         }
 136 }
 137
 138 /* Decodes input (u_int8_t) into output (u_int32_t). Assumes len is
 139  * a multiple of 4.
 140  */
 141 static void Decode(u_int32_t *output, u_int8_t *input, size_t len)
 142 {
 143         size_t i, j;
 144
 145         for (i = 0, j = 0; j < len; i++, j += 4)
 146         {
 147                 output[i] = ((u_int32_t)input[j]) | (((u_int32_t)input[j+1]) << 8) |
 148                 (((u_int32_t)input[j+2]) << 16) | (((u_int32_t)input[j+3]) << 24);
 149         }
 150 }
 151
 152 #elif BYTE_ORDER == LITTLE_ENDIAN
 153  #define Encode memcpy
 154  #define Decode memcpy
 155 #endif
 156
 157 /* MD5 basic transformation. Transforms state based on block.
 158  */
 159 static void MD5Transform(u_int32_t state[4], u_int8_t block[64])
 160 {
 161         u_int32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 162
 163         Decode(x, block, 64);
 164
 165         /* Round 1 */
 166         FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 167         FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 168         FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 169         FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 170         FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 171         FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 172         FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 173         FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 174         FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 175         FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 176         FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 177         FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 178         FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 179         FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 180         FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 181         FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 182
 183         /* Round 2 */
 184         GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 185         GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 186         GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 187         GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 188         GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 189         GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 190         GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 191         GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 192         GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 193         GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 194         GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 195         GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 196         GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 197         GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 198         GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 199         GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 200
 201         /* Round 3 */
 202         HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 203         HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 204         HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 205         HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 206         HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 207         HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 208         HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 209         HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 210         HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 211         HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 212         HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 213         HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 214         HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 215         HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 216         HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 217         HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 218
 219         /* Round 4 */
 220         II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 221         II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 222         II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 223         II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 224         II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 225         II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 226         II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 227         II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 228         II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 229         II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 230         II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 231         II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 232         II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 233         II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 234         II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 235         II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 236
 237         state[0] += a;
 238         state[1] += b;
 239         state[2] += c;
 240         state[3] += d;
 241 }
 242
 243 /* MD5 block update operation. Continues an MD5 message-digest
 244  * operation, processing another message block, and updating the
 245  * context.
 246  */
 247 void MD5Update(private_hasher_md5_t *this, u_int8_t *input, size_t inputLen)
 248 {
 249         u_int32_t i;
 250         size_t index, partLen;
 251
 252         /* Compute number of bytes mod 64 */
 253         index = (u_int8_t)((this->count[0] >> 3) & 0x3F);
 254
 255         /* Update number of bits */
 256         if ((this->count[0] += (inputLen << 3)) < (inputLen << 3))
 257         {
 258                 this->count[1]++;
 259         }
 260         this->count[1] += (inputLen >> 29);
 261
 262         partLen = 64 - index;
 263
 264         /* Transform as many times as possible. */
 265         if (inputLen >= partLen)
 266         {
 267                 memcpy(&this->buffer[index], input, partLen);
 268                 MD5Transform (this->state, this->buffer);
 269
 270                 for (i = partLen; i + 63 < inputLen; i += 64)
 271                 {
 272                 MD5Transform (this->state, &input[i]);
 273                 }
 274                 index = 0;
 275         }
 276         else
 277         {
 278                 i = 0;
 279         }
 280
 281         /* Buffer remaining input */
 282         memcpy(&this->buffer[index], &input[i], inputLen-i);
 283 }
 284
 285 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 286  * the message digest and zeroizing the context.
 287  */
 288 void MD5Final (private_hasher_md5_t *this, u_int8_t digest[16])
 289 {
 290         u_int8_t bits[8];
 291         size_t index, padLen;
 292
 293         /* Save number of bits */
 294         Encode (bits, this->count, 8);
 295
 296         /* Pad out to 56 mod 64. */
 297         index = (size_t)((this->count[0] >> 3) & 0x3f);
 298         padLen = (index < 56) ? (56 - index) : (120 - index);
 299         MD5Update (this, PADDING, padLen);
 300
 301         /* Append length (before padding) */
 302         MD5Update (this, bits, 8);
 303
 304         if (digest != NULL)                     /* Bill Simpson's padding */
 305         {
 306                 /* store state in digest */
 307                 Encode (digest, this->state, 16);
 308         }
 309 }
 310
 311
 312
 313 /**
 314  * implementation of hasher_t.get_hash for md5
 315  */
 316 static status_t get_hash(private_hasher_md5_t *this, chunk_t chunk, u_int8_t *buffer)
 317 {
 318         MD5Update(this, chunk.ptr, chunk.len);
 319         if (buffer != NULL)
 320         {
 321                 MD5Final(this, buffer);
 322                 this->public.hasher_interface.reset(&(this->public.hasher_interface));
 323         }
 324         return SUCCESS;
 325 }
 326
 327
 328 /**
 329  * implementation of hasher_t.allocate_hash for md5
 330  */
 331 static status_t allocate_hash(private_hasher_md5_t *this, chunk_t chunk, chunk_t *hash)
 332 {
 333         chunk_t allocated_hash;
 334
 335         MD5Update(this, chunk.ptr, chunk.len);
 336         if (hash != NULL)
 337         {
 338                 allocated_hash.ptr = allocator_alloc(BLOCK_SIZE_MD5);
 339                 allocated_hash.len = BLOCK_SIZE_MD5;
 340                 if (allocated_hash.ptr == NULL)
 341                 {
 342                         return OUT_OF_RES;
 343                 }
 344                 MD5Final(this, allocated_hash.ptr);
 345                 this->public.hasher_interface.reset(&(this->public.hasher_interface));
 346
 347                 *hash = allocated_hash;
 348         }
 349
 350         return SUCCESS;
 351 }
 352
 353 /**
 354  * implementation of hasher_t.get_block_size for md5
 355  */
 356 static size_t get_block_size(private_hasher_md5_t *this)
 357 {
 358         return BLOCK_SIZE_MD5;
 359 }
 360
 361 /**
 362  * implementation of hasher_t.reset for md5
 363  */
 364 static status_t reset(private_hasher_md5_t *this)
 365 {
 366         this->state[0] = 0x67452301;
 367         this->state[1] = 0xefcdab89;
 368         this->state[2] = 0x98badcfe;
 369         this->state[3] = 0x10325476;
 370         this->count[0] = 0;
 371         this->count[1] = 0;
 372     return SUCCESS;
 373 }
 374 /**
 375  * implementation of hasher_t.destroy for md5
 376  */
 377 static status_t destroy(private_hasher_md5_t *this)
 378 {
 379         allocator_free(this);
 380         return SUCCESS;
 381 }
 382
 383
 384 /*
 385  * Described in header
 386  */
 387 hasher_md5_t *hasher_md5_create()
 388 {
 389         private_hasher_md5_t *this = allocator_alloc_thing(private_hasher_md5_t);
 390         if (this == NULL)
 391         {
 392                 return NULL;
 393         }
 394
 395         this->public.hasher_interface.get_hash = (status_t (*) (hasher_t*, chunk_t, u_int8_t*))get_hash;
 396         this->public.hasher_interface.allocate_hash = (status_t (*) (hasher_t*, chunk_t, chunk_t*))allocate_hash;
 397         this->public.hasher_interface.get_block_size = (size_t (*) (hasher_t*))get_block_size;
 398         this->public.hasher_interface.reset = (size_t (*) (hasher_t*))reset;
 399         this->public.hasher_interface.destroy = (size_t (*) (hasher_t*))destroy;
 400
 401         /* initialize */
 402         this->public.hasher_interface.reset(&(this->public.hasher_interface));
 403
 404         return &(this->public);
 405 }