PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/mcrypt - mcrypt.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 418 481 86.9 %
Date: 2016-07-19 Functions: 43 43 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2016 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Sascha Schumann <sascha@schumann.cx>                        |
      16             :    |          Derick Rethans <derick@derickrethans.nl>                    |
      17             :    +----------------------------------------------------------------------+
      18             :  */
      19             : /* $Id$ */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include "config.h"
      23             : #endif
      24             : 
      25             : #include "php.h"
      26             : 
      27             : #if HAVE_LIBMCRYPT
      28             : 
      29             : #if PHP_WIN32
      30             : # include "win32/winutil.h"
      31             : #endif
      32             : 
      33             : #include "php_mcrypt.h"
      34             : #include "fcntl.h"
      35             : 
      36             : #define NON_FREE
      37             : #define MCRYPT2
      38             : #include "mcrypt.h"
      39             : #include "php_ini.h"
      40             : #include "php_globals.h"
      41             : #include "ext/standard/info.h"
      42             : #include "ext/standard/php_rand.h"
      43             : #include "zend_smart_str.h"
      44             : #include "php_mcrypt_filter.h"
      45             : 
      46             : static int le_mcrypt;
      47             : 
      48             : typedef struct _php_mcrypt {
      49             :         MCRYPT td;
      50             :         zend_bool init;
      51             : } php_mcrypt;
      52             : 
      53             : /* {{{ arginfo */
      54             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_open, 0, 0, 4)
      55             :         ZEND_ARG_INFO(0, cipher)
      56             :         ZEND_ARG_INFO(0, cipher_directory)
      57             :         ZEND_ARG_INFO(0, mode)
      58             :         ZEND_ARG_INFO(0, mode_directory)
      59             : ZEND_END_ARG_INFO()
      60             : 
      61             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_generic_init, 0, 0, 3)
      62             :         ZEND_ARG_INFO(0, td)
      63             :         ZEND_ARG_INFO(0, key)
      64             :         ZEND_ARG_INFO(0, iv)
      65             : ZEND_END_ARG_INFO()
      66             : 
      67             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_generic, 0, 0, 2)
      68             :         ZEND_ARG_INFO(0, td)
      69             :         ZEND_ARG_INFO(0, data)
      70             : ZEND_END_ARG_INFO()
      71             : 
      72             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mdecrypt_generic, 0, 0, 2)
      73             :         ZEND_ARG_INFO(0, td)
      74             :         ZEND_ARG_INFO(0, data)
      75             : ZEND_END_ARG_INFO()
      76             : 
      77             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_get_supported_key_sizes, 0, 0, 1)
      78             :         ZEND_ARG_INFO(0, td)
      79             : ZEND_END_ARG_INFO()
      80             : 
      81             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_self_test, 0, 0, 1)
      82             :         ZEND_ARG_INFO(0, td)
      83             : ZEND_END_ARG_INFO()
      84             : 
      85             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_close, 0, 0, 1)
      86             :         ZEND_ARG_INFO(0, td)
      87             : ZEND_END_ARG_INFO()
      88             : 
      89             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_generic_deinit, 0, 0, 1)
      90             :         ZEND_ARG_INFO(0, td)
      91             : ZEND_END_ARG_INFO()
      92             : 
      93             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_is_block_algorithm_mode, 0, 0, 1)
      94             :         ZEND_ARG_INFO(0, td)
      95             : ZEND_END_ARG_INFO()
      96             : 
      97             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_is_block_algorithm, 0, 0, 1)
      98             :         ZEND_ARG_INFO(0, td)
      99             : ZEND_END_ARG_INFO()
     100             : 
     101             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_is_block_mode, 0, 0, 1)
     102             :         ZEND_ARG_INFO(0, td)
     103             : ZEND_END_ARG_INFO()
     104             : 
     105             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_get_block_size, 0, 0, 1)
     106             :         ZEND_ARG_INFO(0, td)
     107             : ZEND_END_ARG_INFO()
     108             : 
     109             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_get_key_size, 0, 0, 1)
     110             :         ZEND_ARG_INFO(0, td)
     111             : ZEND_END_ARG_INFO()
     112             : 
     113             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_get_iv_size, 0, 0, 1)
     114             :         ZEND_ARG_INFO(0, td)
     115             : ZEND_END_ARG_INFO()
     116             : 
     117             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_get_algorithms_name, 0, 0, 1)
     118             :         ZEND_ARG_INFO(0, td)
     119             : ZEND_END_ARG_INFO()
     120             : 
     121             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_enc_get_modes_name, 0, 0, 1)
     122             :         ZEND_ARG_INFO(0, td)
     123             : ZEND_END_ARG_INFO()
     124             : 
     125             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_self_test, 0, 0, 1)
     126             :         ZEND_ARG_INFO(0, algorithm)
     127             :         ZEND_ARG_INFO(0, lib_dir)
     128             : ZEND_END_ARG_INFO()
     129             : 
     130             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_is_block_algorithm_mode, 0, 0, 1)
     131             :         ZEND_ARG_INFO(0, mode)
     132             :         ZEND_ARG_INFO(0, lib_dir)
     133             : ZEND_END_ARG_INFO()
     134             : 
     135             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_is_block_algorithm, 0, 0, 1)
     136             :         ZEND_ARG_INFO(0, algorithm)
     137             :         ZEND_ARG_INFO(0, lib_dir)
     138             : ZEND_END_ARG_INFO()
     139             : 
     140             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_is_block_mode, 0, 0, 1)
     141             :         ZEND_ARG_INFO(0, mode)
     142             :         ZEND_ARG_INFO(0, lib_dir)
     143             : ZEND_END_ARG_INFO()
     144             : 
     145             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_get_algo_block_size, 0, 0, 1)
     146             :         ZEND_ARG_INFO(0, algorithm)
     147             :         ZEND_ARG_INFO(0, lib_dir)
     148             : ZEND_END_ARG_INFO()
     149             : 
     150             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_get_algo_key_size, 0, 0, 1)
     151             :         ZEND_ARG_INFO(0, algorithm)
     152             :         ZEND_ARG_INFO(0, lib_dir)
     153             : ZEND_END_ARG_INFO()
     154             : 
     155             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_module_get_supported_key_sizes, 0, 0, 1)
     156             :         ZEND_ARG_INFO(0, algorithm)
     157             :         ZEND_ARG_INFO(0, lib_dir)
     158             : ZEND_END_ARG_INFO()
     159             : 
     160             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_list_algorithms, 0, 0, 0)
     161             :         ZEND_ARG_INFO(0, lib_dir)
     162             : ZEND_END_ARG_INFO()
     163             : 
     164             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_list_modes, 0, 0, 0)
     165             :         ZEND_ARG_INFO(0, lib_dir)
     166             : ZEND_END_ARG_INFO()
     167             : 
     168             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_get_key_size, 0, 0, 2)
     169             :         ZEND_ARG_INFO(0, cipher)
     170             :         ZEND_ARG_INFO(0, module)
     171             : ZEND_END_ARG_INFO()
     172             : 
     173             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_get_block_size, 0, 0, 2)
     174             :         ZEND_ARG_INFO(0, cipher)
     175             :         ZEND_ARG_INFO(0, module)
     176             : ZEND_END_ARG_INFO()
     177             : 
     178             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_get_iv_size, 0, 0, 2)
     179             :         ZEND_ARG_INFO(0, cipher)
     180             :         ZEND_ARG_INFO(0, module)
     181             : ZEND_END_ARG_INFO()
     182             : 
     183             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_get_cipher_name, 0, 0, 1)
     184             :         ZEND_ARG_INFO(0, cipher)
     185             : ZEND_END_ARG_INFO()
     186             : 
     187             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_encrypt, 0, 0, 5)
     188             :         ZEND_ARG_INFO(0, cipher)
     189             :         ZEND_ARG_INFO(0, key)
     190             :         ZEND_ARG_INFO(0, data)
     191             :         ZEND_ARG_INFO(0, mode)
     192             :         ZEND_ARG_INFO(0, iv)
     193             : ZEND_END_ARG_INFO()
     194             : 
     195             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_decrypt, 0, 0, 5)
     196             :         ZEND_ARG_INFO(0, cipher)
     197             :         ZEND_ARG_INFO(0, key)
     198             :         ZEND_ARG_INFO(0, data)
     199             :         ZEND_ARG_INFO(0, mode)
     200             :         ZEND_ARG_INFO(0, iv)
     201             : ZEND_END_ARG_INFO()
     202             : 
     203             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mcrypt_create_iv, 0, 0, 1)
     204             :         ZEND_ARG_INFO(0, size)
     205             :         ZEND_ARG_INFO(0, source)
     206             : ZEND_END_ARG_INFO()
     207             : /* }}} */
     208             : 
     209             : const zend_function_entry mcrypt_functions[] = { /* {{{ */
     210             :         PHP_DEP_FE(mcrypt_get_key_size,         arginfo_mcrypt_get_key_size)
     211             :         PHP_DEP_FE(mcrypt_get_block_size,       arginfo_mcrypt_get_block_size)
     212             :         PHP_DEP_FE(mcrypt_get_cipher_name,      arginfo_mcrypt_get_cipher_name)
     213             :         PHP_DEP_FE(mcrypt_create_iv,            arginfo_mcrypt_create_iv)
     214             : 
     215             :         PHP_DEP_FE(mcrypt_list_algorithms,      arginfo_mcrypt_list_algorithms)
     216             :         PHP_DEP_FE(mcrypt_list_modes,           arginfo_mcrypt_list_modes)
     217             :         PHP_DEP_FE(mcrypt_get_iv_size,          arginfo_mcrypt_get_iv_size)
     218             :         PHP_DEP_FE(mcrypt_encrypt,                      arginfo_mcrypt_encrypt)
     219             :         PHP_DEP_FE(mcrypt_decrypt,                      arginfo_mcrypt_decrypt)
     220             : 
     221             :         PHP_DEP_FE(mcrypt_module_open,          arginfo_mcrypt_module_open)
     222             :         PHP_DEP_FE(mcrypt_generic_init,         arginfo_mcrypt_generic_init)
     223             :         PHP_DEP_FE(mcrypt_generic,                      arginfo_mcrypt_generic)
     224             :         PHP_DEP_FE(mdecrypt_generic,            arginfo_mdecrypt_generic)
     225             :         PHP_DEP_FE(mcrypt_generic_deinit,       arginfo_mcrypt_generic_deinit)
     226             : 
     227             :         PHP_DEP_FE(mcrypt_enc_self_test,        arginfo_mcrypt_enc_self_test)
     228             :         PHP_DEP_FE(mcrypt_enc_is_block_algorithm_mode, arginfo_mcrypt_enc_is_block_algorithm_mode)
     229             :         PHP_DEP_FE(mcrypt_enc_is_block_algorithm,       arginfo_mcrypt_enc_is_block_algorithm)
     230             :         PHP_DEP_FE(mcrypt_enc_is_block_mode,            arginfo_mcrypt_enc_is_block_mode)
     231             :         PHP_DEP_FE(mcrypt_enc_get_block_size,           arginfo_mcrypt_enc_get_block_size)
     232             :         PHP_DEP_FE(mcrypt_enc_get_key_size,             arginfo_mcrypt_enc_get_key_size)
     233             :         PHP_DEP_FE(mcrypt_enc_get_supported_key_sizes, arginfo_mcrypt_enc_get_supported_key_sizes)
     234             :         PHP_DEP_FE(mcrypt_enc_get_iv_size,                      arginfo_mcrypt_enc_get_iv_size)
     235             :         PHP_DEP_FE(mcrypt_enc_get_algorithms_name,      arginfo_mcrypt_enc_get_algorithms_name)
     236             :         PHP_DEP_FE(mcrypt_enc_get_modes_name,           arginfo_mcrypt_enc_get_modes_name)
     237             :         PHP_DEP_FE(mcrypt_module_self_test,             arginfo_mcrypt_module_self_test)
     238             : 
     239             :         PHP_DEP_FE(mcrypt_module_is_block_algorithm_mode,       arginfo_mcrypt_module_is_block_algorithm_mode)
     240             :         PHP_DEP_FE(mcrypt_module_is_block_algorithm,            arginfo_mcrypt_module_is_block_algorithm)
     241             :         PHP_DEP_FE(mcrypt_module_is_block_mode,                         arginfo_mcrypt_module_is_block_mode)
     242             :         PHP_DEP_FE(mcrypt_module_get_algo_block_size,           arginfo_mcrypt_module_get_algo_block_size)
     243             :         PHP_DEP_FE(mcrypt_module_get_algo_key_size,             arginfo_mcrypt_module_get_algo_key_size)
     244             :         PHP_DEP_FE(mcrypt_module_get_supported_key_sizes,       arginfo_mcrypt_module_get_supported_key_sizes)
     245             : 
     246             :         PHP_DEP_FE(mcrypt_module_close,                                         arginfo_mcrypt_module_close)
     247             :         PHP_FE_END
     248             : };
     249             : /* }}} */
     250             : 
     251             : static PHP_MINFO_FUNCTION(mcrypt);
     252             : static PHP_MINIT_FUNCTION(mcrypt);
     253             : static PHP_MSHUTDOWN_FUNCTION(mcrypt);
     254             : static PHP_GINIT_FUNCTION(mcrypt);
     255             : static PHP_GSHUTDOWN_FUNCTION(mcrypt);
     256             : 
     257             : ZEND_DECLARE_MODULE_GLOBALS(mcrypt)
     258             : 
     259             : zend_module_entry mcrypt_module_entry = {
     260             :         STANDARD_MODULE_HEADER,
     261             :         "mcrypt",
     262             :         mcrypt_functions,
     263             :         PHP_MINIT(mcrypt), PHP_MSHUTDOWN(mcrypt),
     264             :         NULL, NULL,
     265             :         PHP_MINFO(mcrypt),
     266             :         PHP_MCRYPT_VERSION,
     267             :         PHP_MODULE_GLOBALS(mcrypt),
     268             :         PHP_GINIT(mcrypt),
     269             :         PHP_GSHUTDOWN(mcrypt),
     270             :         NULL,
     271             :         STANDARD_MODULE_PROPERTIES_EX
     272             : };
     273             : 
     274             : #ifdef COMPILE_DL_MCRYPT
     275             : #ifdef ZTS
     276             : ZEND_TSRMLS_CACHE_DEFINE()
     277             : #endif
     278             : ZEND_GET_MODULE(mcrypt)
     279             : #endif
     280             : 
     281             : #define MCRYPT_ENCRYPT 0
     282             : #define MCRYPT_DECRYPT 1
     283             : 
     284             : typedef enum {
     285             :         RANDOM = 0,
     286             :         URANDOM,
     287             :         RAND
     288             : } iv_source;
     289             : 
     290             : #define MCRYPT_GET_INI                                                                                  \
     291             :         cipher_dir_string = MCG(algorithms_dir);                                        \
     292             :         module_dir_string = MCG(modes_dir);
     293             : 
     294             : /*
     295             :  * #warning is not ANSI C
     296             :  * #warning Invalidate resource if the param count is wrong, or other problems
     297             :  * #warning occurred during functions.
     298             :  */
     299             : 
     300             : #define MCRYPT_GET_CRYPT_ARGS                                                                           \
     301             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "sssz|s",  \
     302             :                 &cipher, &cipher_len, &key, &key_len, &data, &data_len, &mode, &iv, &iv_len) == FAILURE) {  \
     303             :                 return;         \
     304             :         }
     305             : 
     306             : #define MCRYPT_GET_TD_ARG                                                                               \
     307             :         zval *mcryptind;                                                                                        \
     308             :         php_mcrypt *pm;                                                                                                 \
     309             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &mcryptind) == FAILURE) {                 \
     310             :                 return;                                                                                                                         \
     311             :         }                                                                                                                                                                               \
     312             :         if ((pm = (php_mcrypt *)zend_fetch_resource(Z_RES_P(mcryptind), "MCrypt", le_mcrypt)) == NULL) { \
     313             :                 RETURN_FALSE; \
     314             :         }
     315             : 
     316             : #define MCRYPT_GET_MODE_DIR_ARGS(DIRECTORY)                                                             \
     317             :         char *dir = NULL;                                                   \
     318             :         size_t   dir_len;                                                      \
     319             :         char *module;                                                       \
     320             :         size_t   module_len;                                                   \
     321             :         if (zend_parse_parameters (ZEND_NUM_ARGS(),               \
     322             :                 "s|s", &module, &module_len, &dir, &dir_len) == FAILURE) {      \
     323             :                 return;                                                         \
     324             :         }
     325             : 
     326             : #define MCRYPT_OPEN_MODULE_FAILED "Module initialization failed"
     327             : 
     328             : #define MCRYPT_ENTRY2_2_4(a,b) REGISTER_STRING_CONSTANT("MCRYPT_" #a, b, CONST_PERSISTENT)
     329             : #define MCRYPT_ENTRY2_4(a) MCRYPT_ENTRY_NAMED(a, a)
     330             : 
     331             : #define PHP_MCRYPT_INIT_CHECK   \
     332             :         if (!pm->init) {     \
     333             :                 php_error_docref(NULL, E_WARNING, "Operation disallowed prior to mcrypt_generic_init().");    \
     334             :                 RETURN_FALSE;   \
     335             :         }       \
     336             : 
     337             : PHP_INI_BEGIN()
     338             :         STD_PHP_INI_ENTRY("mcrypt.algorithms_dir", NULL, PHP_INI_ALL, OnUpdateString, algorithms_dir, zend_mcrypt_globals, mcrypt_globals)
     339             :         STD_PHP_INI_ENTRY("mcrypt.modes_dir",      NULL, PHP_INI_ALL, OnUpdateString, modes_dir, zend_mcrypt_globals, mcrypt_globals)
     340             : PHP_INI_END()
     341             : 
     342          39 : static void php_mcrypt_module_dtor(zend_resource *rsrc) /* {{{ */
     343             : {
     344          39 :         php_mcrypt *pm = (php_mcrypt *) rsrc->ptr;
     345          39 :         if (pm) {
     346          39 :                 mcrypt_generic_deinit(pm->td);
     347          39 :                 mcrypt_module_close(pm->td);
     348          39 :                 efree(pm);
     349          39 :                 pm = NULL;
     350             :         }
     351          39 : }
     352             : /* }}} */
     353             : 
     354       23409 : static PHP_GINIT_FUNCTION(mcrypt)
     355             : {/*{{{*/
     356             : #if defined(COMPILE_DL_MCRYPT) && defined(ZTS)
     357             :         ZEND_TSRMLS_CACHE_UPDATE();
     358             : #endif
     359       23409 :         mcrypt_globals->fd[RANDOM] = -1;
     360       23409 :         mcrypt_globals->fd[URANDOM] = -1;
     361       23409 : }/*}}}*/
     362             : 
     363       23445 : static PHP_GSHUTDOWN_FUNCTION(mcrypt)
     364             : {/*{{{*/
     365       23445 :         if (mcrypt_globals->fd[RANDOM] > 0) {
     366           1 :                 close(mcrypt_globals->fd[RANDOM]);
     367           1 :                 mcrypt_globals->fd[RANDOM] = -1;
     368             :         }
     369             : 
     370       23445 :         if (mcrypt_globals->fd[URANDOM] > 0) {
     371           2 :                 close(mcrypt_globals->fd[URANDOM]);
     372           2 :                 mcrypt_globals->fd[URANDOM] = -1;
     373             :         }
     374       23445 : }/*}}}*/
     375             : 
     376       23409 : static PHP_MINIT_FUNCTION(mcrypt) /* {{{ */
     377             : {
     378       23409 :         le_mcrypt = zend_register_list_destructors_ex(php_mcrypt_module_dtor, NULL, "mcrypt", module_number);
     379             : 
     380             :         /* modes for mcrypt_??? routines */
     381       23409 :         REGISTER_LONG_CONSTANT("MCRYPT_ENCRYPT", 0, CONST_PERSISTENT);
     382       23409 :         REGISTER_LONG_CONSTANT("MCRYPT_DECRYPT", 1, CONST_PERSISTENT);
     383             : 
     384             :         /* sources for mcrypt_create_iv */
     385       23409 :         REGISTER_LONG_CONSTANT("MCRYPT_DEV_RANDOM", RANDOM, CONST_PERSISTENT);
     386       23409 :         REGISTER_LONG_CONSTANT("MCRYPT_DEV_URANDOM", URANDOM, CONST_PERSISTENT);
     387       23409 :         REGISTER_LONG_CONSTANT("MCRYPT_RAND", RAND, CONST_PERSISTENT);
     388             : 
     389             :         /* ciphers */
     390       23409 :         MCRYPT_ENTRY2_2_4(3DES, "tripledes");
     391       23409 :         MCRYPT_ENTRY2_2_4(ARCFOUR_IV, "arcfour-iv");
     392       23409 :         MCRYPT_ENTRY2_2_4(ARCFOUR, "arcfour");
     393       23409 :         MCRYPT_ENTRY2_2_4(BLOWFISH, "blowfish");
     394       23409 :         MCRYPT_ENTRY2_2_4(BLOWFISH_COMPAT, "blowfish-compat");
     395       23409 :         MCRYPT_ENTRY2_2_4(CAST_128, "cast-128");
     396       23409 :         MCRYPT_ENTRY2_2_4(CAST_256, "cast-256");
     397       23409 :         MCRYPT_ENTRY2_2_4(CRYPT, "crypt");
     398       23409 :         MCRYPT_ENTRY2_2_4(DES, "des");
     399       23409 :         MCRYPT_ENTRY2_2_4(ENIGNA, "crypt");
     400       23409 :         MCRYPT_ENTRY2_2_4(GOST, "gost");
     401       23409 :         MCRYPT_ENTRY2_2_4(LOKI97, "loki97");
     402       23409 :         MCRYPT_ENTRY2_2_4(PANAMA, "panama");
     403       23409 :         MCRYPT_ENTRY2_2_4(RC2, "rc2");
     404       23409 :         MCRYPT_ENTRY2_2_4(RIJNDAEL_128, "rijndael-128");
     405       23409 :         MCRYPT_ENTRY2_2_4(RIJNDAEL_192, "rijndael-192");
     406       23409 :         MCRYPT_ENTRY2_2_4(RIJNDAEL_256, "rijndael-256");
     407       23409 :         MCRYPT_ENTRY2_2_4(SAFER64, "safer-sk64");
     408       23409 :         MCRYPT_ENTRY2_2_4(SAFER128, "safer-sk128");
     409       23409 :         MCRYPT_ENTRY2_2_4(SAFERPLUS, "saferplus");
     410       23409 :         MCRYPT_ENTRY2_2_4(SERPENT, "serpent");
     411       23409 :         MCRYPT_ENTRY2_2_4(THREEWAY, "threeway");
     412       23409 :         MCRYPT_ENTRY2_2_4(TRIPLEDES, "tripledes");
     413       23409 :         MCRYPT_ENTRY2_2_4(TWOFISH, "twofish");
     414       23409 :         MCRYPT_ENTRY2_2_4(WAKE, "wake");
     415       23409 :         MCRYPT_ENTRY2_2_4(XTEA, "xtea");
     416             : 
     417       23409 :         MCRYPT_ENTRY2_2_4(IDEA, "idea");
     418       23409 :         MCRYPT_ENTRY2_2_4(MARS, "mars");
     419       23409 :         MCRYPT_ENTRY2_2_4(RC6, "rc6");
     420       23409 :         MCRYPT_ENTRY2_2_4(SKIPJACK, "skipjack");
     421             : /* modes */
     422       23409 :         MCRYPT_ENTRY2_2_4(MODE_CBC, "cbc");
     423       23409 :         MCRYPT_ENTRY2_2_4(MODE_CFB, "cfb");
     424       23409 :         MCRYPT_ENTRY2_2_4(MODE_ECB, "ecb");
     425       23409 :         MCRYPT_ENTRY2_2_4(MODE_NOFB, "nofb");
     426       23409 :         MCRYPT_ENTRY2_2_4(MODE_OFB, "ofb");
     427       23409 :         MCRYPT_ENTRY2_2_4(MODE_STREAM, "stream");
     428       23409 :         REGISTER_INI_ENTRIES();
     429             : 
     430       23409 :         php_stream_filter_register_factory("mcrypt.*", &php_mcrypt_filter_factory);
     431       23409 :         php_stream_filter_register_factory("mdecrypt.*", &php_mcrypt_filter_factory);
     432             : 
     433       23409 :         return SUCCESS;
     434             : }
     435             : /* }}} */
     436             : 
     437       23445 : static PHP_MSHUTDOWN_FUNCTION(mcrypt) /* {{{ */
     438             : {
     439       23445 :         php_stream_filter_unregister_factory("mcrypt.*");
     440       23445 :         php_stream_filter_unregister_factory("mdecrypt.*");
     441             : 
     442       23445 :         UNREGISTER_INI_ENTRIES();
     443       23445 :         return SUCCESS;
     444             : }
     445             : /* }}} */
     446             : 
     447             : #include "zend_smart_str.h"
     448             : 
     449         150 : PHP_MINFO_FUNCTION(mcrypt) /* {{{ */
     450             : {
     451             :         char **modules;
     452             :         char mcrypt_api_no[16];
     453             :         int i, count;
     454         150 :         smart_str tmp1 = {0};
     455         150 :         smart_str tmp2 = {0};
     456             : 
     457         150 :         modules = mcrypt_list_algorithms(MCG(algorithms_dir), &count);
     458         150 :         if (count == 0) {
     459             :                 smart_str_appends(&tmp1, "none");
     460             :         }
     461        3000 :         for (i = 0; i < count; i++) {
     462        2850 :                 smart_str_appends(&tmp1, modules[i]);
     463             :                 smart_str_appendc(&tmp1, ' ');
     464             :         }
     465             :         smart_str_0(&tmp1);
     466         150 :         mcrypt_free_p(modules, count);
     467             : 
     468         150 :         modules = mcrypt_list_modes(MCG(modes_dir), &count);
     469         150 :         if (count == 0) {
     470             :                 smart_str_appends(&tmp2, "none");
     471             :         }
     472        1350 :         for (i = 0; i < count; i++) {
     473        1200 :                 smart_str_appends(&tmp2, modules[i]);
     474             :                 smart_str_appendc(&tmp2, ' ');
     475             :         }
     476             :         smart_str_0 (&tmp2);
     477         150 :         mcrypt_free_p (modules, count);
     478             : 
     479         150 :         snprintf (mcrypt_api_no, 16, "%d", MCRYPT_API_VERSION);
     480             : 
     481         150 :         php_info_print_table_start();
     482         150 :         php_info_print_table_header(2, "mcrypt support", "enabled");
     483         150 :         php_info_print_table_header(2, "mcrypt_filter support", "enabled");
     484         150 :         php_info_print_table_row(2, "Version", LIBMCRYPT_VERSION);
     485         150 :         php_info_print_table_row(2, "Api No", mcrypt_api_no);
     486         150 :         php_info_print_table_row(2, "Supported ciphers", ZSTR_VAL(tmp1.s));
     487         150 :         php_info_print_table_row(2, "Supported modes", ZSTR_VAL(tmp2.s));
     488             :         smart_str_free(&tmp1);
     489             :         smart_str_free(&tmp2);
     490             : 
     491         150 :         php_info_print_table_end();
     492             : 
     493         150 :         DISPLAY_INI_ENTRIES();
     494         150 : }
     495             : /* }}} */
     496             : 
     497             : /* {{{ proto resource mcrypt_module_open(string cipher, string cipher_directory, string mode, string mode_directory)
     498             :    Opens the module of the algorithm and the mode to be used */
     499          40 : PHP_FUNCTION(mcrypt_module_open)
     500             : {
     501             :         char *cipher, *cipher_dir;
     502             :         char *mode,   *mode_dir;
     503             :         size_t   cipher_len, cipher_dir_len;
     504             :         size_t   mode_len,   mode_dir_len;
     505             :         MCRYPT td;
     506             :         php_mcrypt *pm;
     507             : 
     508          40 :         if (zend_parse_parameters (ZEND_NUM_ARGS(), "ssss",
     509             :                 &cipher, &cipher_len, &cipher_dir, &cipher_dir_len,
     510             :                 &mode,   &mode_len,   &mode_dir,   &mode_dir_len)) {
     511           0 :                 return;
     512             :         }
     513             : 
     514          40 :         td = mcrypt_module_open (
     515             :                 cipher,
     516             :                 cipher_dir_len > 0 ? cipher_dir : MCG(algorithms_dir),
     517             :                 mode,
     518             :                 mode_dir_len > 0 ? mode_dir : MCG(modes_dir)
     519             :         );
     520             : 
     521          40 :         if (td == MCRYPT_FAILED) {
     522           1 :                 php_error_docref(NULL, E_WARNING, "Could not open encryption module");
     523           1 :                 RETURN_FALSE;
     524             :         } else {
     525          39 :                 pm = emalloc(sizeof(php_mcrypt));
     526          39 :                 pm->td = td;
     527          39 :                 pm->init = 0;
     528          39 :                 RETURN_RES(zend_register_resource(pm, le_mcrypt));
     529             :         }
     530             : }
     531             : /* }}} */
     532             : 
     533             : /* {{{ proto int mcrypt_generic_init(resource td, string key, string iv)
     534             :    This function initializes all buffers for the specific module */
     535          47 : PHP_FUNCTION(mcrypt_generic_init)
     536             : {
     537             :         char *key, *iv;
     538             :         size_t key_len, iv_len;
     539             :         zval *mcryptind;
     540             :         unsigned char *key_s, *iv_s;
     541             :         int max_key_size, key_size, iv_size;
     542             :         php_mcrypt *pm;
     543          47 :         int result = 0;
     544             : 
     545          47 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rss", &mcryptind, &key, &key_len, &iv, &iv_len) == FAILURE) {
     546           0 :                 return;
     547             :         }
     548             : 
     549          47 :         if ((pm = (php_mcrypt *)zend_fetch_resource(Z_RES_P(mcryptind), "MCrypt", le_mcrypt)) == NULL) {
     550           0 :                 RETURN_FALSE;
     551             :         }
     552             : 
     553          47 :         max_key_size = mcrypt_enc_get_key_size(pm->td);
     554          47 :         iv_size = mcrypt_enc_get_iv_size(pm->td);
     555             : 
     556          47 :         if (key_len == 0) {
     557           0 :                 php_error_docref(NULL, E_WARNING, "Key size is 0");
     558             :         }
     559             : 
     560          47 :         key_s = emalloc(key_len);
     561          47 :         memset(key_s, 0, key_len);
     562             : 
     563          47 :         iv_s = emalloc(iv_size + 1);
     564          47 :         memset(iv_s, 0, iv_size + 1);
     565             : 
     566          47 :         if (key_len > (size_t)max_key_size) {
     567           0 :                 php_error_docref(NULL, E_WARNING, "Key size too large; supplied length: %zd, max: %d", key_len, max_key_size);
     568           0 :                 key_size = max_key_size;
     569             :         } else {
     570          47 :                 key_size = (int)key_len;
     571             :         }
     572          47 :         memcpy(key_s, key, key_len);
     573             : 
     574          47 :         if (iv_len != (size_t)iv_size) {
     575           0 :                 php_error_docref(NULL, E_WARNING, "Iv size incorrect; supplied length: %zd, needed: %d", iv_len, iv_size);
     576           0 :                 if (iv_len > (size_t)iv_size) {
     577           0 :                         iv_len = iv_size;
     578             :                 }
     579             :         }
     580          47 :         memcpy(iv_s, iv, iv_len);
     581             : 
     582          47 :         mcrypt_generic_deinit(pm->td);
     583          47 :         result = mcrypt_generic_init(pm->td, key_s, key_size, iv_s);
     584             : 
     585             :         /* If this function fails, close the mcrypt module to prevent crashes
     586             :          * when further functions want to access this resource */
     587          47 :         if (result < 0) {
     588           0 :                 zend_list_close(Z_RES_P(mcryptind));
     589           0 :                 switch (result) {
     590             :                         case -3:
     591           0 :                                 php_error_docref(NULL, E_WARNING, "Key length incorrect");
     592           0 :                                 break;
     593             :                         case -4:
     594           0 :                                 php_error_docref(NULL, E_WARNING, "Memory allocation error");
     595           0 :                                 break;
     596             :                         case -1:
     597             :                         default:
     598           0 :                                 php_error_docref(NULL, E_WARNING, "Unknown error");
     599             :                                 break;
     600             :                 }
     601             :         } else {
     602          47 :                 pm->init = 1;
     603             :         }
     604          47 :         RETVAL_LONG(result);
     605             : 
     606          47 :         efree(iv_s);
     607          47 :         efree(key_s);
     608             : }
     609             : /* }}} */
     610             : 
     611             : /* {{{ proto string mcrypt_generic(resource td, string data)
     612             :    This function encrypts the plaintext */
     613          43 : PHP_FUNCTION(mcrypt_generic)
     614             : {
     615             :         zval *mcryptind;
     616             :         char *data;
     617             :         size_t data_len;
     618             :         php_mcrypt *pm;
     619             :         zend_string* data_str;
     620             :         int block_size, data_size;
     621             : 
     622          43 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &mcryptind, &data, &data_len) == FAILURE) {
     623           0 :                 return;
     624             :         }
     625             : 
     626          43 :         if ((pm = (php_mcrypt *)zend_fetch_resource(Z_RES_P(mcryptind), "MCrypt", le_mcrypt)) == NULL) {
     627           0 :                 RETURN_FALSE;
     628             :         }
     629          43 :         PHP_MCRYPT_INIT_CHECK
     630             : 
     631          40 :         if (data_len == 0) {
     632           1 :                 php_error_docref(NULL, E_WARNING, "An empty string was passed");
     633           1 :                 RETURN_FALSE
     634             :         }
     635             : 
     636             :         /* Check blocksize */
     637          39 :         if (mcrypt_enc_is_block_mode(pm->td) == 1) { /* It's a block algorithm */
     638          39 :                 block_size = mcrypt_enc_get_block_size(pm->td);
     639          39 :                 data_size = ((((int)data_len - 1) / block_size) + 1) * block_size;
     640          39 :                 if (data_size <= 0) {
     641           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Integer overflow in data size");
     642           0 :                         RETURN_FALSE;
     643             :                 }
     644          78 :                 data_str = zend_string_alloc(data_size, 0);
     645          39 :                 memset(ZSTR_VAL(data_str), 0, data_size);
     646          39 :                 memcpy(ZSTR_VAL(data_str), data, data_len);
     647             :         } else { /* It's not a block algorithm */
     648           0 :                 data_size = (int)data_len;
     649           0 :                 data_str = zend_string_alloc(data_size, 0);
     650           0 :                 memset(ZSTR_VAL(data_str), 0, data_size);
     651           0 :                 memcpy(ZSTR_VAL(data_str), data, data_len);
     652             :         }
     653             : 
     654          39 :         mcrypt_generic(pm->td, ZSTR_VAL(data_str), data_size);
     655          39 :         ZSTR_VAL(data_str)[data_size] = '\0';
     656             : 
     657          39 :         RETVAL_NEW_STR(data_str);
     658             : }
     659             : /* }}} */
     660             : 
     661             : /* {{{ proto string mdecrypt_generic(resource td, string data)
     662             :    This function decrypts the plaintext */
     663           7 : PHP_FUNCTION(mdecrypt_generic)
     664             : {
     665             :         zval *mcryptind;
     666             :         char *data;
     667             :         size_t data_len;
     668             :         php_mcrypt *pm;
     669             :         char* data_s;
     670             :         int block_size, data_size;
     671             : 
     672           7 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs", &mcryptind, &data, &data_len) == FAILURE) {
     673           0 :                 return;
     674             :         }
     675             : 
     676           7 :         if ((pm = (php_mcrypt *)zend_fetch_resource(Z_RES_P(mcryptind), "MCrypt", le_mcrypt)) == NULL) {
     677           0 :                 RETURN_FALSE;
     678             :         }
     679           7 :         PHP_MCRYPT_INIT_CHECK
     680             : 
     681           6 :         if (data_len == 0) {
     682           1 :                 php_error_docref(NULL, E_WARNING, "An empty string was passed");
     683           1 :                 RETURN_FALSE
     684             :         }
     685             : 
     686             :         /* Check blocksize */
     687           5 :         if (mcrypt_enc_is_block_mode(pm->td) == 1) { /* It's a block algorithm */
     688           5 :                 block_size = mcrypt_enc_get_block_size(pm->td);
     689           5 :                 data_size = ((((int)data_len - 1) / block_size) + 1) * block_size;
     690           5 :                 if (data_size <= 0) {
     691           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Integer overflow in data size");
     692           0 :                         RETURN_FALSE;
     693             :                 }
     694           5 :                 data_s = emalloc((size_t)data_size + 1);
     695           5 :                 memset(data_s, 0, data_size);
     696           5 :                 memcpy(data_s, data, data_len);
     697             :         } else { /* It's not a block algorithm */
     698           0 :                 data_size = (int)data_len;
     699           0 :                 data_s = emalloc(data_size + 1);
     700           0 :                 memset(data_s, 0, data_size);
     701           0 :                 memcpy(data_s, data, data_len);
     702             :         }
     703             : 
     704           5 :         mdecrypt_generic(pm->td, data_s, data_size);
     705             : 
     706          10 :         RETVAL_STRINGL(data_s, data_size);
     707           5 :         efree(data_s);
     708             : }
     709             : /* }}} */
     710             : 
     711             : /* {{{ proto array mcrypt_enc_get_supported_key_sizes(resource td)
     712             :    This function decrypts the crypttext */
     713           1 : PHP_FUNCTION(mcrypt_enc_get_supported_key_sizes)
     714             : {
     715           1 :         int i, count = 0;
     716             :         int *key_sizes;
     717             : 
     718           1 :         MCRYPT_GET_TD_ARG
     719           1 :         array_init(return_value);
     720             : 
     721           1 :         key_sizes = mcrypt_enc_get_supported_key_sizes(pm->td, &count);
     722             : 
     723           4 :         for (i = 0; i < count; i++) {
     724           3 :                 add_index_long(return_value, i, key_sizes[i]);
     725             :         }
     726             : 
     727           1 :         mcrypt_free(key_sizes);
     728             : }
     729             : /* }}} */
     730             : 
     731             : /* {{{ proto int mcrypt_enc_self_test(resource td)
     732             :    This function runs the self test on the algorithm specified by the descriptor td */
     733           1 : PHP_FUNCTION(mcrypt_enc_self_test)
     734             : {
     735           1 :         MCRYPT_GET_TD_ARG
     736           1 :         RETURN_LONG(mcrypt_enc_self_test(pm->td));
     737             : }
     738             : /* }}} */
     739             : 
     740             : /* {{{ proto bool mcrypt_module_close(resource td)
     741             :    Free the descriptor td */
     742           1 : PHP_FUNCTION(mcrypt_module_close)
     743             : {
     744           1 :         MCRYPT_GET_TD_ARG
     745           1 :         zend_list_close(Z_RES_P(mcryptind));
     746           1 :         RETURN_TRUE;
     747             : }
     748             : /* }}} */
     749             : 
     750             : /* {{{ proto bool mcrypt_generic_deinit(resource td)
     751             :    This function terminates encrypt specified by the descriptor td */
     752           7 : PHP_FUNCTION(mcrypt_generic_deinit)
     753             : {
     754           7 :         MCRYPT_GET_TD_ARG
     755             : 
     756           7 :         if (mcrypt_generic_deinit(pm->td) < 0) {
     757           0 :                 php_error_docref(NULL, E_WARNING, "Could not terminate encryption specifier");
     758           0 :                 RETURN_FALSE
     759             :         }
     760           7 :         pm->init = 0;
     761           7 :         RETURN_TRUE
     762             : }
     763             : /* }}} */
     764             : 
     765             : /* {{{ proto bool mcrypt_enc_is_block_algorithm_mode(resource td)
     766             :    Returns TRUE if the mode is for use with block algorithms */
     767           3 : PHP_FUNCTION(mcrypt_enc_is_block_algorithm_mode)
     768             : {
     769           3 :         MCRYPT_GET_TD_ARG
     770             : 
     771           3 :         if (mcrypt_enc_is_block_algorithm_mode(pm->td) == 1) {
     772           2 :                 RETURN_TRUE
     773             :         } else {
     774           1 :                 RETURN_FALSE
     775             :         }
     776             : }
     777             : /* }}} */
     778             : 
     779             : /* {{{ proto bool mcrypt_enc_is_block_algorithm(resource td)
     780             :    Returns TRUE if the alrogithm is a block algorithms */
     781           3 : PHP_FUNCTION(mcrypt_enc_is_block_algorithm)
     782             : {
     783           3 :         MCRYPT_GET_TD_ARG
     784             : 
     785           3 :         if (mcrypt_enc_is_block_algorithm(pm->td) == 1) {
     786           2 :                 RETURN_TRUE
     787             :         } else {
     788           1 :                 RETURN_FALSE
     789             :         }
     790             : }
     791             : /* }}} */
     792             : 
     793             : /* {{{ proto bool mcrypt_enc_is_block_mode(resource td)
     794             :    Returns TRUE if the mode outputs blocks */
     795           4 : PHP_FUNCTION(mcrypt_enc_is_block_mode)
     796             : {
     797           4 :         MCRYPT_GET_TD_ARG
     798             : 
     799           4 :         if (mcrypt_enc_is_block_mode(pm->td) == 1) {
     800           2 :                 RETURN_TRUE
     801             :         } else {
     802           2 :                 RETURN_FALSE
     803             :         }
     804             : }
     805             : /* }}} */
     806             : 
     807             : /* {{{ proto int mcrypt_enc_get_block_size(resource td)
     808             :    Returns the block size of the cipher specified by the descriptor td */
     809           3 : PHP_FUNCTION(mcrypt_enc_get_block_size)
     810             : {
     811           3 :         MCRYPT_GET_TD_ARG
     812           3 :         RETURN_LONG(mcrypt_enc_get_block_size(pm->td));
     813             : }
     814             : /* }}} */
     815             : 
     816             : /* {{{ proto int mcrypt_enc_get_key_size(resource td)
     817             :    Returns the maximum supported key size in bytes of the algorithm specified by the descriptor td */
     818           3 : PHP_FUNCTION(mcrypt_enc_get_key_size)
     819             : {
     820           3 :         MCRYPT_GET_TD_ARG
     821           3 :         RETURN_LONG(mcrypt_enc_get_key_size(pm->td));
     822             : }
     823             : /* }}} */
     824             : 
     825             : /* {{{ proto int mcrypt_enc_get_iv_size(resource td)
     826             :    Returns the size of the IV in bytes of the algorithm specified by the descriptor td */
     827           3 : PHP_FUNCTION(mcrypt_enc_get_iv_size)
     828             : {
     829           3 :         MCRYPT_GET_TD_ARG
     830           3 :         RETURN_LONG(mcrypt_enc_get_iv_size(pm->td));
     831             : }
     832             : /* }}} */
     833             : 
     834             : /* {{{ proto string mcrypt_enc_get_algorithms_name(resource td)
     835             :    Returns the name of the algorithm specified by the descriptor td */
     836           5 : PHP_FUNCTION(mcrypt_enc_get_algorithms_name)
     837             : {
     838             :         char *name;
     839           5 :         MCRYPT_GET_TD_ARG
     840             : 
     841           5 :         name = mcrypt_enc_get_algorithms_name(pm->td);
     842          10 :         RETVAL_STRING(name);
     843           5 :         mcrypt_free(name);
     844             : }
     845             : /* }}} */
     846             : 
     847             : /* {{{ proto string mcrypt_enc_get_modes_name(resource td)
     848             :    Returns the name of the mode specified by the descriptor td */
     849           6 : PHP_FUNCTION(mcrypt_enc_get_modes_name)
     850             : {
     851             :         char *name;
     852           6 :         MCRYPT_GET_TD_ARG
     853             : 
     854           6 :         name = mcrypt_enc_get_modes_name(pm->td);
     855          12 :         RETVAL_STRING(name);
     856           6 :         mcrypt_free(name);
     857             : }
     858             : /* }}} */
     859             : 
     860             : /* {{{ proto bool mcrypt_module_self_test(string algorithm [, string lib_dir])
     861             :    Does a self test of the module "module" */
     862           3 : PHP_FUNCTION(mcrypt_module_self_test)
     863             : {
     864           3 :         MCRYPT_GET_MODE_DIR_ARGS(algorithms_dir);
     865             : 
     866           3 :         if (mcrypt_module_self_test(module, dir) == 0) {
     867           2 :                 RETURN_TRUE;
     868             :         } else {
     869           1 :                 RETURN_FALSE;
     870             :         }
     871             : }
     872             : /* }}} */
     873             : 
     874             : /* {{{ proto bool mcrypt_module_is_block_algorithm_mode(string mode [, string lib_dir])
     875             :    Returns TRUE if the mode is for use with block algorithms */
     876           4 : PHP_FUNCTION(mcrypt_module_is_block_algorithm_mode)
     877             : {
     878           4 :         MCRYPT_GET_MODE_DIR_ARGS(modes_dir)
     879             : 
     880           4 :         if (mcrypt_module_is_block_algorithm_mode(module, dir) == 1) {
     881           3 :                 RETURN_TRUE;
     882             :         } else {
     883           1 :                 RETURN_FALSE;
     884             :         }
     885             : }
     886             : /* }}} */
     887             : 
     888             : /* {{{ proto bool mcrypt_module_is_block_algorithm(string algorithm [, string lib_dir])
     889             :    Returns TRUE if the algorithm is a block algorithm */
     890           4 : PHP_FUNCTION(mcrypt_module_is_block_algorithm)
     891             : {
     892           4 :         MCRYPT_GET_MODE_DIR_ARGS(algorithms_dir)
     893             : 
     894           4 :         if (mcrypt_module_is_block_algorithm(module, dir) == 1) {
     895           3 :                 RETURN_TRUE;
     896             :         } else {
     897           1 :                 RETURN_FALSE;
     898             :         }
     899             : }
     900             : /* }}} */
     901             : 
     902             : /* {{{ proto bool mcrypt_module_is_block_mode(string mode [, string lib_dir])
     903             :    Returns TRUE if the mode outputs blocks of bytes */
     904           5 : PHP_FUNCTION(mcrypt_module_is_block_mode)
     905             : {
     906           5 :         MCRYPT_GET_MODE_DIR_ARGS(modes_dir)
     907             : 
     908           5 :         if (mcrypt_module_is_block_mode(module, dir) == 1) {
     909           2 :                 RETURN_TRUE;
     910             :         } else {
     911           3 :                 RETURN_FALSE;
     912             :         }
     913             : }
     914             : /* }}} */
     915             : 
     916             : /* {{{ proto int mcrypt_module_get_algo_block_size(string algorithm [, string lib_dir])
     917             :    Returns the block size of the algorithm */
     918           6 : PHP_FUNCTION(mcrypt_module_get_algo_block_size)
     919             : {
     920           6 :         MCRYPT_GET_MODE_DIR_ARGS(algorithms_dir)
     921             : 
     922           6 :         RETURN_LONG(mcrypt_module_get_algo_block_size(module, dir));
     923             : }
     924             : /* }}} */
     925             : 
     926             : /* {{{ proto int mcrypt_module_get_algo_key_size(string algorithm [, string lib_dir])
     927             :    Returns the maximum supported key size of the algorithm */
     928           6 : PHP_FUNCTION(mcrypt_module_get_algo_key_size)
     929             : {
     930           6 :         MCRYPT_GET_MODE_DIR_ARGS(algorithms_dir);
     931             : 
     932           6 :         RETURN_LONG(mcrypt_module_get_algo_key_size(module, dir));
     933             : }
     934             : /* }}} */
     935             : 
     936             : /* {{{ proto array mcrypt_module_get_supported_key_sizes(string algorithm [, string lib_dir])
     937             :    This function decrypts the crypttext */
     938           2 : PHP_FUNCTION(mcrypt_module_get_supported_key_sizes)
     939             : {
     940           2 :         int i, count = 0;
     941             :         int *key_sizes;
     942             : 
     943           2 :         MCRYPT_GET_MODE_DIR_ARGS(algorithms_dir)
     944           2 :         array_init(return_value);
     945             : 
     946           2 :         key_sizes = mcrypt_module_get_algo_supported_key_sizes(module, dir, &count);
     947             : 
     948           5 :         for (i = 0; i < count; i++) {
     949           3 :                 add_index_long(return_value, i, key_sizes[i]);
     950             :         }
     951           2 :         mcrypt_free(key_sizes);
     952             : }
     953             : /* }}} */
     954             : 
     955             : /* {{{ proto array mcrypt_list_algorithms([string lib_dir])
     956             :    List all algorithms in "module_dir" */
     957           1 : PHP_FUNCTION(mcrypt_list_algorithms)
     958             : {
     959             :         char **modules;
     960           1 :         char *lib_dir = MCG(algorithms_dir);
     961             :         size_t   lib_dir_len;
     962             :         int   i, count;
     963             : 
     964           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s",
     965             :                 &lib_dir, &lib_dir_len) == FAILURE) {
     966           0 :                 return;
     967             :         }
     968             : 
     969           1 :         array_init(return_value);
     970           1 :         modules = mcrypt_list_algorithms(lib_dir, &count);
     971             : 
     972           1 :         if (count == 0) {
     973           0 :                 php_error_docref(NULL, E_WARNING, "No algorithms found in module dir");
     974             :         }
     975          20 :         for (i = 0; i < count; i++) {
     976          19 :                 add_index_string(return_value, i, modules[i]);
     977             :         }
     978           1 :         mcrypt_free_p(modules, count);
     979             : }
     980             : /* }}} */
     981             : 
     982             : /* {{{ proto array mcrypt_list_modes([string lib_dir])
     983             :    List all modes "module_dir" */
     984           1 : PHP_FUNCTION(mcrypt_list_modes)
     985             : {
     986             :         char **modules;
     987           1 :         char *lib_dir = MCG(modes_dir);
     988             :         size_t   lib_dir_len;
     989             :         int   i, count;
     990             : 
     991           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|s",
     992             :                 &lib_dir, &lib_dir_len) == FAILURE) {
     993           0 :                 return;
     994             :         }
     995             : 
     996           1 :         array_init(return_value);
     997           1 :         modules = mcrypt_list_modes(lib_dir, &count);
     998             : 
     999           1 :         if (count == 0) {
    1000           0 :                 php_error_docref(NULL, E_WARNING, "No modes found in module dir");
    1001             :         }
    1002           9 :         for (i = 0; i < count; i++) {
    1003           8 :                 add_index_string(return_value, i, modules[i]);
    1004             :         }
    1005           1 :         mcrypt_free_p(modules, count);
    1006             : }
    1007             : /* }}} */
    1008             : 
    1009             : /* {{{ proto int mcrypt_get_key_size(string cipher, string module)
    1010             :    Get the key size of cipher */
    1011           3 : PHP_FUNCTION(mcrypt_get_key_size)
    1012             : {
    1013             :         char *cipher;
    1014             :         char *module;
    1015             :         size_t   cipher_len, module_len;
    1016             :         char *cipher_dir_string;
    1017             :         char *module_dir_string;
    1018             :         MCRYPT td;
    1019             : 
    1020           3 :         MCRYPT_GET_INI
    1021             : 
    1022           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
    1023             :                 &cipher, &cipher_len, &module, &module_len) == FAILURE) {
    1024           0 :                 return;
    1025             :         }
    1026             : 
    1027           3 :         td = mcrypt_module_open(cipher, cipher_dir_string, module, module_dir_string);
    1028           3 :         if (td != MCRYPT_FAILED) {
    1029           3 :                 RETVAL_LONG(mcrypt_enc_get_key_size(td));
    1030           3 :                 mcrypt_module_close(td);
    1031             :         } else {
    1032           0 :                 php_error_docref(NULL, E_WARNING, MCRYPT_OPEN_MODULE_FAILED);
    1033           0 :                 RETURN_FALSE;
    1034             :         }
    1035             : }
    1036             : /* }}} */
    1037             : 
    1038             : /* {{{ proto int mcrypt_get_block_size(string cipher, string module)
    1039             :    Get the key size of cipher */
    1040           3 : PHP_FUNCTION(mcrypt_get_block_size)
    1041             : {
    1042             :         char *cipher;
    1043             :         char *module;
    1044             :         size_t   cipher_len, module_len;
    1045             :         char *cipher_dir_string;
    1046             :         char *module_dir_string;
    1047             :         MCRYPT td;
    1048             : 
    1049           3 :         MCRYPT_GET_INI
    1050             : 
    1051           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
    1052             :                 &cipher, &cipher_len, &module, &module_len) == FAILURE) {
    1053           0 :                 return;
    1054             :         }
    1055             : 
    1056           3 :         td = mcrypt_module_open(cipher, cipher_dir_string, module, module_dir_string);
    1057           3 :         if (td != MCRYPT_FAILED) {
    1058           3 :                 RETVAL_LONG(mcrypt_enc_get_block_size(td));
    1059           3 :                 mcrypt_module_close(td);
    1060             :         } else {
    1061           0 :                 php_error_docref(NULL, E_WARNING, MCRYPT_OPEN_MODULE_FAILED);
    1062           0 :                 RETURN_FALSE;
    1063             :         }
    1064             : }
    1065             : /* }}} */
    1066             : 
    1067             : /* {{{ proto int mcrypt_get_iv_size(string cipher, string module)
    1068             :    Get the IV size of cipher (Usually the same as the blocksize) */
    1069          12 : PHP_FUNCTION(mcrypt_get_iv_size)
    1070             : {
    1071             :         char *cipher;
    1072             :         char *module;
    1073             :         size_t   cipher_len, module_len;
    1074             :         char *cipher_dir_string;
    1075             :         char *module_dir_string;
    1076             :         MCRYPT td;
    1077             : 
    1078          12 :         MCRYPT_GET_INI
    1079             : 
    1080          12 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss",
    1081             :                 &cipher, &cipher_len, &module, &module_len) == FAILURE) {
    1082           0 :                 return;
    1083             :         }
    1084             : 
    1085          12 :         td = mcrypt_module_open(cipher, cipher_dir_string, module, module_dir_string);
    1086          12 :         if (td != MCRYPT_FAILED) {
    1087          11 :                 RETVAL_LONG(mcrypt_enc_get_iv_size(td));
    1088          11 :                 mcrypt_module_close(td);
    1089             :         } else {
    1090           1 :                 php_error_docref(NULL, E_WARNING, MCRYPT_OPEN_MODULE_FAILED);
    1091           1 :                 RETURN_FALSE;
    1092             :         }
    1093             : }
    1094             : /* }}} */
    1095             : 
    1096             : /* {{{ proto string mcrypt_get_cipher_name(string cipher)
    1097             :    Get the key size of cipher */
    1098           4 : PHP_FUNCTION(mcrypt_get_cipher_name)
    1099             : {
    1100             :         char *cipher_dir_string;
    1101             :         char *module_dir_string;
    1102             :         char *cipher_name;
    1103             :         char *cipher;
    1104             :         size_t   cipher_len;
    1105             :         MCRYPT td;
    1106             : 
    1107           4 :         MCRYPT_GET_INI
    1108             : 
    1109           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s",
    1110             :                 &cipher, &cipher_len) == FAILURE) {
    1111           0 :                 return;
    1112             :         }
    1113             : 
    1114             :         /* The code below is actually not very nice, but I didn't see a better
    1115             :          * method */
    1116           4 :         td = mcrypt_module_open(cipher, cipher_dir_string, "ecb", module_dir_string);
    1117           4 :         if (td != MCRYPT_FAILED) {
    1118           2 :                 cipher_name = mcrypt_enc_get_algorithms_name(td);
    1119           2 :                 mcrypt_module_close(td);
    1120           4 :                 RETVAL_STRING(cipher_name);
    1121           2 :                 mcrypt_free(cipher_name);
    1122             :         } else {
    1123           2 :                 td = mcrypt_module_open(cipher, cipher_dir_string, "stream", module_dir_string);
    1124           2 :                 if (td != MCRYPT_FAILED) {
    1125           2 :                         cipher_name = mcrypt_enc_get_algorithms_name(td);
    1126           2 :                         mcrypt_module_close(td);
    1127           4 :                         RETVAL_STRING(cipher_name);
    1128           2 :                         mcrypt_free(cipher_name);
    1129             :                 } else {
    1130           0 :                         php_error_docref(NULL, E_WARNING, MCRYPT_OPEN_MODULE_FAILED);
    1131           0 :                         RETURN_FALSE;
    1132             :                 }
    1133             :         }
    1134             : }
    1135             : /* }}} */
    1136             : 
    1137          73 : static char *php_mcrypt_get_key_size_str(
    1138             :                 int max_key_size, const int *key_sizes, int key_size_count) /* {{{ */
    1139             : {
    1140          73 :         if (key_size_count == 0) {
    1141             :                 char *str;
    1142           0 :                 spprintf(&str, 0, "Only keys of size 1 to %d supported", max_key_size);
    1143           0 :                 return str;
    1144          73 :         } else if (key_size_count == 1) {
    1145             :                 char *str;
    1146          64 :                 spprintf(&str, 0, "Only keys of size %d supported", key_sizes[0]);
    1147          64 :                 return str;
    1148             :         } else {
    1149             :                 int i;
    1150           9 :                 char *result = NULL;
    1151           9 :                 smart_str str = {0};
    1152             :                 smart_str_appends(&str, "Only keys of sizes ");
    1153             : 
    1154          36 :                 for (i = 0; i < key_size_count; ++i) {
    1155          27 :                         if (i == key_size_count - 1) {
    1156             :                                 smart_str_appends(&str, " or ");
    1157          18 :                         } else if (i != 0) {
    1158             :                                 smart_str_appends(&str, ", ");
    1159             :                         }
    1160             : 
    1161          27 :                         smart_str_append_long(&str, key_sizes[i]);
    1162             :                 }
    1163             : 
    1164             :                 smart_str_appends(&str, " supported");
    1165             :                 smart_str_0(&str);
    1166           9 :                 result = estrndup(ZSTR_VAL(str.s), ZSTR_LEN(str.s));
    1167             :                 smart_str_free(&str);
    1168             : 
    1169           9 :                 return result;
    1170             :         }
    1171             : }
    1172             : /* }}} */
    1173             : 
    1174         218 : static zend_bool php_mcrypt_is_valid_key_size(
    1175             :                 int key_size, int max_key_size, int *key_sizes, int key_size_count) /* {{{ */
    1176             : {
    1177             :         int i;
    1178             : 
    1179         218 :         if (key_size <= 0 || key_size > max_key_size) {
    1180          28 :                 return 0;
    1181             :         }
    1182             : 
    1183         190 :         if (key_size_count == 0) {
    1184             :                 /* All key sizes are valid */
    1185           3 :                 return 1;
    1186             :         }
    1187             : 
    1188         252 :         for (i = 0; i < key_size_count; i++) {
    1189         207 :                 if (key_sizes[i] == key_size) {
    1190         142 :                         return 1;
    1191             :                 }
    1192             :         }
    1193             : 
    1194          45 :         return 0;
    1195             : }
    1196             : /* }}} */
    1197             : 
    1198         218 : static int php_mcrypt_ensure_valid_key_size(MCRYPT td, int key_size) /* {{{ */
    1199             : {
    1200             :         int key_size_count;
    1201         218 :         int max_key_size = mcrypt_enc_get_key_size(td);
    1202         218 :         int *key_sizes = mcrypt_enc_get_supported_key_sizes(td, &key_size_count);
    1203             : 
    1204         218 :         zend_bool is_valid_key_size = php_mcrypt_is_valid_key_size(
    1205             :                 key_size, max_key_size, key_sizes, key_size_count
    1206         218 :         );
    1207         218 :         if (!is_valid_key_size) {
    1208          73 :                 char *key_size_str = php_mcrypt_get_key_size_str(
    1209             :                         max_key_size, key_sizes, key_size_count
    1210          73 :                 );
    1211          73 :                 php_error_docref(NULL, E_WARNING,
    1212             :                         "Key of size %d not supported by this algorithm. %s", key_size, key_size_str
    1213             :                 );
    1214          73 :                 efree(key_size_str);
    1215             :         }
    1216             : 
    1217         218 :         if (key_sizes) {
    1218         215 :                 mcrypt_free(key_sizes);
    1219             :         }
    1220             : 
    1221         218 :         return is_valid_key_size ? SUCCESS : FAILURE;
    1222             : }
    1223             : /* }}} */
    1224             : 
    1225         145 : static int php_mcrypt_ensure_valid_iv(MCRYPT td, const char *iv, int iv_size) /* {{{ */
    1226             : {
    1227         145 :         if (mcrypt_enc_mode_has_iv(td) == 1) {
    1228          82 :                 int expected_iv_size = mcrypt_enc_get_iv_size(td);
    1229          82 :                 if (expected_iv_size == 0) {
    1230             :                         /* Algorithm does not use IV, even though mode supports it */
    1231           2 :                         return SUCCESS;
    1232             :                 }
    1233             : 
    1234          80 :                 if (!iv) {
    1235           5 :                         php_error_docref(NULL, E_WARNING,
    1236             :                                 "Encryption mode requires an initialization vector of size %d", expected_iv_size
    1237             :                         );
    1238           5 :                         return FAILURE;
    1239             :                 }
    1240             : 
    1241          75 :                 if (iv_size != expected_iv_size) {
    1242          53 :                         php_error_docref(NULL, E_WARNING,
    1243             :                                 "Received initialization vector of size %d, but size %d is required "
    1244             :                                 "for this encryption mode", iv_size, expected_iv_size
    1245             :                         );
    1246          53 :                         return FAILURE;
    1247             :                 }
    1248             :         }
    1249             : 
    1250          85 :         return SUCCESS;
    1251             : }
    1252             : /* }}} */
    1253             : 
    1254         298 : static void php_mcrypt_do_crypt(char* cipher, const char *key, size_t key_len, const char *data, size_t data_len, char *mode, const char *iv, size_t iv_len, size_t dencrypt, zval* return_value) /* {{{ */
    1255             : {
    1256             :         char *cipher_dir_string;
    1257             :         char *module_dir_string;
    1258             :         zend_long data_size;
    1259             :         char *data_s;
    1260             :         MCRYPT td;
    1261             : 
    1262         298 :         MCRYPT_GET_INI
    1263             : 
    1264         298 :         td = mcrypt_module_open(cipher, cipher_dir_string, mode, module_dir_string);
    1265         298 :         if (td == MCRYPT_FAILED) {
    1266          80 :                 php_error_docref(NULL, E_WARNING, MCRYPT_OPEN_MODULE_FAILED);
    1267          80 :                 RETURN_FALSE;
    1268             :         }
    1269             : 
    1270         218 :         if (php_mcrypt_ensure_valid_key_size(td, (int)key_len) == FAILURE) {
    1271          73 :                 mcrypt_module_close(td);
    1272          73 :                 RETURN_FALSE;
    1273             :         }
    1274             : 
    1275         145 :         if (php_mcrypt_ensure_valid_iv(td, iv, (int)iv_len) == FAILURE) {
    1276          58 :                 mcrypt_module_close(td);
    1277          58 :                 RETURN_FALSE;
    1278             :         }
    1279             : 
    1280             :         /* Check blocksize */
    1281          87 :         if (mcrypt_enc_is_block_mode(td) == 1) { /* It's a block algorithm */
    1282          81 :                 int block_size = mcrypt_enc_get_block_size(td);
    1283          81 :                 data_size = ((((zend_long)data_len - 1) / block_size) + 1) * block_size;
    1284          81 :                 data_s = emalloc(data_size + 1);
    1285          81 :                 memset(data_s, 0, data_size);
    1286          81 :                 memcpy(data_s, data, data_len);
    1287             :         } else { /* It's not a block algorithm */
    1288           6 :                 data_size = data_len;
    1289           6 :                 data_s = emalloc(data_size + 1);
    1290           6 :                 memcpy(data_s, data, data_len);
    1291             :         }
    1292             : 
    1293          87 :         if (mcrypt_generic_init(td, (void *) key, (int)key_len, (void *) iv) < 0) {
    1294           0 :                 zend_throw_error(NULL, "Mcrypt initialisation failed");
    1295           0 :                 mcrypt_module_close(td);
    1296           0 :                 RETURN_FALSE;
    1297             :         }
    1298             : 
    1299          87 :         if (dencrypt == MCRYPT_ENCRYPT) {
    1300          44 :                 mcrypt_generic(td, data_s, (int)data_size);
    1301             :         } else {
    1302          43 :                 mdecrypt_generic(td, data_s, (int)data_size);
    1303             :         }
    1304             : 
    1305          87 :         data_s[data_size] = 0;
    1306             : 
    1307         174 :         RETVAL_STRINGL(data_s, data_size);
    1308          87 :         efree(data_s);
    1309             : 
    1310             :         /* freeing vars */
    1311          87 :         mcrypt_generic_end(td);
    1312             : }
    1313             : /* }}} */
    1314             : 
    1315             : /* {{{ proto string mcrypt_encrypt(string cipher, string key, string data, string mode, string iv)
    1316             :    OFB crypt/decrypt data using key key with cipher cipher starting with iv */
    1317         179 : PHP_FUNCTION(mcrypt_encrypt)
    1318             : {
    1319         179 :         char *cipher, *key, *data, *mode, *iv = NULL;
    1320         179 :         size_t cipher_len, key_len, data_len, mode_len, iv_len = 0;
    1321             : 
    1322         179 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss|s", &cipher, &cipher_len,
    1323             :                 &key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
    1324          32 :                 return;
    1325             :         }
    1326             : 
    1327         147 :         php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_ENCRYPT, return_value);
    1328             : }
    1329             : /* }}} */
    1330             : 
    1331             : /* {{{ proto string mcrypt_decrypt(string cipher, string key, string data, string mode, string iv)
    1332             :    OFB crypt/decrypt data using key key with cipher cipher starting with iv */
    1333         183 : PHP_FUNCTION(mcrypt_decrypt)
    1334             : {
    1335         183 :         char *cipher, *key, *data, *mode, *iv = NULL;
    1336         183 :         size_t cipher_len, key_len, data_len, mode_len, iv_len = 0;
    1337             : 
    1338         183 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ssss|s", &cipher, &cipher_len,
    1339             :                 &key, &key_len, &data, &data_len, &mode, &mode_len, &iv, &iv_len) == FAILURE) {
    1340          32 :                 return;
    1341             :         }
    1342             : 
    1343         151 :         php_mcrypt_do_crypt(cipher, key, key_len, data, data_len, mode, iv, iv_len, MCRYPT_DECRYPT, return_value);
    1344             : }
    1345             : /* }}} */
    1346             : 
    1347             : /* {{{ proto string mcrypt_create_iv(int size, int source)
    1348             :    Create an initialization vector (IV) */
    1349          15 : PHP_FUNCTION(mcrypt_create_iv)
    1350             : {
    1351             :         char *iv;
    1352          15 :         zend_long source = URANDOM;
    1353             :         zend_long size;
    1354          15 :         int n = 0;
    1355             : 
    1356          15 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &size, &source) == FAILURE) {
    1357           0 :                 return;
    1358             :         }
    1359             : 
    1360          15 :         if (size <= 0 || size >= INT_MAX) {
    1361           0 :                 php_error_docref(NULL, E_WARNING, "Cannot create an IV with a size of less than 1 or greater than %d", INT_MAX);
    1362           0 :                 RETURN_FALSE;
    1363             :         }
    1364             : 
    1365          15 :         iv = ecalloc(size + 1, 1);
    1366             : 
    1367          24 :         if (source == RANDOM || source == URANDOM) {
    1368             : #if PHP_WIN32
    1369             :                 /* random/urandom equivalent on Windows */
    1370             :                 BYTE *iv_b = (BYTE *) iv;
    1371             :                 if (php_win32_get_random_bytes(iv_b, (size_t) size) == FAILURE){
    1372             :                         efree(iv);
    1373             :                         php_error_docref(NULL, E_WARNING, "Could not gather sufficient random data");
    1374             :                         RETURN_FALSE;
    1375             :                 }
    1376             :                 n = (int)size;
    1377             : #else
    1378           9 :                 int    *fd = &MCG(fd[source]);
    1379           9 :                 size_t read_bytes = 0;
    1380             : 
    1381           9 :                 if (*fd < 0) {
    1382           3 :                         *fd = open(source == RANDOM ? "/dev/random" : "/dev/urandom", O_RDONLY);
    1383           3 :                         if (*fd < 0) {
    1384           0 :                                 efree(iv);
    1385           0 :                                 php_error_docref(NULL, E_WARNING, "Cannot open source device");
    1386           0 :                                 RETURN_FALSE;
    1387             :                         }
    1388             :                 }
    1389             : 
    1390          28 :                 while ((zend_long)read_bytes < size) {
    1391          10 :                         n = read(*fd, iv + read_bytes, size - read_bytes);
    1392          10 :                         if (n <= 0) {
    1393           0 :                                 break;
    1394             :                         }
    1395          10 :                         read_bytes += n;
    1396             :                 }
    1397           9 :                 n = read_bytes;
    1398             : 
    1399           9 :                 if (n < size) {
    1400           0 :                         efree(iv);
    1401           0 :                         php_error_docref(NULL, E_WARNING, "Could not gather sufficient random data");
    1402           0 :                         RETURN_FALSE;
    1403             :                 }
    1404             : #endif
    1405             :         } else {
    1406           6 :                 n = (int)size;
    1407         108 :                 while (size) {
    1408          96 :                         iv[--size] = (char) (255.0 * php_rand() / RAND_MAX);
    1409             :                 }
    1410             :         }
    1411          30 :         RETVAL_STRINGL(iv, n);
    1412          15 :         efree(iv);
    1413             : }
    1414             : /* }}} */
    1415             : 
    1416             : #endif
    1417             : 
    1418             : /*
    1419             :  * Local variables:
    1420             :  * tab-width: 4
    1421             :  * c-basic-offset: 4
    1422             :  * End:
    1423             :  * vim600: sw=4 ts=4 fdm=marker
    1424             :  * vim<600: sw=4 ts=4
    1425             :  */

Generated by: LCOV version 1.10

Generated at Wed, 20 Jul 2016 02:56:20 +0000 (3 days ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.