Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-31 19:25
📄 php_hash.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Sara Golemon <pollita@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_H #define PHP_HASH_H #include "php.h" #define PHP_HASH_EXTNAME "hash" #define PHP_HASH_VERSION PHP_VERSION #define PHP_MHASH_VERSION PHP_VERSION #define PHP_HASH_HMAC 0x0001 #define PHP_HASH_SERIALIZE_MAGIC_SPEC 2 #define L64 INT64_C typedef enum { HASH_SPEC_SUCCESS = 0, HASH_SPEC_FAILURE = -1, WRONG_CONTEXT_SIZE = -999, BYTE_OFFSET_POS_ERROR = -1000, CONTEXT_VALIDATION_FAILURE = -2000, } hash_spec_result; typedef struct _php_hashcontext_object php_hashcontext_object; typedef void (php_hash_init_func_t)(void context, HashTable args); typedef void (php_hash_update_func_t)(void context, const unsigned char buf, size_t count); typedef void (php_hash_final_func_t)(unsigned char digest, void context); typedef zend_result (php_hash_copy_func_t)(const void ops, const void orig_context, void dest_context); typedef hash_spec_result (php_hash_serialize_func_t)(const php_hashcontext_object hash, zend_long magic, zval zv); typedef hash_spec_result (php_hash_unserialize_func_t)(php_hashcontext_object hash, zend_long magic, const zval zv); typedef struct _php_hash_ops { const char algo; php_hash_init_func_t hash_init; php_hash_update_func_t hash_update; php_hash_final_func_t hash_final; php_hash_copy_func_t hash_copy; php_hash_serialize_func_t hash_serialize; php_hash_unserialize_func_t hash_unserialize; const char serialize_spec; size_t digest_size; size_t block_size; size_t context_size; unsigned is_crypto: 1; } php_hash_ops; struct _php_hashcontext_object { const php_hash_ops ops; void context; zend_long options; unsigned char key; zend_object std; }; static inline php_hashcontext_object php_hashcontext_from_object(zend_object obj) { return ((php_hashcontext_object)(obj + 1)) - 1; } extern const php_hash_ops php_hash_md2_ops; extern const php_hash_ops php_hash_md4_ops; extern const php_hash_ops php_hash_md5_ops; extern const php_hash_ops php_hash_sha1_ops; extern const php_hash_ops php_hash_sha224_ops; extern const php_hash_ops php_hash_sha256_ops; extern const php_hash_ops php_hash_sha384_ops; extern const php_hash_ops php_hash_sha512_ops; extern const php_hash_ops php_hash_sha512_256_ops; extern const php_hash_ops php_hash_sha512_224_ops; extern const php_hash_ops php_hash_sha3_224_ops; extern const php_hash_ops php_hash_sha3_256_ops; extern const php_hash_ops php_hash_sha3_384_ops; extern const php_hash_ops php_hash_sha3_512_ops; extern const php_hash_ops php_hash_ripemd128_ops; extern const php_hash_ops php_hash_ripemd160_ops; extern const php_hash_ops php_hash_ripemd256_ops; extern const php_hash_ops php_hash_ripemd320_ops; extern const php_hash_ops php_hash_whirlpool_ops; extern const php_hash_ops php_hash_3tiger128_ops; extern const php_hash_ops php_hash_3tiger160_ops; extern const php_hash_ops php_hash_3tiger192_ops; extern const php_hash_ops php_hash_4tiger128_ops; extern const php_hash_ops php_hash_4tiger160_ops; extern const php_hash_ops php_hash_4tiger192_ops; extern const php_hash_ops php_hash_snefru_ops; extern const php_hash_ops php_hash_gost_ops; extern const php_hash_ops php_hash_gost_crypto_ops; extern const php_hash_ops php_hash_adler32_ops; extern const php_hash_ops php_hash_crc32_ops; extern const php_hash_ops php_hash_crc32b_ops; extern const php_hash_ops php_hash_crc32c_ops; extern const php_hash_ops php_hash_fnv132_ops; extern const php_hash_ops php_hash_fnv1a32_ops; extern const php_hash_ops php_hash_fnv164_ops; extern const php_hash_ops php_hash_fnv1a64_ops; extern const php_hash_ops php_hash_joaat_ops; extern const php_hash_ops php_hash_murmur3a_ops; extern const php_hash_ops php_hash_murmur3c_ops; extern const php_hash_ops php_hash_murmur3f_ops; extern const php_hash_ops php_hash_xxh32_ops; extern const php_hash_ops php_hash_xxh64_ops; extern const php_hash_ops php_hash_xxh3_64_ops; extern const php_hash_ops php_hash_xxh3_128_ops; #define PHP_HASH_HAVAL_OPS(p,b) extern const php_hash_ops php_hash_##p##haval##b##_ops; PHP_HASH_HAVAL_OPS(3,128) PHP_HASH_HAVAL_OPS(3,160) PHP_HASH_HAVAL_OPS(3,192) PHP_HASH_HAVAL_OPS(3,224) PHP_HASH_HAVAL_OPS(3,256) PHP_HASH_HAVAL_OPS(4,128) PHP_HASH_HAVAL_OPS(4,160) PHP_HASH_HAVAL_OPS(4,192) PHP_HASH_HAVAL_OPS(4,224) PHP_HASH_HAVAL_OPS(4,256) PHP_HASH_HAVAL_OPS(5,128) PHP_HASH_HAVAL_OPS(5,160) PHP_HASH_HAVAL_OPS(5,192) PHP_HASH_HAVAL_OPS(5,224) PHP_HASH_HAVAL_OPS(5,256) extern zend_module_entry hash_module_entry; #define phpext_hash_ptr &hash_module_entry #ifdef PHP_WIN32 # define PHP_HASH_API __declspec(dllexport) #elif defined(__GNUC__) && __GNUC__ >= 4 # define PHP_HASH_API __attribute__ ((visibility("default"))) #else # define PHP_HASH_API #endif extern PHP_HASH_API zend_class_entry php_hashcontext_ce; PHP_HASH_API const php_hash_ops php_hash_fetch_ops(zend_string algo); PHP_HASH_API void php_hash_register_algo(const char algo, const php_hash_ops ops); PHP_HASH_API zend_result php_hash_copy(const void ops, const void orig_context, void dest_context); PHP_HASH_API hash_spec_result php_hash_serialize(const php_hashcontext_object context, zend_long magic, zval zv); PHP_HASH_API hash_spec_result php_hash_unserialize(php_hashcontext_object context, zend_long magic, const zval zv); PHP_HASH_API hash_spec_result php_hash_serialize_spec(const php_hashcontext_object context, zval zv, const char spec); PHP_HASH_API hash_spec_result php_hash_unserialize_spec(php_hashcontext_object hash, const zval zv, const char spec); static inline void php_hash_alloc_context(const php_hash_ops ops) { /* Zero out context memory so serialization doesn't expose internals / return ecalloc(1, ops->context_size); } static inline void php_hash_bin2hex(char out, const unsigned char in, size_t in_len) { static const char hexits[17] = "0123456789abcdef"; size_t i; for(i = 0; i < in_len; i++) { out[i 2] = hexits[in[i] >> 4]; out[(i * 2) + 1] = hexits[in[i] & 0x0F]; } } #endif /* PHP_HASH_H */	6.8 KB	2026-03-12 17:17
📄 php_hash_adler32.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Wallner <mike@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_ADLER32_H #define PHP_HASH_ADLER32_H typedef struct { uint32_t state; } PHP_ADLER32_CTX; #define PHP_ADLER32_SPEC "l." PHP_HASH_API void PHP_ADLER32Init(PHP_ADLER32_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_ADLER32Update(PHP_ADLER32_CTX context, const unsigned char input, size_t len); PHP_HASH_API void PHP_ADLER32Final(unsigned char digest[4], PHP_ADLER32_CTX context); PHP_HASH_API zend_result PHP_ADLER32Copy(const php_hash_ops ops, const PHP_ADLER32_CTX orig_context, PHP_ADLER32_CTX *copy_context); #endif	1.53 KB	2026-03-12 17:17
📄 php_hash_crc32.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Wallner <mike@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_CRC32_H #define PHP_HASH_CRC32_H #include "ext/standard/basic_functions.h" typedef struct { uint32_t state; } PHP_CRC32_CTX; #define PHP_CRC32_SPEC "l." PHP_HASH_API void PHP_CRC32Init(PHP_CRC32_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_CRC32Update(PHP_CRC32_CTX context, const unsigned char input, size_t len); PHP_HASH_API void PHP_CRC32BUpdate(PHP_CRC32_CTX context, const unsigned char input, size_t len); PHP_HASH_API void PHP_CRC32CUpdate(PHP_CRC32_CTX context, const unsigned char input, size_t len); PHP_HASH_API void PHP_CRC32LEFinal(unsigned char digest[4], PHP_CRC32_CTX context); PHP_HASH_API void PHP_CRC32BEFinal(unsigned char digest[4], PHP_CRC32_CTX context); PHP_HASH_API zend_result PHP_CRC32Copy(const php_hash_ops ops, const PHP_CRC32_CTX orig_context, PHP_CRC32_CTX copy_context); #endif	1.83 KB	2026-03-12 17:17
📄 php_hash_fnv.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Maclean <mgdm@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_FNV_H #define PHP_HASH_FNV_H #define PHP_FNV1_32_INIT ((uint32_t)0x811c9dc5) #define PHP_FNV_32_PRIME ((uint32_t)0x01000193) #define PHP_FNV1_64_INIT ((uint64_t)0xcbf29ce484222325ULL) #define PHP_FNV_64_PRIME ((uint64_t)0x100000001b3ULL) / * hash types / enum php_fnv_type { PHP_FNV_NONE = 0, / invalid FNV hash type / PHP_FNV0_32 = 1, / FNV-0 32 bit hash / PHP_FNV1_32 = 2, / FNV-1 32 bit hash / PHP_FNV1a_32 = 3, / FNV-1a 32 bit hash / PHP_FNV0_64 = 4, / FNV-0 64 bit hash / PHP_FNV1_64 = 5, / FNV-1 64 bit hash / PHP_FNV1a_64 = 6, / FNV-1a 64 bit hash / }; typedef struct { uint32_t state; } PHP_FNV132_CTX; #define PHP_FNV132_SPEC "l." typedef struct { uint64_t state; } PHP_FNV164_CTX; #define PHP_FNV164_SPEC "q." PHP_HASH_API void PHP_FNV132Init(PHP_FNV132_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_FNV132Update(PHP_FNV132_CTX context, const unsigned char input, size_t inputLen); PHP_HASH_API void PHP_FNV1a32Update(PHP_FNV132_CTX context, const unsigned char input, size_t inputLen); PHP_HASH_API void PHP_FNV132Final(unsigned char digest[4], PHP_FNV132_CTX context); PHP_HASH_API void PHP_FNV164Init(PHP_FNV164_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_FNV164Update(PHP_FNV164_CTX context, const unsigned char input, size_t inputLen); PHP_HASH_API void PHP_FNV1a64Update(PHP_FNV164_CTX context, const unsigned char input, size_t inputLen); PHP_HASH_API void PHP_FNV164Final(unsigned char digest[8], PHP_FNV164_CTX * context); static uint32_t fnv_32_buf(void buf, size_t len, uint32_t hval, int alternate); static uint64_t fnv_64_buf(void buf, size_t len, uint64_t hval, int alternate); #endif	2.67 KB	2026-03-12 17:17
📄 php_hash_gost.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Wallner <mike@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_GOST_H #define PHP_HASH_GOST_H / GOST context / typedef struct { uint32_t state[16]; uint32_t count[2]; unsigned char length; unsigned char buffer[32]; const uint32_t (tables)[4][256]; } PHP_GOST_CTX; #define PHP_GOST_SPEC "l16l2bb32" PHP_HASH_API void PHP_GOSTInit(PHP_GOST_CTX , ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_GOSTUpdate(PHP_GOST_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_GOSTFinal(unsigned char[32], PHP_GOST_CTX *); #endif	1.47 KB	2026-03-12 17:17
📄 php_hash_haval.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Sara Golemon <pollita@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_HAVAL_H #define PHP_HASH_HAVAL_H / HAVAL context. / typedef struct { uint32_t state[8]; uint32_t count[2]; unsigned char buffer[128]; char passes; short output; void (Transform)(uint32_t state[8], const unsigned char block[128]); } PHP_HAVAL_CTX; #define PHP_HAVAL_SPEC "l8l2b128" #define PHP_HASH_HAVAL_INIT_DECL(p,b) PHP_HASH_API void PHP_##p##HAVAL##b##Init(PHP_HAVAL_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); \ PHP_HASH_API void PHP_HAVAL##b##Final(unsigned char, PHP_HAVAL_CTX ); PHP_HASH_API void PHP_HAVALUpdate(PHP_HAVAL_CTX , const unsigned char , size_t); PHP_HASH_HAVAL_INIT_DECL(3,128) PHP_HASH_HAVAL_INIT_DECL(3,160) PHP_HASH_HAVAL_INIT_DECL(3,192) PHP_HASH_HAVAL_INIT_DECL(3,224) PHP_HASH_HAVAL_INIT_DECL(3,256) PHP_HASH_HAVAL_INIT_DECL(4,128) PHP_HASH_HAVAL_INIT_DECL(4,160) PHP_HASH_HAVAL_INIT_DECL(4,192) PHP_HASH_HAVAL_INIT_DECL(4,224) PHP_HASH_HAVAL_INIT_DECL(4,256) PHP_HASH_HAVAL_INIT_DECL(5,128) PHP_HASH_HAVAL_INIT_DECL(5,160) PHP_HASH_HAVAL_INIT_DECL(5,192) PHP_HASH_HAVAL_INIT_DECL(5,224) PHP_HASH_HAVAL_INIT_DECL(5,256) #endif	2.05 KB	2026-03-12 17:17
📄 php_hash_joaat.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Martin Jansen <mj@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_JOAAT_H #define PHP_HASH_JOAAT_H typedef struct { uint32_t state; } PHP_JOAAT_CTX; #define PHP_JOAAT_SPEC "l." PHP_HASH_API void PHP_JOAATInit(PHP_JOAAT_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_JOAATUpdate(PHP_JOAAT_CTX context, const unsigned char input, size_t inputLen); PHP_HASH_API void PHP_JOAATFinal(unsigned char digest[4], PHP_JOAAT_CTX context); static uint32_t joaat_buf(void *buf, size_t len, uint32_t hval); #endif	1.44 KB	2026-03-12 17:17
📄 php_hash_md.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Original Author: Rasmus Lerdorf <rasmus@lerdorf.on.ca> \| \| Modified for pHASH by: Sara Golemon <pollita@php.net> +----------------------------------------------------------------------+ / #ifndef PHP_HASH_MD_H #define PHP_HASH_MD_H #include "ext/standard/md5.h" / MD4 context / typedef struct { uint32_t state[4]; uint32_t count[2]; unsigned char buffer[64]; } PHP_MD4_CTX; #define PHP_MD4_SPEC "l4l2b64." #define PHP_MD4Init(ctx) PHP_MD4InitArgs(ctx, NULL) PHP_HASH_API void PHP_MD4InitArgs(PHP_MD4_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_MD4Update(PHP_MD4_CTX context, const unsigned char , size_t); PHP_HASH_API void PHP_MD4Final(unsigned char[16], PHP_MD4_CTX ); /* MD2 context / typedef struct { unsigned char state[48]; unsigned char checksum[16]; unsigned char buffer[16]; unsigned char in_buffer; } PHP_MD2_CTX; #define PHP_MD2_SPEC "b48b16b16b." #define PHP_MD2Init(ctx) PHP_MD2InitArgs(ctx, NULL) PHP_HASH_API void PHP_MD2InitArgs(PHP_MD2_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_MD2Update(PHP_MD2_CTX context, const unsigned char , size_t); PHP_HASH_API void PHP_MD2Final(unsigned char[16], PHP_MD2_CTX ); #endif	2.02 KB	2026-03-12 17:17
📄 php_hash_murmur.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Anatol Belski <ab@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_MURMUR_H #define PHP_HASH_MURMUR_H typedef struct { uint32_t h; uint32_t carry; uint32_t len; } PHP_MURMUR3A_CTX; #define PHP_MURMUR3A_SPEC "lll" PHP_HASH_API void PHP_MURMUR3AInit(PHP_MURMUR3A_CTX ctx, HashTable args); PHP_HASH_API void PHP_MURMUR3AUpdate(PHP_MURMUR3A_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_MURMUR3AFinal(unsigned char digest[4], PHP_MURMUR3A_CTX ctx); PHP_HASH_API zend_result PHP_MURMUR3ACopy(const php_hash_ops ops, const PHP_MURMUR3A_CTX orig_context, PHP_MURMUR3A_CTX copy_context); typedef struct { uint32_t h[4]; uint32_t carry[4]; uint32_t len; } PHP_MURMUR3C_CTX; #define PHP_MURMUR3C_SPEC "lllllllll" PHP_HASH_API void PHP_MURMUR3CInit(PHP_MURMUR3C_CTX ctx, HashTable args); PHP_HASH_API void PHP_MURMUR3CUpdate(PHP_MURMUR3C_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_MURMUR3CFinal(unsigned char digest[16], PHP_MURMUR3C_CTX ctx); PHP_HASH_API zend_result PHP_MURMUR3CCopy(const php_hash_ops ops, const PHP_MURMUR3C_CTX orig_context, PHP_MURMUR3C_CTX copy_context); typedef struct { uint64_t h[2]; uint64_t carry[2]; uint32_t len; } PHP_MURMUR3F_CTX; #define PHP_MURMUR3F_SPEC "qqqql" PHP_HASH_API void PHP_MURMUR3FInit(PHP_MURMUR3F_CTX ctx, HashTable args); PHP_HASH_API void PHP_MURMUR3FUpdate(PHP_MURMUR3F_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_MURMUR3FFinal(unsigned char digest[16], PHP_MURMUR3F_CTX ctx); PHP_HASH_API zend_result PHP_MURMUR3FCopy(const php_hash_ops ops, const PHP_MURMUR3F_CTX orig_context, PHP_MURMUR3F_CTX copy_context); #endif / PHP_HASH_MURMUR_H */	2.58 KB	2026-03-12 17:17
📄 php_hash_ripemd.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Sara Golemon <pollita@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_RIPEMD_H #define PHP_HASH_RIPEMD_H / RIPEMD context. / typedef struct { uint32_t state[4]; / state (ABCD) / uint32_t count[2]; / number of bits, modulo 2^64 (lsb first) / unsigned char buffer[64]; / input buffer / } PHP_RIPEMD128_CTX; #define PHP_RIPEMD128_SPEC "l4l2b64." typedef struct { uint32_t state[5]; / state (ABCD) / uint32_t count[2]; / number of bits, modulo 2^64 (lsb first) / unsigned char buffer[64]; / input buffer / } PHP_RIPEMD160_CTX; #define PHP_RIPEMD160_SPEC "l5l2b64." typedef struct { uint32_t state[8]; / state (ABCD) / uint32_t count[2]; / number of bits, modulo 2^64 (lsb first) / unsigned char buffer[64]; / input buffer / } PHP_RIPEMD256_CTX; #define PHP_RIPEMD256_SPEC "l8l2b64." typedef struct { uint32_t state[10]; / state (ABCD) / uint32_t count[2]; / number of bits, modulo 2^64 (lsb first) / unsigned char buffer[64]; / input buffer / } PHP_RIPEMD320_CTX; #define PHP_RIPEMD320_SPEC "l10l2b64." PHP_HASH_API void PHP_RIPEMD128Init(PHP_RIPEMD128_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_RIPEMD128Update(PHP_RIPEMD128_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_RIPEMD128Final(unsigned char[16], PHP_RIPEMD128_CTX ); PHP_HASH_API void PHP_RIPEMD160Init(PHP_RIPEMD160_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_RIPEMD160Update(PHP_RIPEMD160_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_RIPEMD160Final(unsigned char[20], PHP_RIPEMD160_CTX ); PHP_HASH_API void PHP_RIPEMD256Init(PHP_RIPEMD256_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_RIPEMD256Update(PHP_RIPEMD256_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_RIPEMD256Final(unsigned char[32], PHP_RIPEMD256_CTX ); PHP_HASH_API void PHP_RIPEMD320Init(PHP_RIPEMD320_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_RIPEMD320Update(PHP_RIPEMD320_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_RIPEMD320Final(unsigned char[40], PHP_RIPEMD320_CTX ); #endif / PHP_HASH_RIPEMD_H */	3 KB	2026-03-12 17:17
📄 php_hash_sha.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| SHA1 Author: Stefan Esser <sesser@php.net> \| \| SHA256 Author: Sara Golemon <pollita@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_SHA_H #define PHP_HASH_SHA_H #include "ext/standard/sha1.h" / SHA224 context. / typedef struct { uint32_t state[8]; / state / uint32_t count[2]; / number of bits, modulo 2^64 / unsigned char buffer[64]; / input buffer / } PHP_SHA224_CTX; #define PHP_SHA224_SPEC "l8l2b64." #define PHP_SHA224Init(ctx) PHP_SHA224InitArgs(ctx, NULL) PHP_HASH_API void PHP_SHA224InitArgs(PHP_SHA224_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA224Update(PHP_SHA224_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_SHA224Final(unsigned char[28], PHP_SHA224_CTX ); /* SHA256 context. / typedef struct { uint32_t state[8]; / state / uint32_t count[2]; / number of bits, modulo 2^64 / unsigned char buffer[64]; / input buffer / } PHP_SHA256_CTX; #define PHP_SHA256_SPEC "l8l2b64." #define PHP_SHA256Init(ctx) PHP_SHA256InitArgs(ctx, NULL) PHP_HASH_API void PHP_SHA256InitArgs(PHP_SHA256_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA256Update(PHP_SHA256_CTX , const unsigned char , size_t); #if defined(__cplusplus) \|\| defined(_MSC_VER) # define PHP_STATIC_RESTRICT #else # define PHP_STATIC_RESTRICT static restrict #endif #if defined(__SSE2__) void SHA256_Transform_sse2(uint32_t state[PHP_STATIC_RESTRICT 8], const uint8_t block[PHP_STATIC_RESTRICT 64], uint32_t W[PHP_STATIC_RESTRICT 64], uint32_t S[PHP_STATIC_RESTRICT 8]); #endif #if ((defined(__i386__) \|\| defined(__x86_64__)) && defined(HAVE_IMMINTRIN_H)) \|\| defined(_M_X64) \|\| defined(_M_IX86) # if defined(__SSSE3__) && defined(__SHA__) # define PHP_HASH_INTRIN_SHA_NATIVE 1 # elif defined(HAVE_FUNC_ATTRIBUTE_TARGET) \|\| defined(_M_X64) \|\| defined(_M_IX86) # define PHP_HASH_INTRIN_SHA_RESOLVER 1 # endif #endif #if defined(PHP_HASH_INTRIN_SHA_NATIVE) \|\| defined(PHP_HASH_INTRIN_SHA_RESOLVER) void SHA256_Transform_shani(uint32_t state[PHP_STATIC_RESTRICT 8], const uint8_t block[PHP_STATIC_RESTRICT 64]); #endif PHP_HASH_API void PHP_SHA256Final(unsigned char[32], PHP_SHA256_CTX ); /* SHA384 context / typedef struct { uint64_t state[8]; / state / uint64_t count[2]; / number of bits, modulo 2^128 / unsigned char buffer[128]; / input buffer / } PHP_SHA384_CTX; #define PHP_SHA384_SPEC "q8q2b128." #define PHP_SHA384Init(ctx) PHP_SHA384InitArgs(ctx, NULL) PHP_HASH_API void PHP_SHA384InitArgs(PHP_SHA384_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA384Update(PHP_SHA384_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_SHA384Final(unsigned char[48], PHP_SHA384_CTX ); /* SHA512 context / typedef struct { uint64_t state[8]; / state / uint64_t count[2]; / number of bits, modulo 2^128 / unsigned char buffer[128]; / input buffer / } PHP_SHA512_CTX; #define PHP_SHA512_SPEC "q8q2b128." #define PHP_SHA512Init(ctx) PHP_SHA512InitArgs(ctx, NULL) PHP_HASH_API void PHP_SHA512InitArgs(PHP_SHA512_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA512Update(PHP_SHA512_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_SHA512Final(unsigned char[64], PHP_SHA512_CTX ); #define PHP_SHA512_256Init(ctx) PHP_SHA512_256InitArgs(ctx, NULL) PHP_HASH_API void PHP_SHA512_256InitArgs(PHP_SHA512_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); #define PHP_SHA512_256Update PHP_SHA512Update PHP_HASH_API void PHP_SHA512_256Final(unsigned char[32], PHP_SHA512_CTX ); #define PHP_SHA512_224Init(ctx) PHP_SHA512_224InitArgs(ctx, NULL) PHP_HASH_API void PHP_SHA512_224InitArgs(PHP_SHA512_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); #define PHP_SHA512_224Update PHP_SHA512Update PHP_HASH_API void PHP_SHA512_224Final(unsigned char[28], PHP_SHA512_CTX ); #endif /* PHP_HASH_SHA_H */	4.66 KB	2026-03-12 17:17
📄 php_hash_sha3.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Sara Golemon <pollita@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_SHA3_H #define PHP_HASH_SHA3_H typedef struct { #ifdef HAVE_SLOW_HASH3 unsigned char state[200]; // 5 5 * sizeof(uint64) uint32_t pos; #else unsigned char state[224]; // this must fit a Keccak_HashInstance #endif } PHP_SHA3_CTX; #ifdef HAVE_SLOW_HASH3 #define PHP_SHA3_SPEC "b200l." #endif typedef PHP_SHA3_CTX PHP_SHA3_224_CTX; typedef PHP_SHA3_CTX PHP_SHA3_256_CTX; typedef PHP_SHA3_CTX PHP_SHA3_384_CTX; typedef PHP_SHA3_CTX PHP_SHA3_512_CTX; PHP_HASH_API void PHP_SHA3224Init(PHP_SHA3_224_CTX, ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA3224Update(PHP_SHA3_224_CTX, const unsigned char, size_t); PHP_HASH_API void PHP_SAH3224Final(unsigned char[32], PHP_SHA3_224_CTX); PHP_HASH_API void PHP_SHA3256Init(PHP_SHA3_256_CTX, ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA3256Update(PHP_SHA3_256_CTX, const unsigned char, size_t); PHP_HASH_API void PHP_SAH3256Final(unsigned char[32], PHP_SHA3_256_CTX); PHP_HASH_API void PHP_SHA3384Init(PHP_SHA3_384_CTX, ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA3384Update(PHP_SHA3_384_CTX, const unsigned char, size_t); PHP_HASH_API void PHP_SAH3384Final(unsigned char[32], PHP_SHA3_384_CTX); PHP_HASH_API void PHP_SHA3512Init(PHP_SHA3_512_CTX, ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SHA3512Update(PHP_SHA3_512_CTX, const unsigned char, size_t); PHP_HASH_API void PHP_SAH3512Final(unsigned char[32], PHP_SHA3_512_CTX); #endif	2.42 KB	2026-03-12 17:17
📄 php_hash_snefru.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Wallner <mike@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_SNEFRU_H #define PHP_HASH_SNEFRU_H / SNEFRU-2.5a with 8 passes and 256 bit hash output * AKA "Xerox Secure Hash Function" / / SNEFRU context / typedef struct { uint32_t state[16]; uint32_t count[2]; unsigned char length; unsigned char buffer[32]; } PHP_SNEFRU_CTX; #define PHP_SNEFRU_SPEC "l16l2bb32" PHP_HASH_API void PHP_SNEFRUInit(PHP_SNEFRU_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_SNEFRUUpdate(PHP_SNEFRU_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_SNEFRUFinal(unsigned char[32], PHP_SNEFRU_CTX ); #endif	1.54 KB	2026-03-12 17:17
📄 php_hash_tiger.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Wallner <mike@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_TIGER_H #define PHP_HASH_TIGER_H / TIGER context / typedef struct { uint64_t state[3]; uint64_t passed; unsigned char buffer[64]; uint32_t length; unsigned int passes:1; } PHP_TIGER_CTX; #define PHP_TIGER_SPEC "q3qb64l" PHP_HASH_API void PHP_3TIGERInit(PHP_TIGER_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_4TIGERInit(PHP_TIGER_CTX context, ZEND_ATTRIBUTE_UNUSED HashTable args); PHP_HASH_API void PHP_TIGERUpdate(PHP_TIGER_CTX context, const unsigned char input, size_t len); PHP_HASH_API void PHP_TIGER128Final(unsigned char digest[16], PHP_TIGER_CTX context); PHP_HASH_API void PHP_TIGER160Final(unsigned char digest[20], PHP_TIGER_CTX context); PHP_HASH_API void PHP_TIGER192Final(unsigned char digest[24], PHP_TIGER_CTX context); #endif	1.76 KB	2026-03-12 17:17
📄 php_hash_whirlpool.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Michael Wallner <mike@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_WHIRLPOOL_H #define PHP_HASH_WHIRLPOOL_H / WHIRLPOOL context / typedef struct { uint64_t state[8]; unsigned char bitlength[32]; struct { int pos; int bits; unsigned char data[64]; } buffer; } PHP_WHIRLPOOL_CTX; #define PHP_WHIRLPOOL_SPEC "q8b32iib64." PHP_HASH_API void PHP_WHIRLPOOLInit(PHP_WHIRLPOOL_CTX , ZEND_ATTRIBUTE_UNUSED HashTable ); PHP_HASH_API void PHP_WHIRLPOOLUpdate(PHP_WHIRLPOOL_CTX , const unsigned char , size_t); PHP_HASH_API void PHP_WHIRLPOOLFinal(unsigned char[64], PHP_WHIRLPOOL_CTX ); #endif	1.51 KB	2026-03-12 17:17
📄 php_hash_xxhash.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Anatol Belski <ab@php.net> \| +----------------------------------------------------------------------+ / #ifndef PHP_HASH_XXHASH_H #define PHP_HASH_XXHASH_H #define XXH_INLINE_ALL 1 #include "xxhash/xxhash.h" typedef struct { XXH32_state_t s; } PHP_XXH32_CTX; #define PHP_XXH32_SPEC "llllllllllll" PHP_HASH_API void PHP_XXH32Init(PHP_XXH32_CTX ctx, HashTable args); PHP_HASH_API void PHP_XXH32Update(PHP_XXH32_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_XXH32Final(unsigned char digest[4], PHP_XXH32_CTX ctx); PHP_HASH_API zend_result PHP_XXH32Copy(const php_hash_ops ops, const PHP_XXH32_CTX orig_context, PHP_XXH32_CTX copy_context); typedef struct { XXH64_state_t s; } PHP_XXH64_CTX; #define PHP_XXH64_SPEC "qqqqqqqqqllq" PHP_HASH_API void PHP_XXH64Init(PHP_XXH64_CTX ctx, HashTable args); PHP_HASH_API void PHP_XXH64Update(PHP_XXH64_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_XXH64Final(unsigned char digest[8], PHP_XXH64_CTX ctx); PHP_HASH_API zend_result PHP_XXH64Copy(const php_hash_ops ops, const PHP_XXH64_CTX orig_context, PHP_XXH64_CTX copy_context); #define PHP_XXH3_SECRET_SIZE_MIN XXH3_SECRET_SIZE_MIN #define PHP_XXH3_SECRET_SIZE_MAX 256 typedef struct { XXH3_state_t s; / The value must survive the whole streaming cycle from init to final. A more flexible mechanism would be to carry zend_string* passed through the options. However, that will require to introduce a destructor handler for ctx, so then it wolud be automatically called from the object destructor. Until that is given, the viable way is to use a plausible max secret length. / const unsigned char secret[PHP_XXH3_SECRET_SIZE_MAX]; } PHP_XXH3_CTX; typedef PHP_XXH3_CTX PHP_XXH3_64_CTX; PHP_HASH_API void PHP_XXH3_64_Init(PHP_XXH3_64_CTX ctx, HashTable args); PHP_HASH_API void PHP_XXH3_64_Update(PHP_XXH3_64_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_XXH3_64_Final(unsigned char digest[8], PHP_XXH3_64_CTX ctx); PHP_HASH_API zend_result PHP_XXH3_64_Copy(const php_hash_ops ops, const PHP_XXH3_64_CTX orig_context, PHP_XXH3_64_CTX copy_context); typedef PHP_XXH3_CTX PHP_XXH3_128_CTX; PHP_HASH_API void PHP_XXH3_128_Init(PHP_XXH3_128_CTX ctx, HashTable args); PHP_HASH_API void PHP_XXH3_128_Update(PHP_XXH3_128_CTX ctx, const unsigned char in, size_t len); PHP_HASH_API void PHP_XXH3_128_Final(unsigned char digest[16], PHP_XXH3_128_CTX ctx); PHP_HASH_API zend_result PHP_XXH3_128_Copy(const php_hash_ops ops, const PHP_XXH3_128_CTX orig_context, PHP_XXH3_128_CTX copy_context); #endif / PHP_HASH_XXHASH_H */	3.45 KB	2026-03-12 17:17
📁 xxhash	-	2026-03-31 19:25

Terminal