類別 yii\base\Security

                public function compareString($expected, $actual)
{
    if (!is_string($expected)) {
        throw new InvalidArgumentException('Expected expected value to be a string, ' . gettype($expected) . ' given.');
    }
    if (!is_string($actual)) {
        throw new InvalidArgumentException('Expected actual value to be a string, ' . gettype($actual) . ' given.');
    }
    if (function_exists('hash_equals')) {
        return hash_equals($expected, $actual);
    }
    $expected .= "\0";
    $actual .= "\0";
    $expectedLength = StringHelper::byteLength($expected);
    $actualLength = StringHelper::byteLength($actual);
    $diff = $expectedLength - $actualLength;
    for ($i = 0; $i < $actualLength; $i++) {
        $diff |= (ord($actual[$i]) ^ ord($expected[$i % $expectedLength]));
    }
    return $diff === 0;
}

            

                protected function decrypt($data, $passwordBased, $secret, $info)
{
    if (!extension_loaded('openssl')) {
        throw new InvalidConfigException('Encryption requires the OpenSSL PHP extension');
    }
    if (!isset($this->allowedCiphers[$this->cipher][0], $this->allowedCiphers[$this->cipher][1])) {
        throw new InvalidConfigException($this->cipher . ' is not an allowed cipher');
    }
    list($blockSize, $keySize) = $this->allowedCiphers[$this->cipher];
    $keySalt = StringHelper::byteSubstr($data, 0, $keySize);
    if ($passwordBased) {
        $key = $this->pbkdf2($this->kdfHash, $secret, $keySalt, $this->derivationIterations, $keySize);
    } else {
        $key = $this->hkdf($this->kdfHash, $secret, $keySalt, $info, $keySize);
    }
    $authKey = $this->hkdf($this->kdfHash, $key, null, $this->authKeyInfo, $keySize);
    $data = $this->validateData(StringHelper::byteSubstr($data, $keySize, null), $authKey);
    if ($data === false) {
        return false;
    }
    $iv = StringHelper::byteSubstr($data, 0, $blockSize);
    $encrypted = StringHelper::byteSubstr($data, $blockSize, null);
    $decrypted = openssl_decrypt($encrypted, $this->cipher, $key, OPENSSL_RAW_DATA, $iv);
    if ($decrypted === false) {
        throw new \yii\base\Exception('OpenSSL failure on decryption: ' . openssl_error_string());
    }
    return $decrypted;
}

            

                public function decryptByKey($data, $inputKey, $info = null)
{
    return $this->decrypt($data, false, $inputKey, $info);
}

            

                public function decryptByPassword($data, $password)
{
    return $this->decrypt($data, true, $password, null);
}

            

                protected function encrypt($data, $passwordBased, $secret, $info)
{
    if (!extension_loaded('openssl')) {
        throw new InvalidConfigException('Encryption requires the OpenSSL PHP extension');
    }
    if (!isset($this->allowedCiphers[$this->cipher][0], $this->allowedCiphers[$this->cipher][1])) {
        throw new InvalidConfigException($this->cipher . ' is not an allowed cipher');
    }
    list($blockSize, $keySize) = $this->allowedCiphers[$this->cipher];
    $keySalt = $this->generateRandomKey($keySize);
    if ($passwordBased) {
        $key = $this->pbkdf2($this->kdfHash, $secret, $keySalt, $this->derivationIterations, $keySize);
    } else {
        $key = $this->hkdf($this->kdfHash, $secret, $keySalt, $info, $keySize);
    }
    $iv = $this->generateRandomKey($blockSize);
    $encrypted = openssl_encrypt($data, $this->cipher, $key, OPENSSL_RAW_DATA, $iv);
    if ($encrypted === false) {
        throw new \yii\base\Exception('OpenSSL failure on encryption: ' . openssl_error_string());
    }
    $authKey = $this->hkdf($this->kdfHash, $key, null, $this->authKeyInfo, $keySize);
    $hashed = $this->hashData($iv . $encrypted, $authKey);
    /*
     * Output: [keySalt][MAC][IV][ciphertext]
     * - keySalt is KEY_SIZE bytes long
     * - MAC: message authentication code, length same as the output of MAC_HASH
     * - IV: initialization vector, length $blockSize
     */
    return $keySalt . $hashed;
}

            

                public function encryptByKey($data, $inputKey, $info = null)
{
    return $this->encrypt($data, false, $inputKey, $info);
}

            

                public function encryptByPassword($data, $password)
{
    return $this->encrypt($data, true, $password, null);
}

            

                public function generatePasswordHash($password, $cost = null)
{
    if ($cost === null) {
        $cost = $this->passwordHashCost;
    }
    if (function_exists('password_hash')) {
        /* @noinspection PhpUndefinedConstantInspection */
        return password_hash($password, PASSWORD_DEFAULT, ['cost' => $cost]);
    }
    $salt = $this->generateSalt($cost);
    $hash = crypt($password, $salt);
    // strlen() is safe since crypt() returns only ascii
    if (!is_string($hash) || strlen($hash) !== 60) {
        throw new Exception('Unknown error occurred while generating hash.');
    }
    return $hash;
}

            

                public function generateRandomKey($length = 32)
{
    if (!is_int($length)) {
        throw new InvalidArgumentException('First parameter ($length) must be an integer');
    }
    if ($length < 1) {
        throw new InvalidArgumentException('First parameter ($length) must be greater than 0');
    }
    return random_bytes($length);
}

            

                public function generateRandomString($length = 32)
{
    if (!is_int($length)) {
        throw new InvalidArgumentException('First parameter ($length) must be an integer');
    }
    if ($length < 1) {
        throw new InvalidArgumentException('First parameter ($length) must be greater than 0');
    }
    $bytes = $this->generateRandomKey($length);
    return substr(StringHelper::base64UrlEncode($bytes), 0, $length);
}

            

                protected function generateSalt($cost = 13)
{
    $cost = (int) $cost;
    if ($cost < 4 || $cost > 31) {
        throw new InvalidArgumentException('Cost must be between 4 and 31.');
    }
    // Get a 20-byte random string
    $rand = $this->generateRandomKey(20);
    // Form the prefix that specifies Blowfish (bcrypt) algorithm and cost parameter.
    $salt = sprintf('$2y$%02d$', $cost);
    // Append the random salt data in the required base64 format.
    $salt .= str_replace('+', '.', substr(base64_encode($rand), 0, 22));
    return $salt;
}

            

                public function hashData($data, $key, $rawHash = false)
{
    $hash = hash_hmac($this->macHash, $data, $key, $rawHash);
    if (!$hash) {
        throw new InvalidConfigException('Failed to generate HMAC with hash algorithm: ' . $this->macHash);
    }
    return $hash . $data;
}

            

                public function hkdf($algo, $inputKey, $salt = null, $info = null, $length = 0)
{
    if (function_exists('hash_hkdf')) {
        $outputKey = hash_hkdf((string)$algo, (string)$inputKey, $length, (string)$info, (string)$salt);
        if ($outputKey === false) {
            throw new InvalidArgumentException('Invalid parameters to hash_hkdf()');
        }
        return $outputKey;
    }
    $test = @hash_hmac($algo, '', '', true);
    if (!$test) {
        throw new InvalidArgumentException('Failed to generate HMAC with hash algorithm: ' . $algo);
    }
    $hashLength = StringHelper::byteLength($test);
    if (is_string($length) && preg_match('{^\d{1,16}$}', $length)) {
        $length = (int) $length;
    }
    if (!is_int($length) || $length < 0 || $length > 255 * $hashLength) {
        throw new InvalidArgumentException('Invalid length');
    }
    $blocks = $length !== 0 ? ceil($length / $hashLength) : 1;
    if ($salt === null) {
        $salt = str_repeat("\0", $hashLength);
    }
    $prKey = hash_hmac($algo, $inputKey, $salt, true);
    $hmac = '';
    $outputKey = '';
    for ($i = 1; $i <= $blocks; $i++) {
        $hmac = hash_hmac($algo, $hmac . $info . chr($i), $prKey, true);
        $outputKey .= $hmac;
    }
    if ($length !== 0) {
        $outputKey = StringHelper::byteSubstr($outputKey, 0, $length);
    }
    return $outputKey;
}

            

                public function maskToken($token)
{
    // The number of bytes in a mask is always equal to the number of bytes in a token.
    $mask = $this->generateRandomKey(StringHelper::byteLength($token));
    return StringHelper::base64UrlEncode($mask . ($mask ^ $token));
}

            

                public function pbkdf2($algo, $password, $salt, $iterations, $length = 0)
{
    if (function_exists('hash_pbkdf2') && PHP_VERSION_ID >= 50500) {
        $outputKey = hash_pbkdf2($algo, $password, $salt, $iterations, $length, true);
        if ($outputKey === false) {
            throw new InvalidArgumentException('Invalid parameters to hash_pbkdf2()');
        }
        return $outputKey;
    }
    // todo: is there a nice way to reduce the code repetition in hkdf() and pbkdf2()?
    $test = @hash_hmac($algo, '', '', true);
    if (!$test) {
        throw new InvalidArgumentException('Failed to generate HMAC with hash algorithm: ' . $algo);
    }
    if (is_string($iterations) && preg_match('{^\d{1,16}$}', $iterations)) {
        $iterations = (int) $iterations;
    }
    if (!is_int($iterations) || $iterations < 1) {
        throw new InvalidArgumentException('Invalid iterations');
    }
    if (is_string($length) && preg_match('{^\d{1,16}$}', $length)) {
        $length = (int) $length;
    }
    if (!is_int($length) || $length < 0) {
        throw new InvalidArgumentException('Invalid length');
    }
    $hashLength = StringHelper::byteLength($test);
    $blocks = $length !== 0 ? ceil($length / $hashLength) : 1;
    $outputKey = '';
    for ($j = 1; $j <= $blocks; $j++) {
        $hmac = hash_hmac($algo, $salt . pack('N', $j), $password, true);
        $xorsum = $hmac;
        for ($i = 1; $i < $iterations; $i++) {
            $hmac = hash_hmac($algo, $hmac, $password, true);
            $xorsum ^= $hmac;
        }
        $outputKey .= $xorsum;
    }
    if ($length !== 0) {
        $outputKey = StringHelper::byteSubstr($outputKey, 0, $length);
    }
    return $outputKey;
}

            

                protected function shouldUseLibreSSL()
{
    if ($this->_useLibreSSL === null) {
        // Parse OPENSSL_VERSION_TEXT because OPENSSL_VERSION_NUMBER is no use for LibreSSL.
        // https://bugs.php.net/bug.php?id=71143
        $this->_useLibreSSL = defined('OPENSSL_VERSION_TEXT')
            && preg_match('{^LibreSSL (\d\d?)\.(\d\d?)\.(\d\d?)$}', OPENSSL_VERSION_TEXT, $matches)
            && (10000 * $matches[1]) + (100 * $matches[2]) + $matches[3] >= 20105;
    }
    return $this->_useLibreSSL;
}

            

                public function unmaskToken($maskedToken)
{
    $decoded = StringHelper::base64UrlDecode($maskedToken);
    $length = StringHelper::byteLength($decoded) / 2;
    // Check if the masked token has an even length.
    if (!is_int($length)) {
        return '';
    }
    return StringHelper::byteSubstr($decoded, $length, $length) ^ StringHelper::byteSubstr($decoded, 0, $length);
}

            

                public function validateData($data, $key, $rawHash = false)
{
    $test = @hash_hmac($this->macHash, '', '', $rawHash);
    if (!$test) {
        throw new InvalidConfigException('Failed to generate HMAC with hash algorithm: ' . $this->macHash);
    }
    $hashLength = StringHelper::byteLength($test);
    if (StringHelper::byteLength($data) >= $hashLength) {
        $hash = StringHelper::byteSubstr($data, 0, $hashLength);
        $pureData = StringHelper::byteSubstr($data, $hashLength, null);
        $calculatedHash = hash_hmac($this->macHash, $pureData, $key, $rawHash);
        if ($this->compareString($hash, $calculatedHash)) {
            return $pureData;
        }
    }
    return false;
}

            

                public function validatePassword($password, $hash)
{
    if (!is_string($password) || $password === '') {
        throw new InvalidArgumentException('Password must be a string and cannot be empty.');
    }
    if (
        !preg_match('/^\$2[axy]\$(\d\d)\$[\.\/0-9A-Za-z]{22}/', $hash, $matches)
        || $matches[1] < 4
        || $matches[1] > 30
    ) {
        throw new InvalidArgumentException('Hash is invalid.');
    }
    if (function_exists('password_verify')) {
        return password_verify($password, $hash);
    }
    $test = crypt($password, $hash);
    $n = strlen($test);
    if ($n !== 60) {
        return false;
    }
    return $this->compareString($test, $hash);
}