xref: /php-src/ext/hash/hash.c (revision ac54d1c0)
1 /*
2   +----------------------------------------------------------------------+
3   | Copyright (c) The PHP Group                                          |
4   +----------------------------------------------------------------------+
5   | This source file is subject to version 3.01 of the PHP license,      |
6   | that is bundled with this package in the file LICENSE, and is        |
7   | available through the world-wide-web at the following url:           |
8   | https://www.php.net/license/3_01.txt                                 |
9   | If you did not receive a copy of the PHP license and are unable to   |
10   | obtain it through the world-wide-web, please send a note to          |
11   | license@php.net so we can mail you a copy immediately.               |
12   +----------------------------------------------------------------------+
13   | Author: Sara Golemon <pollita@php.net>                               |
14   |         Scott MacVicar <scottmac@php.net>                            |
15   +----------------------------------------------------------------------+
16 */
17 
18 #ifdef HAVE_CONFIG_H
19 #include <config.h>
20 #endif
21 
22 #include <math.h>
23 #include "php_hash.h"
24 #include "ext/standard/info.h"
25 #include "ext/standard/file.h"
26 #include "ext/standard/php_var.h"
27 
28 #include "zend_attributes.h"
29 #include "zend_exceptions.h"
30 #include "zend_interfaces.h"
31 #include "zend_smart_str.h"
32 
33 #include "hash_arginfo.h"
34 
35 #ifdef PHP_WIN32
36 # define __alignof__ __alignof
37 #else
38 # ifndef HAVE_ALIGNOF
39 #  include <stddef.h>
40 #  define __alignof__(type) offsetof (struct { char c; type member;}, member)
41 # endif
42 #endif
43 
44 static HashTable php_hash_hashtable;
45 zend_class_entry *php_hashcontext_ce;
46 static zend_object_handlers php_hashcontext_handlers;
47 
48 #ifdef PHP_MHASH_BC
49 struct mhash_bc_entry {
50 	char *mhash_name;
51 	char *hash_name;
52 	int value;
53 };
54 
55 #define MHASH_NUM_ALGOS 42
56 
57 static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {
58 	{"CRC32", "crc32", 0}, /* used by bzip */
59 	{"MD5", "md5", 1},
60 	{"SHA1", "sha1", 2},
61 	{"HAVAL256", "haval256,3", 3},
62 	{NULL, NULL, 4},
63 	{"RIPEMD160", "ripemd160", 5},
64 	{NULL, NULL, 6},
65 	{"TIGER", "tiger192,3", 7},
66 	{"GOST", "gost", 8},
67 	{"CRC32B", "crc32b", 9}, /* used by ethernet (IEEE 802.3), gzip, zip, png, etc */
68 	{"HAVAL224", "haval224,3", 10},
69 	{"HAVAL192", "haval192,3", 11},
70 	{"HAVAL160", "haval160,3", 12},
71 	{"HAVAL128", "haval128,3", 13},
72 	{"TIGER128", "tiger128,3", 14},
73 	{"TIGER160", "tiger160,3", 15},
74 	{"MD4", "md4", 16},
75 	{"SHA256", "sha256", 17},
76 	{"ADLER32", "adler32", 18},
77 	{"SHA224", "sha224", 19},
78 	{"SHA512", "sha512", 20},
79 	{"SHA384", "sha384", 21},
80 	{"WHIRLPOOL", "whirlpool", 22},
81 	{"RIPEMD128", "ripemd128", 23},
82 	{"RIPEMD256", "ripemd256", 24},
83 	{"RIPEMD320", "ripemd320", 25},
84 	{NULL, NULL, 26}, /* support needs to be added for snefru 128 */
85 	{"SNEFRU256", "snefru256", 27},
86 	{"MD2", "md2", 28},
87 	{"FNV132", "fnv132", 29},
88 	{"FNV1A32", "fnv1a32", 30},
89 	{"FNV164", "fnv164", 31},
90 	{"FNV1A64", "fnv1a64", 32},
91 	{"JOAAT", "joaat", 33},
92 	{"CRC32C", "crc32c", 34}, /* Castagnoli's CRC, used by iSCSI, SCTP, Btrfs, ext4, etc */
93 	{"MURMUR3A", "murmur3a", 35},
94 	{"MURMUR3C", "murmur3c", 36},
95 	{"MURMUR3F", "murmur3f", 37},
96 	{"XXH32", "xxh32", 38},
97 	{"XXH64", "xxh64", 39},
98 	{"XXH3", "xxh3", 40},
99 	{"XXH128", "xxh128", 41},
100 };
101 #endif
102 
103 /* Hash Registry Access */
104 
php_hash_fetch_ops(zend_string * algo)105 PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(zend_string *algo) /* {{{ */
106 {
107 	zend_string *lower = zend_string_tolower(algo);
108 	php_hash_ops *ops = zend_hash_find_ptr(&php_hash_hashtable, lower);
109 	zend_string_release(lower);
110 
111 	return ops;
112 }
113 /* }}} */
114 
php_hash_register_algo(const char * algo,const php_hash_ops * ops)115 PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops) /* {{{ */
116 {
117 	size_t algo_len = strlen(algo);
118 	char *lower = zend_str_tolower_dup(algo, algo_len);
119 	zend_hash_add_ptr(&php_hash_hashtable, zend_string_init_interned(lower, algo_len, 1), (void *) ops);
120 	efree(lower);
121 }
122 /* }}} */
123 
php_hash_copy(const void * ops,void * orig_context,void * dest_context)124 PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_context) /* {{{ */
125 {
126 	php_hash_ops *hash_ops = (php_hash_ops *)ops;
127 
128 	memcpy(dest_context, orig_context, hash_ops->context_size);
129 	return SUCCESS;
130 }
131 /* }}} */
132 
133 
align_to(size_t pos,size_t alignment)134 static inline size_t align_to(size_t pos, size_t alignment) {
135 	size_t offset = pos & (alignment - 1);
136 	return pos + (offset ? alignment - offset : 0);
137 }
138 
parse_serialize_spec(const char ** specp,size_t * pos,size_t * sz,size_t * max_alignment)139 static size_t parse_serialize_spec(
140 		const char **specp, size_t *pos, size_t *sz, size_t *max_alignment) {
141 	size_t count, alignment;
142 	const char *spec = *specp;
143 	/* parse size */
144 	if (*spec == 's' || *spec == 'S') {
145 		*sz = 2;
146 		alignment = __alignof__(uint16_t); /* usually 2 */
147 	} else if (*spec == 'l' || *spec == 'L') {
148 		*sz = 4;
149 		alignment = __alignof__(uint32_t); /* usually 4 */
150 	} else if (*spec == 'q' || *spec == 'Q') {
151 		*sz = 8;
152 		alignment = __alignof__(uint64_t); /* usually 8 */
153 	} else if (*spec == 'i' || *spec == 'I') {
154 		*sz = sizeof(int);
155 		alignment = __alignof__(int);      /* usually 4 */
156 	} else {
157 		ZEND_ASSERT(*spec == 'b' || *spec == 'B');
158 		*sz = 1;
159 		alignment = 1;
160 	}
161 	/* process alignment */
162 	*pos = align_to(*pos, alignment);
163 	*max_alignment = *max_alignment < alignment ? alignment : *max_alignment;
164 	/* parse count */
165 	++spec;
166 	if (isdigit((unsigned char) *spec)) {
167 		count = 0;
168 		while (isdigit((unsigned char) *spec)) {
169 			count = 10 * count + *spec - '0';
170 			++spec;
171 		}
172 	} else {
173 		count = 1;
174 	}
175 	*specp = spec;
176 	return count;
177 }
178 
one_from_buffer(size_t sz,const unsigned char * buf)179 static uint64_t one_from_buffer(size_t sz, const unsigned char *buf) {
180 	if (sz == 2) {
181 		const uint16_t *x = (const uint16_t *) buf;
182 		return *x;
183 	} else if (sz == 4) {
184 		const uint32_t *x = (const uint32_t *) buf;
185 		return *x;
186 	} else if (sz == 8) {
187 		const uint64_t *x = (const uint64_t *) buf;
188 		return *x;
189 	} else {
190 		ZEND_ASSERT(sz == 1);
191 		return *buf;
192 	}
193 }
194 
one_to_buffer(size_t sz,unsigned char * buf,uint64_t val)195 static void one_to_buffer(size_t sz, unsigned char *buf, uint64_t val) {
196 	if (sz == 2) {
197 		uint16_t *x = (uint16_t *) buf;
198 		*x = val;
199 	} else if (sz == 4) {
200 		uint32_t *x = (uint32_t *) buf;
201 		*x = val;
202 	} else if (sz == 8) {
203 		uint64_t *x = (uint64_t *) buf;
204 		*x = val;
205 	} else {
206 		ZEND_ASSERT(sz == 1);
207 		*buf = val;
208 	}
209 }
210 
211 /* Serialize a hash context according to a `spec` string.
212    Spec contents:
213    b[COUNT] -- serialize COUNT bytes
214    s[COUNT] -- serialize COUNT 16-bit integers
215    l[COUNT] -- serialize COUNT 32-bit integers
216    q[COUNT] -- serialize COUNT 64-bit integers
217    i[COUNT] -- serialize COUNT `int`s
218    B[COUNT] -- skip COUNT bytes
219    S[COUNT], L[COUNT], etc. -- uppercase versions skip instead of read
220    . (must be last character) -- assert that the hash context has exactly
221        this size
222    Example: "llllllb64l16." is the spec for an MD5 context: 6 32-bit
223    integers, followed by 64 bytes, then 16 32-bit integers, and that's
224    exactly the size of the context.
225 
226    The serialization result is an array. Each integer is serialized as a
227    32-bit integer, except that a run of 2 or more bytes is encoded as a
228    string, and each 64-bit integer is serialized as two 32-bit integers, least
229    significant bits first. This allows 32-bit and 64-bit architectures to
230    interchange serialized HashContexts. */
231 
php_hash_serialize_spec(const php_hashcontext_object * hash,zval * zv,const char * spec)232 PHP_HASH_API int php_hash_serialize_spec(const php_hashcontext_object *hash, zval *zv, const char *spec) /* {{{ */
233 {
234 	size_t pos = 0, max_alignment = 1;
235 	unsigned char *buf = (unsigned char *) hash->context;
236 	zval tmp;
237 	if (buf == NULL) {
238 		return FAILURE;
239 	}
240 	array_init(zv);
241 	while (*spec != '\0' && *spec != '.') {
242 		char spec_ch = *spec;
243 		size_t sz, count = parse_serialize_spec(&spec, &pos, &sz, &max_alignment);
244 		if (pos + count * sz > hash->ops->context_size) {
245 			return FAILURE;
246 		}
247 		if (isupper((unsigned char) spec_ch)) {
248 			pos += count * sz;
249 		} else if (sz == 1 && count > 1) {
250 			ZVAL_STRINGL(&tmp, (char *) buf + pos, count);
251 			zend_hash_next_index_insert(Z_ARRVAL_P(zv), &tmp);
252 			pos += count;
253 		} else {
254 			while (count > 0) {
255 				uint64_t val = one_from_buffer(sz, buf + pos);
256 				pos += sz;
257 				ZVAL_LONG(&tmp, (int32_t) val);
258 				zend_hash_next_index_insert(Z_ARRVAL_P(zv), &tmp);
259 				if (sz == 8) {
260 					ZVAL_LONG(&tmp, (int32_t) (val >> 32));
261 					zend_hash_next_index_insert(Z_ARRVAL_P(zv), &tmp);
262 				}
263 				--count;
264 			}
265 		}
266 	}
267 	if (*spec == '.' && align_to(pos, max_alignment) != hash->ops->context_size) {
268 		return FAILURE;
269 	}
270 	return SUCCESS;
271 }
272 /* }}} */
273 
274 /* Unserialize a hash context serialized by `php_hash_serialize_spec` with `spec`.
275    Returns SUCCESS on success and a negative error code on failure.
276    Codes: FAILURE (-1) == generic failure
277    -999 == spec wrong size for context
278    -1000 - POS == problem at byte offset POS */
279 
php_hash_unserialize_spec(php_hashcontext_object * hash,const zval * zv,const char * spec)280 PHP_HASH_API int php_hash_unserialize_spec(php_hashcontext_object *hash, const zval *zv, const char *spec) /* {{{ */
281 {
282 	size_t pos = 0, max_alignment = 1, j = 0;
283 	unsigned char *buf = (unsigned char *) hash->context;
284 	zval *elt;
285 	if (Z_TYPE_P(zv) != IS_ARRAY) {
286 		return FAILURE;
287 	}
288 	while (*spec != '\0' && *spec != '.') {
289 		char spec_ch = *spec;
290 		size_t sz, count = parse_serialize_spec(&spec, &pos, &sz, &max_alignment);
291 		if (pos + count * sz > hash->ops->context_size) {
292 			return -999;
293 		}
294 		if (isupper((unsigned char) spec_ch)) {
295 			pos += count * sz;
296 		} else if (sz == 1 && count > 1) {
297 			elt = zend_hash_index_find(Z_ARRVAL_P(zv), j);
298 			if (!elt || Z_TYPE_P(elt) != IS_STRING || Z_STRLEN_P(elt) != count) {
299 				return -1000 - pos;
300 			}
301 			++j;
302 			memcpy(buf + pos, Z_STRVAL_P(elt), count);
303 			pos += count;
304 		} else {
305 			while (count > 0) {
306 				uint64_t val;
307 				elt = zend_hash_index_find(Z_ARRVAL_P(zv), j);
308 				if (!elt || Z_TYPE_P(elt) != IS_LONG) {
309 					return -1000 - pos;
310 				}
311 				++j;
312 				val = (uint32_t) Z_LVAL_P(elt);
313 				if (sz == 8) {
314 					elt = zend_hash_index_find(Z_ARRVAL_P(zv), j);
315 					if (!elt || Z_TYPE_P(elt) != IS_LONG) {
316 						return -1000 - pos;
317 					}
318 					++j;
319 					val += ((uint64_t) Z_LVAL_P(elt)) << 32;
320 				}
321 				one_to_buffer(sz, buf + pos, val);
322 				pos += sz;
323 				--count;
324 			}
325 		}
326 	}
327 	if (*spec == '.' && align_to(pos, max_alignment) != hash->ops->context_size) {
328 		return -999;
329 	}
330 	return SUCCESS;
331 }
332 /* }}} */
333 
php_hash_serialize(const php_hashcontext_object * hash,zend_long * magic,zval * zv)334 PHP_HASH_API int php_hash_serialize(const php_hashcontext_object *hash, zend_long *magic, zval *zv) /* {{{ */
335 {
336 	if (hash->ops->serialize_spec) {
337 		*magic = PHP_HASH_SERIALIZE_MAGIC_SPEC;
338 		return php_hash_serialize_spec(hash, zv, hash->ops->serialize_spec);
339 	} else {
340 		return FAILURE;
341 	}
342 }
343 /* }}} */
344 
php_hash_unserialize(php_hashcontext_object * hash,zend_long magic,const zval * zv)345 PHP_HASH_API int php_hash_unserialize(php_hashcontext_object *hash, zend_long magic, const zval *zv) /* {{{ */
346 {
347 	if (hash->ops->serialize_spec
348 		&& magic == PHP_HASH_SERIALIZE_MAGIC_SPEC) {
349 		return php_hash_unserialize_spec(hash, zv, hash->ops->serialize_spec);
350 	} else {
351 		return FAILURE;
352 	}
353 }
354 /* }}} */
355 
356 /* Userspace */
357 
php_hash_do_hash(zval * return_value,zend_string * algo,char * data,size_t data_len,bool raw_output,bool isfilename,HashTable * args)358 static void php_hash_do_hash(
359 	zval *return_value, zend_string *algo, char *data, size_t data_len, bool raw_output, bool isfilename, HashTable *args
360 ) /* {{{ */ {
361 	zend_string *digest;
362 	const php_hash_ops *ops;
363 	void *context;
364 	php_stream *stream = NULL;
365 
366 	ops = php_hash_fetch_ops(algo);
367 	if (!ops) {
368 		zend_argument_value_error(1, "must be a valid hashing algorithm");
369 		RETURN_THROWS();
370 	}
371 	if (isfilename) {
372 		if (CHECK_NULL_PATH(data, data_len)) {
373 			zend_argument_value_error(1, "must not contain any null bytes");
374 			RETURN_THROWS();
375 		}
376 		stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, FG(default_context));
377 		if (!stream) {
378 			/* Stream will report errors opening file */
379 			RETURN_FALSE;
380 		}
381 	}
382 
383 	context = php_hash_alloc_context(ops);
384 	ops->hash_init(context, args);
385 
386 	if (isfilename) {
387 		char buf[1024];
388 		ssize_t n;
389 
390 		while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
391 			ops->hash_update(context, (unsigned char *) buf, n);
392 		}
393 		php_stream_close(stream);
394 		if (n < 0) {
395 			efree(context);
396 			RETURN_FALSE;
397 		}
398 	} else {
399 		ops->hash_update(context, (unsigned char *) data, data_len);
400 	}
401 
402 	digest = zend_string_alloc(ops->digest_size, 0);
403 	ops->hash_final((unsigned char *) ZSTR_VAL(digest), context);
404 	efree(context);
405 
406 	if (raw_output) {
407 		ZSTR_VAL(digest)[ops->digest_size] = 0;
408 		RETURN_NEW_STR(digest);
409 	} else {
410 		zend_string *hex_digest = zend_string_safe_alloc(ops->digest_size, 2, 0, 0);
411 
412 		php_hash_bin2hex(ZSTR_VAL(hex_digest), (unsigned char *) ZSTR_VAL(digest), ops->digest_size);
413 		ZSTR_VAL(hex_digest)[2 * ops->digest_size] = 0;
414 		zend_string_release_ex(digest, 0);
415 		RETURN_NEW_STR(hex_digest);
416 	}
417 }
418 /* }}} */
419 
420 /* {{{ Generate a hash of a given input string
421 Returns lowercase hexits by default */
PHP_FUNCTION(hash)422 PHP_FUNCTION(hash)
423 {
424 	zend_string *algo;
425 	char *data;
426 	size_t data_len;
427 	bool raw_output = 0;
428 	HashTable *args = NULL;
429 
430 	ZEND_PARSE_PARAMETERS_START(2, 4)
431 		Z_PARAM_STR(algo)
432 		Z_PARAM_STRING(data, data_len)
433 		Z_PARAM_OPTIONAL
434 		Z_PARAM_BOOL(raw_output)
435 		Z_PARAM_ARRAY_HT(args)
436 	ZEND_PARSE_PARAMETERS_END();
437 
438 	php_hash_do_hash(return_value, algo, data, data_len, raw_output, 0, args);
439 }
440 /* }}} */
441 
442 /* {{{ Generate a hash of a given file
443 Returns lowercase hexits by default */
PHP_FUNCTION(hash_file)444 PHP_FUNCTION(hash_file)
445 {
446 	zend_string *algo;
447 	char *data;
448 	size_t data_len;
449 	bool raw_output = 0;
450 	HashTable *args = NULL;
451 
452 	ZEND_PARSE_PARAMETERS_START(2, 4)
453 		Z_PARAM_STR(algo)
454 		Z_PARAM_STRING(data, data_len)
455 		Z_PARAM_OPTIONAL
456 		Z_PARAM_BOOL(raw_output)
457 		Z_PARAM_ARRAY_HT(args)
458 	ZEND_PARSE_PARAMETERS_END();
459 
460 	php_hash_do_hash(return_value, algo, data, data_len, raw_output, 1, args);
461 }
462 /* }}} */
463 
php_hash_string_xor_char(unsigned char * out,const unsigned char * in,const unsigned char xor_with,const size_t length)464 static inline void php_hash_string_xor_char(unsigned char *out, const unsigned char *in, const unsigned char xor_with, const size_t length) {
465 	size_t i;
466 	for (i=0; i < length; i++) {
467 		out[i] = in[i] ^ xor_with;
468 	}
469 }
470 
php_hash_string_xor(unsigned char * out,const unsigned char * in,const unsigned char * xor_with,const size_t length)471 static inline void php_hash_string_xor(unsigned char *out, const unsigned char *in, const unsigned char *xor_with, const size_t length) {
472 	size_t i;
473 	for (i=0; i < length; i++) {
474 		out[i] = in[i] ^ xor_with[i];
475 	}
476 }
477 
php_hash_hmac_prep_key(unsigned char * K,const php_hash_ops * ops,void * context,const unsigned char * key,const size_t key_len)478 static 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) {
479 	memset(K, 0, ops->block_size);
480 	if (key_len > ops->block_size) {
481 		/* Reduce the key first */
482 		ops->hash_init(context, NULL);
483 		ops->hash_update(context, key, key_len);
484 		ops->hash_final(K, context);
485 	} else {
486 		memcpy(K, key, key_len);
487 	}
488 	/* XOR the key with 0x36 to get the ipad) */
489 	php_hash_string_xor_char(K, K, 0x36, ops->block_size);
490 }
491 
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)492 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) {
493 	ops->hash_init(context, NULL);
494 	ops->hash_update(context, key, ops->block_size);
495 	ops->hash_update(context, data, data_size);
496 	ops->hash_final(final, context);
497 }
498 
php_hash_do_hash_hmac(zval * return_value,zend_string * algo,char * data,size_t data_len,char * key,size_t key_len,bool raw_output,bool isfilename)499 static void php_hash_do_hash_hmac(
500 	zval *return_value, zend_string *algo, char *data, size_t data_len, char *key, size_t key_len, bool raw_output, bool isfilename
501 ) /* {{{ */ {
502 	zend_string *digest;
503 	unsigned char *K;
504 	const php_hash_ops *ops;
505 	void *context;
506 	php_stream *stream = NULL;
507 
508 	ops = php_hash_fetch_ops(algo);
509 	if (!ops || !ops->is_crypto) {
510 		zend_argument_value_error(1, "must be a valid cryptographic hashing algorithm");
511 		RETURN_THROWS();
512 	}
513 
514 	if (isfilename) {
515 		if (CHECK_NULL_PATH(data, data_len)) {
516 			zend_argument_value_error(2, "must not contain any null bytes");
517 			RETURN_THROWS();
518 		}
519 		stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, FG(default_context));
520 		if (!stream) {
521 			/* Stream will report errors opening file */
522 			RETURN_FALSE;
523 		}
524 	}
525 
526 	context = php_hash_alloc_context(ops);
527 
528 	K = emalloc(ops->block_size);
529 	digest = zend_string_alloc(ops->digest_size, 0);
530 
531 	php_hash_hmac_prep_key(K, ops, context, (unsigned char *) key, key_len);
532 
533 	if (isfilename) {
534 		char buf[1024];
535 		ssize_t n;
536 		ops->hash_init(context, NULL);
537 		ops->hash_update(context, K, ops->block_size);
538 		while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
539 			ops->hash_update(context, (unsigned char *) buf, n);
540 		}
541 		php_stream_close(stream);
542 		if (n < 0) {
543 			efree(context);
544 			efree(K);
545 			zend_string_release(digest);
546 			RETURN_FALSE;
547 		}
548 
549 		ops->hash_final((unsigned char *) ZSTR_VAL(digest), context);
550 	} else {
551 		php_hash_hmac_round((unsigned char *) ZSTR_VAL(digest), ops, context, K, (unsigned char *) data, data_len);
552 	}
553 
554 	php_hash_string_xor_char(K, K, 0x6A, ops->block_size);
555 
556 	php_hash_hmac_round((unsigned char *) ZSTR_VAL(digest), ops, context, K, (unsigned char *) ZSTR_VAL(digest), ops->digest_size);
557 
558 	/* Zero the key */
559 	ZEND_SECURE_ZERO(K, ops->block_size);
560 	efree(K);
561 	efree(context);
562 
563 	if (raw_output) {
564 		ZSTR_VAL(digest)[ops->digest_size] = 0;
565 		RETURN_NEW_STR(digest);
566 	} else {
567 		zend_string *hex_digest = zend_string_safe_alloc(ops->digest_size, 2, 0, 0);
568 
569 		php_hash_bin2hex(ZSTR_VAL(hex_digest), (unsigned char *) ZSTR_VAL(digest), ops->digest_size);
570 		ZSTR_VAL(hex_digest)[2 * ops->digest_size] = 0;
571 		zend_string_release_ex(digest, 0);
572 		RETURN_NEW_STR(hex_digest);
573 	}
574 }
575 /* }}} */
576 
577 /* {{{ Generate a hash of a given input string with a key using HMAC
578 Returns lowercase hexits by default */
PHP_FUNCTION(hash_hmac)579 PHP_FUNCTION(hash_hmac)
580 {
581 	zend_string *algo;
582 	char *data, *key;
583 	size_t data_len, key_len;
584 	bool raw_output = 0;
585 
586 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sss|b", &algo, &data, &data_len, &key, &key_len, &raw_output) == FAILURE) {
587 		RETURN_THROWS();
588 	}
589 
590 	php_hash_do_hash_hmac(return_value, algo, data, data_len, key, key_len, raw_output, 0);
591 }
592 /* }}} */
593 
594 /* {{{ Generate a hash of a given file with a key using HMAC
595 Returns lowercase hexits by default */
PHP_FUNCTION(hash_hmac_file)596 PHP_FUNCTION(hash_hmac_file)
597 {
598 	zend_string *algo;
599 	char *data, *key;
600 	size_t data_len, key_len;
601 	bool raw_output = 0;
602 
603 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sss|b", &algo, &data, &data_len, &key, &key_len, &raw_output) == FAILURE) {
604 		RETURN_THROWS();
605 	}
606 
607 	php_hash_do_hash_hmac(return_value, algo, data, data_len, key, key_len, raw_output, 1);
608 }
609 /* }}} */
610 
611 /* {{{ Initialize a hashing context */
PHP_FUNCTION(hash_init)612 PHP_FUNCTION(hash_init)
613 {
614 	zend_string *algo, *key = NULL;
615 	zend_long options = 0;
616 	void *context;
617 	const php_hash_ops *ops;
618 	php_hashcontext_object *hash;
619 	HashTable *args = NULL;
620 
621 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|lSh", &algo, &options, &key, &args) == FAILURE) {
622 		RETURN_THROWS();
623 	}
624 
625 	ops = php_hash_fetch_ops(algo);
626 	if (!ops) {
627 		zend_argument_value_error(1, "must be a valid hashing algorithm");
628 		RETURN_THROWS();
629 	}
630 
631 	if (options & PHP_HASH_HMAC) {
632 		if (!ops->is_crypto) {
633 			zend_argument_value_error(1, "must be a cryptographic hashing algorithm if HMAC is requested");
634 			RETURN_THROWS();
635 		}
636 		if (!key || (ZSTR_LEN(key) == 0)) {
637 			/* Note: a zero length key is no key at all */
638 			zend_argument_value_error(3, "cannot be empty when HMAC is requested");
639 			RETURN_THROWS();
640 		}
641 	}
642 
643 	object_init_ex(return_value, php_hashcontext_ce);
644 	hash = php_hashcontext_from_object(Z_OBJ_P(return_value));
645 
646 	context = php_hash_alloc_context(ops);
647 	ops->hash_init(context, args);
648 
649 	hash->ops = ops;
650 	hash->context = context;
651 	hash->options = options;
652 	hash->key = NULL;
653 
654 	if (options & PHP_HASH_HMAC) {
655 		char *K = emalloc(ops->block_size);
656 		size_t i, block_size;
657 
658 		memset(K, 0, ops->block_size);
659 
660 		if (ZSTR_LEN(key) > ops->block_size) {
661 			/* Reduce the key first */
662 			ops->hash_update(context, (unsigned char *) ZSTR_VAL(key), ZSTR_LEN(key));
663 			ops->hash_final((unsigned char *) K, context);
664 			/* Make the context ready to start over */
665 			ops->hash_init(context, args);
666 		} else {
667 			memcpy(K, ZSTR_VAL(key), ZSTR_LEN(key));
668 		}
669 
670 		/* XOR ipad */
671 		block_size = ops->block_size;
672 		for(i = 0; i < block_size; i++) {
673 			K[i] ^= 0x36;
674 		}
675 		ops->hash_update(context, (unsigned char *) K, ops->block_size);
676 		hash->key = (unsigned char *) K;
677 	}
678 }
679 /* }}} */
680 
681 #define PHP_HASHCONTEXT_VERIFY(hash) { \
682 	if (!hash->context) { \
683 		zend_argument_type_error(1, "must be a valid, non-finalized HashContext"); \
684 		RETURN_THROWS(); \
685 	} \
686 }
687 
688 /* {{{ Pump data into the hashing algorithm */
PHP_FUNCTION(hash_update)689 PHP_FUNCTION(hash_update)
690 {
691 	zval *zhash;
692 	php_hashcontext_object *hash;
693 	zend_string *data;
694 
695 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "OS", &zhash, php_hashcontext_ce, &data) == FAILURE) {
696 		RETURN_THROWS();
697 	}
698 
699 	hash = php_hashcontext_from_object(Z_OBJ_P(zhash));
700 	PHP_HASHCONTEXT_VERIFY(hash);
701 	hash->ops->hash_update(hash->context, (unsigned char *) ZSTR_VAL(data), ZSTR_LEN(data));
702 
703 	RETURN_TRUE;
704 }
705 /* }}} */
706 
707 /* {{{ Pump data into the hashing algorithm from an open stream */
PHP_FUNCTION(hash_update_stream)708 PHP_FUNCTION(hash_update_stream)
709 {
710 	zval *zhash, *zstream;
711 	php_hashcontext_object *hash;
712 	php_stream *stream = NULL;
713 	zend_long length = -1, didread = 0;
714 
715 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "Or|l", &zhash, php_hashcontext_ce, &zstream, &length) == FAILURE) {
716 		RETURN_THROWS();
717 	}
718 
719 	hash = php_hashcontext_from_object(Z_OBJ_P(zhash));
720 	PHP_HASHCONTEXT_VERIFY(hash);
721 	php_stream_from_zval(stream, zstream);
722 
723 	while (length) {
724 		char buf[1024];
725 		zend_long toread = 1024;
726 		ssize_t n;
727 
728 		if (length > 0 && toread > length) {
729 			toread = length;
730 		}
731 
732 		if ((n = php_stream_read(stream, buf, toread)) <= 0) {
733 			RETURN_LONG(didread);
734 		}
735 		hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
736 		length -= n;
737 		didread += n;
738 	}
739 
740 	RETURN_LONG(didread);
741 }
742 /* }}} */
743 
744 /* {{{ Pump data into the hashing algorithm from a file */
PHP_FUNCTION(hash_update_file)745 PHP_FUNCTION(hash_update_file)
746 {
747 	zval *zhash, *zcontext = NULL;
748 	php_hashcontext_object *hash;
749 	php_stream_context *context = NULL;
750 	php_stream *stream;
751 	zend_string *filename;
752 	char buf[1024];
753 	ssize_t n;
754 
755 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "OP|r!", &zhash, php_hashcontext_ce, &filename, &zcontext) == FAILURE) {
756 		RETURN_THROWS();
757 	}
758 
759 	hash = php_hashcontext_from_object(Z_OBJ_P(zhash));
760 	PHP_HASHCONTEXT_VERIFY(hash);
761 	context = php_stream_context_from_zval(zcontext, 0);
762 
763 	stream = php_stream_open_wrapper_ex(ZSTR_VAL(filename), "rb", REPORT_ERRORS, NULL, context);
764 	if (!stream) {
765 		/* Stream will report errors opening file */
766 		RETURN_FALSE;
767 	}
768 
769 	while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
770 		hash->ops->hash_update(hash->context, (unsigned char *) buf, n);
771 	}
772 	php_stream_close(stream);
773 
774 	RETURN_BOOL(n >= 0);
775 }
776 /* }}} */
777 
778 /* {{{ Output resulting digest */
PHP_FUNCTION(hash_final)779 PHP_FUNCTION(hash_final)
780 {
781 	zval *zhash;
782 	php_hashcontext_object *hash;
783 	bool raw_output = 0;
784 	zend_string *digest;
785 	size_t digest_len;
786 
787 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "O|b", &zhash, php_hashcontext_ce, &raw_output) == FAILURE) {
788 		RETURN_THROWS();
789 	}
790 
791 	hash = php_hashcontext_from_object(Z_OBJ_P(zhash));
792 	PHP_HASHCONTEXT_VERIFY(hash);
793 
794 	digest_len = hash->ops->digest_size;
795 	digest = zend_string_alloc(digest_len, 0);
796 	hash->ops->hash_final((unsigned char *) ZSTR_VAL(digest), hash->context);
797 	if (hash->options & PHP_HASH_HMAC) {
798 		size_t i, block_size;
799 
800 		/* Convert K to opad -- 0x6A = 0x36 ^ 0x5C */
801 		block_size = hash->ops->block_size;
802 		for(i = 0; i < block_size; i++) {
803 			hash->key[i] ^= 0x6A;
804 		}
805 
806 		/* Feed this result into the outer hash */
807 		hash->ops->hash_init(hash->context, NULL);
808 		hash->ops->hash_update(hash->context, hash->key, hash->ops->block_size);
809 		hash->ops->hash_update(hash->context, (unsigned char *) ZSTR_VAL(digest), hash->ops->digest_size);
810 		hash->ops->hash_final((unsigned char *) ZSTR_VAL(digest), hash->context);
811 
812 		/* Zero the key */
813 		ZEND_SECURE_ZERO(hash->key, hash->ops->block_size);
814 		efree(hash->key);
815 		hash->key = NULL;
816 	}
817 	ZSTR_VAL(digest)[digest_len] = 0;
818 
819 	/* Invalidate the object from further use */
820 	efree(hash->context);
821 	hash->context = NULL;
822 
823 	if (raw_output) {
824 		RETURN_NEW_STR(digest);
825 	} else {
826 		zend_string *hex_digest = zend_string_safe_alloc(digest_len, 2, 0, 0);
827 
828 		php_hash_bin2hex(ZSTR_VAL(hex_digest), (unsigned char *) ZSTR_VAL(digest), digest_len);
829 		ZSTR_VAL(hex_digest)[2 * digest_len] = 0;
830 		zend_string_release_ex(digest, 0);
831 		RETURN_NEW_STR(hex_digest);
832 	}
833 }
834 /* }}} */
835 
836 /* {{{ Copy hash object */
PHP_FUNCTION(hash_copy)837 PHP_FUNCTION(hash_copy)
838 {
839 	zval *zhash;
840 	php_hashcontext_object *context;
841 
842 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &zhash, php_hashcontext_ce) == FAILURE) {
843 		RETURN_THROWS();
844 	}
845 
846 	context = php_hashcontext_from_object(Z_OBJ_P(zhash));
847 	PHP_HASHCONTEXT_VERIFY(context);
848 
849 	RETVAL_OBJ(Z_OBJ_HANDLER_P(zhash, clone_obj)(Z_OBJ_P(zhash)));
850 
851 	if (php_hashcontext_from_object(Z_OBJ_P(return_value))->context == NULL) {
852 		zval_ptr_dtor(return_value);
853 
854 		zend_throw_error(NULL, "Cannot copy hash");
855 		RETURN_THROWS();
856 	}
857 }
858 /* }}} */
859 
860 /* {{{ Return a list of registered hashing algorithms */
PHP_FUNCTION(hash_algos)861 PHP_FUNCTION(hash_algos)
862 {
863 	zend_string *str;
864 
865 	if (zend_parse_parameters_none() == FAILURE) {
866 		RETURN_THROWS();
867 	}
868 
869 	array_init(return_value);
870 	ZEND_HASH_MAP_FOREACH_STR_KEY(&php_hash_hashtable, str) {
871 		add_next_index_str(return_value, zend_string_copy(str));
872 	} ZEND_HASH_FOREACH_END();
873 }
874 /* }}} */
875 
876 /* {{{ Return a list of registered hashing algorithms suitable for hash_hmac() */
PHP_FUNCTION(hash_hmac_algos)877 PHP_FUNCTION(hash_hmac_algos)
878 {
879 	zend_string *str;
880 	const php_hash_ops *ops;
881 
882 	if (zend_parse_parameters_none() == FAILURE) {
883 		RETURN_THROWS();
884 	}
885 
886 	array_init(return_value);
887 	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&php_hash_hashtable, str, ops) {
888 		if (ops->is_crypto) {
889 			add_next_index_str(return_value, zend_string_copy(str));
890 		}
891 	} ZEND_HASH_FOREACH_END();
892 }
893 /* }}} */
894 
895 /* {{{ RFC5869 HMAC-based key derivation function */
PHP_FUNCTION(hash_hkdf)896 PHP_FUNCTION(hash_hkdf)
897 {
898 	zend_string *returnval, *ikm, *algo, *info = NULL, *salt = NULL;
899 	zend_long length = 0;
900 	unsigned char *prk, *digest, *K;
901 	size_t i;
902 	size_t rounds;
903 	const php_hash_ops *ops;
904 	void *context;
905 
906 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|lSS", &algo, &ikm, &length, &info, &salt) == FAILURE) {
907 		RETURN_THROWS();
908 	}
909 
910 	ops = php_hash_fetch_ops(algo);
911 	if (!ops || !ops->is_crypto) {
912 		zend_argument_value_error(1, "must be a valid cryptographic hashing algorithm");
913 		RETURN_THROWS();
914 	}
915 
916 	if (ZSTR_LEN(ikm) == 0) {
917 		zend_argument_value_error(2, "cannot be empty");
918 		RETURN_THROWS();
919 	}
920 
921 	if (length < 0) {
922 		zend_argument_value_error(3, "must be greater than or equal to 0");
923 		RETURN_THROWS();
924 	} else if (length == 0) {
925 		length = ops->digest_size;
926 	} else if (length > (zend_long) (ops->digest_size * 255)) {
927 		zend_argument_value_error(3, "must be less than or equal to %zd", ops->digest_size * 255);
928 		RETURN_THROWS();
929 	}
930 
931 	context = php_hash_alloc_context(ops);
932 
933 	// Extract
934 	ops->hash_init(context, NULL);
935 	K = emalloc(ops->block_size);
936 	php_hash_hmac_prep_key(K, ops, context,
937 		(unsigned char *) (salt ? ZSTR_VAL(salt) : ""), salt ? ZSTR_LEN(salt) : 0);
938 
939 	prk = emalloc(ops->digest_size);
940 	php_hash_hmac_round(prk, ops, context, K, (unsigned char *) ZSTR_VAL(ikm), ZSTR_LEN(ikm));
941 	php_hash_string_xor_char(K, K, 0x6A, ops->block_size);
942 	php_hash_hmac_round(prk, ops, context, K, prk, ops->digest_size);
943 	ZEND_SECURE_ZERO(K, ops->block_size);
944 
945 	// Expand
946 	returnval = zend_string_alloc(length, 0);
947 	digest = emalloc(ops->digest_size);
948 	for (i = 1, rounds = (length - 1) / ops->digest_size + 1; i <= rounds; i++) {
949 		// chr(i)
950 		unsigned char c[1];
951 		c[0] = (i & 0xFF);
952 
953 		php_hash_hmac_prep_key(K, ops, context, prk, ops->digest_size);
954 		ops->hash_init(context, NULL);
955 		ops->hash_update(context, K, ops->block_size);
956 
957 		if (i > 1) {
958 			ops->hash_update(context, digest, ops->digest_size);
959 		}
960 
961 		if (info != NULL && ZSTR_LEN(info) > 0) {
962 			ops->hash_update(context, (unsigned char *) ZSTR_VAL(info), ZSTR_LEN(info));
963 		}
964 
965 		ops->hash_update(context, c, 1);
966 		ops->hash_final(digest, context);
967 		php_hash_string_xor_char(K, K, 0x6A, ops->block_size);
968 		php_hash_hmac_round(digest, ops, context, K, digest, ops->digest_size);
969 		memcpy(
970 			ZSTR_VAL(returnval) + ((i - 1) * ops->digest_size),
971 			digest,
972 			(i == rounds ? length - ((i - 1) * ops->digest_size) : ops->digest_size)
973 		);
974 	}
975 
976 	ZEND_SECURE_ZERO(K, ops->block_size);
977 	ZEND_SECURE_ZERO(digest, ops->digest_size);
978 	ZEND_SECURE_ZERO(prk, ops->digest_size);
979 	efree(K);
980 	efree(context);
981 	efree(prk);
982 	efree(digest);
983 	ZSTR_VAL(returnval)[length] = 0;
984 	RETURN_STR(returnval);
985 }
986 
987 /* {{{ Generate a PBKDF2 hash of the given password and salt
988 Returns lowercase hexits by default */
PHP_FUNCTION(hash_pbkdf2)989 PHP_FUNCTION(hash_pbkdf2)
990 {
991 	zend_string *returnval, *algo;
992 	char *salt, *pass = NULL;
993 	unsigned char *computed_salt, *digest, *temp, *result, *K1, *K2 = NULL;
994 	zend_long loops, i, j, iterations, digest_length = 0, length = 0;
995 	size_t pass_len, salt_len = 0;
996 	bool raw_output = 0;
997 	const php_hash_ops *ops;
998 	void *context;
999 	HashTable *args = NULL;
1000 
1001 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sssl|lbh", &algo, &pass, &pass_len, &salt, &salt_len, &iterations, &length, &raw_output, &args) == FAILURE) {
1002 		RETURN_THROWS();
1003 	}
1004 
1005 	ops = php_hash_fetch_ops(algo);
1006 	if (!ops || !ops->is_crypto) {
1007 		zend_argument_value_error(1, "must be a valid cryptographic hashing algorithm");
1008 		RETURN_THROWS();
1009 	}
1010 
1011 	if (salt_len > INT_MAX - 4) {
1012 		zend_argument_value_error(3, "must be less than or equal to INT_MAX - 4 bytes");
1013 		RETURN_THROWS();
1014 	}
1015 
1016 	if (iterations <= 0) {
1017 		zend_argument_value_error(4, "must be greater than 0");
1018 		RETURN_THROWS();
1019 	}
1020 
1021 	if (length < 0) {
1022 		zend_argument_value_error(5, "must be greater than or equal to 0");
1023 		RETURN_THROWS();
1024 	}
1025 
1026 	context = php_hash_alloc_context(ops);
1027 	ops->hash_init(context, args);
1028 
1029 	K1 = emalloc(ops->block_size);
1030 	K2 = emalloc(ops->block_size);
1031 	digest = emalloc(ops->digest_size);
1032 	temp = emalloc(ops->digest_size);
1033 
1034 	/* Setup Keys that will be used for all hmac rounds */
1035 	php_hash_hmac_prep_key(K1, ops, context, (unsigned char *) pass, pass_len);
1036 	/* Convert K1 to opad -- 0x6A = 0x36 ^ 0x5C */
1037 	php_hash_string_xor_char(K2, K1, 0x6A, ops->block_size);
1038 
1039 	/* Setup Main Loop to build a long enough result */
1040 	if (length == 0) {
1041 		length = ops->digest_size;
1042 		if (!raw_output) {
1043 			length = length * 2;
1044 		}
1045 	}
1046 	digest_length = length;
1047 	if (!raw_output) {
1048 		digest_length = (zend_long) ceil((float) length / 2.0);
1049 	}
1050 
1051 	loops = (zend_long) ceil((float) digest_length / (float) ops->digest_size);
1052 
1053 	result = safe_emalloc(loops, ops->digest_size, 0);
1054 
1055 	computed_salt = safe_emalloc(salt_len, 1, 4);
1056 	memcpy(computed_salt, (unsigned char *) salt, salt_len);
1057 
1058 	for (i = 1; i <= loops; i++) {
1059 		/* digest = hash_hmac(salt + pack('N', i), password) { */
1060 
1061 		/* pack("N", i) */
1062 		computed_salt[salt_len] = (unsigned char) (i >> 24);
1063 		computed_salt[salt_len + 1] = (unsigned char) ((i & 0xFF0000) >> 16);
1064 		computed_salt[salt_len + 2] = (unsigned char) ((i & 0xFF00) >> 8);
1065 		computed_salt[salt_len + 3] = (unsigned char) (i & 0xFF);
1066 
1067 		php_hash_hmac_round(digest, ops, context, K1, computed_salt, (zend_long) salt_len + 4);
1068 		php_hash_hmac_round(digest, ops, context, K2, digest, ops->digest_size);
1069 		/* } */
1070 
1071 		/* temp = digest */
1072 		memcpy(temp, digest, ops->digest_size);
1073 
1074 		/*
1075 		 * Note that the loop starting at 1 is intentional, since we've already done
1076 		 * the first round of the algorithm.
1077 		 */
1078 		for (j = 1; j < iterations; j++) {
1079 			/* digest = hash_hmac(digest, password) { */
1080 			php_hash_hmac_round(digest, ops, context, K1, digest, ops->digest_size);
1081 			php_hash_hmac_round(digest, ops, context, K2, digest, ops->digest_size);
1082 			/* } */
1083 			/* temp ^= digest */
1084 			php_hash_string_xor(temp, temp, digest, ops->digest_size);
1085 		}
1086 		/* result += temp */
1087 		memcpy(result + ((i - 1) * ops->digest_size), temp, ops->digest_size);
1088 	}
1089 	/* Zero potentially sensitive variables */
1090 	ZEND_SECURE_ZERO(K1, ops->block_size);
1091 	ZEND_SECURE_ZERO(K2, ops->block_size);
1092 	ZEND_SECURE_ZERO(computed_salt, salt_len + 4);
1093 	efree(K1);
1094 	efree(K2);
1095 	efree(computed_salt);
1096 	efree(context);
1097 	efree(digest);
1098 	efree(temp);
1099 
1100 	returnval = zend_string_alloc(length, 0);
1101 	if (raw_output) {
1102 		memcpy(ZSTR_VAL(returnval), result, length);
1103 	} else {
1104 		php_hash_bin2hex(ZSTR_VAL(returnval), result, digest_length);
1105 	}
1106 	ZSTR_VAL(returnval)[length] = 0;
1107 	efree(result);
1108 	RETURN_NEW_STR(returnval);
1109 }
1110 /* }}} */
1111 
1112 /* {{{ Compares two strings using the same time whether they're equal or not.
1113    A difference in length will leak */
PHP_FUNCTION(hash_equals)1114 PHP_FUNCTION(hash_equals)
1115 {
1116 	zval *known_zval, *user_zval;
1117 	int result = 0;
1118 
1119 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &known_zval, &user_zval) == FAILURE) {
1120 		RETURN_THROWS();
1121 	}
1122 
1123 	/* We only allow comparing string to prevent unexpected results. */
1124 	if (Z_TYPE_P(known_zval) != IS_STRING) {
1125 		zend_argument_type_error(1, "must be of type string, %s given", zend_zval_value_name(known_zval));
1126 		RETURN_THROWS();
1127 	}
1128 
1129 	if (Z_TYPE_P(user_zval) != IS_STRING) {
1130 		zend_argument_type_error(2, "must be of type string, %s given", zend_zval_value_name(user_zval));
1131 		RETURN_THROWS();
1132 	}
1133 
1134 	/* This is security sensitive code. Do not optimize this for speed. */
1135 	result = php_safe_bcmp(Z_STR_P(known_zval), Z_STR_P(user_zval));
1136 
1137 	RETURN_BOOL(0 == result);
1138 }
1139 /* }}} */
1140 
1141 /* {{{ */
PHP_METHOD(HashContext,__construct)1142 PHP_METHOD(HashContext, __construct) {
1143 	/* Normally unreachable as private/final */
1144 	zend_throw_exception(zend_ce_error, "Illegal call to private/final constructor", 0);
1145 }
1146 /* }}} */
1147 
1148 /* Module Housekeeping */
1149 
1150 #define PHP_HASH_HAVAL_REGISTER(p,b)	php_hash_register_algo("haval" #b "," #p , &php_hash_##p##haval##b##_ops);
1151 
1152 #ifdef PHP_MHASH_BC
1153 
1154 #if 0
1155 /* See #69823, we should not insert module into module_registry while doing startup */
1156 
1157 PHP_MINFO_FUNCTION(mhash)
1158 {
1159 	php_info_print_table_start();
1160 	php_info_print_table_row(2, "MHASH support", "Enabled");
1161 	php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
1162 	php_info_print_table_end();
1163 }
1164 
1165 zend_module_entry mhash_module_entry = {
1166 	STANDARD_MODULE_HEADER,
1167 	"mhash",
1168 	NULL,
1169 	NULL,
1170 	NULL,
1171 	NULL,
1172 	NULL,
1173 	PHP_MINFO(mhash),
1174 	PHP_MHASH_VERSION,
1175 	STANDARD_MODULE_PROPERTIES,
1176 };
1177 #endif
1178 
mhash_init(INIT_FUNC_ARGS)1179 static void mhash_init(INIT_FUNC_ARGS)
1180 {
1181 	char buf[128];
1182 	int len;
1183 	int algo_number = 0;
1184 
1185 	for (algo_number = 0; algo_number < MHASH_NUM_ALGOS; algo_number++) {
1186 		struct mhash_bc_entry algorithm = mhash_to_hash[algo_number];
1187 		if (algorithm.mhash_name == NULL) {
1188 			continue;
1189 		}
1190 
1191 		len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name);
1192 		zend_register_long_constant(buf, len, algorithm.value, CONST_PERSISTENT, module_number);
1193 	}
1194 
1195 	/* TODO: this cause #69823 zend_register_internal_module(&mhash_module_entry); */
1196 }
1197 
1198 /* {{{ Hash data with hash */
PHP_FUNCTION(mhash)1199 PHP_FUNCTION(mhash)
1200 {
1201 	zend_long algorithm;
1202 	zend_string *algo = NULL;
1203 	char *data, *key = NULL;
1204 	size_t data_len, key_len = 0;
1205 
1206 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "ls|s!", &algorithm, &data, &data_len, &key, &key_len) == FAILURE) {
1207 		RETURN_THROWS();
1208 	}
1209 
1210 	/* need to convert the first parameter from int constant to string algorithm name */
1211 	if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
1212 		struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1213 		if (algorithm_lookup.hash_name) {
1214 			algo = zend_string_init(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name), 0);
1215 		}
1216 	}
1217 
1218 	if (key) {
1219 		php_hash_do_hash_hmac(return_value, algo, data, data_len, key, key_len, 1, 0);
1220 	} else {
1221 		php_hash_do_hash(return_value, algo, data, data_len, 1, 0, NULL);
1222 	}
1223 
1224 	if (algo) {
1225 		zend_string_release(algo);
1226 	}
1227 }
1228 /* }}} */
1229 
1230 /* {{{ Gets the name of hash */
PHP_FUNCTION(mhash_get_hash_name)1231 PHP_FUNCTION(mhash_get_hash_name)
1232 {
1233 	zend_long algorithm;
1234 
1235 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &algorithm) == FAILURE) {
1236 		RETURN_THROWS();
1237 	}
1238 
1239 	if (algorithm >= 0 && algorithm  < MHASH_NUM_ALGOS) {
1240 		struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1241 		if (algorithm_lookup.mhash_name) {
1242 			RETURN_STRING(algorithm_lookup.mhash_name);
1243 		}
1244 	}
1245 	RETURN_FALSE;
1246 }
1247 /* }}} */
1248 
1249 /* {{{ Gets the number of available hashes */
PHP_FUNCTION(mhash_count)1250 PHP_FUNCTION(mhash_count)
1251 {
1252 	if (zend_parse_parameters_none() == FAILURE) {
1253 		RETURN_THROWS();
1254 	}
1255 	RETURN_LONG(MHASH_NUM_ALGOS - 1);
1256 }
1257 /* }}} */
1258 
1259 /* {{{ Gets the block size of hash */
PHP_FUNCTION(mhash_get_block_size)1260 PHP_FUNCTION(mhash_get_block_size)
1261 {
1262 	zend_long algorithm;
1263 
1264 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &algorithm) == FAILURE) {
1265 		RETURN_THROWS();
1266 	}
1267 	RETVAL_FALSE;
1268 
1269 	if (algorithm >= 0 && algorithm  < MHASH_NUM_ALGOS) {
1270 		struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1271 		if (algorithm_lookup.mhash_name) {
1272 			const php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
1273 			if (ops) {
1274 				RETVAL_LONG(ops->digest_size);
1275 			}
1276 		}
1277 	}
1278 }
1279 /* }}} */
1280 
1281 #define SALT_SIZE 8
1282 
1283 /* {{{ Generates a key using hash functions */
PHP_FUNCTION(mhash_keygen_s2k)1284 PHP_FUNCTION(mhash_keygen_s2k)
1285 {
1286 	zend_long algorithm, l_bytes;
1287 	int bytes;
1288 	char *password, *salt;
1289 	size_t password_len, salt_len;
1290 	char padded_salt[SALT_SIZE];
1291 
1292 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) {
1293 		RETURN_THROWS();
1294 	}
1295 
1296 	bytes = (int)l_bytes;
1297 	if (bytes <= 0){
1298 		zend_argument_value_error(4, "must be a greater than 0");
1299 		RETURN_THROWS();
1300 	}
1301 
1302 	salt_len = MIN(salt_len, SALT_SIZE);
1303 
1304 	memcpy(padded_salt, salt, salt_len);
1305 	if (salt_len < SALT_SIZE) {
1306 		memset(padded_salt + salt_len, 0, SALT_SIZE - salt_len);
1307 	}
1308 	salt_len = SALT_SIZE;
1309 
1310 	RETVAL_FALSE;
1311 	if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
1312 		struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1313 		if (algorithm_lookup.mhash_name) {
1314 			const php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
1315 			if (ops) {
1316 				unsigned char null = '\0';
1317 				void *context;
1318 				char *key, *digest;
1319 				int i = 0, j = 0;
1320 				size_t block_size = ops->digest_size;
1321 				size_t times = bytes / block_size;
1322 
1323 				if ((bytes % block_size) != 0) {
1324 					times++;
1325 				}
1326 
1327 				context = php_hash_alloc_context(ops);
1328 				ops->hash_init(context, NULL);
1329 
1330 				key = ecalloc(1, times * block_size);
1331 				digest = emalloc(ops->digest_size + 1);
1332 
1333 				for (i = 0; i < times; i++) {
1334 					ops->hash_init(context, NULL);
1335 
1336 					for (j=0;j<i;j++) {
1337 						ops->hash_update(context, &null, 1);
1338 					}
1339 					ops->hash_update(context, (unsigned char *)padded_salt, salt_len);
1340 					ops->hash_update(context, (unsigned char *)password, password_len);
1341 					ops->hash_final((unsigned char *)digest, context);
1342 					memcpy( &key[i*block_size], digest, block_size);
1343 				}
1344 
1345 				RETVAL_STRINGL(key, bytes);
1346 				ZEND_SECURE_ZERO(key, bytes);
1347 				efree(digest);
1348 				efree(context);
1349 				efree(key);
1350 			}
1351 		}
1352 	}
1353 }
1354 /* }}} */
1355 
1356 #endif
1357 
1358 /* ----------------------------------------------------------------------- */
1359 
1360 /* {{{ php_hashcontext_create */
php_hashcontext_create(zend_class_entry * ce)1361 static zend_object* php_hashcontext_create(zend_class_entry *ce) {
1362 	php_hashcontext_object *objval = zend_object_alloc(sizeof(php_hashcontext_object), ce);
1363 	zend_object *zobj = &objval->std;
1364 
1365 	zend_object_std_init(zobj, ce);
1366 	object_properties_init(zobj, ce);
1367 	zobj->handlers = &php_hashcontext_handlers;
1368 
1369 	return zobj;
1370 }
1371 /* }}} */
1372 
1373 /* {{{ php_hashcontext_dtor */
php_hashcontext_dtor(zend_object * obj)1374 static void php_hashcontext_dtor(zend_object *obj) {
1375 	php_hashcontext_object *hash = php_hashcontext_from_object(obj);
1376 
1377 	if (hash->context) {
1378 		efree(hash->context);
1379 		hash->context = NULL;
1380 	}
1381 
1382 	if (hash->key) {
1383 		ZEND_SECURE_ZERO(hash->key, hash->ops->block_size);
1384 		efree(hash->key);
1385 		hash->key = NULL;
1386 	}
1387 }
1388 /* }}} */
1389 
php_hashcontext_free(zend_object * obj)1390 static void php_hashcontext_free(zend_object *obj) {
1391 	php_hashcontext_dtor(obj);
1392 	zend_object_std_dtor(obj);
1393 }
1394 
1395 /* {{{ php_hashcontext_clone */
php_hashcontext_clone(zend_object * zobj)1396 static zend_object *php_hashcontext_clone(zend_object *zobj) {
1397 	php_hashcontext_object *oldobj = php_hashcontext_from_object(zobj);
1398 	zend_object *znew = php_hashcontext_create(zobj->ce);
1399 	php_hashcontext_object *newobj = php_hashcontext_from_object(znew);
1400 
1401 	if (!oldobj->context) {
1402 		zend_throw_exception(zend_ce_value_error, "Cannot clone a finalized HashContext", 0);
1403 		return znew;
1404 	}
1405 
1406 	zend_objects_clone_members(znew, zobj);
1407 
1408 	newobj->ops = oldobj->ops;
1409 	newobj->options = oldobj->options;
1410 	newobj->context = php_hash_alloc_context(newobj->ops);
1411 	newobj->ops->hash_init(newobj->context, NULL);
1412 
1413 	if (SUCCESS != newobj->ops->hash_copy(newobj->ops, oldobj->context, newobj->context)) {
1414 		efree(newobj->context);
1415 		newobj->context = NULL;
1416 		return znew;
1417 	}
1418 
1419 	newobj->key = ecalloc(1, newobj->ops->block_size);
1420 	if (oldobj->key) {
1421 		memcpy(newobj->key, oldobj->key, newobj->ops->block_size);
1422 	}
1423 
1424 	return znew;
1425 }
1426 /* }}} */
1427 
1428 /* Serialization format: 5-element array
1429    Index 0: hash algorithm (string)
1430    Index 1: options (long, 0)
1431    Index 2: hash-determined serialization of context state (usually array)
1432    Index 3: magic number defining layout of context state (long, usually 2)
1433    Index 4: properties (array)
1434 
1435    HashContext serializations are not necessarily portable between architectures or
1436    PHP versions. If the format of a serialized hash context changes, that should
1437    be reflected in either a different value of `magic` or a different format of
1438    the serialized context state. Most context states are unparsed and parsed using
1439    a spec string, such as "llb128.", using the format defined by
1440    `php_hash_serialize_spec`/`php_hash_unserialize_spec`. Some hash algorithms must
1441    also check the unserialized state for validity, to ensure that using an
1442    unserialized context is safe from memory errors.
1443 
1444    Currently HASH_HMAC contexts cannot be serialized, because serializing them
1445    would require serializing the HMAC key in plaintext. */
1446 
1447 /* {{{ Serialize the object */
PHP_METHOD(HashContext,__serialize)1448 PHP_METHOD(HashContext, __serialize)
1449 {
1450 	zval *object = ZEND_THIS;
1451 	php_hashcontext_object *hash = php_hashcontext_from_object(Z_OBJ_P(object));
1452 	zend_long magic = 0;
1453 	zval tmp;
1454 
1455 	if (zend_parse_parameters_none() == FAILURE) {
1456 		RETURN_THROWS();
1457 	}
1458 
1459 	array_init(return_value);
1460 
1461 	if (!hash->ops->hash_serialize) {
1462 		goto serialize_failure;
1463 	} else if (hash->options & PHP_HASH_HMAC) {
1464 		zend_throw_exception(NULL, "HashContext with HASH_HMAC option cannot be serialized", 0);
1465 		RETURN_THROWS();
1466 	}
1467 
1468 	ZVAL_STRING(&tmp, hash->ops->algo);
1469 	zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1470 
1471 	ZVAL_LONG(&tmp, hash->options);
1472 	zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1473 
1474 	if (hash->ops->hash_serialize(hash, &magic, &tmp) != SUCCESS) {
1475 		goto serialize_failure;
1476 	}
1477 	zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1478 
1479 	ZVAL_LONG(&tmp, magic);
1480 	zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1481 
1482 	/* members */
1483 	ZVAL_ARR(&tmp, zend_std_get_properties(&hash->std));
1484 	Z_TRY_ADDREF(tmp);
1485 	zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1486 
1487 	return;
1488 
1489 serialize_failure:
1490 	zend_throw_exception_ex(NULL, 0, "HashContext for algorithm \"%s\" cannot be serialized", hash->ops->algo);
1491 	RETURN_THROWS();
1492 }
1493 /* }}} */
1494 
1495 /* {{{ unserialize the object */
PHP_METHOD(HashContext,__unserialize)1496 PHP_METHOD(HashContext, __unserialize)
1497 {
1498 	zval *object = ZEND_THIS;
1499 	php_hashcontext_object *hash = php_hashcontext_from_object(Z_OBJ_P(object));
1500 	HashTable *data;
1501 	zval *algo_zv, *magic_zv, *options_zv, *hash_zv, *members_zv;
1502 	zend_long magic, options;
1503 	int unserialize_result;
1504 	const php_hash_ops *ops;
1505 
1506 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &data) == FAILURE) {
1507 		RETURN_THROWS();
1508 	}
1509 
1510 	if (hash->context) {
1511 		zend_throw_exception(NULL, "HashContext::__unserialize called on initialized object", 0);
1512 		RETURN_THROWS();
1513 	}
1514 
1515 	algo_zv = zend_hash_index_find(data, 0);
1516 	options_zv = zend_hash_index_find(data, 1);
1517 	hash_zv = zend_hash_index_find(data, 2);
1518 	magic_zv = zend_hash_index_find(data, 3);
1519 	members_zv = zend_hash_index_find(data, 4);
1520 
1521 	if (!algo_zv || Z_TYPE_P(algo_zv) != IS_STRING
1522 		|| !magic_zv || Z_TYPE_P(magic_zv) != IS_LONG
1523 		|| !options_zv || Z_TYPE_P(options_zv) != IS_LONG
1524 		|| !hash_zv
1525 		|| !members_zv || Z_TYPE_P(members_zv) != IS_ARRAY) {
1526 		zend_throw_exception(NULL, "Incomplete or ill-formed serialization data", 0);
1527 		RETURN_THROWS();
1528 	}
1529 
1530 	magic = Z_LVAL_P(magic_zv);
1531 	options = Z_LVAL_P(options_zv);
1532 	if (options & PHP_HASH_HMAC) {
1533 		zend_throw_exception(NULL, "HashContext with HASH_HMAC option cannot be serialized", 0);
1534 		RETURN_THROWS();
1535 	}
1536 
1537 	ops = php_hash_fetch_ops(Z_STR_P(algo_zv));
1538 	if (!ops) {
1539 		zend_throw_exception(NULL, "Unknown hash algorithm", 0);
1540 		RETURN_THROWS();
1541 	} else if (!ops->hash_unserialize) {
1542 		zend_throw_exception_ex(NULL, 0, "Hash algorithm \"%s\" cannot be unserialized", ops->algo);
1543 		RETURN_THROWS();
1544 	}
1545 
1546 	hash->ops = ops;
1547 	hash->context = php_hash_alloc_context(ops);
1548 	hash->options = options;
1549 	ops->hash_init(hash->context, NULL);
1550 
1551 	unserialize_result = ops->hash_unserialize(hash, magic, hash_zv);
1552 	if (unserialize_result != SUCCESS) {
1553 		zend_throw_exception_ex(NULL, 0, "Incomplete or ill-formed serialization data (\"%s\" code %d)", ops->algo, unserialize_result);
1554 		/* free context */
1555 		php_hashcontext_dtor(Z_OBJ_P(object));
1556 		RETURN_THROWS();
1557 	}
1558 
1559 	object_properties_load(&hash->std, Z_ARRVAL_P(members_zv));
1560 }
1561 /* }}} */
1562 
ZEND_METHOD(HashContext,__debugInfo)1563 ZEND_METHOD(HashContext, __debugInfo)
1564 {
1565 	zval *object = ZEND_THIS;
1566 	php_hashcontext_object *hash = php_hashcontext_from_object(Z_OBJ_P(object));
1567 
1568 	ZEND_PARSE_PARAMETERS_NONE();
1569 
1570 	zval tmp;
1571 
1572 	array_init(return_value);
1573 
1574 	ZVAL_STRING(&tmp, hash->ops->algo);
1575 	zend_hash_str_update(Z_ARR_P(return_value), "algo", strlen("algo"), &tmp);
1576 }
1577 
1578 /* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(hash)1579 PHP_MINIT_FUNCTION(hash)
1580 {
1581 	zend_hash_init(&php_hash_hashtable, 35, NULL, NULL, 1);
1582 
1583 	php_hash_register_algo("md2",			&php_hash_md2_ops);
1584 	php_hash_register_algo("md4",			&php_hash_md4_ops);
1585 	php_hash_register_algo("md5",			&php_hash_md5_ops);
1586 	php_hash_register_algo("sha1",			&php_hash_sha1_ops);
1587 	php_hash_register_algo("sha224",		&php_hash_sha224_ops);
1588 	php_hash_register_algo("sha256",		&php_hash_sha256_ops);
1589 	php_hash_register_algo("sha384",		&php_hash_sha384_ops);
1590 	php_hash_register_algo("sha512/224",            &php_hash_sha512_224_ops);
1591 	php_hash_register_algo("sha512/256",            &php_hash_sha512_256_ops);
1592 	php_hash_register_algo("sha512",		&php_hash_sha512_ops);
1593 	php_hash_register_algo("sha3-224",		&php_hash_sha3_224_ops);
1594 	php_hash_register_algo("sha3-256",		&php_hash_sha3_256_ops);
1595 	php_hash_register_algo("sha3-384",		&php_hash_sha3_384_ops);
1596 	php_hash_register_algo("sha3-512",		&php_hash_sha3_512_ops);
1597 	php_hash_register_algo("ripemd128",		&php_hash_ripemd128_ops);
1598 	php_hash_register_algo("ripemd160",		&php_hash_ripemd160_ops);
1599 	php_hash_register_algo("ripemd256",		&php_hash_ripemd256_ops);
1600 	php_hash_register_algo("ripemd320",		&php_hash_ripemd320_ops);
1601 	php_hash_register_algo("whirlpool",		&php_hash_whirlpool_ops);
1602 	php_hash_register_algo("tiger128,3",	&php_hash_3tiger128_ops);
1603 	php_hash_register_algo("tiger160,3",	&php_hash_3tiger160_ops);
1604 	php_hash_register_algo("tiger192,3",	&php_hash_3tiger192_ops);
1605 	php_hash_register_algo("tiger128,4",	&php_hash_4tiger128_ops);
1606 	php_hash_register_algo("tiger160,4",	&php_hash_4tiger160_ops);
1607 	php_hash_register_algo("tiger192,4",	&php_hash_4tiger192_ops);
1608 	php_hash_register_algo("snefru",		&php_hash_snefru_ops);
1609 	php_hash_register_algo("snefru256",		&php_hash_snefru_ops);
1610 	php_hash_register_algo("gost",			&php_hash_gost_ops);
1611 	php_hash_register_algo("gost-crypto",		&php_hash_gost_crypto_ops);
1612 	php_hash_register_algo("adler32",		&php_hash_adler32_ops);
1613 	php_hash_register_algo("crc32",			&php_hash_crc32_ops);
1614 	php_hash_register_algo("crc32b",		&php_hash_crc32b_ops);
1615 	php_hash_register_algo("crc32c",		&php_hash_crc32c_ops);
1616 	php_hash_register_algo("fnv132",		&php_hash_fnv132_ops);
1617 	php_hash_register_algo("fnv1a32",		&php_hash_fnv1a32_ops);
1618 	php_hash_register_algo("fnv164",		&php_hash_fnv164_ops);
1619 	php_hash_register_algo("fnv1a64",		&php_hash_fnv1a64_ops);
1620 	php_hash_register_algo("joaat",			&php_hash_joaat_ops);
1621 	php_hash_register_algo("murmur3a",		&php_hash_murmur3a_ops);
1622 	php_hash_register_algo("murmur3c",		&php_hash_murmur3c_ops);
1623 	php_hash_register_algo("murmur3f",		&php_hash_murmur3f_ops);
1624 	php_hash_register_algo("xxh32",		&php_hash_xxh32_ops);
1625 	php_hash_register_algo("xxh64",		&php_hash_xxh64_ops);
1626 	php_hash_register_algo("xxh3",		&php_hash_xxh3_64_ops);
1627 	php_hash_register_algo("xxh128",		&php_hash_xxh3_128_ops);
1628 
1629 	PHP_HASH_HAVAL_REGISTER(3,128);
1630 	PHP_HASH_HAVAL_REGISTER(3,160);
1631 	PHP_HASH_HAVAL_REGISTER(3,192);
1632 	PHP_HASH_HAVAL_REGISTER(3,224);
1633 	PHP_HASH_HAVAL_REGISTER(3,256);
1634 
1635 	PHP_HASH_HAVAL_REGISTER(4,128);
1636 	PHP_HASH_HAVAL_REGISTER(4,160);
1637 	PHP_HASH_HAVAL_REGISTER(4,192);
1638 	PHP_HASH_HAVAL_REGISTER(4,224);
1639 	PHP_HASH_HAVAL_REGISTER(4,256);
1640 
1641 	PHP_HASH_HAVAL_REGISTER(5,128);
1642 	PHP_HASH_HAVAL_REGISTER(5,160);
1643 	PHP_HASH_HAVAL_REGISTER(5,192);
1644 	PHP_HASH_HAVAL_REGISTER(5,224);
1645 	PHP_HASH_HAVAL_REGISTER(5,256);
1646 
1647 	register_hash_symbols(module_number);
1648 
1649 	php_hashcontext_ce = register_class_HashContext();
1650 	php_hashcontext_ce->create_object = php_hashcontext_create;
1651 
1652 	memcpy(&php_hashcontext_handlers, &std_object_handlers,
1653 	       sizeof(zend_object_handlers));
1654 	php_hashcontext_handlers.offset = XtOffsetOf(php_hashcontext_object, std);
1655 	php_hashcontext_handlers.free_obj = php_hashcontext_free;
1656 	php_hashcontext_handlers.clone_obj = php_hashcontext_clone;
1657 
1658 #ifdef PHP_MHASH_BC
1659 	mhash_init(INIT_FUNC_ARGS_PASSTHRU);
1660 #endif
1661 
1662 	return SUCCESS;
1663 }
1664 /* }}} */
1665 
1666 /* {{{ PHP_MSHUTDOWN_FUNCTION */
PHP_MSHUTDOWN_FUNCTION(hash)1667 PHP_MSHUTDOWN_FUNCTION(hash)
1668 {
1669 	zend_hash_destroy(&php_hash_hashtable);
1670 
1671 	return SUCCESS;
1672 }
1673 /* }}} */
1674 
1675 /* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(hash)1676 PHP_MINFO_FUNCTION(hash)
1677 {
1678 	char buffer[2048];
1679 	zend_string *str;
1680 	char *s = buffer, *e = s + sizeof(buffer);
1681 
1682 	ZEND_HASH_MAP_FOREACH_STR_KEY(&php_hash_hashtable, str) {
1683 		s += slprintf(s, e - s, "%s ", ZSTR_VAL(str));
1684 	} ZEND_HASH_FOREACH_END();
1685 	*s = 0;
1686 
1687 	php_info_print_table_start();
1688 	php_info_print_table_row(2, "hash support", "enabled");
1689 	php_info_print_table_row(2, "Hashing Engines", buffer);
1690 	php_info_print_table_end();
1691 
1692 #ifdef PHP_MHASH_BC
1693 	php_info_print_table_start();
1694 	php_info_print_table_row(2, "MHASH support", "Enabled");
1695 	php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
1696 	php_info_print_table_end();
1697 #endif
1698 
1699 }
1700 /* }}} */
1701 
1702 /* {{{ hash_module_entry */
1703 zend_module_entry hash_module_entry = {
1704 	STANDARD_MODULE_HEADER,
1705 	PHP_HASH_EXTNAME,
1706 	ext_functions,
1707 	PHP_MINIT(hash),
1708 	PHP_MSHUTDOWN(hash),
1709 	NULL, /* RINIT */
1710 	NULL, /* RSHUTDOWN */
1711 	PHP_MINFO(hash),
1712 	PHP_HASH_VERSION,
1713 	STANDARD_MODULE_PROPERTIES
1714 };
1715 /* }}} */
1716