#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#if HAVE_LIBMHASH
#include "fcntl.h"
#include "php_mhash.h"
#include "mhash.h"
#include "php_ini.h"
#include "php_globals.h"
#include "ext/standard/info.h"
zend_function_entry mhash_functions[] = {
PHP_FE(mhash_get_block_size, NULL)
PHP_FE(mhash_get_hash_name, NULL)
PHP_FE(mhash_keygen_s2k, NULL)
PHP_FE(mhash_count, NULL)
PHP_FE(mhash, NULL)
{NULL, NULL, NULL}
};
zend_module_entry mhash_module_entry = {
STANDARD_MODULE_HEADER,
"mhash",
mhash_functions,
PHP_MINIT(mhash), NULL,
NULL, NULL,
PHP_MINFO(mhash),
NO_VERSION_YET,
STANDARD_MODULE_PROPERTIES,
};
#ifdef COMPILE_DL_MHASH
ZEND_GET_MODULE(mhash)
#endif
#define SALT_SIZE 8
PHP_MINIT_FUNCTION(mhash)
{
int i, n, l;
char *name;
char buf[128];
n = mhash_count() + 1;
for (i=0; i<n; i++) {
if ((name = mhash_get_hash_name(i))) {
l = slprintf(buf, 127, "MHASH_%s", name);
zend_register_long_constant(buf, l + 1, i, CONST_PERSISTENT, module_number TSRMLS_CC);
free(name);
}
}
return SUCCESS;
}
PHP_MINFO_FUNCTION(mhash)
{
char version[32];
snprintf(version, sizeof(version), "%d", MHASH_API_VERSION);
php_info_print_table_start();
php_info_print_table_row(2, "MHASH support", "Enabled");
php_info_print_table_row(2, "MHASH API Version", version);
php_info_print_table_end();
}
PHP_FUNCTION(mhash_count)
{
if (ZEND_NUM_ARGS() != 0) {
WRONG_PARAM_COUNT;
}
RETURN_LONG(mhash_count());
}
PHP_FUNCTION(mhash_get_block_size)
{
long hash;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hash) == FAILURE) {
return;
}
RETURN_LONG(mhash_get_block_size(hash));
}
PHP_FUNCTION(mhash_get_hash_name)
{
char *name;
long hash;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &hash) == FAILURE) {
return;
}
name = mhash_get_hash_name(hash);
if (name) {
RETVAL_STRING(name, 1);
free(name);
} else {
RETVAL_FALSE;
}
}
PHP_FUNCTION(mhash)
{
MHASH td;
int bsize;
unsigned char *hash_data;
long hash;
int data_len, key_len=0;
char *data, *key=NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls|s", &hash, &data, &data_len, &key, &key_len) == FAILURE) {
return;
}
bsize = mhash_get_block_size(hash);
if (key_len) {
if (mhash_get_hash_pblock(hash) == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "mhash initialization failed");
RETURN_FALSE;
}
td = mhash_hmac_init(hash, key, key_len, mhash_get_hash_pblock(hash));
} else {
td = mhash_init(hash);
}
if (td == MHASH_FAILED) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "mhash initialization failed");
RETURN_FALSE;
}
mhash(td, data, data_len);
if (key_len) {
hash_data = (unsigned char *) mhash_hmac_end(td);
} else {
hash_data = (unsigned char *) mhash_end(td);
}
if (hash_data) {
RETVAL_STRINGL(hash_data, bsize, 1);
mhash_free(hash_data);
} else {
RETURN_FALSE;
}
}
PHP_FUNCTION(mhash_keygen_s2k)
{
KEYGEN keystruct;
char salt[SALT_SIZE], *ret;
long hash, bytes;
char *password, *in_salt;
int password_len, salt_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lssl", &hash, &password, &password_len, &in_salt, &salt_len, &bytes) == FAILURE) {
return;
}
if (bytes <= 0){
php_error_docref(NULL TSRMLS_CC, E_WARNING, "the byte parameter must be greater than 0");
RETURN_FALSE;
}
salt_len = MIN(salt_len, SALT_SIZE);
if (salt_len > mhash_get_keygen_salt_size(KEYGEN_S2K_SALTED)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"The specified salt [%d] is more bytes than the required by the algorithm [%d]\n",
salt_len, mhash_get_keygen_salt_size(KEYGEN_S2K_SALTED));
}
memcpy(salt, in_salt, salt_len);
if (salt_len < SALT_SIZE) {
memset(salt + salt_len, 0, SALT_SIZE - salt_len);
}
salt_len = SALT_SIZE;
keystruct.hash_algorithm[0] = hash;
keystruct.hash_algorithm[1] = hash;
keystruct.count = 0;
keystruct.salt = salt;
keystruct.salt_size = salt_len;
ret = safe_emalloc(1, bytes, 1);
if (mhash_keygen_ext(KEYGEN_S2K_SALTED, keystruct, ret, bytes, password, password_len) >= 0) {
ret[bytes] = '\0';
RETVAL_STRINGL(ret, bytes, 0);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "mhash key generation failed");
efree(ret);
RETURN_FALSE;
}
}
#endif