diff options
Diffstat (limited to 'ext/hash/hash.c')
| -rw-r--r-- | ext/hash/hash.c | 1107 |
1 files changed, 1107 insertions, 0 deletions
diff --git a/ext/hash/hash.c b/ext/hash/hash.c new file mode 100644 index 0000000..f5dca3f --- /dev/null +++ b/ext/hash/hash.c @@ -0,0 +1,1107 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2013 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.01 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_01.txt | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Author: Sara Golemon <pollita@php.net> | + | Scott MacVicar <scottmac@php.net> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php_hash.h" +#include "ext/standard/info.h" +#include "ext/standard/file.h" + +static int php_hash_le_hash; +HashTable php_hash_hashtable; + +#if (PHP_MAJOR_VERSION >= 5) +# define DEFAULT_CONTEXT FG(default_context) +#else +# define DEFAULT_CONTEXT NULL +#endif + +#ifdef PHP_MHASH_BC +struct mhash_bc_entry { + char *mhash_name; + char *hash_name; + int value; +}; + +#define MHASH_NUM_ALGOS 34 + +static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = { + {"CRC32", "crc32", 0}, + {"MD5", "md5", 1}, + {"SHA1", "sha1", 2}, + {"HAVAL256", "haval256,3", 3}, + {NULL, NULL, 4}, + {"RIPEMD160", "ripemd160", 5}, + {NULL, NULL, 6}, + {"TIGER", "tiger192,3", 7}, + {"GOST", "gost", 8}, + {"CRC32B", "crc32b", 9}, + {"HAVAL224", "haval224,3", 10}, + {"HAVAL192", "haval192,3", 11}, + {"HAVAL160", "haval160,3", 12}, + {"HAVAL128", "haval128,3", 13}, + {"TIGER128", "tiger128,3", 14}, + {"TIGER160", "tiger160,3", 15}, + {"MD4", "md4", 16}, + {"SHA256", "sha256", 17}, + {"ADLER32", "adler32", 18}, + {"SHA224", "sha224", 19}, + {"SHA512", "sha512", 20}, + {"SHA384", "sha384", 21}, + {"WHIRLPOOL", "whirlpool", 22}, + {"RIPEMD128", "ripemd128", 23}, + {"RIPEMD256", "ripemd256", 24}, + {"RIPEMD320", "ripemd320", 25}, + {NULL, NULL, 26}, /* support needs to be added for snefru 128 */ + {"SNEFRU256", "snefru256", 27}, + {"MD2", "md2", 28}, + {"FNV132", "fnv132", 29}, + {"FNV1A32", "fnv1a32", 30}, + {"FNV164", "fnv164", 31}, + {"FNV1A64", "fnv1a64", 32}, + {"JOAAT", "joaat", 33}, +}; +#endif + +/* Hash Registry Access */ + +PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, int algo_len) /* {{{ */ +{ + php_hash_ops *ops; + char *lower = estrndup(algo, algo_len); + + zend_str_tolower(lower, algo_len); + if (SUCCESS != zend_hash_find(&php_hash_hashtable, lower, algo_len + 1, (void*)&ops)) { + ops = NULL; + } + efree(lower); + + return ops; +} +/* }}} */ + +PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops) /* {{{ */ +{ + int algo_len = strlen(algo); + char *lower = estrndup(algo, algo_len); + + zend_str_tolower(lower, algo_len); + zend_hash_add(&php_hash_hashtable, lower, algo_len + 1, (void*)ops, sizeof(php_hash_ops), NULL); + efree(lower); +} +/* }}} */ + +PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context) /* {{{ */ +{ + php_hash_ops *hash_ops = (php_hash_ops *)ops; + + memcpy(dest_context, orig_context, hash_ops->context_size); + return SUCCESS; +} +/* }}} */ + +/* Userspace */ + +static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */ +{ + char *algo, *data, *digest; + int algo_len, data_len; + zend_bool raw_output = raw_output_default; + const php_hash_ops *ops; + void *context; + php_stream *stream = NULL; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &algo, &algo_len, &data, &data_len, &raw_output) == FAILURE) { + return; + } + + ops = php_hash_fetch_ops(algo, algo_len); + if (!ops) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo); + RETURN_FALSE; + } + if (isfilename) { + if (CHECK_NULL_PATH(data, data_len)) { + RETURN_FALSE; + } + stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, DEFAULT_CONTEXT); + if (!stream) { + /* Stream will report errors opening file */ + RETURN_FALSE; + } + } + + context = emalloc(ops->context_size); + ops->hash_init(context); + + if (isfilename) { + char buf[1024]; + int n; + + while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) { + ops->hash_update(context, (unsigned char *) buf, n); + } + php_stream_close(stream); + } else { + ops->hash_update(context, (unsigned char *) data, data_len); + } + + digest = emalloc(ops->digest_size + 1); + ops->hash_final((unsigned char *) digest, context); + efree(context); + + if (raw_output) { + digest[ops->digest_size] = 0; + RETURN_STRINGL(digest, ops->digest_size, 0); + } else { + char *hex_digest = safe_emalloc(ops->digest_size, 2, 1); + + php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size); + hex_digest[2 * ops->digest_size] = 0; + efree(digest); + RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0); + } +} +/* }}} */ + +/* {{{ proto string hash(string algo, string data[, bool raw_output = false]) +Generate a hash of a given input string +Returns lowercase hexits by default */ +PHP_FUNCTION(hash) +{ + php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0); +} +/* }}} */ + +/* {{{ proto string hash_file(string algo, string filename[, bool raw_output = false]) +Generate a hash of a given file +Returns lowercase hexits by default */ +PHP_FUNCTION(hash_file) +{ + php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0); +} +/* }}} */ + +static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */ +{ + char *algo, *data, *digest, *key, *K; + int algo_len, data_len, key_len, i; + zend_bool raw_output = raw_output_default; + const php_hash_ops *ops; + void *context; + php_stream *stream = NULL; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|b", &algo, &algo_len, &data, &data_len, + &key, &key_len, &raw_output) == FAILURE) { + return; + } + + ops = php_hash_fetch_ops(algo, algo_len); + if (!ops) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo); + RETURN_FALSE; + } + if (isfilename) { + stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, DEFAULT_CONTEXT); + if (!stream) { + /* Stream will report errors opening file */ + RETURN_FALSE; + } + } + + context = emalloc(ops->context_size); + ops->hash_init(context); + + K = emalloc(ops->block_size); + memset(K, 0, ops->block_size); + + if (key_len > ops->block_size) { + /* Reduce the key first */ + ops->hash_update(context, (unsigned char *) key, key_len); + ops->hash_final((unsigned char *) K, context); + /* Make the context ready to start over */ + ops->hash_init(context); + } else { + memcpy(K, key, key_len); + } + + /* XOR ipad */ + for(i=0; i < ops->block_size; i++) { + K[i] ^= 0x36; + } + ops->hash_update(context, (unsigned char *) K, ops->block_size); + + if (isfilename) { + char buf[1024]; + int n; + + while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) { + ops->hash_update(context, (unsigned char *) buf, n); + } + php_stream_close(stream); + } else { + ops->hash_update(context, (unsigned char *) data, data_len); + } + + digest = emalloc(ops->digest_size + 1); + ops->hash_final((unsigned char *) digest, context); + + /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */ + for(i=0; i < ops->block_size; i++) { + K[i] ^= 0x6A; + } + + /* Feed this result into the outter hash */ + ops->hash_init(context); + ops->hash_update(context, (unsigned char *) K, ops->block_size); + ops->hash_update(context, (unsigned char *) digest, ops->digest_size); + ops->hash_final((unsigned char *) digest, context); + + /* Zero the key */ + memset(K, 0, ops->block_size); + efree(K); + efree(context); + + if (raw_output) { + digest[ops->digest_size] = 0; + RETURN_STRINGL(digest, ops->digest_size, 0); + } else { + char *hex_digest = safe_emalloc(ops->digest_size, 2, 1); + + php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size); + hex_digest[2 * ops->digest_size] = 0; + efree(digest); + RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0); + } +} +/* }}} */ + +/* {{{ proto string hash_hmac(string algo, string data, string key[, bool raw_output = false]) +Generate a hash of a given input string with a key using HMAC +Returns lowercase hexits by default */ +PHP_FUNCTION(hash_hmac) +{ + php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0); +} +/* }}} */ + +/* {{{ proto string hash_hmac_file(string algo, string filename, string key[, bool raw_output = false]) +Generate a hash of a given file with a key using HMAC +Returns lowercase hexits by default */ +PHP_FUNCTION(hash_hmac_file) +{ + php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0); +} +/* }}} */ + + +/* {{{ proto resource hash_init(string algo[, int options, string key]) +Initialize a hashing context */ +PHP_FUNCTION(hash_init) +{ + char *algo, *key = NULL; + int algo_len, key_len = 0, argc = ZEND_NUM_ARGS(); + long options = 0; + void *context; + const php_hash_ops *ops; + php_hash_data *hash; + + if (zend_parse_parameters(argc TSRMLS_CC, "s|ls", &algo, &algo_len, &options, &key, &key_len) == FAILURE) { + return; + } + + ops = php_hash_fetch_ops(algo, algo_len); + if (!ops) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo); + RETURN_FALSE; + } + + if (options & PHP_HASH_HMAC && + key_len <= 0) { + /* Note: a zero length key is no key at all */ + php_error_docref(NULL TSRMLS_CC, E_WARNING, "HMAC requested without a key"); + RETURN_FALSE; + } + + context = emalloc(ops->context_size); + ops->hash_init(context); + + hash = emalloc(sizeof(php_hash_data)); + hash->ops = ops; + hash->context = context; + hash->options = options; + hash->key = NULL; + + if (options & PHP_HASH_HMAC) { + char *K = emalloc(ops->block_size); + int i; + + memset(K, 0, ops->block_size); + + if (key_len > ops->block_size) { + /* Reduce the key first */ + ops->hash_update(context, (unsigned char *) key, key_len); + ops->hash_final((unsigned char *) K, context); + /* Make the context ready to start over */ + ops->hash_init(context); + } else { + memcpy(K, key, key_len); + } + + /* XOR ipad */ + for(i=0; i < ops->block_size; i++) { + K[i] ^= 0x36; + } + ops->hash_update(context, (unsigned char *) K, ops->block_size); + hash->key = (unsigned char *) K; + } + + ZEND_REGISTER_RESOURCE(return_value, hash, php_hash_le_hash); +} +/* }}} */ + +/* {{{ proto bool hash_update(resource context, string data) +Pump data into the hashing algorithm */ +PHP_FUNCTION(hash_update) +{ + zval *zhash; + php_hash_data *hash; + char *data; + int data_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &zhash, &data, &data_len) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash); + + hash->ops->hash_update(hash->context, (unsigned char *) data, data_len); + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto int hash_update_stream(resource context, resource handle[, integer length]) +Pump data into the hashing algorithm from an open stream */ +PHP_FUNCTION(hash_update_stream) +{ + zval *zhash, *zstream; + php_hash_data *hash; + php_stream *stream = NULL; + long length = -1, didread = 0; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|l", &zhash, &zstream, &length) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash); + php_stream_from_zval(stream, &zstream); + + while (length) { + char buf[1024]; + long n, toread = 1024; + + if (length > 0 && toread > length) { + toread = length; + } + + if ((n = php_stream_read(stream, buf, toread)) <= 0) { + /* Nada mas */ + RETURN_LONG(didread); + } + hash->ops->hash_update(hash->context, (unsigned char *) buf, n); + length -= n; + didread += n; + } + + RETURN_LONG(didread); +} +/* }}} */ + +/* {{{ proto bool hash_update_file(resource context, string filename[, resource context]) +Pump data into the hashing algorithm from a file */ +PHP_FUNCTION(hash_update_file) +{ + zval *zhash, *zcontext = NULL; + php_hash_data *hash; + php_stream_context *context; + php_stream *stream; + char *filename, buf[1024]; + int filename_len, n; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|r", &zhash, &filename, &filename_len, &zcontext) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash); + context = php_stream_context_from_zval(zcontext, 0); + + stream = php_stream_open_wrapper_ex(filename, "rb", REPORT_ERRORS, NULL, context); + if (!stream) { + /* Stream will report errors opening file */ + RETURN_FALSE; + } + + while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) { + hash->ops->hash_update(hash->context, (unsigned char *) buf, n); + } + php_stream_close(stream); + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto string hash_final(resource context[, bool raw_output=false]) +Output resulting digest */ +PHP_FUNCTION(hash_final) +{ + zval *zhash; + php_hash_data *hash; + zend_bool raw_output = 0; + zend_rsrc_list_entry *le; + char *digest; + int digest_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|b", &zhash, &raw_output) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash); + + digest_len = hash->ops->digest_size; + digest = emalloc(digest_len + 1); + hash->ops->hash_final((unsigned char *) digest, hash->context); + if (hash->options & PHP_HASH_HMAC) { + int i; + + /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */ + for(i=0; i < hash->ops->block_size; i++) { + hash->key[i] ^= 0x6A; + } + + /* Feed this result into the outter hash */ + hash->ops->hash_init(hash->context); + hash->ops->hash_update(hash->context, (unsigned char *) hash->key, hash->ops->block_size); + hash->ops->hash_update(hash->context, (unsigned char *) digest, hash->ops->digest_size); + hash->ops->hash_final((unsigned char *) digest, hash->context); + + /* Zero the key */ + memset(hash->key, 0, hash->ops->block_size); + efree(hash->key); + hash->key = NULL; + } + digest[digest_len] = 0; + efree(hash->context); + hash->context = NULL; + + /* zend_list_REAL_delete() */ + if (zend_hash_index_find(&EG(regular_list), Z_RESVAL_P(zhash), (void *) &le)==SUCCESS) { + /* This is a hack to avoid letting the resource hide elsewhere (like in separated vars) + FETCH_RESOURCE is intelligent enough to handle dealing with any issues this causes */ + le->refcount = 1; + } /* FAILURE is not an option */ + zend_list_delete(Z_RESVAL_P(zhash)); + + if (raw_output) { + RETURN_STRINGL(digest, digest_len, 0); + } else { + char *hex_digest = safe_emalloc(digest_len,2,1); + + php_hash_bin2hex(hex_digest, (unsigned char *) digest, digest_len); + hex_digest[2 * digest_len] = 0; + efree(digest); + RETURN_STRINGL(hex_digest, 2 * digest_len, 0); + } +} +/* }}} */ + +/* {{{ proto resource hash_copy(resource context) +Copy hash resource */ +PHP_FUNCTION(hash_copy) +{ + zval *zhash; + php_hash_data *hash, *copy_hash; + void *context; + int res; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zhash) == FAILURE) { + return; + } + + ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash); + + + context = emalloc(hash->ops->context_size); + hash->ops->hash_init(context); + + res = hash->ops->hash_copy(hash->ops, hash->context, context); + if (res != SUCCESS) { + efree(context); + RETURN_FALSE; + } + + copy_hash = emalloc(sizeof(php_hash_data)); + copy_hash->ops = hash->ops; + copy_hash->context = context; + copy_hash->options = hash->options; + copy_hash->key = ecalloc(1, hash->ops->block_size); + if (hash->key) { + memcpy(copy_hash->key, hash->key, hash->ops->block_size); + } + ZEND_REGISTER_RESOURCE(return_value, copy_hash, php_hash_le_hash); +} +/* }}} */ + +/* {{{ proto array hash_algos(void) +Return a list of registered hashing algorithms */ +PHP_FUNCTION(hash_algos) +{ + HashPosition pos; + char *str; + uint str_len; + long type; + ulong idx; + + array_init(return_value); + for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos); + (type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, &str_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT; + zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) { + add_next_index_stringl(return_value, str, str_len-1, 1); + } +} +/* }}} */ + +/* Module Housekeeping */ + +static void php_hash_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */ +{ + php_hash_data *hash = (php_hash_data*)rsrc->ptr; + + /* Just in case the algo has internally allocated resources */ + if (hash->context) { + unsigned char *dummy = emalloc(hash->ops->digest_size); + hash->ops->hash_final(dummy, hash->context); + efree(dummy); + efree(hash->context); + } + + if (hash->key) { + memset(hash->key, 0, hash->ops->block_size); + efree(hash->key); + } + efree(hash); +} +/* }}} */ + +#define PHP_HASH_HAVAL_REGISTER(p,b) php_hash_register_algo("haval" #b "," #p , &php_hash_##p##haval##b##_ops); + +#ifdef PHP_MHASH_BC + +PHP_MINFO_FUNCTION(mhash) +{ + php_info_print_table_start(); + php_info_print_table_row(2, "MHASH support", "Enabled"); + php_info_print_table_row(2, "MHASH API Version", "Emulated Support"); + php_info_print_table_end(); +} + +zend_module_entry mhash_module_entry = { + STANDARD_MODULE_HEADER, + "mhash", + NULL, + NULL, + NULL, + NULL, + NULL, + PHP_MINFO(mhash), + NO_VERSION_YET, + STANDARD_MODULE_PROPERTIES, +}; + +static void mhash_init(INIT_FUNC_ARGS) +{ + char buf[128]; + int len; + int algo_number = 0; + + for (algo_number = 0; algo_number < MHASH_NUM_ALGOS; algo_number++) { + struct mhash_bc_entry algorithm = mhash_to_hash[algo_number]; + if (algorithm.mhash_name == NULL) { + continue; + } + + len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name, strlen(algorithm.mhash_name)); + zend_register_long_constant(buf, len + 1, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC); + } + zend_register_internal_module(&mhash_module_entry TSRMLS_CC); +} + +/* {{{ proto string mhash(int hash, string data [, string key]) + Hash data with hash */ +PHP_FUNCTION(mhash) +{ + zval **z_algorithm; + long algorithm; + + if (zend_parse_parameters(1 TSRMLS_CC, "Z", &z_algorithm) == FAILURE) { + return; + } + + SEPARATE_ZVAL(z_algorithm); + convert_to_long_ex(z_algorithm); + algorithm = Z_LVAL_PP(z_algorithm); + + /* need to convert the first parameter from int constant to string algorithm name */ + if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) { + struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm]; + if (algorithm_lookup.hash_name) { + ZVAL_STRING(*z_algorithm, algorithm_lookup.hash_name, 1); + } + } + + if (ZEND_NUM_ARGS() == 3) { + php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1); + } else if (ZEND_NUM_ARGS() == 2) { + php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1); + } else { + WRONG_PARAM_COUNT; + } +} +/* }}} */ + +/* {{{ proto string mhash_get_hash_name(int hash) + Gets the name of hash */ +PHP_FUNCTION(mhash_get_hash_name) +{ + long algorithm; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &algorithm) == FAILURE) { + return; + } + + if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) { + struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm]; + if (algorithm_lookup.mhash_name) { + RETURN_STRING(algorithm_lookup.mhash_name, 1); + } + } + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto int mhash_count(void) + Gets the number of available hashes */ +PHP_FUNCTION(mhash_count) +{ + if (zend_parse_parameters_none() == FAILURE) { + return; + } + RETURN_LONG(MHASH_NUM_ALGOS - 1); +} +/* }}} */ + +/* {{{ proto int mhash_get_block_size(int hash) + Gets the block size of hash */ +PHP_FUNCTION(mhash_get_block_size) +{ + long algorithm; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &algorithm) == FAILURE) { + return; + } + RETVAL_FALSE; + + if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) { + struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm]; + if (algorithm_lookup.mhash_name) { + const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name)); + if (ops) { + RETVAL_LONG(ops->digest_size); + } + } + } +} +/* }}} */ + +#define SALT_SIZE 8 + +/* {{{ proto string mhash_keygen_s2k(int hash, string input_password, string salt, int bytes) + Generates a key using hash functions */ +PHP_FUNCTION(mhash_keygen_s2k) +{ + long algorithm, l_bytes; + int bytes; + char *password, *salt; + int password_len, salt_len; + char padded_salt[SALT_SIZE]; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) { + return; + } + + bytes = (int)l_bytes; + if (bytes <= 0){ + php_error_docref(NULL TSRMLS_CC, E_WARNING, "the byte parameter must be greater than 0"); + RETURN_FALSE; + } + + salt_len = MIN(salt_len, SALT_SIZE); + + memcpy(padded_salt, salt, salt_len); + if (salt_len < SALT_SIZE) { + memset(padded_salt + salt_len, 0, SALT_SIZE - salt_len); + } + salt_len = SALT_SIZE; + + RETVAL_FALSE; + if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) { + struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm]; + if (algorithm_lookup.mhash_name) { + const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name)); + if (ops) { + unsigned char null = '\0'; + void *context; + char *key, *digest; + int i = 0, j = 0; + int block_size = ops->digest_size; + int times = bytes / block_size; + if (bytes % block_size != 0) times++; + + context = emalloc(ops->context_size); + ops->hash_init(context); + + key = ecalloc(1, times * block_size); + digest = emalloc(ops->digest_size + 1); + + for (i = 0; i < times; i++) { + ops->hash_init(context); + + for (j=0;j<i;j++) { + ops->hash_update(context, &null, 1); + } + ops->hash_update(context, (unsigned char *)padded_salt, salt_len); + ops->hash_update(context, (unsigned char *)password, password_len); + ops->hash_final((unsigned char *)digest, context); + memcpy( &key[i*block_size], digest, block_size); + } + + RETVAL_STRINGL(key, bytes, 1); + memset(key, 0, bytes); + efree(digest); + efree(context); + efree(key); + } + } + } +} +/* }}} */ + +#endif + +/* {{{ PHP_MINIT_FUNCTION + */ +PHP_MINIT_FUNCTION(hash) +{ + php_hash_le_hash = zend_register_list_destructors_ex(php_hash_dtor, NULL, PHP_HASH_RESNAME, module_number); + + zend_hash_init(&php_hash_hashtable, 35, NULL, NULL, 1); + + php_hash_register_algo("md2", &php_hash_md2_ops); + php_hash_register_algo("md4", &php_hash_md4_ops); + php_hash_register_algo("md5", &php_hash_md5_ops); + php_hash_register_algo("sha1", &php_hash_sha1_ops); + php_hash_register_algo("sha224", &php_hash_sha224_ops); + php_hash_register_algo("sha256", &php_hash_sha256_ops); + php_hash_register_algo("sha384", &php_hash_sha384_ops); + php_hash_register_algo("sha512", &php_hash_sha512_ops); + php_hash_register_algo("ripemd128", &php_hash_ripemd128_ops); + php_hash_register_algo("ripemd160", &php_hash_ripemd160_ops); + php_hash_register_algo("ripemd256", &php_hash_ripemd256_ops); + php_hash_register_algo("ripemd320", &php_hash_ripemd320_ops); + php_hash_register_algo("whirlpool", &php_hash_whirlpool_ops); + php_hash_register_algo("tiger128,3", &php_hash_3tiger128_ops); + php_hash_register_algo("tiger160,3", &php_hash_3tiger160_ops); + php_hash_register_algo("tiger192,3", &php_hash_3tiger192_ops); + php_hash_register_algo("tiger128,4", &php_hash_4tiger128_ops); + php_hash_register_algo("tiger160,4", &php_hash_4tiger160_ops); + php_hash_register_algo("tiger192,4", &php_hash_4tiger192_ops); + php_hash_register_algo("snefru", &php_hash_snefru_ops); + php_hash_register_algo("snefru256", &php_hash_snefru_ops); + php_hash_register_algo("gost", &php_hash_gost_ops); + php_hash_register_algo("adler32", &php_hash_adler32_ops); + php_hash_register_algo("crc32", &php_hash_crc32_ops); + php_hash_register_algo("crc32b", &php_hash_crc32b_ops); + php_hash_register_algo("fnv132", &php_hash_fnv132_ops); + php_hash_register_algo("fnv164", &php_hash_fnv164_ops); + php_hash_register_algo("joaat", &php_hash_joaat_ops); + + PHP_HASH_HAVAL_REGISTER(3,128); + PHP_HASH_HAVAL_REGISTER(3,160); + PHP_HASH_HAVAL_REGISTER(3,192); + PHP_HASH_HAVAL_REGISTER(3,224); + PHP_HASH_HAVAL_REGISTER(3,256); + + PHP_HASH_HAVAL_REGISTER(4,128); + PHP_HASH_HAVAL_REGISTER(4,160); + PHP_HASH_HAVAL_REGISTER(4,192); + PHP_HASH_HAVAL_REGISTER(4,224); + PHP_HASH_HAVAL_REGISTER(4,256); + + PHP_HASH_HAVAL_REGISTER(5,128); + PHP_HASH_HAVAL_REGISTER(5,160); + PHP_HASH_HAVAL_REGISTER(5,192); + PHP_HASH_HAVAL_REGISTER(5,224); + PHP_HASH_HAVAL_REGISTER(5,256); + + REGISTER_LONG_CONSTANT("HASH_HMAC", PHP_HASH_HMAC, CONST_CS | CONST_PERSISTENT); + +#ifdef PHP_MHASH_BC + mhash_init(INIT_FUNC_ARGS_PASSTHRU); +#endif + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MSHUTDOWN_FUNCTION + */ +PHP_MSHUTDOWN_FUNCTION(hash) +{ + zend_hash_destroy(&php_hash_hashtable); + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MINFO_FUNCTION + */ +PHP_MINFO_FUNCTION(hash) +{ + HashPosition pos; + char buffer[2048]; + char *s = buffer, *e = s + sizeof(buffer), *str; + ulong idx; + long type; + + for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos); + (type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, NULL, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT; + zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) { + s += slprintf(s, e - s, "%s ", str); + } + *s = 0; + + php_info_print_table_start(); + php_info_print_table_row(2, "hash support", "enabled"); + php_info_print_table_row(2, "Hashing Engines", buffer); + php_info_print_table_end(); +} +/* }}} */ + +/* {{{ arginfo */ +#ifdef PHP_HASH_MD5_NOT_IN_CORE +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5, 0, 0, 1) + ZEND_ARG_INFO(0, str) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5_file, 0, 0, 1) + ZEND_ARG_INFO(0, filename) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() +#endif + +#ifdef PHP_HASH_SHA1_NOT_IN_CORE +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1, 0, 0, 1) + ZEND_ARG_INFO(0, str) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1_file, 0, 0, 1) + ZEND_ARG_INFO(0, filename) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() +#endif + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash, 0, 0, 2) + ZEND_ARG_INFO(0, algo) + ZEND_ARG_INFO(0, data) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_file, 0, 0, 2) + ZEND_ARG_INFO(0, algo) + ZEND_ARG_INFO(0, filename) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac, 0, 0, 3) + ZEND_ARG_INFO(0, algo) + ZEND_ARG_INFO(0, data) + ZEND_ARG_INFO(0, key) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac_file, 0, 0, 3) + ZEND_ARG_INFO(0, algo) + ZEND_ARG_INFO(0, filename) + ZEND_ARG_INFO(0, key) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_init, 0, 0, 1) + ZEND_ARG_INFO(0, algo) + ZEND_ARG_INFO(0, options) + ZEND_ARG_INFO(0, key) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_hash_update, 0) + ZEND_ARG_INFO(0, context) + ZEND_ARG_INFO(0, data) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_stream, 0, 0, 2) + ZEND_ARG_INFO(0, context) + ZEND_ARG_INFO(0, handle) + ZEND_ARG_INFO(0, length) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_file, 0, 0, 2) + ZEND_ARG_INFO(0, context) + ZEND_ARG_INFO(0, filename) + ZEND_ARG_INFO(0, context) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_final, 0, 0, 1) + ZEND_ARG_INFO(0, context) + ZEND_ARG_INFO(0, raw_output) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_hash_copy, 0) + ZEND_ARG_INFO(0, context) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_hash_algos, 0) +ZEND_END_ARG_INFO() + +/* BC Land */ +#ifdef PHP_MHASH_BC +ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_block_size, 0) + ZEND_ARG_INFO(0, hash) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_hash_name, 0) + ZEND_ARG_INFO(0, hash) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_mhash_keygen_s2k, 0) + ZEND_ARG_INFO(0, hash) + ZEND_ARG_INFO(0, input_password) + ZEND_ARG_INFO(0, salt) + ZEND_ARG_INFO(0, bytes) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO(arginfo_mhash_count, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_INFO_EX(arginfo_mhash, 0, 0, 2) + ZEND_ARG_INFO(0, hash) + ZEND_ARG_INFO(0, data) + ZEND_ARG_INFO(0, key) +ZEND_END_ARG_INFO() +#endif + +/* }}} */ + +/* {{{ hash_functions[] + */ +const zend_function_entry hash_functions[] = { + PHP_FE(hash, arginfo_hash) + PHP_FE(hash_file, arginfo_hash_file) + + PHP_FE(hash_hmac, arginfo_hash_hmac) + PHP_FE(hash_hmac_file, arginfo_hash_hmac_file) + + PHP_FE(hash_init, arginfo_hash_init) + PHP_FE(hash_update, arginfo_hash_update) + PHP_FE(hash_update_stream, arginfo_hash_update_stream) + PHP_FE(hash_update_file, arginfo_hash_update_file) + PHP_FE(hash_final, arginfo_hash_final) + PHP_FE(hash_copy, arginfo_hash_copy) + + PHP_FE(hash_algos, arginfo_hash_algos) + + /* BC Land */ +#ifdef PHP_HASH_MD5_NOT_IN_CORE + PHP_NAMED_FE(md5, php_if_md5, arginfo_hash_md5) + PHP_NAMED_FE(md5_file, php_if_md5_file, arginfo_hash_md5_file) +#endif /* PHP_HASH_MD5_NOT_IN_CORE */ + +#ifdef PHP_HASH_SHA1_NOT_IN_CORE + PHP_NAMED_FE(sha1, php_if_sha1, arginfo_hash_sha1) + PHP_NAMED_FE(sha1_file, php_if_sha1_file, arginfo_hash_sha1_file) +#endif /* PHP_HASH_SHA1_NOT_IN_CORE */ + +#ifdef PHP_MHASH_BC + PHP_FE(mhash_keygen_s2k, arginfo_mhash_keygen_s2k) + PHP_FE(mhash_get_block_size, arginfo_mhash_get_block_size) + PHP_FE(mhash_get_hash_name, arginfo_mhash_get_hash_name) + PHP_FE(mhash_count, arginfo_mhash_count) + PHP_FE(mhash, arginfo_mhash) +#endif + + PHP_FE_END +}; +/* }}} */ + +/* {{{ hash_module_entry + */ +zend_module_entry hash_module_entry = { +#if ZEND_MODULE_API_NO >= 20010901 + STANDARD_MODULE_HEADER, +#endif + PHP_HASH_EXTNAME, + hash_functions, + PHP_MINIT(hash), + PHP_MSHUTDOWN(hash), + NULL, /* RINIT */ + NULL, /* RSHUTDOWN */ + PHP_MINFO(hash), +#if ZEND_MODULE_API_NO >= 20010901 + PHP_HASH_EXTVER, /* Replace with version number for your extension */ +#endif + STANDARD_MODULE_PROPERTIES +}; +/* }}} */ + +#ifdef COMPILE_DL_HASH +ZEND_GET_MODULE(hash) +#endif + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: noet sw=4 ts=4 fdm=marker + * vim<600: noet sw=4 ts=4 + */ |