PHP mcrypt_module_open函数代码示例

 /**
  * 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 Magento_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_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)];
             }
         } else {
             if (false === $initVector) {
                 /* Set vector to zero bytes to not use it */
                 $initVector = str_repeat("", $initVectorSize);
             } else {
                 if (!is_string($initVector) || strlen($initVector) != $initVectorSize) {
                     throw new Magento_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);
 }

 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;
 }

 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 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($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;
     }
 }

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;
}

 /**
  * 对密文进行解密
  * @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;
 }

 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");
 }

 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;
 }

 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 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);
 }

 /**
  * 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 __construct($key = '', $algorithm = MCRYPT_DES, $mode = MCRYPT_MODE_CBC)
 {
     if (!empty($key)) {
         $this->key = $key;
     }
     $this->encrypter = mcrypt_module_open($algorithm, '', $mode, '');
 }

 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);
 }

 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;
 }