crypt/md5-block.c

   1 /* These are the four functions used in the four steps of the MD5 algorithm
   2    and defined in the RFC 1321.  The first function is a little bit optimized
   3    (as found in Colin Plumbs public domain implementation).  */
   4 /* #define FF(b, c, d) ((b & c) | (~b & d)) */
   5 #define FF(b, c, d) (d ^ (b & (c ^ d)))
   6 #define FG(b, c, d) FF (d, b, c)
   7 #define FH(b, c, d) (b ^ c ^ d)
   8 #define FI(b, c, d) (c ^ (b | ~d))
   9
  10 /* Process LEN bytes of BUFFER, accumulating context into CTX.
  11    It is assumed that LEN % 64 == 0.  */
  12
  13 void
  14 __md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
  15 {
  16   md5_uint32 correct_words[16];
  17   const md5_uint32 *words = buffer;
  18   size_t nwords = len / sizeof (md5_uint32);
  19   const md5_uint32 *endp = words + nwords;
  20   md5_uint32 A = ctx->A;
  21   md5_uint32 B = ctx->B;
  22   md5_uint32 C = ctx->C;
  23   md5_uint32 D = ctx->D;
  24   md5_uint32 lolen = len;
  25
  26   /* First increment the byte count.  RFC 1321 specifies the possible
  27      length of the file up to 2^64 bits.  Here we only compute the
  28      number of bytes.  Do a double word increment.  */
  29   ctx->total[0] += lolen;
  30   ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
  31
  32   /* Process all bytes in the buffer with 64 bytes in each round of
  33      the loop.  */
  34   while (words < endp)
  35     {
  36       md5_uint32 *cwp = correct_words;
  37       md5_uint32 A_save = A;
  38       md5_uint32 B_save = B;
  39       md5_uint32 C_save = C;
  40       md5_uint32 D_save = D;
  41
  42       /* First round: using the given function, the context and a constant
  43          the next context is computed.  Because the algorithms processing
  44          unit is a 32-bit word and it is determined to work on words in
  45          little endian byte order we perhaps have to change the byte order
  46          before the computation.  To reduce the work for the next steps
  47          we store the swapped words in the array CORRECT_WORDS.  */
  48
  49 #define OP(a, b, c, d, s, T)                                            \
  50       do                                                                \
  51         {                                                               \
  52           a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
  53           ++words;                                                      \
  54           CYCLIC (a, s);                                                \
  55           a += b;                                                       \
  56         }                                                               \
  57       while (0)
  58
  59       /* It is unfortunate that C does not provide an operator for
  60          cyclic rotation.  Hope the C compiler is smart enough.  */
  61 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
  62
  63       /* Before we start, one word to the strange constants.
  64          They are defined in RFC 1321 as
  65
  66          T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
  67        */
  68
  69       /* Round 1.  */
  70       OP (A, B, C, D,  7, 0xd76aa478);
  71       OP (D, A, B, C, 12, 0xe8c7b756);
  72       OP (C, D, A, B, 17, 0x242070db);
  73       OP (B, C, D, A, 22, 0xc1bdceee);
  74       OP (A, B, C, D,  7, 0xf57c0faf);
  75       OP (D, A, B, C, 12, 0x4787c62a);
  76       OP (C, D, A, B, 17, 0xa8304613);
  77       OP (B, C, D, A, 22, 0xfd469501);
  78       OP (A, B, C, D,  7, 0x698098d8);
  79       OP (D, A, B, C, 12, 0x8b44f7af);
  80       OP (C, D, A, B, 17, 0xffff5bb1);
  81       OP (B, C, D, A, 22, 0x895cd7be);
  82       OP (A, B, C, D,  7, 0x6b901122);
  83       OP (D, A, B, C, 12, 0xfd987193);
  84       OP (C, D, A, B, 17, 0xa679438e);
  85       OP (B, C, D, A, 22, 0x49b40821);
  86
  87       /* For the second to fourth round we have the possibly swapped words
  88          in CORRECT_WORDS.  Redefine the macro to take an additional first
  89          argument specifying the function to use.  */
  90 #undef OP
  91 #define OP(f, a, b, c, d, k, s, T)                                      \
  92       do                                                                \
  93         {                                                               \
  94           a += f (b, c, d) + correct_words[k] + T;                      \
  95           CYCLIC (a, s);                                                \
  96           a += b;                                                       \
  97         }                                                               \
  98       while (0)
  99
 100       /* Round 2.  */
 101       OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
 102       OP (FG, D, A, B, C,  6,  9, 0xc040b340);
 103       OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
 104       OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
 105       OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
 106       OP (FG, D, A, B, C, 10,  9, 0x02441453);
 107       OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
 108       OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
 109       OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
 110       OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
 111       OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
 112       OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
 113       OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
 114       OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
 115       OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
 116       OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
 117
 118       /* Round 3.  */
 119       OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
 120       OP (FH, D, A, B, C,  8, 11, 0x8771f681);
 121       OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
 122       OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
 123       OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
 124       OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
 125       OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
 126       OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
 127       OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
 128       OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
 129       OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
 130       OP (FH, B, C, D, A,  6, 23, 0x04881d05);
 131       OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
 132       OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
 133       OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
 134       OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
 135
 136       /* Round 4.  */
 137       OP (FI, A, B, C, D,  0,  6, 0xf4292244);
 138       OP (FI, D, A, B, C,  7, 10, 0x432aff97);
 139       OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
 140       OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
 141       OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
 142       OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
 143       OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
 144       OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
 145       OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
 146       OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
 147       OP (FI, C, D, A, B,  6, 15, 0xa3014314);
 148       OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
 149       OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
 150       OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
 151       OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
 152       OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
 153
 154       /* Add the starting values of the context.  */
 155       A += A_save;
 156       B += B_save;
 157       C += C_save;
 158       D += D_save;
 159     }
 160
 161   /* Put checksum in context given as argument.  */
 162   ctx->A = A;
 163   ctx->B = B;
 164   ctx->C = C;
 165   ctx->D = D;
 166 }