Source for file aes.php

Documentation is available at aes.php

  1. <?php
  2. /**
  3.  * @package    FrameworkOnFramework
  4.  * @subpackage encrypt
  5.  * @copyright  Copyright (C) 2010 - 2012 Akeeba Ltd. All rights reserved.
  6.  * @license    GNU General Public License version 2 or later; see LICENSE.txt
  7.  */
  8. // Protect from unauthorized access
  9. defined('_JEXEC') or die;
  10.  
  11. /**
  12.  * A simple implementation of AES-128, AES-192 and AES-256 encryption using the
  13.  * high performance mcrypt library.
  14.  *
  15.  * @package  FrameworkOnFramework
  16.  * @since    1.0
  17.  */
  18. class FOFEncryptAES
  19. {
  20.     /** @var string The AES cipher to use (this is an mcrypt identifier, not the bit strength) */
  21.     private $_cipherType = 0;
  22.  
  23.     /** @var string Cipher mode. Can be CBC or ECB. We recommend using CBC */
  24.     private $_cipherMode = 0;
  25.  
  26.     /** @var string The cipher key (password) */
  27.     private $_keyString = '';
  28.  
  29.     /**
  30.      * Initialise the AES encryption object
  31.      *
  32.      * @param   string  $key       The encryption key (password). It can be a raw key (32 bytes) or a passphrase.
  33.      * @param   int     $strength  Bit strength (128, 192 or 256)
  34.      * @param   string  $mode      Ecnryption mode. Can be ebc or cbc. We recommend using cbc.
  35.      */
  36.     public function __construct($key, $strength = 256, $mode = 'cbc')
  37.     {
  38.         $this->_keyString = $key;
  39.  
  40.         switch ($strength)
  41.         {
  42.             case 256:
  43.             default:
  44.                 $this->_cipherType = MCRYPT_RIJNDAEL_256;
  45.                 break;
  46.  
  47.             case 192:
  48.                 $this->_cipherType = MCRYPT_RIJNDAEL_192;
  49.                 break;
  50.  
  51.             case 128:
  52.                 $this->_cipherType = MCRYPT_RIJNDAEL_128;
  53.                 break;
  54.         }
  55.  
  56.         switch (strtoupper($mode))
  57.         {
  58.             case 'ECB':
  59.                 $this->_cipherMode = MCRYPT_MODE_ECB;
  60.                 break;
  61.  
  62.             case 'CBC':
  63.                 $this->_cipherMode = MCRYPT_MODE_CBC;
  64.                 break;
  65.         }
  66.     }
  67.  
  68.     /**
  69.      * Encrypts a string using AES
  70.      *
  71.      * @param   string  $stringToEncrypt  The plaintext to encrypt
  72.      * @param   bool    $base64encoded    Should I Base64-encode the result?
  73.      *
  74.      * @return   string  The cryptotext. Please note that the first 16 bytes of
  75.      *                    the raw string is the IV (initialisation vector) which
  76.      *                    is necessary for decoding the string.
  77.      */
  78.     public function encryptString($stringToEncrypt, $base64encoded = true)
  79.     {
  80.         if (strlen($this->_keyString) != 32)
  81.         {
  82.             $key = hash('sha256', $this->_keyString, true);
  83.         }
  84.         else
  85.         {
  86.             $key = $this->_keyString;
  87.         }
  88.  
  89.         // Set up the IV (Initialization Vector)
  90.         $iv_size = mcrypt_get_iv_size($this->_cipherType, $this->_cipherMode);
  91.         $iv = mcrypt_create_iv($iv_size, MCRYPT_DEV_URANDOM);
  92.  
  93.         if (empty($iv))
  94.         {
  95.             $iv = mcrypt_create_iv($iv_size, MCRYPT_DEV_RANDOM);
  96.         }
  97.  
  98.         if (empty($iv))
  99.         {
  100.             $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND);
  101.         }
  102.  
  103.         // Encrypt the data
  104.         $cipherText = mcrypt_encrypt($this->_cipherType, $key, $stringToEncrypt, $this->_cipherMode, $iv);
  105.  
  106.         // Prepend the IV to the ciphertext
  107.         $cipherText = $iv . $cipherText;
  108.  
  109.         // Optionally pass the result through Base64 encoding
  110.         if ($base64encoded)
  111.         {
  112.             $cipherText = base64_encode($cipherText);
  113.         }
  114.  
  115.         // Return the result
  116.         return $cipherText;
  117.     }
  118.  
  119.     /**
  120.      * Decrypts a ciphertext into a plaintext string using AES
  121.      *
  122.      * @param   string  $stringToDecrypt  The ciphertext to decrypt. The first 16 bytes of the raw string must contain the IV (initialisation vector).
  123.      * @param   bool    $base64encoded    Should I Base64-decode the data before decryption?
  124.      *
  125.      * @return   string  The plain text string
  126.      */
  127.     public function decryptString($stringToDecrypt, $base64encoded = true)
  128.     {
  129.         if (strlen($this->_keyString) != 32)
  130.         {
  131.             $key = hash('sha256', $this->_keyString, true);
  132.         }
  133.         else
  134.         {
  135.             $key = $this->_keyString;
  136.         }
  137.  
  138.         if ($base64encoded)
  139.         {
  140.             $stringToDecrypt = base64_decode($stringToDecrypt);
  141.         }
  142.  
  143.         // Calculate the IV size
  144.         $iv_size = mcrypt_get_iv_size($this->_cipherType, $this->_cipherMode);
  145.  
  146.         // Extract IV
  147.         $iv = substr($stringToDecrypt, 0, $iv_size);
  148.         $stringToDecrypt = substr($stringToDecrypt, $iv_size);
  149.  
  150.         // Decrypt the data
  151.         $plainText = mcrypt_decrypt($this->_cipherType, $key, $stringToDecrypt, $this->_cipherMode, $iv);
  152.  
  153.         return $plainText;
  154.     }
  155.  
  156.     /**
  157.      * Is AES encryption supported by this PHP installation?
  158.      *
  159.      * @return boolean 
  160.      */
  161.     public static function isSupported()
  162.     {
  163.         if (!function_exists('mcrypt_get_key_size'))
  164.         {
  165.             return false;
  166.         }
  167.  
  168.         if (!function_exists('mcrypt_get_iv_size'))
  169.         {
  170.             return false;
  171.         }
  172.  
  173.         if (!function_exists('mcrypt_create_iv'))
  174.         {
  175.             return false;
  176.         }
  177.  
  178.         if (!function_exists('mcrypt_encrypt'))
  179.         {
  180.             return false;
  181.         }
  182.  
  183.         if (!function_exists('mcrypt_decrypt'))
  184.         {
  185.             return false;
  186.         }
  187.  
  188.         if (!function_exists('mcrypt_list_algorithms'))
  189.         {
  190.             return false;
  191.         }
  192.  
  193.         if (!function_exists('hash'))
  194.         {
  195.             return false;
  196.         }
  197.  
  198.         if (!function_exists('hash_algos'))
  199.         {
  200.             return false;
  201.         }
  202.  
  203.         if (!function_exists('base64_encode'))
  204.         {
  205.             return false;
  206.         }
  207.  
  208.         if (!function_exists('base64_decode'))
  209.         {
  210.             return false;
  211.         }
  212.  
  213.         $algorightms = mcrypt_list_algorithms();
  214.  
  215.         if (!in_array('rijndael-128', $algorightms))
  216.         {
  217.             return false;
  218.         }
  219.  
  220.         if (!in_array('rijndael-192', $algorightms))
  221.         {
  222.             return false;
  223.         }
  224.  
  225.         if (!in_array('rijndael-256', $algorightms))
  226.         {
  227.             return false;
  228.         }
  229.  
  230.         $algorightms = hash_algos();
  231.  
  232.         if (!in_array('sha256', $algorightms))
  233.         {
  234.             return false;
  235.         }
  236.  
  237.         return true;
  238.     }
  239. }

Documentation generated on Tue, 19 Nov 2013 14:53:38 +0100 by phpDocumentor 1.4.3