diff options
37 files changed, 220 insertions, 110 deletions
diff --git a/ext/hash/hash.c b/ext/hash/hash.c index f7b851f5a4..a337ef0489 100644 --- a/ext/hash/hash.c +++ b/ext/hash/hash.c @@ -349,7 +349,7 @@ PHP_HASH_API int php_hash_unserialize(php_hashcontext_object *hash, zend_long ma /* Userspace */ static void php_hash_do_hash( - zval *return_value, zend_string *algo, char *data, size_t data_len, zend_bool raw_output, bool isfilename + zval *return_value, zend_string *algo, char *data, size_t data_len, zend_bool raw_output, bool isfilename, HashTable *args ) /* {{{ */ { zend_string *digest; const php_hash_ops *ops; @@ -374,7 +374,7 @@ static void php_hash_do_hash( } context = php_hash_alloc_context(ops); - ops->hash_init(context); + ops->hash_init(context, args); if (isfilename) { char buf[1024]; @@ -418,15 +418,17 @@ PHP_FUNCTION(hash) char *data; size_t data_len; zend_bool raw_output = 0; + HashTable *args = NULL; - ZEND_PARSE_PARAMETERS_START(2, 3) + ZEND_PARSE_PARAMETERS_START(2, 4) Z_PARAM_STR(algo) Z_PARAM_STRING(data, data_len) Z_PARAM_OPTIONAL Z_PARAM_BOOL(raw_output) + Z_PARAM_ARRAY_HT(args) ZEND_PARSE_PARAMETERS_END(); - php_hash_do_hash(return_value, algo, data, data_len, raw_output, 0); + php_hash_do_hash(return_value, algo, data, data_len, raw_output, 0, args); } /* }}} */ @@ -438,15 +440,17 @@ PHP_FUNCTION(hash_file) char *data; size_t data_len; zend_bool raw_output = 0; + HashTable *args = NULL; ZEND_PARSE_PARAMETERS_START(2, 3) Z_PARAM_STR(algo) Z_PARAM_STRING(data, data_len) Z_PARAM_OPTIONAL Z_PARAM_BOOL(raw_output) + Z_PARAM_ARRAY_HT(args) ZEND_PARSE_PARAMETERS_END(); - php_hash_do_hash(return_value, algo, data, data_len, raw_output, 1); + php_hash_do_hash(return_value, algo, data, data_len, raw_output, 1, args); } /* }}} */ @@ -468,7 +472,7 @@ static inline void php_hash_hmac_prep_key(unsigned char *K, const php_hash_ops * memset(K, 0, ops->block_size); if (key_len > ops->block_size) { /* Reduce the key first */ - ops->hash_init(context); + ops->hash_init(context, NULL); ops->hash_update(context, key, key_len); ops->hash_final(K, context); } else { @@ -479,7 +483,7 @@ static inline void php_hash_hmac_prep_key(unsigned char *K, const php_hash_ops * } static inline void php_hash_hmac_round(unsigned char *final, const php_hash_ops *ops, void *context, const unsigned char *key, const unsigned char *data, const zend_long data_size) { - ops->hash_init(context); + ops->hash_init(context, NULL); ops->hash_update(context, key, ops->block_size); ops->hash_update(context, data, data_size); ops->hash_final(final, context); @@ -522,7 +526,7 @@ static void php_hash_do_hash_hmac( if (isfilename) { char buf[1024]; ssize_t n; - ops->hash_init(context); + ops->hash_init(context, NULL); ops->hash_update(context, K, ops->block_size); while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) { ops->hash_update(context, (unsigned char *) buf, n); @@ -605,8 +609,9 @@ PHP_FUNCTION(hash_init) void *context; const php_hash_ops *ops; php_hashcontext_object *hash; + HashTable *args = NULL; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|lS", &algo, &options, &key) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|lSh", &algo, &options, &key, &args) == FAILURE) { RETURN_THROWS(); } @@ -632,7 +637,7 @@ PHP_FUNCTION(hash_init) hash = php_hashcontext_from_object(Z_OBJ_P(return_value)); context = php_hash_alloc_context(ops); - ops->hash_init(context); + ops->hash_init(context, args); hash->ops = ops; hash->context = context; @@ -650,7 +655,7 @@ PHP_FUNCTION(hash_init) ops->hash_update(context, (unsigned char *) ZSTR_VAL(key), ZSTR_LEN(key)); ops->hash_final((unsigned char *) K, context); /* Make the context ready to start over */ - ops->hash_init(context); + ops->hash_init(context, args); } else { memcpy(K, ZSTR_VAL(key), ZSTR_LEN(key)); } @@ -792,7 +797,7 @@ PHP_FUNCTION(hash_final) } /* Feed this result into the outer hash */ - hash->ops->hash_init(hash->context); + hash->ops->hash_init(hash->context, NULL); hash->ops->hash_update(hash->context, hash->key, hash->ops->block_size); hash->ops->hash_update(hash->context, (unsigned char *) ZSTR_VAL(digest), hash->ops->digest_size); hash->ops->hash_final((unsigned char *) ZSTR_VAL(digest), hash->context); @@ -915,7 +920,7 @@ PHP_FUNCTION(hash_hkdf) context = php_hash_alloc_context(ops); // Extract - ops->hash_init(context); + ops->hash_init(context, NULL); K = emalloc(ops->block_size); php_hash_hmac_prep_key(K, ops, context, (unsigned char *) (salt ? ZSTR_VAL(salt) : ""), salt ? ZSTR_LEN(salt) : 0); @@ -935,7 +940,7 @@ PHP_FUNCTION(hash_hkdf) c[0] = (i & 0xFF); php_hash_hmac_prep_key(K, ops, context, prk, ops->digest_size); - ops->hash_init(context); + ops->hash_init(context, NULL); ops->hash_update(context, K, ops->block_size); if (i > 1) { @@ -980,8 +985,9 @@ PHP_FUNCTION(hash_pbkdf2) zend_bool raw_output = 0; const php_hash_ops *ops; void *context; + HashTable *args; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sssl|lb", &algo, &pass, &pass_len, &salt, &salt_len, &iterations, &length, &raw_output) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sssl|lbh", &algo, &pass, &pass_len, &salt, &salt_len, &iterations, &length, &raw_output, &args) == FAILURE) { RETURN_THROWS(); } @@ -1007,7 +1013,7 @@ PHP_FUNCTION(hash_pbkdf2) } context = php_hash_alloc_context(ops); - ops->hash_init(context); + ops->hash_init(context, args); K1 = emalloc(ops->block_size); K2 = emalloc(ops->block_size); @@ -1212,7 +1218,7 @@ PHP_FUNCTION(mhash) if (key) { php_hash_do_hash_hmac(return_value, algo, data, data_len, key, key_len, 1, 0); } else { - php_hash_do_hash(return_value, algo, data, data_len, 1, 0); + php_hash_do_hash(return_value, algo, data, data_len, 1, 0, NULL); } if (algo) { @@ -1319,13 +1325,13 @@ PHP_FUNCTION(mhash_keygen_s2k) } context = php_hash_alloc_context(ops); - ops->hash_init(context); + ops->hash_init(context, NULL); key = ecalloc(1, times * block_size); digest = emalloc(ops->digest_size + 1); for (i = 0; i < times; i++) { - ops->hash_init(context); + ops->hash_init(context, NULL); for (j=0;j<i;j++) { ops->hash_update(context, &null, 1); @@ -1392,7 +1398,7 @@ static zend_object *php_hashcontext_clone(zend_object *zobj) { newobj->ops = oldobj->ops; newobj->options = oldobj->options; newobj->context = php_hash_alloc_context(newobj->ops); - newobj->ops->hash_init(newobj->context); + newobj->ops->hash_init(newobj->context, NULL); if (SUCCESS != newobj->ops->hash_copy(newobj->ops, oldobj->context, newobj->context)) { efree(newobj->context); @@ -1529,8 +1535,8 @@ PHP_METHOD(HashContext, __unserialize) hash->ops = ops; hash->context = php_hash_alloc_context(ops); - ops->hash_init(hash->context); hash->options = options; + ops->hash_init(hash->context, NULL); unserialize_result = ops->hash_unserialize(hash, magic, hash_zv); if (unserialize_result != SUCCESS) { diff --git a/ext/hash/hash.stub.php b/ext/hash/hash.stub.php index c0d4cbca7c..7eb3925c35 100644 --- a/ext/hash/hash.stub.php +++ b/ext/hash/hash.stub.php @@ -2,15 +2,15 @@ /** @generate-function-entries */ -function hash(string $algo, string $data, bool $binary = false): string|false {} +function hash(string $algo, string $data, bool $binary = false, array $options = []): string|false {} -function hash_file(string $algo, string $filename, bool $binary = false): string|false {} +function hash_file(string $algo, string $filename, bool $binary = false, array $options = []): string|false {} function hash_hmac(string $algo, string $data, string $key, bool $binary = false): string|false {} function hash_hmac_file(string $algo, string $data, string $key, bool $binary = false): string|false {} -function hash_init(string $algo, int $flags = 0, string $key = ""): HashContext {} +function hash_init(string $algo, int $flags = 0, string $key = "", array $options = []): HashContext {} function hash_update(HashContext $context, string $data): bool {} diff --git a/ext/hash/hash_adler32.c b/ext/hash/hash_adler32.c index d45012f8e6..5acd621b2d 100644 --- a/ext/hash/hash_adler32.c +++ b/ext/hash/hash_adler32.c @@ -18,7 +18,7 @@ #include "php_hash.h" #include "php_hash_adler32.h" -PHP_HASH_API void PHP_ADLER32Init(PHP_ADLER32_CTX *context) +PHP_HASH_API void PHP_ADLER32Init(PHP_ADLER32_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->state = 1; } diff --git a/ext/hash/hash_arginfo.h b/ext/hash/hash_arginfo.h index db043da97b..1d654b546e 100644 --- a/ext/hash/hash_arginfo.h +++ b/ext/hash/hash_arginfo.h @@ -1,16 +1,18 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 9352e0ac98e2ac53dc15d5024f9ef0c8092c4e9c */ + * Stub hash: e8466049fca2eae179adbc19bb67e71f6486ec4e */ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_hash, 0, 2, MAY_BE_STRING|MAY_BE_FALSE) ZEND_ARG_TYPE_INFO(0, algo, IS_STRING, 0) ZEND_ARG_TYPE_INFO(0, data, IS_STRING, 0) ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, binary, _IS_BOOL, 0, "false") + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 0, "[]") ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_hash_file, 0, 2, MAY_BE_STRING|MAY_BE_FALSE) ZEND_ARG_TYPE_INFO(0, algo, IS_STRING, 0) ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0) ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, binary, _IS_BOOL, 0, "false") + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 0, "[]") ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_hash_hmac, 0, 3, MAY_BE_STRING|MAY_BE_FALSE) @@ -26,6 +28,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_hash_init, 0, 1, HashContext, 0) ZEND_ARG_TYPE_INFO(0, algo, IS_STRING, 0) ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0") ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, key, IS_STRING, 0, "\"\"") + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 0, "[]") ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_hash_update, 0, 2, _IS_BOOL, 0) diff --git a/ext/hash/hash_crc32.c b/ext/hash/hash_crc32.c index ade32a3b35..d77cdde013 100644 --- a/ext/hash/hash_crc32.c +++ b/ext/hash/hash_crc32.c @@ -20,7 +20,7 @@ #include "php_hash_crc32_tables.h" #include "ext/standard/crc32_x86.h" -PHP_HASH_API void PHP_CRC32Init(PHP_CRC32_CTX *context) +PHP_HASH_API void PHP_CRC32Init(PHP_CRC32_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->state = ~0; } diff --git a/ext/hash/hash_fnv.c b/ext/hash/hash_fnv.c index 2ee81b9c86..3a48d40484 100644 --- a/ext/hash/hash_fnv.c +++ b/ext/hash/hash_fnv.c @@ -83,7 +83,7 @@ const php_hash_ops php_hash_fnv1a64_ops = { /* {{{ PHP_FNV132Init * 32-bit FNV-1 hash initialisation */ -PHP_HASH_API void PHP_FNV132Init(PHP_FNV132_CTX *context) +PHP_HASH_API void PHP_FNV132Init(PHP_FNV132_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->state = PHP_FNV1_32_INIT; } @@ -118,7 +118,7 @@ PHP_HASH_API void PHP_FNV132Final(unsigned char digest[4], PHP_FNV132_CTX * cont /* {{{ PHP_FNV164Init * 64-bit FNV-1 hash initialisation */ -PHP_HASH_API void PHP_FNV164Init(PHP_FNV164_CTX *context) +PHP_HASH_API void PHP_FNV164Init(PHP_FNV164_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->state = PHP_FNV1_64_INIT; } diff --git a/ext/hash/hash_gost.c b/ext/hash/hash_gost.c index 46ea032c32..d1f4a31765 100644 --- a/ext/hash/hash_gost.c +++ b/ext/hash/hash_gost.c @@ -235,15 +235,15 @@ static inline void GostTransform(PHP_GOST_CTX *context, const unsigned char inpu Gost(context, data); } -PHP_HASH_API void PHP_GOSTInit(PHP_GOST_CTX *context) +PHP_HASH_API void PHP_GOSTInit(PHP_GOST_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { memset(context, 0, sizeof(*context)); context->tables = &tables_test; } -PHP_HASH_API void PHP_GOSTInitCrypto(PHP_GOST_CTX *context) +PHP_HASH_API void PHP_GOSTInitCrypto(PHP_GOST_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { - PHP_GOSTInit(context); + PHP_GOSTInit(context, NULL); context->tables = &tables_crypto; } diff --git a/ext/hash/hash_haval.c b/ext/hash/hash_haval.c index 84ff242bd9..9b117db8d9 100644 --- a/ext/hash/hash_haval.c +++ b/ext/hash/hash_haval.c @@ -253,7 +253,7 @@ const php_hash_ops php_hash_##p##haval##b##_ops = { \ php_hash_unserialize, \ PHP_HAVAL_SPEC, \ ((b) / 8), 128, sizeof(PHP_HAVAL_CTX), 1 }; \ -PHP_HASH_API void PHP_##p##HAVAL##b##Init(PHP_HAVAL_CTX *context) \ +PHP_HASH_API void PHP_##p##HAVAL##b##Init(PHP_HAVAL_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) \ { int i; context->count[0] = context->count[1] = 0; \ for(i = 0; i < 8; i++) context->state[i] = D0[i]; \ context->passes = p; context->output = b; \ diff --git a/ext/hash/hash_joaat.c b/ext/hash/hash_joaat.c index 5d5a2e53b9..41fde52f30 100644 --- a/ext/hash/hash_joaat.c +++ b/ext/hash/hash_joaat.c @@ -36,7 +36,7 @@ const php_hash_ops php_hash_joaat_ops = { 0 }; -PHP_HASH_API void PHP_JOAATInit(PHP_JOAAT_CTX *context) +PHP_HASH_API void PHP_JOAATInit(PHP_JOAAT_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->state = 0; } diff --git a/ext/hash/hash_md.c b/ext/hash/hash_md.c index 94fafbbf79..a34936d625 100644 --- a/ext/hash/hash_md.c +++ b/ext/hash/hash_md.c @@ -19,7 +19,7 @@ const php_hash_ops php_hash_md5_ops = { "md5", - (php_hash_init_func_t) PHP_MD5Init, + (php_hash_init_func_t) PHP_MD5InitArgs, (php_hash_update_func_t) PHP_MD5Update, (php_hash_final_func_t) PHP_MD5Final, php_hash_copy, @@ -34,7 +34,7 @@ const php_hash_ops php_hash_md5_ops = { const php_hash_ops php_hash_md4_ops = { "md4", - (php_hash_init_func_t) PHP_MD4Init, + (php_hash_init_func_t) PHP_MD4InitArgs, (php_hash_update_func_t) PHP_MD4Update, (php_hash_final_func_t) PHP_MD4Final, php_hash_copy, @@ -51,7 +51,7 @@ static int php_md2_unserialize(php_hashcontext_object *hash, zend_long magic, co const php_hash_ops php_hash_md2_ops = { "md2", - (php_hash_init_func_t) PHP_MD2Init, + (php_hash_init_func_t) PHP_MD2InitArgs, (php_hash_update_func_t) PHP_MD2Update, (php_hash_final_func_t) PHP_MD2Final, php_hash_copy, @@ -182,10 +182,10 @@ static void MD4Transform(uint32_t state[4], const unsigned char block[64]) state[3] += d; } -/* {{{ PHP_MD4Init +/* {{{ PHP_MD4InitArgs * MD4 initialization. Begins an MD4 operation, writing a new context. */ -PHP_HASH_API void PHP_MD4Init(PHP_MD4_CTX * context) +PHP_HASH_API void PHP_MD4InitArgs(PHP_MD4_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -287,7 +287,7 @@ static const unsigned char MD2_S[256] = { 242, 239, 183, 14, 102, 88, 208, 228, 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237, 31, 26, 219, 153, 141, 51, 159, 17, 131, 20 }; -PHP_HASH_API void PHP_MD2Init(PHP_MD2_CTX *context) +PHP_HASH_API void PHP_MD2InitArgs(PHP_MD2_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { memset(context, 0, sizeof(PHP_MD2_CTX)); } diff --git a/ext/hash/hash_murmur.c b/ext/hash/hash_murmur.c index ab01b4f19f..466231054c 100644 --- a/ext/hash/hash_murmur.c +++ b/ext/hash/hash_murmur.c @@ -36,9 +36,20 @@ const php_hash_ops php_hash_murmur3a_ops = { 0 }; -PHP_HASH_API void PHP_MURMUR3AInit(PHP_MURMUR3A_CTX *ctx) +PHP_HASH_API void PHP_MURMUR3AInit(PHP_MURMUR3A_CTX *ctx, HashTable *args) { - ctx->h = 0; + if (args) { + zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1); + /* This might be a bit too restrictive, but thinking that a seed might be set + once and for all, it should be done a clean way. */ + if (seed && IS_LONG == Z_TYPE_P(seed)) { + ctx->h = (uint32_t)Z_LVAL_P(seed); + } else { + ctx->h = 0; + } + } else { + ctx->h = 0; + } ctx->carry = 0; ctx->len = 0; } @@ -82,9 +93,24 @@ const php_hash_ops php_hash_murmur3c_ops = { 0 }; -PHP_HASH_API void PHP_MURMUR3CInit(PHP_MURMUR3C_CTX *ctx) +PHP_HASH_API void PHP_MURMUR3CInit(PHP_MURMUR3C_CTX *ctx, HashTable *args) { - memset(&ctx->h, 0, sizeof ctx->h); + if (args) { + zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1); + /* This might be a bit too restrictive, but thinking that a seed might be set + once and for all, it should be done a clean way. */ + if (seed && IS_LONG == Z_TYPE_P(seed)) { + uint32_t _seed = (uint32_t)Z_LVAL_P(seed); + ctx->h[0] = _seed; + ctx->h[1] = _seed; + ctx->h[2] = _seed; + ctx->h[3] = _seed; + } else { + memset(&ctx->h, 0, sizeof ctx->h); + } + } else { + memset(&ctx->h, 0, sizeof ctx->h); + } memset(&ctx->carry, 0, sizeof ctx->carry); ctx->len = 0; } @@ -141,9 +167,22 @@ const php_hash_ops php_hash_murmur3f_ops = { 0 }; -PHP_HASH_API void PHP_MURMUR3FInit(PHP_MURMUR3F_CTX *ctx) +PHP_HASH_API void PHP_MURMUR3FInit(PHP_MURMUR3F_CTX *ctx, HashTable *args) { - memset(&ctx->h, 0, sizeof ctx->h); + if (args) { + zval *seed = zend_hash_str_find_deref(args, "seed", sizeof("seed") - 1); + /* This might be a bit too restrictive, but thinking that a seed might be set + once and for all, it should be done a clean way. */ + if (seed && IS_LONG == Z_TYPE_P(seed)) { + uint64_t _seed = (uint64_t)Z_LVAL_P(seed); + ctx->h[0] = _seed; + ctx->h[1] = _seed; + } else { + memset(&ctx->h, 0, sizeof ctx->h); + } + } else { + memset(&ctx->h, 0, sizeof ctx->h); + } memset(&ctx->carry, 0, sizeof ctx->carry); ctx->len = 0; } diff --git a/ext/hash/hash_ripemd.c b/ext/hash/hash_ripemd.c index db1d1dc02b..58c40b06a7 100644 --- a/ext/hash/hash_ripemd.c +++ b/ext/hash/hash_ripemd.c @@ -84,7 +84,7 @@ const php_hash_ops php_hash_ripemd320_ops = { /* {{{ PHP_RIPEMD128Init * ripemd128 initialization. Begins a ripemd128 operation, writing a new context. */ -PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX * context) +PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -99,7 +99,7 @@ PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX * context) /* {{{ PHP_RIPEMD256Init * ripemd256 initialization. Begins a ripemd256 operation, writing a new context. */ -PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX * context) +PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -118,7 +118,7 @@ PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX * context) /* {{{ PHP_RIPEMD160Init * ripemd160 initialization. Begins a ripemd160 operation, writing a new context. */ -PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX * context) +PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -134,7 +134,7 @@ PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX * context) /* {{{ PHP_RIPEMD320Init * ripemd320 initialization. Begins a ripemd320 operation, writing a new context. */ -PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX * context) +PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. diff --git a/ext/hash/hash_sha.c b/ext/hash/hash_sha.c index 4ea5b768d7..acc23a21bf 100644 --- a/ext/hash/hash_sha.c +++ b/ext/hash/hash_sha.c @@ -64,7 +64,7 @@ static void SHADecode32(uint32_t *output, const unsigned char *input, unsigned i const php_hash_ops php_hash_sha1_ops = { "sha1", - (php_hash_init_func_t) PHP_SHA1Init, + (php_hash_init_func_t) PHP_SHA1InitArgs, (php_hash_update_func_t) PHP_SHA1Update, (php_hash_final_func_t) PHP_SHA1Final, php_hash_copy, @@ -81,7 +81,7 @@ const php_hash_ops php_hash_sha1_ops = { const php_hash_ops php_hash_sha256_ops = { "sha256", - (php_hash_init_func_t) PHP_SHA256Init, + (php_hash_init_func_t) PHP_SHA256InitArgs, (php_hash_update_func_t) PHP_SHA256Update, (php_hash_final_func_t) PHP_SHA256Final, php_hash_copy, @@ -96,7 +96,7 @@ const php_hash_ops php_hash_sha256_ops = { const php_hash_ops php_hash_sha224_ops = { "sha224", - (php_hash_init_func_t) PHP_SHA224Init, + (php_hash_init_func_t) PHP_SHA224InitArgs, (php_hash_update_func_t) PHP_SHA224Update, (php_hash_final_func_t) PHP_SHA224Final, php_hash_copy, @@ -136,10 +136,10 @@ static const uint32_t SHA256_K[64] = { 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 }; -/* {{{ PHP_SHA256Init +/* {{{ PHP_SHA256InitArgs * SHA256 initialization. Begins an SHA256 operation, writing a new context. */ -PHP_HASH_API void PHP_SHA256Init(PHP_SHA256_CTX * context) +PHP_HASH_API void PHP_SHA256InitArgs(PHP_SHA256_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -196,10 +196,10 @@ static void SHA256Transform(uint32_t state[8], const unsigned char block[64]) } /* }}} */ -/* {{{ PHP_SHA224Init +/* {{{ PHP_SHA224InitArgs * SHA224 initialization. Begins an SHA224 operation, writing a new context. */ -PHP_HASH_API void PHP_SHA224Init(PHP_SHA224_CTX * context) +PHP_HASH_API void PHP_SHA224InitArgs(PHP_SHA224_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -445,10 +445,10 @@ static void SHADecode64(uint64_t *output, const unsigned char *input, unsigned i } /* }}} */ -/* {{{ PHP_SHA384Init +/* {{{ PHP_SHA384InitArgs * SHA384 initialization. Begins an SHA384 operation, writing a new context. */ -PHP_HASH_API void PHP_SHA384Init(PHP_SHA384_CTX * context) +PHP_HASH_API void PHP_SHA384InitArgs(PHP_SHA384_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -591,7 +591,7 @@ PHP_HASH_API void PHP_SHA384Final(unsigned char digest[48], PHP_SHA384_CTX * con const php_hash_ops php_hash_sha384_ops = { "sha384", - (php_hash_init_func_t) PHP_SHA384Init, + (php_hash_init_func_t) PHP_SHA384InitArgs, (php_hash_update_func_t) PHP_SHA384Update, (php_hash_final_func_t) PHP_SHA384Final, php_hash_copy, @@ -604,10 +604,10 @@ const php_hash_ops php_hash_sha384_ops = { 1 }; -/* {{{ PHP_SHA512Init +/* {{{ PHP_SHA512InitArgs * SHA512 initialization. Begins an SHA512 operation, writing a new context. */ -PHP_HASH_API void PHP_SHA512Init(PHP_SHA512_CTX * context) +PHP_HASH_API void PHP_SHA512InitArgs(PHP_SHA512_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. @@ -623,10 +623,10 @@ PHP_HASH_API void PHP_SHA512Init(PHP_SHA512_CTX * context) } /* }}} */ -/* {{{ PHP_SHA512_256Init +/* {{{ PHP_SHA512_256InitArgs * SHA512/245 initialization. Identical algorithm to SHA512, using alternate initval and truncation */ -PHP_HASH_API void PHP_SHA512_256Init(PHP_SHA512_CTX * context) +PHP_HASH_API void PHP_SHA512_256InitArgs(PHP_SHA512_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; @@ -641,10 +641,10 @@ PHP_HASH_API void PHP_SHA512_256Init(PHP_SHA512_CTX * context) } /* }}} */ -/* {{{ PHP_SHA512_224Init +/* {{{ PHP_SHA512_224InitArgs * SHA512/224 initialization. Identical algorithm to SHA512, using alternate initval and truncation */ -PHP_HASH_API void PHP_SHA512_224Init(PHP_SHA512_CTX * context) +PHP_HASH_API void PHP_SHA512_224InitArgs(PHP_SHA512_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; @@ -768,7 +768,7 @@ PHP_HASH_API void PHP_SHA512_224Final(unsigned char digest[28], PHP_SHA512_CTX * const php_hash_ops php_hash_sha512_ops = { "sha512", - (php_hash_init_func_t) PHP_SHA512Init, + (php_hash_init_func_t) PHP_SHA512InitArgs, (php_hash_update_func_t) PHP_SHA512Update, (php_hash_final_func_t) PHP_SHA512Final, php_hash_copy, @@ -783,7 +783,7 @@ const php_hash_ops php_hash_sha512_ops = { const php_hash_ops php_hash_sha512_256_ops = { "sha512/256", - (php_hash_init_func_t) PHP_SHA512_256Init, + (php_hash_init_func_t) PHP_SHA512_256InitArgs, (php_hash_update_func_t) PHP_SHA512_256Update, (php_hash_final_func_t) PHP_SHA512_256Final, php_hash_copy, @@ -798,7 +798,7 @@ const php_hash_ops php_hash_sha512_256_ops = { const php_hash_ops php_hash_sha512_224_ops = { "sha512/224", - (php_hash_init_func_t) PHP_SHA512_224Init, + (php_hash_init_func_t) PHP_SHA512_224InitArgs, (php_hash_update_func_t) PHP_SHA512_224Update, (php_hash_final_func_t) PHP_SHA512_224Final, php_hash_copy, diff --git a/ext/hash/hash_sha3.c b/ext/hash/hash_sha3.c index 52bd495f9d..123e599d04 100644 --- a/ext/hash/hash_sha3.c +++ b/ext/hash/hash_sha3.c @@ -220,7 +220,7 @@ static int php_sha3_unserialize(php_hashcontext_object *hash, // ========================================================================== #define DECLARE_SHA3_OPS(bits) \ -void PHP_SHA3##bits##Init(PHP_SHA3_##bits##_CTX* ctx) { \ +void PHP_SHA3##bits##Init(PHP_SHA3_##bits##_CTX* ctx, ZEND_ATTRIBUTE_UNUSED HashTable *args) { \ PHP_SHA3_Init(ctx, bits); \ } \ void PHP_SHA3##bits##Update(PHP_SHA3_##bits##_CTX* ctx, \ @@ -315,7 +315,7 @@ static int php_keccak_unserialize(php_hashcontext_object *hash, zend_long magic, // ========================================================================== #define DECLARE_SHA3_OPS(bits) \ -void PHP_SHA3##bits##Init(PHP_SHA3_##bits##_CTX* ctx) { \ +void PHP_SHA3##bits##Init(PHP_SHA3_##bits##_CTX* ctx, ZEND_ATTRIBUTE_UNUSED HashTable *args) { \ ZEND_ASSERT(sizeof(Keccak_HashInstance) <= sizeof(PHP_SHA3_##bits##_CTX)); \ Keccak_HashInitialize_SHA3_##bits((Keccak_HashInstance *)ctx); \ } \ diff --git a/ext/hash/hash_snefru.c b/ext/hash/hash_snefru.c index 292bfef2cb..66f9300b11 100644 --- a/ext/hash/hash_snefru.c +++ b/ext/hash/hash_snefru.c @@ -128,7 +128,7 @@ static inline void SnefruTransform(PHP_SNEFRU_CTX *context, const unsigned char ZEND_SECURE_ZERO(&context->state[8], sizeof(uint32_t) * 8); } -PHP_HASH_API void PHP_SNEFRUInit(PHP_SNEFRU_CTX *context) +PHP_HASH_API void PHP_SNEFRUInit(PHP_SNEFRU_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { memset(context, 0, sizeof(*context)); } diff --git a/ext/hash/hash_tiger.c b/ext/hash/hash_tiger.c index 8e0f365dc4..b360dd6ade 100644 --- a/ext/hash/hash_tiger.c +++ b/ext/hash/hash_tiger.c @@ -174,7 +174,7 @@ static inline void TigerDigest(unsigned char *digest_str, unsigned int digest_le } } -PHP_HASH_API void PHP_3TIGERInit(PHP_TIGER_CTX *context) +PHP_HASH_API void PHP_3TIGERInit(PHP_TIGER_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { memset(context, 0, sizeof(*context)); context->state[0] = L64(0x0123456789ABCDEF); @@ -182,7 +182,7 @@ PHP_HASH_API void PHP_3TIGERInit(PHP_TIGER_CTX *context) context->state[2] = L64(0xF096A5B4C3B2E187); } -PHP_HASH_API void PHP_4TIGERInit(PHP_TIGER_CTX *context) +PHP_HASH_API void PHP_4TIGERInit(PHP_TIGER_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { memset(context, 0, sizeof(*context)); context->passes = 1; diff --git a/ext/hash/hash_whirlpool.c b/ext/hash/hash_whirlpool.c index 8d5cbb7737..2a64e864c1 100644 --- a/ext/hash/hash_whirlpool.c +++ b/ext/hash/hash_whirlpool.c @@ -263,7 +263,7 @@ static void WhirlpoolTransform(PHP_WHIRLPOOL_CTX *context) ZEND_SECURE_ZERO(state, sizeof(state)); } -PHP_HASH_API void PHP_WHIRLPOOLInit(PHP_WHIRLPOOL_CTX *context) +PHP_HASH_API void PHP_WHIRLPOOLInit(PHP_WHIRLPOOL_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { memset(context, 0, sizeof(*context)); } diff --git a/ext/hash/php_hash.h b/ext/hash/php_hash.h index 69d1330072..7f57fe567d 100644 --- a/ext/hash/php_hash.h +++ b/ext/hash/php_hash.h @@ -31,7 +31,7 @@ typedef struct _php_hashcontext_object php_hashcontext_object; -typedef void (*php_hash_init_func_t)(void *context); +typedef void (*php_hash_init_func_t)(void *context, HashTable *args); typedef void (*php_hash_update_func_t)(void *context, const unsigned char *buf, size_t count); typedef void (*php_hash_final_func_t)(unsigned char *digest, void *context); typedef int (*php_hash_copy_func_t)(const void *ops, void *orig_context, void *dest_context); diff --git a/ext/hash/php_hash_adler32.h b/ext/hash/php_hash_adler32.h index 049f16b28e..db2db38114 100644 --- a/ext/hash/php_hash_adler32.h +++ b/ext/hash/php_hash_adler32.h @@ -24,7 +24,7 @@ typedef struct { } PHP_ADLER32_CTX; #define PHP_ADLER32_SPEC "l." -PHP_HASH_API void PHP_ADLER32Init(PHP_ADLER32_CTX *context); +PHP_HASH_API void PHP_ADLER32Init(PHP_ADLER32_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_ADLER32Update(PHP_ADLER32_CTX *context, const unsigned char *input, size_t len); PHP_HASH_API void PHP_ADLER32Final(unsigned char digest[4], PHP_ADLER32_CTX *context); PHP_HASH_API int PHP_ADLER32Copy(const php_hash_ops *ops, PHP_ADLER32_CTX *orig_context, PHP_ADLER32_CTX *copy_context); diff --git a/ext/hash/php_hash_crc32.h b/ext/hash/php_hash_crc32.h index 4c1b0fedc9..1003e4b39b 100644 --- a/ext/hash/php_hash_crc32.h +++ b/ext/hash/php_hash_crc32.h @@ -24,7 +24,7 @@ typedef struct { } PHP_CRC32_CTX; #define PHP_CRC32_SPEC "l." -PHP_HASH_API void PHP_CRC32Init(PHP_CRC32_CTX *context); +PHP_HASH_API void PHP_CRC32Init(PHP_CRC32_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_CRC32Update(PHP_CRC32_CTX *context, const unsigned char *input, size_t len); PHP_HASH_API void PHP_CRC32BUpdate(PHP_CRC32_CTX *context, const unsigned char *input, size_t len); PHP_HASH_API void PHP_CRC32CUpdate(PHP_CRC32_CTX *context, const unsigned char *input, size_t len); diff --git a/ext/hash/php_hash_fnv.h b/ext/hash/php_hash_fnv.h index 6728b2e902..f4dacb223e 100644 --- a/ext/hash/php_hash_fnv.h +++ b/ext/hash/php_hash_fnv.h @@ -52,12 +52,12 @@ typedef struct { #define PHP_FNV164_SPEC "q." -PHP_HASH_API void PHP_FNV132Init(PHP_FNV132_CTX *context); +PHP_HASH_API void PHP_FNV132Init(PHP_FNV132_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_FNV132Update(PHP_FNV132_CTX *context, const unsigned char *input, size_t inputLen); PHP_HASH_API void PHP_FNV1a32Update(PHP_FNV132_CTX *context, const unsigned char *input, size_t inputLen); PHP_HASH_API void PHP_FNV132Final(unsigned char digest[16], PHP_FNV132_CTX * context); -PHP_HASH_API void PHP_FNV164Init(PHP_FNV164_CTX *context); +PHP_HASH_API void PHP_FNV164Init(PHP_FNV164_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_FNV164Update(PHP_FNV164_CTX *context, const unsigned char *input, size_t inputLen); PHP_HASH_API void PHP_FNV1a64Update(PHP_FNV164_CTX *context, const unsigned char *input, size_t inputLen); PHP_HASH_API void PHP_FNV164Final(unsigned char digest[16], PHP_FNV164_CTX * context); diff --git a/ext/hash/php_hash_gost.h b/ext/hash/php_hash_gost.h index eb9441faa6..850b089506 100644 --- a/ext/hash/php_hash_gost.h +++ b/ext/hash/php_hash_gost.h @@ -29,7 +29,7 @@ typedef struct { } PHP_GOST_CTX; #define PHP_GOST_SPEC "l16l2bb32" -PHP_HASH_API void PHP_GOSTInit(PHP_GOST_CTX *); +PHP_HASH_API void PHP_GOSTInit(PHP_GOST_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_GOSTUpdate(PHP_GOST_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_GOSTFinal(unsigned char[64], PHP_GOST_CTX *); diff --git a/ext/hash/php_hash_haval.h b/ext/hash/php_hash_haval.h index 43802b4183..2ae0af6bf8 100644 --- a/ext/hash/php_hash_haval.h +++ b/ext/hash/php_hash_haval.h @@ -30,7 +30,7 @@ typedef struct { } PHP_HAVAL_CTX; #define PHP_HAVAL_SPEC "l8l2b128" -#define PHP_HASH_HAVAL_INIT_DECL(p,b) PHP_HASH_API void PHP_##p##HAVAL##b##Init(PHP_HAVAL_CTX *); \ +#define PHP_HASH_HAVAL_INIT_DECL(p,b) PHP_HASH_API void PHP_##p##HAVAL##b##Init(PHP_HAVAL_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); \ PHP_HASH_API void PHP_HAVAL##b##Final(unsigned char*, PHP_HAVAL_CTX *); PHP_HASH_API void PHP_HAVALUpdate(PHP_HAVAL_CTX *, const unsigned char *, size_t); diff --git a/ext/hash/php_hash_joaat.h b/ext/hash/php_hash_joaat.h index b0df8a67b3..113983c2a4 100644 --- a/ext/hash/php_hash_joaat.h +++ b/ext/hash/php_hash_joaat.h @@ -22,7 +22,7 @@ typedef struct { } PHP_JOAAT_CTX; #define PHP_JOAAT_SPEC "l." -PHP_HASH_API void PHP_JOAATInit(PHP_JOAAT_CTX *context); +PHP_HASH_API void PHP_JOAATInit(PHP_JOAAT_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_JOAATUpdate(PHP_JOAAT_CTX *context, const unsigned char *input, size_t inputLen); PHP_HASH_API void PHP_JOAATFinal(unsigned char digest[16], PHP_JOAAT_CTX * context); diff --git a/ext/hash/php_hash_md.h b/ext/hash/php_hash_md.h index 2a677fe54d..ce155b3e1f 100644 --- a/ext/hash/php_hash_md.h +++ b/ext/hash/php_hash_md.h @@ -28,7 +28,8 @@ typedef struct { } PHP_MD4_CTX; #define PHP_MD4_SPEC "l4l2b64." -PHP_HASH_API void PHP_MD4Init(PHP_MD4_CTX *); +#define PHP_MD4Init(ctx) PHP_MD4InitArgs(ctx, NULL) +PHP_HASH_API void PHP_MD4InitArgs(PHP_MD4_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_MD4Update(PHP_MD4_CTX *context, const unsigned char *, size_t); PHP_HASH_API void PHP_MD4Final(unsigned char[16], PHP_MD4_CTX *); @@ -41,7 +42,8 @@ typedef struct { } PHP_MD2_CTX; #define PHP_MD2_SPEC "b48b16b16b." -PHP_HASH_API void PHP_MD2Init(PHP_MD2_CTX *context); +#define PHP_MD2Init(ctx) PHP_MD2InitArgs(ctx, NULL) +PHP_HASH_API void PHP_MD2InitArgs(PHP_MD2_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_MD2Update(PHP_MD2_CTX *context, const unsigned char *, size_t); PHP_HASH_API void PHP_MD2Final(unsigned char[16], PHP_MD2_CTX *); diff --git a/ext/hash/php_hash_murmur.h b/ext/hash/php_hash_murmur.h index 100a8d1fa3..598912141b 100644 --- a/ext/hash/php_hash_murmur.h +++ b/ext/hash/php_hash_murmur.h @@ -24,7 +24,7 @@ typedef struct { } PHP_MURMUR3A_CTX; #define PHP_MURMUR3A_SPEC "lll" -PHP_HASH_API void PHP_MURMUR3AInit(PHP_MURMUR3A_CTX *ctx); +PHP_HASH_API void PHP_MURMUR3AInit(PHP_MURMUR3A_CTX *ctx, HashTable *args); PHP_HASH_API void PHP_MURMUR3AUpdate(PHP_MURMUR3A_CTX *ctx, const unsigned char *in, size_t len); PHP_HASH_API void PHP_MURMUR3AFinal(unsigned char digest[4], PHP_MURMUR3A_CTX *ctx); PHP_HASH_API int PHP_MURMUR3ACopy(const php_hash_ops *ops, PHP_MURMUR3A_CTX *orig_context, PHP_MURMUR3A_CTX *copy_context); @@ -36,7 +36,7 @@ typedef struct { } PHP_MURMUR3C_CTX; #define PHP_MURMUR3C_SPEC "lllllllll" -PHP_HASH_API void PHP_MURMUR3CInit(PHP_MURMUR3C_CTX *ctx); +PHP_HASH_API void PHP_MURMUR3CInit(PHP_MURMUR3C_CTX *ctx, HashTable *args); PHP_HASH_API void PHP_MURMUR3CUpdate(PHP_MURMUR3C_CTX *ctx, const unsigned char *in, size_t len); PHP_HASH_API void PHP_MURMUR3CFinal(unsigned char digest[16], PHP_MURMUR3C_CTX *ctx); PHP_HASH_API int PHP_MURMUR3CCopy(const php_hash_ops *ops, PHP_MURMUR3C_CTX *orig_context, PHP_MURMUR3C_CTX *copy_context); @@ -48,7 +48,7 @@ typedef struct { } PHP_MURMUR3F_CTX; #define PHP_MURMUR3F_SPEC "qqqql" -PHP_HASH_API void PHP_MURMUR3FInit(PHP_MURMUR3F_CTX *ctx); +PHP_HASH_API void PHP_MURMUR3FInit(PHP_MURMUR3F_CTX *ctx, HashTable *args); PHP_HASH_API void PHP_MURMUR3FUpdate(PHP_MURMUR3F_CTX *ctx, const unsigned char *in, size_t len); PHP_HASH_API void PHP_MURMUR3FFinal(unsigned char digest[16], PHP_MURMUR3F_CTX *ctx); PHP_HASH_API int PHP_MURMUR3FCopy(const php_hash_ops *ops, PHP_MURMUR3F_CTX *orig_context, PHP_MURMUR3F_CTX *copy_context); diff --git a/ext/hash/php_hash_ripemd.h b/ext/hash/php_hash_ripemd.h index dd9913b85b..55a430a4f2 100644 --- a/ext/hash/php_hash_ripemd.h +++ b/ext/hash/php_hash_ripemd.h @@ -47,19 +47,19 @@ typedef struct { } PHP_RIPEMD320_CTX; #define PHP_RIPEMD320_SPEC "l10l2b64." -PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX *); +PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_RIPEMD128Update(PHP_RIPEMD128_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_RIPEMD128Final(unsigned char[16], PHP_RIPEMD128_CTX *); -PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX *); +PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_RIPEMD160Update(PHP_RIPEMD160_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_RIPEMD160Final(unsigned char[20], PHP_RIPEMD160_CTX *); -PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX *); +PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_RIPEMD256Update(PHP_RIPEMD256_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_RIPEMD256Final(unsigned char[32], PHP_RIPEMD256_CTX *); -PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX *); +PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_RIPEMD320Update(PHP_RIPEMD320_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_RIPEMD320Final(unsigned char[40], PHP_RIPEMD320_CTX *); diff --git a/ext/hash/php_hash_sha.h b/ext/hash/php_hash_sha.h index 16da927363..4240a6228e 100644 --- a/ext/hash/php_hash_sha.h +++ b/ext/hash/php_hash_sha.h @@ -29,7 +29,8 @@ typedef struct { } PHP_SHA224_CTX; #define PHP_SHA224_SPEC "l8l2b64." -PHP_HASH_API void PHP_SHA224Init(PHP_SHA224_CTX *); +#define PHP_SHA224Init(ctx) PHP_SHA224InitArgs(ctx, NULL) +PHP_HASH_API void PHP_SHA224InitArgs(PHP_SHA224_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA224Update(PHP_SHA224_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_SHA224Final(unsigned char[28], PHP_SHA224_CTX *); @@ -41,7 +42,8 @@ typedef struct { } PHP_SHA256_CTX; #define PHP_SHA256_SPEC "l8l2b64." -PHP_HASH_API void PHP_SHA256Init(PHP_SHA256_CTX *); +#define PHP_SHA256Init(ctx) PHP_SHA256InitArgs(ctx, NULL) +PHP_HASH_API void PHP_SHA256InitArgs(PHP_SHA256_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA256Update(PHP_SHA256_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_SHA256Final(unsigned char[32], PHP_SHA256_CTX *); @@ -53,7 +55,8 @@ typedef struct { } PHP_SHA384_CTX; #define PHP_SHA384_SPEC "q8q2b128." -PHP_HASH_API void PHP_SHA384Init(PHP_SHA384_CTX *); +#define PHP_SHA384Init(ctx) PHP_SHA384InitArgs(ctx, NULL) +PHP_HASH_API void PHP_SHA384InitArgs(PHP_SHA384_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA384Update(PHP_SHA384_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_SHA384Final(unsigned char[48], PHP_SHA384_CTX *); @@ -65,15 +68,18 @@ typedef struct { } PHP_SHA512_CTX; #define PHP_SHA512_SPEC "q8q2b128." -PHP_HASH_API void PHP_SHA512Init(PHP_SHA512_CTX *); +#define PHP_SHA512Init(ctx) PHP_SHA512InitArgs(ctx, NULL) +PHP_HASH_API void PHP_SHA512InitArgs(PHP_SHA512_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA512Update(PHP_SHA512_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_SHA512Final(unsigned char[64], PHP_SHA512_CTX *); -PHP_HASH_API void PHP_SHA512_256Init(PHP_SHA512_CTX *); +#define PHP_SHA512_256Init(ctx) PHP_SHA512_256InitArgs(ctx, NULL) +PHP_HASH_API void PHP_SHA512_256InitArgs(PHP_SHA512_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); #define PHP_SHA512_256Update PHP_SHA512Update PHP_HASH_API void PHP_SHA512_256Final(unsigned char[32], PHP_SHA512_CTX *); -PHP_HASH_API void PHP_SHA512_224Init(PHP_SHA512_CTX *); +#define PHP_SHA512_224Init(ctx) PHP_SHA512_224InitArgs(ctx, NULL) +PHP_HASH_API void PHP_SHA512_224InitArgs(PHP_SHA512_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); #define PHP_SHA512_224Update PHP_SHA512Update PHP_HASH_API void PHP_SHA512_224Final(unsigned char[28], PHP_SHA512_CTX *); diff --git a/ext/hash/php_hash_sha3.h b/ext/hash/php_hash_sha3.h index f75191f339..b8bd310cce 100644 --- a/ext/hash/php_hash_sha3.h +++ b/ext/hash/php_hash_sha3.h @@ -36,19 +36,19 @@ typedef PHP_SHA3_CTX PHP_SHA3_256_CTX; typedef PHP_SHA3_CTX PHP_SHA3_384_CTX; typedef PHP_SHA3_CTX PHP_SHA3_512_CTX; -PHP_HASH_API void PHP_SHA3224Init(PHP_SHA3_224_CTX*); +PHP_HASH_API void PHP_SHA3224Init(PHP_SHA3_224_CTX*, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA3224Update(PHP_SHA3_224_CTX*, const unsigned char*, size_t); PHP_HASH_API void PHP_SAH3224Final(unsigned char[32], PHP_SHA3_224_CTX*); -PHP_HASH_API void PHP_SHA3256Init(PHP_SHA3_256_CTX*); +PHP_HASH_API void PHP_SHA3256Init(PHP_SHA3_256_CTX*, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA3256Update(PHP_SHA3_256_CTX*, const unsigned char*, size_t); PHP_HASH_API void PHP_SAH3256Final(unsigned char[32], PHP_SHA3_256_CTX*); -PHP_HASH_API void PHP_SHA3384Init(PHP_SHA3_384_CTX*); +PHP_HASH_API void PHP_SHA3384Init(PHP_SHA3_384_CTX*, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA3384Update(PHP_SHA3_384_CTX*, const unsigned char*, size_t); PHP_HASH_API void PHP_SAH3384Final(unsigned char[32], PHP_SHA3_384_CTX*); -PHP_HASH_API void PHP_SHA3512Init(PHP_SHA3_512_CTX*); +PHP_HASH_API void PHP_SHA3512Init(PHP_SHA3_512_CTX*, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SHA3512Update(PHP_SHA3_512_CTX*, const unsigned char*, size_t); PHP_HASH_API void PHP_SAH3512Final(unsigned char[32], PHP_SHA3_512_CTX*); diff --git a/ext/hash/php_hash_snefru.h b/ext/hash/php_hash_snefru.h index 0f339e9309..c533b576a9 100644 --- a/ext/hash/php_hash_snefru.h +++ b/ext/hash/php_hash_snefru.h @@ -32,7 +32,7 @@ typedef struct { } PHP_SNEFRU_CTX; #define PHP_SNEFRU_SPEC "l16l2bb32" -PHP_HASH_API void PHP_SNEFRUInit(PHP_SNEFRU_CTX *); +PHP_HASH_API void PHP_SNEFRUInit(PHP_SNEFRU_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_SNEFRUUpdate(PHP_SNEFRU_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_SNEFRUFinal(unsigned char[32], PHP_SNEFRU_CTX *); diff --git a/ext/hash/php_hash_tiger.h b/ext/hash/php_hash_tiger.h index d30276ddea..6854c35887 100644 --- a/ext/hash/php_hash_tiger.h +++ b/ext/hash/php_hash_tiger.h @@ -27,8 +27,8 @@ typedef struct { } PHP_TIGER_CTX; #define PHP_TIGER_SPEC "q3qb64l" -PHP_HASH_API void PHP_3TIGERInit(PHP_TIGER_CTX *context); -PHP_HASH_API void PHP_4TIGERInit(PHP_TIGER_CTX *context); +PHP_HASH_API void PHP_3TIGERInit(PHP_TIGER_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); +PHP_HASH_API void PHP_4TIGERInit(PHP_TIGER_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHP_HASH_API void PHP_TIGERUpdate(PHP_TIGER_CTX *context, const unsigned char *input, size_t len); PHP_HASH_API void PHP_TIGER128Final(unsigned char digest[16], PHP_TIGER_CTX *context); PHP_HASH_API void PHP_TIGER160Final(unsigned char digest[20], PHP_TIGER_CTX *context); diff --git a/ext/hash/php_hash_whirlpool.h b/ext/hash/php_hash_whirlpool.h index fbd5948a48..376d75a940 100644 --- a/ext/hash/php_hash_whirlpool.h +++ b/ext/hash/php_hash_whirlpool.h @@ -29,7 +29,7 @@ typedef struct { } PHP_WHIRLPOOL_CTX; #define PHP_WHIRLPOOL_SPEC "q8b32iib64." -PHP_HASH_API void PHP_WHIRLPOOLInit(PHP_WHIRLPOOL_CTX *); +PHP_HASH_API void PHP_WHIRLPOOLInit(PHP_WHIRLPOOL_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHP_HASH_API void PHP_WHIRLPOOLUpdate(PHP_WHIRLPOOL_CTX *, const unsigned char *, size_t); PHP_HASH_API void PHP_WHIRLPOOLFinal(unsigned char[64], PHP_WHIRLPOOL_CTX *); diff --git a/ext/hash/tests/murmurhash3_seed.phpt b/ext/hash/tests/murmurhash3_seed.phpt new file mode 100644 index 0000000000..68cc10a719 --- /dev/null +++ b/ext/hash/tests/murmurhash3_seed.phpt @@ -0,0 +1,52 @@ +--TEST-- +Hash: MurmurHash3 seed +--FILE-- +<?php + +$ctx = hash_init("murmur3f", options: ["seed" => 42]); +hash_update($ctx, "Two"); +hash_update($ctx, " hashes"); +hash_update($ctx, " meet"); +hash_update($ctx, " in"); +hash_update($ctx, " a"); +hash_update($ctx, " bar."); +$h0 = hash_final($ctx); +echo $h0, "\n"; + +$h0 = hash("murmur3f", "Two hashes meet in a bar.", options: ["seed" => 42]); +echo $h0, "\n"; + +$ctx = hash_init("murmur3c", options: ["seed" => 106]); +hash_update($ctx, "Two"); +hash_update($ctx, " hashes"); +hash_update($ctx, " meet"); +hash_update($ctx, " in"); +hash_update($ctx, " a"); +hash_update($ctx, " bar."); +$h0 = hash_final($ctx); +echo $h0, "\n"; + +$h0 = hash("murmur3c", "Two hashes meet in a bar.", options: ["seed" => 106]); +echo $h0, "\n"; + +$ctx = hash_init("murmur3a", options: ["seed" => 2345]); +hash_update($ctx, "Two"); +hash_update($ctx, " hashes"); +hash_update($ctx, " meet"); +hash_update($ctx, " in"); +hash_update($ctx, " a"); +hash_update($ctx, " bar."); +$h0 = hash_final($ctx); +echo $h0, "\n"; + +$h0 = hash("murmur3a", "Two hashes meet in a bar.", options: ["seed" => 2345]); +echo $h0, "\n"; + +?> +--EXPECT-- +95855f9be0db784a5c37e878c4a4dcee +95855f9be0db784a5c37e878c4a4dcee +f64c9eb40287fa686575163893e283b2 +f64c9eb40287fa686575163893e283b2 +7f7ec59b +7f7ec59b diff --git a/ext/standard/md5.c b/ext/standard/md5.c index ec07ae2ed3..83d43c4976 100644 --- a/ext/standard/md5.c +++ b/ext/standard/md5.c @@ -290,7 +290,7 @@ static const void *body(PHP_MD5_CTX *ctx, const void *data, size_t size) return ptr; } -PHPAPI void PHP_MD5Init(PHP_MD5_CTX *ctx) +PHPAPI void PHP_MD5InitArgs(PHP_MD5_CTX *ctx, ZEND_ATTRIBUTE_UNUSED HashTable *args) { ctx->a = 0x67452301; ctx->b = 0xefcdab89; diff --git a/ext/standard/md5.h b/ext/standard/md5.h index ac60d7fca4..09bcff1cf1 100644 --- a/ext/standard/md5.h +++ b/ext/standard/md5.h @@ -42,7 +42,8 @@ typedef struct { } PHP_MD5_CTX; #define PHP_MD5_SPEC "llllllb64l16." -PHPAPI void PHP_MD5Init(PHP_MD5_CTX *ctx); +#define PHP_MD5Init(ctx) PHP_MD5InitArgs(ctx, NULL) +PHPAPI void PHP_MD5InitArgs(PHP_MD5_CTX *context, ZEND_ATTRIBUTE_UNUSED HashTable *args); PHPAPI void PHP_MD5Update(PHP_MD5_CTX *ctx, const void *data, size_t size); PHPAPI void PHP_MD5Final(unsigned char *result, PHP_MD5_CTX *ctx); diff --git a/ext/standard/sha1.c b/ext/standard/sha1.c index 58bd91385c..f5668b9283 100644 --- a/ext/standard/sha1.c +++ b/ext/standard/sha1.c @@ -152,7 +152,7 @@ static const unsigned char PADDING[64] = /* {{{ PHP_SHA1Init * SHA1 initialization. Begins an SHA1 operation, writing a new context. */ -PHPAPI void PHP_SHA1Init(PHP_SHA1_CTX * context) +PHPAPI void PHP_SHA1InitArgs(PHP_SHA1_CTX * context, ZEND_ATTRIBUTE_UNUSED HashTable *args) { context->count[0] = context->count[1] = 0; /* Load magic initialization constants. diff --git a/ext/standard/sha1.h b/ext/standard/sha1.h index ef98ecc29c..3ae3ec219e 100644 --- a/ext/standard/sha1.h +++ b/ext/standard/sha1.h @@ -27,7 +27,8 @@ typedef struct { } PHP_SHA1_CTX; #define PHP_SHA1_SPEC "l5l2b64." -PHPAPI void PHP_SHA1Init(PHP_SHA1_CTX *); +#define PHP_SHA1Init(ctx) PHP_SHA1InitArgs(ctx, NULL) +PHPAPI void PHP_SHA1InitArgs(PHP_SHA1_CTX *, ZEND_ATTRIBUTE_UNUSED HashTable *); PHPAPI void PHP_SHA1Update(PHP_SHA1_CTX *, const unsigned char *, size_t); PHPAPI void PHP_SHA1Final(unsigned char[20], PHP_SHA1_CTX *); PHPAPI void make_sha1_digest(char *sha1str, const unsigned char *digest); |