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 #include "ext/spl/spl_exceptions.h"
28
29 #include "zend_interfaces.h"
30 #include "zend_exceptions.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 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_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_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 char *known_str, *user_str;
1118 int result = 0;
1119 size_t j;
1120
1121 if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &known_zval, &user_zval) == FAILURE) {
1122 RETURN_THROWS();
1123 }
1124
1125 /* We only allow comparing string to prevent unexpected results. */
1126 if (Z_TYPE_P(known_zval) != IS_STRING) {
1127 zend_argument_type_error(1, "must be of type string, %s given", zend_zval_type_name(known_zval));
1128 RETURN_THROWS();
1129 }
1130
1131 if (Z_TYPE_P(user_zval) != IS_STRING) {
1132 zend_argument_type_error(2, "must be of type string, %s given", zend_zval_type_name(user_zval));
1133 RETURN_THROWS();
1134 }
1135
1136 if (Z_STRLEN_P(known_zval) != Z_STRLEN_P(user_zval)) {
1137 RETURN_FALSE;
1138 }
1139
1140 known_str = Z_STRVAL_P(known_zval);
1141 user_str = Z_STRVAL_P(user_zval);
1142
1143 /* This is security sensitive code. Do not optimize this for speed. */
1144 for (j = 0; j < Z_STRLEN_P(known_zval); j++) {
1145 result |= known_str[j] ^ user_str[j];
1146 }
1147
1148 RETURN_BOOL(0 == result);
1149 }
1150 /* }}} */
1151
1152 /* {{{ */
PHP_METHOD(HashContext,__construct)1153 PHP_METHOD(HashContext, __construct) {
1154 /* Normally unreachable as private/final */
1155 zend_throw_exception(zend_ce_error, "Illegal call to private/final constructor", 0);
1156 }
1157 /* }}} */
1158
1159 /* Module Housekeeping */
1160
1161 #define PHP_HASH_HAVAL_REGISTER(p,b) php_hash_register_algo("haval" #b "," #p , &php_hash_##p##haval##b##_ops);
1162
1163 #ifdef PHP_MHASH_BC
1164
1165 #if 0
1166 /* See #69823, we should not insert module into module_registry while doing startup */
1167
1168 PHP_MINFO_FUNCTION(mhash)
1169 {
1170 php_info_print_table_start();
1171 php_info_print_table_row(2, "MHASH support", "Enabled");
1172 php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
1173 php_info_print_table_end();
1174 }
1175
1176 zend_module_entry mhash_module_entry = {
1177 STANDARD_MODULE_HEADER,
1178 "mhash",
1179 NULL,
1180 NULL,
1181 NULL,
1182 NULL,
1183 NULL,
1184 PHP_MINFO(mhash),
1185 PHP_MHASH_VERSION,
1186 STANDARD_MODULE_PROPERTIES,
1187 };
1188 #endif
1189
mhash_init(INIT_FUNC_ARGS)1190 static void mhash_init(INIT_FUNC_ARGS)
1191 {
1192 char buf[128];
1193 int len;
1194 int algo_number = 0;
1195
1196 for (algo_number = 0; algo_number < MHASH_NUM_ALGOS; algo_number++) {
1197 struct mhash_bc_entry algorithm = mhash_to_hash[algo_number];
1198 if (algorithm.mhash_name == NULL) {
1199 continue;
1200 }
1201
1202 len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name);
1203 zend_register_long_constant(buf, len, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number);
1204 }
1205
1206 /* TODO: this cause #69823 zend_register_internal_module(&mhash_module_entry); */
1207 }
1208
1209 /* {{{ Hash data with hash */
PHP_FUNCTION(mhash)1210 PHP_FUNCTION(mhash)
1211 {
1212 zend_long algorithm;
1213 zend_string *algo = NULL;
1214 char *data, *key = NULL;
1215 size_t data_len, key_len = 0;
1216
1217 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ls|s!", &algorithm, &data, &data_len, &key, &key_len) == FAILURE) {
1218 RETURN_THROWS();
1219 }
1220
1221 /* need to convert the first parameter from int constant to string algorithm name */
1222 if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
1223 struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1224 if (algorithm_lookup.hash_name) {
1225 algo = zend_string_init(algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name), 0);
1226 }
1227 }
1228
1229 if (key) {
1230 php_hash_do_hash_hmac(return_value, algo, data, data_len, key, key_len, 1, 0);
1231 } else {
1232 php_hash_do_hash(return_value, algo, data, data_len, 1, 0, NULL);
1233 }
1234
1235 if (algo) {
1236 zend_string_release(algo);
1237 }
1238 }
1239 /* }}} */
1240
1241 /* {{{ Gets the name of hash */
PHP_FUNCTION(mhash_get_hash_name)1242 PHP_FUNCTION(mhash_get_hash_name)
1243 {
1244 zend_long algorithm;
1245
1246 if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &algorithm) == FAILURE) {
1247 RETURN_THROWS();
1248 }
1249
1250 if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
1251 struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1252 if (algorithm_lookup.mhash_name) {
1253 RETURN_STRING(algorithm_lookup.mhash_name);
1254 }
1255 }
1256 RETURN_FALSE;
1257 }
1258 /* }}} */
1259
1260 /* {{{ Gets the number of available hashes */
PHP_FUNCTION(mhash_count)1261 PHP_FUNCTION(mhash_count)
1262 {
1263 if (zend_parse_parameters_none() == FAILURE) {
1264 RETURN_THROWS();
1265 }
1266 RETURN_LONG(MHASH_NUM_ALGOS - 1);
1267 }
1268 /* }}} */
1269
1270 /* {{{ Gets the block size of hash */
PHP_FUNCTION(mhash_get_block_size)1271 PHP_FUNCTION(mhash_get_block_size)
1272 {
1273 zend_long algorithm;
1274
1275 if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &algorithm) == FAILURE) {
1276 RETURN_THROWS();
1277 }
1278 RETVAL_FALSE;
1279
1280 if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
1281 struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1282 if (algorithm_lookup.mhash_name) {
1283 const php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
1284 if (ops) {
1285 RETVAL_LONG(ops->digest_size);
1286 }
1287 }
1288 }
1289 }
1290 /* }}} */
1291
1292 #define SALT_SIZE 8
1293
1294 /* {{{ Generates a key using hash functions */
PHP_FUNCTION(mhash_keygen_s2k)1295 PHP_FUNCTION(mhash_keygen_s2k)
1296 {
1297 zend_long algorithm, l_bytes;
1298 int bytes;
1299 char *password, *salt;
1300 size_t password_len, salt_len;
1301 char padded_salt[SALT_SIZE];
1302
1303 if (zend_parse_parameters(ZEND_NUM_ARGS(), "lssl", &algorithm, &password, &password_len, &salt, &salt_len, &l_bytes) == FAILURE) {
1304 RETURN_THROWS();
1305 }
1306
1307 bytes = (int)l_bytes;
1308 if (bytes <= 0){
1309 zend_argument_value_error(4, "must be a greater than 0");
1310 RETURN_THROWS();
1311 }
1312
1313 salt_len = MIN(salt_len, SALT_SIZE);
1314
1315 memcpy(padded_salt, salt, salt_len);
1316 if (salt_len < SALT_SIZE) {
1317 memset(padded_salt + salt_len, 0, SALT_SIZE - salt_len);
1318 }
1319 salt_len = SALT_SIZE;
1320
1321 RETVAL_FALSE;
1322 if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
1323 struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
1324 if (algorithm_lookup.mhash_name) {
1325 const php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, algorithm_lookup.hash_name, strlen(algorithm_lookup.hash_name));
1326 if (ops) {
1327 unsigned char null = '\0';
1328 void *context;
1329 char *key, *digest;
1330 int i = 0, j = 0;
1331 size_t block_size = ops->digest_size;
1332 size_t times = bytes / block_size;
1333
1334 if ((bytes % block_size) != 0) {
1335 times++;
1336 }
1337
1338 context = php_hash_alloc_context(ops);
1339 ops->hash_init(context, NULL);
1340
1341 key = ecalloc(1, times * block_size);
1342 digest = emalloc(ops->digest_size + 1);
1343
1344 for (i = 0; i < times; i++) {
1345 ops->hash_init(context, NULL);
1346
1347 for (j=0;j<i;j++) {
1348 ops->hash_update(context, &null, 1);
1349 }
1350 ops->hash_update(context, (unsigned char *)padded_salt, salt_len);
1351 ops->hash_update(context, (unsigned char *)password, password_len);
1352 ops->hash_final((unsigned char *)digest, context);
1353 memcpy( &key[i*block_size], digest, block_size);
1354 }
1355
1356 RETVAL_STRINGL(key, bytes);
1357 ZEND_SECURE_ZERO(key, bytes);
1358 efree(digest);
1359 efree(context);
1360 efree(key);
1361 }
1362 }
1363 }
1364 }
1365 /* }}} */
1366
1367 #endif
1368
1369 /* ----------------------------------------------------------------------- */
1370
1371 /* {{{ php_hashcontext_create */
php_hashcontext_create(zend_class_entry * ce)1372 static zend_object* php_hashcontext_create(zend_class_entry *ce) {
1373 php_hashcontext_object *objval = zend_object_alloc(sizeof(php_hashcontext_object), ce);
1374 zend_object *zobj = &objval->std;
1375
1376 zend_object_std_init(zobj, ce);
1377 object_properties_init(zobj, ce);
1378 zobj->handlers = &php_hashcontext_handlers;
1379
1380 return zobj;
1381 }
1382 /* }}} */
1383
1384 /* {{{ php_hashcontext_dtor */
php_hashcontext_dtor(zend_object * obj)1385 static void php_hashcontext_dtor(zend_object *obj) {
1386 php_hashcontext_object *hash = php_hashcontext_from_object(obj);
1387
1388 if (hash->context) {
1389 efree(hash->context);
1390 hash->context = NULL;
1391 }
1392
1393 if (hash->key) {
1394 ZEND_SECURE_ZERO(hash->key, hash->ops->block_size);
1395 efree(hash->key);
1396 hash->key = NULL;
1397 }
1398 }
1399 /* }}} */
1400
php_hashcontext_free(zend_object * obj)1401 static void php_hashcontext_free(zend_object *obj) {
1402 php_hashcontext_dtor(obj);
1403 zend_object_std_dtor(obj);
1404 }
1405
1406 /* {{{ php_hashcontext_clone */
php_hashcontext_clone(zend_object * zobj)1407 static zend_object *php_hashcontext_clone(zend_object *zobj) {
1408 php_hashcontext_object *oldobj = php_hashcontext_from_object(zobj);
1409 zend_object *znew = php_hashcontext_create(zobj->ce);
1410 php_hashcontext_object *newobj = php_hashcontext_from_object(znew);
1411
1412 if (!oldobj->context) {
1413 zend_throw_exception(zend_ce_value_error, "Cannot clone a finalized HashContext", 0);
1414 return znew;
1415 }
1416
1417 zend_objects_clone_members(znew, zobj);
1418
1419 newobj->ops = oldobj->ops;
1420 newobj->options = oldobj->options;
1421 newobj->context = php_hash_alloc_context(newobj->ops);
1422 newobj->ops->hash_init(newobj->context, NULL);
1423
1424 if (SUCCESS != newobj->ops->hash_copy(newobj->ops, oldobj->context, newobj->context)) {
1425 efree(newobj->context);
1426 newobj->context = NULL;
1427 return znew;
1428 }
1429
1430 newobj->key = ecalloc(1, newobj->ops->block_size);
1431 if (oldobj->key) {
1432 memcpy(newobj->key, oldobj->key, newobj->ops->block_size);
1433 }
1434
1435 return znew;
1436 }
1437 /* }}} */
1438
1439 /* Serialization format: 5-element array
1440 Index 0: hash algorithm (string)
1441 Index 1: options (long, 0)
1442 Index 2: hash-determined serialization of context state (usually array)
1443 Index 3: magic number defining layout of context state (long, usually 2)
1444 Index 4: properties (array)
1445
1446 HashContext serializations are not necessarily portable between architectures or
1447 PHP versions. If the format of a serialized hash context changes, that should
1448 be reflected in either a different value of `magic` or a different format of
1449 the serialized context state. Most context states are unparsed and parsed using
1450 a spec string, such as "llb128.", using the format defined by
1451 `php_hash_serialize_spec`/`php_hash_unserialize_spec`. Some hash algorithms must
1452 also check the unserialized state for validity, to ensure that using an
1453 unserialized context is safe from memory errors.
1454
1455 Currently HASH_HMAC contexts cannot be serialized, because serializing them
1456 would require serializing the HMAC key in plaintext. */
1457
1458 /* {{{ Serialize the object */
PHP_METHOD(HashContext,__serialize)1459 PHP_METHOD(HashContext, __serialize)
1460 {
1461 zval *object = ZEND_THIS;
1462 php_hashcontext_object *hash = php_hashcontext_from_object(Z_OBJ_P(object));
1463 zend_long magic = 0;
1464 zval tmp;
1465
1466 if (zend_parse_parameters_none() == FAILURE) {
1467 RETURN_THROWS();
1468 }
1469
1470 array_init(return_value);
1471
1472 if (!hash->ops->hash_serialize) {
1473 goto serialize_failure;
1474 } else if (hash->options & PHP_HASH_HMAC) {
1475 zend_throw_exception(NULL, "HashContext with HASH_HMAC option cannot be serialized", 0);
1476 RETURN_THROWS();
1477 }
1478
1479 ZVAL_STRING(&tmp, hash->ops->algo);
1480 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1481
1482 ZVAL_LONG(&tmp, hash->options);
1483 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1484
1485 if (hash->ops->hash_serialize(hash, &magic, &tmp) != SUCCESS) {
1486 goto serialize_failure;
1487 }
1488 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1489
1490 ZVAL_LONG(&tmp, magic);
1491 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1492
1493 /* members */
1494 ZVAL_ARR(&tmp, zend_std_get_properties(&hash->std));
1495 Z_TRY_ADDREF(tmp);
1496 zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &tmp);
1497
1498 return;
1499
1500 serialize_failure:
1501 zend_throw_exception_ex(NULL, 0, "HashContext for algorithm \"%s\" cannot be serialized", hash->ops->algo);
1502 RETURN_THROWS();
1503 }
1504 /* }}} */
1505
1506 /* {{{ unserialize the object */
PHP_METHOD(HashContext,__unserialize)1507 PHP_METHOD(HashContext, __unserialize)
1508 {
1509 zval *object = ZEND_THIS;
1510 php_hashcontext_object *hash = php_hashcontext_from_object(Z_OBJ_P(object));
1511 HashTable *data;
1512 zval *algo_zv, *magic_zv, *options_zv, *hash_zv, *members_zv;
1513 zend_long magic, options;
1514 int unserialize_result;
1515 const php_hash_ops *ops;
1516
1517 if (zend_parse_parameters(ZEND_NUM_ARGS(), "h", &data) == FAILURE) {
1518 RETURN_THROWS();
1519 }
1520
1521 if (hash->context) {
1522 zend_throw_exception(NULL, "HashContext::__unserialize called on initialized object", 0);
1523 RETURN_THROWS();
1524 }
1525
1526 algo_zv = zend_hash_index_find(data, 0);
1527 options_zv = zend_hash_index_find(data, 1);
1528 hash_zv = zend_hash_index_find(data, 2);
1529 magic_zv = zend_hash_index_find(data, 3);
1530 members_zv = zend_hash_index_find(data, 4);
1531
1532 if (!algo_zv || Z_TYPE_P(algo_zv) != IS_STRING
1533 || !magic_zv || Z_TYPE_P(magic_zv) != IS_LONG
1534 || !options_zv || Z_TYPE_P(options_zv) != IS_LONG
1535 || !hash_zv
1536 || !members_zv || Z_TYPE_P(members_zv) != IS_ARRAY) {
1537 zend_throw_exception(NULL, "Incomplete or ill-formed serialization data", 0);
1538 RETURN_THROWS();
1539 }
1540
1541 magic = Z_LVAL_P(magic_zv);
1542 options = Z_LVAL_P(options_zv);
1543 if (options & PHP_HASH_HMAC) {
1544 zend_throw_exception(NULL, "HashContext with HASH_HMAC option cannot be serialized", 0);
1545 RETURN_THROWS();
1546 }
1547
1548 ops = php_hash_fetch_ops(Z_STR_P(algo_zv));
1549 if (!ops) {
1550 zend_throw_exception(NULL, "Unknown hash algorithm", 0);
1551 RETURN_THROWS();
1552 } else if (!ops->hash_unserialize) {
1553 zend_throw_exception_ex(NULL, 0, "Hash algorithm \"%s\" cannot be unserialized", ops->algo);
1554 RETURN_THROWS();
1555 }
1556
1557 hash->ops = ops;
1558 hash->context = php_hash_alloc_context(ops);
1559 hash->options = options;
1560 ops->hash_init(hash->context, NULL);
1561
1562 unserialize_result = ops->hash_unserialize(hash, magic, hash_zv);
1563 if (unserialize_result != SUCCESS) {
1564 zend_throw_exception_ex(NULL, 0, "Incomplete or ill-formed serialization data (\"%s\" code %d)", ops->algo, unserialize_result);
1565 /* free context */
1566 php_hashcontext_dtor(Z_OBJ_P(object));
1567 RETURN_THROWS();
1568 }
1569
1570 object_properties_load(&hash->std, Z_ARRVAL_P(members_zv));
1571 }
1572 /* }}} */
1573
1574 /* {{{ PHP_MINIT_FUNCTION */
PHP_MINIT_FUNCTION(hash)1575 PHP_MINIT_FUNCTION(hash)
1576 {
1577 zend_hash_init(&php_hash_hashtable, 35, NULL, NULL, 1);
1578
1579 php_hash_register_algo("md2", &php_hash_md2_ops);
1580 php_hash_register_algo("md4", &php_hash_md4_ops);
1581 php_hash_register_algo("md5", &php_hash_md5_ops);
1582 php_hash_register_algo("sha1", &php_hash_sha1_ops);
1583 php_hash_register_algo("sha224", &php_hash_sha224_ops);
1584 php_hash_register_algo("sha256", &php_hash_sha256_ops);
1585 php_hash_register_algo("sha384", &php_hash_sha384_ops);
1586 php_hash_register_algo("sha512/224", &php_hash_sha512_224_ops);
1587 php_hash_register_algo("sha512/256", &php_hash_sha512_256_ops);
1588 php_hash_register_algo("sha512", &php_hash_sha512_ops);
1589 php_hash_register_algo("sha3-224", &php_hash_sha3_224_ops);
1590 php_hash_register_algo("sha3-256", &php_hash_sha3_256_ops);
1591 php_hash_register_algo("sha3-384", &php_hash_sha3_384_ops);
1592 php_hash_register_algo("sha3-512", &php_hash_sha3_512_ops);
1593 php_hash_register_algo("ripemd128", &php_hash_ripemd128_ops);
1594 php_hash_register_algo("ripemd160", &php_hash_ripemd160_ops);
1595 php_hash_register_algo("ripemd256", &php_hash_ripemd256_ops);
1596 php_hash_register_algo("ripemd320", &php_hash_ripemd320_ops);
1597 php_hash_register_algo("whirlpool", &php_hash_whirlpool_ops);
1598 php_hash_register_algo("tiger128,3", &php_hash_3tiger128_ops);
1599 php_hash_register_algo("tiger160,3", &php_hash_3tiger160_ops);
1600 php_hash_register_algo("tiger192,3", &php_hash_3tiger192_ops);
1601 php_hash_register_algo("tiger128,4", &php_hash_4tiger128_ops);
1602 php_hash_register_algo("tiger160,4", &php_hash_4tiger160_ops);
1603 php_hash_register_algo("tiger192,4", &php_hash_4tiger192_ops);
1604 php_hash_register_algo("snefru", &php_hash_snefru_ops);
1605 php_hash_register_algo("snefru256", &php_hash_snefru_ops);
1606 php_hash_register_algo("gost", &php_hash_gost_ops);
1607 php_hash_register_algo("gost-crypto", &php_hash_gost_crypto_ops);
1608 php_hash_register_algo("adler32", &php_hash_adler32_ops);
1609 php_hash_register_algo("crc32", &php_hash_crc32_ops);
1610 php_hash_register_algo("crc32b", &php_hash_crc32b_ops);
1611 php_hash_register_algo("crc32c", &php_hash_crc32c_ops);
1612 php_hash_register_algo("fnv132", &php_hash_fnv132_ops);
1613 php_hash_register_algo("fnv1a32", &php_hash_fnv1a32_ops);
1614 php_hash_register_algo("fnv164", &php_hash_fnv164_ops);
1615 php_hash_register_algo("fnv1a64", &php_hash_fnv1a64_ops);
1616 php_hash_register_algo("joaat", &php_hash_joaat_ops);
1617 php_hash_register_algo("murmur3a", &php_hash_murmur3a_ops);
1618 php_hash_register_algo("murmur3c", &php_hash_murmur3c_ops);
1619 php_hash_register_algo("murmur3f", &php_hash_murmur3f_ops);
1620 php_hash_register_algo("xxh32", &php_hash_xxh32_ops);
1621 php_hash_register_algo("xxh64", &php_hash_xxh64_ops);
1622 php_hash_register_algo("xxh3", &php_hash_xxh3_64_ops);
1623 php_hash_register_algo("xxh128", &php_hash_xxh3_128_ops);
1624
1625 PHP_HASH_HAVAL_REGISTER(3,128);
1626 PHP_HASH_HAVAL_REGISTER(3,160);
1627 PHP_HASH_HAVAL_REGISTER(3,192);
1628 PHP_HASH_HAVAL_REGISTER(3,224);
1629 PHP_HASH_HAVAL_REGISTER(3,256);
1630
1631 PHP_HASH_HAVAL_REGISTER(4,128);
1632 PHP_HASH_HAVAL_REGISTER(4,160);
1633 PHP_HASH_HAVAL_REGISTER(4,192);
1634 PHP_HASH_HAVAL_REGISTER(4,224);
1635 PHP_HASH_HAVAL_REGISTER(4,256);
1636
1637 PHP_HASH_HAVAL_REGISTER(5,128);
1638 PHP_HASH_HAVAL_REGISTER(5,160);
1639 PHP_HASH_HAVAL_REGISTER(5,192);
1640 PHP_HASH_HAVAL_REGISTER(5,224);
1641 PHP_HASH_HAVAL_REGISTER(5,256);
1642
1643 REGISTER_LONG_CONSTANT("HASH_HMAC", PHP_HASH_HMAC, CONST_CS | CONST_PERSISTENT);
1644
1645 php_hashcontext_ce = register_class_HashContext();
1646 php_hashcontext_ce->create_object = php_hashcontext_create;
1647
1648 memcpy(&php_hashcontext_handlers, &std_object_handlers,
1649 sizeof(zend_object_handlers));
1650 php_hashcontext_handlers.offset = XtOffsetOf(php_hashcontext_object, std);
1651 php_hashcontext_handlers.free_obj = php_hashcontext_free;
1652 php_hashcontext_handlers.clone_obj = php_hashcontext_clone;
1653
1654 #ifdef PHP_MHASH_BC
1655 mhash_init(INIT_FUNC_ARGS_PASSTHRU);
1656 #endif
1657
1658 return SUCCESS;
1659 }
1660 /* }}} */
1661
1662 /* {{{ PHP_MSHUTDOWN_FUNCTION */
PHP_MSHUTDOWN_FUNCTION(hash)1663 PHP_MSHUTDOWN_FUNCTION(hash)
1664 {
1665 zend_hash_destroy(&php_hash_hashtable);
1666
1667 return SUCCESS;
1668 }
1669 /* }}} */
1670
1671 /* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(hash)1672 PHP_MINFO_FUNCTION(hash)
1673 {
1674 char buffer[2048];
1675 zend_string *str;
1676 char *s = buffer, *e = s + sizeof(buffer);
1677
1678 ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) {
1679 s += slprintf(s, e - s, "%s ", ZSTR_VAL(str));
1680 } ZEND_HASH_FOREACH_END();
1681 *s = 0;
1682
1683 php_info_print_table_start();
1684 php_info_print_table_row(2, "hash support", "enabled");
1685 php_info_print_table_row(2, "Hashing Engines", buffer);
1686 php_info_print_table_end();
1687
1688 #ifdef PHP_MHASH_BC
1689 php_info_print_table_start();
1690 php_info_print_table_row(2, "MHASH support", "Enabled");
1691 php_info_print_table_row(2, "MHASH API Version", "Emulated Support");
1692 php_info_print_table_end();
1693 #endif
1694
1695 }
1696 /* }}} */
1697
1698 /* {{{ hash_module_entry */
1699 zend_module_entry hash_module_entry = {
1700 STANDARD_MODULE_HEADER,
1701 PHP_HASH_EXTNAME,
1702 ext_functions,
1703 PHP_MINIT(hash),
1704 PHP_MSHUTDOWN(hash),
1705 NULL, /* RINIT */
1706 NULL, /* RSHUTDOWN */
1707 PHP_MINFO(hash),
1708 PHP_HASH_VERSION,
1709 STANDARD_MODULE_PROPERTIES
1710 };
1711 /* }}} */
1712
