Annotation of embedaddon/php/ext/hash/hash.c, revision 1.1.1.1
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: | Author: Sara Golemon <pollita@php.net> |
16: | Scott MacVicar <scottmac@php.net> |
17: +----------------------------------------------------------------------+
18: */
19:
20: /* $Id: hash.c 321634 2012-01-01 13:15:04Z felipe $ */
21:
22: #ifdef HAVE_CONFIG_H
23: #include "config.h"
24: #endif
25:
26: #include "php_hash.h"
27: #include "ext/standard/info.h"
28: #include "ext/standard/file.h"
29:
30: static int php_hash_le_hash;
31: HashTable php_hash_hashtable;
32:
33: #if (PHP_MAJOR_VERSION >= 5)
34: # define DEFAULT_CONTEXT FG(default_context)
35: #else
36: # define DEFAULT_CONTEXT NULL
37: #endif
38:
39: #ifdef PHP_MHASH_BC
40: struct mhash_bc_entry {
41: char *mhash_name;
42: char *hash_name;
43: int value;
44: };
45:
46: #define MHASH_NUM_ALGOS 29
47:
48: static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {
49: {"CRC32", "crc32", 0},
50: {"MD5", "md5", 1},
51: {"SHA1", "sha1", 2},
52: {"HAVAL256", "haval256,3", 3},
53: {NULL, NULL, 4},
54: {"RIPEMD160", "ripemd160", 5},
55: {NULL, NULL, 6},
56: {"TIGER", "tiger192,3", 7},
57: {"GOST", "gost", 8},
58: {"CRC32B", "crc32b", 9},
59: {"HAVAL224", "haval224,3", 10},
60: {"HAVAL192", "haval192,3", 11},
61: {"HAVAL160", "haval160,3", 12},
62: {"HAVAL128", "haval128,3", 13},
63: {"TIGER128", "tiger128,3", 14},
64: {"TIGER160", "tiger160,3", 15},
65: {"MD4", "md4", 16},
66: {"SHA256", "sha256", 17},
67: {"ADLER32", "adler32", 18},
68: {"SHA224", "sha224", 19},
69: {"SHA512", "sha512", 20},
70: {"SHA384", "sha384", 21},
71: {"WHIRLPOOL", "whirlpool", 22},
72: {"RIPEMD128", "ripemd128", 23},
73: {"RIPEMD256", "ripemd256", 24},
74: {"RIPEMD320", "ripemd320", 25},
75: {NULL, NULL, 26}, /* support needs to be added for snefru 128 */
76: {"SNEFRU256", "snefru256", 27},
77: {"MD2", "md2", 28}
78: };
79: #endif
80:
81: /* Hash Registry Access */
82:
83: PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, int algo_len) /* {{{ */
84: {
85: php_hash_ops *ops;
86: char *lower = estrndup(algo, algo_len);
87:
88: zend_str_tolower(lower, algo_len);
89: if (SUCCESS != zend_hash_find(&php_hash_hashtable, lower, algo_len + 1, (void*)&ops)) {
90: ops = NULL;
91: }
92: efree(lower);
93:
94: return ops;
95: }
96: /* }}} */
97:
98: PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops) /* {{{ */
99: {
100: int algo_len = strlen(algo);
101: char *lower = estrndup(algo, algo_len);
102:
103: zend_str_tolower(lower, algo_len);
104: zend_hash_add(&php_hash_hashtable, lower, algo_len + 1, (void*)ops, sizeof(php_hash_ops), NULL);
105: efree(lower);
106: }
107: /* }}} */
108:
109: PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context) /* {{{ */
110: {
111: php_hash_ops *hash_ops = (php_hash_ops *)ops;
112:
113: memcpy(dest_context, orig_context, hash_ops->context_size);
114: return SUCCESS;
115: }
116: /* }}} */
117:
118: /* Userspace */
119:
120: static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
121: {
122: char *algo, *data, *digest;
123: int algo_len, data_len;
124: zend_bool raw_output = raw_output_default;
125: const php_hash_ops *ops;
126: void *context;
127: php_stream *stream = NULL;
128:
129: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &algo, &algo_len, &data, &data_len, &raw_output) == FAILURE) {
130: return;
131: }
132:
133: ops = php_hash_fetch_ops(algo, algo_len);
134: if (!ops) {
135: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
136: RETURN_FALSE;
137: }
138: if (isfilename) {
139: stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL, DEFAULT_CONTEXT);
140: if (!stream) {
141: /* Stream will report errors opening file */
142: RETURN_FALSE;
143: }
144: }
145:
146: context = emalloc(ops->context_size);
147: ops->hash_init(context);
148:
149: if (isfilename) {
150: char buf[1024];
151: int n;
152:
153: while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
154: ops->hash_update(context, (unsigned char *) buf, n);
155: }
156: php_stream_close(stream);
157: } else {
158: ops->hash_update(context, (unsigned char *) data, data_len);
159: }
160:
161: digest = emalloc(ops->digest_size + 1);
162: ops->hash_final((unsigned char *) digest, context);
163: efree(context);
164:
165: if (raw_output) {
166: digest[ops->digest_size] = 0;
167: RETURN_STRINGL(digest, ops->digest_size, 0);
168: } else {
169: char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);
170:
171: php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
172: hex_digest[2 * ops->digest_size] = 0;
173: efree(digest);
174: RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
175: }
176: }
177: /* }}} */
178:
179: /* {{{ proto string hash(string algo, string data[, bool raw_output = false])
180: Generate a hash of a given input string
181: Returns lowercase hexits by default */
182: PHP_FUNCTION(hash)
183: {
184: php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
185: }
186: /* }}} */
187:
188: /* {{{ proto string hash_file(string algo, string filename[, bool raw_output = false])
189: Generate a hash of a given file
190: Returns lowercase hexits by default */
191: PHP_FUNCTION(hash_file)
192: {
193: php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
194: }
195: /* }}} */
196:
197: static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
198: {
199: char *algo, *data, *digest, *key, *K;
200: int algo_len, data_len, key_len, i;
201: zend_bool raw_output = raw_output_default;
202: const php_hash_ops *ops;
203: void *context;
204: php_stream *stream = NULL;
205:
206: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|b", &algo, &algo_len, &data, &data_len,
207: &key, &key_len, &raw_output) == FAILURE) {
208: return;
209: }
210:
211: ops = php_hash_fetch_ops(algo, algo_len);
212: if (!ops) {
213: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
214: RETURN_FALSE;
215: }
216: if (isfilename) {
217: stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL, DEFAULT_CONTEXT);
218: if (!stream) {
219: /* Stream will report errors opening file */
220: RETURN_FALSE;
221: }
222: }
223:
224: context = emalloc(ops->context_size);
225: ops->hash_init(context);
226:
227: K = emalloc(ops->block_size);
228: memset(K, 0, ops->block_size);
229:
230: if (key_len > ops->block_size) {
231: /* Reduce the key first */
232: ops->hash_update(context, (unsigned char *) key, key_len);
233: ops->hash_final((unsigned char *) K, context);
234: /* Make the context ready to start over */
235: ops->hash_init(context);
236: } else {
237: memcpy(K, key, key_len);
238: }
239:
240: /* XOR ipad */
241: for(i=0; i < ops->block_size; i++) {
242: K[i] ^= 0x36;
243: }
244: ops->hash_update(context, (unsigned char *) K, ops->block_size);
245:
246: if (isfilename) {
247: char buf[1024];
248: int n;
249:
250: while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
251: ops->hash_update(context, (unsigned char *) buf, n);
252: }
253: php_stream_close(stream);
254: } else {
255: ops->hash_update(context, (unsigned char *) data, data_len);
256: }
257:
258: digest = emalloc(ops->digest_size + 1);
259: ops->hash_final((unsigned char *) digest, context);
260:
261: /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */
262: for(i=0; i < ops->block_size; i++) {
263: K[i] ^= 0x6A;
264: }
265:
266: /* Feed this result into the outter hash */
267: ops->hash_init(context);
268: ops->hash_update(context, (unsigned char *) K, ops->block_size);
269: ops->hash_update(context, (unsigned char *) digest, ops->digest_size);
270: ops->hash_final((unsigned char *) digest, context);
271:
272: /* Zero the key */
273: memset(K, 0, ops->block_size);
274: efree(K);
275: efree(context);
276:
277: if (raw_output) {
278: digest[ops->digest_size] = 0;
279: RETURN_STRINGL(digest, ops->digest_size, 0);
280: } else {
281: char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);
282:
283: php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
284: hex_digest[2 * ops->digest_size] = 0;
285: efree(digest);
286: RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
287: }
288: }
289: /* }}} */
290:
291: /* {{{ proto string hash_hmac(string algo, string data, string key[, bool raw_output = false])
292: Generate a hash of a given input string with a key using HMAC
293: Returns lowercase hexits by default */
294: PHP_FUNCTION(hash_hmac)
295: {
296: php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
297: }
298: /* }}} */
299:
300: /* {{{ proto string hash_hmac_file(string algo, string filename, string key[, bool raw_output = false])
301: Generate a hash of a given file with a key using HMAC
302: Returns lowercase hexits by default */
303: PHP_FUNCTION(hash_hmac_file)
304: {
305: php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
306: }
307: /* }}} */
308:
309:
310: /* {{{ proto resource hash_init(string algo[, int options, string key])
311: Initialize a hashing context */
312: PHP_FUNCTION(hash_init)
313: {
314: char *algo, *key = NULL;
315: int algo_len, key_len = 0, argc = ZEND_NUM_ARGS();
316: long options = 0;
317: void *context;
318: const php_hash_ops *ops;
319: php_hash_data *hash;
320:
321: if (zend_parse_parameters(argc TSRMLS_CC, "s|ls", &algo, &algo_len, &options, &key, &key_len) == FAILURE) {
322: return;
323: }
324:
325: ops = php_hash_fetch_ops(algo, algo_len);
326: if (!ops) {
327: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
328: RETURN_FALSE;
329: }
330:
331: if (options & PHP_HASH_HMAC &&
332: key_len <= 0) {
333: /* Note: a zero length key is no key at all */
334: php_error_docref(NULL TSRMLS_CC, E_WARNING, "HMAC requested without a key");
335: RETURN_FALSE;
336: }
337:
338: context = emalloc(ops->context_size);
339: ops->hash_init(context);
340:
341: hash = emalloc(sizeof(php_hash_data));
342: hash->ops = ops;
343: hash->context = context;
344: hash->options = options;
345: hash->key = NULL;
346:
347: if (options & PHP_HASH_HMAC) {
348: char *K = emalloc(ops->block_size);
349: int i;
350:
351: memset(K, 0, ops->block_size);
352:
353: if (key_len > ops->block_size) {
354: /* Reduce the key first */
355: ops->hash_update(context, (unsigned char *) key, key_len);
356: ops->hash_final((unsigned char *) K, context);
357: /* Make the context ready to start over */
358: ops->hash_init(context);
359: } else {
360: memcpy(K, key, key_len);
361: }
362:
363: /* XOR ipad */
364: for(i=0; i < ops->block_size; i++) {
365: K[i] ^= 0x36;
366: }
367: ops->hash_update(context, (unsigned char *) K, ops->block_size);
368: hash->key = (unsigned char *) K;
369: }
370:
371: ZEND_REGISTER_RESOURCE(return_value, hash, php_hash_le_hash);
372: }
373: /* }}} */
374:
375: /* {{{ proto bool hash_update(resource context, string data)
376: Pump data into the hashing algorithm */
377: PHP_FUNCTION(hash_update)
378: {
379: zval *zhash;
380: php_hash_data *hash;
381: char *data;
382: int data_len;
383:
384: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &zhash, &data, &data_len) == FAILURE) {
385: return;
386: }
387:
388: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
389:
390: hash->ops->hash_update(hash->context, (unsigned char *) data, data_len);
391:
392: RETURN_TRUE;
393: }
394: /* }}} */
395:
396: /* {{{ proto int hash_update_stream(resource context, resource handle[, integer length])
397: Pump data into the hashing algorithm from an open stream */
398: PHP_FUNCTION(hash_update_stream)
399: {
400: zval *zhash, *zstream;
401: php_hash_data *hash;
402: php_stream *stream = NULL;
403: long length = -1, didread = 0;
404:
405: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|l", &zhash, &zstream, &length) == FAILURE) {
406: return;
407: }
408:
409: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
410: php_stream_from_zval(stream, &zstream);
411:
412: while (length) {
413: char buf[1024];
414: long n, toread = 1024;
415:
416: if (length > 0 && toread > length) {
417: toread = length;
418: }
419:
420: if ((n = php_stream_read(stream, buf, toread)) <= 0) {
421: /* Nada mas */
422: RETURN_LONG(didread);
423: }
424: hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
425: length -= n;
426: didread += n;
427: }
428:
429: RETURN_LONG(didread);
430: }
431: /* }}} */
432:
433: /* {{{ proto bool hash_update_file(resource context, string filename[, resource context])
434: Pump data into the hashing algorithm from a file */
435: PHP_FUNCTION(hash_update_file)
436: {
437: zval *zhash, *zcontext = NULL;
438: php_hash_data *hash;
439: php_stream_context *context;
440: php_stream *stream;
441: char *filename, buf[1024];
442: int filename_len, n;
443:
444: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|r", &zhash, &filename, &filename_len, &zcontext) == FAILURE) {
445: return;
446: }
447:
448: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
449: context = php_stream_context_from_zval(zcontext, 0);
450:
451: stream = php_stream_open_wrapper_ex(filename, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL, context);
452: if (!stream) {
453: /* Stream will report errors opening file */
454: RETURN_FALSE;
455: }
456:
457: while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
458: hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
459: }
460: php_stream_close(stream);
461:
462: RETURN_TRUE;
463: }
464: /* }}} */
465:
466: /* {{{ proto string hash_final(resource context[, bool raw_output=false])
467: Output resulting digest */
468: PHP_FUNCTION(hash_final)
469: {
470: zval *zhash;
471: php_hash_data *hash;
472: zend_bool raw_output = 0;
473: zend_rsrc_list_entry *le;
474: char *digest;
475: int digest_len;
476:
477: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|b", &zhash, &raw_output) == FAILURE) {
478: return;
479: }
480:
481: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
482:
483: digest_len = hash->ops->digest_size;
484: digest = emalloc(digest_len + 1);
485: hash->ops->hash_final((unsigned char *) digest, hash->context);
486: if (hash->options & PHP_HASH_HMAC) {
487: int i;
488:
489: /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */
490: for(i=0; i < hash->ops->block_size; i++) {
491: hash->key[i] ^= 0x6A;
492: }
493:
494: /* Feed this result into the outter hash */
495: hash->ops->hash_init(hash->context);
496: hash->ops->hash_update(hash->context, (unsigned char *) hash->key, hash->ops->block_size);
497: hash->ops->hash_update(hash->context, (unsigned char *) digest, hash->ops->digest_size);
498: hash->ops->hash_final((unsigned char *) digest, hash->context);
499:
500: /* Zero the key */
501: memset(hash->key, 0, hash->ops->block_size);
502: efree(hash->key);
503: hash->key = NULL;
504: }
505: digest[digest_len] = 0;
506: efree(hash->context);
507: hash->context = NULL;
508:
509: /* zend_list_REAL_delete() */
510: if (zend_hash_index_find(&EG(regular_list), Z_RESVAL_P(zhash), (void *) &le)==SUCCESS) {
511: /* This is a hack to avoid letting the resource hide elsewhere (like in separated vars)
512: FETCH_RESOURCE is intelligent enough to handle dealing with any issues this causes */
513: le->refcount = 1;
514: } /* FAILURE is not an option */
515: zend_list_delete(Z_RESVAL_P(zhash));
516:
517: if (raw_output) {
518: RETURN_STRINGL(digest, digest_len, 0);
519: } else {
520: char *hex_digest = safe_emalloc(digest_len,2,1);
521:
522: php_hash_bin2hex(hex_digest, (unsigned char *) digest, digest_len);
523: hex_digest[2 * digest_len] = 0;
524: efree(digest);
525: RETURN_STRINGL(hex_digest, 2 * digest_len, 0);
526: }
527: }
528: /* }}} */
529:
530: /* {{{ proto resource hash_copy(resource context)
531: Copy hash resource */
532: PHP_FUNCTION(hash_copy)
533: {
534: zval *zhash;
535: php_hash_data *hash, *copy_hash;
536: void *context;
537: int res;
538:
539: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zhash) == FAILURE) {
540: return;
541: }
542:
543: ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
544:
545:
546: context = emalloc(hash->ops->context_size);
547: hash->ops->hash_init(context);
548:
549: res = hash->ops->hash_copy(hash->ops, hash->context, context);
550: if (res != SUCCESS) {
551: efree(context);
552: RETURN_FALSE;
553: }
554:
555: copy_hash = emalloc(sizeof(php_hash_data));
556: copy_hash->ops = hash->ops;
557: copy_hash->context = context;
558: copy_hash->options = hash->options;
559: copy_hash->key = ecalloc(1, hash->ops->block_size);
560: if (hash->key) {
561: memcpy(copy_hash->key, hash->key, hash->ops->block_size);
562: }
563: ZEND_REGISTER_RESOURCE(return_value, copy_hash, php_hash_le_hash);
564: }
565: /* }}} */
566:
567: /* {{{ proto array hash_algos(void)
568: Return a list of registered hashing algorithms */
569: PHP_FUNCTION(hash_algos)
570: {
571: HashPosition pos;
572: char *str;
573: uint str_len;
574: long type;
575: ulong idx;
576:
577: array_init(return_value);
578: for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
579: (type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, &str_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT;
580: zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
581: add_next_index_stringl(return_value, str, str_len-1, 1);
582: }
583: }
584: /* }}} */
585:
586: /* Module Housekeeping */
587:
588: static void php_hash_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
589: {
590: php_hash_data *hash = (php_hash_data*)rsrc->ptr;
591:
592: /* Just in case the algo has internally allocated resources */
593: if (hash->context) {
594: unsigned char *dummy = emalloc(hash->ops->digest_size);
595: hash->ops->hash_final(dummy, hash->context);
596: efree(dummy);
597: efree(hash->context);
598: }
599:
600: if (hash->key) {
601: memset(hash->key, 0, hash->ops->block_size);
602: efree(hash->key);
603: }
604: efree(hash);
605: }
606: /* }}} */
607:
608: #define PHP_HASH_HAVAL_REGISTER(p,b) php_hash_register_algo("haval" #b "," #p , &php_hash_##p##haval##b##_ops);
609:
610: #ifdef PHP_MHASH_BC
611:
612: PHP_MINFO_FUNCTION(mhash)
613: {
614: php_info_print_table_start();
615: php_info_print_table_row(2, "MHASH support", "Enabled");
616: php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
617: php_info_print_table_end();
618: }
619:
620: zend_module_entry mhash_module_entry = {
621: STANDARD_MODULE_HEADER,
622: "mhash",
623: NULL,
624: NULL,
625: NULL,
626: NULL,
627: NULL,
628: PHP_MINFO(mhash),
629: NO_VERSION_YET,
630: STANDARD_MODULE_PROPERTIES,
631: };
632:
633: static void mhash_init(INIT_FUNC_ARGS)
634: {
635: char buf[128];
636: int len;
637: int algo_number = 0;
638:
639: for (algo_number = 0; algo_number < MHASH_NUM_ALGOS; algo_number++) {
640: struct mhash_bc_entry algorithm = mhash_to_hash[algo_number];
641: if (algorithm.mhash_name == NULL) {
642: continue;
643: }
644:
645: len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name, strlen(algorithm.mhash_name));
646: zend_register_long_constant(buf, len + 1, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
647: }
648: zend_register_internal_module(&mhash_module_entry TSRMLS_CC);
649: }
650:
651: /* {{{ proto string mhash(int hash, string data [, string key])
652: Hash data with hash */
653: PHP_FUNCTION(mhash)
654: {
655: zval **z_algorithm;
656: long algorithm;
657:
658: if (zend_parse_parameters(1 TSRMLS_CC, "Z", &z_algorithm) == FAILURE) {
659: return;
660: }
661:
662: SEPARATE_ZVAL(z_algorithm);
663: convert_to_long_ex(z_algorithm);
664: algorithm = Z_LVAL_PP(z_algorithm);
665:
666: /* need to convert the first parameter from int constant to string algorithm name */
667: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
668: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
669: if (algorithm_lookup.hash_name) {
670: ZVAL_STRING(*z_algorithm, algorithm_lookup.hash_name, 1);
671: }
672: }
673:
674: if (ZEND_NUM_ARGS() == 3) {
675: php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
676: } else if (ZEND_NUM_ARGS() == 2) {
677: php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
678: } else {
679: WRONG_PARAM_COUNT;
680: }
681: }
682: /* }}} */
683:
684: /* {{{ proto string mhash_get_hash_name(int hash)
685: Gets the name of hash */
686: PHP_FUNCTION(mhash_get_hash_name)
687: {
688: long algorithm;
689:
690: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &algorithm) == FAILURE) {
691: return;
692: }
693:
694: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
695: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
696: if (algorithm_lookup.mhash_name) {
697: RETURN_STRING(algorithm_lookup.mhash_name, 1);
698: }
699: }
700: RETURN_FALSE;
701: }
702: /* }}} */
703:
704: /* {{{ proto int mhash_count(void)
705: Gets the number of available hashes */
706: PHP_FUNCTION(mhash_count)
707: {
708: if (zend_parse_parameters_none() == FAILURE) {
709: return;
710: }
711: RETURN_LONG(MHASH_NUM_ALGOS - 1);
712: }
713: /* }}} */
714:
715: /* {{{ proto int mhash_get_block_size(int hash)
716: Gets the block size of hash */
717: PHP_FUNCTION(mhash_get_block_size)
718: {
719: long algorithm;
720:
721: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &algorithm) == FAILURE) {
722: return;
723: }
724: RETVAL_FALSE;
725:
726: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
727: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
728: if (algorithm_lookup.mhash_name) {
729: const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
730: if (ops) {
731: RETVAL_LONG(ops->digest_size);
732: }
733: }
734: }
735: }
736: /* }}} */
737:
738: #define SALT_SIZE 8
739:
740: /* {{{ proto string mhash_keygen_s2k(int hash, string input_password, string salt, int bytes)
741: Generates a key using hash functions */
742: PHP_FUNCTION(mhash_keygen_s2k)
743: {
744: long algorithm, l_bytes;
745: int bytes;
746: char *password, *salt;
747: int password_len, salt_len;
748: char padded_salt[SALT_SIZE];
749:
750: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) {
751: return;
752: }
753:
754: bytes = (int)l_bytes;
755: if (bytes <= 0){
756: php_error_docref(NULL TSRMLS_CC, E_WARNING, "the byte parameter must be greater than 0");
757: RETURN_FALSE;
758: }
759:
760: salt_len = MIN(salt_len, SALT_SIZE);
761:
762: memcpy(padded_salt, salt, salt_len);
763: if (salt_len < SALT_SIZE) {
764: memset(padded_salt + salt_len, 0, SALT_SIZE - salt_len);
765: }
766: salt_len = SALT_SIZE;
767:
768: RETVAL_FALSE;
769: if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
770: struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
771: if (algorithm_lookup.mhash_name) {
772: const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
773: if (ops) {
774: unsigned char null = '\0';
775: void *context;
776: char *key, *digest;
777: int i = 0, j = 0;
778: int block_size = ops->digest_size;
779: int times = bytes / block_size;
780: if (bytes % block_size != 0) times++;
781:
782: context = emalloc(ops->context_size);
783: ops->hash_init(context);
784:
785: key = ecalloc(1, times * block_size);
786: digest = emalloc(ops->digest_size + 1);
787:
788: for (i = 0; i < times; i++) {
789: ops->hash_init(context);
790:
791: for (j=0;j<i;j++) {
792: ops->hash_update(context, &null, 1);
793: }
794: ops->hash_update(context, (unsigned char *)padded_salt, salt_len);
795: ops->hash_update(context, (unsigned char *)password, password_len);
796: ops->hash_final((unsigned char *)digest, context);
797: memcpy( &key[i*block_size], digest, block_size);
798: }
799:
800: RETVAL_STRINGL(key, bytes, 1);
801: memset(key, 0, bytes);
802: efree(digest);
803: efree(context);
804: efree(key);
805: }
806: }
807: }
808: }
809: /* }}} */
810:
811: #endif
812:
813: /* {{{ PHP_MINIT_FUNCTION
814: */
815: PHP_MINIT_FUNCTION(hash)
816: {
817: php_hash_le_hash = zend_register_list_destructors_ex(php_hash_dtor, NULL, PHP_HASH_RESNAME, module_number);
818:
819: zend_hash_init(&php_hash_hashtable, 35, NULL, NULL, 1);
820:
821: php_hash_register_algo("md2", &php_hash_md2_ops);
822: php_hash_register_algo("md4", &php_hash_md4_ops);
823: php_hash_register_algo("md5", &php_hash_md5_ops);
824: php_hash_register_algo("sha1", &php_hash_sha1_ops);
825: php_hash_register_algo("sha224", &php_hash_sha224_ops);
826: php_hash_register_algo("sha256", &php_hash_sha256_ops);
827: php_hash_register_algo("sha384", &php_hash_sha384_ops);
828: php_hash_register_algo("sha512", &php_hash_sha512_ops);
829: php_hash_register_algo("ripemd128", &php_hash_ripemd128_ops);
830: php_hash_register_algo("ripemd160", &php_hash_ripemd160_ops);
831: php_hash_register_algo("ripemd256", &php_hash_ripemd256_ops);
832: php_hash_register_algo("ripemd320", &php_hash_ripemd320_ops);
833: php_hash_register_algo("whirlpool", &php_hash_whirlpool_ops);
834: php_hash_register_algo("tiger128,3", &php_hash_3tiger128_ops);
835: php_hash_register_algo("tiger160,3", &php_hash_3tiger160_ops);
836: php_hash_register_algo("tiger192,3", &php_hash_3tiger192_ops);
837: php_hash_register_algo("tiger128,4", &php_hash_4tiger128_ops);
838: php_hash_register_algo("tiger160,4", &php_hash_4tiger160_ops);
839: php_hash_register_algo("tiger192,4", &php_hash_4tiger192_ops);
840: php_hash_register_algo("snefru", &php_hash_snefru_ops);
841: php_hash_register_algo("snefru256", &php_hash_snefru_ops);
842: php_hash_register_algo("gost", &php_hash_gost_ops);
843: php_hash_register_algo("adler32", &php_hash_adler32_ops);
844: php_hash_register_algo("crc32", &php_hash_crc32_ops);
845: php_hash_register_algo("crc32b", &php_hash_crc32b_ops);
846: php_hash_register_algo("salsa10", &php_hash_salsa10_ops);
847: php_hash_register_algo("salsa20", &php_hash_salsa20_ops);
848:
849: PHP_HASH_HAVAL_REGISTER(3,128);
850: PHP_HASH_HAVAL_REGISTER(3,160);
851: PHP_HASH_HAVAL_REGISTER(3,192);
852: PHP_HASH_HAVAL_REGISTER(3,224);
853: PHP_HASH_HAVAL_REGISTER(3,256);
854:
855: PHP_HASH_HAVAL_REGISTER(4,128);
856: PHP_HASH_HAVAL_REGISTER(4,160);
857: PHP_HASH_HAVAL_REGISTER(4,192);
858: PHP_HASH_HAVAL_REGISTER(4,224);
859: PHP_HASH_HAVAL_REGISTER(4,256);
860:
861: PHP_HASH_HAVAL_REGISTER(5,128);
862: PHP_HASH_HAVAL_REGISTER(5,160);
863: PHP_HASH_HAVAL_REGISTER(5,192);
864: PHP_HASH_HAVAL_REGISTER(5,224);
865: PHP_HASH_HAVAL_REGISTER(5,256);
866:
867: REGISTER_LONG_CONSTANT("HASH_HMAC", PHP_HASH_HMAC, CONST_CS | CONST_PERSISTENT);
868:
869: #ifdef PHP_MHASH_BC
870: mhash_init(INIT_FUNC_ARGS_PASSTHRU);
871: #endif
872:
873: return SUCCESS;
874: }
875: /* }}} */
876:
877: /* {{{ PHP_MSHUTDOWN_FUNCTION
878: */
879: PHP_MSHUTDOWN_FUNCTION(hash)
880: {
881: zend_hash_destroy(&php_hash_hashtable);
882:
883: return SUCCESS;
884: }
885: /* }}} */
886:
887: /* {{{ PHP_MINFO_FUNCTION
888: */
889: PHP_MINFO_FUNCTION(hash)
890: {
891: HashPosition pos;
892: char buffer[2048];
893: char *s = buffer, *e = s + sizeof(buffer), *str;
894: ulong idx;
895: long type;
896:
897: for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
898: (type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, NULL, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT;
899: zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
900: s += slprintf(s, e - s, "%s ", str);
901: }
902: *s = 0;
903:
904: php_info_print_table_start();
905: php_info_print_table_row(2, "hash support", "enabled");
906: php_info_print_table_row(2, "Hashing Engines", buffer);
907: php_info_print_table_end();
908: }
909: /* }}} */
910:
911: /* {{{ arginfo */
912: #ifdef PHP_HASH_MD5_NOT_IN_CORE
913: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5, 0, 0, 1)
914: ZEND_ARG_INFO(0, str)
915: ZEND_ARG_INFO(0, raw_output)
916: ZEND_END_ARG_INFO()
917:
918: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5_file, 0, 0, 1)
919: ZEND_ARG_INFO(0, filename)
920: ZEND_ARG_INFO(0, raw_output)
921: ZEND_END_ARG_INFO()
922: #endif
923:
924: #ifdef PHP_HASH_SHA1_NOT_IN_CORE
925: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1, 0, 0, 1)
926: ZEND_ARG_INFO(0, str)
927: ZEND_ARG_INFO(0, raw_output)
928: ZEND_END_ARG_INFO()
929:
930: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1_file, 0, 0, 1)
931: ZEND_ARG_INFO(0, filename)
932: ZEND_ARG_INFO(0, raw_output)
933: ZEND_END_ARG_INFO()
934: #endif
935:
936: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash, 0, 0, 2)
937: ZEND_ARG_INFO(0, algo)
938: ZEND_ARG_INFO(0, data)
939: ZEND_ARG_INFO(0, raw_output)
940: ZEND_END_ARG_INFO()
941:
942: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_file, 0, 0, 2)
943: ZEND_ARG_INFO(0, algo)
944: ZEND_ARG_INFO(0, filename)
945: ZEND_ARG_INFO(0, raw_output)
946: ZEND_END_ARG_INFO()
947:
948: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac, 0, 0, 3)
949: ZEND_ARG_INFO(0, algo)
950: ZEND_ARG_INFO(0, data)
951: ZEND_ARG_INFO(0, key)
952: ZEND_ARG_INFO(0, raw_output)
953: ZEND_END_ARG_INFO()
954:
955: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac_file, 0, 0, 3)
956: ZEND_ARG_INFO(0, algo)
957: ZEND_ARG_INFO(0, filename)
958: ZEND_ARG_INFO(0, key)
959: ZEND_ARG_INFO(0, raw_output)
960: ZEND_END_ARG_INFO()
961:
962: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_init, 0, 0, 1)
963: ZEND_ARG_INFO(0, algo)
964: ZEND_ARG_INFO(0, options)
965: ZEND_ARG_INFO(0, key)
966: ZEND_END_ARG_INFO()
967:
968: ZEND_BEGIN_ARG_INFO(arginfo_hash_update, 0)
969: ZEND_ARG_INFO(0, context)
970: ZEND_ARG_INFO(0, data)
971: ZEND_END_ARG_INFO()
972:
973: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_stream, 0, 0, 2)
974: ZEND_ARG_INFO(0, context)
975: ZEND_ARG_INFO(0, handle)
976: ZEND_ARG_INFO(0, length)
977: ZEND_END_ARG_INFO()
978:
979: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_file, 0, 0, 2)
980: ZEND_ARG_INFO(0, context)
981: ZEND_ARG_INFO(0, filename)
982: ZEND_ARG_INFO(0, context)
983: ZEND_END_ARG_INFO()
984:
985: ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_final, 0, 0, 1)
986: ZEND_ARG_INFO(0, context)
987: ZEND_ARG_INFO(0, raw_output)
988: ZEND_END_ARG_INFO()
989:
990: ZEND_BEGIN_ARG_INFO(arginfo_hash_copy, 0)
991: ZEND_ARG_INFO(0, context)
992: ZEND_END_ARG_INFO()
993:
994: ZEND_BEGIN_ARG_INFO(arginfo_hash_algos, 0)
995: ZEND_END_ARG_INFO()
996:
997: /* BC Land */
998: #ifdef PHP_MHASH_BC
999: ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_block_size, 0)
1000: ZEND_ARG_INFO(0, hash)
1001: ZEND_END_ARG_INFO()
1002:
1003: ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_hash_name, 0)
1004: ZEND_ARG_INFO(0, hash)
1005: ZEND_END_ARG_INFO()
1006:
1007: ZEND_BEGIN_ARG_INFO(arginfo_mhash_keygen_s2k, 0)
1008: ZEND_ARG_INFO(0, hash)
1009: ZEND_ARG_INFO(0, input_password)
1010: ZEND_ARG_INFO(0, salt)
1011: ZEND_ARG_INFO(0, bytes)
1012: ZEND_END_ARG_INFO()
1013:
1014: ZEND_BEGIN_ARG_INFO(arginfo_mhash_count, 0)
1015: ZEND_END_ARG_INFO()
1016:
1017: ZEND_BEGIN_ARG_INFO_EX(arginfo_mhash, 0, 0, 2)
1018: ZEND_ARG_INFO(0, hash)
1019: ZEND_ARG_INFO(0, data)
1020: ZEND_ARG_INFO(0, key)
1021: ZEND_END_ARG_INFO()
1022: #endif
1023:
1024: /* }}} */
1025:
1026: /* {{{ hash_functions[]
1027: */
1028: const zend_function_entry hash_functions[] = {
1029: PHP_FE(hash, arginfo_hash)
1030: PHP_FE(hash_file, arginfo_hash_file)
1031:
1032: PHP_FE(hash_hmac, arginfo_hash_hmac)
1033: PHP_FE(hash_hmac_file, arginfo_hash_hmac_file)
1034:
1035: PHP_FE(hash_init, arginfo_hash_init)
1036: PHP_FE(hash_update, arginfo_hash_update)
1037: PHP_FE(hash_update_stream, arginfo_hash_update_stream)
1038: PHP_FE(hash_update_file, arginfo_hash_update_file)
1039: PHP_FE(hash_final, arginfo_hash_final)
1040: PHP_FE(hash_copy, arginfo_hash_copy)
1041:
1042: PHP_FE(hash_algos, arginfo_hash_algos)
1043:
1044: /* BC Land */
1045: #ifdef PHP_HASH_MD5_NOT_IN_CORE
1046: PHP_NAMED_FE(md5, php_if_md5, arginfo_hash_md5)
1047: PHP_NAMED_FE(md5_file, php_if_md5_file, arginfo_hash_md5_file)
1048: #endif /* PHP_HASH_MD5_NOT_IN_CORE */
1049:
1050: #ifdef PHP_HASH_SHA1_NOT_IN_CORE
1051: PHP_NAMED_FE(sha1, php_if_sha1, arginfo_hash_sha1)
1052: PHP_NAMED_FE(sha1_file, php_if_sha1_file, arginfo_hash_sha1_file)
1053: #endif /* PHP_HASH_SHA1_NOT_IN_CORE */
1054:
1055: #ifdef PHP_MHASH_BC
1056: PHP_FE(mhash_keygen_s2k, arginfo_mhash_keygen_s2k)
1057: PHP_FE(mhash_get_block_size, arginfo_mhash_get_block_size)
1058: PHP_FE(mhash_get_hash_name, arginfo_mhash_get_hash_name)
1059: PHP_FE(mhash_count, arginfo_mhash_count)
1060: PHP_FE(mhash, arginfo_mhash)
1061: #endif
1062:
1063: PHP_FE_END
1064: };
1065: /* }}} */
1066:
1067: /* {{{ hash_module_entry
1068: */
1069: zend_module_entry hash_module_entry = {
1070: #if ZEND_MODULE_API_NO >= 20010901
1071: STANDARD_MODULE_HEADER,
1072: #endif
1073: PHP_HASH_EXTNAME,
1074: hash_functions,
1075: PHP_MINIT(hash),
1076: PHP_MSHUTDOWN(hash),
1077: NULL, /* RINIT */
1078: NULL, /* RSHUTDOWN */
1079: PHP_MINFO(hash),
1080: #if ZEND_MODULE_API_NO >= 20010901
1081: PHP_HASH_EXTVER, /* Replace with version number for your extension */
1082: #endif
1083: STANDARD_MODULE_PROPERTIES
1084: };
1085: /* }}} */
1086:
1087: #ifdef COMPILE_DL_HASH
1088: ZEND_GET_MODULE(hash)
1089: #endif
1090:
1091: /*
1092: * Local variables:
1093: * tab-width: 4
1094: * c-basic-offset: 4
1095: * End:
1096: * vim600: noet sw=4 ts=4 fdm=marker
1097: * vim<600: noet sw=4 ts=4
1098: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hash.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