public static function encrypt($string, $key = '')
{
$encrypted = null;
if (function_exists("mcrypt_generic") && mcrypt_module_self_test(MCRYPT_WAKE)) {
$encrypted = jCrypt::mcryptEncrypt($string, $key);
} else {
$encrypted = jCrypt::simpleCrypt($string, $key);
}
return base64_encode($encrypted);
}
/**
* Encrypt a string with a specific key
* @param string $string the string to encrypt
* @param string $key the key used to encrypt
* @return string encrypted string
*/
public static function encrypt($string, $key)
{
$encrypted = null;
// Check if mcrypt is installed, and if WAKE algo exists
if (function_exists("mcrypt_generic") && mcrypt_module_self_test(MCRYPT_WAKE)) {
$encrypted = jCrypt::mcryptEncrypt($string, $key);
} else {
$encrypted = jCrypt::simpleCrypt($string, $key);
}
return base64_encode($encrypted);
}
function check_environment()
{
global $config;
//check mcrypt
if (!function_exists('mcrypt_encrypt')) {
throw new arcException('PHPs mcrypt library not available!');
}
//check ciphers
foreach ($config['used_mcrypt_ciphers'] as $cipher => $mode) {
if (!mcrypt_module_self_test($cipher)) {
throw new arcException('Trying to use cipher [' . $cipher . '], but self-test failed!');
}
}
//check paths
if (!is_dir($config['tmppath'])) {
@mkdir($config['tmppath']);
chmod($config['tmppath'], 0700);
}
if (!is_writable($config['tmppath'])) {
throw new arcException("tmppath " . $config['tmppath'] . " is not writable!");
}
if (!is_dir($config['cache_path'])) {
@mkdir($config['cache_path']);
chmod($config['cache_path'], 0700);
}
if (!is_writable($config['cache_path'])) {
throw new arcException("cache_path " . $config['cache_path'] . " is not writable!");
}
$virusscanner = explode(' ', $config['virusscanner']);
if (!is_executable($virusscanner[0]) && $config['enablevirusscan'] === TRUE) {
throw new arcException("Filescanner [" . $config['virusscanner'] . "] not executable");
}
if (!is_dir($config['js_lang_realpath'])) {
@mkdir($config['js_lang_realpath']);
//dont throw any arcException, arcanum may work anyway
}
}
/**
* Sets new encryption options
*
* @param string|array $options Encryption options
* @return Zend_Filter_File_Encryption
*/
public function setEncryption($options)
{
if (is_string($options)) {
$options = array('key' => $options);
}
if (!is_array($options)) {
#require_once 'Zend/Filter/Exception.php';
throw new Zend_Filter_Exception('Invalid options argument provided to filter');
}
$options = $options + $this->getEncryption();
$algorithms = mcrypt_list_algorithms($options['algorithm_directory']);
if (!in_array($options['algorithm'], $algorithms)) {
#require_once 'Zend/Filter/Exception.php';
throw new Zend_Filter_Exception("The algorithm '{$options['algorithm']}' is not supported");
}
$modes = mcrypt_list_modes($options['mode_directory']);
if (!in_array($options['mode'], $modes)) {
#require_once 'Zend/Filter/Exception.php';
throw new Zend_Filter_Exception("The mode '{$options['mode']}' is not supported");
}
if (!mcrypt_module_self_test($options['algorithm'], $options['algorithm_directory'])) {
#require_once 'Zend/Filter/Exception.php';
throw new Zend_Filter_Exception('The given algorithm can not be used due an internal mcrypt problem');
}
if (!isset($options['vector'])) {
$options['vector'] = null;
}
$this->_encryption = $options;
$this->setVector($options['vector']);
return $this;
}
public function decrypt($text, $iv)
{
if (!Xcrud_config::$alt_encription_key) {
self::error('Please, set <strong>$alt_encription_key</strong> parameter in configuration file');
}
if (!is_callable('mcrypt_module_open')) {
self::error('<strong>mcrypt_module</strong> not found');
}
if (defined('MCRYPT_TWOFISH') && mcrypt_module_self_test(MCRYPT_TWOFISH)) {
$algoritm = MCRYPT_TWOFISH;
} elseif (defined('MCRYPT_RIJNDAEL_256') && mcrypt_module_self_test(MCRYPT_RIJNDAEL_256)) {
$algoritm = MCRYPT_RIJNDAEL_256;
} elseif (defined('MCRYPT_SERPENT') && mcrypt_module_self_test(MCRYPT_SERPENT)) {
$algoritm = MCRYPT_SERPENT;
} elseif (defined('MCRYPT_BLOWFISH') && mcrypt_module_self_test(MCRYPT_BLOWFISH)) {
$algoritm = MCRYPT_BLOWFISH;
} else {
self::error('MCRYPT - Supported algorytm not found');
}
$td = mcrypt_module_open($algoritm, '', MCRYPT_MODE_CFB, '');
$ks = mcrypt_enc_get_key_size($td);
$key = substr(Xcrud_config::$alt_encription_key, 0, $ks);
mcrypt_generic_init($td, $key, base64_decode($iv));
$decrypted = mdecrypt_generic($td, base64_decode($text));
mcrypt_generic_deinit($td);
mcrypt_module_close($td);
$obj = json_decode($decrypted, true);
return $obj;
}
function mcrypt_module_self_test($algorithm, $lib_dir = '')
{
return mcrypt_module_self_test($algorithm, $lib_dir);
}
/**
* Comprobar si el módulo de encriptación está disponible.
*
* @return bool
*/
public static function checkCryptModule()
{
return mcrypt_module_self_test(MCRYPT_RIJNDAEL_256);
}
mcrypt_generic_init($td, $key, $iv);
$decrypted = mdecrypt_generic($td, $encrypted);
mcrypt_generic_end($td);
mcrypt_module_close($td);
VS($decrypted, "This is very important data");
VERIFY(in_array("blowfish", mcrypt_list_algorithms()));
VERIFY(in_array("cbc", mcrypt_list_modes()));
VS(mcrypt_module_get_algo_block_size("blowfish"), 8);
VS(mcrypt_module_get_algo_key_size("blowfish"), 56);
VS(mcrypt_module_get_supported_key_sizes("blowfish"), array());
VS(mcrypt_module_get_supported_key_sizes("twofish"), array(16, 24, 32));
VS(mcrypt_module_is_block_algorithm_mode("cbc"), true);
VS(mcrypt_module_is_block_algorithm("blowfish"), true);
VS(mcrypt_module_is_block_mode("cbc"), true);
VS(mcrypt_module_self_test(MCRYPT_RIJNDAEL_128), true);
VS(mcrypt_module_self_test("bogus"), false);
$text = "boggles the inivisble monkey will rule the world";
$key = "very secret key";
$iv_size = mcrypt_get_iv_size(MCRYPT_XTEA, MCRYPT_MODE_ECB);
$iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
$enc = mcrypt_encrypt(MCRYPT_XTEA, $key, $text, MCRYPT_MODE_ECB, $iv);
VS(bin2hex($enc), "f522c62002fa16129c8576bcddc6dd0f7ea81991103ba42962d94c8bfff3ee660d53b187d7e989540abf5a729c2f7baf");
$crypttext = mcrypt_decrypt(MCRYPT_XTEA, $key, $enc, MCRYPT_MODE_ECB, $iv);
VS($crypttext, $text);
//////////////////////////////////////////////////////////////////////
$key = "123456789012345678901234567890123456789012345678901234567890";
$CC = "4007000000027";
$encrypted = mcrypt_cbc(MCRYPT_RIJNDAEL_128, substr($key, 0, 32), $CC, MCRYPT_ENCRYPT, substr($key, 32, 16));
$decrypted = mcrypt_cbc(MCRYPT_RIJNDAEL_128, substr($key, 0, 32), $encrypted, MCRYPT_DECRYPT, substr($key, 32, 16));
VERIFY($encrypted !== $decrypted);
VS(trim((string) $decrypted), $CC);
<?php
var_dump(mcrypt_module_self_test(MCRYPT_RIJNDAEL_128));
var_dump(mcrypt_module_self_test(MCRYPT_RC2));
var_dump(mcrypt_module_self_test(''));
/**
* Run mcrypt module self-test.
*/
function testSelfModuleMcrypt()
{
$this->assertTrue(mcrypt_module_self_test(MCRYPT_RIJNDAEL_256));
$this->assertTrue(mcrypt_module_self_test(MCRYPT_BLOWFISH));
}
/**
* Performs an internal self-test on the specified mcrypt algorithm and
* returns either boolean true/false depending on if the self-test passed
* or failed.
*
* @param string $cipher_type
* @return boolean
*/
public function algoSelfTest($cipher_type = MCRYPT_TRIPLEDES)
{
return mcrypt_module_self_test($cipher_type);
}
