hash: Support custom algo parameters

The concrete need on this change is to support passing an initial seed
to the murmur hash. Passing a custom seed is important in terms of
randomizing the hash function.

The suggested implementation adds a HashTable parameter to all the
init callbacks. Further on, an array with custom arguments is accepted
from `hash` or `hash_init` from the user land. Currently several things
like `hash_hkdf` are not touched, as they don't need passing custom
args.

Some convenience macros have been added to the SHA/MD families of
functions, so the consuming code doesn't have to be changed widely.

Another way to implement this is to add another type of the init that
would accept a HT with arguments. However, that would still require
touching all the context structs in all the algos. That would also
increase the size of those structs. As an init function is called just
once, the way of modifying the existing init callback has been seen
as more preferrable.

Closes GH-6400.

Signed-off-by: Anatol Belski <ab@php.net>
Co-Developed-by: Nikita Popov <nikita.ppv@googlemail.com>
Signed-off-by: Nikita Popov <nikita.ppv@googlemail.com>
Acked-by: Michael Wallner <mike@php.net>
Reviewed-by: Máté Kocsis <kocsismate@woohoolabs.com>
Reviewed-by: Eddie Kohler <ekohler@gmail.com>

diff --git a/ext/hash/hash.c b/ext/hash/hash.c
index f7b851f5a49fe2f01ed21e0f409a6846bd7c094a..a337ef0489342726955b52878ce64f96b5f05d91 100644 (file)
--- 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 c0d4cbca7c3d5495b111470a82607157a2c325f9..7eb3925c353b4a34804508832dcd103c51b8e050 100644 (file)
--- 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 d45012f8e6d515e481bdc037b4e4a652f037db11..5acd621b2d3f41f6e08941058bafb9032862db8d 100644 (file)
--- 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 db043da97b477d29bf1711077eef6b4c8abd2d7c..1d654b546ee1f491257a75c104a14748a6c73165 100644 (file)
--- 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 ade32a3b35c1c93316f94691d6ebd49ec776e0f7..d77cdde013fbdd0a77154291e177f39f487d1ec3 100644 (file)
--- 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 2ee81b9c8601b11ba69f813b6a97b0dc492efad8..3a48d404841a3926aa2107c1fc3300376b7d4b55 100644 (file)
--- 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 46ea032c32e300362adedbbfa1c04610fb66ee0a..d1f4a31765a9a2982857b85b336dc51943051ed3 100644 (file)
--- 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 84ff242bd90d5ed298572a2397ac0219bb44863c..9b117db8d9b01e8e359d76bc35a415a845a5aaa5 100644 (file)
--- 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 5d5a2e53b9b39522ce7a1bec7bcfb90024095cd9..41fde52f30474bb8ba3a0e914f9be56032eccf57 100644 (file)
--- 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 94fafbbf798a81321cc974d0c18a49252106eacd..a34936d625304f9503b20e399082cbc2bdbffe26 100644 (file)
--- 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 ab01b4f19fce62842344256c82ddd56567405c6f..466231054c6694559463ad1460e477e165147adb 100644 (file)
--- 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 db1d1dc02b9e2656ce4d2a25d5550e12e6e71106..58c40b06a78ccad67fe6c0ce6f896a812e7fbd62 100644 (file)
--- 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 4ea5b768d703c50fd080cb21e6e4ef36c3be1c29..acc23a21bf0969386bb86c8848f49e5b3713733c 100644 (file)
--- 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 52bd495f9df60317b8c09c44abb05d7358e1d0f2..123e599d04c310bf63a38dc7dff3366c47b23155 100644 (file)
--- 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 292bfef2cb8da57a7955eb93255cf15c038fd95d..66f9300b115069f3ab8a86352077c833a42dee2e 100644 (file)
--- 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 8e0f365dc49ebe510a00b509b78d912a6bf90427..b360dd6adec313fbaf4cadb0394a1ee8fbe0d9bf 100644 (file)
--- 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 8d5cbb77370a89f8b79681ce960a656fe94a56fa..2a64e864c1cc4bce2e4f4bad7b37633dc96b71a6 100644 (file)
--- 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 69d1330072daf140c767d00c8b471b0446fc8c6e..7f57fe567d0f9a4027852c8800a9958169f9dbd4 100644 (file)
--- 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 049f16b28e95618a67611c96ce962090d598eae0..db2db3811401276b5c5bffa19e5f90bcfd383a4e 100644 (file)
--- 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 4c1b0fedc915915b46061aef299fe6f30b0977b5..1003e4b39bc07155f4403e01db206a5470cbdc9b 100644 (file)
--- 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 6728b2e90205ea0a6e7c2f8fe52c6d0bff68efa8..f4dacb223e89405c273b67a2a23a2c20b2fcb89b 100644 (file)
--- 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 eb9441faa66a4b9f4edf4fc9986fd3d5ee4213b1..850b089506810538f64b36ad32b93c49348c06f7 100644 (file)
--- 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 43802b41834faf98b7216f80860891b63502d418..2ae0af6bf8ea2975954c92179e608080b451649d 100644 (file)
--- 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 b0df8a67b38ae631edb179c626ca15d7f2c05847..113983c2a42541b384569a4f85d1d068bdddd0ec 100644 (file)
--- 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 2a677fe54d6621a51c89187ed4c710a9c05b4cb1..ce155b3e1f295f742d940ff449a6e4caa2f64550 100644 (file)
--- 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 100a8d1fa32f15dd7843e8745d7ade4d3b0dc69e..598912141b5c49c49dd3afdd39211edc2ff2ad0a 100644 (file)
--- 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 dd9913b85b72ac2b34a990bd7e5f37ce58cdf427..55a430a4f2bdcdbd9f7c5577f7a75ecc15bce94f 100644 (file)
--- 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 16da9273636a79f0ba46dc1b2e1ba83696eab6aa..4240a6228e147eee886766ea44e0c3113bf537b4 100644 (file)
--- 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 f75191f339fc67357405dd2e7154959cefdeb0dc..b8bd310ccef6669731fd854e5461758975de470f 100644 (file)
--- 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 0f339e93090ab507c7736534334059d5c32efb7c..c533b576a909fb8148e08ffd0f6523d3aae1cf3b 100644 (file)
--- 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 d30276ddeaa29f758d27203faa7b0e98562fbdf2..6854c3588715fdf13148ed8fbaec491ccc197c33 100644 (file)
--- 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 fbd5948a4817bbdd070bb2a8d1038bedde1ee6b0..376d75a94009f8e928b4c0961b6829c0948af654 100644 (file)
--- 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 (file)
index 0000000..68cc10a
--- /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 ec07ae2ed35ad42b31e4aea18d4e7cb496290827..83d43c497694ee4f2757976df8306fda26f6f454 100644 (file)
--- 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 ac60d7fca4cdaf1378596f73126ed90583fc74bb..09bcff1cf1e721e422bc1af6f5e311e5e9eeef4e 100644 (file)
--- 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 58bd91385c2c7019fc2700bffba5126ef06166c1..f5668b9283c8aa1757af2b474c43defc8580ab63 100644 (file)
--- 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 ef98ecc29cc895da9af0e482fa1effc63a9de944..3ae3ec219ed2d251a5d285cf69902111f301d44b 100644 (file)
--- 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);