xref: /PHP-7.3/ext/hash/hash_md.c (revision 8d3f8ca1)
1 /*
2   +----------------------------------------------------------------------+
3   | PHP Version 7                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2018 The PHP Group                                |
6   +----------------------------------------------------------------------+
7   | This source file is subject to version 3.01 of the PHP license,      |
8   | that is bundled with this package in the file LICENSE, and is        |
9   | available through the world-wide-web at the following url:           |
10   | http://www.php.net/license/3_01.txt                                  |
11   | If you did not receive a copy of the PHP license and are unable to   |
12   | obtain it through the world-wide-web, please send a note to          |
13   | license@php.net so we can mail you a copy immediately.               |
14   +----------------------------------------------------------------------+
15   | Taken from: ext/standard/md5.c                                       |
16   +----------------------------------------------------------------------+
17 */
18 
19 #include "php_hash.h"
20 #include "php_hash_md.h"
21 
22 const php_hash_ops php_hash_md5_ops = {
23 	(php_hash_init_func_t) PHP_MD5Init,
24 	(php_hash_update_func_t) PHP_MD5Update,
25 	(php_hash_final_func_t) PHP_MD5Final,
26 	(php_hash_copy_func_t) php_hash_copy,
27 	16,
28 	64,
29 	sizeof(PHP_MD5_CTX),
30 	1
31 };
32 
33 const php_hash_ops php_hash_md4_ops = {
34 	(php_hash_init_func_t) PHP_MD4Init,
35 	(php_hash_update_func_t) PHP_MD4Update,
36 	(php_hash_final_func_t) PHP_MD4Final,
37 	(php_hash_copy_func_t) php_hash_copy,
38 	16,
39 	64,
40 	sizeof(PHP_MD4_CTX),
41 	1
42 };
43 
44 const php_hash_ops php_hash_md2_ops = {
45 	(php_hash_init_func_t) PHP_MD2Init,
46 	(php_hash_update_func_t) PHP_MD2Update,
47 	(php_hash_final_func_t) PHP_MD2Final,
48 	(php_hash_copy_func_t) php_hash_copy,
49 	16,
50 	16,
51 	sizeof(PHP_MD2_CTX),
52 	1
53 };
54 
55 /* MD common stuff */
56 
57 static const unsigned char PADDING[64] =
58 {
59 	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
60 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
61 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
62 };
63 
64 /* {{{ Encode
65    Encodes input (uint32_t) into output (unsigned char). Assumes len is
66    a multiple of 4.
67  */
Encode(unsigned char * output,uint32_t * input,unsigned int len)68 static void Encode(unsigned char *output, uint32_t *input, unsigned int len)
69 {
70 	unsigned int i, j;
71 
72 	for (i = 0, j = 0; j < len; i++, j += 4) {
73 		output[j] = (unsigned char) (input[i] & 0xff);
74 		output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
75 		output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
76 		output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
77 	}
78 }
79 /* }}} */
80 
81 /* {{{ Decode
82    Decodes input (unsigned char) into output (uint32_t). Assumes len is
83    a multiple of 4.
84  */
Decode(uint32_t * output,const unsigned char * input,unsigned int len)85 static void Decode(uint32_t *output, const unsigned char *input, unsigned int len)
86 {
87 	unsigned int i, j;
88 
89 	for (i = 0, j = 0; j < len; i++, j += 4)
90 		output[i] = ((uint32_t) input[j]) | (((uint32_t) input[j + 1]) << 8) |
91 			(((uint32_t) input[j + 2]) << 16) | (((uint32_t) input[j + 3]) << 24);
92 }
93 /* }}} */
94 
95 #ifdef PHP_HASH_MD5_NOT_IN_CORE
96 
97 /* MD5 */
98 
make_digest(char * md5str,unsigned char * digest)99 PHP_HASH_API void make_digest(char *md5str, unsigned char *digest)
100 {
101 	php_hash_bin2hex(md5str, digest, 16);
102 	md5str[32] = '\0';
103 }
104 
105 /* {{{ proto string md5(string str, [ bool raw_output])
106    Calculate the md5 hash of a string */
PHP_NAMED_FUNCTION(php_if_md5)107 PHP_NAMED_FUNCTION(php_if_md5)
108 {
109 	char *arg;
110 	size_t arg_len;
111 	zend_bool raw_output = 0;
112 	PHP_MD5_CTX context;
113 	unsigned char digest[16];
114 
115 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|b", &arg, &arg_len, &raw_output) == FAILURE) {
116 		return;
117 	}
118 
119 	PHP_MD5Init(&context);
120 	PHP_MD5Update(&context, arg, arg_len);
121 	PHP_MD5Final(digest, &context);
122 	if (raw_output) {
123 		RETURN_STRINGL(digest, 16);
124 	} else {
125 		RETVAL_NEW_STR(zend_string_alloc(32, 0));
126 		make_digest(Z_STRVAL_P(return_value), digest);
127 	}
128 
129 }
130 /* }}} */
131 
132 /* {{{ proto string md5_file(string filename [, bool raw_output])
133    Calculate the md5 hash of given filename */
PHP_NAMED_FUNCTION(php_if_md5_file)134 PHP_NAMED_FUNCTION(php_if_md5_file)
135 {
136 	char          *arg;
137 	size_t        arg_len;
138 	zend_bool raw_output = 0;
139 	unsigned char buf[1024];
140 	unsigned char digest[16];
141 	PHP_MD5_CTX   context;
142 	int           n;
143 	php_stream    *stream;
144 
145 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "p|b", &arg, &arg_len, &raw_output) == FAILURE) {
146 		return;
147 	}
148 
149 	stream = php_stream_open_wrapper(arg, "rb", REPORT_ERRORS, NULL);
150 	if (!stream) {
151 		RETURN_FALSE;
152 	}
153 
154 	PHP_MD5Init(&context);
155 
156 	while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
157 		PHP_MD5Update(&context, buf, n);
158 	}
159 
160 	PHP_MD5Final(digest, &context);
161 
162 	php_stream_close(stream);
163 
164 	if (n<0) {
165 		RETURN_FALSE;
166 	}
167 
168 	if (raw_output) {
169 		RETURN_STRINGL(digest, 16);
170 	} else {
171 		RETVAL_NEW_STR(zend_string_alloc(32, 0));
172 		make_digest(Z_STRVAL_P(return_value), digest);
173 	}
174 }
175 /* }}} */
176 
177 /*
178  * The remaining code is the reference MD5 code (md5c.c) from rfc1321
179  */
180 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
181  */
182 
183 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
184    rights reserved.
185 
186    License to copy and use this software is granted provided that it
187    is identified as the "RSA Data Security, Inc. MD5 Message-Digest
188    Algorithm" in all material mentioning or referencing this software
189    or this function.
190 
191    License is also granted to make and use derivative works provided
192    that such works are identified as "derived from the RSA Data
193    Security, Inc. MD5 Message-Digest Algorithm" in all material
194    mentioning or referencing the derived work.
195 
196    RSA Data Security, Inc. makes no representations concerning either
197    the merchantability of this software or the suitability of this
198    software for any particular purpose. It is provided "as is"
199    without express or implied warranty of any kind.
200 
201    These notices must be retained in any copies of any part of this
202    documentation and/or software.
203  */
204 
205 /* Constants for MD5Transform routine.
206  */
207 
208 #define S11 7
209 #define S12 12
210 #define S13 17
211 #define S14 22
212 #define S21 5
213 #define S22 9
214 #define S23 14
215 #define S24 20
216 #define S31 4
217 #define S32 11
218 #define S33 16
219 #define S34 23
220 #define S41 6
221 #define S42 10
222 #define S43 15
223 #define S44 21
224 
225 static void MD5Transform(uint32_t[4], const unsigned char[64]);
226 
227 /* F, G, H and I are basic MD5 functions.
228  */
229 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
230 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
231 #define H(x, y, z) ((x) ^ (y) ^ (z))
232 #define I(x, y, z) ((y) ^ ((x) | (~z)))
233 
234 /* ROTATE_LEFT rotates x left n bits.
235  */
236 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
237 
238 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
239    Rotation is separate from addition to prevent recomputation.
240  */
241 #define FF(a, b, c, d, x, s, ac) { \
242  (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \
243  (a) = ROTATE_LEFT ((a), (s)); \
244  (a) += (b); \
245   }
246 #define GG(a, b, c, d, x, s, ac) { \
247  (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \
248  (a) = ROTATE_LEFT ((a), (s)); \
249  (a) += (b); \
250   }
251 #define HH(a, b, c, d, x, s, ac) { \
252  (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \
253  (a) = ROTATE_LEFT ((a), (s)); \
254  (a) += (b); \
255   }
256 #define II(a, b, c, d, x, s, ac) { \
257  (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \
258  (a) = ROTATE_LEFT ((a), (s)); \
259  (a) += (b); \
260   }
261 
262 /* {{{ PHP_MD5Init
263  * MD5 initialization. Begins an MD5 operation, writing a new context.
264  */
PHP_MD5Init(PHP_MD5_CTX * context)265 PHP_HASH_API void PHP_MD5Init(PHP_MD5_CTX * context)
266 {
267 	context->count[0] = context->count[1] = 0;
268 	/* Load magic initialization constants.
269 	 */
270 	context->state[0] = 0x67452301;
271 	context->state[1] = 0xefcdab89;
272 	context->state[2] = 0x98badcfe;
273 	context->state[3] = 0x10325476;
274 }
275 /* }}} */
276 
277 /* {{{ PHP_MD5Update
278    MD5 block update operation. Continues an MD5 message-digest
279    operation, processing another message block, and updating the
280    context.
281  */
PHP_MD5Update(PHP_MD5_CTX * context,const unsigned char * input,unsigned int inputLen)282 PHP_HASH_API void PHP_MD5Update(PHP_MD5_CTX * context, const unsigned char *input,
283 			   unsigned int inputLen)
284 {
285 	unsigned int i, index, partLen;
286 
287 	/* Compute number of bytes mod 64 */
288 	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
289 
290 	/* Update number of bits */
291 	if ((context->count[0] += ((uint32_t) inputLen << 3))
292 		< ((uint32_t) inputLen << 3))
293 		context->count[1]++;
294 	context->count[1] += ((uint32_t) inputLen >> 29);
295 
296 	partLen = 64 - index;
297 
298 	/* Transform as many times as possible.
299 	 */
300 	if (inputLen >= partLen) {
301 		memcpy
302 			((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
303 		MD5Transform(context->state, context->buffer);
304 
305 		for (i = partLen; i + 63 < inputLen; i += 64)
306 			MD5Transform(context->state, &input[i]);
307 
308 		index = 0;
309 	} else
310 		i = 0;
311 
312 	/* Buffer remaining input */
313 	memcpy
314 		((unsigned char*) & context->buffer[index], (unsigned char*) & input[i],
315 		 inputLen - i);
316 }
317 /* }}} */
318 
319 /* {{{ PHP_MD5Final
320    MD5 finalization. Ends an MD5 message-digest operation, writing the
321    the message digest and zeroizing the context.
322  */
PHP_MD5Final(unsigned char digest[16],PHP_MD5_CTX * context)323 PHP_HASH_API void PHP_MD5Final(unsigned char digest[16], PHP_MD5_CTX * context)
324 {
325 	unsigned char bits[8];
326 	unsigned int index, padLen;
327 
328 	/* Save number of bits */
329 	Encode(bits, context->count, 8);
330 
331 	/* Pad out to 56 mod 64.
332 	 */
333 	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
334 	padLen = (index < 56) ? (56 - index) : (120 - index);
335 	PHP_MD5Update(context, PADDING, padLen);
336 
337 	/* Append length (before padding) */
338 	PHP_MD5Update(context, bits, 8);
339 
340 	/* Store state in digest */
341 	Encode(digest, context->state, 16);
342 
343 	/* Zeroize sensitive information.
344 	 */
345 	ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
346 }
347 /* }}} */
348 
349 /* {{{ MD5Transform
350  * MD5 basic transformation. Transforms state based on block.
351  */
MD5Transform(state,block)352 static void MD5Transform(state, block)
353 uint32_t state[4];
354 const unsigned char block[64];
355 {
356 	uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
357 
358 	Decode(x, block, 64);
359 
360 	/* Round 1 */
361 	FF(a, b, c, d, x[0], S11, 0xd76aa478);	/* 1 */
362 	FF(d, a, b, c, x[1], S12, 0xe8c7b756);	/* 2 */
363 	FF(c, d, a, b, x[2], S13, 0x242070db);	/* 3 */
364 	FF(b, c, d, a, x[3], S14, 0xc1bdceee);	/* 4 */
365 	FF(a, b, c, d, x[4], S11, 0xf57c0faf);	/* 5 */
366 	FF(d, a, b, c, x[5], S12, 0x4787c62a);	/* 6 */
367 	FF(c, d, a, b, x[6], S13, 0xa8304613);	/* 7 */
368 	FF(b, c, d, a, x[7], S14, 0xfd469501);	/* 8 */
369 	FF(a, b, c, d, x[8], S11, 0x698098d8);	/* 9 */
370 	FF(d, a, b, c, x[9], S12, 0x8b44f7af);	/* 10 */
371 	FF(c, d, a, b, x[10], S13, 0xffff5bb1);		/* 11 */
372 	FF(b, c, d, a, x[11], S14, 0x895cd7be);		/* 12 */
373 	FF(a, b, c, d, x[12], S11, 0x6b901122);		/* 13 */
374 	FF(d, a, b, c, x[13], S12, 0xfd987193);		/* 14 */
375 	FF(c, d, a, b, x[14], S13, 0xa679438e);		/* 15 */
376 	FF(b, c, d, a, x[15], S14, 0x49b40821);		/* 16 */
377 
378 	/* Round 2 */
379 	GG(a, b, c, d, x[1], S21, 0xf61e2562);	/* 17 */
380 	GG(d, a, b, c, x[6], S22, 0xc040b340);	/* 18 */
381 	GG(c, d, a, b, x[11], S23, 0x265e5a51);		/* 19 */
382 	GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);	/* 20 */
383 	GG(a, b, c, d, x[5], S21, 0xd62f105d);	/* 21 */
384 	GG(d, a, b, c, x[10], S22, 0x2441453);	/* 22 */
385 	GG(c, d, a, b, x[15], S23, 0xd8a1e681);		/* 23 */
386 	GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);	/* 24 */
387 	GG(a, b, c, d, x[9], S21, 0x21e1cde6);	/* 25 */
388 	GG(d, a, b, c, x[14], S22, 0xc33707d6);		/* 26 */
389 	GG(c, d, a, b, x[3], S23, 0xf4d50d87);	/* 27 */
390 	GG(b, c, d, a, x[8], S24, 0x455a14ed);	/* 28 */
391 	GG(a, b, c, d, x[13], S21, 0xa9e3e905);		/* 29 */
392 	GG(d, a, b, c, x[2], S22, 0xfcefa3f8);	/* 30 */
393 	GG(c, d, a, b, x[7], S23, 0x676f02d9);	/* 31 */
394 	GG(b, c, d, a, x[12], S24, 0x8d2a4c8a);		/* 32 */
395 
396 	/* Round 3 */
397 	HH(a, b, c, d, x[5], S31, 0xfffa3942);	/* 33 */
398 	HH(d, a, b, c, x[8], S32, 0x8771f681);	/* 34 */
399 	HH(c, d, a, b, x[11], S33, 0x6d9d6122);		/* 35 */
400 	HH(b, c, d, a, x[14], S34, 0xfde5380c);		/* 36 */
401 	HH(a, b, c, d, x[1], S31, 0xa4beea44);	/* 37 */
402 	HH(d, a, b, c, x[4], S32, 0x4bdecfa9);	/* 38 */
403 	HH(c, d, a, b, x[7], S33, 0xf6bb4b60);	/* 39 */
404 	HH(b, c, d, a, x[10], S34, 0xbebfbc70);		/* 40 */
405 	HH(a, b, c, d, x[13], S31, 0x289b7ec6);		/* 41 */
406 	HH(d, a, b, c, x[0], S32, 0xeaa127fa);	/* 42 */
407 	HH(c, d, a, b, x[3], S33, 0xd4ef3085);	/* 43 */
408 	HH(b, c, d, a, x[6], S34, 0x4881d05);	/* 44 */
409 	HH(a, b, c, d, x[9], S31, 0xd9d4d039);	/* 45 */
410 	HH(d, a, b, c, x[12], S32, 0xe6db99e5);		/* 46 */
411 	HH(c, d, a, b, x[15], S33, 0x1fa27cf8);		/* 47 */
412 	HH(b, c, d, a, x[2], S34, 0xc4ac5665);	/* 48 */
413 
414 	/* Round 4 */
415 	II(a, b, c, d, x[0], S41, 0xf4292244);	/* 49 */
416 	II(d, a, b, c, x[7], S42, 0x432aff97);	/* 50 */
417 	II(c, d, a, b, x[14], S43, 0xab9423a7);		/* 51 */
418 	II(b, c, d, a, x[5], S44, 0xfc93a039);	/* 52 */
419 	II(a, b, c, d, x[12], S41, 0x655b59c3);		/* 53 */
420 	II(d, a, b, c, x[3], S42, 0x8f0ccc92);	/* 54 */
421 	II(c, d, a, b, x[10], S43, 0xffeff47d);		/* 55 */
422 	II(b, c, d, a, x[1], S44, 0x85845dd1);	/* 56 */
423 	II(a, b, c, d, x[8], S41, 0x6fa87e4f);	/* 57 */
424 	II(d, a, b, c, x[15], S42, 0xfe2ce6e0);		/* 58 */
425 	II(c, d, a, b, x[6], S43, 0xa3014314);	/* 59 */
426 	II(b, c, d, a, x[13], S44, 0x4e0811a1);		/* 60 */
427 	II(a, b, c, d, x[4], S41, 0xf7537e82);	/* 61 */
428 	II(d, a, b, c, x[11], S42, 0xbd3af235);		/* 62 */
429 	II(c, d, a, b, x[2], S43, 0x2ad7d2bb);	/* 63 */
430 	II(b, c, d, a, x[9], S44, 0xeb86d391);	/* 64 */
431 
432 	state[0] += a;
433 	state[1] += b;
434 	state[2] += c;
435 	state[3] += d;
436 
437 	/* Zeroize sensitive information. */
438 	ZEND_SECURE_ZERO((unsigned char*) x, sizeof(x));
439 }
440 /* }}} */
441 
442 #endif /* PHP_HASH_MD5_NOT_IN_CORE */
443 
444 /* MD4 */
445 
446 #define MD4_F(x,y,z)			((z) ^ ((x) & ((y) ^ (z))))
447 #define MD4_G(x,y,z)			(((x) & ((y) | (z))) | ((y) & (z)))
448 #define MD4_H(x,y,z)			((x) ^ (y) ^ (z))
449 
450 #define ROTL32(s,v)				(((v) << (s)) | ((v) >> (32 - (s))))
451 
452 #define MD4_R1(a,b,c,d,k,s)		a = ROTL32(s, a + MD4_F(b,c,d) + x[k])
453 #define MD4_R2(a,b,c,d,k,s)		a = ROTL32(s, a + MD4_G(b,c,d) + x[k] + 0x5A827999)
454 #define MD4_R3(a,b,c,d,k,s)		a = ROTL32(s, a + MD4_H(b,c,d) + x[k] + 0x6ED9EBA1)
455 
MD4Transform(uint32_t state[4],const unsigned char block[64])456 static void MD4Transform(uint32_t state[4], const unsigned char block[64])
457 {
458 	uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
459 
460 	Decode(x, block, 64);
461 
462 	/* Round 1 */
463 	MD4_R1(a,b,c,d, 0, 3);
464 	MD4_R1(d,a,b,c, 1, 7);
465 	MD4_R1(c,d,a,b, 2,11);
466 	MD4_R1(b,c,d,a, 3,19);
467 	MD4_R1(a,b,c,d, 4, 3);
468 	MD4_R1(d,a,b,c, 5, 7);
469 	MD4_R1(c,d,a,b, 6,11);
470 	MD4_R1(b,c,d,a, 7,19);
471 	MD4_R1(a,b,c,d, 8, 3);
472 	MD4_R1(d,a,b,c, 9, 7);
473 	MD4_R1(c,d,a,b,10,11);
474 	MD4_R1(b,c,d,a,11,19);
475 	MD4_R1(a,b,c,d,12, 3);
476 	MD4_R1(d,a,b,c,13, 7);
477 	MD4_R1(c,d,a,b,14,11);
478 	MD4_R1(b,c,d,a,15,19);
479 
480 	/* Round 2 */
481 	MD4_R2(a,b,c,d, 0, 3);
482 	MD4_R2(d,a,b,c, 4, 5);
483 	MD4_R2(c,d,a,b, 8, 9);
484 	MD4_R2(b,c,d,a,12,13);
485 	MD4_R2(a,b,c,d, 1, 3);
486 	MD4_R2(d,a,b,c, 5, 5);
487 	MD4_R2(c,d,a,b, 9, 9);
488 	MD4_R2(b,c,d,a,13,13);
489 	MD4_R2(a,b,c,d, 2, 3);
490 	MD4_R2(d,a,b,c, 6, 5);
491 	MD4_R2(c,d,a,b,10, 9);
492 	MD4_R2(b,c,d,a,14,13);
493 	MD4_R2(a,b,c,d, 3, 3);
494 	MD4_R2(d,a,b,c, 7, 5);
495 	MD4_R2(c,d,a,b,11, 9);
496 	MD4_R2(b,c,d,a,15,13);
497 
498 	/* Round 3 */
499 	MD4_R3(a,b,c,d, 0, 3);
500 	MD4_R3(d,a,b,c, 8, 9);
501 	MD4_R3(c,d,a,b, 4,11);
502 	MD4_R3(b,c,d,a,12,15);
503 	MD4_R3(a,b,c,d, 2, 3);
504 	MD4_R3(d,a,b,c,10, 9);
505 	MD4_R3(c,d,a,b, 6,11);
506 	MD4_R3(b,c,d,a,14,15);
507 	MD4_R3(a,b,c,d, 1, 3);
508 	MD4_R3(d,a,b,c, 9, 9);
509 	MD4_R3(c,d,a,b, 5,11);
510 	MD4_R3(b,c,d,a,13,15);
511 	MD4_R3(a,b,c,d, 3, 3);
512 	MD4_R3(d,a,b,c,11, 9);
513 	MD4_R3(c,d,a,b, 7,11);
514 	MD4_R3(b,c,d,a,15,15);
515 
516 	state[0] += a;
517 	state[1] += b;
518 	state[2] += c;
519 	state[3] += d;
520 }
521 
522 /* {{{ PHP_MD4Init
523  * MD4 initialization. Begins an MD4 operation, writing a new context.
524  */
PHP_MD4Init(PHP_MD4_CTX * context)525 PHP_HASH_API void PHP_MD4Init(PHP_MD4_CTX * context)
526 {
527 	context->count[0] = context->count[1] = 0;
528 	/* Load magic initialization constants.
529 	 */
530 	context->state[0] = 0x67452301;
531 	context->state[1] = 0xefcdab89;
532 	context->state[2] = 0x98badcfe;
533 	context->state[3] = 0x10325476;
534 }
535 /* }}} */
536 
537 /* {{{ PHP_MD4Update
538    MD4 block update operation. Continues an MD4 message-digest
539    operation, processing another message block, and updating the
540    context.
541  */
PHP_MD4Update(PHP_MD4_CTX * context,const unsigned char * input,unsigned int inputLen)542 PHP_HASH_API void PHP_MD4Update(PHP_MD4_CTX * context, const unsigned char *input, unsigned int inputLen)
543 {
544 	unsigned int i, index, partLen;
545 
546 	/* Compute number of bytes mod 64 */
547 	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
548 
549 	/* Update number of bits */
550 	if ((context->count[0] += ((uint32_t) inputLen << 3))
551 		< ((uint32_t) inputLen << 3))
552 		context->count[1]++;
553 	context->count[1] += ((uint32_t) inputLen >> 29);
554 
555 	partLen = 64 - index;
556 
557 	/* Transform as many times as possible.
558 	 */
559 	if (inputLen >= partLen) {
560 		memcpy((unsigned char*) & context->buffer[index], (unsigned char*) input, partLen);
561 		MD4Transform(context->state, context->buffer);
562 
563 		for (i = partLen; i + 63 < inputLen; i += 64) {
564 			MD4Transform(context->state, &input[i]);
565 		}
566 
567 		index = 0;
568 	} else {
569 		i = 0;
570 	}
571 
572 	/* Buffer remaining input */
573 	memcpy((unsigned char*) & context->buffer[index], (unsigned char*) & input[i], inputLen - i);
574 }
575 /* }}} */
576 
577 /* {{{ PHP_MD4Final
578    MD4 finalization. Ends an MD4 message-digest operation, writing the
579    the message digest and zeroizing the context.
580  */
PHP_MD4Final(unsigned char digest[16],PHP_MD4_CTX * context)581 PHP_HASH_API void PHP_MD4Final(unsigned char digest[16], PHP_MD4_CTX * context)
582 {
583 	unsigned char bits[8];
584 	unsigned int index, padLen;
585 
586 	/* Save number of bits */
587 	Encode(bits, context->count, 8);
588 
589 	/* Pad out to 56 mod 64.
590 	 */
591 	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
592 	padLen = (index < 56) ? (56 - index) : (120 - index);
593 	PHP_MD4Update(context, PADDING, padLen);
594 
595 	/* Append length (before padding) */
596 	PHP_MD4Update(context, bits, 8);
597 
598 	/* Store state in digest */
599 	Encode(digest, context->state, 16);
600 
601 	/* Zeroize sensitive information.
602 	 */
603 	ZEND_SECURE_ZERO((unsigned char*) context, sizeof(*context));
604 }
605 /* }}} */
606 
607 /* MD2 */
608 
609 static const unsigned char MD2_S[256] = {
610 	 41,  46,  67, 201, 162, 216, 124,   1,  61,  54,  84, 161, 236, 240,   6,  19,
611 	 98, 167,   5, 243, 192, 199, 115, 140, 152, 147,  43, 217, 188,  76, 130, 202,
612 	 30, 155,  87,  60, 253, 212, 224,  22, 103,  66, 111,  24, 138,  23, 229,  18,
613 	190,  78, 196, 214, 218, 158, 222,  73, 160, 251, 245, 142, 187,  47, 238, 122,
614 	169, 104, 121, 145,  21, 178,   7,  63, 148, 194,  16, 137,  11,  34,  95,  33,
615 	128, 127,  93, 154,  90, 144,  50,  39,  53,  62, 204, 231, 191, 247, 151,   3,
616 	255,  25,  48, 179,  72, 165, 181, 209, 215,  94, 146,  42, 172,  86, 170, 198,
617 	 79, 184,  56, 210, 150, 164, 125, 182, 118, 252, 107, 226, 156, 116,   4, 241,
618 	 69, 157, 112,  89, 100, 113, 135,  32, 134,  91, 207, 101, 230,  45, 168,   2,
619 	 27,  96,  37, 173, 174, 176, 185, 246,  28,  70,  97, 105,  52,  64, 126,  15,
620 	 85,  71, 163,  35, 221,  81, 175,  58, 195,  92, 249, 206, 186, 197, 234,  38,
621 	 44,  83,  13, 110, 133,  40, 132,   9, 211, 223, 205, 244,  65, 129,  77,  82,
622 	106, 220,  55, 200, 108, 193, 171, 250,  36, 225, 123,   8,  12, 189, 177,  74,
623 	120, 136, 149, 139, 227,  99, 232, 109, 233, 203, 213, 254,  59,   0,  29,  57,
624 	242, 239, 183,  14, 102,  88, 208, 228, 166, 119, 114, 248, 235, 117,  75,  10,
625 	 49,  68,  80, 180, 143, 237,  31,  26, 219, 153, 141,  51, 159,  17, 131,  20 };
626 
PHP_MD2Init(PHP_MD2_CTX * context)627 PHP_HASH_API void PHP_MD2Init(PHP_MD2_CTX *context)
628 {
629 	memset(context, 0, sizeof(PHP_MD2_CTX));
630 }
631 
MD2_Transform(PHP_MD2_CTX * context,const unsigned char * block)632 static void MD2_Transform(PHP_MD2_CTX *context, const unsigned char *block)
633 {
634 	unsigned char i,j,t = 0;
635 
636 	for(i = 0; i < 16; i++) {
637 		context->state[16+i] = block[i];
638 		context->state[32+i] = (context->state[16+i] ^ context->state[i]);
639 	}
640 
641 	for(i = 0; i < 18; i++) {
642 		for(j = 0; j < 48; j++) {
643 			t = context->state[j] = context->state[j] ^ MD2_S[t];
644 		}
645 		t += i;
646 	}
647 
648 	/* Update checksum -- must be after transform to avoid fouling up last message block */
649 	t = context->checksum[15];
650 	for(i = 0; i < 16; i++) {
651 		t = context->checksum[i] ^= MD2_S[block[i] ^ t];
652 	}
653 }
654 
PHP_MD2Update(PHP_MD2_CTX * context,const unsigned char * buf,unsigned int len)655 PHP_HASH_API void PHP_MD2Update(PHP_MD2_CTX *context, const unsigned char *buf, unsigned int len)
656 {
657 	const unsigned char *p = buf, *e = buf + len;
658 
659 	if (context->in_buffer) {
660 		if (context->in_buffer + len < 16) {
661 			/* Not enough for block, just pass into buffer */
662 			memcpy(context->buffer + context->in_buffer, p, len);
663 			context->in_buffer += len;
664 			return;
665 		}
666 		/* Put buffered data together with inbound for a single block */
667 		memcpy(context->buffer + context->in_buffer, p, 16 - context->in_buffer);
668 		MD2_Transform(context, context->buffer);
669 		p += 16 - context->in_buffer;
670 		context->in_buffer = 0;
671 	}
672 
673 	/* Process as many whole blocks as remain */
674 	while ((p + 16) <= e) {
675 		MD2_Transform(context, p);
676 		p += 16;
677 	}
678 
679 	/* Copy remaining data to buffer */
680 	if (p < e) {
681 		memcpy(context->buffer, p, e - p);
682 		context->in_buffer = e - p;
683 	}
684 }
685 
PHP_MD2Final(unsigned char output[16],PHP_MD2_CTX * context)686 PHP_HASH_API void PHP_MD2Final(unsigned char output[16], PHP_MD2_CTX *context)
687 {
688 	memset(context->buffer + context->in_buffer, 16 - context->in_buffer, 16 - context->in_buffer);
689 	MD2_Transform(context, context->buffer);
690 	MD2_Transform(context, context->checksum);
691 
692 	memcpy(output, context->state, 16);
693 }
694 
695 /*
696  * Local variables:
697  * tab-width: 4
698  * c-basic-offset: 4
699  * End:
700  * vim600: sw=4 ts=4 fdm=marker
701  * vim<600: sw=4 ts=4
702  */
703