Re: cvs: php4 /ext/mcrypt config.m4 mcrypt.c php_mcrypt.h
| From: | Andi Gutmans | Date: | Sun, 13 Aug 2000 04:09:47 +0000 |
| Subject: | Re: cvs: php4 /ext/mcrypt config.m4 mcrypt.c php_mcrypt.h | ||
| References: | 1 | Groups: | php.cvs |
| Request: | Send a blank email to php-cvs+get-1159@lists.php.net to get a copy of this message | ||
You should consider using a better way of accessing INI directives.
Zeev sent an Email on how to do it a while ago to php-dev@. Take a look at the MySQL module for an example.
PHP_INI_BEGIN()
....
PHP_INI_END().
Andi
At 06:45 PM 8/11/00 +0000, Derick Rethans wrote:
derick Fri Aug 11 11:45:17 2000 EDTModified files:/php4/ext/mcrypt php_mcrypt.h mcrypt.c config.m4Log: @ Added support for libmcrypt 2.4.4 Index: php4/ext/mcrypt/php_mcrypt.h diff -u php4/ext/mcrypt/php_mcrypt.h:1.13 php4/ext/mcrypt/php_mcrypt.h:1.14 --- php4/ext/mcrypt/php_mcrypt.h:1.13 Sat Mar 11 12:57:34 2000+++ php4/ext/mcrypt/php_mcrypt.h Fri Aug 11 11:45:16 2000@@ -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); @@ -20,6 +26,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 Index: php4/ext/mcrypt/mcrypt.c diff -u php4/ext/mcrypt/mcrypt.c:1.35 php4/ext/mcrypt/mcrypt.c:1.36--- php4/ext/mcrypt/mcrypt.c:1.35 Tue Jul 25 15:17:20 2000 +++ php4/ext/mcrypt/mcrypt.c Fri Aug 11 11:45:17 2000@@ -13,6 +13,7 @@| license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Sascha Schumann <sascha@schumann.cx> | + | Derick Rethans <d.rethans@jdimedia.nl> | +----------------------------------------------------------------------+*/ @@ -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 - -#if 0 - -typedef struct mcrypt_global_struct {- int le_h;-} mcrypt_global_struct; - -static mcrypt_global_struct mcryptg; - -#define MCRYPTG(x) mcryptg.x +#endif +#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 @@
#define MCRYPT_ARGS \
MCRYPT_ARGS2; \
- pval **iv+#if HAVE_LIBMCRYPT22 #define MCRYPT_CONVERT+ zval **iv
\
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); \
@@ -110,16 +161,96 @@
else \
mdecrypt_##x(td, ndata, nsize); \
end_mcrypt_##x(td)+ +#define MCRYPT_IV_WRONG_SIZE "The IV parameter must be as long as the blocksize" -#define MCRYPT_IV_WRONG_SIZE "The IV paramater 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 @@
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 @@
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 @@
}
/* }}} */
+
+#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 @@
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 @@
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;
@@ -383,5 +1619,7 @@
RETURN_STRINGL(ndata, nsize, 0);} /* }}} */ + +#endif /* MCRYPT_2_2 */ #endif Index: php4/ext/mcrypt/config.m4 diff -u php4/ext/mcrypt/config.m4:1.9 php4/ext/mcrypt/config.m4:1.10
--- php4/ext/mcrypt/config.m4:1.9 Mon May 1 21:01:14 2000+++ php4/ext/mcrypt/config.m4 Fri Aug 11 11:45:17 2000 @@ -1,4 +1,4 @@ -dnl $Id: config.m4,v 1.9 2000/05/02 04:01:14 sas Exp $ +dnl $Id: config.m4,v 1.10 2000/08/11 18:45:17 derick Exp $ dnl config.m4 for extension mcrypt dnl don't forget to call PHP_EXTENSION(mcrypt) @@ -19,8 +19,19 @@ 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) -- PHP CVS Mailing List (http://www.php.net/) To unsubscribe, e-mail: php-cvs-unsubscribe@lists.php.net For additional commands, e-mail: php-cvs-help@lists.php.net To contact the list administrators, e-mail: php-list-admin@lists.php.net --- Andi Gutmans <andi@zend.com> http://www.zend.com/