function enkripsi_plain2($algoritma, $mode, $secretkey, $fileplain) { /* Membuka Modul untuk memilih Algoritma & Mode Operasi */ $td = mcrypt_module_open($algoritma, '', $mode, ''); /* Inisialisasi IV dan Menentukan panjang kunci yang digunakan*/ $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND); $ks = mcrypt_enc_get_key_size($td); /* Menghasilkan Kunci */ $key = $secretkey; //echo "kuncinya : ". $key. "<br>"; /* Inisialisasi */ mcrypt_generic_init($td, $key, $iv); /* Enkripsi Data, dimana hasil enkripsi harus di encode dengan base64.\ Hal ini dikarenakan web browser tidak dapat membaca karakter-karakter\ ASCII dalam bentuk simbol-simbol */ $buffer = $fileplain; $encrypted = mcrypt_generic($td, $buffer); $encrypted1 = base64_encode($iv) . ";" . base64_encode($encrypted); $encrypted2 = base64_encode($encrypted1); $filecipher = $encrypted2; /* Menghentikan proses enkripsi dan menutup modul */ mcrypt_generic_deinit($td); mcrypt_module_close($td); return $filecipher; }
public function decrypt($data) { // if($this->input->ip_address() == '10.52.66.172') { // var_dump($data); // die; // } $key = "secret"; $td = mcrypt_module_open(MCRYPT_DES, "", MCRYPT_MODE_ECB, ""); $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND); mcrypt_generic_init($td, $key, $iv); // mcrypt_generic_deinit($td); // if($this->input->ip_address() == '10.52.66.172') { // var_dump($data); // die; // } $data = mdecrypt_generic($td, base64_decode($data)); // if($this->input->ip_address() == '10.52.66.172') { // var_dump($data); // die; // } mcrypt_generic_deinit($td); if (substr($data, 0, 1) != '!') { return false; } $data = substr($data, 1, strlen($data) - 1); return unserialize($data); }
public function decrypt($msg, $k, $base64 = false) { if ($base64) { $msg = base64_decode($msg); } if (!($td = mcrypt_module_open('rijndael-256', '', 'ctr', ''))) { return false; } $iv = substr($msg, 0, 32); $mo = strlen($msg) - 32; $em = substr($msg, $mo); $msg = substr($msg, 32, strlen($msg) - 64); $mac = $this->pbkdf2($iv . $msg, $k, 1000, 32); if ($em !== $mac) { return false; } if (mcrypt_generic_init($td, $k, $iv) !== 0) { return false; } $msg = mdecrypt_generic($td, $msg); $msg = unserialize($msg); mcrypt_generic_deinit($td); mcrypt_module_close($td); return $msg; }
public static function decrypt($varValue, $clesCryptage = null) { self::initialize(); // Recursively decrypt arrays if (is_array($varValue)) { foreach ($varValue as $k => $v) { $varValue[$k] = self::decrypt(urldecode($v)); } return $varValue; } elseif ($varValue == '') { return ''; } $varValue = base64_decode($varValue); $ivsize = mcrypt_enc_get_iv_size(self::$resTd); $iv = substr($varValue, 0, $ivsize); $varValue = substr($varValue, $ivsize); if ($varValue == '') { return ''; } if ($clesCryptage === null) { $clesCryptage = self::$clesCryptage; } mcrypt_generic_init(self::$resTd, md5($clesCryptage), $iv); $strDecrypted = mdecrypt_generic(self::$resTd, $varValue); mcrypt_generic_deinit(self::$resTd); if (strpos($strDecrypted, "%") !== false) { return urldecode($strDecrypted); } else { return $strDecrypted; } }
function phpFreaksCrypto($key = 'a843l?nv89rjfd}O(jdnsleken0', $iv = false, $algorithm = 'tripledes', $mode = 'ecb') { if (extension_loaded('mcrypt') === FALSE) { //$prefix = (PHP_SHLIB_SUFFIX == 'dll') ? 'php_' : ''; //dl($prefix . 'mcrypt.' . PHP_SHLIB_SUFFIX) or die('The Mcrypt module could not be loaded.'); die('The Mcrypt module is not loaded and is required.'); } if ($mode != 'ecb' && $iv === false) { /* the iv must remain the same from encryption to decryption and is usually passed into the encrypted string in some form, but not always. */ die('In order to use encryption modes other then ecb, you must specify a unique and consistent initialization vector.'); } // set mcrypt mode and cipher $this->td = mcrypt_module_open($algorithm, '', $mode, ''); // Unix has better pseudo random number generator then mcrypt, so if it is available lets use it! //$random_seed = strstr(PHP_OS, "WIN") ? MCRYPT_RAND : MCRYPT_DEV_RANDOM; $random_seed = MCRYPT_RAND; // if initialization vector set in constructor use it else, generate from random seed $iv = $iv === false ? mcrypt_create_iv(mcrypt_enc_get_iv_size($this->td), $random_seed) : substr($iv, 0, mcrypt_enc_get_iv_size($this->td)); // get the expected key size based on mode and cipher $expected_key_size = mcrypt_enc_get_key_size($this->td); // we dont need to know the real key, we just need to be able to confirm a hashed version $key = substr(md5($key), 0, $expected_key_size); // initialize mcrypt library with mode/cipher, encryption key, and random initialization vector mcrypt_generic_init($this->td, $key, $iv); }
/** * Decrypt * * @param string $data Data to decrypt * * @return string */ public function decrypt($data) { mcrypt_generic_init($this->module, $this->key, $this->iv); $decrypted = mdecrypt_generic($this->module, $data); mcrypt_generic_deinit($this->module); return trim($decrypted); }
/** * 对密文进行解密 * @param string $encrypt 密文 * @return string 明文 */ public function decrypt($encrypt) { //BASE64解码 $encrypt = base64_decode($encrypt); //打开加密算法模块 $td = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_CBC, ''); //初始化加密算法模块 mcrypt_generic_init($td, $this->cyptKey, substr($this->cyptKey, 0, 16)); //执行解密 $decrypt = mdecrypt_generic($td, $encrypt); //去除PKCS7补位 $decrypt = self::PKCS7Decode($decrypt, mcrypt_enc_get_key_size($td)); //关闭加密算法模块 mcrypt_generic_deinit($td); mcrypt_module_close($td); if (strlen($decrypt) < 16) { throw new \Exception("非法密文字符串!"); } //去除随机字符串 $decrypt = substr($decrypt, 16); //获取网络字节序 $size = unpack("N", substr($decrypt, 0, 4)); $size = $size[1]; //APP_ID $appid = substr($decrypt, $size + 4); //验证APP_ID if ($appid !== $this->appId) { throw new \Exception("非法APP_ID!"); } //明文内容 $text = substr($decrypt, 4, $size); return $text; }
public function decrypt($ciphertext) { mcrypt_generic_init($this->encrypter, $this->key, substr($this->key, 0, 16)); $origData = mdecrypt_generic($this->encrypter, $ciphertext); mcrypt_generic_deinit($this->encrypter); return pkcs5unPadding($origData); }
static function decrypt($input, $base64 = true) { if (!$input || !strlen($input) > 0) { return null; } if (!($td = mcrypt_module_open('rijndael-256', '', 'ctr', ''))) { return null; } if ($base64) { $content = base64_decode($input); } else { $content = $input; } $iv = substr($content, 0, 32); $extract = substr($content, strlen($content) - 32); $content = substr($content, 32, strlen($content) - 64); $mac = self::pbkdf2($iv . $content, MSettings::$c_key, 1000, 32); if ($extract !== $mac) { return null; } if (mcrypt_generic_init($td, MSettings::$c_key, $iv) !== 0) { return null; } $content = mdecrypt_generic($td, $content); $content = unserialize($content); mcrypt_generic_deinit($td); mcrypt_module_close($td); return $content; }
public function encrypt($string) { mcrypt_generic_init($this->cipher, $this->key, $this->iv); $cipherText = mcrypt_generic($this->cipher, $string); mcrypt_generic_deinit($this->cipher); return $cipherText; }
/** * Decryption of data * * @param string $data Data to be decrypted * @param bool|string $key Key, if not specified - system key will be used * * @return bool|mixed */ function decrypt($data, $key = false) { if (!$this->encrypt_support) { return $data; } if (!is_resource($this->td)) { $this->td = mcrypt_module_open(MCRYPT_BLOWFISH, '', 'cbc', ''); $this->key = mb_substr($this->key, 0, mcrypt_enc_get_key_size($this->td)); $this->iv = mb_substr(md5($this->iv), 0, mcrypt_enc_get_iv_size($this->td)); } if ($key === false) { $key = $this->key; } else { $key = mb_substr(md5($this->key) . md5($key), 0, mcrypt_enc_get_key_size($this->td)); } mcrypt_generic_init($this->td, $key, $this->iv); errors_off(); $decrypted = @unserialize(mdecrypt_generic($this->td, $data)); errors_on(); mcrypt_generic_deinit($this->td); if (is_array($decrypted) && $decrypted['key'] == $key) { return $decrypted['data']; } else { return false; } }
public function decrypt($encrypted, $corpid) { try { $ciphertext_dec = base64_decode($encrypted); $module = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_CBC, ''); $iv = substr($this->key, 0, 16); mcrypt_generic_init($module, $this->key, $iv); $decrypted = mdecrypt_generic($module, $ciphertext_dec); mcrypt_generic_deinit($module); mcrypt_module_close($module); } catch (Exception $e) { return array(ErrorCode::$DecryptAESError, null); } try { //去除补位字符 $pkc_encoder = new PKCS7Encoder(); $result = $pkc_encoder->decode($decrypted); //去除16位随机字符串,网络字节序和AppId if (strlen($result) < 16) { return ""; } $content = substr($result, 16, strlen($result)); $len_list = unpack("N", substr($content, 0, 4)); $xml_len = $len_list[1]; $xml_content = substr($content, 4, $xml_len); $from_corpid = substr($content, $xml_len + 4); } catch (Exception $e) { print $e; return array(ErrorCode::$DecryptAESError, null); } if ($from_corpid != $corpid) { return array(ErrorCode::$ValidateSuiteKeyError, null); } return array(0, $xml_content); }
public function decrypt($text) { mcrypt_generic_init($this->td, $this->key, $this->iv); $decrypted = mdecrypt_generic($this->td, $text); mcrypt_generic_deinit($this->td); return $decrypted; }
public function computeSign($sharedSecret) { if (!$this->isValid) { throw new Exception(__METHOD__ . ": Message was not validated."); } try { // ak mame zadany shared secret v hexa tvare tak ho prevedieme na 32 bytovy string if (strlen($sharedSecret) == 64) { $sharedSecret = pack('H*', $sharedSecret); } $base = $this->GetSignatureBase(); $bytesHash = sha1($base, TRUE); // vezmeme prvych 16 bytov $bytesHash = substr($bytesHash, 0, 16); $aes = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_ECB, ''); $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($aes), MCRYPT_RAND); mcrypt_generic_init($aes, $sharedSecret, $iv); $bytesSign = mcrypt_generic($aes, $bytesHash); mcrypt_generic_deinit($aes); mcrypt_module_close($aes); $sign = strtoupper(bin2hex($bytesSign)); } catch (Exception $e) { return FALSE; } return $sign; }
/** * 要解密的字符串 * * @param string $string 需要解密的字符 * * @return string */ public function decode($string) { mcrypt_generic_init($this->td, $this->key, $this->iv); $data = mdecrypt_generic($this->td, base64_decode($string)); mcrypt_generic_deinit($this->td); return trim($data); }
public function decrypt($encrypted, $appid) { try { $ciphertext_dec = base64_decode($encrypted); $module = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_CBC, ''); $iv = substr($this->key, 0, 16); mcrypt_generic_init($module, $this->key, $iv); $decrypted = mdecrypt_generic($module, $ciphertext_dec); mcrypt_generic_deinit($module); mcrypt_module_close($module); } catch (Exception $e) { return array(ErrorCode::$DecryptAESError, NULL); } try { $pkc_encoder = new PKCS7Encoder(); $result = $pkc_encoder->decode($decrypted); if (strlen($result) < 16) { return ''; } $content = substr($result, 16, strlen($result)); $len_list = unpack('N', substr($content, 0, 4)); $xml_len = $len_list[1]; $xml_content = substr($content, 4, $xml_len); $from_appid = substr($content, $xml_len + 4); } catch (Exception $e) { print $e; return array(ErrorCode::$IllegalBuffer, NULL); } if ($from_appid != $appid) { return array(ErrorCode::$ValidateAppidError, NULL); } return array(0, $xml_content); }
private function decrypt($input, $base64 = false) { if ($this->key == '') { return false; } if ($base64) { $input = base64_decode($input); } if (!($td = mcrypt_module_open('rijndael-256', '', 'ctr', ''))) { return false; } $iv = substr($input, 0, 32); $mace = substr($input, strlen($input) - 32); $input = substr($input, 32, strlen($input) - 64); $macd = $this->pbkdf2($iv . $input, $this->key, 1000, 32); if ($mace !== $macd) { return false; } if (mcrypt_generic_init($td, $this->key, $iv) !== 0) { return false; } $decrypted_data = mdecrypt_generic($td, $input); $decrypted_data = unserialize($decrypted_data); mcrypt_generic_deinit($td); mcrypt_module_close($td); return $decrypted_data; }
function ssl_encode($data, $key = '') { // Use the Encrypt.php function get_key to encode the data. $key = $this->get_key($key); // Set a random salt $salt = substr(md5(mt_rand(), true), 8); $block = mcrypt_get_block_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_CBC); $pad = $block - strlen($data) % $block; $data = $data . str_repeat(chr($pad), $pad); // Setup encryption parameters $td = mcrypt_module_open(MCRYPT_RIJNDAEL_128, "", MCRYPT_MODE_CBC, ""); $key_len = mcrypt_enc_get_key_size($td); $iv_len = mcrypt_enc_get_iv_size($td); $total_len = $key_len + $iv_len; $salted = ''; $dx = ''; // Salt the key and iv while (strlen($salted) < $total_len) { $dx = md5($dx . $key . $salt, true); $salted .= $dx; } $key = substr($salted, 0, $key_len); $iv = substr($salted, $key_len, $iv_len); mcrypt_generic_init($td, $key, $iv); $encrypted_data = mcrypt_generic($td, $data); mcrypt_generic_deinit($td); mcrypt_module_close($td); return chunk_split(base64_encode('Salted__' . $salt . $encrypted_data), 32, "\n"); }
function decryptNET3DES($key, $iv, $text) { if (empty($text)) { return ""; } $td = mcrypt_module_open(MCRYPT_3DES, '', MCRYPT_MODE_ECB, ''); // 把key值补充完整,在PHP里面如果key值不够24位剩下的会自动补0,但是在.net中,会做一个循环把前面的值补充到后面补够24位,所以这里强制补前面的字符 $key_add = 24 - strlen($key); $key .= substr($key, 0, $key_add); mcrypt_generic_init($td, $key, $iv); $decrypt_text = mdecrypt_generic($td, $text); mcrypt_generic_deinit($td); mcrypt_module_close($td); //去掉padding的尾巴,因为.net中默认的padding是PKCS7,而php中默认的padding是zero,所以在.net使用默认的情况下,要将php程序的padding重新设置 $block = mcrypt_get_block_size('tripledes', 'ecb'); $packing = ord($decrypt_text[strlen($decrypt_text) - 1]); if ($packing and $packing < $block) { for ($P = strlen($decrypt_text) - 1; $P >= strlen($decrypt_text) - $packing; $P--) { if (ord($decrypt_text[$P]) != $packing) { $packing = 0; } } } $decrypt_text = substr($decrypt_text, 0, strlen($decrypt_text) - $packing); return $decrypt_text; }
public function decrypt($encrypted, $is_id = false) { static $_map = array(); if ($is_id) { $len = strlen($encrypted); $tmp = ''; for ($i = 0; $i < $len; $i = $i + 2) { $tmp = $tmp . chr(hexdec($encrypted[$i] . $encrypted[$i + 1])); } $encrypted = $tmp; } else { $encrypted = base64_decode($encrypted); } $hashkey = md5($encrypted . $this->key); if (isset($_map[$hashkey])) { return $_map[$hashkey]; } $key = str_pad($this->key, 24, '0'); $td = mcrypt_module_open(MCRYPT_3DES, '', 'ecb', ''); $iv = @mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND); $ks = mcrypt_enc_get_key_size($td); @mcrypt_generic_init($td, $key, $iv); $decrypted = mdecrypt_generic($td, $encrypted); mcrypt_generic_deinit($td); mcrypt_module_close($td); $y = $this->pkcs5_unpad($decrypted); if ($is_id) { $y = base_convert($y, 36, 10); } $_map[$hashkey] = $y; return $y; }
public function __construct($key, $algorithm, $mode = 'ecb', $iv = false) { /* In non-ECB mode, an initialization vector is required. */ if ($mode != 'ecb' && $iv === false) { return false; } /* Try to open the encryption module. */ $this->_td = mcrypt_module_open($algorithm, '', $mode, ''); if ($this->_td === false) { return false; } /* Use UNIX random number generator if available. */ if (strstr(PHP_OS, 'WIN') !== false) { $randomSeed = MCRYPT_RAND; } else { $randomSeed = MCRYPT_DEV_RANDOM; } /* If an initialization vector was not specified, create one; * otherwise ensure that the specified IV is the proper size. */ if ($iv === false) { $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($this->_td), $randomSeed); } else { $iv = substr($iv, 0, mcrypt_enc_get_iv_size($this->_td)); } /* Trim the key to the maximum allowed key size. */ $key = substr($key, 0, mcrypt_enc_get_key_size($this->_td)); /* Initialize the MCrypt library. */ mcrypt_generic_init($this->_td, $key, $iv); }
public function authenticate(array $credentials) { $mcrypt = mcrypt_module_open(MCRYPT_BLOWFISH, '', MCRYPT_MODE_CBC, ''); $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($mcrypt), MCRYPT_DEV_RANDOM); mcrypt_generic_init($mcrypt, $this->cryptPassword, $iv); $url = $this->getUrl($credentials[self::USERNAME], $credentials[self::PASSWORD], $mcrypt, $iv); try { $res = $this->httpClient->get($url)->send(); } catch (\Guzzle\Http\Exception\ClientErrorResponseException $e) { if ($e->getResponse()->getStatusCode() === 403) { throw new \Nette\Security\AuthenticationException("User '{$credentials[self::USERNAME]}' not found.", self::INVALID_CREDENTIAL); } elseif ($e->getResponse()->getStatusCode() === 404) { throw new \Nette\Security\AuthenticationException("Invalid password.", self::IDENTITY_NOT_FOUND); } else { throw $e; } } $responseBody = trim(mdecrypt_generic($mcrypt, $res->getBody(TRUE))); $apiData = Json::decode($responseBody); $user = $this->db->table('users')->where('id = ?', $apiData->id)->fetch(); $registered = new \DateTimeImmutable($apiData->registered->date, new \DateTimeZone($apiData->registered->timezone)); $userData = array('username' => $credentials[self::USERNAME], 'password' => $this->calculateAddonsPortalPasswordHash($credentials[self::PASSWORD]), 'email' => $apiData->email, 'realname' => $apiData->realname, 'url' => $apiData->url, 'signature' => $apiData->signature, 'language' => $apiData->language, 'num_posts' => $apiData->num_posts, 'apiToken' => $apiData->apiToken, 'registered' => $registered->getTimestamp()); if (!$user) { $userData['id'] = $apiData->id; $userData['group_id'] = 4; $this->db->table('users')->insert($userData); $user = $this->db->table('users')->where('username = ?', $credentials[self::USERNAME])->fetch(); } else { $user->update($userData); } return $this->createIdentity($user); }
public function decrypt($encrypted, $appid = '') { try { $encrypted = base64_decode($encrypted); $td = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', MCRYPT_MODE_CBC, ''); $iv = substr($this->key, 0, 16); mcrypt_generic_init($td, $this->key, $iv); $decrypted = mdecrypt_generic($td, $encrypted); mcrypt_generic_deinit($td); mcrypt_module_close($td); } catch (Exception $e) { throw new Exception($e->getMessage(), ErrorCode::$DecryptAESError); } try { $result = self::PKCS7Decode($decrypted); if (strlen($result) < 16) { throw new Exception('PKCS7Decode length less than 16', ErrorCode::$IllegalBuffer); } $content = substr($result, 16); $lenlist = unpack('N', substr($content, 0, 4)); $xmlLen = $lenlist[1]; $xmlData = substr($content, 4, $xmlLen); $fromId = substr($content, $xmlLen + 4); } catch (Exception $e) { throw new Exception($e->getMessage(), ErrorCode::$IllegalBuffer); } if ($fromId != $appid) { throw new Exception('Unvalidated Appid.', ErrorCode::$ValidateAppidError); } else { return $xmlData; } }
public function decrypt($data) { mcrypt_generic_init($this->module, $this->key, $this->iv); $ret = mdecrypt_generic($this->module, $data); mcrypt_generic_deinit($this->module); return rtrim($ret, ""); }
public function computeSign($sharedSecret) { if (!$this->isValid) { throw new Exception(__METHOD__ . ": Message was not validated."); } try { $bytesHash = sha1($this->GetSignatureBase(), true); $sharedSecret = pack('H*', $sharedSecret); // uprava pre PHP < 5.0 if (strlen($bytesHash) != 20) { $bytes = ""; for ($i = 0; $i < strlen($bytesHash); $i += 2) { $bytes .= chr(hexdec(substr($str, $i, 2))); } $bytesHash = $bytes; } $cipher = mcrypt_module_open(MCRYPT_RIJNDAEL_128, "", MCRYPT_MODE_ECB, ""); $iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($cipher), MCRYPT_RAND); mcrypt_generic_init($cipher, $sharedSecret, $iv); $text = $this->pad(substr($bytesHash, 0, 16), mcrypt_get_block_size(MCRYPT_RIJNDAEL_128, MCRYPT_MODE_ECB)); $bytesSign = mcrypt_generic($cipher, $text); mcrypt_generic_deinit($cipher); mcrypt_module_close($cipher); $sign = substr(strtoupper(bin2hex($bytesSign)), 0, 32); } catch (Exception $e) { return false; } return $sign; }
/** * @param string $api_key API ключ UserEcho * @param string $project_key Ключ UserEcho * @param array $user_info * * @return SSO KEY */ public static function get_sso_token($api_key, $project_key, $user_info) { $sso_key = ''; if ($uid = get_uid(false)) { $user = new users(); $user->GetUserByUID($uid); $iv = str_shuffle('memoKomo1234QWER'); $message = array('guid' => $uid, 'expires_date' => gmdate('Y-m-d H:i:s', time() + 86400), 'display_name' => $user->login, 'email' => $user->email, 'locale' => 'ru', 'verified_email' => true); // key hash, length = 16 $key_hash = substr(hash('sha1', $api_key . $project_key, true), 0, 16); $message_json = json_encode(encodeCharset('CP1251', 'UTF-8', $message)); // double XOR first block message_json for ($i = 0; $i < 16; ++$i) { $message_json[$i] = $message_json[$i] ^ $iv[$i]; } // fill tail of message_json by bytes equaled count empty bytes (to 16) $pad = 16 - strlen($message_json) % 16; $message_json = $message_json . str_repeat(chr($pad), $pad); // encode json $cipher = mcrypt_module_open(MCRYPT_RIJNDAEL_128, '', 'cbc', ''); mcrypt_generic_init($cipher, $key_hash, $iv); $encrypted_bytes = mcrypt_generic($cipher, $message_json); mcrypt_generic_deinit($cipher); // encode bytes to url safe string $sso_key = urlencode(base64_encode($encrypted_bytes)); } return $sso_key; }
/** */ public function decrypt($text) { mcrypt_generic_init($this->_mcrypt, $this->key, empty($this->iv) ? str_repeat('0', Horde_Crypt_Blowfish::IV_LENGTH) : $this->iv); $out = mdecrypt_generic($this->_mcrypt, $this->_pad($text, true)); mcrypt_generic_deinit($this->_mcrypt); return $this->_unpad($out); }
/** * Constructor * * @param string $key Secret encryption key. * It's unsafe to store encryption key in memory, so no getter for key exists. * @param string $cipher Cipher algorithm (one of the MCRYPT_ciphername constants) * @param string $mode Mode of cipher algorithm (MCRYPT_MODE_modeabbr constants) * @param string|bool $initVector Initial vector to fill algorithm blocks. * TRUE generates a random initial vector. * FALSE fills initial vector with zero bytes to not use it. * @throws \Exception */ public function __construct($key, $cipher = MCRYPT_BLOWFISH, $mode = MCRYPT_MODE_ECB, $initVector = false) { $this->_cipher = $cipher; $this->_mode = $mode; $this->_handle = mcrypt_module_open($cipher, '', $mode, ''); try { $maxKeySize = mcrypt_enc_get_key_size($this->_handle); if (strlen($key) > $maxKeySize) { throw new \Magento\Framework\Exception('Key must not exceed ' . $maxKeySize . ' bytes.'); } $initVectorSize = mcrypt_enc_get_iv_size($this->_handle); if (true === $initVector) { /* Generate a random vector from human-readable characters */ $abc = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; $initVector = ''; for ($i = 0; $i < $initVectorSize; $i++) { $initVector .= $abc[rand(0, strlen($abc) - 1)]; } } elseif (false === $initVector) { /* Set vector to zero bytes to not use it */ $initVector = str_repeat("", $initVectorSize); } elseif (!is_string($initVector) || strlen($initVector) != $initVectorSize) { throw new \Magento\Framework\Exception('Init vector must be a string of ' . $initVectorSize . ' bytes.'); } $this->_initVector = $initVector; } catch (\Exception $e) { mcrypt_module_close($this->_handle); throw $e; } mcrypt_generic_init($this->_handle, $key, $initVector); }
/** * Initialize mcrypt module * * @param string $key cipher private key * @return Varien_Crypt_Mcrypt */ public function init($key) { if (!$this->getCipher()) { $this->setCipher(MCRYPT_BLOWFISH); } if (!$this->getMode()) { $this->setMode(MCRYPT_MODE_ECB); } $this->setHandler(mcrypt_module_open($this->getCipher(), '', $this->getMode(), '')); if (!$this->getInitVector()) { if (MCRYPT_MODE_CBC == $this->getMode()) { $this->setInitVector(substr(md5(mcrypt_create_iv(mcrypt_enc_get_iv_size($this->getHandler()), MCRYPT_RAND)), -mcrypt_enc_get_iv_size($this->getHandler()))); } else { $this->setInitVector(mcrypt_create_iv(mcrypt_enc_get_iv_size($this->getHandler()), MCRYPT_RAND)); } } $maxKeySize = mcrypt_enc_get_key_size($this->getHandler()); if (strlen($key) > $maxKeySize) { // strlen() intentionally, to count bytes, rather than characters $this->setHandler(null); throw new Varien_Exception('Maximum key size must be smaller ' . $maxKeySize); } mcrypt_generic_init($this->getHandler(), $key, $this->getInitVector()); return $this; }
public function __construct($cipher, $key, $taglen) { $logging = \Plop\Plop::getInstance(); $this->cipher = mcrypt_module_open($cipher, null, 'ecb', null); mcrypt_generic_init($this->cipher, $key, str_repeat("", 16)); $this->taglen = $taglen; $logging->debug('Pre-computing GCM table'); $H = gmp_init(bin2hex(mcrypt_generic($this->cipher, str_repeat("", 16))), 16); $H = str_pad(gmp_strval($H, 2), 128, '0', STR_PAD_LEFT); $R = gmp_init('E1000000000000000000000000000000', 16); $this->table = array(); for ($i = 0; $i < 16; $i++) { $this->table[$i] = array(); for ($j = 0; $j < 256; $j++) { $V = gmp_init(dechex($j) . str_repeat("00", $i), 16); $Z = gmp_init(0); for ($k = 0; $k < 128; $k++) { // Compute Z_n+1 if ($H[$k]) { $Z = gmp_xor($Z, $V); } // Compute V_n+1 $odd = gmp_testbit($V, 0); $V = gmp_div_q($V, 2); if ($odd) { $V = gmp_xor($V, $R); } } $this->table[$i][$j] = pack('H*', str_pad(gmp_strval($Z, 16), 32, 0, STR_PAD_LEFT)); } } $logging->debug('Done pre-computing GCM table'); }