/lib/Cake/Utility/Security.php - pictcode - Redmine

pictcode / lib / Cake / Utility / Security.php @ master

       <?php
       /**
        * Core Security
+       *
        * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
        * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
+       *
        * Licensed under The MIT License
        * For full copyright and license information, please see the LICENSE.txt
        * Redistributions of files must retain the above copyright notice.
+       *
        * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
        * @link          http://cakephp.org CakePHP(tm) Project
        * @package       Cake.Utility
        * @since         CakePHP(tm) v .0.10.0.1233
        * @license       http://www.opensource.org/licenses/mit-license.php MIT License
        */
       App::uses('CakeText', 'Utility');
       /**
        * Security Library contains utility methods related to security
+       *
        * @package       Cake.Utility
        */
       class Security {
       /**
        * Default hash method
+       *
        * @var string
        */
               public static $hashType = null;
       /**
        * Default cost
+       *
        * @var string
        */
               public static $hashCost = '10';
       /**
        * Get allowed minutes of inactivity based on security level.
+       *
        * @deprecated 3.0.0 Exists for backwards compatibility only, not used by the core
        * @return int Allowed inactivity in minutes
        */
               public static function inactiveMins() {
                       switch (Configure::read('Security.level')) {
                               case 'high':
                                       return 10;
                               case 'medium':
                                       return 100;
                               case 'low':
                               default:
                                       return 300;
+                      }
+              }
       /**
        * Generate authorization hash.
+       *
        * @return string Hash
        */
               public static function generateAuthKey() {
                       return Security::hash(CakeText::uuid());
+              }
       /**
        * Validate authorization hash.
+       *
        * @param string $authKey Authorization hash
        * @return bool Success
        */
               public static function validateAuthKey($authKey) {
                       return true;
+              }
       /**
        * Create a hash from string using given method or fallback on next available method.
+       *
        * #### Using Blowfish
+       *
        * - Creating Hashes: *Do not supply a salt*. Cake handles salt creation for
        * you ensuring that each hashed password will have a *unique* salt.
        * - Comparing Hashes: Simply pass the originally hashed password as the salt.
        * The salt is prepended to the hash and php handles the parsing automagically.
        * For convenience the `BlowfishPasswordHasher` class is available for use with
        * the AuthComponent.
        * - Do NOT use a constant salt for blowfish!
+       *
        * Creating a blowfish/bcrypt hash:
+       *
        * ```
        *         $hash = Security::hash($password, 'blowfish');
        * ```
+       *
        * @param string $string String to hash
        * @param string $type Method to use (sha1/sha256/md5/blowfish)
        * @param mixed $salt If true, automatically prepends the application's salt
        *     value to $string (Security.salt). If you are using blowfish the salt
        *     must be false or a previously generated salt.
        * @return string Hash
        * @link http://book.cakephp.org/2.0/en/core-utility-libraries/security.html#Security::hash
        */
               public static function hash($string, $type = null, $salt = false) {
                       if (empty($type)) {
                               $type = static::$hashType;
+                      }
                       $type = strtolower($type);
                       if ($type === 'blowfish') {
                               return static::_crypt($string, $salt);
+                      }
                       if ($salt) {
                               if (!is_string($salt)) {
                                       $salt = Configure::read('Security.salt');
+                              }
                               $string = $salt . $string;
+                      }
                       if (!$type || $type === 'sha1') {
                               if (function_exists('sha1')) {
                                       return sha1($string);
+                              }
                               $type = 'sha256';
+                      }
                       if ($type === 'sha256' && function_exists('mhash')) {
                               return bin2hex(mhash(MHASH_SHA256, $string));
+                      }
                       if (function_exists('hash')) {
                               return hash($type, $string);
+                      }
                       return md5($string);
+              }
       /**
        * Sets the default hash method for the Security object. This affects all objects using
        * Security::hash().
+       *
        * @param string $hash Method to use (sha1/sha256/md5/blowfish)
        * @return void
        * @see Security::hash()
        */
               public static function setHash($hash) {
                       static::$hashType = $hash;
+              }
       /**
        * Sets the cost for they blowfish hash method.
+       *
        * @param int $cost Valid values are 4-31
        * @return void
        */
               public static function setCost($cost) {
                       if ($cost < 4 || $cost > 31) {
                               trigger_error(__d(
                                       'cake_dev',
                                       'Invalid value, cost must be between %s and %s',
                                       array(4, 31)
                               ), E_USER_WARNING);
                               return null;
+                      }
                       static::$hashCost = $cost;
+              }
       /**
        * Runs $text through a XOR cipher.
+       *
        * *Note* This is not a cryptographically strong method and should not be used
        * for sensitive data. Additionally this method does *not* work in environments
        * where suhosin is enabled.
+       *
        * Instead you should use Security::rijndael() when you need strong
        * encryption.
+       *
        * @param string $text Encrypted string to decrypt, normal string to encrypt
        * @param string $key Key to use
        * @return string Encrypted/Decrypted string
        * @deprecated 3.0.0 Will be removed in 3.0.
        */
               public static function cipher($text, $key) {
                       if (empty($key)) {
                               trigger_error(__d('cake_dev', 'You cannot use an empty key for %s', 'Security::cipher()'), E_USER_WARNING);
                               return '';
+                      }
                       srand(Configure::read('Security.cipherSeed'));
                       $out = '';
                       $keyLength = strlen($key);
                       for ($i = 0, $textLength = strlen($text); $i < $textLength; $i++) {
                               $j = ord(substr($key, $i % $keyLength, 1));
                               while ($j--) {
                                       rand(0, 255);
+                              }
                               $mask = rand(0, 255);
                               $out .= chr(ord(substr($text, $i, 1)) ^ $mask);
+                      }
                       srand();
                       return $out;
+              }
       /**
        * Encrypts/Decrypts a text using the given key using rijndael method.
+       *
        * Prior to 2.3.1, a fixed initialization vector was used. This was not
        * secure. This method now uses a random iv, and will silently upgrade values when
        * they are re-encrypted.
+       *
        * @param string $text Encrypted string to decrypt, normal string to encrypt
        * @param string $key Key to use as the encryption key for encrypted data.
        * @param string $operation Operation to perform, encrypt or decrypt
        * @return string Encrypted/Decrypted string
        */
               public static function rijndael($text, $key, $operation) {
                       if (empty($key)) {
                               trigger_error(__d('cake_dev', 'You cannot use an empty key for %s', 'Security::rijndael()'), E_USER_WARNING);
                               return '';
+                      }
                       if (empty($operation) || !in_array($operation, array('encrypt', 'decrypt'))) {
                               trigger_error(__d('cake_dev', 'You must specify the operation for Security::rijndael(), either encrypt or decrypt'), E_USER_WARNING);
                               return '';
+                      }
                       if (strlen($key) < 32) {
                               trigger_error(__d('cake_dev', 'You must use a key larger than 32 bytes for Security::rijndael()'), E_USER_WARNING);
                               return '';
+                      }
                       $algorithm = MCRYPT_RIJNDAEL_256;
                       $mode = MCRYPT_MODE_CBC;
                       $ivSize = mcrypt_get_iv_size($algorithm, $mode);
                       $cryptKey = substr($key, 0, 32);
                       if ($operation === 'encrypt') {
                               $iv = mcrypt_create_iv($ivSize, MCRYPT_RAND);
                               return $iv . '$$' . mcrypt_encrypt($algorithm, $cryptKey, $text, $mode, $iv);
+                      }
                       // Backwards compatible decrypt with fixed iv
                       if (substr($text, $ivSize, 2) !== '$$') {
                               $iv = substr($key, strlen($key) - 32, 32);
                               return rtrim(mcrypt_decrypt($algorithm, $cryptKey, $text, $mode, $iv), "\0");
+                      }
                       $iv = substr($text, 0, $ivSize);
                       $text = substr($text, $ivSize + 2);
                       return rtrim(mcrypt_decrypt($algorithm, $cryptKey, $text, $mode, $iv), "\0");
+              }
       /**
        * Generates a pseudo random salt suitable for use with php's crypt() function.
        * The salt length should not exceed 27. The salt will be composed of
        * [./0-9A-Za-z]{$length}.
+       *
        * @param int $length The length of the returned salt
        * @return string The generated salt
        */
               protected static function _salt($length = 22) {
                       $salt = str_replace(
                               array('+', '='),
                               '.',
                               base64_encode(sha1(uniqid(Configure::read('Security.salt'), true), true))
                       );
                       return substr($salt, 0, $length);
+              }
       /**
        * One way encryption using php's crypt() function. To use blowfish hashing see ``Security::hash()``
+       *
        * @param string $password The string to be encrypted.
        * @param mixed $salt false to generate a new salt or an existing salt.
        * @return string The hashed string or an empty string on error.
        */
               protected static function _crypt($password, $salt = false) {
                       if ($salt === false) {
                               $salt = static::_salt(22);
                               $salt = vsprintf('$2a$%02d$%s', array(static::$hashCost, $salt));
+                      }
                       $invalidCipher = (
                               strpos($salt, '$2y$') !== 0 &&
                               strpos($salt, '$2x$') !== 0 &&
                               strpos($salt, '$2a$') !== 0
                       );
                       if ($salt === true || $invalidCipher || strlen($salt) < 29) {
                               trigger_error(__d(
                                       'cake_dev',
                                       'Invalid salt: %s for %s Please visit http://www.php.net/crypt and read the appropriate section for building %s salts.',
                                       array($salt, 'blowfish', 'blowfish')
                               ), E_USER_WARNING);
                               return '';
+                      }
                       return crypt($password, $salt);
+              }
       /**
        * Encrypt a value using AES-256.
+       *
        * *Caveat* You cannot properly encrypt/decrypt data with trailing null bytes.
        * Any trailing null bytes will be removed on decryption due to how PHP pads messages
        * with nulls prior to encryption.
+       *
        * @param string $plain The value to encrypt.
        * @param string $key The 256 bit/32 byte key to use as a cipher key.
        * @param string $hmacSalt The salt to use for the HMAC process. Leave null to use Security.salt.
        * @return string Encrypted data.
        * @throws CakeException On invalid data or key.
        */
               public static function encrypt($plain, $key, $hmacSalt = null) {
                       static::_checkKey($key, 'encrypt()');
                       if ($hmacSalt === null) {
                               $hmacSalt = Configure::read('Security.salt');
+                      }
                       // Generate the encryption and hmac key.
                       $key = substr(hash('sha256', $key . $hmacSalt), 0, 32);
                       $algorithm = MCRYPT_RIJNDAEL_128;
                       $mode = MCRYPT_MODE_CBC;
                       $ivSize = mcrypt_get_iv_size($algorithm, $mode);
                       $iv = mcrypt_create_iv($ivSize, MCRYPT_DEV_URANDOM);
                       $ciphertext = $iv . mcrypt_encrypt($algorithm, $key, $plain, $mode, $iv);
                       $hmac = hash_hmac('sha256', $ciphertext, $key);
                       return $hmac . $ciphertext;
+              }
       /**
        * Check the encryption key for proper length.
+       *
        * @param string $key Key to check.
        * @param string $method The method the key is being checked for.
        * @return void
        * @throws CakeException When key length is not 256 bit/32 bytes
        */
               protected static function _checkKey($key, $method) {
                       if (strlen($key) < 32) {
                               throw new CakeException(__d('cake_dev', 'Invalid key for %s, key must be at least 256 bits (32 bytes) long.', $method));
+                      }
+              }
       /**
        * Decrypt a value using AES-256.
+       *
        * @param string $cipher The ciphertext to decrypt.
        * @param string $key The 256 bit/32 byte key to use as a cipher key.
        * @param string $hmacSalt The salt to use for the HMAC process. Leave null to use Security.salt.
        * @return string Decrypted data. Any trailing null bytes will be removed.
        * @throws CakeException On invalid data or key.
        */
               public static function decrypt($cipher, $key, $hmacSalt = null) {
                       static::_checkKey($key, 'decrypt()');
                       if (empty($cipher)) {
                               throw new CakeException(__d('cake_dev', 'The data to decrypt cannot be empty.'));
+                      }
                       if ($hmacSalt === null) {
                               $hmacSalt = Configure::read('Security.salt');
+                      }
                       // Generate the encryption and hmac key.
                       $key = substr(hash('sha256', $key . $hmacSalt), 0, 32);
                       // Split out hmac for comparison
                       $macSize = 64;
                       $hmac = substr($cipher, 0, $macSize);
                       $cipher = substr($cipher, $macSize);
                       $compareHmac = hash_hmac('sha256', $cipher, $key);
                       if ($hmac !== $compareHmac) {
                               return false;
+                      }
                       $algorithm = MCRYPT_RIJNDAEL_128;
                       $mode = MCRYPT_MODE_CBC;
                       $ivSize = mcrypt_get_iv_size($algorithm, $mode);
                       $iv = substr($cipher, 0, $ivSize);
                       $cipher = substr($cipher, $ivSize);
                       $plain = mcrypt_decrypt($algorithm, $key, $cipher, $mode, $iv);
                       return rtrim($plain, "\0");
+              }
+      }