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