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