From bab5db79f63541b20afd2b31c197dc24581e3be1 Mon Sep 17 00:00:00 2001 From: Derick Rethans Date: Fri, 11 Aug 2000 18:45:17 +0000 Subject: [PATCH] @ Added support for libmcrypt 2.4.4 --- ext/mcrypt/config.m4 | 13 +- ext/mcrypt/mcrypt.c | 1292 ++++++++++++++++++++++++++++++++++++++- ext/mcrypt/php_mcrypt.h | 67 ++ 3 files changed, 1344 insertions(+), 28 deletions(-) diff --git a/ext/mcrypt/config.m4 b/ext/mcrypt/config.m4 index 8fbee13736..67ed516c39 100644 --- a/ext/mcrypt/config.m4 +++ b/ext/mcrypt/config.m4 @@ -19,8 +19,19 @@ if test "$PHP_MCRYPT" != "no"; then AC_ADD_INCLUDE($MCRYPT_DIR/include) PHP_SUBST(MCRYPT_SHARED_LIBADD) + AC_CHECK_LIB(mcrypt, init_mcrypt, [ AC_DEFINE(HAVE_LIBMCRYPT22,1,[ ]) ]) + old_LIBS=$LIBS + LIBS="$LIBS -lltdl" + AC_CHECK_LIB(mcrypt, mcrypt_module_open, [LIBS="$LIBS -lltdl"],[ ],) + LIBS=$old_LIBS AC_ADD_LIBRARY_WITH_PATH(mcrypt, $MCRYPT_DIR/lib, MCRYPT_SHARED_LIBADD) - + if test "$ac_cv_lib_mcrypt_init_mcrypt" = "yes"; then + AC_DEFINE(HAVE_LIBMCRYPT22,1,[ ]) + fi + if test "$ac_cv_lib_mcrypt_mcrypt_module_open" = "yes"; then + AC_ADD_LIBRARY(ltdl) + AC_DEFINE(HAVE_LIBMCRYPT24,1,[ ]) + fi AC_DEFINE(HAVE_LIBMCRYPT,1,[ ]) PHP_EXTENSION(mcrypt, $ext_shared) diff --git a/ext/mcrypt/mcrypt.c b/ext/mcrypt/mcrypt.c index c52a4291f6..d31e41ddd6 100644 --- a/ext/mcrypt/mcrypt.c +++ b/ext/mcrypt/mcrypt.c @@ -13,6 +13,7 @@ | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Sascha Schumann | + | Derick Rethans | +----------------------------------------------------------------------+ */ @@ -26,48 +27,86 @@ #define NON_FREE #define MCRYPT2 #include "mcrypt.h" +#include "php_ini.h" +#include "ext/standard/info.h" + + +#if !defined(HAVE_LIBMCRYPT22) && !defined(HAVE_LIBMCRYPT24) +#error Upgrade you version of mcrypt to at least 2.2.7, preferrable 2.4.4 +#endif function_entry mcrypt_functions[] = { PHP_FE(mcrypt_ecb, NULL) PHP_FE(mcrypt_cbc, NULL) PHP_FE(mcrypt_cfb, NULL) PHP_FE(mcrypt_ofb, NULL) - PHP_FE(mcrypt_get_cipher_name, NULL) - PHP_FE(mcrypt_get_block_size, NULL) PHP_FE(mcrypt_get_key_size, NULL) + PHP_FE(mcrypt_get_block_size, NULL) + PHP_FE(mcrypt_get_cipher_name, NULL) PHP_FE(mcrypt_create_iv, NULL) +#if HAVE_LIBMCRYPT24 + PHP_FE(mcrypt_list_algorithms, NULL) + PHP_FE(mcrypt_list_modes, NULL) + PHP_FE(mcrypt_get_iv_size, NULL) + PHP_FE(mcrypt_encrypt, NULL) + PHP_FE(mcrypt_decrypt, NULL) + + PHP_FE(mcrypt_module_open, NULL) + PHP_FE(mcrypt_generic_init, NULL) + PHP_FE(mcrypt_generic, NULL) + PHP_FE(mdecrypt_generic, NULL) + PHP_FE(mcrypt_generic_end, NULL) + PHP_FE(mcrypt_enc_self_test, NULL) + PHP_FE(mcrypt_enc_is_block_algorithm_mode, NULL) + PHP_FE(mcrypt_enc_is_block_algorithm, NULL) + PHP_FE(mcrypt_enc_is_block_mode, NULL) + PHP_FE(mcrypt_enc_get_block_size, NULL) + PHP_FE(mcrypt_enc_get_key_size, NULL) + PHP_FE(mcrypt_enc_get_supported_key_sizes, NULL) + PHP_FE(mcrypt_enc_get_iv_size, NULL) + PHP_FE(mcrypt_enc_get_algorithms_name, NULL) + PHP_FE(mcrypt_enc_get_modes_name, NULL) + PHP_FE(mcrypt_module_self_test, NULL) + + PHP_FE(mcrypt_module_is_block_algorithm_mode, NULL) + PHP_FE(mcrypt_module_is_block_algorithm, NULL) + PHP_FE(mcrypt_module_is_block_mode, NULL) + PHP_FE(mcrypt_module_get_algo_block_size, NULL) + PHP_FE(mcrypt_module_get_algo_key_size, NULL) + PHP_FE(mcrypt_module_get_supported_key_sizes, NULL) + + PHP_FE(mcrypt_module_close, NULL) +#endif {0}, }; +static PHP_MINFO_FUNCTION(mcrypt); static PHP_MINIT_FUNCTION(mcrypt); +static PHP_MSHUTDOWN_FUNCTION(mcrypt); zend_module_entry mcrypt_module_entry = { "mcrypt", mcrypt_functions, - PHP_MINIT(mcrypt), NULL, + PHP_MINIT(mcrypt), PHP_MSHUTDOWN(mcrypt), NULL, NULL, - NULL, + PHP_MINFO(mcrypt), STANDARD_MODULE_PROPERTIES, }; -#ifdef COMPILE_DL_MCRYPT -ZEND_GET_MODULE(mcrypt) +#if HAVE_LIBMCRYPT24 +#ifdef ZTS +ZEND_DECLARE_MODULE_GLOBALS(mcrypt) +#else +static mcrypt_global_struct mcrypt_globals; +#endif #endif -#if 0 - -typedef struct mcrypt_global_struct { - int le_h; -} mcrypt_global_struct; - -static mcrypt_global_struct mcryptg; - -#define MCRYPTG(x) mcryptg.x - +#ifdef COMPILE_DL_MCRYPT +ZEND_GET_MODULE(mcrypt) #endif #define MCRYPT_ARGS2 \ - pval **cipher, **data, **key, **mode; \ + zval **cipher, **data, **key, **mode; \ int td; \ char *ndata; \ size_t bsize; \ @@ -76,13 +115,25 @@ static mcrypt_global_struct mcryptg; #define MCRYPT_ARGS \ MCRYPT_ARGS2; \ - pval **iv + zval **iv +#if HAVE_LIBMCRYPT22 #define MCRYPT_CONVERT \ convert_to_long_ex(cipher); \ convert_to_long_ex(mode); \ convert_to_string_ex(data); \ convert_to_string_ex(key) +#else +#define MCRYPT_CONVERT \ + convert_to_string_ex(cipher); \ + convert_to_string_ex(mode); \ + convert_to_string_ex(data); \ + convert_to_string_ex(key) +#define MCRYPT_CONVERT_WO_MODE \ + convert_to_string_ex(cipher); \ + convert_to_string_ex(data); \ + convert_to_string_ex(key) +#endif #define MCRYPT_SIZE \ bsize = mcrypt_get_block_size((*cipher)->value.lval); \ @@ -111,15 +162,95 @@ static mcrypt_global_struct mcryptg; mdecrypt_##x(td, ndata, nsize); \ end_mcrypt_##x(td) -#define MCRYPT_IV_WRONG_SIZE "The IV paramater must be as long as the blocksize" +#define MCRYPT_IV_WRONG_SIZE "The IV parameter must be as long as the blocksize" + +#if HAVE_LIBMCRYPT24 +#define MCRYPT_ENCRYPT 0 +#define MCRYPT_DECRYPT 1 + +#define MCRYPT_GET_INI \ + cipher_dir_string = INI_STR("mcrypt.algorithms_dir"); \ + module_dir_string = INI_STR("mcrypt.modes_dir"); + +#define MCRYPT_CHECK_PARAM_COUNT(a,b) \ + if (argc < (a) || argc > (b)) { \ + WRONG_PARAM_COUNT; \ + } + +#define MCRYPT_GET_CRYPT_ARGS \ + switch (argc) { \ + case 5: \ + if (zend_get_parameters_ex(5, &cipher, &key, &data, &mode, &iv) == FAILURE) { \ + WRONG_PARAM_COUNT; \ + } \ + convert_to_string_ex(iv); \ + break; \ + case 4: \ + if (zend_get_parameters_ex(4, &cipher, &key, &data, &mode) == FAILURE) { \ + WRONG_PARAM_COUNT; \ + } \ + iv = NULL; \ + break; \ + default: \ + WRONG_PARAM_COUNT; \ + } + +#define MCRYPT_GET_TD_ARG \ + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &mcryptind) == FAILURE) { \ + WRONG_PARAM_COUNT \ + } \ + ZEND_FETCH_RESOURCE (td, MCRYPT, mcryptind, -1, "MCrypt", MCG(le_h)); + +#define MCRYPT_GET_MODE_DIR_ARGS(DIRECTORY) \ + switch (argc) { \ + case 2: \ + lib_dir_s = (*lib_dir)->value.str.val; \ + if (zend_get_parameters_ex(2, &arg1, &lib_dir) == FAILURE) \ + { \ + WRONG_PARAM_COUNT; \ + } \ + convert_to_string_ex (lib_dir); \ + break; \ + case 1: \ + lib_dir_s = INI_STR(DIRECTORY); \ + if (zend_get_parameters_ex(1, &arg1) == FAILURE) \ + { \ + WRONG_PARAM_COUNT; \ + } \ + break; \ + default: \ + WRONG_PARAM_COUNT; \ + } \ + convert_to_string_ex(arg1); + +#endif + +#if HAVE_LIBMCRYPT22 #define MCRYPT_FAILED "mcrypt initialization failed" +#else +#define MCRYPT_OPEN_MODULE_FAILED "mcrypt module initialization failed" +#endif +#if HAVE_LIBMCRYPT22 #define MCRYPT_ENTRY_NAMED(a,b) REGISTER_LONG_CONSTANT("MCRYPT_" #a, b, CONST_PERSISTENT) #define MCRYPT_ENTRY2(a) MCRYPT_ENTRY_NAMED(a, MCRYPT_##a) #define MCRYPT_ENTRY(a) MCRYPT_ENTRY_NAMED(a, a) +#else /* MCRYPT_2_4 */ +#define MCRYPT_ENTRY2_2_4(a,b) REGISTER_STRING_CONSTANT("MCRYPT_" #a, b, CONST_PERSISTENT) +#define MCRYPT_ENTRY2_4(a) MCRYPT_ENTRY_NAMED(a, a) +#endif + +PHP_INI_BEGIN() + PHP_INI_ENTRY("mcrypt.algorithms_dir", NULL, PHP_INI_ALL, NULL) + PHP_INI_ENTRY("mcrypt.modes_dir", NULL, PHP_INI_ALL, NULL) +PHP_INI_END() static PHP_MINIT_FUNCTION(mcrypt) { +#ifdef ZTS + ZEND_INIT_MODULE_GLOBALS(mcrypt, NULL, NULL); + mcrypt_module_entry.type = type; +#endif /* modes for mcrypt_??? routines */ REGISTER_LONG_CONSTANT("MCRYPT_ENCRYPT", 0, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("MCRYPT_DECRYPT", 1, CONST_PERSISTENT); @@ -130,7 +261,7 @@ static PHP_MINIT_FUNCTION(mcrypt) REGISTER_LONG_CONSTANT("MCRYPT_RAND", 2, CONST_PERSISTENT); /* ciphers */ -#if defined(MCRYPT_API_VERSION) && MCRYPT_API_VERSION >= 19991015 +#if HAVE_LIBMCRYPT22 MCRYPT_ENTRY2(BLOWFISH_448); MCRYPT_ENTRY2(DES); MCRYPT_ENTRY2(3DES); @@ -163,24 +294,1126 @@ static PHP_MINIT_FUNCTION(mcrypt) MCRYPT_ENTRY2(RC6_128); MCRYPT_ENTRY2(RC6_192); MCRYPT_ENTRY2(RC4); -#else -#error Please update your mcrypt library #endif - +#if HAVE_LIBMCRYPT24 + MCRYPT_ENTRY2_2_4(ARCFOUR_IV, "arcfour-iv"); + MCRYPT_ENTRY2_2_4(ARCFOUR, "arcfour"); + MCRYPT_ENTRY2_2_4(BLOWFISH, "blowfish"); + MCRYPT_ENTRY2_2_4(CAST_128, "cast-128"); + MCRYPT_ENTRY2_2_4(CAST_256, "cast-256"); + MCRYPT_ENTRY2_2_4(CRYPT, "crypt"); + MCRYPT_ENTRY2_2_4(DES, "des"); + MCRYPT_ENTRY2_2_4(ENIGNA, "crypt"); + MCRYPT_ENTRY2_2_4(GOST, "gost"); + MCRYPT_ENTRY2_2_4(LOKI97, "loki97"); + MCRYPT_ENTRY2_2_4(PANAMA, "panama"); + MCRYPT_ENTRY2_2_4(RC2, "rc2"); + MCRYPT_ENTRY2_2_4(RIJNDAEL_128, "rijndael-128"); + MCRYPT_ENTRY2_2_4(RIJNDAEL_192, "rijndael-192"); + MCRYPT_ENTRY2_2_4(RIJNDAEL_256, "rijndael-256"); + MCRYPT_ENTRY2_2_4(SAFER64, "safer-sk64"); + MCRYPT_ENTRY2_2_4(SAFER128, "safer-sk128"); + MCRYPT_ENTRY2_2_4(SAFERPLUS, "saferplus"); + MCRYPT_ENTRY2_2_4(SERPENT, "serpent"); + MCRYPT_ENTRY2_2_4(THREEWAY, "threeway"); + MCRYPT_ENTRY2_2_4(TRIPLEDES, "tripledes"); + MCRYPT_ENTRY2_2_4(TWOFISH, "twofish"); + MCRYPT_ENTRY2_2_4(WAKE, "wake"); + MCRYPT_ENTRY2_2_4(XTEA, "xtea"); + + MCRYPT_ENTRY2_2_4(IDEA, "idea"); + MCRYPT_ENTRY2_2_4(MARS, "mars"); + MCRYPT_ENTRY2_2_4(RC6, "rc6"); + MCRYPT_ENTRY2_2_4(SKIPJACK, "skipjack"); +/* modes */ + MCRYPT_ENTRY2_2_4(MODE_CBC, "cbc"); + MCRYPT_ENTRY2_2_4(MODE_CFB, "cfb"); + MCRYPT_ENTRY2_2_4(MODE_ECB, "ecb"); + MCRYPT_ENTRY2_2_4(MODE_NOFB, "nofb"); + MCRYPT_ENTRY2_2_4(MODE_OFB, "ofb"); + MCRYPT_ENTRY2_2_4(MODE_STREAM, "stream"); +#endif + REGISTER_INI_ENTRIES(); + return SUCCESS; +} + +static PHP_MSHUTDOWN_FUNCTION(mcrypt) +{ + UNREGISTER_INI_ENTRIES(); return SUCCESS; } +PHP_MINFO_FUNCTION(mcrypt) +{ +#if HAVE_LIBMCRYPT24 + char **modules; + int i, count; + char *tmp, *tmp2; + + tmp = emalloc (2048); + memset (tmp, 0, sizeof(tmp)); + modules = mcrypt_list_algorithms (INI_STR("mcrypt.algorithms_dir"), &count); + if (count == 0) { + strcpy (tmp, "none"); + } + for (i = 0; i < count; i++) { + strcat (tmp, modules[i]); + strcat (tmp, " "); + } + mcrypt_free_p (modules, count); + + tmp2 = emalloc (2048); + memset (tmp2, 0, sizeof(tmp2)); + modules = mcrypt_list_modes (INI_STR("mcrypt.modes_dir"), &count); + if (count == 0) { + strcpy (tmp2, "none"); + } + for (i = 0; i < count; i++) { + strcat (tmp2, modules[i]); + strcat (tmp2, " "); + } + mcrypt_free_p (modules, count); +#endif + + php_info_print_table_start(); + php_info_print_table_header(2, "mcrypt support", "enabled"); +#if HAVE_LIBMCRYPT24 + php_info_print_table_row(2, "API Version", ">= 20000320"); + php_info_print_table_row(2, "Supported ciphers", tmp); + php_info_print_table_row(2, "Supported modes", tmp2); + efree (tmp2); + efree (tmp); +#endif + php_info_print_table_end(); + + DISPLAY_INI_ENTRIES(); +} + typedef enum { RANDOM = 0, URANDOM, RAND } iv_source; +#if HAVE_LIBMCRYPT24 + +/* {{{ proto resource mcrypt_module_open(string cipher, string cipher_directory, string mode, string mode_directory) + Opens the module of the algorithm and the mode to be used */ +PHP_FUNCTION(mcrypt_module_open) +{ + zval **cipher, **cipher_directory, **mode, **mode_directory; + MCRYPT td; + int argc; + MCLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + MCRYPT_CHECK_PARAM_COUNT (4,4) + + zend_get_parameters_ex(4, &cipher, &cipher_directory, &mode, &mode_directory); + convert_to_string_ex(cipher); + convert_to_string_ex(cipher_directory); + convert_to_string_ex(mode); + convert_to_string_ex(mode_directory); + + td = mcrypt_module_open ((*cipher)->value.str.val, + (*cipher_directory)->value.str.len > 0 ? (*cipher_directory)->value.str.val : INI_STR("mcrypt.algorithms_dir"), + (*mode)->value.str.val, + (*mode_directory)->value.str.len > 0 ? (*mode_directory)->value.str.val : INI_STR("mcrypt.modes_dir")); + + if (td == MCRYPT_FAILED) { + php_error (E_WARNING, "could not open encryption module"); + RETURN_FALSE; + } else { + ZEND_REGISTER_RESOURCE (return_value, td, MCG(le_h)); + } +} +/* }}} */ + + +/* {{{ proto int mcrypt_generic_init(resource td, string key, string iv) + This function initializes all buffers for the specific module */ +PHP_FUNCTION(mcrypt_generic_init) +{ + zval **key, **iv; + zval **mcryptind; + char *key_s, *iv_s; + int key_size, iv_size; + MCRYPT td; + int argc; + MCLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + MCRYPT_CHECK_PARAM_COUNT (3,3) + + zend_get_parameters_ex(3, &mcryptind, &key, &iv); + ZEND_FETCH_RESOURCE (td, MCRYPT, mcryptind, -1, "MCrypt", MCG(le_h)); + convert_to_string_ex (key); + convert_to_string_ex (iv); + + key_size = mcrypt_enc_get_key_size (td); + key_s = emalloc (key_size + 1); + memset (key_s, 0, key_size + 1); + + iv_size = mcrypt_enc_get_iv_size (td); + iv_s = emalloc (iv_size + 1); + memset (iv_s, 0, iv_size + 1); + + if ((*key)->value.str.len != key_size) { + php_error (E_WARNING, "key size is incorrect"); + } + strncpy (key_s, (*key)->value.str.val, key_size); + + if ((*iv)->value.str.len != iv_size) { + php_error (E_WARNING, "iv size is incorrect"); + } + strncpy (iv_s, (*iv)->value.str.val, iv_size); + + RETVAL_LONG (mcrypt_generic_init (td, key_s, key_size, iv_s)); + efree (iv_s); + efree (key_s); +} +/* }}} */ + + +/* {{{ proto string mcrypt_generic(resource td, string data) + This function encrypts the plaintext */ +PHP_FUNCTION(mcrypt_generic) +{ + zval **data, **mcryptind; + MCRYPT td; + int argc; + char* data_s; + int block_size, data_size; + MCLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + MCRYPT_CHECK_PARAM_COUNT (2,2) + + zend_get_parameters_ex(2, &mcryptind, &data); + ZEND_FETCH_RESOURCE (td, MCRYPT, mcryptind, -1, "MCrypt", MCG(le_h)); + convert_to_string_ex (data); + + /* Check blocksize */ + if (mcrypt_enc_is_block_algorithm (td) == 1) { /* It's a block algorithm */ + block_size = mcrypt_enc_get_block_size (td); + data_size = ((((*data)->value.str.len - 1) / block_size) + 1) * block_size; + data_s = emalloc (data_size); + memset (data_s, 0, data_size); + memcpy (data_s, (*data)->value.str.val, (*data)->value.str.len); + } + else { /* It's not a block algorithm */ + data_size = (*data)->value.str.len; + data_s = emalloc (data_size); + memset (data_s, 0, data_size); + memcpy (data_s, (*data)->value.str.val, (*data)->value.str.len); + } + + mcrypt_generic (td, data_s, data_size); + + RETVAL_STRINGL (data_s, data_size, 1); + efree (data_s); +} +/* }}} */ + + +/* {{{ proto string mdecrypt_generic(resource td, string data) + This function decrypts the plaintext */ +PHP_FUNCTION(mdecrypt_generic) +{ + zval **data, **mcryptind; + MCRYPT td; + int argc; + char* data_s; + int block_size, data_size; + MCLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + MCRYPT_CHECK_PARAM_COUNT (2,2) + + zend_get_parameters_ex(2, &mcryptind, &data); + ZEND_FETCH_RESOURCE (td, MCRYPT, mcryptind, -1, "MCrypt", MCG(le_h)); + convert_to_string_ex (data); + + /* Check blocksize */ + if (mcrypt_enc_is_block_algorithm (td) == 1) { /* It's a block algorithm */ + block_size = mcrypt_enc_get_block_size (td); + data_size = ((((*data)->value.str.len - 1) / block_size) + 1) * block_size; + data_s = emalloc (data_size); + memset (data_s, 0, data_size); + memcpy (data_s, (*data)->value.str.val, (*data)->value.str.len); + } + else { /* It's not a block algorithm */ + data_size = (*data)->value.str.len; + data_s = emalloc (data_size); + memset (data_s, 0, data_size); + memcpy (data_s, (*data)->value.str.val, (*data)->value.str.len); + } + + mdecrypt_generic (td, data_s, data_size); + + RETVAL_STRINGL (data_s, data_size, 1); + efree (data_s); +} +/* }}} */ + + +/* {{{ proto int mcrypt_enc_get_supported_key_sizes(resource td) + This function decrypts the crypttext */ +PHP_FUNCTION(mcrypt_enc_get_supported_key_sizes) +{ + zval **mcryptind; + MCRYPT td; + int argc, i, count; + int *key_sizes; + MCLS_FETCH(); + + argc = ZEND_NUM_ARGS(); + MCRYPT_GET_TD_ARG + + key_sizes = mcrypt_enc_get_supported_key_sizes (td, &count); + + if (array_init(return_value) == FAILURE) { + php_error(E_ERROR, "Unable to initialize array"); + return; + } + if (count != 0) { + for (i = 0; i < count; i++) { + add_index_long(return_value, i, key_sizes[i]); + } + } + mcrypt_free (key_sizes); +} +/* }}} */ + + +/* {{{ proto int mcrypt_enc_self_test(resource td) + This function runs the self test on the algorithm specified by the descriptor td */ +PHP_FUNCTION(mcrypt_enc_self_test) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + RETURN_LONG (mcrypt_enc_self_test (td)); +} +/* }}} */ + + +PHP_FUNCTION(mcrypt_module_close) +{ + zval **mcryptind; + int id; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + if (mcrypt_module_close (td) == -1) { + php_error (E_WARNING, "could not close module"); + RETURN_FALSE + } else { + zend_list_delete ((*mcryptind)->value.lval); + RETURN_TRUE + } +} + + +/* {{{ proto bool mcrypt_generic_end(resource td) + This function terminates encrypt specified by the descriptor td */ +PHP_FUNCTION(mcrypt_generic_end) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + if (mcrypt_generic_end (td) == -1) { + php_error (E_WARNING, "could not terminate encryption specifier"); + RETURN_FALSE + } + RETURN_TRUE +} +/* }}} */ + + +/* {{{ proto bool mcrypt_enc_is_block_algorithm_mode(resource td) + Returns TRUE if the mode is for use with block algorithms */ +PHP_FUNCTION(mcrypt_enc_is_block_algorithm_mode) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + if (mcrypt_enc_is_block_algorithm_mode (td) == 1) + RETURN_TRUE + else + RETURN_FALSE +} +/* }}} */ + + +/* {{{ proto bool mcrypt_enc_is_block_algorithm(resource td) + Returns TRUE if the alrogithm is a block algorithms */ +PHP_FUNCTION(mcrypt_enc_is_block_algorithm) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + if (mcrypt_enc_is_block_algorithm (td) == 1) + RETURN_TRUE + else + RETURN_FALSE +} +/* }}} */ + + +/* {{{ proto bool mcrypt_enc_is_block_mode(resource td) + Returns TRUE if the mode outputs blocks */ +PHP_FUNCTION(mcrypt_enc_is_block_mode) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + if (mcrypt_enc_is_block_mode (td) == 1) + RETURN_TRUE + else + RETURN_FALSE +} +/* }}} */ + + +/* {{{ proto int mcrypt_enc_get_block_size(resource td) + Returns the block size of the cipher specified by the descriptor td */ +PHP_FUNCTION(mcrypt_enc_get_block_size) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + RETURN_LONG (mcrypt_enc_get_block_size (td)); +} +/* }}} */ + + +/* {{{ proto int mcrypt_enc_get_key_size(resource td) + Returns the maximum supported key size in bytes of the algorithm specified by the descriptor td */ +PHP_FUNCTION(mcrypt_enc_get_key_size) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + RETURN_LONG (mcrypt_enc_get_key_size (td)); +} +/* }}} */ + + +/* {{{ proto int mcrypt_enc_get_iv_size(resource td) + Returns the size of the IV in bytes of the algorithm specified by the descriptor td */ +PHP_FUNCTION(mcrypt_enc_get_iv_size) +{ + zval **mcryptind; + MCRYPT td; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + RETURN_LONG (mcrypt_enc_get_iv_size (td)); +} +/* }}} */ + + +/* {{{ proto string mcrypt_enc_get_algorithms_name(resource td) + Returns the name of the algorithm specified by the descriptor td */ +PHP_FUNCTION(mcrypt_enc_get_algorithms_name) +{ + zval **mcryptind; + MCRYPT td; + char *name; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + name = mcrypt_enc_get_algorithms_name (td); + RETVAL_STRING (name, 1); + mcrypt_free (name); +} +/* }}} */ + + +/* {{{ proto string mcrypt_enc_get_modes_name(resource td) + Returns the name of the mode specified by the descriptor td */ +PHP_FUNCTION(mcrypt_enc_get_modes_name) +{ + zval **mcryptind; + MCRYPT td; + char *name; + MCLS_FETCH(); + + MCRYPT_GET_TD_ARG + + name = mcrypt_enc_get_modes_name (td); + RETVAL_STRING (name, 1); + mcrypt_free (name); +} +/* }}} */ + + +/* {{{ proto bool mcrypt_module_self_test(string algorithm [, string lib_dir]) + Does a self test of the module "module" */ +PHP_FUNCTION(mcrypt_module_self_test) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.algorithms_dir"); + + if (mcrypt_module_self_test ((*arg1)->value.str.val, lib_dir_s) == 0) { + RETURN_TRUE; + } + else { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto bool mcrypt_module_is_block_algorithm_mode(string mode [, string lib_dir]) + Returns TRUE if the mode is for use with block algorithms */ +PHP_FUNCTION(mcrypt_module_is_block_algorithm_mode) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.modes_dir") + + if (mcrypt_module_is_block_algorithm_mode ((*arg1)->value.str.val, lib_dir_s) == 0) { + RETURN_TRUE; + } + else { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto bool mcrypt_module_is_block_algorithm(string algorithm [, string lib_dir]) + Returns TRUE if the algorithm is a block algorithm */ +PHP_FUNCTION(mcrypt_module_is_block_algorithm) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.algorithms_dir") + + if (mcrypt_module_is_block_algorithm ((*arg1)->value.str.val, lib_dir_s) == 0) { + RETURN_TRUE; + } + else { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto bool mcrypt_module_is_block_mode(string mode [, string lib_dir]) + Returns TRUE if the mode outputs blocks of bytes */ +PHP_FUNCTION(mcrypt_module_is_block_mode) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.modes_dir") + + if (mcrypt_module_is_block_mode ((*arg1)->value.str.val, lib_dir_s) == 0) { + RETURN_TRUE; + } + else { + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto int mcrypt_module_get_algo_block_size(string algorithm [, string lib_dir]) + Returns the block size of the algorithm */ +PHP_FUNCTION(mcrypt_module_get_algo_block_size) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.algorithms_dir") + + RETURN_LONG(mcrypt_module_get_algo_block_size ((*arg1)->value.str.val, lib_dir_s)) +} +/* }}} */ + + +/* {{{ proto int mcrypt_module_get_algo_key_size(string algorithm [, string lib_dir]) + Returns the maximum supported key size of the algorithm */ +PHP_FUNCTION(mcrypt_module_get_algo_key_size) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.algorithms_dir"); + + RETURN_LONG(mcrypt_module_get_algo_key_size ((*arg1)->value.str.val, lib_dir_s)) +} +/* }}} */ + + +/* {{{ proto int mcrypt_module_get_supported_key_sizes(string algorithm [, string lib_dir]) + This function decrypts the crypttext */ +PHP_FUNCTION(mcrypt_module_get_supported_key_sizes) +{ + zval **arg1, **lib_dir; + char *lib_dir_s; + int argc, i, count; + int *key_sizes; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_GET_MODE_DIR_ARGS("mcrypt.algorithms_dir") + + key_sizes = mcrypt_module_get_algo_supported_key_sizes ((*arg1)->value.str.val, lib_dir_s, &count); + + if (array_init(return_value) == FAILURE) { + php_error(E_ERROR, "Unable to initialize array"); + return; + } + if (count != 0) { + for (i = 0; i < count; i++) { + add_index_long(return_value, i, key_sizes[i]); + } + } + mcrypt_free (key_sizes); +} +/* }}} */ + + +/* {{{ proto array mcrypt_list_algorithms([string lib_dir]) + List all algorithms in "module_dir" */ +PHP_FUNCTION(mcrypt_list_algorithms) +{ + zval **lib_dir; + char **modules; + char *lib_dir_s; + int i, count, argc; + + argc = ZEND_NUM_ARGS(); + MCRYPT_CHECK_PARAM_COUNT (0,1) + + switch (argc) { + case 1: + if (zend_get_parameters_ex (1, &lib_dir) == FAILURE) { + WRONG_PARAM_COUNT + } + convert_to_string_ex (lib_dir); + lib_dir_s = (*lib_dir)->value.str.val; + break; + case 0: + lib_dir_s = INI_STR("mcrypt.algorithms_dir"); + break; + default: + WRONG_PARAM_COUNT + } + + modules = mcrypt_list_algorithms (lib_dir_s, &count); + + if (array_init(return_value) == FAILURE) { + php_error(E_ERROR, "Unable to initialize array"); + return; + } + if (count == 0) { + php_error (E_WARNING, "No algorithms found in module dir"); + } + for (i = 0; i < count; i++) { + add_index_string(return_value, i, modules[i], 1); + } + mcrypt_free_p (modules, count); +} +/* }}} */ + + +/* {{{ proto array mcrypt_list_modes([string lib_dir]) + List all modes "module_dir" */ +PHP_FUNCTION(mcrypt_list_modes) +{ + zval **lib_dir; + char **modules; + char *lib_dir_s; + int i, count, argc; + + argc = ZEND_NUM_ARGS(); + MCRYPT_CHECK_PARAM_COUNT (0,1) + + switch (argc) { + case 1: + if (zend_get_parameters_ex (1, &lib_dir) == FAILURE) { + WRONG_PARAM_COUNT + } + convert_to_string_ex (lib_dir); + lib_dir_s = (*lib_dir)->value.str.val; + break; + case 0: + lib_dir_s = INI_STR("mcrypt.modes_dir"); + break; + default: + WRONG_PARAM_COUNT + } + + modules = mcrypt_list_modes (lib_dir_s, &count); + + if (array_init(return_value) == FAILURE) { + php_error(E_ERROR, "Unable to initialize array"); + return; + } + if (count == 0) { + php_error (E_WARNING, "No modes found in module dir"); + } + for (i = 0; i < count; i++) { + add_index_string(return_value, i, modules[i], 1); + } + mcrypt_free_p (modules, count); +} +/* }}} */ + + +/* {{{ proto int mcrypt_get_key_size(string cipher, string module) + Get the key size of cipher */ +PHP_FUNCTION(mcrypt_get_key_size) +{ + zval **cipher; + zval **module; + char *cipher_dir_string; + char *module_dir_string; + long key_size; + MCRYPT td; + + MCRYPT_GET_INI + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &cipher, &module) == FAILURE) { + WRONG_PARAM_COUNT; + } + + convert_to_string_ex(cipher); + convert_to_string_ex(module); + + td = mcrypt_module_open( + (*cipher)->value.str.val, + cipher_dir_string, + (*module)->value.str.val, + module_dir_string); + if (td != MCRYPT_FAILED) + { + key_size = mcrypt_enc_get_key_size(td); + mcrypt_module_close(td); + RETVAL_LONG(key_size); + } + else + { + php_error (E_WARNING, MCRYPT_OPEN_MODULE_FAILED); + RETVAL_LONG(0); + } +} +/* }}} */ + + +/* {{{ proto int mcrypt_get_block_size(string cipher, string module) + Get the key size of cipher */ +PHP_FUNCTION(mcrypt_get_block_size) +{ + zval **cipher; + zval **module; + char *cipher_dir_string; + char *module_dir_string; + long key_size; + MCRYPT td; + + MCRYPT_GET_INI + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &cipher, &module) == FAILURE) { + WRONG_PARAM_COUNT; + } + + convert_to_string_ex(cipher); + convert_to_string_ex(module); + + td = mcrypt_module_open( + (*cipher)->value.str.val, + cipher_dir_string, + (*module)->value.str.val, + module_dir_string); + if (td != MCRYPT_FAILED) + { + key_size = mcrypt_enc_get_block_size(td); + mcrypt_module_close(td); + RETVAL_LONG(key_size); + } + else + { + php_error (E_WARNING, MCRYPT_OPEN_MODULE_FAILED); + RETVAL_LONG(0); + } +} +/* }}} */ + + +/* {{{ proto int mcrypt_get_iv_size(string cipher, string module) + Get the IV size of cipher (Usually the same as the blocksize) */ +PHP_FUNCTION(mcrypt_get_iv_size) +{ + zval **cipher; + zval **module; + char *cipher_dir_string; + char *module_dir_string; + long key_size; + MCRYPT td; + + MCRYPT_GET_INI + + if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &cipher, &module) == FAILURE) { + WRONG_PARAM_COUNT; + } + + convert_to_string_ex(cipher); + convert_to_string_ex(module); + + td = mcrypt_module_open( + (*cipher)->value.str.val, + cipher_dir_string, + (*module)->value.str.val, + module_dir_string); + if (td != MCRYPT_FAILED) + { + key_size = mcrypt_enc_get_iv_size(td); + mcrypt_module_close(td); + RETURN_LONG(key_size); + } + else + { + php_error (E_WARNING, MCRYPT_OPEN_MODULE_FAILED); + RETURN_FALSE; + } +} +/* }}} */ + + +/* {{{ proto string mcrypt_get_cipher_name(string cipher) + Get the key size of cipher */ +PHP_FUNCTION(mcrypt_get_cipher_name) +{ + zval **cipher; + char *cipher_dir_string; + char *module_dir_string; + char *cipher_name; + MCRYPT td; + + MCRYPT_GET_INI + + if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &cipher) == FAILURE) { + WRONG_PARAM_COUNT; + } + + convert_to_string_ex(cipher); + + /* The code below is actually not very nice, but I didn see a better method */ + td = mcrypt_module_open( + (*cipher)->value.str.val, + cipher_dir_string, + "ecb", + module_dir_string); + if (td != MCRYPT_FAILED) + { + cipher_name = mcrypt_enc_get_algorithms_name(td); + mcrypt_module_close(td); + RETVAL_STRING(cipher_name,1); + mcrypt_free (cipher_name); + } + else + { + td = mcrypt_module_open( + (*cipher)->value.str.val, + cipher_dir_string, + "stream", + module_dir_string); + if (td != MCRYPT_FAILED) + { + cipher_name = mcrypt_enc_get_algorithms_name(td); + mcrypt_module_close(td); + RETVAL_STRING(cipher_name,1); + mcrypt_free (cipher_name); + } + else + { + php_error (E_WARNING, MCRYPT_OPEN_MODULE_FAILED); + RETURN_FALSE; + } + } +} +/* }}} */ + + +static void php_mcrypt_do_crypt (char* cipher, zval **key, zval **data, char *mode, zval **iv, int argc, int dencrypt, zval* return_value) +{ + char *cipher_dir_string; + char *module_dir_string; + int block_size, max_key_length, use_key_length, i, count, iv_size; + unsigned long int data_size; + int *key_length_sizes; + char *key_s, *iv_s; + char *data_s; + MCRYPT td; + + MCRYPT_GET_INI + + td = mcrypt_module_open ( + cipher, + cipher_dir_string, + mode, + module_dir_string); + if (td == MCRYPT_FAILED) { + php_error (E_WARNING, MCRYPT_OPEN_MODULE_FAILED); + RETURN_FALSE; + } + /* Checking for key-length */ + max_key_length = mcrypt_enc_get_key_size (td); + if ((*key)->value.str.len > max_key_length) { + php_error (E_WARNING, "size of key is too large for this algorithm"); + } + key_length_sizes = mcrypt_enc_get_supported_key_sizes (td, &count); + if (count == 0 && key_length_sizes == NULL) { /* all lengths 1 - k_l_s = OK */ + key_s = estrdup ((*key)->value.str.val); + use_key_length = (*key)->value.str.len; + } + else if (count == 1) { /* only m_k_l = OK */ + key_s = emalloc (key_length_sizes[0]); + memset (key_s, 0, key_length_sizes[0]); + strcpy (key_s, (*key)->value.str.val); + use_key_length = key_length_sizes[0]; + } + else { /* derterminating smallest supported key > length of requested key */ + use_key_length = max_key_length; /* start with max key length */ + for (i = 0; i < count; i++) { + if (key_length_sizes[i] >= (*key)->value.str.len && + key_length_sizes[i] < use_key_length) + { + use_key_length = key_length_sizes[i]; + } + } + key_s = emalloc (use_key_length); + memset (key_s, 0, use_key_length); + strcpy (key_s, (*key)->value.str.val); + } + mcrypt_free (key_length_sizes); + + /* Check IV */ + iv_s = NULL; + iv_size = mcrypt_enc_get_iv_size (td); + if (argc == 5) { + if (iv_size != (*iv)->value.str.len) { + php_error (E_WARNING, MCRYPT_IV_WRONG_SIZE); + + } + else { + iv_s = emalloc (iv_size + 1); + memcpy (iv_s, (*iv)->value.str.val, iv_size); + } + } + else if (argc == 4) + { + if (iv_size != 0) { + php_error (E_WARNING, "attempt to use an empty IV, which is NOT recommend"); + iv_s = emalloc (iv_size + 1); + memset (iv_s, 0, iv_size + 1); + } + } + + /* Check blocksize */ + if (mcrypt_enc_is_block_algorithm (td) == 1) { /* It's a block algorithm */ + block_size = mcrypt_enc_get_block_size (td); + data_size = ((((*data)->value.str.len - 1) / block_size) + 1) * block_size; + data_s = emalloc (data_size); + memset (data_s, 0, data_size); + memcpy (data_s, (*data)->value.str.val, (*data)->value.str.len); + } + else { /* It's not a block algorithm */ + data_size = (*data)->value.str.len; + data_s = emalloc (data_size); + memset (data_s, 0, data_size); + memcpy (data_s, (*data)->value.str.val, (*data)->value.str.len); + } + + if (mcrypt_generic_init (td, key_s, use_key_length, iv_s) == -1) { + php_error (E_ERROR, "generic_init failed"); + } + if (dencrypt == MCRYPT_ENCRYPT) + mcrypt_generic (td, data_s, data_size); + else + mdecrypt_generic (td, data_s, data_size); + + RETVAL_STRINGL (data_s, data_size, 1); + +/* freeing vars */ + mcrypt_generic_end (td); + if (iv_s != NULL) + efree (iv_s); + efree (data_s); + mcrypt_module_close (td); +} + +/* {{{ proto string mcrypt_encrypt(string cipher, string key, string data, string mode, string iv) + OFB crypt/decrypt data using key key with cipher cipher starting with iv */ +PHP_FUNCTION(mcrypt_encrypt) +{ + zval **cipher, **key, **data, **mode, **iv; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_CHECK_PARAM_COUNT (4, 5) + MCRYPT_GET_CRYPT_ARGS + + MCRYPT_CONVERT; + + php_mcrypt_do_crypt ((*cipher)->value.str.val, key, data, (*mode)->value.str.val, iv, argc, MCRYPT_ENCRYPT, return_value); +} + + +/* {{{ proto string mcrypt_decrypt(string cipher, string key, string data, string mode, string iv) + OFB crypt/decrypt data using key key with cipher cipher starting with iv */ +PHP_FUNCTION(mcrypt_decrypt) +{ + zval **cipher, **key, **data, **mode, **iv; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_CHECK_PARAM_COUNT (4, 5) + MCRYPT_GET_CRYPT_ARGS + + MCRYPT_CONVERT; + + php_mcrypt_do_crypt ((*cipher)->value.str.val, key, data, (*mode)->value.str.val, iv, argc, MCRYPT_DECRYPT, return_value); +} + + +/* {{{ proto string mcrypt_ecb(int cipher, string key, string data, int mode, string iv) + ECB crypt/decrypt data using key key with cipher cipher starting with iv */ +PHP_FUNCTION(mcrypt_ecb) +{ + zval **cipher, **key, **data, **mode, **iv; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_CHECK_PARAM_COUNT (4, 5) + MCRYPT_GET_CRYPT_ARGS + + MCRYPT_CONVERT_WO_MODE; + convert_to_long_ex(mode); + + php_mcrypt_do_crypt ((*cipher)->value.str.val, key, data, "ecb", iv, argc, (*mode)->value.lval, return_value); +} + + +/* {{{ proto string mcrypt_cbc(int cipher, string key, string data, int mode, string iv) + CBC crypt/decrypt data using key key with cipher cipher starting with iv */ +PHP_FUNCTION(mcrypt_cbc) +{ + zval **cipher, **key, **data, **mode, **iv; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_CHECK_PARAM_COUNT (4, 5) + MCRYPT_GET_CRYPT_ARGS + + MCRYPT_CONVERT_WO_MODE; + convert_to_long_ex(mode); + + php_mcrypt_do_crypt ((*cipher)->value.str.val, key, data, "cbc", iv, argc, (*mode)->value.lval, return_value); +} + + +/* {{{ proto string mcrypt_cfb(int cipher, string key, string data, int mode, string iv) + CFB crypt/decrypt data using key key with cipher cipher starting with iv */ +PHP_FUNCTION(mcrypt_cfb) +{ + zval **cipher, **key, **data, **mode, **iv; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_CHECK_PARAM_COUNT (4, 5) + MCRYPT_GET_CRYPT_ARGS + + MCRYPT_CONVERT_WO_MODE; + convert_to_long_ex(mode); + + php_mcrypt_do_crypt ((*cipher)->value.str.val, key, data, "cfb", iv, argc, (*mode)->value.lval, return_value); +} + + +/* {{{ proto string mcrypt_ofb(int cipher, string key, string data, int mode, string iv) + OFB crypt/decrypt data using key key with cipher cipher starting with iv */ +PHP_FUNCTION(mcrypt_ofb) +{ + zval **cipher, **key, **data, **mode, **iv; + int argc; + + argc = ZEND_NUM_ARGS(); + + MCRYPT_CHECK_PARAM_COUNT (4, 5) + MCRYPT_GET_CRYPT_ARGS + + MCRYPT_CONVERT_WO_MODE; + convert_to_long_ex(mode); + + php_mcrypt_do_crypt ((*cipher)->value.str.val, key, data, "ofb", iv, argc, (*mode)->value.lval, return_value); +} + +#endif + /* {{{ proto string mcrypt_create_iv(int size, int source) Create an initializing vector (IV) */ PHP_FUNCTION(mcrypt_create_iv) { - pval **size, **psource; + zval **size, **psource; char *iv; iv_source source; int i; @@ -232,11 +1465,14 @@ PHP_FUNCTION(mcrypt_create_iv) } /* }}} */ + +#if HAVE_LIBMCRYPT22 + /* {{{ proto string mcrypt_get_cipher_name(int cipher) Get the name of cipher */ PHP_FUNCTION(mcrypt_get_cipher_name) { - pval **cipher; + zval **cipher; char *str, *nstr; if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &cipher) == FAILURE) { @@ -260,7 +1496,7 @@ PHP_FUNCTION(mcrypt_get_cipher_name) Get the key size of cipher */ PHP_FUNCTION(mcrypt_get_key_size) { - pval **cipher; + zval **cipher; if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &cipher) == FAILURE) { WRONG_PARAM_COUNT; @@ -276,7 +1512,7 @@ PHP_FUNCTION(mcrypt_get_key_size) Get the block size of cipher */ PHP_FUNCTION(mcrypt_get_block_size) { - pval **cipher; + zval **cipher; if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &cipher) == FAILURE) { WRONG_PARAM_COUNT; @@ -384,4 +1620,6 @@ PHP_FUNCTION(mcrypt_ecb) } /* }}} */ +#endif /* MCRYPT_2_2 */ + #endif diff --git a/ext/mcrypt/php_mcrypt.h b/ext/mcrypt/php_mcrypt.h index 87585ae2cc..be1196636b 100644 --- a/ext/mcrypt/php_mcrypt.h +++ b/ext/mcrypt/php_mcrypt.h @@ -3,6 +3,10 @@ #if HAVE_LIBMCRYPT +#ifdef ZTS +#include "TSRM.h" +#endif + #if PHP_API_VERSION < 19990421 #define zend_module_entry zend_module_entry #include "modules.h" @@ -10,8 +14,10 @@ #endif extern zend_module_entry mcrypt_module_entry; + #define mcrypt_module_ptr &mcrypt_module_entry +/* Functions for both old and new API */ PHP_FUNCTION(mcrypt_ecb); PHP_FUNCTION(mcrypt_cbc); PHP_FUNCTION(mcrypt_cfb); @@ -21,6 +27,67 @@ PHP_FUNCTION(mcrypt_get_block_size); PHP_FUNCTION(mcrypt_get_key_size); PHP_FUNCTION(mcrypt_create_iv); +#if HAVE_LIBMCRYPT24 +/* Support functions for old API */ +PHP_FUNCTION(mcrypt_list_algorithms); +PHP_FUNCTION(mcrypt_list_modes); +PHP_FUNCTION(mcrypt_get_iv_size); +PHP_FUNCTION(mcrypt_encrypt); +PHP_FUNCTION(mcrypt_decrypt); + +/* Functions for new API */ +PHP_FUNCTION(mcrypt_module_open); +PHP_FUNCTION(mcrypt_generic_init); +PHP_FUNCTION(mcrypt_generic); +PHP_FUNCTION(mdecrypt_generic); +PHP_FUNCTION(mcrypt_generic_end); +PHP_FUNCTION(mcrypt_enc_self_test); +PHP_FUNCTION(mcrypt_enc_is_block_algorithm_mode); +PHP_FUNCTION(mcrypt_enc_is_block_algorithm); +PHP_FUNCTION(mcrypt_enc_is_block_mode); +PHP_FUNCTION(mcrypt_enc_get_block_size); +PHP_FUNCTION(mcrypt_enc_get_key_size); +PHP_FUNCTION(mcrypt_enc_get_supported_key_sizes); +PHP_FUNCTION(mcrypt_enc_get_iv_size); +PHP_FUNCTION(mcrypt_enc_get_algorithms_name); +PHP_FUNCTION(mcrypt_enc_get_modes_name); +PHP_FUNCTION(mcrypt_module_self_test); +PHP_FUNCTION(mcrypt_module_is_block_algorithm_mode); +PHP_FUNCTION(mcrypt_module_is_block_algorithm); +PHP_FUNCTION(mcrypt_module_is_block_mode); +PHP_FUNCTION(mcrypt_module_get_algo_block_size); +PHP_FUNCTION(mcrypt_module_get_algo_key_size); +PHP_FUNCTION(mcrypt_module_get_supported_key_sizes); +PHP_FUNCTION(mcrypt_module_close); + +#ifdef ZTS +ZEND_BEGIN_MODULE_GLOBALS(mcrypt) + int le_h; +ZEND_END_MODULE_GLOBALS(mcrypt) +#else +typedef struct mcrypt_global_struct { + int le_h; +} mcrypt_global_struct; +#endif + +#ifdef ZTS +# define MCLS_D zend_mcrypt_globals *mcrypt_globals +# define MCLS_DC , MCLS_D +# define MCLS_C mcrypt_globals +# define MCLS_CC , MCLS_C +# define MCG(v) (mcrypt_globals->v) +# define MCLS_FETCH() zend_mcrypt_globals *mcrypt_globals = ts_resource(mcrypt_globals_id) +#else +# define MCLS_D +# define MCLS_DC +# define MCLS_C +# define MCLS_CC +# define MCG(v) (mcrypt_globals.v) +# define MCLS_FETCH() +#endif + +#endif + #else #define mcrypt_module_ptr NULL #endif -- 2.40.0