Annotation of embedaddon/php/ext/hash/hash_md.c, revision 1.1.1.2
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 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:
1.1.1.2 ! misho 19: /* $Id$ */
1.1 misho 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 (php_hash_uint32) into output (unsigned char). Assumes len is
65: a multiple of 4.
66: */
67: static void Encode(unsigned char *output, php_hash_uint32 *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 (php_hash_uint32). Assumes len is
82: a multiple of 4.
83: */
84: static void Decode(php_hash_uint32 *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] = ((php_hash_uint32) input[j]) | (((php_hash_uint32) input[j + 1]) << 8) |
90: (((php_hash_uint32) input[j + 2]) << 16) | (((php_hash_uint32) input[j + 3]) << 24);
91: }
92: /* }}} */
93:
94: #ifdef PHP_HASH_MD5_NOT_IN_CORE
95:
96: /* MD5 */
97:
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 */
106: PHP_NAMED_FUNCTION(php_if_md5)
107: {
108: char *arg;
109: int 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() TSRMLS_CC, "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, 1);
125: } else {
126: make_digest(md5str, digest);
127: RETVAL_STRING(md5str, 1);
128: }
129:
130: }
131: /* }}} */
132:
133: /* {{{ proto string md5_file(string filename [, bool raw_output])
134: Calculate the md5 hash of given filename */
135: PHP_NAMED_FUNCTION(php_if_md5_file)
136: {
137: char *arg;
138: int 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:
1.1.1.2 ! misho 147: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|b", &arg, &arg_len, &raw_output) == FAILURE) {
1.1 misho 148: return;
149: }
150:
1.1.1.2 ! misho 151: stream = php_stream_open_wrapper(arg, "rb", REPORT_ERRORS, NULL);
1.1 misho 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, 1);
172: } else {
173: make_digest(md5str, digest);
174: RETVAL_STRING(md5str, 1);
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(php_hash_uint32[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) + (php_hash_uint32)(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) + (php_hash_uint32)(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) + (php_hash_uint32)(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) + (php_hash_uint32)(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: */
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: */
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] += ((php_hash_uint32) inputLen << 3))
294: < ((php_hash_uint32) inputLen << 3))
295: context->count[1]++;
296: context->count[1] += ((php_hash_uint32) 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: */
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: memset((unsigned char*) context, 0, sizeof(*context));
348: }
349: /* }}} */
350:
351: /* {{{ MD5Transform
352: * MD5 basic transformation. Transforms state based on block.
353: */
354: static void MD5Transform(state, block)
355: php_hash_uint32 state[4];
356: const unsigned char block[64];
357: {
358: php_hash_uint32 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: memset((unsigned char*) x, 0, 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:
458: static void MD4Transform(php_hash_uint32 state[4], const unsigned char block[64])
459: {
460: php_hash_uint32 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: */
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: */
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] += ((php_hash_uint32) inputLen << 3))
553: < ((php_hash_uint32) inputLen << 3))
554: context->count[1]++;
555: context->count[1] += ((php_hash_uint32) 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: */
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: memset((unsigned char*) context, 0, 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:
629: PHP_HASH_API void PHP_MD2Init(PHP_MD2_CTX *context)
630: {
631: memset(context, 0, sizeof(PHP_MD2_CTX));
632: }
633:
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:
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:
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: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hash_md.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / hash