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