<?php

/**

 * Phijndael - an implementation of the AES encryption standard in PHP

 * Originally written by Fritz Schneider <fritz AT cd DOT ucsd DOT edu>

 * Ported to PHP by Dan Fuhry <dan AT enano DOT homelinux DOT org>

 * @package phijndael

 * @author Fritz Schneider

 * @author Dan Fuhry

 * @license BSD-style license

 */

error_reporting(E_ALL);

define ('ENC_HEX', 201);

define ('ENC_BASE64', 202);

define ('ENC_BINARY', 203);

class AESCrypt {

  var $debug = false;

  var $mcrypt = false;

  // Rijndael parameters --  Valid values are 128, 192, or 256

  var $keySizeInBits = 128;

  var $blockSizeInBits = 128;

  ///////  You shouldn't have to modify anything below this line except for

  ///////  the function getRandomBytes().

  //

  // Note: in the following code the two dimensional arrays are indexed as

  //       you would probably expect, as array[row][column]. The state arrays

  //       are 2d arrays of the form state[4][Nb].

  // The number of rounds for the cipher, indexed by [Nk][Nb]

  var $roundsArray = Array(0,0,0,0,Array(0,0,0,0,10,0, 12,0, 14),0, 

                               Array(0,0,0,0,12,0, 12,0, 14),0, 

                               Array(0,0,0,0,14,0, 14,0, 14) );

  // The number of bytes to shift by in shiftRow, indexed by [Nb][row]

  var $shiftOffsets = Array(0,0,0,0,Array(0,1, 2, 3),0,Array(0,1, 2, 3),0,Array(0,1, 3, 4) );

  // The round constants used in subkey expansion

  var $Rcon = Array( 

  0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 

  0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 

  0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 

  0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 

  0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 );

  // Precomputed lookup table for the SBox

  var $SBox = Array(

   99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171, 

  118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164, 

  114, 192, 183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113, 

  216,  49,  21,   4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226, 

  235,  39, 178, 117,   9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 

  179,  41, 227,  47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 

  190,  57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,  69, 

  249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146, 157,  56, 245, 

  188, 182, 218,  33,  16, 255, 243, 210, 205,  12,  19, 236,  95, 151,  68,  

  23,  196, 167, 126,  61, 100,  93,  25, 115,  96, 129,  79, 220,  34,  42, 

  144, 136,  70, 238, 184,  20, 222,  94,  11, 219, 224,  50,  58,  10,  73,

    6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 

  141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,  

   46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138, 112,  62, 

  181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158, 225,

  248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223,

  140, 161, 137,  13, 191, 230,  66, 104,  65, 153,  45,  15, 176,  84, 187,  

   22 );

  // Precomputed lookup table for the inverse SBox

  var $SBoxInverse = Array(

   82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129, 243, 215, 

  251, 124, 227,  57, 130, 155,  47, 255, 135,  52, 142,  67,  68, 196, 222, 

  233, 203,  84, 123, 148,  50, 166, 194,  35,  61, 238,  76, 149,  11,  66, 

  250, 195,  78,   8,  46, 161, 102,  40, 217,  36, 178, 118,  91, 162,  73, 

  109, 139, 209,  37, 114, 248, 246, 100, 134, 104, 152,  22, 212, 164,  92, 

  204,  93, 101, 182, 146, 108, 112,  72,  80, 253, 237, 185, 218,  94,  21,  

   70,  87, 167, 141, 157, 132, 144, 216, 171,   0, 140, 188, 211,  10, 247, 

  228,  88,   5, 184, 179,  69,   6, 208,  44,  30, 143, 202,  63,  15,   2, 

  193, 175, 189,   3,   1,  19, 138, 107,  58, 145,  17,  65,  79, 103, 220, 

  234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116,  34, 231, 173,

   53, 133, 226, 249,  55, 232,  28, 117, 223, 110,  71, 241,  26, 113,  29, 

   41, 197, 137, 111, 183,  98,  14, 170,  24, 190,  27, 252,  86,  62,  75, 

  198, 210, 121,  32, 154, 219, 192, 254, 120, 205,  90, 244,  31, 221, 168,

   51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95,  96,  81,

  127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147, 201, 156, 239, 160,

  224,  59,  77, 174,  42, 245, 176, 200, 235, 187,  60, 131,  83, 153,  97, 

   23,  43,   4, 126, 186, 119, 214,  38, 225, 105,  20,  99,  85,  33,  12,

  125 );

  function AESCrypt($ks = 128, $bs = 128, $debug = false)

  {

    $this->__construct($ks, $bs, $debug);

  }

  function __construct($ks = 128, $bs = 128, $debug = false)

  {

    $this->keySizeInBits = $ks;

    $this->blockSizeInBits = $bs;

    // Use the Mcrypt library? This speeds things up dramatically.

    if(defined('MCRYPT_RIJNDAEL_' . $ks) && defined('MCRYPT_ACCEL'))

    {

      eval('$mcb = MCRYPT_RIJNDAEL_' . $ks.';');

      $bks = mcrypt_module_get_algo_block_size($mcb);

      $bks = $bks * 8;

      if ( $bks != $bs )

      {

        $mcb = false;

        echo (string)$bks;

      }

    }

    else

    {

      $mcb = false;

    }

    $this->mcrypt = $mcb;

    // Cipher parameters ... do not change these

    $this->Nk = $this->keySizeInBits / 32;

    $this->Nb = $this->blockSizeInBits / 32;

    $this->Nr = $this->roundsArray[$this->Nk][$this->Nb];

    $this->debug = $debug;

  }

  // Error handler

  function trigger_error($text, $level = E_USER_NOTICE)

  {

    $bt = debug_backtrace();

    $lastfunc =& $bt[1];

    switch($level)

    {

      case E_USER_NOTICE:

      default:

        $desc = 'Notice';

        break;

      case E_USER_WARNING:

        $desc = 'Warning';

        break;

      case E_USER_ERROR:

        $desc = 'Fatal';

        break;

    }

    ob_start();

    if($this->debug || $level == E_USER_ERROR) echo "AES encryption: <b>{$desc}:</b> $text in {$lastfunc['file']} on line {$lastfunc['line']} in function {$lastfunc['function']}<br />";

    if($this->debug)

    {

      //echo '<pre>'.enano_debug_print_backtrace(true).'</pre>';

    }

    ob_end_flush();

    if($level == E_USER_ERROR)

    {

      echo '<p><b>This can sometimes happen if you are upgrading Enano to a new version and did not log out first.</b> <a href="'.$_SERVER['PHP_SELF'].'?do=diag&amp;sub=cookie_destroy">Click here</a> to force cookies to clear and try again. You will be logged out.</p>';

      exit;

    }

  }

  function array_slice_js_compat($array, $start, $finish = 0)

  {

    $len = $finish - $start;

    if($len < 0) $len = 0 - $len;

    //if($this->debug) echo (string)$len . ' ';

    //if(count($array) < $start + $len)

    //  $this->trigger_error('Index out of range', E_USER_WARNING);

    return array_slice($array, $start, $len);

  }

  function concat($s1, $s2)

  {

    if(is_array($s1) && is_array($s2))

      return array_merge($s1, $s2);

    elseif( ( is_array($s1) && !is_array($s2) ) || ( !is_array($s1) && is_array($s2) ) )

    {

      $this->trigger_error('incompatible types - you can\'t combine a non-array with an array', E_USER_WARNING);

      return false;

    }

    else

      return $s1 . $s2;

  }

  // This method circularly shifts the array left by the number of elements

  // given in its parameter. It returns the resulting array and is used for 

  // the ShiftRow step. Note that shift() and push() could be used for a more 

  // elegant solution, but they require IE5.5+, so I chose to do it manually. 

  function cyclicShiftLeft($theArray, $positions) {

    if(!is_int($positions))

    {

      $this->trigger_error('$positions is not an integer! Backtrace:<br /><pre>'.print_r(debug_backtrace(), true).'</pre>', E_USER_WARNING);

      return false;

    }

    $second = array_slice($theArray, 0, $positions);

    $first = array_slice($theArray, $positions);

    $theArray = array_merge($first, $second);

    return $theArray;

  }

  // Multiplies the element "poly" of GF(2^8) by x. See the Rijndael spec.

  function xtime($poly) {

    $poly <<= 1;

    return (($poly & 0x100) ? ($poly ^ 0x11B) : ($poly));

  }

  // Multiplies the two elements of GF(2^8) together and returns the result.

  // See the Rijndael spec, but should be straightforward: for each power of

  // the indeterminant that has a 1 coefficient in x, add y times that power

  // to the result. x and y should be bytes representing elements of GF(2^8)

  function mult_GF256($x, $y) {

    $result = 0;

    for ($bit = 1; $bit < 256; $bit *= 2, $y = $this->xtime($y)) {

      if ($x & $bit) 

        $result ^= $y;

    }

    return $result;

  }

  // Performs the substitution step of the cipher. State is the 2d array of

  // state information (see spec) and direction is string indicating whether

  // we are performing the forward substitution ("encrypt") or inverse 

  // substitution (anything else)

  function byteSub(&$state, $direction) {

    //global $this->SBox, $this->SBoxInverse, $this->Nb;

    if ($direction == "encrypt")           // Point S to the SBox we're using

      $S =& $this->SBox;

    else

      $S =& $this->SBoxInverse;

    for ($i = 0; $i < 4; $i++)           // Substitute for every byte in state

      for ($j = 0; $j < $this->Nb; $j++)

         $state[$i][$j] = $S[$state[$i][$j]];

  }

  // Performs the row shifting step of the cipher.

  function shiftRow(&$state, $direction) {

    //global $this->Nb, $this->shiftOffsets;

    for ($i=1; $i<4; $i++)               // Row 0 never shifts

      if ($direction == "encrypt")

         $state[$i] = $this->cyclicShiftLeft($state[$i], $this->shiftOffsets[$this->Nb][$i]);

      else

         $state[$i] = $this->cyclicShiftLeft($state[$i], $this->Nb - $this->shiftOffsets[$this->Nb][$i]);

  }

  // Performs the column mixing step of the cipher. Most of these steps can

  // be combined into table lookups on 32bit values (at least for encryption)

  // to greatly increase the speed. 

  function mixColumn(&$state, $direction) {

    //global $this->Nb;

    $b = Array();                                  // Result of matrix multiplications

    for ($j = 0; $j < $this->Nb; $j++) {                 // Go through each column...

      for ($i = 0; $i < 4; $i++) {                 // and for each row in the column...

        if ($direction == "encrypt")

          $b[$i] = $this->mult_GF256($state[$i][$j], 2) ^ // perform mixing

                   $this->mult_GF256($state[($i+1)%4][$j], 3) ^ 

                   $state[($i+2)%4][$j] ^ 

                   $state[($i+3)%4][$j];

        else 

          $b[$i] = $this->mult_GF256($state[$i][$j], 0xE) ^ 

                   $this->mult_GF256($state[($i+1)%4][$j], 0xB) ^

                   $this->mult_GF256($state[($i+2)%4][$j], 0xD) ^

                   $this->mult_GF256($state[($i+3)%4][$j], 9);

      }

      for ($i = 0; $i < 4; $i++)          // Place result back into column

        $state[$i][$j] = $b[$i];

    }

  }

  // Adds the current round key to the state information. Straightforward.

  function addRoundKey(&$state, $roundKey) {

    //global $this->Nb;

    for ($j = 0; $j < $this->Nb; $j++) {                      // Step through columns...

      $state[0][$j] ^= ( $roundKey[$j] & 0xFF);         // and XOR

      $state[1][$j] ^= (($roundKey[$j]>>8) & 0xFF);

      $state[2][$j] ^= (($roundKey[$j]>>16) & 0xFF);

      $state[3][$j] ^= (($roundKey[$j]>>24) & 0xFF);

    }

  }

  // This function creates the expanded key from the input (128/192/256-bit)

  // key. The parameter key is an array of bytes holding the value of the key.

  // The returned value is an array whose elements are the 32-bit words that 

  // make up the expanded key.

  function keyExpansion($key) {

    //global $this->keySizeInBits, $this->blockSizeInBits, $this->roundsArray, $this->Nk, $this->Nb, $this->Nr, $this->Nk, $this->SBox, $this->Rcon;

    $expandedKey = Array();

    // in case the key size or parameters were changed...

    $this->Nk = $this->keySizeInBits / 32;                   

    $this->Nb = $this->blockSizeInBits / 32;

    $this->Nr = $this->roundsArray[$this->Nk][$this->Nb];

    for ($j=0; $j < $this->Nk; $j++)     // Fill in input key first

      $expandedKey[$j] = 

        ($key[4*$j]) | ($key[4*$j+1]<<8) | ($key[4*$j+2]<<16) | ($key[4*$j+3]<<24);

    // Now walk down the rest of the array filling in expanded key bytes as

    // per Rijndael's spec

    for ($j = $this->Nk; $j < $this->Nb * ($this->Nr + 1); $j++) {    // For each word of expanded key

      $temp = $expandedKey[$j - 1];

      if ($j % $this->Nk == 0) 

        $temp = ( ($this->SBox[($temp>>8) & 0xFF]) |

                  ($this->SBox[($temp>>16) & 0xFF]<<8) |

                  ($this->SBox[($temp>>24) & 0xFF]<<16) |

                  ($this->SBox[$temp & 0xFF]<<24) ) ^ $this->Rcon[floor($j / $this->Nk) - 1];

      elseif  ($this->Nk > 6 && $j % $this->Nk == 4)

        $temp = ($this->SBox[($temp>>24) & 0xFF]<<24) |

               ($this->SBox[($temp>>16) & 0xFF]<<16) |

               ($this->SBox[($temp>>8) & 0xFF]<<8) |

               ($this->SBox[ $temp & 0xFF]);

      $expandedKey[$j] = $expandedKey[$j-$this->Nk] ^ $temp;

    }

    return $expandedKey;

  }

  // Rijndael's round functions... 

  function RijndaelRound(&$state, $roundKey) {

    $this->byteSub($state, "encrypt");

    $this->shiftRow($state, "encrypt");

    $this->mixColumn($state, "encrypt");

    $this->addRoundKey($state, $roundKey);

  }

  function InverseRijndaelRound(&$state, $roundKey) {

    $this->addRoundKey($state, $roundKey);

    $this->mixColumn($state, "decrypt");

    $this->shiftRow($state, "decrypt");

    $this->byteSub($state, "decrypt");

  }

  function FinalRijndaelRound(&$state, $roundKey) {

    $this->byteSub($state, "encrypt");

    $this->shiftRow($state, "encrypt");

    $this->addRoundKey($state, $roundKey);

  }

  function InverseFinalRijndaelRound(&$state, $roundKey){

    $this->addRoundKey($state, $roundKey);

    $this->shiftRow($state, "decrypt");

    $this->byteSub($state, "decrypt");  

  }

  // encrypt is the basic encryption function. It takes parameters

  // block, an array of bytes representing a plaintext block, and expandedKey,

  // an array of words representing the expanded key previously returned by

  // keyExpansion(). The ciphertext block is returned as an array of bytes.

  function cryptBlock($block, $expandedKey) {

    //global $this->blockSizeInBits, $this->Nb, $this->Nr;

    $t=count($block)*8;

    if (!is_array($block) || count($block)*8 != $this->blockSizeInBits)

    {

      $this->trigger_error('block is bad or block size is wrong<pre>'.print_r($block, true).'</pre><p>Aiming for size '.$this->blockSizeInBits.', got '.$t.'.', E_USER_WARNING); 

      return false;

    }

    if (!$expandedKey)

      return;

    $block = $this->packBytes($block);

    $this->addRoundKey($block, $expandedKey);

    for ($i=1; $i<$this->Nr; $i++) 

      $this->RijndaelRound($block, $this->array_slice_js_compat($expandedKey, $this->Nb*$i, $this->Nb*($i+1)));

    $this->FinalRijndaelRound($block, $this->array_slice_js_compat($expandedKey, $this->Nb*$this->Nr));

    $ret = $this->unpackBytes($block);

    return $ret;

  }

  // decrypt is the basic decryption function. It takes parameters

  // block, an array of bytes representing a ciphertext block, and expandedKey,

  // an array of words representing the expanded key previously returned by

  // keyExpansion(). The decrypted block is returned as an array of bytes.

  function unCryptBlock($block, $expandedKey) {

    $t = count($block)*8;

    if (!is_array($block) || count($block)*8 != $this->blockSizeInBits)

    {

      $this->trigger_error('$block is not a valid rijndael-block array: '.$this->byteArrayToHex($block).'<pre>'.print_r($block, true).'</pre><p>Block size is '.$t.', should be '.$this->blockSizeInBits.'</p>', E_USER_WARNING);

      return false;

    }

    if (!$expandedKey)

    {

      $this->trigger_error('$expandedKey is invalid', E_USER_WARNING);

      return false;

    }

    $block = $this->packBytes($block);

    $this->InverseFinalRijndaelRound($block, $this->array_slice_js_compat($expandedKey, $this->Nb*$this->Nr)); 

    for ($i = $this->Nr - 1; $i>0; $i--) 

    {

      $this->InverseRijndaelRound($block, $this->array_slice_js_compat($expandedKey, $this->Nb*$i, $this->Nb*($i+1)));

    }

    $this->addRoundKey($block, $expandedKey);

    $ret = $this->unpackBytes($block);

    if(!is_array($ret))

    {

      $this->trigger_error('$ret is not an array', E_USER_WARNING);

    }

    return $ret;

  }

  // This method takes a byte array (byteArray) and converts it to a string by

  // applying String.fromCharCode() to each value and concatenating the result.

  // The resulting string is returned. Note that this function SKIPS zero bytes

  // under the assumption that they are padding added in formatPlaintext().

  // Obviously, do not invoke this method on raw data that can contain zero

  // bytes. It is really only appropriate for printable ASCII/Latin-1 

  // values. Roll your own function for more robust functionality :)

  function byteArrayToString($byteArray) {

    $result = "";

    for($i=0; $i<count($byteArray); $i++)

      if ($byteArray[$i] != 0) 

        $result .= chr($byteArray[$i]);

    return $result;

  }

  // This function takes an array of bytes (byteArray) and converts them

  // to a hexadecimal string. Array element 0 is found at the beginning of 

  // the resulting string, high nibble first. Consecutive elements follow

  // similarly, for example [16, 255] --> "10ff". The function returns a 

  // string.

  /*

  function byteArrayToHex($byteArray) {

    $result = "";

    if (!$byteArray)

      return;

    for ($i=0; $i<count($byteArray); $i++)

      $result .= (($byteArray[$i]<16) ? "0" : "") + toString($byteArray[$i]); // magic number here is 16, not sure how to handle this...

    return $result;

  }

  */

  function byteArrayToHex($arr)

  {

    $ret = '';

    foreach($arr as $a)

    {

      $nibble = (string)dechex(intval($a));

      if(strlen($nibble) == 1) $nibble = '0' . $nibble;

      $ret .= $nibble;

    }

    return $ret;

  }

  // PHP equivalent of Javascript's toString()

  function toString($bool)

  {

    if(is_bool($bool))

      return ($bool) ? 'true' : 'false';

    elseif(is_array($bool))

      return implode(',', $bool);

    else

      return (string)$bool;

  }

  // This function converts a string containing hexadecimal digits to an 

  // array of bytes. The resulting byte array is filled in the order the

  // values occur in the string, for example "10FF" --> [16, 255]. This

  // function returns an array. 

  /*

  function hexToByteArray($hexString) {

    $byteArray = Array();

    if (strlen($hexString) % 2)             // must have even length

      return;

    if (strstr($hexString, "0x") == $hexString || strstr($hexString, "0X") == $hexString)

      $hexString = substr($hexString, 2);

    for ($i = 0; $i<strlen($hexString); $i++,$i++) 

      $byteArray[floor($i/2)] = intval(substr($hexString, $i, 2)); // again, that strange magic number: 16

    return $byteArray;

  }

  */

  function hexToByteArray($str)

  {

    if(substr($str, 0, 2) == '0x' || substr($str, 0, 2) == '0X')

      $str = substr($str, 2);

    $arr = Array();

    $str = $this->enano_str_split($str, 2);

    foreach($str as $s)

    {

      $arr[] = intval(hexdec($s));

    }

    return $arr;

  }

  // This function packs an array of bytes into the four row form defined by

  // Rijndael. It assumes the length of the array of bytes is divisible by

  // four. Bytes are filled in according to the Rijndael spec (starting with

  // column 0, row 0 to 3). This function returns a 2d array.

  function packBytes($octets) {

    $state = Array();

    if (!$octets || count($octets) % 4)

      return;

    $state[0] = Array(); $state[1] = Array(); 

    $state[2] = Array(); $state[3] = Array();

    for ($j=0; $j<count($octets); $j = $j+4) {

       $state[0][$j/4] = $octets[$j];

       $state[1][$j/4] = $octets[$j+1];

       $state[2][$j/4] = $octets[$j+2];

       $state[3][$j/4] = $octets[$j+3];

    }

    return $state;

  }

  // This function unpacks an array of bytes from the four row format preferred

  // by Rijndael into a single 1d array of bytes. It assumes the input "packed"

  // is a packed array. Bytes are filled in according to the Rijndael spec. 

  // This function returns a 1d array of bytes.

  function unpackBytes($packed) {

    $result = Array();

    for ($j=0; $j<count($packed[0]); $j++) {

      $result[] = $packed[0][$j];