PHP Base::setKey方法代码示例

    /**
     * Sets the key.
     *
     * Keys can be of any length. RC2, itself, uses 8 to 1024 bit keys (eg.
     * strlen($key) <= 128), however, we only use the first 128 bytes if $key
     * has more then 128 bytes in it, and set $key to a single null byte if
     * it is empty.
     *
     * If the key is not explicitly set, it'll be assumed to be a single
     * null byte.
     *
     * @see \phpseclib\Crypt\Base::setKey()
     * @access public
     * @param string $key
     * @param int $t1 optional Effective key length in bits.
     */
    function setKey($key, $t1 = 0)
    {
        $this->orig_key = $key;

        if ($t1 <= 0) {
            $t1 = $this->default_key_length;
        } elseif ($t1 > 1024) {
            $t1 = 1024;
        }
        $this->current_key_length = $t1;
        // Key byte count should be 1..128.
        $key = strlen($key) ? substr($key, 0, 128) : "\x00";
        $t = strlen($key);

        // The mcrypt RC2 implementation only supports effective key length
        // of 1024 bits. It is however possible to handle effective key
        // lengths in range 1..1024 by expanding the key and applying
        // inverse pitable mapping to the first byte before submitting it
        // to mcrypt.

        // Key expansion.
        $l = array_values(unpack('C*', $key));
        $t8 = ($t1 + 7) >> 3;
        $tm = 0xFF >> (8 * $t8 - $t1);

        // Expand key.
        $pitable = $this->pitable;
        for ($i = $t; $i < 128; $i++) {
            $l[$i] = $pitable[$l[$i - 1] + $l[$i - $t]];
        }
        $i = 128 - $t8;
        $l[$i] = $pitable[$l[$i] & $tm];
        while ($i--) {
            $l[$i] = $pitable[$l[$i + 1] ^ $l[$i + $t8]];
        }

        // Prepare the key for mcrypt.
        $l[0] = $this->invpitable[$l[0]];
        array_unshift($l, 'C*');

        parent::setKey(call_user_func_array('pack', $l));
    }

 /**
  * Sets the key.
  *
  * Keys can be between 1 and 256 bytes long.  If they are longer then 256 bytes, the first 256 bytes will
  * be used.  If no key is explicitly set, it'll be assumed to be a single null byte.
  *
  * @access public
  * @see    \phpseclib\Crypt\Base::setKey()
  *
  * @param String $key
  */
 function setKey($key)
 {
     parent::setKey(substr($key, 0, 256));
 }

 /**
  * Sets the key length
  *
  * Keys can be between 1 and 256 bytes long.
  *
  * @access public
  * @param int $length
  * @throws \LengthException if the key length is invalid
  */
 function setKey($key)
 {
     $length = strlen($key);
     if ($length < 1 || $length > 256) {
         throw new \LengthException('Key size of ' . $length . ' bytes is not supported by RC4. Keys must be between 1 and 256 bytes long');
     }
     parent::setKey($key);
 }

 /**
  * Sets the key.
  *
  * Keys must be 64-bits long or 8 bytes long.
  *
  * DES also requires that every eighth bit be a parity bit, however, we'll ignore that.
  *
  * @see \phpseclib\Crypt\Base::setKey()
  * @access public
  * @param string $key
  */
 function setKey($key)
 {
     if (!$this instanceof TripleDES && strlen($key) != 8) {
         throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of size 8 are supported');
     }
     // Sets the key
     parent::setKey($key);
 }

 /**
  * Sets the key.
  *
  * Keys can be of any length. Twofish, itself, requires the use of a key that's 128, 192 or 256-bits long.
  * If the key is less than 256-bits we round the length up to the closest valid key length,
  * padding $key with null bytes. If the key is more than 256-bits, we trim the excess bits.
  *
  * If the key is not explicitly set, it'll be assumed a 128 bits key to be all null bytes.
  *
  * @access public
  * @see    \phpseclib\Crypt\Base::setKey()
  *
  * @param String $key
  */
 function setKey($key)
 {
     $keylength = strlen($key);
     switch (true) {
         case $keylength <= 16:
             $key = str_pad($key, 16, "");
             break;
         case $keylength <= 24:
             $key = str_pad($key, 24, "");
             break;
         case $keylength < 32:
             $key = str_pad($key, 32, "");
             break;
         case $keylength > 32:
             $key = substr($key, 0, 32);
     }
     parent::setKey($key);
 }

 /**
 * Default Constructor.
 *
 * Determines whether or not the mcrypt extension should be used.
 *
 * $mode could be:
 *
 * - \phpseclib\Crypt\Base::MODE_ECB
 *
 * - \phpseclib\Crypt\Base::MODE_CBC
 *
 * - \phpseclib\Crypt\Base::MODE_CTR
 *
 * - \phpseclib\Crypt\Base::MODE_CFB
 *
 * - \phpseclib\Crypt\Base::MODE_OFB
 *
 * If not explictly set, \phpseclib\Crypt\Base::MODE_CBC will be used.
 *
 * @see \phpseclib\Crypt\Base::Crypt_Base()
 * @param optional Integer $mode
 * @access public
 
     /**
 * Sets the key.
 *
 * Keys can be of any length.  Rijndael, itself, requires the use of a key that's between 128-bits and 256-bits long and
 * whose length is a multiple of 32.  If the key is less than 256-bits and the key length isn't set, we round the length
 * up to the closest valid key length, padding $key with null bytes.  If the key is more than 256-bits, we trim the
 * excess bits.
 *
 * If the key is not explicitly set, it'll be assumed to be all null bytes.
 *
 * Note: 160/224-bit keys must explicitly set by setKeyLength(), otherwise they will be round/pad up to 192/256 bits.
 *
 * @see \phpseclib\Crypt\Base:setKey()
 * @see setKeyLength()
 * @access public
 * @param String $key
 */
 function setKey($key)
 {
     if (!$this->explicit_key_length) {
         $length = strlen($key);
         switch (true) {
             case $length <= 16:
                 $this->key_size = 16;
                 break;
             case $length <= 20:
                 $this->key_size = 20;
                 break;
             case $length <= 24:
                 $this->key_size = 24;
                 break;
             case $length <= 28:
                 $this->key_size = 28;
                 break;
             default:
                 $this->key_size = 32;
         }
     }
     parent::setKey($key);
 }

 /**
  * Sets the key.
  *
  * Rijndael supports five different key lengths
  *
  * @see setKeyLength()
  * @access public
  * @param string $key
  * @throws \LengthException if the key length isn't supported
  */
 function setKey($key)
 {
     switch (strlen($key)) {
         case 16:
         case 24:
         case 32:
             break;
         default:
             throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
     }
     parent::setKey($key);
 }

 /**
  * Sets the key.
  *
  * Keys can be of any length.  Blowfish, itself, requires the use of a key between 32 and max. 448-bits long.
  * If the key is less than 32-bits we NOT fill the key to 32bit but let the key as it is to be compatible
  * with mcrypt because mcrypt act this way with blowfish key's < 32 bits.
  *
  * If the key is more than 448-bits, we trim the excess bits.
  *
  * If the key is not explicitly set, or empty, it'll be assumed a 128 bits key to be all null bytes.
  *
  * @access public
  * @see    \phpseclib\Crypt\Base::setKey()
  *
  * @param String $key
  */
 function setKey($key)
 {
     $keylength = strlen($key);
     if (!$keylength) {
         $key = "";
     } elseif ($keylength > 56) {
         $key = substr($key, 0, 56);
     }
     parent::setKey($key);
 }

 /**
  * Sets the key.
  *
  * Keys can be of any length. RC2, itself, uses 8 to 1024 bit keys (eg.
  * strlen($key) <= 128), however, we only use the first 128 bytes if $key
  * has more then 128 bytes in it, and set $key to a single null byte if
  * it is empty.
  *
  * If the key is not explicitly set, it'll be assumed to be a single
  * null byte.
  *
  * @see \phpseclib\Crypt\Base::setKey()
  * @access public
  * @param string $key
  * @param int $t1 optional Effective key length in bits.
  * @throws \LengthException if the key length isn't supported
  */
 function setKey($key, $t1 = false)
 {
     $this->orig_key = $key;
     if ($t1 === false) {
         $t1 = $this->default_key_length;
     }
     if ($t1 < 1 || $t1 > 1024) {
         throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys between 1 and 1024 bits, inclusive, are supported');
     }
     $this->current_key_length = $t1;
     // Key byte count should be 1..128.
     $key = strlen($key) ? substr($key, 0, 128) : "";
     $t = strlen($key);
     // The mcrypt RC2 implementation only supports effective key length
     // of 1024 bits. It is however possible to handle effective key
     // lengths in range 1..1024 by expanding the key and applying
     // inverse pitable mapping to the first byte before submitting it
     // to mcrypt.
     // Key expansion.
     $l = array_values(unpack('C*', $key));
     $t8 = $t1 + 7 >> 3;
     $tm = 0xff >> 8 * $t8 - $t1;
     // Expand key.
     $pitable = $this->pitable;
     for ($i = $t; $i < 128; $i++) {
         $l[$i] = $pitable[$l[$i - 1] + $l[$i - $t]];
     }
     $i = 128 - $t8;
     $l[$i] = $pitable[$l[$i] & $tm];
     while ($i--) {
         $l[$i] = $pitable[$l[$i + 1] ^ $l[$i + $t8]];
     }
     // Prepare the key for mcrypt.
     $l[0] = $this->invpitable[$l[0]];
     array_unshift($l, 'C*');
     parent::setKey(call_user_func_array('pack', $l));
 }

 /**
  * Sets the key.
  *
  * Keys can be of any length.  Rijndael, itself, requires the use of a key that's between 128-bits and 256-bits long and
  * whose length is a multiple of 32.  If the key is less than 256-bits and the key length isn't set, we round the length
  * up to the closest valid key length, padding $key with null bytes.  If the key is more than 256-bits, we trim the
  * excess bits.
  *
  * If the key is not explicitly set, it'll be assumed to be all null bytes.
  *
  * Note: 160/224-bit keys must explicitly set by setKeyLength(), otherwise they will be round/pad up to 192/256 bits.
  *
  * @see Base:setKey()
  * @see setKeyLength()
  * @access public
  * @param String $key
  */
 function setKey($key)
 {
     parent::setKey($key);
     if (!$this->explicit_key_length) {
         $length = strlen($key);
         switch (true) {
             case $length <= 16:
                 $this->key_size = 16;
                 break;
             case $length <= 24:
                 $this->key_size = 24;
                 break;
             default:
                 $this->key_size = 32;
         }
         $this->_setupEngine();
     }
 }

 /**
  * Sets the key.
  *
  * Keys can be of any length.  DES, itself, uses 64-bit keys (eg. strlen($key) == 8), however, we
  * only use the first eight, if $key has more then eight characters in it, and pad $key with the
  * null byte if it is less then eight characters long.
  *
  * DES also requires that every eighth bit be a parity bit, however, we'll ignore that.
  *
  * If the key is not explicitly set, it'll be assumed to be all zero's.
  *
  * @see    \phpseclib\Crypt\Base::setKey()
  * @access public
  *
  * @param String $key
  */
 function setKey($key)
 {
     // We check/cut here only up to max length of the key.
     // Key padding to the proper length will be done in _setupKey()
     if (strlen($key) > $this->key_size_max) {
         $key = substr($key, 0, $this->key_size_max);
     }
     // Sets the key
     parent::setKey($key);
 }