1/*
2  +----------------------------------------------------------------------+
3  | PHP Version 7                                                        |
4  +----------------------------------------------------------------------+
5  | Copyright (c) 1997-2015 The PHP Group                                |
6  +----------------------------------------------------------------------+
7  | This source file is subject to version 3.01 of the PHP license,      |
8  | that is bundled with this package in the file LICENSE, and is        |
9  | available through the world-wide-web at the following url:           |
10  | http://www.php.net/license/3_01.txt                                  |
11  | If you did not receive a copy of the PHP license and are unable to   |
12  | obtain it through the world-wide-web, please send a note to          |
13  | license@php.net so we can mail you a copy immediately.               |
14  +----------------------------------------------------------------------+
15  | Author: Sara Golemon <pollita@php.net>                               |
16  |         Scott MacVicar <scottmac@php.net>                            |
17  +----------------------------------------------------------------------+
18*/
19
20/* $Id$ */
21
22#ifdef HAVE_CONFIG_H
23#include "config.h"
24#endif
25
26#include <math.h>
27#include "php_hash.h"
28#include "ext/standard/info.h"
29#include "ext/standard/file.h"
30
31static int php_hash_le_hash;
32HashTable php_hash_hashtable;
33
34#if (PHP_MAJOR_VERSION >= 5)
35# define DEFAULT_CONTEXT FG(default_context)
36#else
37# define DEFAULT_CONTEXT NULL
38#endif
39
40#ifdef PHP_MHASH_BC
41struct mhash_bc_entry {
42    char *mhash_name;
43    char *hash_name;
44    int value;
45};
46
47#define MHASH_NUM_ALGOS 34
48
49static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {
50    {"CRC32", "crc32", 0},
51    {"MD5", "md5", 1},
52    {"SHA1", "sha1", 2},
53    {"HAVAL256", "haval256,3", 3},
54    {NULL, NULL, 4},
55    {"RIPEMD160", "ripemd160", 5},
56    {NULL, NULL, 6},
57    {"TIGER", "tiger192,3", 7},
58    {"GOST", "gost", 8},
59    {"CRC32B", "crc32b", 9},
60    {"HAVAL224", "haval224,3", 10},
61    {"HAVAL192", "haval192,3", 11},
62    {"HAVAL160", "haval160,3", 12},
63    {"HAVAL128", "haval128,3", 13},
64    {"TIGER128", "tiger128,3", 14},
65    {"TIGER160", "tiger160,3", 15},
66    {"MD4", "md4", 16},
67    {"SHA256", "sha256", 17},
68    {"ADLER32", "adler32", 18},
69    {"SHA224", "sha224", 19},
70    {"SHA512", "sha512", 20},
71    {"SHA384", "sha384", 21},
72    {"WHIRLPOOL", "whirlpool", 22},
73    {"RIPEMD128", "ripemd128", 23},
74    {"RIPEMD256", "ripemd256", 24},
75    {"RIPEMD320", "ripemd320", 25},
76    {NULL, NULL, 26}, /* support needs to be added for snefru 128 */
77    {"SNEFRU256", "snefru256", 27},
78    {"MD2", "md2", 28},
79    {"FNV132", "fnv132", 29},
80    {"FNV1A32", "fnv1a32", 30},
81    {"FNV164", "fnv164", 31},
82    {"FNV1A64", "fnv1a64", 32},
83    {"JOAAT", "joaat", 33},
84};
85#endif
86
87/* Hash Registry Access */
88
89PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, size_t algo_len) /* {{{ */
90{
91    char *lower = zend_str_tolower_dup(algo, algo_len);
92    php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, lower, algo_len);
93    efree(lower);
94
95    return ops;
96}
97/* }}} */
98
99PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops) /* {{{ */
100{
101    int algo_len = strlen(algo);
102    char *lower = zend_str_tolower_dup(algo, algo_len);
103    zend_hash_str_add_ptr(&php_hash_hashtable, lower, algo_len, (void *) ops);
104    efree(lower);
105}
106/* }}} */
107
108PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context) /* {{{ */
109{
110    php_hash_ops *hash_ops = (php_hash_ops *)ops;
111
112    memcpy(dest_context, orig_context, hash_ops->context_size);
113    return SUCCESS;
114}
115/* }}} */
116
117/* Userspace */
118
119static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
120{
121    zend_string *digest;
122    char *algo, *data;
123    size_t algo_len, data_len;
124    zend_bool raw_output = raw_output_default;
125    const php_hash_ops *ops;
126    void *context;
127    php_stream *stream = NULL;
128
129    if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss|b", &algo, &algo_len, &data, &data_len, &raw_output) == FAILURE) {
130        return;
131    }
132
133    ops = php_hash_fetch_ops(algo, algo_len);
134    if (!ops) {
135        php_error_docref(NULL, E_WARNING, "Unknown hashing algorithm: %s", algo);
136        RETURN_FALSE;
137    }
138    if (isfilename) {
139        if (CHECK_NULL_PATH(data, data_len)) {
140            RETURN_FALSE;
141        }
142        stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, DEFAULT_CONTEXT);
143        if (!stream) {
144            /* Stream will report errors opening file */
145            RETURN_FALSE;
146        }
147    }
148
149    context = emalloc(ops->context_size);
150    ops->hash_init(context);
151
152    if (isfilename) {
153        char buf[1024];
154        int n;
155
156        while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
157            ops->hash_update(context, (unsigned char *) buf, n);
158        }
159        php_stream_close(stream);
160    } else {
161        ops->hash_update(context, (unsigned char *) data, data_len);
162    }
163
164    digest = zend_string_alloc(ops->digest_size, 0);
165    ops->hash_final((unsigned char *) digest->val, context);
166    efree(context);
167
168    if (raw_output) {
169        digest->val[ops->digest_size] = 0;
170        RETURN_STR(digest);
171    } else {
172        zend_string *hex_digest = zend_string_safe_alloc(ops->digest_size, 2, 0, 0);
173
174        php_hash_bin2hex(hex_digest->val, (unsigned char *) digest->val, ops->digest_size);
175        hex_digest->val[2 * ops->digest_size] = 0;
176        zend_string_release(digest);
177        RETURN_STR(hex_digest);
178    }
179}
180/* }}} */
181
182/* {{{ proto string hash(string algo, string data[, bool raw_output = false])
183Generate a hash of a given input string
184Returns lowercase hexits by default */
185PHP_FUNCTION(hash)
186{
187    php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
188}
189/* }}} */
190
191/* {{{ proto string hash_file(string algo, string filename[, bool raw_output = false])
192Generate a hash of a given file
193Returns lowercase hexits by default */
194PHP_FUNCTION(hash_file)
195{
196    php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
197}
198/* }}} */
199
200static inline void php_hash_string_xor_char(unsigned char *out, const unsigned char *in, const unsigned char xor_with, const int length) {
201    int i;
202    for (i=0; i < length; i++) {
203        out[i] = in[i] ^ xor_with;
204    }
205}
206
207static inline void php_hash_string_xor(unsigned char *out, const unsigned char *in, const unsigned char *xor_with, const int length) {
208    int i;
209    for (i=0; i < length; i++) {
210        out[i] = in[i] ^ xor_with[i];
211    }
212}
213
214static inline void php_hash_hmac_prep_key(unsigned char *K, const php_hash_ops *ops, void *context, const unsigned char *key, const size_t key_len) {
215    memset(K, 0, ops->block_size);
216    if (key_len > ops->block_size) {
217        /* Reduce the key first */
218        ops->hash_init(context);
219        ops->hash_update(context, key, key_len);
220        ops->hash_final(K, context);
221    } else {
222        memcpy(K, key, key_len);
223    }
224    /* XOR the key with 0x36 to get the ipad) */
225    php_hash_string_xor_char(K, K, 0x36, ops->block_size);
226}
227
228static 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) {
229    ops->hash_init(context);
230    ops->hash_update(context, key, ops->block_size);
231    ops->hash_update(context, data, data_size);
232    ops->hash_final(final, context);
233}
234
235static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
236{
237    zend_string *digest;
238    char *algo, *data, *key;
239    unsigned char *K;
240    size_t algo_len, data_len, key_len;
241    zend_bool raw_output = raw_output_default;
242    const php_hash_ops *ops;
243    void *context;
244    php_stream *stream = NULL;
245
246    if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss|b", &algo, &algo_len, &data, &data_len,
247                                                                  &key, &key_len, &raw_output) == FAILURE) {
248        return;
249    }
250
251    ops = php_hash_fetch_ops(algo, algo_len);
252    if (!ops) {
253        php_error_docref(NULL, E_WARNING, "Unknown hashing algorithm: %s", algo);
254        RETURN_FALSE;
255    }
256    if (isfilename) {
257        stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, DEFAULT_CONTEXT);
258        if (!stream) {
259            /* Stream will report errors opening file */
260            RETURN_FALSE;
261        }
262    }
263
264    context = emalloc(ops->context_size);
265
266    K = emalloc(ops->block_size);
267    digest = zend_string_alloc(ops->digest_size, 0);
268
269    php_hash_hmac_prep_key(K, ops, context, (unsigned char *) key, key_len);
270
271    if (isfilename) {
272        char buf[1024];
273        int n;
274        ops->hash_init(context);
275        ops->hash_update(context, K, ops->block_size);
276        while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
277            ops->hash_update(context, (unsigned char *) buf, n);
278        }
279        php_stream_close(stream);
280        ops->hash_final((unsigned char *) digest->val, context);
281    } else {
282        php_hash_hmac_round((unsigned char *) digest->val, ops, context, K, (unsigned char *) data, data_len);
283    }
284
285    php_hash_string_xor_char(K, K, 0x6A, ops->block_size);
286
287    php_hash_hmac_round((unsigned char *) digest->val, ops, context, K, (unsigned char *) digest->val, ops->digest_size);
288
289    /* Zero the key */
290    ZEND_SECURE_ZERO(K, ops->block_size);
291    efree(K);
292    efree(context);
293
294    if (raw_output) {
295        digest->val[ops->digest_size] = 0;
296        RETURN_STR(digest);
297    } else {
298        zend_string *hex_digest = zend_string_safe_alloc(ops->digest_size, 2, 0, 0);
299
300        php_hash_bin2hex(hex_digest->val, (unsigned char *) digest->val, ops->digest_size);
301        hex_digest->val[2 * ops->digest_size] = 0;
302        zend_string_release(digest);
303        RETURN_STR(hex_digest);
304    }
305}
306/* }}} */
307
308/* {{{ proto string hash_hmac(string algo, string data, string key[, bool raw_output = false])
309Generate a hash of a given input string with a key using HMAC
310Returns lowercase hexits by default */
311PHP_FUNCTION(hash_hmac)
312{
313    php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
314}
315/* }}} */
316
317/* {{{ proto string hash_hmac_file(string algo, string filename, string key[, bool raw_output = false])
318Generate a hash of a given file with a key using HMAC
319Returns lowercase hexits by default */
320PHP_FUNCTION(hash_hmac_file)
321{
322    php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, 0);
323}
324/* }}} */
325
326
327/* {{{ proto resource hash_init(string algo[, int options, string key])
328Initialize a hashing context */
329PHP_FUNCTION(hash_init)
330{
331    char *algo, *key = NULL;
332    size_t algo_len, key_len = 0;
333    int argc = ZEND_NUM_ARGS();
334    zend_long options = 0;
335    void *context;
336    const php_hash_ops *ops;
337    php_hash_data *hash;
338
339    if (zend_parse_parameters(argc, "s|ls", &algo, &algo_len, &options, &key, &key_len) == FAILURE) {
340        return;
341    }
342
343    ops = php_hash_fetch_ops(algo, algo_len);
344    if (!ops) {
345        php_error_docref(NULL, E_WARNING, "Unknown hashing algorithm: %s", algo);
346        RETURN_FALSE;
347    }
348
349    if (options & PHP_HASH_HMAC &&
350        key_len <= 0) {
351        /* Note: a zero length key is no key at all */
352        php_error_docref(NULL, E_WARNING, "HMAC requested without a key");
353        RETURN_FALSE;
354    }
355
356    context = emalloc(ops->context_size);
357    ops->hash_init(context);
358
359    hash = emalloc(sizeof(php_hash_data));
360    hash->ops = ops;
361    hash->context = context;
362    hash->options = options;
363    hash->key = NULL;
364
365    if (options & PHP_HASH_HMAC) {
366        char *K = emalloc(ops->block_size);
367        int i;
368
369        memset(K, 0, ops->block_size);
370
371        if (key_len > ops->block_size) {
372            /* Reduce the key first */
373            ops->hash_update(context, (unsigned char *) key, key_len);
374            ops->hash_final((unsigned char *) K, context);
375            /* Make the context ready to start over */
376            ops->hash_init(context);
377        } else {
378            memcpy(K, key, key_len);
379        }
380
381        /* XOR ipad */
382        for(i=0; i < ops->block_size; i++) {
383            K[i] ^= 0x36;
384        }
385        ops->hash_update(context, (unsigned char *) K, ops->block_size);
386        hash->key = (unsigned char *) K;
387    }
388
389    RETURN_RES(zend_register_resource(hash, php_hash_le_hash));
390}
391/* }}} */
392
393/* {{{ proto bool hash_update(resource context, string data)
394Pump data into the hashing algorithm */
395PHP_FUNCTION(hash_update)
396{
397    zval *zhash;
398    php_hash_data *hash;
399    char *data;
400    size_t data_len;
401
402    if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &zhash, &data, &data_len) == FAILURE) {
403        return;
404    }
405
406    if ((hash = (php_hash_data *)zend_fetch_resource(Z_RES_P(zhash), PHP_HASH_RESNAME, php_hash_le_hash)) == NULL) {
407        RETURN_FALSE;
408    }
409
410    hash->ops->hash_update(hash->context, (unsigned char *) data, data_len);
411
412    RETURN_TRUE;
413}
414/* }}} */
415
416/* {{{ proto int hash_update_stream(resource context, resource handle[, integer length])
417Pump data into the hashing algorithm from an open stream */
418PHP_FUNCTION(hash_update_stream)
419{
420    zval *zhash, *zstream;
421    php_hash_data *hash;
422    php_stream *stream = NULL;
423    zend_long length = -1, didread = 0;
424
425    if (zend_parse_parameters(ZEND_NUM_ARGS(), "rr|l", &zhash, &zstream, &length) == FAILURE) {
426        return;
427    }
428
429    if ((hash = (php_hash_data *)zend_fetch_resource(Z_RES_P(zhash), PHP_HASH_RESNAME, php_hash_le_hash)) == NULL) {
430        RETURN_FALSE;
431    }
432
433    php_stream_from_zval(stream, zstream);
434
435    while (length) {
436        char buf[1024];
437        zend_long n, toread = 1024;
438
439        if (length > 0 && toread > length) {
440            toread = length;
441        }
442
443        if ((n = php_stream_read(stream, buf, toread)) <= 0) {
444            /* Nada mas */
445            RETURN_LONG(didread);
446        }
447        hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
448        length -= n;
449        didread += n;
450    }
451
452    RETURN_LONG(didread);
453}
454/* }}} */
455
456/* {{{ proto bool hash_update_file(resource context, string filename[, resource context])
457Pump data into the hashing algorithm from a file */
458PHP_FUNCTION(hash_update_file)
459{
460    zval *zhash, *zcontext = NULL;
461    php_hash_data *hash;
462    php_stream_context *context;
463    php_stream *stream;
464    char *filename, buf[1024];
465    size_t filename_len, n;
466
467    if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|r", &zhash, &filename, &filename_len, &zcontext) == FAILURE) {
468        return;
469    }
470
471    if ((hash = (php_hash_data *)zend_fetch_resource(Z_RES_P(zhash), PHP_HASH_RESNAME, php_hash_le_hash)) == NULL) {
472        RETURN_FALSE;
473    }
474    context = php_stream_context_from_zval(zcontext, 0);
475
476    stream = php_stream_open_wrapper_ex(filename, "rb", REPORT_ERRORS, NULL, context);
477    if (!stream) {
478        /* Stream will report errors opening file */
479        RETURN_FALSE;
480    }
481
482    while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
483        hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
484    }
485    php_stream_close(stream);
486
487    RETURN_TRUE;
488}
489/* }}} */
490
491/* {{{ proto string hash_final(resource context[, bool raw_output=false])
492Output resulting digest */
493PHP_FUNCTION(hash_final)
494{
495    zval *zhash;
496    php_hash_data *hash;
497    zend_bool raw_output = 0;
498    zend_string *digest;
499    int digest_len;
500
501    if (zend_parse_parameters(ZEND_NUM_ARGS(), "r|b", &zhash, &raw_output) == FAILURE) {
502        return;
503    }
504
505    if ((hash = (php_hash_data *)zend_fetch_resource(Z_RES_P(zhash), PHP_HASH_RESNAME, php_hash_le_hash)) == NULL) {
506        RETURN_FALSE;
507    }
508
509    digest_len = hash->ops->digest_size;
510    digest = zend_string_alloc(digest_len, 0);
511    hash->ops->hash_final((unsigned char *) digest->val, hash->context);
512    if (hash->options & PHP_HASH_HMAC) {
513        int i;
514
515        /* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */
516        for(i=0; i < hash->ops->block_size; i++) {
517            hash->key[i] ^= 0x6A;
518        }
519
520        /* Feed this result into the outter hash */
521        hash->ops->hash_init(hash->context);
522        hash->ops->hash_update(hash->context, hash->key, hash->ops->block_size);
523        hash->ops->hash_update(hash->context, (unsigned char *) digest->val, hash->ops->digest_size);
524        hash->ops->hash_final((unsigned char *) digest->val, hash->context);
525
526        /* Zero the key */
527        ZEND_SECURE_ZERO(hash->key, hash->ops->block_size);
528        efree(hash->key);
529        hash->key = NULL;
530    }
531    digest->val[digest_len] = 0;
532    efree(hash->context);
533    hash->context = NULL;
534
535    //???
536    //??? /* zend_list_REAL_delete() */
537    //??? if (zend_hash_index_find(&EG(regular_list), Z_RESVAL_P(zhash), (void *) &le)==SUCCESS) {
538    //???   /* This is a hack to avoid letting the resource hide elsewhere (like in separated vars)
539    //???       FETCH_RESOURCE is intelligent enough to handle dealing with any issues this causes */
540    //???   le->refcount = 1;
541    //??? } /* FAILURE is not an option */
542    zend_list_close(Z_RES_P(zhash));
543
544    if (raw_output) {
545        RETURN_STR(digest);
546    } else {
547        zend_string *hex_digest = zend_string_safe_alloc(digest_len, 2, 0, 0);
548
549        php_hash_bin2hex(hex_digest->val, (unsigned char *) digest->val, digest_len);
550        hex_digest->val[2 * digest_len] = 0;
551        zend_string_release(digest);
552        RETURN_STR(hex_digest);
553    }
554}
555/* }}} */
556
557/* {{{ proto resource hash_copy(resource context)
558Copy hash resource */
559PHP_FUNCTION(hash_copy)
560{
561    zval *zhash;
562    php_hash_data *hash, *copy_hash;
563    void *context;
564    int res;
565
566    if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &zhash) == FAILURE) {
567        return;
568    }
569
570    if ((hash = (php_hash_data *)zend_fetch_resource(Z_RES_P(zhash), PHP_HASH_RESNAME, php_hash_le_hash)) == NULL) {
571        RETURN_FALSE;
572    }
573
574
575    context = emalloc(hash->ops->context_size);
576    hash->ops->hash_init(context);
577
578    res = hash->ops->hash_copy(hash->ops, hash->context, context);
579    if (res != SUCCESS) {
580        efree(context);
581        RETURN_FALSE;
582    }
583
584    copy_hash = emalloc(sizeof(php_hash_data));
585    copy_hash->ops = hash->ops;
586    copy_hash->context = context;
587    copy_hash->options = hash->options;
588    copy_hash->key = ecalloc(1, hash->ops->block_size);
589    if (hash->key) {
590        memcpy(copy_hash->key, hash->key, hash->ops->block_size);
591    }
592    RETURN_RES(zend_register_resource(copy_hash, php_hash_le_hash));
593}
594/* }}} */
595
596/* {{{ proto array hash_algos(void)
597Return a list of registered hashing algorithms */
598PHP_FUNCTION(hash_algos)
599{
600    zend_string *str;
601
602    array_init(return_value);
603    ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) {
604        add_next_index_str(return_value, zend_string_copy(str));
605    } ZEND_HASH_FOREACH_END();
606}
607/* }}} */
608
609/* {{{ proto string hash_pbkdf2(string algo, string password, string salt, int iterations [, int length = 0, bool raw_output = false])
610Generate a PBKDF2 hash of the given password and salt
611Returns lowercase hexits by default */
612PHP_FUNCTION(hash_pbkdf2)
613{
614    zend_string *returnval;
615    char *algo, *salt, *pass = NULL;
616    unsigned char *computed_salt, *digest, *temp, *result, *K1, *K2 = NULL;
617    zend_long loops, i, j, iterations, digest_length = 0, length = 0;
618    size_t algo_len, pass_len, salt_len = 0;
619    zend_bool raw_output = 0;
620    const php_hash_ops *ops;
621    void *context;
622
623    if (zend_parse_parameters(ZEND_NUM_ARGS(), "sssl|lb", &algo, &algo_len, &pass, &pass_len, &salt, &salt_len, &iterations, &length, &raw_output) == FAILURE) {
624        return;
625    }
626
627    ops = php_hash_fetch_ops(algo, algo_len);
628    if (!ops) {
629        php_error_docref(NULL, E_WARNING, "Unknown hashing algorithm: %s", algo);
630        RETURN_FALSE;
631    }
632
633    if (iterations <= 0) {
634        php_error_docref(NULL, E_WARNING, "Iterations must be a positive integer: " ZEND_LONG_FMT, iterations);
635        RETURN_FALSE;
636    }
637
638    if (length < 0) {
639        php_error_docref(NULL, E_WARNING, "Length must be greater than or equal to 0: " ZEND_LONG_FMT, length);
640        RETURN_FALSE;
641    }
642
643    if (salt_len > INT_MAX - 4) {
644        php_error_docref(NULL, E_WARNING, "Supplied salt is too long, max of INT_MAX - 4 bytes: %zd supplied", salt_len);
645        RETURN_FALSE;
646    }
647
648    context = emalloc(ops->context_size);
649    ops->hash_init(context);
650
651    K1 = emalloc(ops->block_size);
652    K2 = emalloc(ops->block_size);
653    digest = emalloc(ops->digest_size);
654    temp = emalloc(ops->digest_size);
655
656    /* Setup Keys that will be used for all hmac rounds */
657    php_hash_hmac_prep_key(K1, ops, context, (unsigned char *) pass, pass_len);
658    /* Convert K1 to opad -- 0x6A = 0x36 ^ 0x5C */
659    php_hash_string_xor_char(K2, K1, 0x6A, ops->block_size);
660
661    /* Setup Main Loop to build a long enough result */
662    if (length == 0) {
663        length = ops->digest_size;
664        if (!raw_output) {
665            length = length * 2;
666        }
667    }
668    digest_length = length;
669    if (!raw_output) {
670        digest_length = (zend_long) ceil((float) length / 2.0);
671    }
672
673    loops = (zend_long) ceil((float) digest_length / (float) ops->digest_size);
674
675    result = safe_emalloc(loops, ops->digest_size, 0);
676
677    computed_salt = safe_emalloc(salt_len, 1, 4);
678    memcpy(computed_salt, (unsigned char *) salt, salt_len);
679
680    for (i = 1; i <= loops; i++) {
681        /* digest = hash_hmac(salt + pack('N', i), password) { */
682
683        /* pack("N", i) */
684        computed_salt[salt_len] = (unsigned char) (i >> 24);
685        computed_salt[salt_len + 1] = (unsigned char) ((i & 0xFF0000) >> 16);
686        computed_salt[salt_len + 2] = (unsigned char) ((i & 0xFF00) >> 8);
687        computed_salt[salt_len + 3] = (unsigned char) (i & 0xFF);
688
689        php_hash_hmac_round(digest, ops, context, K1, computed_salt, (zend_long) salt_len + 4);
690        php_hash_hmac_round(digest, ops, context, K2, digest, ops->digest_size);
691        /* } */
692
693        /* temp = digest */
694        memcpy(temp, digest, ops->digest_size);
695
696        /*
697         * Note that the loop starting at 1 is intentional, since we've already done
698         * the first round of the algorithm.
699         */
700        for (j = 1; j < iterations; j++) {
701            /* digest = hash_hmac(digest, password) { */
702            php_hash_hmac_round(digest, ops, context, K1, digest, ops->digest_size);
703            php_hash_hmac_round(digest, ops, context, K2, digest, ops->digest_size);
704            /* } */
705            /* temp ^= digest */
706            php_hash_string_xor(temp, temp, digest, ops->digest_size);
707        }
708        /* result += temp */
709        memcpy(result + ((i - 1) * ops->digest_size), temp, ops->digest_size);
710    }
711    /* Zero potentially sensitive variables */
712    ZEND_SECURE_ZERO(K1, ops->block_size);
713    ZEND_SECURE_ZERO(K2, ops->block_size);
714    ZEND_SECURE_ZERO(computed_salt, salt_len + 4);
715    efree(K1);
716    efree(K2);
717    efree(computed_salt);
718    efree(context);
719    efree(digest);
720    efree(temp);
721
722    returnval = zend_string_alloc(length, 0);
723    if (raw_output) {
724        memcpy(returnval->val, result, length);
725    } else {
726        php_hash_bin2hex(returnval->val, result, digest_length);
727    }
728    returnval->val[length] = 0;
729    efree(result);
730    RETURN_STR(returnval);
731}
732/* }}} */
733
734/* {{{ proto bool hash_equals(string known_string, string user_string)
735   Compares two strings using the same time whether they're equal or not.
736   A difference in length will leak */
737PHP_FUNCTION(hash_equals)
738{
739    zval *known_zval, *user_zval;
740    char *known_str, *user_str;
741    int result = 0, j;
742
743    if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &known_zval, &user_zval) == FAILURE) {
744        return;
745    }
746
747    /* We only allow comparing string to prevent unexpected results. */
748    if (Z_TYPE_P(known_zval) != IS_STRING) {
749        php_error_docref(NULL, E_WARNING, "Expected known_string to be a string, %s given", zend_zval_type_name(known_zval));
750        RETURN_FALSE;
751    }
752
753    if (Z_TYPE_P(user_zval) != IS_STRING) {
754        php_error_docref(NULL, E_WARNING, "Expected user_string to be a string, %s given", zend_zval_type_name(user_zval));
755        RETURN_FALSE;
756    }
757
758    if (Z_STRLEN_P(known_zval) != Z_STRLEN_P(user_zval)) {
759        RETURN_FALSE;
760    }
761
762    known_str = Z_STRVAL_P(known_zval);
763    user_str = Z_STRVAL_P(user_zval);
764
765    /* This is security sensitive code. Do not optimize this for speed. */
766    for (j = 0; j < Z_STRLEN_P(known_zval); j++) {
767        result |= known_str[j] ^ user_str[j];
768    }
769
770    RETURN_BOOL(0 == result);
771}
772/* }}} */
773
774/* Module Housekeeping */
775
776static void php_hash_dtor(zend_resource *rsrc) /* {{{ */
777{
778    php_hash_data *hash = (php_hash_data*)rsrc->ptr;
779
780    /* Just in case the algo has internally allocated resources */
781    if (hash->context) {
782        unsigned char *dummy = emalloc(hash->ops->digest_size);
783        hash->ops->hash_final(dummy, hash->context);
784        efree(dummy);
785        efree(hash->context);
786    }
787
788    if (hash->key) {
789        memset(hash->key, 0, hash->ops->block_size);
790        efree(hash->key);
791    }
792    efree(hash);
793}
794/* }}} */
795
796#define PHP_HASH_HAVAL_REGISTER(p,b)    php_hash_register_algo("haval" #b "," #p , &php_hash_##p##haval##b##_ops);
797
798#ifdef PHP_MHASH_BC
799
800PHP_MINFO_FUNCTION(mhash)
801{
802    php_info_print_table_start();
803    php_info_print_table_row(2, "MHASH support", "Enabled");
804    php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
805    php_info_print_table_end();
806}
807
808zend_module_entry mhash_module_entry = {
809    STANDARD_MODULE_HEADER,
810    "mhash",
811    NULL,
812    NULL,
813    NULL,
814    NULL,
815    NULL,
816    PHP_MINFO(mhash),
817    NO_VERSION_YET,
818    STANDARD_MODULE_PROPERTIES,
819};
820
821static void mhash_init(INIT_FUNC_ARGS)
822{
823    char buf[128];
824    int len;
825    int algo_number = 0;
826
827    for (algo_number = 0; algo_number < MHASH_NUM_ALGOS; algo_number++) {
828        struct mhash_bc_entry algorithm = mhash_to_hash[algo_number];
829        if (algorithm.mhash_name == NULL) {
830            continue;
831        }
832
833        len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name, strlen(algorithm.mhash_name));
834        zend_register_long_constant(buf, len, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number);
835    }
836    zend_register_internal_module(&mhash_module_entry);
837}
838
839/* {{{ proto string mhash(int hash, string data [, string key])
840   Hash data with hash */
841PHP_FUNCTION(mhash)
842{
843    zval *z_algorithm;
844    zend_long algorithm;
845
846    if (zend_parse_parameters(1, "z", &z_algorithm) == FAILURE) {
847        return;
848    }
849
850    SEPARATE_ZVAL(z_algorithm);
851    convert_to_long_ex(z_algorithm);
852    algorithm = Z_LVAL_P(z_algorithm);
853
854    /* need to convert the first parameter from int constant to string algorithm name */
855    if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
856        struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
857        if (algorithm_lookup.hash_name) {
858            ZVAL_STRING(z_algorithm, algorithm_lookup.hash_name);
859        }
860    }
861
862    if (ZEND_NUM_ARGS() == 3) {
863        php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
864    } else if (ZEND_NUM_ARGS() == 2) {
865        php_hash_do_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 1);
866    } else {
867        WRONG_PARAM_COUNT;
868    }
869}
870/* }}} */
871
872/* {{{ proto string mhash_get_hash_name(int hash)
873   Gets the name of hash */
874PHP_FUNCTION(mhash_get_hash_name)
875{
876    zend_long algorithm;
877
878    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &algorithm) == FAILURE) {
879        return;
880    }
881
882    if (algorithm >= 0 && algorithm  < MHASH_NUM_ALGOS) {
883        struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
884        if (algorithm_lookup.mhash_name) {
885            RETURN_STRING(algorithm_lookup.mhash_name);
886        }
887    }
888    RETURN_FALSE;
889}
890/* }}} */
891
892/* {{{ proto int mhash_count(void)
893   Gets the number of available hashes */
894PHP_FUNCTION(mhash_count)
895{
896    if (zend_parse_parameters_none() == FAILURE) {
897        return;
898    }
899    RETURN_LONG(MHASH_NUM_ALGOS - 1);
900}
901/* }}} */
902
903/* {{{ proto int mhash_get_block_size(int hash)
904   Gets the block size of hash */
905PHP_FUNCTION(mhash_get_block_size)
906{
907    zend_long algorithm;
908
909    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &algorithm) == FAILURE) {
910        return;
911    }
912    RETVAL_FALSE;
913
914    if (algorithm >= 0 && algorithm  < MHASH_NUM_ALGOS) {
915        struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
916        if (algorithm_lookup.mhash_name) {
917            const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
918            if (ops) {
919                RETVAL_LONG(ops->digest_size);
920            }
921        }
922    }
923}
924/* }}} */
925
926#define SALT_SIZE 8
927
928/* {{{ proto string mhash_keygen_s2k(int hash, string input_password, string salt, int bytes)
929   Generates a key using hash functions */
930PHP_FUNCTION(mhash_keygen_s2k)
931{
932    zend_long algorithm, l_bytes;
933    int bytes;
934    char *password, *salt;
935    size_t password_len, salt_len;
936    char padded_salt[SALT_SIZE];
937
938    if (zend_parse_parameters(ZEND_NUM_ARGS(), "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) {
939        return;
940    }
941
942    bytes = (int)l_bytes;
943    if (bytes <= 0){
944        php_error_docref(NULL, E_WARNING, "the byte parameter must be greater than 0");
945        RETURN_FALSE;
946    }
947
948    salt_len = MIN(salt_len, SALT_SIZE);
949
950    memcpy(padded_salt, salt, salt_len);
951    if (salt_len < SALT_SIZE) {
952        memset(padded_salt + salt_len, 0, SALT_SIZE - salt_len);
953    }
954    salt_len = SALT_SIZE;
955
956    RETVAL_FALSE;
957    if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
958        struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
959        if (algorithm_lookup.mhash_name) {
960            const php_hash_ops *ops = php_hash_fetch_ops(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
961            if (ops) {
962                unsigned char null = '\0';
963                void *context;
964                char *key, *digest;
965                int i = 0, j = 0;
966                int block_size = ops->digest_size;
967                int times = bytes / block_size;
968                if (bytes % block_size  != 0) times++;
969
970                context = emalloc(ops->context_size);
971                ops->hash_init(context);
972
973                key = ecalloc(1, times * block_size);
974                digest = emalloc(ops->digest_size + 1);
975
976                for (i = 0; i < times; i++) {
977                    ops->hash_init(context);
978
979                    for (j=0;j<i;j++) {
980                        ops->hash_update(context, &null, 1);
981                    }
982                    ops->hash_update(context, (unsigned char *)padded_salt, salt_len);
983                    ops->hash_update(context, (unsigned char *)password, password_len);
984                    ops->hash_final((unsigned char *)digest, context);
985                    memcpy( &key[i*block_size], digest, block_size);
986                }
987
988                RETVAL_STRINGL(key, bytes);
989                ZEND_SECURE_ZERO(key, bytes);
990                efree(digest);
991                efree(context);
992                efree(key);
993            }
994        }
995    }
996}
997/* }}} */
998
999#endif
1000
1001/* {{{ PHP_MINIT_FUNCTION
1002 */
1003PHP_MINIT_FUNCTION(hash)
1004{
1005    php_hash_le_hash = zend_register_list_destructors_ex(php_hash_dtor, NULL, PHP_HASH_RESNAME, module_number);
1006
1007    zend_hash_init(&php_hash_hashtable, 35, NULL, NULL, 1);
1008
1009    php_hash_register_algo("md2",           &php_hash_md2_ops);
1010    php_hash_register_algo("md4",           &php_hash_md4_ops);
1011    php_hash_register_algo("md5",           &php_hash_md5_ops);
1012    php_hash_register_algo("sha1",          &php_hash_sha1_ops);
1013    php_hash_register_algo("sha224",        &php_hash_sha224_ops);
1014    php_hash_register_algo("sha256",        &php_hash_sha256_ops);
1015    php_hash_register_algo("sha384",        &php_hash_sha384_ops);
1016    php_hash_register_algo("sha512",        &php_hash_sha512_ops);
1017    php_hash_register_algo("ripemd128",     &php_hash_ripemd128_ops);
1018    php_hash_register_algo("ripemd160",     &php_hash_ripemd160_ops);
1019    php_hash_register_algo("ripemd256",     &php_hash_ripemd256_ops);
1020    php_hash_register_algo("ripemd320",     &php_hash_ripemd320_ops);
1021    php_hash_register_algo("whirlpool",     &php_hash_whirlpool_ops);
1022    php_hash_register_algo("tiger128,3",    &php_hash_3tiger128_ops);
1023    php_hash_register_algo("tiger160,3",    &php_hash_3tiger160_ops);
1024    php_hash_register_algo("tiger192,3",    &php_hash_3tiger192_ops);
1025    php_hash_register_algo("tiger128,4",    &php_hash_4tiger128_ops);
1026    php_hash_register_algo("tiger160,4",    &php_hash_4tiger160_ops);
1027    php_hash_register_algo("tiger192,4",    &php_hash_4tiger192_ops);
1028    php_hash_register_algo("snefru",        &php_hash_snefru_ops);
1029    php_hash_register_algo("snefru256",     &php_hash_snefru_ops);
1030    php_hash_register_algo("gost",          &php_hash_gost_ops);
1031    php_hash_register_algo("gost-crypto",       &php_hash_gost_crypto_ops);
1032    php_hash_register_algo("adler32",       &php_hash_adler32_ops);
1033    php_hash_register_algo("crc32",         &php_hash_crc32_ops);
1034    php_hash_register_algo("crc32b",        &php_hash_crc32b_ops);
1035    php_hash_register_algo("fnv132",        &php_hash_fnv132_ops);
1036    php_hash_register_algo("fnv1a32",       &php_hash_fnv1a32_ops);
1037    php_hash_register_algo("fnv164",        &php_hash_fnv164_ops);
1038    php_hash_register_algo("fnv1a64",       &php_hash_fnv1a64_ops);
1039    php_hash_register_algo("joaat",         &php_hash_joaat_ops);
1040
1041    PHP_HASH_HAVAL_REGISTER(3,128);
1042    PHP_HASH_HAVAL_REGISTER(3,160);
1043    PHP_HASH_HAVAL_REGISTER(3,192);
1044    PHP_HASH_HAVAL_REGISTER(3,224);
1045    PHP_HASH_HAVAL_REGISTER(3,256);
1046
1047    PHP_HASH_HAVAL_REGISTER(4,128);
1048    PHP_HASH_HAVAL_REGISTER(4,160);
1049    PHP_HASH_HAVAL_REGISTER(4,192);
1050    PHP_HASH_HAVAL_REGISTER(4,224);
1051    PHP_HASH_HAVAL_REGISTER(4,256);
1052
1053    PHP_HASH_HAVAL_REGISTER(5,128);
1054    PHP_HASH_HAVAL_REGISTER(5,160);
1055    PHP_HASH_HAVAL_REGISTER(5,192);
1056    PHP_HASH_HAVAL_REGISTER(5,224);
1057    PHP_HASH_HAVAL_REGISTER(5,256);
1058
1059    REGISTER_LONG_CONSTANT("HASH_HMAC",     PHP_HASH_HMAC,  CONST_CS | CONST_PERSISTENT);
1060
1061#ifdef PHP_MHASH_BC
1062    mhash_init(INIT_FUNC_ARGS_PASSTHRU);
1063#endif
1064
1065    return SUCCESS;
1066}
1067/* }}} */
1068
1069/* {{{ PHP_MSHUTDOWN_FUNCTION
1070 */
1071PHP_MSHUTDOWN_FUNCTION(hash)
1072{
1073    zend_hash_destroy(&php_hash_hashtable);
1074
1075    return SUCCESS;
1076}
1077/* }}} */
1078
1079/* {{{ PHP_MINFO_FUNCTION
1080 */
1081PHP_MINFO_FUNCTION(hash)
1082{
1083    char buffer[2048];
1084    zend_string *str;
1085    char *s = buffer, *e = s + sizeof(buffer);
1086
1087    ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) {
1088        s += slprintf(s, e - s, "%s ", str->val);
1089    } ZEND_HASH_FOREACH_END();
1090    *s = 0;
1091
1092    php_info_print_table_start();
1093    php_info_print_table_row(2, "hash support", "enabled");
1094    php_info_print_table_row(2, "Hashing Engines", buffer);
1095    php_info_print_table_end();
1096}
1097/* }}} */
1098
1099/* {{{ arginfo */
1100#ifdef PHP_HASH_MD5_NOT_IN_CORE
1101ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5, 0, 0, 1)
1102    ZEND_ARG_INFO(0, str)
1103    ZEND_ARG_INFO(0, raw_output)
1104ZEND_END_ARG_INFO()
1105
1106ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_md5_file, 0, 0, 1)
1107    ZEND_ARG_INFO(0, filename)
1108    ZEND_ARG_INFO(0, raw_output)
1109ZEND_END_ARG_INFO()
1110#endif
1111
1112#ifdef PHP_HASH_SHA1_NOT_IN_CORE
1113ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1, 0, 0, 1)
1114    ZEND_ARG_INFO(0, str)
1115    ZEND_ARG_INFO(0, raw_output)
1116ZEND_END_ARG_INFO()
1117
1118ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_sha1_file, 0, 0, 1)
1119    ZEND_ARG_INFO(0, filename)
1120    ZEND_ARG_INFO(0, raw_output)
1121ZEND_END_ARG_INFO()
1122#endif
1123
1124ZEND_BEGIN_ARG_INFO_EX(arginfo_hash, 0, 0, 2)
1125    ZEND_ARG_INFO(0, algo)
1126    ZEND_ARG_INFO(0, data)
1127    ZEND_ARG_INFO(0, raw_output)
1128ZEND_END_ARG_INFO()
1129
1130ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_file, 0, 0, 2)
1131    ZEND_ARG_INFO(0, algo)
1132    ZEND_ARG_INFO(0, filename)
1133    ZEND_ARG_INFO(0, raw_output)
1134ZEND_END_ARG_INFO()
1135
1136ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac, 0, 0, 3)
1137    ZEND_ARG_INFO(0, algo)
1138    ZEND_ARG_INFO(0, data)
1139    ZEND_ARG_INFO(0, key)
1140    ZEND_ARG_INFO(0, raw_output)
1141ZEND_END_ARG_INFO()
1142
1143ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_hmac_file, 0, 0, 3)
1144    ZEND_ARG_INFO(0, algo)
1145    ZEND_ARG_INFO(0, filename)
1146    ZEND_ARG_INFO(0, key)
1147    ZEND_ARG_INFO(0, raw_output)
1148ZEND_END_ARG_INFO()
1149
1150ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_init, 0, 0, 1)
1151    ZEND_ARG_INFO(0, algo)
1152    ZEND_ARG_INFO(0, options)
1153    ZEND_ARG_INFO(0, key)
1154ZEND_END_ARG_INFO()
1155
1156ZEND_BEGIN_ARG_INFO(arginfo_hash_update, 0)
1157    ZEND_ARG_INFO(0, context)
1158    ZEND_ARG_INFO(0, data)
1159ZEND_END_ARG_INFO()
1160
1161ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_stream, 0, 0, 2)
1162    ZEND_ARG_INFO(0, context)
1163    ZEND_ARG_INFO(0, handle)
1164    ZEND_ARG_INFO(0, length)
1165ZEND_END_ARG_INFO()
1166
1167ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_update_file, 0, 0, 2)
1168    ZEND_ARG_INFO(0, context)
1169    ZEND_ARG_INFO(0, filename)
1170    ZEND_ARG_INFO(0, context)
1171ZEND_END_ARG_INFO()
1172
1173ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_final, 0, 0, 1)
1174    ZEND_ARG_INFO(0, context)
1175    ZEND_ARG_INFO(0, raw_output)
1176ZEND_END_ARG_INFO()
1177
1178ZEND_BEGIN_ARG_INFO(arginfo_hash_copy, 0)
1179    ZEND_ARG_INFO(0, context)
1180ZEND_END_ARG_INFO()
1181
1182ZEND_BEGIN_ARG_INFO(arginfo_hash_algos, 0)
1183ZEND_END_ARG_INFO()
1184
1185ZEND_BEGIN_ARG_INFO_EX(arginfo_hash_pbkdf2, 0, 0, 4)
1186    ZEND_ARG_INFO(0, algo)
1187    ZEND_ARG_INFO(0, password)
1188    ZEND_ARG_INFO(0, salt)
1189    ZEND_ARG_INFO(0, iterations)
1190    ZEND_ARG_INFO(0, length)
1191    ZEND_ARG_INFO(0, raw_output)
1192ZEND_END_ARG_INFO()
1193
1194ZEND_BEGIN_ARG_INFO(arginfo_hash_equals, 0)
1195    ZEND_ARG_INFO(0, known_string)
1196    ZEND_ARG_INFO(0, user_string)
1197ZEND_END_ARG_INFO()
1198
1199/* BC Land */
1200#ifdef PHP_MHASH_BC
1201ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_block_size, 0)
1202    ZEND_ARG_INFO(0, hash)
1203ZEND_END_ARG_INFO()
1204
1205ZEND_BEGIN_ARG_INFO(arginfo_mhash_get_hash_name, 0)
1206    ZEND_ARG_INFO(0, hash)
1207ZEND_END_ARG_INFO()
1208
1209ZEND_BEGIN_ARG_INFO(arginfo_mhash_keygen_s2k, 0)
1210    ZEND_ARG_INFO(0, hash)
1211    ZEND_ARG_INFO(0, input_password)
1212    ZEND_ARG_INFO(0, salt)
1213    ZEND_ARG_INFO(0, bytes)
1214ZEND_END_ARG_INFO()
1215
1216ZEND_BEGIN_ARG_INFO(arginfo_mhash_count, 0)
1217ZEND_END_ARG_INFO()
1218
1219ZEND_BEGIN_ARG_INFO_EX(arginfo_mhash, 0, 0, 2)
1220    ZEND_ARG_INFO(0, hash)
1221    ZEND_ARG_INFO(0, data)
1222    ZEND_ARG_INFO(0, key)
1223ZEND_END_ARG_INFO()
1224#endif
1225
1226/* }}} */
1227
1228/* {{{ hash_functions[]
1229 */
1230const zend_function_entry hash_functions[] = {
1231    PHP_FE(hash,                                    arginfo_hash)
1232    PHP_FE(hash_file,                               arginfo_hash_file)
1233
1234    PHP_FE(hash_hmac,                               arginfo_hash_hmac)
1235    PHP_FE(hash_hmac_file,                          arginfo_hash_hmac_file)
1236
1237    PHP_FE(hash_init,                               arginfo_hash_init)
1238    PHP_FE(hash_update,                             arginfo_hash_update)
1239    PHP_FE(hash_update_stream,                      arginfo_hash_update_stream)
1240    PHP_FE(hash_update_file,                        arginfo_hash_update_file)
1241    PHP_FE(hash_final,                              arginfo_hash_final)
1242    PHP_FE(hash_copy,                               arginfo_hash_copy)
1243
1244    PHP_FE(hash_algos,                              arginfo_hash_algos)
1245    PHP_FE(hash_pbkdf2,                             arginfo_hash_pbkdf2)
1246    PHP_FE(hash_equals,                             arginfo_hash_equals)
1247
1248    /* BC Land */
1249#ifdef PHP_HASH_MD5_NOT_IN_CORE
1250    PHP_NAMED_FE(md5, php_if_md5,                   arginfo_hash_md5)
1251    PHP_NAMED_FE(md5_file, php_if_md5_file,         arginfo_hash_md5_file)
1252#endif /* PHP_HASH_MD5_NOT_IN_CORE */
1253
1254#ifdef PHP_HASH_SHA1_NOT_IN_CORE
1255    PHP_NAMED_FE(sha1, php_if_sha1,                 arginfo_hash_sha1)
1256    PHP_NAMED_FE(sha1_file, php_if_sha1_file,       arginfo_hash_sha1_file)
1257#endif /* PHP_HASH_SHA1_NOT_IN_CORE */
1258
1259#ifdef PHP_MHASH_BC
1260    PHP_FE(mhash_keygen_s2k, arginfo_mhash_keygen_s2k)
1261    PHP_FE(mhash_get_block_size, arginfo_mhash_get_block_size)
1262    PHP_FE(mhash_get_hash_name, arginfo_mhash_get_hash_name)
1263    PHP_FE(mhash_count, arginfo_mhash_count)
1264    PHP_FE(mhash, arginfo_mhash)
1265#endif
1266
1267    PHP_FE_END
1268};
1269/* }}} */
1270
1271/* {{{ hash_module_entry
1272 */
1273zend_module_entry hash_module_entry = {
1274#if ZEND_MODULE_API_NO >= 20010901
1275    STANDARD_MODULE_HEADER,
1276#endif
1277    PHP_HASH_EXTNAME,
1278    hash_functions,
1279    PHP_MINIT(hash),
1280    PHP_MSHUTDOWN(hash),
1281    NULL, /* RINIT */
1282    NULL, /* RSHUTDOWN */
1283    PHP_MINFO(hash),
1284#if ZEND_MODULE_API_NO >= 20010901
1285    PHP_HASH_EXTVER, /* Replace with version number for your extension */
1286#endif
1287    STANDARD_MODULE_PROPERTIES
1288};
1289/* }}} */
1290
1291#ifdef COMPILE_DL_HASH
1292ZEND_GET_MODULE(hash)
1293#endif
1294
1295/*
1296 * Local variables:
1297 * tab-width: 4
1298 * c-basic-offset: 4
1299 * End:
1300 * vim600: noet sw=4 ts=4 fdm=marker
1301 * vim<600: noet sw=4 ts=4
1302 */
1303
1304