PHP mcrypt_module_get_algo_key_size函数代码示例

 function __construct($cipher)
 {
     $this->cipher = $cipher;
     $this->key_size = mcrypt_module_get_algo_key_size($cipher);
     $this->block_size = mcrypt_module_get_algo_block_size($cipher);
     $this->iv = str_repeat("", mcrypt_get_iv_size($cipher, 'ncfb'));
 }

    /**
     * Decrypt a text using Mcrypt
     *
     * @see http://maxime-ohayon.developpez.com/tutoriels/mcrypt
     * @param string $algorithm, ex : MCRYPT_3DES, MCRYPT_BLOWFISH, etc. see Mcrpyt doc
     * @param string $mode,      ex : MCRYPT_MODE_ECB, MCRYPT_MODE_NOFB, etc. see Mcrpyt doc
     * @param string $key        = your secret key or passphrase
     * @param string $encrypted  : your value to be decrypted
     */
    public static function decrypt($algorithm = MCRYPT_BLOWFISH, $mode = MCRYPT_MODE_NOFB, $key = "mySecretKey", $encrypted = "encryptedText")
    {
        $key_size = mcrypt_module_get_algo_key_size($algorithm);
        $iv_size = mcrypt_get_iv_size($algorithm, $mode);
        $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
        $key = substr($key, 0, $key_size);

        return mcrypt_decrypt($algorithm, $key, $cyphered, $mode, $iv);
    }

 public function testBase64Mode()
 {
     $algo = Mcrypt::ALGO_DES;
     $mode = Mcrypt::MODE_ECB;
     $key = Mcrypt::createRandomKey(mcrypt_module_get_algo_key_size($algo));
     $iv = Mcrypt::createRandomIv(mcrypt_get_iv_size($algo, $mode));
     $mcrypt = new Mcrypt($key, $iv, $algo, $mode);
     $mcrypt->setBase64Mode(false);
     $encrypted = $mcrypt->encrypt('foo');
     $this->assertSame(base64_encode($encrypted), $mcrypt->setBase64Mode(true)->encrypt('foo'));
 }

 /**
  * Checks if a key is valid for {@link cryptAlgorithm}.
  * @param string $key the key to check
  * @return boolean the validation result
  * @throws CException if the supported key lengths of the cipher are unknown
  */
 protected function validateEncryptionKey($key)
 {
     if (is_string($key)) {
         $supportedKeyLengths = mcrypt_module_get_supported_key_sizes($this->cryptAlgorithm);
         if ($supportedKeyLengths) {
             if (!in_array($this->strlen($key), $supportedKeyLengths)) {
                 throw new CException(Yii::t('yii', 'Encryption key length can be {keyLengths}.', array('{keyLengths}' => implode(',', $supportedKeyLengths))));
             }
         } elseif (isset(self::$encryptionKeyMinimumLengths[$this->cryptAlgorithm])) {
             $minLength = self::$encryptionKeyMinimumLengths[$this->cryptAlgorithm];
             $maxLength = mcrypt_module_get_algo_key_size($this->cryptAlgorithm);
             if ($this->strlen($key) < $minLength || $this->strlen($key) > $maxLength) {
                 throw new CException(Yii::t('yii', 'Encryption key length must be between {minLength} and {maxLength}.', array('{minLength}' => $minLength, '{maxLength}' => $maxLength)));
             }
         } else {
             throw new CException(Yii::t('yii', 'Failed to validate key. Supported key lengths of cipher not known.'));
         }
     } else {
         throw new CException(Yii::t('yii', 'Encryption key should be a string.'));
     }
 }

 /**
  * @return int
  */
 public function getMaxKeySize()
 {
     return mcrypt_module_get_algo_key_size($this->getAlgorithm());
 }

 public function generateSessionKey()
 {
     $key = '';
     if (!empty($this->cryptParams['cipher']) && !empty($this->cryptParams['mode'])) {
         $keysize = mcrypt_module_get_algo_key_size($this->cryptParams['cipher']);
         /* Generating random key using iv generation routines */
         if ($keysize > 0 && ($td = mcrypt_module_open(MCRYPT_RIJNDAEL_256, '', $this->cryptParams['mode'], ''))) {
             if ($this->cryptParams['cipher'] == MCRYPT_RIJNDAEL_128) {
                 $keysize = 16;
                 if ($this->type == XMLSecurityKey::AES256_CBC) {
                     $keysize = 32;
                 } elseif ($this->type == XMLSecurityKey::AES192_CBC) {
                     $keysize = 24;
                 }
             }
             while (strlen($key) < $keysize) {
                 $key .= mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);
             }
             mcrypt_module_close($td);
             $key = substr($key, 0, $keysize);
             $this->key = $key;
         }
     }
     return $key;
 }

 /**
  * Generate the private key to use for encryption/decryption
  * 
  * @param array $params
  * @return array $params
  */
 private function GeneratePrivateKey($params)
 {
     // Max size for the key by chosen algorhythm
     $size = mcrypt_module_get_algo_key_size($params["cipher"]);
     // reduce key to max. size supported
     $params["private_key"] = substr($params["public_key"], 0, $size);
     return $params;
 }

<?php

var_dump(mcrypt_module_get_algo_key_size(MCRYPT_RIJNDAEL_256));
var_dump(mcrypt_module_get_algo_key_size(MCRYPT_RIJNDAEL_192));
var_dump(mcrypt_module_get_algo_key_size(MCRYPT_RC2));
var_dump(mcrypt_module_get_algo_key_size(MCRYPT_XTEA));
var_dump(mcrypt_module_get_algo_key_size(MCRYPT_CAST_128));
var_dump(mcrypt_module_get_algo_key_size(MCRYPT_BLOWFISH));

 /**
  * This method encrypts data and returns a CipherText object. You need it to decrypt the data back.
  *
  * @param string $cipher The cipher algorithm to use.
  * @param mixed $plainText The plaintext to encrypt.
  * @param binary $key An optional key. If not specified, PSL will generate it and return it within CipherText.
  * @param string $operationMode The cipher mode of operation to use. Defaults to CBC.
  * @param binary $iv An optional parameter. PSL will generate it if not given and return it within CipherText.
  * @throws Exception
  * @return \PSL\CipherText
  */
 public static function encrypt($cipher, $plainText, $key = null, $operationMode = 'cbc', $iv = null)
 {
     $operationMode = strtolower($operationMode);
     // If the key is null, we generate it on ourself.
     if ($key === null) {
         // Check whether the cipher is supported.
         $supportedCiphers = self::getSupportedCiphers();
         if (in_array($cipher, $supportedCiphers) === false) {
             throw new Exception("The cipher '{$cipher}' is not supported on this system. The following is a list of supported ciphers: " . implode(', ', $supportedCiphers));
         }
         // We will use the maximum strength.
         $length = mcrypt_module_get_algo_key_size($cipher);
         $key = Randomizer::getRandomBytes($length);
     }
     // Make sure we can actually encrypt with these details. Be strict.
     self::isCipherable($cipher, $key, $operationMode, true);
     // If the developer did not specify an IV, we generate a strong pseudo random one.
     if ($iv === null) {
         if (($ivSize = @mcrypt_get_iv_size($cipher, $operationMode)) === false) {
             throw new Exception("Could not retrieve an IV size for cipher '{$cipher}' using a operation mode '{$operationMode}'.");
         }
         $iv = Randomizer::getRandomBytes($ivSize);
     }
     // Padding for block cipher modes such as CBC and ECB.
     $padded = false;
     if (mcrypt_module_is_block_mode($operationMode) === true) {
         $padded = true;
         // Calculate how many bytes we need to add.
         $addBytes = $ivSize - strlen((string) $plainText) % $ivSize;
         if ($addBytes === 0) {
             // Important.
             $addBytes = $ivSize;
         }
         // Pad with chr($addBytes).
         $plainText .= str_repeat(chr($addBytes), $addBytes);
     }
     // The encryption.
     if (($cipherText = @mcrypt_encrypt($cipher, $key, $plainText, $operationMode, $iv)) === false) {
         throw new Exception("Could not encrypt with a cipher '{$cipher}' using a operation mode '{$operationMode}'.");
     }
     // Building the object with the right properties and returning it.
     $ct = new CipherText();
     $ct->cipherText = $cipherText;
     $ct->iv = $iv;
     $ct->operationMode = $operationMode;
     $ct->cipher = $cipher;
     $ct->key = $key;
     $ct->padded = $padded;
     // In case some one needs to know this.
     return $ct;
 }

 public static function decrypt($val, $key = 'siteenligne', $iv = 'hmco3773')
 {
     $key_size = mcrypt_module_get_algo_key_size(MCRYPT_BLOWFISH);
     $iv_size = mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_NOFB);
     $key = substr($key, 0, $key_size);
     $crypte = urldecode($val);
     $crypte = base64_decode($crypte);
     $crypte = mcrypt_decrypt(MCRYPT_BLOWFISH, $key, $crypte, MCRYPT_MODE_NOFB, $iv);
     return $crypte;
 }

<?php

// normal usage of mcrypt
mcrypt_module_get_algo_key_size($c);
// no mcrypt usage
$mcrypt_create_iv = 2;
$x = 'mcrypt_enc_is_block_algorithm_mode';

$iv = mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_DEV_RANDOM);
$ks = mcrypt_enc_get_key_size($td);
$key = substr(md5("very secret key"), 0, $ks);
mcrypt_generic_init($td, $key, $iv);
$encrypted = mcrypt_generic($td, "This is very important data");
VERIFY($encrypted !== "This is very important data");
mcrypt_generic_deinit($td);
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);

function plugin_accounts_crypte($Texte, $action)
{
    //$algo = "blowfish"; // ou la constante php MCRYPT_BLOWFISH
    //$mode = "nofb"; // ou la constante php MCRYPT_MODE_NOFB
    $key_size = mcrypt_module_get_algo_key_size(MCRYPT_RIJNDAEL_256);
    //$iv_size = mcrypt_get_iv_size($algo, $mode);
    //$iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
    $iv = mcrypt_create_iv(mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB), MCRYPT_RAND);
    $key = 'Ceci est une clé secrète';
    if ($action == 1) {
        $crypttext = mcrypt_encrypt(MCRYPT_RIJNDAEL_256, $key, $Texte, MCRYPT_MODE_ECB, $iv);
        $crypttext = base64_encode($crypttext);
    } else {
        if ($action == 2) {
            $crypttext = "<script language='javascript'>document.write(AESEncryptCtr({$Texte},SHA256({$key}),256));</script>";
        } else {
            if ($action == 3) {
                $Texte = base64_decode($Texte);
                $crypttext = mcrypt_decrypt(MCRYPT_RIJNDAEL_256, $key, $Texte, MCRYPT_MODE_ECB, $iv);
            }
        }
    }
    return trim($crypttext);
}

<?php

$algorithms = mcrypt_list_algorithms();
printf("%-18s %s %8s\n", "算法名", "最大支持密钥长度（字节）", "分组(block)/流式(stream)");
foreach ($algorithms as $cipher) {
    $max_key_size = mcrypt_module_get_algo_key_size($cipher);
    $stream_mode = mcrypt_module_is_block_algorithm($cipher) == TRUE ? "block" : "stream";
    printf("%-18s %3d %25s\n", $cipher, $max_key_size, $stream_mode);
}