e12d5d1bea57d3fb480f250626696e96d7d9fd78
2 This Library has been modified from its original form by
3 Brian Aker (brian@tangent.org)
5 See below for original Copyright.
7 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
10 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
13 License to copy and use this software is granted provided that it
14 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
15 Algorithm" in all material mentioning or referencing this software
18 License is also granted to make and use derivative works provided
19 that such works are identified as "derived from the RSA Data
20 Security, Inc. MD5 Message-Digest Algorithm" in all material
21 mentioning or referencing the derived work.
23 RSA Data Security, Inc. makes no representations concerning either
24 the merchantability of this software or the suitability of this
25 software for any particular purpose. It is provided "as is"
26 without express or implied warranty of any kind.
28 These notices must be retained in any copies of any part of this
29 documentation and/or software.
33 #include <sys/types.h>
35 /* POINTER defines a generic pointer type */
36 typedef unsigned char *POINTER
;
39 /* UINT4 defines a four byte word */
40 typedef unsigned int UINT4
;
45 UINT4 state
[4]; /* state (ABCD) */
46 UINT4 count
[2]; /* number of bits, modulo 2^64 (lsb first) */
47 unsigned char buffer
[64]; /* input buffer */
50 static void MD5Init
PROTO_LIST ((MD5_CTX
*));
51 static void MD5Update
PROTO_LIST ((MD5_CTX
*, unsigned char *, unsigned int));
52 static void MD5Final
PROTO_LIST ((unsigned char [16], MD5_CTX
*));
54 /* Constants for MD5Transform routine. */
74 static void MD5Transform
PROTO_LIST ((UINT4
[4], unsigned char [64]));
75 static void Encode PROTO_LIST
76 ((unsigned char *, UINT4
*, unsigned int));
77 static void Decode PROTO_LIST
78 ((UINT4
*, unsigned char *, unsigned int));
79 static void MD5_memcpy
PROTO_LIST ((POINTER
, POINTER
, unsigned int));
80 static void MD5_memset
PROTO_LIST ((POINTER
, int, unsigned int));
82 static unsigned char PADDING
[64] = {
83 0x80, 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, 0, 0, 0, 0,
85 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
88 /* F, G, H and I are basic MD5 functions.
90 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
91 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
92 #define H(x, y, z) ((x) ^ (y) ^ (z))
93 #define I(x, y, z) ((y) ^ ((x) | (~z)))
95 /* ROTATE_LEFT rotates x left n bits.
97 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
99 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
100 Rotation is separate from addition to prevent recomputation.
102 #define FF(a, b, c, d, x, s, ac) { \
103 (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
104 (a) = ROTATE_LEFT ((a), (s)); \
107 #define GG(a, b, c, d, x, s, ac) { \
108 (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
109 (a) = ROTATE_LEFT ((a), (s)); \
112 #define HH(a, b, c, d, x, s, ac) { \
113 (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
114 (a) = ROTATE_LEFT ((a), (s)); \
117 #define II(a, b, c, d, x, s, ac) { \
118 (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
119 (a) = ROTATE_LEFT ((a), (s)); \
125 Just a simple method for getting the signature
128 void md5_signature(const unsigned char *key
, unsigned int length
, char *result
)
130 const char *hex
= "0123456789abcdef";
132 unsigned char hash
[16];
136 (void)MD5Update(&my_md5
, buf
, length
);
137 MD5Final(hash
, &my_md5
);
139 for (i
= 0, r
= result
; i
< 16; i
++)
141 *r
++ = hex
[hash
[i
] >> 4];
142 *r
++ = hex
[hash
[i
] & 0xF];
146 /* MD5 initialization. Begins an MD5 operation, writing a new context.
148 static void MD5Init (MD5_CTX
*context
) /* context */
150 context
->count
[0] = context
->count
[1] = 0;
151 /* Load magic initialization constants.
153 context
->state
[0] = 0x67452301;
154 context
->state
[1] = 0xefcdab89;
155 context
->state
[2] = 0x98badcfe;
156 context
->state
[3] = 0x10325476;
159 /* MD5 block update operation. Continues an MD5 message-digest
160 operation, processing another message block, and updating the
164 static void MD5Update (
165 MD5_CTX
*context
, /* context */
166 unsigned char *input
, /* input block */
167 unsigned int inputLen
) /* length of input block */
169 unsigned int i
, idx
, partLen
;
171 /* Compute number of bytes mod 64 */
172 idx
= (unsigned int)((context
->count
[0] >> 3) & 0x3F);
175 /* Update number of bits */
176 if ((context
->count
[0] += ((UINT4
)inputLen
<< 3))
177 < ((UINT4
)inputLen
<< 3))
179 context
->count
[1] += ((UINT4
)inputLen
>> 29);
183 /* Transform as many times as possible.
185 if (inputLen
>= partLen
) {
186 MD5_memcpy((POINTER
)&context
->buffer
[idx
], (POINTER
)input
, partLen
);
187 MD5Transform(context
->state
, context
->buffer
);
189 for (i
= partLen
; i
+ 63 < inputLen
; i
+= 64)
190 MD5Transform (context
->state
, &input
[i
]);
197 /* Buffer remaining input */
198 MD5_memcpy((POINTER
)&context
->buffer
[idx
], (POINTER
)&input
[i
],
202 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
203 the message digest and zeroizing the context.
206 static void MD5Final (
207 unsigned char digest
[16], /* message digest */
208 MD5_CTX
*context
) /* context */
210 unsigned char bits
[8];
211 unsigned int idx
, padLen
;
213 /* Save number of bits */
214 Encode (bits
, context
->count
, 8);
216 /* Pad out to 56 mod 64.
218 idx
= (unsigned int)((context
->count
[0] >> 3) & 0x3f);
219 padLen
= (idx
< 56) ? (56 - idx
) : (120 - idx
);
220 MD5Update (context
, PADDING
, padLen
);
222 /* Append length (before padding) */
223 MD5Update (context
, bits
, 8);
225 /* Store state in digest */
226 Encode (digest
, context
->state
, 16);
228 /* Zeroize sensitive information.
230 MD5_memset ((POINTER
)context
, 0, sizeof (*context
));
233 /* MD5 basic transformation. Transforms state based on block.
235 static void MD5Transform (
237 unsigned char block
[64])
239 UINT4 a
= state
[0], b
= state
[1], c
= state
[2], d
= state
[3], x
[16];
241 Decode (x
, block
, 64);
244 FF (a
, b
, c
, d
, x
[ 0], S11
, 0xd76aa478); /* 1 */
245 FF (d
, a
, b
, c
, x
[ 1], S12
, 0xe8c7b756); /* 2 */
246 FF (c
, d
, a
, b
, x
[ 2], S13
, 0x242070db); /* 3 */
247 FF (b
, c
, d
, a
, x
[ 3], S14
, 0xc1bdceee); /* 4 */
248 FF (a
, b
, c
, d
, x
[ 4], S11
, 0xf57c0faf); /* 5 */
249 FF (d
, a
, b
, c
, x
[ 5], S12
, 0x4787c62a); /* 6 */
250 FF (c
, d
, a
, b
, x
[ 6], S13
, 0xa8304613); /* 7 */
251 FF (b
, c
, d
, a
, x
[ 7], S14
, 0xfd469501); /* 8 */
252 FF (a
, b
, c
, d
, x
[ 8], S11
, 0x698098d8); /* 9 */
253 FF (d
, a
, b
, c
, x
[ 9], S12
, 0x8b44f7af); /* 10 */
254 FF (c
, d
, a
, b
, x
[10], S13
, 0xffff5bb1); /* 11 */
255 FF (b
, c
, d
, a
, x
[11], S14
, 0x895cd7be); /* 12 */
256 FF (a
, b
, c
, d
, x
[12], S11
, 0x6b901122); /* 13 */
257 FF (d
, a
, b
, c
, x
[13], S12
, 0xfd987193); /* 14 */
258 FF (c
, d
, a
, b
, x
[14], S13
, 0xa679438e); /* 15 */
259 FF (b
, c
, d
, a
, x
[15], S14
, 0x49b40821); /* 16 */
262 GG (a
, b
, c
, d
, x
[ 1], S21
, 0xf61e2562); /* 17 */
263 GG (d
, a
, b
, c
, x
[ 6], S22
, 0xc040b340); /* 18 */
264 GG (c
, d
, a
, b
, x
[11], S23
, 0x265e5a51); /* 19 */
265 GG (b
, c
, d
, a
, x
[ 0], S24
, 0xe9b6c7aa); /* 20 */
266 GG (a
, b
, c
, d
, x
[ 5], S21
, 0xd62f105d); /* 21 */
267 GG (d
, a
, b
, c
, x
[10], S22
, 0x2441453); /* 22 */
268 GG (c
, d
, a
, b
, x
[15], S23
, 0xd8a1e681); /* 23 */
269 GG (b
, c
, d
, a
, x
[ 4], S24
, 0xe7d3fbc8); /* 24 */
270 GG (a
, b
, c
, d
, x
[ 9], S21
, 0x21e1cde6); /* 25 */
271 GG (d
, a
, b
, c
, x
[14], S22
, 0xc33707d6); /* 26 */
272 GG (c
, d
, a
, b
, x
[ 3], S23
, 0xf4d50d87); /* 27 */
273 GG (b
, c
, d
, a
, x
[ 8], S24
, 0x455a14ed); /* 28 */
274 GG (a
, b
, c
, d
, x
[13], S21
, 0xa9e3e905); /* 29 */
275 GG (d
, a
, b
, c
, x
[ 2], S22
, 0xfcefa3f8); /* 30 */
276 GG (c
, d
, a
, b
, x
[ 7], S23
, 0x676f02d9); /* 31 */
277 GG (b
, c
, d
, a
, x
[12], S24
, 0x8d2a4c8a); /* 32 */
280 HH (a
, b
, c
, d
, x
[ 5], S31
, 0xfffa3942); /* 33 */
281 HH (d
, a
, b
, c
, x
[ 8], S32
, 0x8771f681); /* 34 */
282 HH (c
, d
, a
, b
, x
[11], S33
, 0x6d9d6122); /* 35 */
283 HH (b
, c
, d
, a
, x
[14], S34
, 0xfde5380c); /* 36 */
284 HH (a
, b
, c
, d
, x
[ 1], S31
, 0xa4beea44); /* 37 */
285 HH (d
, a
, b
, c
, x
[ 4], S32
, 0x4bdecfa9); /* 38 */
286 HH (c
, d
, a
, b
, x
[ 7], S33
, 0xf6bb4b60); /* 39 */
287 HH (b
, c
, d
, a
, x
[10], S34
, 0xbebfbc70); /* 40 */
288 HH (a
, b
, c
, d
, x
[13], S31
, 0x289b7ec6); /* 41 */
289 HH (d
, a
, b
, c
, x
[ 0], S32
, 0xeaa127fa); /* 42 */
290 HH (c
, d
, a
, b
, x
[ 3], S33
, 0xd4ef3085); /* 43 */
291 HH (b
, c
, d
, a
, x
[ 6], S34
, 0x4881d05); /* 44 */
292 HH (a
, b
, c
, d
, x
[ 9], S31
, 0xd9d4d039); /* 45 */
293 HH (d
, a
, b
, c
, x
[12], S32
, 0xe6db99e5); /* 46 */
294 HH (c
, d
, a
, b
, x
[15], S33
, 0x1fa27cf8); /* 47 */
295 HH (b
, c
, d
, a
, x
[ 2], S34
, 0xc4ac5665); /* 48 */
298 II (a
, b
, c
, d
, x
[ 0], S41
, 0xf4292244); /* 49 */
299 II (d
, a
, b
, c
, x
[ 7], S42
, 0x432aff97); /* 50 */
300 II (c
, d
, a
, b
, x
[14], S43
, 0xab9423a7); /* 51 */
301 II (b
, c
, d
, a
, x
[ 5], S44
, 0xfc93a039); /* 52 */
302 II (a
, b
, c
, d
, x
[12], S41
, 0x655b59c3); /* 53 */
303 II (d
, a
, b
, c
, x
[ 3], S42
, 0x8f0ccc92); /* 54 */
304 II (c
, d
, a
, b
, x
[10], S43
, 0xffeff47d); /* 55 */
305 II (b
, c
, d
, a
, x
[ 1], S44
, 0x85845dd1); /* 56 */
306 II (a
, b
, c
, d
, x
[ 8], S41
, 0x6fa87e4f); /* 57 */
307 II (d
, a
, b
, c
, x
[15], S42
, 0xfe2ce6e0); /* 58 */
308 II (c
, d
, a
, b
, x
[ 6], S43
, 0xa3014314); /* 59 */
309 II (b
, c
, d
, a
, x
[13], S44
, 0x4e0811a1); /* 60 */
310 II (a
, b
, c
, d
, x
[ 4], S41
, 0xf7537e82); /* 61 */
311 II (d
, a
, b
, c
, x
[11], S42
, 0xbd3af235); /* 62 */
312 II (c
, d
, a
, b
, x
[ 2], S43
, 0x2ad7d2bb); /* 63 */
313 II (b
, c
, d
, a
, x
[ 9], S44
, 0xeb86d391); /* 64 */
321 /* Zeroize sensitive information.
323 MD5_memset ((POINTER
)x
, 0, sizeof (x
));
326 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
330 unsigned char *output
,
336 for (i
= 0, j
= 0; j
< len
; i
++, j
+= 4) {
337 output
[j
] = (unsigned char)(input
[i
] & 0xff);
338 output
[j
+1] = (unsigned char)((input
[i
] >> 8) & 0xff);
339 output
[j
+2] = (unsigned char)((input
[i
] >> 16) & 0xff);
340 output
[j
+3] = (unsigned char)((input
[i
] >> 24) & 0xff);
345 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
350 unsigned char *input
,
355 for (i
= 0, j
= 0; j
< len
; i
++, j
+= 4)
356 output
[i
] = ((UINT4
)input
[j
]) | (((UINT4
)input
[j
+1]) << 8) |
357 (((UINT4
)input
[j
+2]) << 16) | (((UINT4
)input
[j
+3]) << 24);
360 /* Note: Replace "for loop" with standard memcpy if possible.
364 static void MD5_memcpy (output
, input
, len
)
371 for (i
= 0; i
< len
; i
++)
372 output
[i
] = input
[i
];
376 /* Note: Replace "for loop" with standard memset if possible.
380 static void MD5_memset (output
, value
, len
)
387 for (i
= 0; i
< len
; i
++)
388 ((char *)output
)[i
] = (char)value
;