[ Index ]

PHP Cross Reference of DokuWiki

title

Body

[close]

/inc/phpseclib/ -> Crypt_Rijndael.php (source)

   1  <?php
   2  /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   3  
   4  /**
   5   * Pure-PHP implementation of Rijndael.
   6   *
   7   * Uses mcrypt, if available/possible, and an internal implementation, otherwise.
   8   *
   9   * PHP versions 4 and 5
  10   *
  11   * If {@link Crypt_Rijndael::setBlockLength() setBlockLength()} isn't called, it'll be assumed to be 128 bits.  If
  12   * {@link Crypt_Rijndael::setKeyLength() setKeyLength()} isn't called, it'll be calculated from
  13   * {@link Crypt_Rijndael::setKey() setKey()}.  ie. if the key is 128-bits, the key length will be 128-bits.  If it's
  14   * 136-bits it'll be null-padded to 192-bits and 192 bits will be the key length until
  15   * {@link Crypt_Rijndael::setKey() setKey()} is called, again, at which point, it'll be recalculated.
  16   *
  17   * Not all Rijndael implementations may support 160-bits or 224-bits as the block length / key length.  mcrypt, for example,
  18   * does not.  AES, itself, only supports block lengths of 128 and key lengths of 128, 192, and 256.
  19   * {@link http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf#page=10 Rijndael-ammended.pdf#page=10} defines the
  20   * algorithm for block lengths of 192 and 256 but not for block lengths / key lengths of 160 and 224.  Indeed, 160 and 224
  21   * are first defined as valid key / block lengths in
  22   * {@link http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf#page=44 Rijndael-ammended.pdf#page=44}:
  23   * Extensions: Other block and Cipher Key lengths.
  24   * Note: Use of 160/224-bit Keys must be explicitly set by setKeyLength(160) respectively setKeyLength(224).
  25   *
  26   * {@internal The variable names are the same as those in
  27   * {@link http://www.csrc.nist.gov/publications/fips/fips197/fips-197.pdf#page=10 fips-197.pdf#page=10}.}}
  28   *
  29   * Here's a short example of how to use this library:
  30   * <code>
  31   * <?php
  32   *    include('Crypt/Rijndael.php');
  33   *
  34   *    $rijndael = new Crypt_Rijndael();
  35   *
  36   *    $rijndael->setKey('abcdefghijklmnop');
  37   *
  38   *    $size = 10 * 1024;
  39   *    $plaintext = '';
  40   *    for ($i = 0; $i < $size; $i++) {
  41   *        $plaintext.= 'a';
  42   *    }
  43   *
  44   *    echo $rijndael->decrypt($rijndael->encrypt($plaintext));
  45   * ?>
  46   * </code>
  47   *
  48   * LICENSE: Permission is hereby granted, free of charge, to any person obtaining a copy
  49   * of this software and associated documentation files (the "Software"), to deal
  50   * in the Software without restriction, including without limitation the rights
  51   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  52   * copies of the Software, and to permit persons to whom the Software is
  53   * furnished to do so, subject to the following conditions:
  54   *
  55   * The above copyright notice and this permission notice shall be included in
  56   * all copies or substantial portions of the Software.
  57   *
  58   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  59   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  60   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  61   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  62   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  63   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  64   * THE SOFTWARE.
  65   *
  66   * @category   Crypt
  67   * @package    Crypt_Rijndael
  68   * @author     Jim Wigginton <terrafrost@php.net>
  69   * @copyright  MMVIII Jim Wigginton
  70   * @license    http://www.opensource.org/licenses/mit-license.html  MIT License
  71   * @link       http://phpseclib.sourceforge.net
  72   */
  73  
  74  /**
  75   * Include Crypt_Base
  76   *
  77   * Base cipher class
  78   */
  79  if (!class_exists('Crypt_Base')) {
  80      require_once('Base.php');
  81  }
  82  
  83  /**#@+
  84   * @access public
  85   * @see Crypt_Rijndael::encrypt()
  86   * @see Crypt_Rijndael::decrypt()
  87   */
  88  /**
  89   * Encrypt / decrypt using the Counter mode.
  90   *
  91   * Set to -1 since that's what Crypt/Random.php uses to index the CTR mode.
  92   *
  93   * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Counter_.28CTR.29
  94   */
  95  define('CRYPT_RIJNDAEL_MODE_CTR', CRYPT_MODE_CTR);
  96  /**
  97   * Encrypt / decrypt using the Electronic Code Book mode.
  98   *
  99   * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Electronic_codebook_.28ECB.29
 100   */
 101  define('CRYPT_RIJNDAEL_MODE_ECB', CRYPT_MODE_ECB);
 102  /**
 103   * Encrypt / decrypt using the Code Book Chaining mode.
 104   *
 105   * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher-block_chaining_.28CBC.29
 106   */
 107  define('CRYPT_RIJNDAEL_MODE_CBC', CRYPT_MODE_CBC);
 108  /**
 109   * Encrypt / decrypt using the Cipher Feedback mode.
 110   *
 111   * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Cipher_feedback_.28CFB.29
 112   */
 113  define('CRYPT_RIJNDAEL_MODE_CFB', CRYPT_MODE_CFB);
 114  /**
 115   * Encrypt / decrypt using the Cipher Feedback mode.
 116   *
 117   * @link http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation#Output_feedback_.28OFB.29
 118   */
 119  define('CRYPT_RIJNDAEL_MODE_OFB', CRYPT_MODE_OFB);
 120  /**#@-*/
 121  
 122  /**#@+
 123   * @access private
 124   * @see Crypt_Rijndael::Crypt_Rijndael()
 125   */
 126  /**
 127   * Toggles the internal implementation
 128   */
 129  define('CRYPT_RIJNDAEL_MODE_INTERNAL', CRYPT_MODE_INTERNAL);
 130  /**
 131   * Toggles the mcrypt implementation
 132   */
 133  define('CRYPT_RIJNDAEL_MODE_MCRYPT', CRYPT_MODE_MCRYPT);
 134  /**#@-*/
 135  
 136  /**
 137   * Pure-PHP implementation of Rijndael.
 138   *
 139   * @author  Jim Wigginton <terrafrost@php.net>
 140   * @version 0.1.0
 141   * @access  public
 142   * @package Crypt_Rijndael
 143   */
 144  class Crypt_Rijndael extends Crypt_Base {
 145      /**
 146       * The default password key_size used by setPassword()
 147       *
 148       * @see Crypt_Base::password_key_size
 149       * @see Crypt_Base::setPassword()
 150       * @var Integer
 151       * @access private
 152       */
 153      var $password_key_size = 16;
 154  
 155      /**
 156       * The namespace used by the cipher for its constants.
 157       *
 158       * @see Crypt_Base::const_namespace
 159       * @var String
 160       * @access private
 161       */
 162      var $const_namespace = 'RIJNDAEL';
 163  
 164      /**
 165       * The mcrypt specific name of the cipher
 166       *
 167       * Mcrypt is useable for 128/192/256-bit $block_size/$key_size. For 160/224 not.
 168       * Crypt_Rijndael determines automatically whether mcrypt is useable
 169       * or not for the current $block_size/$key_size.
 170       * In case of, $cipher_name_mcrypt will be set dynamicaly at run time accordingly.
 171       *
 172       * @see Crypt_Base::cipher_name_mcrypt
 173       * @see Crypt_Base::engine
 174       * @see _setupEngine()
 175       * @var String
 176       * @access private
 177       */
 178      var $cipher_name_mcrypt = 'rijndael-128';
 179  
 180      /**
 181       * The default salt used by setPassword()
 182       *
 183       * @see Crypt_Base::password_default_salt
 184       * @see Crypt_Base::setPassword()
 185       * @var String
 186       * @access private
 187       */
 188      var $password_default_salt = 'phpseclib';
 189  
 190      /**
 191       * Has the key length explicitly been set or should it be derived from the key, itself?
 192       *
 193       * @see setKeyLength()
 194       * @var Boolean
 195       * @access private
 196       */
 197      var $explicit_key_length = false;
 198  
 199      /**
 200       * The Key Schedule
 201       *
 202       * @see _setup()
 203       * @var Array
 204       * @access private
 205       */
 206      var $w;
 207  
 208      /**
 209       * The Inverse Key Schedule
 210       *
 211       * @see _setup()
 212       * @var Array
 213       * @access private
 214       */
 215      var $dw;
 216  
 217      /**
 218       * The Block Length divided by 32
 219       *
 220       * @see setBlockLength()
 221       * @var Integer
 222       * @access private
 223       * @internal The max value is 256 / 32 = 8, the min value is 128 / 32 = 4.  Exists in conjunction with $block_size
 224       *    because the encryption / decryption / key schedule creation requires this number and not $block_size.  We could
 225       *    derive this from $block_size or vice versa, but that'd mean we'd have to do multiple shift operations, so in lieu
 226       *    of that, we'll just precompute it once.
 227       *
 228       */
 229      var $Nb = 4;
 230  
 231      /**
 232       * The Key Length
 233       *
 234       * @see setKeyLength()
 235       * @var Integer
 236       * @access private
 237       * @internal The max value is 256 / 8 = 32, the min value is 128 / 8 = 16.  Exists in conjunction with $Nk
 238       *    because the encryption / decryption / key schedule creation requires this number and not $key_size.  We could
 239       *    derive this from $key_size or vice versa, but that'd mean we'd have to do multiple shift operations, so in lieu
 240       *    of that, we'll just precompute it once.
 241       */
 242      var $key_size = 16;
 243  
 244      /**
 245       * The Key Length divided by 32
 246       *
 247       * @see setKeyLength()
 248       * @var Integer
 249       * @access private
 250       * @internal The max value is 256 / 32 = 8, the min value is 128 / 32 = 4
 251       */
 252      var $Nk = 4;
 253  
 254      /**
 255       * The Number of Rounds
 256       *
 257       * @var Integer
 258       * @access private
 259       * @internal The max value is 14, the min value is 10.
 260       */
 261      var $Nr;
 262  
 263      /**
 264       * Shift offsets
 265       *
 266       * @var Array
 267       * @access private
 268       */
 269      var $c;
 270  
 271      /**
 272       * Holds the last used key- and block_size information
 273       *
 274       * @var Array
 275       * @access private
 276       */
 277      var $kl;
 278  
 279      /**
 280       * Precomputed mixColumns table
 281       *
 282       * According to <http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf#page=19> (section 5.2.1),
 283       * precomputed tables can be used in the mixColumns phase.  in that example, they're assigned t0...t3, so
 284       * those are the names we'll use.
 285       *
 286       * @see Crypt_Rijndael:_encryptBlock()
 287       * @see Crypt_Rijndael:_decryptBlock()
 288       * @var Array
 289       * @access private
 290       */
 291      var $t0 = array(
 292          0xC66363A5, 0xF87C7C84, 0xEE777799, 0xF67B7B8D, 0xFFF2F20D, 0xD66B6BBD, 0xDE6F6FB1, 0x91C5C554,
 293          0x60303050, 0x02010103, 0xCE6767A9, 0x562B2B7D, 0xE7FEFE19, 0xB5D7D762, 0x4DABABE6, 0xEC76769A,
 294          0x8FCACA45, 0x1F82829D, 0x89C9C940, 0xFA7D7D87, 0xEFFAFA15, 0xB25959EB, 0x8E4747C9, 0xFBF0F00B,
 295          0x41ADADEC, 0xB3D4D467, 0x5FA2A2FD, 0x45AFAFEA, 0x239C9CBF, 0x53A4A4F7, 0xE4727296, 0x9BC0C05B,
 296          0x75B7B7C2, 0xE1FDFD1C, 0x3D9393AE, 0x4C26266A, 0x6C36365A, 0x7E3F3F41, 0xF5F7F702, 0x83CCCC4F,
 297          0x6834345C, 0x51A5A5F4, 0xD1E5E534, 0xF9F1F108, 0xE2717193, 0xABD8D873, 0x62313153, 0x2A15153F,
 298          0x0804040C, 0x95C7C752, 0x46232365, 0x9DC3C35E, 0x30181828, 0x379696A1, 0x0A05050F, 0x2F9A9AB5,
 299          0x0E070709, 0x24121236, 0x1B80809B, 0xDFE2E23D, 0xCDEBEB26, 0x4E272769, 0x7FB2B2CD, 0xEA75759F,
 300          0x1209091B, 0x1D83839E, 0x582C2C74, 0x341A1A2E, 0x361B1B2D, 0xDC6E6EB2, 0xB45A5AEE, 0x5BA0A0FB,
 301          0xA45252F6, 0x763B3B4D, 0xB7D6D661, 0x7DB3B3CE, 0x5229297B, 0xDDE3E33E, 0x5E2F2F71, 0x13848497,
 302          0xA65353F5, 0xB9D1D168, 0x00000000, 0xC1EDED2C, 0x40202060, 0xE3FCFC1F, 0x79B1B1C8, 0xB65B5BED,
 303          0xD46A6ABE, 0x8DCBCB46, 0x67BEBED9, 0x7239394B, 0x944A4ADE, 0x984C4CD4, 0xB05858E8, 0x85CFCF4A,
 304          0xBBD0D06B, 0xC5EFEF2A, 0x4FAAAAE5, 0xEDFBFB16, 0x864343C5, 0x9A4D4DD7, 0x66333355, 0x11858594,
 305          0x8A4545CF, 0xE9F9F910, 0x04020206, 0xFE7F7F81, 0xA05050F0, 0x783C3C44, 0x259F9FBA, 0x4BA8A8E3,
 306          0xA25151F3, 0x5DA3A3FE, 0x804040C0, 0x058F8F8A, 0x3F9292AD, 0x219D9DBC, 0x70383848, 0xF1F5F504,
 307          0x63BCBCDF, 0x77B6B6C1, 0xAFDADA75, 0x42212163, 0x20101030, 0xE5FFFF1A, 0xFDF3F30E, 0xBFD2D26D,
 308          0x81CDCD4C, 0x180C0C14, 0x26131335, 0xC3ECEC2F, 0xBE5F5FE1, 0x359797A2, 0x884444CC, 0x2E171739,
 309          0x93C4C457, 0x55A7A7F2, 0xFC7E7E82, 0x7A3D3D47, 0xC86464AC, 0xBA5D5DE7, 0x3219192B, 0xE6737395,
 310          0xC06060A0, 0x19818198, 0x9E4F4FD1, 0xA3DCDC7F, 0x44222266, 0x542A2A7E, 0x3B9090AB, 0x0B888883,
 311          0x8C4646CA, 0xC7EEEE29, 0x6BB8B8D3, 0x2814143C, 0xA7DEDE79, 0xBC5E5EE2, 0x160B0B1D, 0xADDBDB76,
 312          0xDBE0E03B, 0x64323256, 0x743A3A4E, 0x140A0A1E, 0x924949DB, 0x0C06060A, 0x4824246C, 0xB85C5CE4,
 313          0x9FC2C25D, 0xBDD3D36E, 0x43ACACEF, 0xC46262A6, 0x399191A8, 0x319595A4, 0xD3E4E437, 0xF279798B,
 314          0xD5E7E732, 0x8BC8C843, 0x6E373759, 0xDA6D6DB7, 0x018D8D8C, 0xB1D5D564, 0x9C4E4ED2, 0x49A9A9E0,
 315          0xD86C6CB4, 0xAC5656FA, 0xF3F4F407, 0xCFEAEA25, 0xCA6565AF, 0xF47A7A8E, 0x47AEAEE9, 0x10080818,
 316          0x6FBABAD5, 0xF0787888, 0x4A25256F, 0x5C2E2E72, 0x381C1C24, 0x57A6A6F1, 0x73B4B4C7, 0x97C6C651,
 317          0xCBE8E823, 0xA1DDDD7C, 0xE874749C, 0x3E1F1F21, 0x964B4BDD, 0x61BDBDDC, 0x0D8B8B86, 0x0F8A8A85,
 318          0xE0707090, 0x7C3E3E42, 0x71B5B5C4, 0xCC6666AA, 0x904848D8, 0x06030305, 0xF7F6F601, 0x1C0E0E12,
 319          0xC26161A3, 0x6A35355F, 0xAE5757F9, 0x69B9B9D0, 0x17868691, 0x99C1C158, 0x3A1D1D27, 0x279E9EB9,
 320          0xD9E1E138, 0xEBF8F813, 0x2B9898B3, 0x22111133, 0xD26969BB, 0xA9D9D970, 0x078E8E89, 0x339494A7,
 321          0x2D9B9BB6, 0x3C1E1E22, 0x15878792, 0xC9E9E920, 0x87CECE49, 0xAA5555FF, 0x50282878, 0xA5DFDF7A,
 322          0x038C8C8F, 0x59A1A1F8, 0x09898980, 0x1A0D0D17, 0x65BFBFDA, 0xD7E6E631, 0x844242C6, 0xD06868B8,
 323          0x824141C3, 0x299999B0, 0x5A2D2D77, 0x1E0F0F11, 0x7BB0B0CB, 0xA85454FC, 0x6DBBBBD6, 0x2C16163A
 324      );
 325  
 326      /**
 327       * Precomputed mixColumns table
 328       *
 329       * @see Crypt_Rijndael:_encryptBlock()
 330       * @see Crypt_Rijndael:_decryptBlock()
 331       * @var Array
 332       * @access private
 333       */
 334      var $t1 = array(
 335          0xA5C66363, 0x84F87C7C, 0x99EE7777, 0x8DF67B7B, 0x0DFFF2F2, 0xBDD66B6B, 0xB1DE6F6F, 0x5491C5C5,
 336          0x50603030, 0x03020101, 0xA9CE6767, 0x7D562B2B, 0x19E7FEFE, 0x62B5D7D7, 0xE64DABAB, 0x9AEC7676,
 337          0x458FCACA, 0x9D1F8282, 0x4089C9C9, 0x87FA7D7D, 0x15EFFAFA, 0xEBB25959, 0xC98E4747, 0x0BFBF0F0,
 338          0xEC41ADAD, 0x67B3D4D4, 0xFD5FA2A2, 0xEA45AFAF, 0xBF239C9C, 0xF753A4A4, 0x96E47272, 0x5B9BC0C0,
 339          0xC275B7B7, 0x1CE1FDFD, 0xAE3D9393, 0x6A4C2626, 0x5A6C3636, 0x417E3F3F, 0x02F5F7F7, 0x4F83CCCC,
 340          0x5C683434, 0xF451A5A5, 0x34D1E5E5, 0x08F9F1F1, 0x93E27171, 0x73ABD8D8, 0x53623131, 0x3F2A1515,
 341          0x0C080404, 0x5295C7C7, 0x65462323, 0x5E9DC3C3, 0x28301818, 0xA1379696, 0x0F0A0505, 0xB52F9A9A,
 342          0x090E0707, 0x36241212, 0x9B1B8080, 0x3DDFE2E2, 0x26CDEBEB, 0x694E2727, 0xCD7FB2B2, 0x9FEA7575,
 343          0x1B120909, 0x9E1D8383, 0x74582C2C, 0x2E341A1A, 0x2D361B1B, 0xB2DC6E6E, 0xEEB45A5A, 0xFB5BA0A0,
 344          0xF6A45252, 0x4D763B3B, 0x61B7D6D6, 0xCE7DB3B3, 0x7B522929, 0x3EDDE3E3, 0x715E2F2F, 0x97138484,
 345          0xF5A65353, 0x68B9D1D1, 0x00000000, 0x2CC1EDED, 0x60402020, 0x1FE3FCFC, 0xC879B1B1, 0xEDB65B5B,
 346          0xBED46A6A, 0x468DCBCB, 0xD967BEBE, 0x4B723939, 0xDE944A4A, 0xD4984C4C, 0xE8B05858, 0x4A85CFCF,
 347          0x6BBBD0D0, 0x2AC5EFEF, 0xE54FAAAA, 0x16EDFBFB, 0xC5864343, 0xD79A4D4D, 0x55663333, 0x94118585,
 348          0xCF8A4545, 0x10E9F9F9, 0x06040202, 0x81FE7F7F, 0xF0A05050, 0x44783C3C, 0xBA259F9F, 0xE34BA8A8,
 349          0xF3A25151, 0xFE5DA3A3, 0xC0804040, 0x8A058F8F, 0xAD3F9292, 0xBC219D9D, 0x48703838, 0x04F1F5F5,
 350          0xDF63BCBC, 0xC177B6B6, 0x75AFDADA, 0x63422121, 0x30201010, 0x1AE5FFFF, 0x0EFDF3F3, 0x6DBFD2D2,
 351          0x4C81CDCD, 0x14180C0C, 0x35261313, 0x2FC3ECEC, 0xE1BE5F5F, 0xA2359797, 0xCC884444, 0x392E1717,
 352          0x5793C4C4, 0xF255A7A7, 0x82FC7E7E, 0x477A3D3D, 0xACC86464, 0xE7BA5D5D, 0x2B321919, 0x95E67373,
 353          0xA0C06060, 0x98198181, 0xD19E4F4F, 0x7FA3DCDC, 0x66442222, 0x7E542A2A, 0xAB3B9090, 0x830B8888,
 354          0xCA8C4646, 0x29C7EEEE, 0xD36BB8B8, 0x3C281414, 0x79A7DEDE, 0xE2BC5E5E, 0x1D160B0B, 0x76ADDBDB,
 355          0x3BDBE0E0, 0x56643232, 0x4E743A3A, 0x1E140A0A, 0xDB924949, 0x0A0C0606, 0x6C482424, 0xE4B85C5C,
 356          0x5D9FC2C2, 0x6EBDD3D3, 0xEF43ACAC, 0xA6C46262, 0xA8399191, 0xA4319595, 0x37D3E4E4, 0x8BF27979,
 357          0x32D5E7E7, 0x438BC8C8, 0x596E3737, 0xB7DA6D6D, 0x8C018D8D, 0x64B1D5D5, 0xD29C4E4E, 0xE049A9A9,
 358          0xB4D86C6C, 0xFAAC5656, 0x07F3F4F4, 0x25CFEAEA, 0xAFCA6565, 0x8EF47A7A, 0xE947AEAE, 0x18100808,
 359          0xD56FBABA, 0x88F07878, 0x6F4A2525, 0x725C2E2E, 0x24381C1C, 0xF157A6A6, 0xC773B4B4, 0x5197C6C6,
 360          0x23CBE8E8, 0x7CA1DDDD, 0x9CE87474, 0x213E1F1F, 0xDD964B4B, 0xDC61BDBD, 0x860D8B8B, 0x850F8A8A,
 361          0x90E07070, 0x427C3E3E, 0xC471B5B5, 0xAACC6666, 0xD8904848, 0x05060303, 0x01F7F6F6, 0x121C0E0E,
 362          0xA3C26161, 0x5F6A3535, 0xF9AE5757, 0xD069B9B9, 0x91178686, 0x5899C1C1, 0x273A1D1D, 0xB9279E9E,
 363          0x38D9E1E1, 0x13EBF8F8, 0xB32B9898, 0x33221111, 0xBBD26969, 0x70A9D9D9, 0x89078E8E, 0xA7339494,
 364          0xB62D9B9B, 0x223C1E1E, 0x92158787, 0x20C9E9E9, 0x4987CECE, 0xFFAA5555, 0x78502828, 0x7AA5DFDF,
 365          0x8F038C8C, 0xF859A1A1, 0x80098989, 0x171A0D0D, 0xDA65BFBF, 0x31D7E6E6, 0xC6844242, 0xB8D06868,
 366          0xC3824141, 0xB0299999, 0x775A2D2D, 0x111E0F0F, 0xCB7BB0B0, 0xFCA85454, 0xD66DBBBB, 0x3A2C1616
 367      );
 368  
 369      /**
 370       * Precomputed mixColumns table
 371       *
 372       * @see Crypt_Rijndael:_encryptBlock()
 373       * @see Crypt_Rijndael:_decryptBlock()
 374       * @var Array
 375       * @access private
 376       */
 377      var $t2 = array(
 378          0x63A5C663, 0x7C84F87C, 0x7799EE77, 0x7B8DF67B, 0xF20DFFF2, 0x6BBDD66B, 0x6FB1DE6F, 0xC55491C5,
 379          0x30506030, 0x01030201, 0x67A9CE67, 0x2B7D562B, 0xFE19E7FE, 0xD762B5D7, 0xABE64DAB, 0x769AEC76,
 380          0xCA458FCA, 0x829D1F82, 0xC94089C9, 0x7D87FA7D, 0xFA15EFFA, 0x59EBB259, 0x47C98E47, 0xF00BFBF0,
 381          0xADEC41AD, 0xD467B3D4, 0xA2FD5FA2, 0xAFEA45AF, 0x9CBF239C, 0xA4F753A4, 0x7296E472, 0xC05B9BC0,
 382          0xB7C275B7, 0xFD1CE1FD, 0x93AE3D93, 0x266A4C26, 0x365A6C36, 0x3F417E3F, 0xF702F5F7, 0xCC4F83CC,
 383          0x345C6834, 0xA5F451A5, 0xE534D1E5, 0xF108F9F1, 0x7193E271, 0xD873ABD8, 0x31536231, 0x153F2A15,
 384          0x040C0804, 0xC75295C7, 0x23654623, 0xC35E9DC3, 0x18283018, 0x96A13796, 0x050F0A05, 0x9AB52F9A,
 385          0x07090E07, 0x12362412, 0x809B1B80, 0xE23DDFE2, 0xEB26CDEB, 0x27694E27, 0xB2CD7FB2, 0x759FEA75,
 386          0x091B1209, 0x839E1D83, 0x2C74582C, 0x1A2E341A, 0x1B2D361B, 0x6EB2DC6E, 0x5AEEB45A, 0xA0FB5BA0,
 387          0x52F6A452, 0x3B4D763B, 0xD661B7D6, 0xB3CE7DB3, 0x297B5229, 0xE33EDDE3, 0x2F715E2F, 0x84971384,
 388          0x53F5A653, 0xD168B9D1, 0x00000000, 0xED2CC1ED, 0x20604020, 0xFC1FE3FC, 0xB1C879B1, 0x5BEDB65B,
 389          0x6ABED46A, 0xCB468DCB, 0xBED967BE, 0x394B7239, 0x4ADE944A, 0x4CD4984C, 0x58E8B058, 0xCF4A85CF,
 390          0xD06BBBD0, 0xEF2AC5EF, 0xAAE54FAA, 0xFB16EDFB, 0x43C58643, 0x4DD79A4D, 0x33556633, 0x85941185,
 391          0x45CF8A45, 0xF910E9F9, 0x02060402, 0x7F81FE7F, 0x50F0A050, 0x3C44783C, 0x9FBA259F, 0xA8E34BA8,
 392          0x51F3A251, 0xA3FE5DA3, 0x40C08040, 0x8F8A058F, 0x92AD3F92, 0x9DBC219D, 0x38487038, 0xF504F1F5,
 393          0xBCDF63BC, 0xB6C177B6, 0xDA75AFDA, 0x21634221, 0x10302010, 0xFF1AE5FF, 0xF30EFDF3, 0xD26DBFD2,
 394          0xCD4C81CD, 0x0C14180C, 0x13352613, 0xEC2FC3EC, 0x5FE1BE5F, 0x97A23597, 0x44CC8844, 0x17392E17,
 395          0xC45793C4, 0xA7F255A7, 0x7E82FC7E, 0x3D477A3D, 0x64ACC864, 0x5DE7BA5D, 0x192B3219, 0x7395E673,
 396          0x60A0C060, 0x81981981, 0x4FD19E4F, 0xDC7FA3DC, 0x22664422, 0x2A7E542A, 0x90AB3B90, 0x88830B88,
 397          0x46CA8C46, 0xEE29C7EE, 0xB8D36BB8, 0x143C2814, 0xDE79A7DE, 0x5EE2BC5E, 0x0B1D160B, 0xDB76ADDB,
 398          0xE03BDBE0, 0x32566432, 0x3A4E743A, 0x0A1E140A, 0x49DB9249, 0x060A0C06, 0x246C4824, 0x5CE4B85C,
 399          0xC25D9FC2, 0xD36EBDD3, 0xACEF43AC, 0x62A6C462, 0x91A83991, 0x95A43195, 0xE437D3E4, 0x798BF279,
 400          0xE732D5E7, 0xC8438BC8, 0x37596E37, 0x6DB7DA6D, 0x8D8C018D, 0xD564B1D5, 0x4ED29C4E, 0xA9E049A9,
 401          0x6CB4D86C, 0x56FAAC56, 0xF407F3F4, 0xEA25CFEA, 0x65AFCA65, 0x7A8EF47A, 0xAEE947AE, 0x08181008,
 402          0xBAD56FBA, 0x7888F078, 0x256F4A25, 0x2E725C2E, 0x1C24381C, 0xA6F157A6, 0xB4C773B4, 0xC65197C6,
 403          0xE823CBE8, 0xDD7CA1DD, 0x749CE874, 0x1F213E1F, 0x4BDD964B, 0xBDDC61BD, 0x8B860D8B, 0x8A850F8A,
 404          0x7090E070, 0x3E427C3E, 0xB5C471B5, 0x66AACC66, 0x48D89048, 0x03050603, 0xF601F7F6, 0x0E121C0E,
 405          0x61A3C261, 0x355F6A35, 0x57F9AE57, 0xB9D069B9, 0x86911786, 0xC15899C1, 0x1D273A1D, 0x9EB9279E,
 406          0xE138D9E1, 0xF813EBF8, 0x98B32B98, 0x11332211, 0x69BBD269, 0xD970A9D9, 0x8E89078E, 0x94A73394,
 407          0x9BB62D9B, 0x1E223C1E, 0x87921587, 0xE920C9E9, 0xCE4987CE, 0x55FFAA55, 0x28785028, 0xDF7AA5DF,
 408          0x8C8F038C, 0xA1F859A1, 0x89800989, 0x0D171A0D, 0xBFDA65BF, 0xE631D7E6, 0x42C68442, 0x68B8D068,
 409          0x41C38241, 0x99B02999, 0x2D775A2D, 0x0F111E0F, 0xB0CB7BB0, 0x54FCA854, 0xBBD66DBB, 0x163A2C16
 410      );
 411  
 412      /**
 413       * Precomputed mixColumns table
 414       *
 415       * @see Crypt_Rijndael:_encryptBlock()
 416       * @see Crypt_Rijndael:_decryptBlock()
 417       * @var Array
 418       * @access private
 419       */
 420      var $t3 = array(
 421          0x6363A5C6, 0x7C7C84F8, 0x777799EE, 0x7B7B8DF6, 0xF2F20DFF, 0x6B6BBDD6, 0x6F6FB1DE, 0xC5C55491,
 422          0x30305060, 0x01010302, 0x6767A9CE, 0x2B2B7D56, 0xFEFE19E7, 0xD7D762B5, 0xABABE64D, 0x76769AEC,
 423          0xCACA458F, 0x82829D1F, 0xC9C94089, 0x7D7D87FA, 0xFAFA15EF, 0x5959EBB2, 0x4747C98E, 0xF0F00BFB,
 424          0xADADEC41, 0xD4D467B3, 0xA2A2FD5F, 0xAFAFEA45, 0x9C9CBF23, 0xA4A4F753, 0x727296E4, 0xC0C05B9B,
 425          0xB7B7C275, 0xFDFD1CE1, 0x9393AE3D, 0x26266A4C, 0x36365A6C, 0x3F3F417E, 0xF7F702F5, 0xCCCC4F83,
 426          0x34345C68, 0xA5A5F451, 0xE5E534D1, 0xF1F108F9, 0x717193E2, 0xD8D873AB, 0x31315362, 0x15153F2A,
 427          0x04040C08, 0xC7C75295, 0x23236546, 0xC3C35E9D, 0x18182830, 0x9696A137, 0x05050F0A, 0x9A9AB52F,
 428          0x0707090E, 0x12123624, 0x80809B1B, 0xE2E23DDF, 0xEBEB26CD, 0x2727694E, 0xB2B2CD7F, 0x75759FEA,
 429          0x09091B12, 0x83839E1D, 0x2C2C7458, 0x1A1A2E34, 0x1B1B2D36, 0x6E6EB2DC, 0x5A5AEEB4, 0xA0A0FB5B,
 430          0x5252F6A4, 0x3B3B4D76, 0xD6D661B7, 0xB3B3CE7D, 0x29297B52, 0xE3E33EDD, 0x2F2F715E, 0x84849713,
 431          0x5353F5A6, 0xD1D168B9, 0x00000000, 0xEDED2CC1, 0x20206040, 0xFCFC1FE3, 0xB1B1C879, 0x5B5BEDB6,
 432          0x6A6ABED4, 0xCBCB468D, 0xBEBED967, 0x39394B72, 0x4A4ADE94, 0x4C4CD498, 0x5858E8B0, 0xCFCF4A85,
 433          0xD0D06BBB, 0xEFEF2AC5, 0xAAAAE54F, 0xFBFB16ED, 0x4343C586, 0x4D4DD79A, 0x33335566, 0x85859411,
 434          0x4545CF8A, 0xF9F910E9, 0x02020604, 0x7F7F81FE, 0x5050F0A0, 0x3C3C4478, 0x9F9FBA25, 0xA8A8E34B,
 435          0x5151F3A2, 0xA3A3FE5D, 0x4040C080, 0x8F8F8A05, 0x9292AD3F, 0x9D9DBC21, 0x38384870, 0xF5F504F1,
 436          0xBCBCDF63, 0xB6B6C177, 0xDADA75AF, 0x21216342, 0x10103020, 0xFFFF1AE5, 0xF3F30EFD, 0xD2D26DBF,
 437          0xCDCD4C81, 0x0C0C1418, 0x13133526, 0xECEC2FC3, 0x5F5FE1BE, 0x9797A235, 0x4444CC88, 0x1717392E,
 438          0xC4C45793, 0xA7A7F255, 0x7E7E82FC, 0x3D3D477A, 0x6464ACC8, 0x5D5DE7BA, 0x19192B32, 0x737395E6,
 439          0x6060A0C0, 0x81819819, 0x4F4FD19E, 0xDCDC7FA3, 0x22226644, 0x2A2A7E54, 0x9090AB3B, 0x8888830B,
 440          0x4646CA8C, 0xEEEE29C7, 0xB8B8D36B, 0x14143C28, 0xDEDE79A7, 0x5E5EE2BC, 0x0B0B1D16, 0xDBDB76AD,
 441          0xE0E03BDB, 0x32325664, 0x3A3A4E74, 0x0A0A1E14, 0x4949DB92, 0x06060A0C, 0x24246C48, 0x5C5CE4B8,
 442          0xC2C25D9F, 0xD3D36EBD, 0xACACEF43, 0x6262A6C4, 0x9191A839, 0x9595A431, 0xE4E437D3, 0x79798BF2,
 443          0xE7E732D5, 0xC8C8438B, 0x3737596E, 0x6D6DB7DA, 0x8D8D8C01, 0xD5D564B1, 0x4E4ED29C, 0xA9A9E049,
 444          0x6C6CB4D8, 0x5656FAAC, 0xF4F407F3, 0xEAEA25CF, 0x6565AFCA, 0x7A7A8EF4, 0xAEAEE947, 0x08081810,
 445          0xBABAD56F, 0x787888F0, 0x25256F4A, 0x2E2E725C, 0x1C1C2438, 0xA6A6F157, 0xB4B4C773, 0xC6C65197,
 446          0xE8E823CB, 0xDDDD7CA1, 0x74749CE8, 0x1F1F213E, 0x4B4BDD96, 0xBDBDDC61, 0x8B8B860D, 0x8A8A850F,
 447          0x707090E0, 0x3E3E427C, 0xB5B5C471, 0x6666AACC, 0x4848D890, 0x03030506, 0xF6F601F7, 0x0E0E121C,
 448          0x6161A3C2, 0x35355F6A, 0x5757F9AE, 0xB9B9D069, 0x86869117, 0xC1C15899, 0x1D1D273A, 0x9E9EB927,
 449          0xE1E138D9, 0xF8F813EB, 0x9898B32B, 0x11113322, 0x6969BBD2, 0xD9D970A9, 0x8E8E8907, 0x9494A733,
 450          0x9B9BB62D, 0x1E1E223C, 0x87879215, 0xE9E920C9, 0xCECE4987, 0x5555FFAA, 0x28287850, 0xDFDF7AA5,
 451          0x8C8C8F03, 0xA1A1F859, 0x89898009, 0x0D0D171A, 0xBFBFDA65, 0xE6E631D7, 0x4242C684, 0x6868B8D0,
 452          0x4141C382, 0x9999B029, 0x2D2D775A, 0x0F0F111E, 0xB0B0CB7B, 0x5454FCA8, 0xBBBBD66D, 0x16163A2C
 453      );
 454  
 455      /**
 456       * Precomputed invMixColumns table
 457       *
 458       * @see Crypt_Rijndael:_encryptBlock()
 459       * @see Crypt_Rijndael:_decryptBlock()
 460       * @var Array
 461       * @access private
 462       */
 463      var $dt0 = array(
 464          0x51F4A750, 0x7E416553, 0x1A17A4C3, 0x3A275E96, 0x3BAB6BCB, 0x1F9D45F1, 0xACFA58AB, 0x4BE30393,
 465          0x2030FA55, 0xAD766DF6, 0x88CC7691, 0xF5024C25, 0x4FE5D7FC, 0xC52ACBD7, 0x26354480, 0xB562A38F,
 466          0xDEB15A49, 0x25BA1B67, 0x45EA0E98, 0x5DFEC0E1, 0xC32F7502, 0x814CF012, 0x8D4697A3, 0x6BD3F9C6,
 467          0x038F5FE7, 0x15929C95, 0xBF6D7AEB, 0x955259DA, 0xD4BE832D, 0x587421D3, 0x49E06929, 0x8EC9C844,
 468          0x75C2896A, 0xF48E7978, 0x99583E6B, 0x27B971DD, 0xBEE14FB6, 0xF088AD17, 0xC920AC66, 0x7DCE3AB4,
 469          0x63DF4A18, 0xE51A3182, 0x97513360, 0x62537F45, 0xB16477E0, 0xBB6BAE84, 0xFE81A01C, 0xF9082B94,
 470          0x70486858, 0x8F45FD19, 0x94DE6C87, 0x527BF8B7, 0xAB73D323, 0x724B02E2, 0xE31F8F57, 0x6655AB2A,
 471          0xB2EB2807, 0x2FB5C203, 0x86C57B9A, 0xD33708A5, 0x302887F2, 0x23BFA5B2, 0x02036ABA, 0xED16825C,
 472          0x8ACF1C2B, 0xA779B492, 0xF307F2F0, 0x4E69E2A1, 0x65DAF4CD, 0x0605BED5, 0xD134621F, 0xC4A6FE8A,
 473          0x342E539D, 0xA2F355A0, 0x058AE132, 0xA4F6EB75, 0x0B83EC39, 0x4060EFAA, 0x5E719F06, 0xBD6E1051,
 474          0x3E218AF9, 0x96DD063D, 0xDD3E05AE, 0x4DE6BD46, 0x91548DB5, 0x71C45D05, 0x0406D46F, 0x605015FF,
 475          0x1998FB24, 0xD6BDE997, 0x894043CC, 0x67D99E77, 0xB0E842BD, 0x07898B88, 0xE7195B38, 0x79C8EEDB,
 476          0xA17C0A47, 0x7C420FE9, 0xF8841EC9, 0x00000000, 0x09808683, 0x322BED48, 0x1E1170AC, 0x6C5A724E,
 477          0xFD0EFFFB, 0x0F853856, 0x3DAED51E, 0x362D3927, 0x0A0FD964, 0x685CA621, 0x9B5B54D1, 0x24362E3A,
 478          0x0C0A67B1, 0x9357E70F, 0xB4EE96D2, 0x1B9B919E, 0x80C0C54F, 0x61DC20A2, 0x5A774B69, 0x1C121A16,
 479          0xE293BA0A, 0xC0A02AE5, 0x3C22E043, 0x121B171D, 0x0E090D0B, 0xF28BC7AD, 0x2DB6A8B9, 0x141EA9C8,
 480          0x57F11985, 0xAF75074C, 0xEE99DDBB, 0xA37F60FD, 0xF701269F, 0x5C72F5BC, 0x44663BC5, 0x5BFB7E34,
 481          0x8B432976, 0xCB23C6DC, 0xB6EDFC68, 0xB8E4F163, 0xD731DCCA, 0x42638510, 0x13972240, 0x84C61120,
 482          0x854A247D, 0xD2BB3DF8, 0xAEF93211, 0xC729A16D, 0x1D9E2F4B, 0xDCB230F3, 0x0D8652EC, 0x77C1E3D0,
 483          0x2BB3166C, 0xA970B999, 0x119448FA, 0x47E96422, 0xA8FC8CC4, 0xA0F03F1A, 0x567D2CD8, 0x223390EF,
 484          0x87494EC7, 0xD938D1C1, 0x8CCAA2FE, 0x98D40B36, 0xA6F581CF, 0xA57ADE28, 0xDAB78E26, 0x3FADBFA4,
 485          0x2C3A9DE4, 0x5078920D, 0x6A5FCC9B, 0x547E4662, 0xF68D13C2, 0x90D8B8E8, 0x2E39F75E, 0x82C3AFF5,
 486          0x9F5D80BE, 0x69D0937C, 0x6FD52DA9, 0xCF2512B3, 0xC8AC993B, 0x10187DA7, 0xE89C636E, 0xDB3BBB7B,
 487          0xCD267809, 0x6E5918F4, 0xEC9AB701, 0x834F9AA8, 0xE6956E65, 0xAAFFE67E, 0x21BCCF08, 0xEF15E8E6,
 488          0xBAE79BD9, 0x4A6F36CE, 0xEA9F09D4, 0x29B07CD6, 0x31A4B2AF, 0x2A3F2331, 0xC6A59430, 0x35A266C0,
 489          0x744EBC37, 0xFC82CAA6, 0xE090D0B0, 0x33A7D815, 0xF104984A, 0x41ECDAF7, 0x7FCD500E, 0x1791F62F,
 490          0x764DD68D, 0x43EFB04D, 0xCCAA4D54, 0xE49604DF, 0x9ED1B5E3, 0x4C6A881B, 0xC12C1FB8, 0x4665517F,
 491          0x9D5EEA04, 0x018C355D, 0xFA877473, 0xFB0B412E, 0xB3671D5A, 0x92DBD252, 0xE9105633, 0x6DD64713,
 492          0x9AD7618C, 0x37A10C7A, 0x59F8148E, 0xEB133C89, 0xCEA927EE, 0xB761C935, 0xE11CE5ED, 0x7A47B13C,
 493          0x9CD2DF59, 0x55F2733F, 0x1814CE79, 0x73C737BF, 0x53F7CDEA, 0x5FFDAA5B, 0xDF3D6F14, 0x7844DB86,
 494          0xCAAFF381, 0xB968C43E, 0x3824342C, 0xC2A3405F, 0x161DC372, 0xBCE2250C, 0x283C498B, 0xFF0D9541,
 495          0x39A80171, 0x080CB3DE, 0xD8B4E49C, 0x6456C190, 0x7BCB8461, 0xD532B670, 0x486C5C74, 0xD0B85742
 496      );
 497  
 498      /**
 499       * Precomputed invMixColumns table
 500       *
 501       * @see Crypt_Rijndael:_encryptBlock()
 502       * @see Crypt_Rijndael:_decryptBlock()
 503       * @var Array
 504       * @access private
 505       */
 506      var $dt1 = array(
 507          0x5051F4A7, 0x537E4165, 0xC31A17A4, 0x963A275E, 0xCB3BAB6B, 0xF11F9D45, 0xABACFA58, 0x934BE303,
 508          0x552030FA, 0xF6AD766D, 0x9188CC76, 0x25F5024C, 0xFC4FE5D7, 0xD7C52ACB, 0x80263544, 0x8FB562A3,
 509          0x49DEB15A, 0x6725BA1B, 0x9845EA0E, 0xE15DFEC0, 0x02C32F75, 0x12814CF0, 0xA38D4697, 0xC66BD3F9,
 510          0xE7038F5F, 0x9515929C, 0xEBBF6D7A, 0xDA955259, 0x2DD4BE83, 0xD3587421, 0x2949E069, 0x448EC9C8,
 511          0x6A75C289, 0x78F48E79, 0x6B99583E, 0xDD27B971, 0xB6BEE14F, 0x17F088AD, 0x66C920AC, 0xB47DCE3A,
 512          0x1863DF4A, 0x82E51A31, 0x60975133, 0x4562537F, 0xE0B16477, 0x84BB6BAE, 0x1CFE81A0, 0x94F9082B,
 513          0x58704868, 0x198F45FD, 0x8794DE6C, 0xB7527BF8, 0x23AB73D3, 0xE2724B02, 0x57E31F8F, 0x2A6655AB,
 514          0x07B2EB28, 0x032FB5C2, 0x9A86C57B, 0xA5D33708, 0xF2302887, 0xB223BFA5, 0xBA02036A, 0x5CED1682,
 515          0x2B8ACF1C, 0x92A779B4, 0xF0F307F2, 0xA14E69E2, 0xCD65DAF4, 0xD50605BE, 0x1FD13462, 0x8AC4A6FE,
 516          0x9D342E53, 0xA0A2F355, 0x32058AE1, 0x75A4F6EB, 0x390B83EC, 0xAA4060EF, 0x065E719F, 0x51BD6E10,
 517          0xF93E218A, 0x3D96DD06, 0xAEDD3E05, 0x464DE6BD, 0xB591548D, 0x0571C45D, 0x6F0406D4, 0xFF605015,
 518          0x241998FB, 0x97D6BDE9, 0xCC894043, 0x7767D99E, 0xBDB0E842, 0x8807898B, 0x38E7195B, 0xDB79C8EE,
 519          0x47A17C0A, 0xE97C420F, 0xC9F8841E, 0x00000000, 0x83098086, 0x48322BED, 0xAC1E1170, 0x4E6C5A72,
 520          0xFBFD0EFF, 0x560F8538, 0x1E3DAED5, 0x27362D39, 0x640A0FD9, 0x21685CA6, 0xD19B5B54, 0x3A24362E,
 521          0xB10C0A67, 0x0F9357E7, 0xD2B4EE96, 0x9E1B9B91, 0x4F80C0C5, 0xA261DC20, 0x695A774B, 0x161C121A,
 522          0x0AE293BA, 0xE5C0A02A, 0x433C22E0, 0x1D121B17, 0x0B0E090D, 0xADF28BC7, 0xB92DB6A8, 0xC8141EA9,
 523          0x8557F119, 0x4CAF7507, 0xBBEE99DD, 0xFDA37F60, 0x9FF70126, 0xBC5C72F5, 0xC544663B, 0x345BFB7E,
 524          0x768B4329, 0xDCCB23C6, 0x68B6EDFC, 0x63B8E4F1, 0xCAD731DC, 0x10426385, 0x40139722, 0x2084C611,
 525          0x7D854A24, 0xF8D2BB3D, 0x11AEF932, 0x6DC729A1, 0x4B1D9E2F, 0xF3DCB230, 0xEC0D8652, 0xD077C1E3,
 526          0x6C2BB316, 0x99A970B9, 0xFA119448, 0x2247E964, 0xC4A8FC8C, 0x1AA0F03F, 0xD8567D2C, 0xEF223390,
 527          0xC787494E, 0xC1D938D1, 0xFE8CCAA2, 0x3698D40B, 0xCFA6F581, 0x28A57ADE, 0x26DAB78E, 0xA43FADBF,
 528          0xE42C3A9D, 0x0D507892, 0x9B6A5FCC, 0x62547E46, 0xC2F68D13, 0xE890D8B8, 0x5E2E39F7, 0xF582C3AF,
 529          0xBE9F5D80, 0x7C69D093, 0xA96FD52D, 0xB3CF2512, 0x3BC8AC99, 0xA710187D, 0x6EE89C63, 0x7BDB3BBB,
 530          0x09CD2678, 0xF46E5918, 0x01EC9AB7, 0xA8834F9A, 0x65E6956E, 0x7EAAFFE6, 0x0821BCCF, 0xE6EF15E8,
 531          0xD9BAE79B, 0xCE4A6F36, 0xD4EA9F09, 0xD629B07C, 0xAF31A4B2, 0x312A3F23, 0x30C6A594, 0xC035A266,
 532          0x37744EBC, 0xA6FC82CA, 0xB0E090D0, 0x1533A7D8, 0x4AF10498, 0xF741ECDA, 0x0E7FCD50, 0x2F1791F6,
 533          0x8D764DD6, 0x4D43EFB0, 0x54CCAA4D, 0xDFE49604, 0xE39ED1B5, 0x1B4C6A88, 0xB8C12C1F, 0x7F466551,
 534          0x049D5EEA, 0x5D018C35, 0x73FA8774, 0x2EFB0B41, 0x5AB3671D, 0x5292DBD2, 0x33E91056, 0x136DD647,
 535          0x8C9AD761, 0x7A37A10C, 0x8E59F814, 0x89EB133C, 0xEECEA927, 0x35B761C9, 0xEDE11CE5, 0x3C7A47B1,
 536          0x599CD2DF, 0x3F55F273, 0x791814CE, 0xBF73C737, 0xEA53F7CD, 0x5B5FFDAA, 0x14DF3D6F, 0x867844DB,
 537          0x81CAAFF3, 0x3EB968C4, 0x2C382434, 0x5FC2A340, 0x72161DC3, 0x0CBCE225, 0x8B283C49, 0x41FF0D95,
 538          0x7139A801, 0xDE080CB3, 0x9CD8B4E4, 0x906456C1, 0x617BCB84, 0x70D532B6, 0x74486C5C, 0x42D0B857
 539      );
 540  
 541      /**
 542       * Precomputed invMixColumns table
 543       *
 544       * @see Crypt_Rijndael:_encryptBlock()
 545       * @see Crypt_Rijndael:_decryptBlock()
 546       * @var Array
 547       * @access private
 548       */
 549      var $dt2 = array(
 550          0xA75051F4, 0x65537E41, 0xA4C31A17, 0x5E963A27, 0x6BCB3BAB, 0x45F11F9D, 0x58ABACFA, 0x03934BE3,
 551          0xFA552030, 0x6DF6AD76, 0x769188CC, 0x4C25F502, 0xD7FC4FE5, 0xCBD7C52A, 0x44802635, 0xA38FB562,
 552          0x5A49DEB1, 0x1B6725BA, 0x0E9845EA, 0xC0E15DFE, 0x7502C32F, 0xF012814C, 0x97A38D46, 0xF9C66BD3,
 553          0x5FE7038F, 0x9C951592, 0x7AEBBF6D, 0x59DA9552, 0x832DD4BE, 0x21D35874, 0x692949E0, 0xC8448EC9,
 554          0x896A75C2, 0x7978F48E, 0x3E6B9958, 0x71DD27B9, 0x4FB6BEE1, 0xAD17F088, 0xAC66C920, 0x3AB47DCE,
 555          0x4A1863DF, 0x3182E51A, 0x33609751, 0x7F456253, 0x77E0B164, 0xAE84BB6B, 0xA01CFE81, 0x2B94F908,
 556          0x68587048, 0xFD198F45, 0x6C8794DE, 0xF8B7527B, 0xD323AB73, 0x02E2724B, 0x8F57E31F, 0xAB2A6655,
 557          0x2807B2EB, 0xC2032FB5, 0x7B9A86C5, 0x08A5D337, 0x87F23028, 0xA5B223BF, 0x6ABA0203, 0x825CED16,
 558          0x1C2B8ACF, 0xB492A779, 0xF2F0F307, 0xE2A14E69, 0xF4CD65DA, 0xBED50605, 0x621FD134, 0xFE8AC4A6,
 559          0x539D342E, 0x55A0A2F3, 0xE132058A, 0xEB75A4F6, 0xEC390B83, 0xEFAA4060, 0x9F065E71, 0x1051BD6E,
 560          0x8AF93E21, 0x063D96DD, 0x05AEDD3E, 0xBD464DE6, 0x8DB59154, 0x5D0571C4, 0xD46F0406, 0x15FF6050,
 561          0xFB241998, 0xE997D6BD, 0x43CC8940, 0x9E7767D9, 0x42BDB0E8, 0x8B880789, 0x5B38E719, 0xEEDB79C8,
 562          0x0A47A17C, 0x0FE97C42, 0x1EC9F884, 0x00000000, 0x86830980, 0xED48322B, 0x70AC1E11, 0x724E6C5A,
 563          0xFFFBFD0E, 0x38560F85, 0xD51E3DAE, 0x3927362D, 0xD9640A0F, 0xA621685C, 0x54D19B5B, 0x2E3A2436,
 564          0x67B10C0A, 0xE70F9357, 0x96D2B4EE, 0x919E1B9B, 0xC54F80C0, 0x20A261DC, 0x4B695A77, 0x1A161C12,
 565          0xBA0AE293, 0x2AE5C0A0, 0xE0433C22, 0x171D121B, 0x0D0B0E09, 0xC7ADF28B, 0xA8B92DB6, 0xA9C8141E,
 566          0x198557F1, 0x074CAF75, 0xDDBBEE99, 0x60FDA37F, 0x269FF701, 0xF5BC5C72, 0x3BC54466, 0x7E345BFB,
 567          0x29768B43, 0xC6DCCB23, 0xFC68B6ED, 0xF163B8E4, 0xDCCAD731, 0x85104263, 0x22401397, 0x112084C6,
 568          0x247D854A, 0x3DF8D2BB, 0x3211AEF9, 0xA16DC729, 0x2F4B1D9E, 0x30F3DCB2, 0x52EC0D86, 0xE3D077C1,
 569          0x166C2BB3, 0xB999A970, 0x48FA1194, 0x642247E9, 0x8CC4A8FC, 0x3F1AA0F0, 0x2CD8567D, 0x90EF2233,
 570          0x4EC78749, 0xD1C1D938, 0xA2FE8CCA, 0x0B3698D4, 0x81CFA6F5, 0xDE28A57A, 0x8E26DAB7, 0xBFA43FAD,
 571          0x9DE42C3A, 0x920D5078, 0xCC9B6A5F, 0x4662547E, 0x13C2F68D, 0xB8E890D8, 0xF75E2E39, 0xAFF582C3,
 572          0x80BE9F5D, 0x937C69D0, 0x2DA96FD5, 0x12B3CF25, 0x993BC8AC, 0x7DA71018, 0x636EE89C, 0xBB7BDB3B,
 573          0x7809CD26, 0x18F46E59, 0xB701EC9A, 0x9AA8834F, 0x6E65E695, 0xE67EAAFF, 0xCF0821BC, 0xE8E6EF15,
 574          0x9BD9BAE7, 0x36CE4A6F, 0x09D4EA9F, 0x7CD629B0, 0xB2AF31A4, 0x23312A3F, 0x9430C6A5, 0x66C035A2,
 575          0xBC37744E, 0xCAA6FC82, 0xD0B0E090, 0xD81533A7, 0x984AF104, 0xDAF741EC, 0x500E7FCD, 0xF62F1791,
 576          0xD68D764D, 0xB04D43EF, 0x4D54CCAA, 0x04DFE496, 0xB5E39ED1, 0x881B4C6A, 0x1FB8C12C, 0x517F4665,
 577          0xEA049D5E, 0x355D018C, 0x7473FA87, 0x412EFB0B, 0x1D5AB367, 0xD25292DB, 0x5633E910, 0x47136DD6,
 578          0x618C9AD7, 0x0C7A37A1, 0x148E59F8, 0x3C89EB13, 0x27EECEA9, 0xC935B761, 0xE5EDE11C, 0xB13C7A47,
 579          0xDF599CD2, 0x733F55F2, 0xCE791814, 0x37BF73C7, 0xCDEA53F7, 0xAA5B5FFD, 0x6F14DF3D, 0xDB867844,
 580          0xF381CAAF, 0xC43EB968, 0x342C3824, 0x405FC2A3, 0xC372161D, 0x250CBCE2, 0x498B283C, 0x9541FF0D,
 581          0x017139A8, 0xB3DE080C, 0xE49CD8B4, 0xC1906456, 0x84617BCB, 0xB670D532, 0x5C74486C, 0x5742D0B8
 582      );
 583  
 584      /**
 585       * Precomputed invMixColumns table
 586       *
 587       * @see Crypt_Rijndael:_encryptBlock()
 588       * @see Crypt_Rijndael:_decryptBlock()
 589       * @var Array
 590       * @access private
 591       */
 592      var $dt3 = array(
 593          0xF4A75051, 0x4165537E, 0x17A4C31A, 0x275E963A, 0xAB6BCB3B, 0x9D45F11F, 0xFA58ABAC, 0xE303934B,
 594          0x30FA5520, 0x766DF6AD, 0xCC769188, 0x024C25F5, 0xE5D7FC4F, 0x2ACBD7C5, 0x35448026, 0x62A38FB5,
 595          0xB15A49DE, 0xBA1B6725, 0xEA0E9845, 0xFEC0E15D, 0x2F7502C3, 0x4CF01281, 0x4697A38D, 0xD3F9C66B,
 596          0x8F5FE703, 0x929C9515, 0x6D7AEBBF, 0x5259DA95, 0xBE832DD4, 0x7421D358, 0xE0692949, 0xC9C8448E,
 597          0xC2896A75, 0x8E7978F4, 0x583E6B99, 0xB971DD27, 0xE14FB6BE, 0x88AD17F0, 0x20AC66C9, 0xCE3AB47D,
 598          0xDF4A1863, 0x1A3182E5, 0x51336097, 0x537F4562, 0x6477E0B1, 0x6BAE84BB, 0x81A01CFE, 0x082B94F9,
 599          0x48685870, 0x45FD198F, 0xDE6C8794, 0x7BF8B752, 0x73D323AB, 0x4B02E272, 0x1F8F57E3, 0x55AB2A66,
 600          0xEB2807B2, 0xB5C2032F, 0xC57B9A86, 0x3708A5D3, 0x2887F230, 0xBFA5B223, 0x036ABA02, 0x16825CED,
 601          0xCF1C2B8A, 0x79B492A7, 0x07F2F0F3, 0x69E2A14E, 0xDAF4CD65, 0x05BED506, 0x34621FD1, 0xA6FE8AC4,
 602          0x2E539D34, 0xF355A0A2, 0x8AE13205, 0xF6EB75A4, 0x83EC390B, 0x60EFAA40, 0x719F065E, 0x6E1051BD,
 603          0x218AF93E, 0xDD063D96, 0x3E05AEDD, 0xE6BD464D, 0x548DB591, 0xC45D0571, 0x06D46F04, 0x5015FF60,
 604          0x98FB2419, 0xBDE997D6, 0x4043CC89, 0xD99E7767, 0xE842BDB0, 0x898B8807, 0x195B38E7, 0xC8EEDB79,
 605          0x7C0A47A1, 0x420FE97C, 0x841EC9F8, 0x00000000, 0x80868309, 0x2BED4832, 0x1170AC1E, 0x5A724E6C,
 606          0x0EFFFBFD, 0x8538560F, 0xAED51E3D, 0x2D392736, 0x0FD9640A, 0x5CA62168, 0x5B54D19B, 0x362E3A24,
 607          0x0A67B10C, 0x57E70F93, 0xEE96D2B4, 0x9B919E1B, 0xC0C54F80, 0xDC20A261, 0x774B695A, 0x121A161C,
 608          0x93BA0AE2, 0xA02AE5C0, 0x22E0433C, 0x1B171D12, 0x090D0B0E, 0x8BC7ADF2, 0xB6A8B92D, 0x1EA9C814,
 609          0xF1198557, 0x75074CAF, 0x99DDBBEE, 0x7F60FDA3, 0x01269FF7, 0x72F5BC5C, 0x663BC544, 0xFB7E345B,
 610          0x4329768B, 0x23C6DCCB, 0xEDFC68B6, 0xE4F163B8, 0x31DCCAD7, 0x63851042, 0x97224013, 0xC6112084,
 611          0x4A247D85, 0xBB3DF8D2, 0xF93211AE, 0x29A16DC7, 0x9E2F4B1D, 0xB230F3DC, 0x8652EC0D, 0xC1E3D077,
 612          0xB3166C2B, 0x70B999A9, 0x9448FA11, 0xE9642247, 0xFC8CC4A8, 0xF03F1AA0, 0x7D2CD856, 0x3390EF22,
 613          0x494EC787, 0x38D1C1D9, 0xCAA2FE8C, 0xD40B3698, 0xF581CFA6, 0x7ADE28A5, 0xB78E26DA, 0xADBFA43F,
 614          0x3A9DE42C, 0x78920D50, 0x5FCC9B6A, 0x7E466254, 0x8D13C2F6, 0xD8B8E890, 0x39F75E2E, 0xC3AFF582,
 615          0x5D80BE9F, 0xD0937C69, 0xD52DA96F, 0x2512B3CF, 0xAC993BC8, 0x187DA710, 0x9C636EE8, 0x3BBB7BDB,
 616          0x267809CD, 0x5918F46E, 0x9AB701EC, 0x4F9AA883, 0x956E65E6, 0xFFE67EAA, 0xBCCF0821, 0x15E8E6EF,
 617          0xE79BD9BA, 0x6F36CE4A, 0x9F09D4EA, 0xB07CD629, 0xA4B2AF31, 0x3F23312A, 0xA59430C6, 0xA266C035,
 618          0x4EBC3774, 0x82CAA6FC, 0x90D0B0E0, 0xA7D81533, 0x04984AF1, 0xECDAF741, 0xCD500E7F, 0x91F62F17,
 619          0x4DD68D76, 0xEFB04D43, 0xAA4D54CC, 0x9604DFE4, 0xD1B5E39E, 0x6A881B4C, 0x2C1FB8C1, 0x65517F46,
 620          0x5EEA049D, 0x8C355D01, 0x877473FA, 0x0B412EFB, 0x671D5AB3, 0xDBD25292, 0x105633E9, 0xD647136D,
 621          0xD7618C9A, 0xA10C7A37, 0xF8148E59, 0x133C89EB, 0xA927EECE, 0x61C935B7, 0x1CE5EDE1, 0x47B13C7A,
 622          0xD2DF599C, 0xF2733F55, 0x14CE7918, 0xC737BF73, 0xF7CDEA53, 0xFDAA5B5F, 0x3D6F14DF, 0x44DB8678,
 623          0xAFF381CA, 0x68C43EB9, 0x24342C38, 0xA3405FC2, 0x1DC37216, 0xE2250CBC, 0x3C498B28, 0x0D9541FF,
 624          0xA8017139, 0x0CB3DE08, 0xB4E49CD8, 0x56C19064, 0xCB84617B, 0x32B670D5, 0x6C5C7448, 0xB85742D0
 625      );
 626  
 627      /**
 628       * The SubByte S-Box
 629       *
 630       * @see Crypt_Rijndael::_encryptBlock()
 631       * @var Array
 632       * @access private
 633       */
 634      var $sbox = array(
 635          0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
 636          0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
 637          0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
 638          0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
 639          0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
 640          0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
 641          0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
 642          0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
 643          0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
 644          0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
 645          0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
 646          0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
 647          0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
 648          0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
 649          0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
 650          0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
 651      );
 652  
 653      /**
 654       * The inverse SubByte S-Box
 655       *
 656       * @see Crypt_Rijndael::_decryptBlock()
 657       * @var Array
 658       * @access private
 659       */
 660      var $isbox = array(
 661          0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
 662          0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
 663          0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
 664          0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
 665          0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
 666          0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
 667          0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
 668          0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
 669          0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
 670          0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
 671          0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
 672          0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
 673          0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
 674          0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
 675          0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
 676          0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
 677      );
 678  
 679      /**
 680       * Default Constructor.
 681       *
 682       * Determines whether or not the mcrypt extension should be used.
 683       *
 684       * $mode could be:
 685       *
 686       * - CRYPT_RIJNDAEL_MODE_ECB
 687       *
 688       * - CRYPT_RIJNDAEL_MODE_CBC
 689       *
 690       * - CRYPT_RIJNDAEL_MODE_CTR
 691       *
 692       * - CRYPT_RIJNDAEL_MODE_CFB
 693       *
 694       * - CRYPT_RIJNDAEL_MODE_OFB
 695       *
 696       * If not explictly set, CRYPT_RIJNDAEL_MODE_CBC will be used.
 697       *
 698       * @see Crypt_Base::Crypt_Base()
 699       * @param optional Integer $mode
 700       * @access public
 701       */
 702      function __construct($mode = CRYPT_RIJNDAEL_MODE_CBC)
 703      {
 704          parent::__construct($mode);
 705      }
 706  
 707      /**
 708       * Sets the key.
 709       *
 710       * Keys can be of any length.  Rijndael, itself, requires the use of a key that's between 128-bits and 256-bits long and
 711       * 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
 712       * up to the closest valid key length, padding $key with null bytes.  If the key is more than 256-bits, we trim the
 713       * excess bits.
 714       *
 715       * If the key is not explicitly set, it'll be assumed to be all null bytes.
 716       *
 717       * Note: 160/224-bit keys must explicitly set by setKeyLength(), otherwise they will be round/pad up to 192/256 bits.
 718       *
 719       * @see Crypt_Base:setKey()
 720       * @see setKeyLength()
 721       * @access public
 722       * @param String $key
 723       */
 724      function setKey($key)
 725      {
 726          parent::setKey($key);
 727  
 728          if (!$this->explicit_key_length) {
 729              $length = strlen($key);
 730              switch (true) {
 731                  case $length <= 16:
 732                      $this->key_size = 16;
 733                      break;
 734                  case $length <= 24:
 735                      $this->key_size = 24;
 736                      break;
 737                  default:
 738                      $this->key_size = 32;
 739              }
 740              $this->_setupEngine();
 741          }
 742      }
 743  
 744      /**
 745       * Sets the key length
 746       *
 747       * Valid key lengths are 128, 160, 192, 224, and 256.  If the length is less than 128, it will be rounded up to
 748       * 128.  If the length is greater than 128 and invalid, it will be rounded down to the closest valid amount.
 749       *
 750       * Note: phpseclib extends Rijndael (and AES) for using 160- and 224-bit keys but they are officially not defined
 751       *       and the most (if not all) implementations are not able using 160/224-bit keys but round/pad them up to
 752       *       192/256 bits as, for example, mcrypt will do.
 753       *
 754       *       That said, if you want be compatible with other Rijndael and AES implementations,
 755       *       you should not setKeyLength(160) or setKeyLength(224).
 756       *
 757       * Additional: In case of 160- and 224-bit keys, phpseclib will/can, for that reason, not use
 758       *             the mcrypt php extention, even if available.
 759       *             This results then in slower encryption.
 760       *
 761       * @access public
 762       * @param Integer $length
 763       */
 764      function setKeyLength($length)
 765      {
 766          switch (true) {
 767              case $length == 160:
 768                  $this->key_size = 20;
 769                  break;
 770              case $length == 224:
 771                  $this->key_size = 28;
 772                  break;
 773              case $length <= 128:
 774                  $this->key_size = 16;
 775                  break;
 776              case $length <= 192:
 777                  $this->key_size = 24;
 778                  break;
 779              default:
 780                  $this->key_size = 32;
 781          }
 782  
 783          $this->explicit_key_length = true;
 784          $this->changed = true;
 785          $this->_setupEngine();
 786      }
 787  
 788      /**
 789       * Sets the block length
 790       *
 791       * Valid block lengths are 128, 160, 192, 224, and 256.  If the length is less than 128, it will be rounded up to
 792       * 128.  If the length is greater than 128 and invalid, it will be rounded down to the closest valid amount.
 793       *
 794       * @access public
 795       * @param Integer $length
 796       */
 797      function setBlockLength($length)
 798      {
 799          $length >>= 5;
 800          if ($length > 8) {
 801              $length = 8;
 802          } else if ($length < 4) {
 803              $length = 4;
 804          }
 805          $this->Nb = $length;
 806          $this->block_size = $length << 2;
 807          $this->changed = true;
 808          $this->_setupEngine();
 809      }
 810  
 811      /**
 812       * Setup the fastest possible $engine
 813       *
 814       * Determines if the mcrypt (MODE_MCRYPT) $engine available
 815       * and usable for the current $block_size and $key_size.
 816       *
 817       * If not, the slower MODE_INTERNAL $engine will be set.
 818       *
 819       * @see setKey()
 820       * @see setKeyLength()
 821       * @see setBlockLength()
 822       * @access private
 823       */
 824      function _setupEngine()
 825      {
 826          if (constant('CRYPT_' . $this->const_namespace . '_MODE') == CRYPT_MODE_INTERNAL) {
 827              // No mcrypt support at all for rijndael
 828              return;
 829          }
 830  
 831          // The required mcrypt module name for the current $block_size of rijndael
 832          $cipher_name_mcrypt = 'rijndael-' . ($this->block_size << 3);
 833  
 834          // Determining the availibility/usability of $cipher_name_mcrypt
 835          switch (true) {
 836              case $this->key_size % 8: // mcrypt is not usable for 160/224-bit keys, only for 128/192/256-bit keys
 837              case !in_array($cipher_name_mcrypt, mcrypt_list_algorithms()): // $cipher_name_mcrypt is not available for the current $block_size
 838                  $engine = CRYPT_MODE_INTERNAL;
 839                  break;
 840              default:
 841                  $engine = CRYPT_MODE_MCRYPT;
 842          }
 843  
 844          if ($this->engine == $engine && $this->cipher_name_mcrypt == $cipher_name_mcrypt) {
 845              // allready set, so we not unnecessary close $this->enmcrypt/demcrypt/ecb
 846              return;
 847          }
 848  
 849          // Set the $engine
 850          $this->engine = $engine;
 851          $this->cipher_name_mcrypt = $cipher_name_mcrypt;
 852  
 853          if ($this->enmcrypt) {
 854              // Closing the current mcrypt resource(s). _mcryptSetup() will, if needed,
 855              // (re)open them with the module named in $this->cipher_name_mcrypt
 856              mcrypt_module_close($this->enmcrypt);
 857              mcrypt_module_close($this->demcrypt);
 858              $this->enmcrypt = null;
 859              $this->demcrypt = null;
 860  
 861              if ($this->ecb) {
 862                  mcrypt_module_close($this->ecb);
 863                  $this->ecb = null;
 864              }
 865          }
 866      }
 867  
 868      /**
 869       * Setup the CRYPT_MODE_MCRYPT $engine
 870       *
 871       * @see Crypt_Base::_setupMcrypt()
 872       * @access private
 873       */
 874      function _setupMcrypt()
 875      {
 876          $this->key = str_pad(substr($this->key, 0, $this->key_size), $this->key_size, "\0");
 877          parent::_setupMcrypt();
 878      }
 879  
 880      /**
 881       * Encrypts a block
 882       *
 883       * @access private
 884       * @param String $in
 885       * @return String
 886       */
 887      function _encryptBlock($in)
 888      {
 889          static $t0, $t1, $t2, $t3, $sbox;
 890          if (!$t0) {
 891              for ($i = 0; $i < 256; ++$i) {
 892                  $t0[] = (int)$this->t0[$i];
 893                  $t1[] = (int)$this->t1[$i];
 894                  $t2[] = (int)$this->t2[$i];
 895                  $t3[] = (int)$this->t3[$i];
 896                  $sbox[] = (int)$this->sbox[$i];
 897              }
 898          }
 899  
 900          $state = array();
 901          $words = unpack('N*', $in);
 902  
 903          $c = $this->c;
 904          $w = $this->w;
 905          $Nb = $this->Nb;
 906          $Nr = $this->Nr;
 907  
 908          // addRoundKey
 909          $i = -1;
 910          foreach ($words as $word) {
 911              $state[] = $word ^ $w[0][++$i];
 912          }
 913  
 914          // fips-197.pdf#page=19, "Figure 5. Pseudo Code for the Cipher", states that this loop has four components -
 915          // subBytes, shiftRows, mixColumns, and addRoundKey. fips-197.pdf#page=30, "Implementation Suggestions Regarding
 916          // Various Platforms" suggests that performs enhanced implementations are described in Rijndael-ammended.pdf.
 917          // Rijndael-ammended.pdf#page=20, "Implementation aspects / 32-bit processor", discusses such an optimization.
 918          // Unfortunately, the description given there is not quite correct.  Per aes.spec.v316.pdf#page=19 [1],
 919          // equation (7.4.7) is supposed to use addition instead of subtraction, so we'll do that here, as well.
 920  
 921          // [1] http://fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.v316.pdf
 922          $temp = array();
 923          for ($round = 1; $round < $Nr; ++$round) {
 924              $i = 0; // $c[0] == 0
 925              $j = $c[1];
 926              $k = $c[2];
 927              $l = $c[3];
 928  
 929              while ($i < $Nb) {
 930                  $temp[$i] = $t0[$state[$i] >> 24 & 0x000000FF] ^
 931                              $t1[$state[$j] >> 16 & 0x000000FF] ^
 932                              $t2[$state[$k] >>  8 & 0x000000FF] ^
 933                              $t3[$state[$l]       & 0x000000FF] ^
 934                              $w[$round][$i];
 935                  ++$i;
 936                  $j = ($j + 1) % $Nb;
 937                  $k = ($k + 1) % $Nb;
 938                  $l = ($l + 1) % $Nb;
 939              }
 940              $state = $temp;
 941          }
 942  
 943          // subWord
 944          for ($i = 0; $i < $Nb; ++$i) {
 945              $state[$i] =   $sbox[$state[$i]       & 0x000000FF]        |
 946                            ($sbox[$state[$i] >>  8 & 0x000000FF] <<  8) |
 947                            ($sbox[$state[$i] >> 16 & 0x000000FF] << 16) |
 948                            ($sbox[$state[$i] >> 24 & 0x000000FF] << 24);
 949          }
 950  
 951          // shiftRows + addRoundKey
 952          $i = 0; // $c[0] == 0
 953          $j = $c[1];
 954          $k = $c[2];
 955          $l = $c[3];
 956          while ($i < $Nb) {
 957              $temp[$i] = ($state[$i] & 0xFF000000) ^
 958                          ($state[$j] & 0x00FF0000) ^
 959                          ($state[$k] & 0x0000FF00) ^
 960                          ($state[$l] & 0x000000FF) ^
 961                           $w[$Nr][$i];
 962              ++$i;
 963              $j = ($j + 1) % $Nb;
 964              $k = ($k + 1) % $Nb;
 965              $l = ($l + 1) % $Nb;
 966          }
 967  
 968          switch ($Nb) {
 969              case 8:
 970                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4], $temp[5], $temp[6], $temp[7]);
 971              case 7:
 972                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4], $temp[5], $temp[6]);
 973              case 6:
 974                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4], $temp[5]);
 975              case 5:
 976                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4]);
 977              default:
 978                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3]);
 979          }
 980      }
 981  
 982      /**
 983       * Decrypts a block
 984       *
 985       * @access private
 986       * @param String $in
 987       * @return String
 988       */
 989      function _decryptBlock($in)
 990      {
 991          static $dt0, $dt1, $dt2, $dt3, $isbox;
 992          if (!$dt0) {
 993              for ($i = 0; $i < 256; ++$i) {
 994                  $dt0[] = (int)$this->dt0[$i];
 995                  $dt1[] = (int)$this->dt1[$i];
 996                  $dt2[] = (int)$this->dt2[$i];
 997                  $dt3[] = (int)$this->dt3[$i];
 998                  $isbox[] = (int)$this->isbox[$i];
 999              }
1000          }
1001  
1002          $state = array();
1003          $words = unpack('N*', $in);
1004  
1005          $c  = $this->c;
1006          $dw = $this->dw;
1007          $Nb = $this->Nb;
1008          $Nr = $this->Nr;
1009  
1010          // addRoundKey
1011          $i = -1;
1012          foreach ($words as $word) {
1013              $state[] = $word ^ $dw[$Nr][++$i];
1014          }
1015  
1016          $temp = array();
1017          for ($round = $Nr - 1; $round > 0; --$round) {
1018              $i = 0; // $c[0] == 0
1019              $j = $Nb - $c[1];
1020              $k = $Nb - $c[2];
1021              $l = $Nb - $c[3];
1022  
1023              while ($i < $Nb) {
1024                  $temp[$i] = $dt0[$state[$i] >> 24 & 0x000000FF] ^
1025                              $dt1[$state[$j] >> 16 & 0x000000FF] ^
1026                              $dt2[$state[$k] >>  8 & 0x000000FF] ^
1027                              $dt3[$state[$l]       & 0x000000FF] ^
1028                              $dw[$round][$i];
1029                  ++$i;
1030                  $j = ($j + 1) % $Nb;
1031                  $k = ($k + 1) % $Nb;
1032                  $l = ($l + 1) % $Nb;
1033              }
1034              $state = $temp;
1035          }
1036  
1037          // invShiftRows + invSubWord + addRoundKey
1038          $i = 0; // $c[0] == 0
1039          $j = $Nb - $c[1];
1040          $k = $Nb - $c[2];
1041          $l = $Nb - $c[3];
1042  
1043          while ($i < $Nb) {
1044              $word = ($state[$i] & 0xFF000000) |
1045                      ($state[$j] & 0x00FF0000) |
1046                      ($state[$k] & 0x0000FF00) |
1047                      ($state[$l] & 0x000000FF);
1048  
1049              $temp[$i] = $dw[0][$i] ^ ($isbox[$word       & 0x000000FF]        |
1050                                       ($isbox[$word >>  8 & 0x000000FF] <<  8) |
1051                                       ($isbox[$word >> 16 & 0x000000FF] << 16) |
1052                                       ($isbox[$word >> 24 & 0x000000FF] << 24));
1053              ++$i;
1054              $j = ($j + 1) % $Nb;
1055              $k = ($k + 1) % $Nb;
1056              $l = ($l + 1) % $Nb;
1057          }
1058  
1059          switch ($Nb) {
1060              case 8:
1061                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4], $temp[5], $temp[6], $temp[7]);
1062              case 7:
1063                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4], $temp[5], $temp[6]);
1064              case 6:
1065                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4], $temp[5]);
1066              case 5:
1067                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3], $temp[4]);
1068              default:
1069                  return pack('N*', $temp[0], $temp[1], $temp[2], $temp[3]);
1070          }
1071      }
1072  
1073      /**
1074       * Setup the key (expansion)
1075       *
1076       * @see Crypt_Base::_setupKey()
1077       * @access private
1078       */
1079      function _setupKey()
1080      {
1081          // Each number in $rcon is equal to the previous number multiplied by two in Rijndael's finite field.
1082          // See http://en.wikipedia.org/wiki/Finite_field_arithmetic#Multiplicative_inverse
1083          static $rcon = array(0,
1084              0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000,
1085              0x20000000, 0x40000000, 0x80000000, 0x1B000000, 0x36000000,
1086              0x6C000000, 0xD8000000, 0xAB000000, 0x4D000000, 0x9A000000,
1087              0x2F000000, 0x5E000000, 0xBC000000, 0x63000000, 0xC6000000,
1088              0x97000000, 0x35000000, 0x6A000000, 0xD4000000, 0xB3000000,
1089              0x7D000000, 0xFA000000, 0xEF000000, 0xC5000000, 0x91000000
1090          );
1091  
1092          $this->key = str_pad(substr($this->key, 0, $this->key_size), $this->key_size, "\0");
1093  
1094          if (isset($this->kl['key']) && $this->key === $this->kl['key'] && $this->key_size === $this->kl['key_size'] && $this->block_size === $this->kl['block_size']) {
1095              // already expanded
1096              return;
1097          }
1098          $this->kl = array('key' => $this->key, 'key_size' => $this->key_size, 'block_size' => $this->block_size);
1099  
1100          $this->Nk = $this->key_size >> 2;
1101          // see Rijndael-ammended.pdf#page=44
1102          $this->Nr = max($this->Nk, $this->Nb) + 6;
1103  
1104          // shift offsets for Nb = 5, 7 are defined in Rijndael-ammended.pdf#page=44,
1105          //     "Table 8: Shift offsets in Shiftrow for the alternative block lengths"
1106          // shift offsets for Nb = 4, 6, 8 are defined in Rijndael-ammended.pdf#page=14,
1107          //     "Table 2: Shift offsets for different block lengths"
1108          switch ($this->Nb) {
1109              case 4:
1110              case 5:
1111              case 6:
1112                  $this->c = array(0, 1, 2, 3);
1113                  break;
1114              case 7:
1115                  $this->c = array(0, 1, 2, 4);
1116                  break;
1117              case 8:
1118                  $this->c = array(0, 1, 3, 4);
1119          }
1120  
1121          $w = array_values(unpack('N*words', $this->key));
1122  
1123          $length = $this->Nb * ($this->Nr + 1);
1124          for ($i = $this->Nk; $i < $length; $i++) {
1125              $temp = $w[$i - 1];
1126              if ($i % $this->Nk == 0) {
1127                  // according to <http://php.net/language.types.integer>, "the size of an integer is platform-dependent".
1128                  // on a 32-bit machine, it's 32-bits, and on a 64-bit machine, it's 64-bits. on a 32-bit machine,
1129                  // 0xFFFFFFFF << 8 == 0xFFFFFF00, but on a 64-bit machine, it equals 0xFFFFFFFF00. as such, doing 'and'
1130                  // with 0xFFFFFFFF (or 0xFFFFFF00) on a 32-bit machine is unnecessary, but on a 64-bit machine, it is.
1131                  $temp = (($temp << 8) & 0xFFFFFF00) | (($temp >> 24) & 0x000000FF); // rotWord
1132                  $temp = $this->_subWord($temp) ^ $rcon[$i / $this->Nk];
1133              } else if ($this->Nk > 6 && $i % $this->Nk == 4) {
1134                  $temp = $this->_subWord($temp);
1135              }
1136              $w[$i] = $w[$i - $this->Nk] ^ $temp;
1137          }
1138  
1139          // convert the key schedule from a vector of $Nb * ($Nr + 1) length to a matrix with $Nr + 1 rows and $Nb columns
1140          // and generate the inverse key schedule.  more specifically,
1141          // according to <http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf#page=23> (section 5.3.3),
1142          // "The key expansion for the Inverse Cipher is defined as follows:
1143          //        1. Apply the Key Expansion.
1144          //        2. Apply InvMixColumn to all Round Keys except the first and the last one."
1145          // also, see fips-197.pdf#page=27, "5.3.5 Equivalent Inverse Cipher"
1146          $temp = $this->w = $this->dw = array();
1147          for ($i = $row = $col = 0; $i < $length; $i++, $col++) {
1148              if ($col == $this->Nb) {
1149                  if ($row == 0) {
1150                      $this->dw[0] = $this->w[0];
1151                  } else {
1152                      // subWord + invMixColumn + invSubWord = invMixColumn
1153                      $j = 0;
1154                      while ($j < $this->Nb) {
1155                          $dw = $this->_subWord($this->w[$row][$j]);
1156                          $temp[$j] = $this->dt0[$dw >> 24 & 0x000000FF] ^
1157                                      $this->dt1[$dw >> 16 & 0x000000FF] ^
1158                                      $this->dt2[$dw >>  8 & 0x000000FF] ^
1159                                      $this->dt3[$dw       & 0x000000FF];
1160                          $j++;
1161                      }
1162                      $this->dw[$row] = $temp;
1163                  }
1164  
1165                  $col = 0;
1166                  $row++;
1167              }
1168              $this->w[$row][$col] = $w[$i];
1169          }
1170  
1171          $this->dw[$row] = $this->w[$row];
1172  
1173          // In case of $this->use_inline_crypt === true we have to use 1-dim key arrays (both ascending)
1174          if ($this->use_inline_crypt) {
1175              $this->dw = array_reverse($this->dw);
1176              $w  = array_pop($this->w);
1177              $dw = array_pop($this->dw);
1178              foreach ($this->w as $r => $wr) {
1179                  foreach ($wr as $c => $wc) {
1180                      $w[]  = $wc;
1181                      $dw[] = $this->dw[$r][$c];
1182                  }
1183              }
1184              $this->w  = $w;
1185              $this->dw = $dw;
1186          }
1187      }
1188  
1189      /**
1190       * Performs S-Box substitutions
1191       *
1192       * @access private
1193       * @param Integer $word
1194       */
1195      function _subWord($word)
1196      {
1197          $sbox = $this->sbox;
1198  
1199          return  $sbox[$word       & 0x000000FF]        |
1200                 ($sbox[$word >>  8 & 0x000000FF] <<  8) |
1201                 ($sbox[$word >> 16 & 0x000000FF] << 16) |
1202                 ($sbox[$word >> 24 & 0x000000FF] << 24);
1203      }
1204  
1205      /**
1206       * Setup the performance-optimized function for de/encrypt()
1207       *
1208       * @see Crypt_Base::_setupInlineCrypt()
1209       * @access private
1210       */
1211      function _setupInlineCrypt()
1212      {
1213          // Note: _setupInlineCrypt() will be called only if $this->changed === true
1214          // So here we are'nt under the same heavy timing-stress as we are in _de/encryptBlock() or de/encrypt().
1215          // However...the here generated function- $code, stored as php callback in $this->inline_crypt, must work as fast as even possible.
1216  
1217          $lambda_functions =& Crypt_Rijndael::_getLambdaFunctions();
1218  
1219          // The first 10 generated $lambda_functions will use the key-words hardcoded for better performance.
1220          // For memory reason we limit those ultra-optimized functions.
1221          // After that, we use pure (extracted) integer vars for the key-words which is faster than accessing them via array.
1222          if (count($lambda_functions) < 10) {
1223              $w  = $this->w;
1224              $dw = $this->dw;
1225              $init_encrypt = '';
1226              $init_decrypt = '';
1227          } else {
1228              for ($i = 0, $cw = count($this->w); $i < $cw; ++$i) {
1229                  $w[]  = '$w['  . $i . ']';
1230                  $dw[] = '$dw[' . $i . ']';
1231              }
1232              $init_encrypt = '$w = $self->w;';
1233              $init_decrypt = '$dw = $self->dw;';
1234          }
1235  
1236          $code_hash = md5(str_pad("Crypt_Rijndael, {$this->mode}, {$this->block_size}, ", 32, "\0") . implode(',', $w));
1237  
1238          if (!isset($lambda_functions[$code_hash])) {
1239              $Nr = $this->Nr;
1240              $Nb = $this->Nb;
1241              $c  = $this->c;
1242  
1243              // Generating encrypt code:
1244              $init_encrypt.= '
1245                  static $t0, $t1, $t2, $t3, $sbox;
1246                  if (!$t0) {
1247                      for ($i = 0; $i < 256; ++$i) {
1248                          $t0[$i]    = (int)$self->t0[$i];
1249                          $t1[$i]    = (int)$self->t1[$i];
1250                          $t2[$i]    = (int)$self->t2[$i];
1251                          $t3[$i]    = (int)$self->t3[$i];
1252                          $sbox[$i]  = (int)$self->sbox[$i];
1253                      }
1254                  }
1255              ';
1256  
1257              $s  = 'e';
1258              $e  = 's';
1259              $wc = $Nb - 1;
1260  
1261              // Preround: addRoundKey
1262              $encrypt_block = '$in = unpack("N*", $in);'."\n";
1263              for ($i = 0; $i < $Nb; ++$i) {
1264                  $encrypt_block .= '$s'.$i.' = $in['.($i + 1).'] ^ '.$w[++$wc].";\n";
1265              }
1266  
1267              // Mainrounds: shiftRows + subWord + mixColumns + addRoundKey
1268              for ($round = 1; $round < $Nr; ++$round) {
1269                  list($s, $e) = array($e, $s);
1270                  for ($i = 0; $i < $Nb; ++$i) {
1271                      $encrypt_block.=
1272                          '$'.$e.$i.' =
1273                          $t0[($'.$s.$i                  .' >> 24) & 0xff] ^
1274                          $t1[($'.$s.(($i + $c[1]) % $Nb).' >> 16) & 0xff] ^
1275                          $t2[($'.$s.(($i + $c[2]) % $Nb).' >>  8) & 0xff] ^
1276                          $t3[ $'.$s.(($i + $c[3]) % $Nb).'        & 0xff] ^
1277                          '.$w[++$wc].";\n";
1278                  }
1279              }
1280  
1281              // Finalround: subWord + shiftRows + addRoundKey
1282              for ($i = 0; $i < $Nb; ++$i) {
1283                  $encrypt_block.=
1284                      '$'.$e.$i.' =
1285                       $sbox[ $'.$e.$i.'        & 0xff]        |
1286                      ($sbox[($'.$e.$i.' >>  8) & 0xff] <<  8) |
1287                      ($sbox[($'.$e.$i.' >> 16) & 0xff] << 16) |
1288                      ($sbox[($'.$e.$i.' >> 24) & 0xff] << 24);'."\n";
1289              }
1290              $encrypt_block .= '$in = pack("N*"'."\n";
1291              for ($i = 0; $i < $Nb; ++$i) {
1292                  $encrypt_block.= ',
1293                      ($'.$e.$i                  .' & 0xFF000000) ^
1294                      ($'.$e.(($i + $c[1]) % $Nb).' & 0x00FF0000) ^
1295                      ($'.$e.(($i + $c[2]) % $Nb).' & 0x0000FF00) ^
1296                      ($'.$e.(($i + $c[3]) % $Nb).' & 0x000000FF) ^
1297                      '.$w[$i]."\n";
1298              }
1299              $encrypt_block .= ');';
1300  
1301              // Generating decrypt code:
1302              $init_decrypt.= '
1303                  static $dt0, $dt1, $dt2, $dt3, $isbox;
1304                  if (!$dt0) {
1305                      for ($i = 0; $i < 256; ++$i) {
1306                          $dt0[$i]   = (int)$self->dt0[$i];
1307                          $dt1[$i]   = (int)$self->dt1[$i];
1308                          $dt2[$i]   = (int)$self->dt2[$i];
1309                          $dt3[$i]   = (int)$self->dt3[$i];
1310                          $isbox[$i] = (int)$self->isbox[$i];
1311                      }
1312                  }
1313              ';
1314  
1315              $s  = 'e';
1316              $e  = 's';
1317              $wc = $Nb - 1;
1318  
1319              // Preround: addRoundKey
1320              $decrypt_block = '$in = unpack("N*", $in);'."\n";
1321              for ($i = 0; $i < $Nb; ++$i) {
1322                  $decrypt_block .= '$s'.$i.' = $in['.($i + 1).'] ^ '.$dw[++$wc].';'."\n";
1323              }
1324  
1325              // Mainrounds: shiftRows + subWord + mixColumns + addRoundKey
1326              for ($round = 1; $round < $Nr; ++$round) {
1327                  list($s, $e) = array($e, $s);
1328                  for ($i = 0; $i < $Nb; ++$i) {
1329                      $decrypt_block.=
1330                          '$'.$e.$i.' =
1331                          $dt0[($'.$s.$i                        .' >> 24) & 0xff] ^
1332                          $dt1[($'.$s.(($Nb + $i - $c[1]) % $Nb).' >> 16) & 0xff] ^
1333                          $dt2[($'.$s.(($Nb + $i - $c[2]) % $Nb).' >>  8) & 0xff] ^
1334                          $dt3[ $'.$s.(($Nb + $i - $c[3]) % $Nb).'        & 0xff] ^
1335                          '.$dw[++$wc].";\n";
1336                  }
1337              }
1338  
1339              // Finalround: subWord + shiftRows + addRoundKey
1340              for ($i = 0; $i < $Nb; ++$i) {
1341                  $decrypt_block.=
1342                      '$'.$e.$i.' =
1343                       $isbox[ $'.$e.$i.'        & 0xff]        |
1344                      ($isbox[($'.$e.$i.' >>  8) & 0xff] <<  8) |
1345                      ($isbox[($'.$e.$i.' >> 16) & 0xff] << 16) |
1346                      ($isbox[($'.$e.$i.' >> 24) & 0xff] << 24);'."\n";
1347              }
1348              $decrypt_block .= '$in = pack("N*"'."\n";
1349              for ($i = 0; $i < $Nb; ++$i) {
1350                  $decrypt_block.= ',
1351                      ($'.$e.$i.                        ' & 0xFF000000) ^
1352                      ($'.$e.(($Nb + $i - $c[1]) % $Nb).' & 0x00FF0000) ^
1353                      ($'.$e.(($Nb + $i - $c[2]) % $Nb).' & 0x0000FF00) ^
1354                      ($'.$e.(($Nb + $i - $c[3]) % $Nb).' & 0x000000FF) ^
1355                      '.$dw[$i]."\n";
1356              }
1357              $decrypt_block .= ');';
1358  
1359              $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
1360                  array(
1361                     'init_crypt'    => '',
1362                     'init_encrypt'  => $init_encrypt,
1363                     'init_decrypt'  => $init_decrypt,
1364                     'encrypt_block' => $encrypt_block,
1365                     'decrypt_block' => $decrypt_block
1366                  )
1367              );
1368          }
1369          $this->inline_crypt = $lambda_functions[$code_hash];
1370      }
1371  }
1372  
1373  // vim: ts=4:sw=4:et:
1374  // vim6: fdl=1: