nilsteampassnet / TeamPass

includes/libraries/phpcrypt/ciphers/CAST256.php

Doc Comments +2 added lines, -2 removed lines

@@ -237,7 +237,7 @@ 
 	/**
 	 * CAST-256 F2 function
 	 *
-	 * @param $d integer The the data input
+	 * @param integer $d integer The the data input
 	 * @param $m integer The 32 bit masking key
 	 * @param $r integer The round number
 	 * @return integer The value after the F2 calculation
@@ -258,7 +258,7 @@ 
 	/**
 	 * CAST-256 F3 function
 	 *
-	 * @param $d integer The the data input
+	 * @param integer $d integer The the data input
 	 * @param $m integer The 32 bit masking key
 	 * @param $r integer The round number
 	 * @return integer The value after the F3 calculation

Indentation +614 added lines, -614 removed lines

@@ -38,619 +38,619 @@
  */
 class Cipher_CAST_256 extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 16; // 128 bits;
-
-	//const BYTES_KEY = 0; // between 128, 160, 192, 224, 256 bits
-
-	/** @type integer BYTES_KEY_MAX The max key size, in bytes */
-	const BYTES_KEY_MAX = 32;
-
-	/** @type array $_s1 An array of 256 unsigned integers */
-	private static $_s1 = array();
-
-	/** @type array $_s2 An array of 256 unsigned integers */
-	private static $_s2 = array();
-
-	/** @type array $_s3 An array of 256 unsigned integers */
-	private static $_s3 = array();
-
-	/** @type array $_s4 An array of 256 unsigned integers */
-	private static $_s4 = array();
-
-	private static $_req_key_sizes = array(16, 20, 24, 28, 32);
-
-	/** @type string $_mkey The 16 byte masking subkey */
-	private $_mkey = array();
-
-	/** @type string $_rkey The 16 byte rotate subkey */
-	private $_rkey = array();
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		$keylen = strlen($key);
-
-		if($keylen > self::BYTES_KEY_MAX)
-		{
-			$key = substr($key, 0, self::BYTES_KEY_MAX);
-			$keylen = self::BYTES_KEY_MAX;
-		}
-		else if(!in_array($keylen, self::$_req_key_sizes))
-		{
-			$msg  = PHP_Crypt::CIPHER_CAST_256." requires a key size of 16, ";
-			$msg .= "20, 24, 28, or 32 bytes.";
-			trigger_error($msg, E_USER_WARNING);
-		}
-
-		// set the key, make sure the required length is set in bytes
-		parent::__construct(PHP_Crypt::CIPHER_CAST_256, $key, $keylen);
-
-		// set the block size
-		$this->blockSize(self::BYTES_BLOCK);
-
-		// initialize the sboxes constants
-		$this->initTables();
-
-		// create the sub keys using the sboxes
-		$this->createSubKeys();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data
-	 *
-	 * @param string $data A 128 bit block of plain data
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$data)
-	{
-		$this->operation(parent::ENCRYPT);
-
-		// first split the data into four 32 bit blocks, reverse
-		// the string order of each block, convert the blocks of data to integers
-		$data = str_split($data, 4);
-		$data = array_map("strrev", $data);
-		$data = array_map("parent::str2Dec", $data);
-
-		// do the first 6 loops
-		for($i = 0; $i < 6; ++$i)
-		{
-
-			$data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
-			$data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
-			$data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
-			$data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
-		}
-
-		// the second 6 loops are done in a different order
-		for($i = 6; $i < 12; ++$i)
-		{
-
-			$data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
-			$data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
-			$data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
-			$data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
-		}
-
-		// convert the decimals back to a string, reverse the string so it's
-		// in the correct order
-		$data = array_map(function($v) {
-			$v = Core::dec2Str($v, 4);
-			return strrev($v);
-		}, $data);
-
-		// glue the string back together
-		$data = implode("", $data);
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt an encrypted string, it does all the steps of encryption,
-	 * but in reverse.
-	 *
-	 * @param string $data A 128 bit block of encrypted data
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$data)
-	{
-		$this->operation(parent::DECRYPT);
-
-		// first split the data into four 32 bit blocks, reverse
-		// the string order of each block, convert the blocks of data to integers
-		$data = str_split($data, 4);
-		$data = array_map("strrev", $data);
-		$data = array_map("parent::str2Dec", $data);
-
-		// do the first 6 loops
-		for($i = 11; $i >= 6; --$i)
-		{
-			$data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
-			$data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
-			$data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
-			$data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
-		}
-
-		// the second 6 loops are done in a different order
-		for($i = 5; $i >= 0; --$i)
-		{
-			$data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
-			$data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
-			$data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
-			$data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
-		}
-
-		// convert the decimals back to a string, reverse the string so it's
-		// in the correct order
-		$data = array_map(function($v) {
-			$v = Core::dec2Str($v, 4);
-			return strrev($v);
-		}, $data);
-
-		// glue the string back together
-		$data = implode("", $data);
-
-		return true;
-	}
-
-
-	/**
-	 * CAST-256 F1 function
-	 *
-	 * @param $d integer The the data input
-	 * @param $m integer The 32 bit masking key
-	 * @param $r integer The round number
-	 * @return integer The value after the F1 calculation
-	 */
-	private function f1($d, $m, $r)
-	{
-		$n = parent::uInt32($m + $d);
-		$n = parent::uInt32(parent::rotBitsLeft32($n, $r));
-		$n = parent::dec2Str($n, 4);
-
-		return parent::uInt32(
-				((self::$_s1[ord($n[0])] ^ self::$_s2[ord($n[1])]) -
-				self::$_s3[ord($n[2])]) + self::$_s4[ord($n[3])]
-			);
-	}
-
-
-	/**
-	 * CAST-256 F2 function
-	 *
-	 * @param $d integer The the data input
-	 * @param $m integer The 32 bit masking key
-	 * @param $r integer The round number
-	 * @return integer The value after the F2 calculation
-	 */
-	private function f2($d, $m, $r)
-	{
-		$n = parent::uInt32($m ^ $d);
-		$n = parent::uInt32(parent::rotBitsLeft32($n, $r));
-		$n = parent::dec2Str($n, 4);
-
-		return parent::uInt32(
-				((self::$_s1[ord($n[0])] - self::$_s2[ord($n[1])]) +
-				self::$_s3[ord($n[2])]) ^ self::$_s4[ord($n[3])]
-			);
-	}
-
-
-	/**
-	 * CAST-256 F3 function
-	 *
-	 * @param $d integer The the data input
-	 * @param $m integer The 32 bit masking key
-	 * @param $r integer The round number
-	 * @return integer The value after the F3 calculation
-	 */
-	private function f3($d, $m, $r)
-	{
-		$n = parent::uInt32($m - $d);
-		$n = parent::uInt32(parent::rotBitsLeft32($n, $r));
-		$n = parent::dec2Str($n, 4);
-
-		return parent::uInt32(
-				((self::$_s1[ord($n[0])] + self::$_s2[ord($n[1])]) ^
-				self::$_s3[ord($n[2])]) - self::$_s4[ord($n[3])]
-			);
-	}
-
-
-	/**
-	 * Creates the subkeys $_mkey (the masking key) and
-	 * $_rkey (the rotate key) which are 16 bytes each. These are
-	 * created from the original key. The original key is null
-	 * padded up to 16 bytes and expanded to 32 bytes. It is then
-	 * split in half to create $_mkey and $_rkey
-	 *
-	 * @return void
-	 */
-	private function createSubKeys()
-	{
-		$cm = 0x5A827999;
-		$mm = 0x6ED9EBA1;
-		$cr = 19;
-		$mr = 17;
-		$tm = array();
-		$tr = array();
-		$xkey = $this->key();
-		$tmpkey = array();
-
-		// if the key is less than 32 bytes, pad it to 32 bytes
-		// for the key expansion
-		if($this->keySize() < 32)
-			$xkey = str_pad($xkey, 32, "\0", STR_PAD_RIGHT);
-
-		// split the key up into 4 byte parts, reverse the string,
-		// then convert each part into a 32 bit integer
-		$xkey = str_split($xkey, 4);
-		$xkey = array_map("strrev", $xkey);
-		$xkey = array_map("parent::str2Dec", $xkey);
-
-		// set up the values need for creating round and masking keys
-		for($i = 0; $i < 24; ++$i)
-		{
-			$tm[$i] = array();
-			$tr[$i] = array();
-
-			for($j = 0; $j < 8; ++$j)
-			{
-				$tm[$i][$j] = $cm;
-				$cm = parent::uInt32($cm + $mm);
-				$tr[$i][$j] = $cr;
-				$cr = parent::uInt32($cr + $mr);
-			}
-		}
-
-		// now create the round and masking keys
-		for($i = 0; $i < 12; ++$i)
-		{
-			$j = 2 * $i;
-
-			$xkey[6] = parent::uInt32($xkey[6] ^ $this->f1($xkey[7], $tm[$j][0], $tr[$j][0]));
-			$xkey[5] = parent::uInt32($xkey[5] ^ $this->f2($xkey[6], $tm[$j][1], $tr[$j][1]));
-			$xkey[4] = parent::uInt32($xkey[4] ^ $this->f3($xkey[5], $tm[$j][2], $tr[$j][2]));
-			$xkey[3] = parent::uInt32($xkey[3] ^ $this->f1($xkey[4], $tm[$j][3], $tr[$j][3]));
-			$xkey[2] = parent::uInt32($xkey[2] ^ $this->f2($xkey[3], $tm[$j][4], $tr[$j][4]));
-			$xkey[1] = parent::uInt32($xkey[1] ^ $this->f3($xkey[2], $tm[$j][5], $tr[$j][5]));
-			$xkey[0] = parent::uInt32($xkey[0] ^ $this->f1($xkey[1], $tm[$j][6], $tr[$j][6]));
-			$xkey[7] = parent::uInt32($xkey[7] ^ $this->f2($xkey[0], $tm[$j][7], $tr[$j][7]));
-
-			$j =  (2 * $i) + 1;
-			$xkey[6] = parent::uInt32($xkey[6] ^ $this->f1($xkey[7], $tm[$j][0], $tr[$j][0]));
-			$xkey[5] = parent::uInt32($xkey[5] ^ $this->f2($xkey[6], $tm[$j][1], $tr[$j][1]));
-			$xkey[4] = parent::uInt32($xkey[4] ^ $this->f3($xkey[5], $tm[$j][2], $tr[$j][2]));
-			$xkey[3] = parent::uInt32($xkey[3] ^ $this->f1($xkey[4], $tm[$j][3], $tr[$j][3]));
-			$xkey[2] = parent::uInt32($xkey[2] ^ $this->f2($xkey[3], $tm[$j][4], $tr[$j][4]));
-			$xkey[1] = parent::uInt32($xkey[1] ^ $this->f3($xkey[2], $tm[$j][5], $tr[$j][5]));
-			$xkey[0] = parent::uInt32($xkey[0] ^ $this->f1($xkey[1], $tm[$j][6], $tr[$j][6]));
-			$xkey[7] = parent::uInt32($xkey[7] ^ $this->f2($xkey[0], $tm[$j][7], $tr[$j][7]));
-
-			// take the least 5 significant bits of each $xkey byte below and assign it
-			// to the round key
-			$this->_rkey[$i][0] = $xkey[0] & 31;
-			$this->_rkey[$i][1] = $xkey[2] & 31;
-			$this->_rkey[$i][2] = $xkey[4] & 31;
-			$this->_rkey[$i][3] = $xkey[6] & 31;
-
-			// now create 32 byte masking keys
-			$this->_mkey[$i][0] = $xkey[7];
-			$this->_mkey[$i][1] = $xkey[5];
-			$this->_mkey[$i][2] = $xkey[3];
-			$this->_mkey[$i][3] = $xkey[1];
-		}
-	}
-
-
-	/**
-	 * Initialize the tables
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		// 256 unsigned 32 bit integers
-		self::$_s1 = array(
-			0x30FB40D4, 0x9FA0FF0B, 0x6BECCD2F, 0x3F258C7A,
-			0x1E213F2F, 0x9C004DD3, 0x6003E540, 0xCF9FC949,
-			0xBFD4AF27, 0x88BBBDB5, 0xE2034090, 0x98D09675,
-			0x6E63A0E0, 0x15C361D2, 0xC2E7661D, 0x22D4FF8E,
-			0x28683B6F, 0xC07FD059, 0xFF2379C8, 0x775F50E2,
-			0x43C340D3, 0xDF2F8656, 0x887CA41A, 0xA2D2BD2D,
-			0xA1C9E0D6, 0x346C4819, 0x61B76D87, 0x22540F2F,
-			0x2ABE32E1, 0xAA54166B, 0x22568E3A, 0xA2D341D0,
-			0x66DB40C8, 0xA784392F, 0x004DFF2F, 0x2DB9D2DE,
-			0x97943FAC, 0x4A97C1D8, 0x527644B7, 0xB5F437A7,
-			0xB82CBAEF, 0xD751D159, 0x6FF7F0ED, 0x5A097A1F,
-			0x827B68D0, 0x90ECF52E, 0x22B0C054, 0xBC8E5935,
-			0x4B6D2F7F, 0x50BB64A2, 0xD2664910, 0xBEE5812D,
-			0xB7332290, 0xE93B159F, 0xB48EE411, 0x4BFF345D,
-			0xFD45C240, 0xAD31973F, 0xC4F6D02E, 0x55FC8165,
-			0xD5B1CAAD, 0xA1AC2DAE, 0xA2D4B76D, 0xC19B0C50,
-			0x882240F2, 0x0C6E4F38, 0xA4E4BFD7, 0x4F5BA272,
-			0x564C1D2F, 0xC59C5319, 0xB949E354, 0xB04669FE,
-			0xB1B6AB8A, 0xC71358DD, 0x6385C545, 0x110F935D,
-			0x57538AD5, 0x6A390493, 0xE63D37E0, 0x2A54F6B3,
-			0x3A787D5F, 0x6276A0B5, 0x19A6FCDF, 0x7A42206A,
-			0x29F9D4D5, 0xF61B1891, 0xBB72275E, 0xAA508167,
-			0x38901091, 0xC6B505EB, 0x84C7CB8C, 0x2AD75A0F,
-			0x874A1427, 0xA2D1936B, 0x2AD286AF, 0xAA56D291,
-			0xD7894360, 0x425C750D, 0x93B39E26, 0x187184C9,
-			0x6C00B32D, 0x73E2BB14, 0xA0BEBC3C, 0x54623779,
-			0x64459EAB, 0x3F328B82, 0x7718CF82, 0x59A2CEA6,
-			0x04EE002E, 0x89FE78E6, 0x3FAB0950, 0x325FF6C2,
-			0x81383F05, 0x6963C5C8, 0x76CB5AD6, 0xD49974C9,
-			0xCA180DCF, 0x380782D5, 0xC7FA5CF6, 0x8AC31511,
-			0x35E79E13, 0x47DA91D0, 0xF40F9086, 0xA7E2419E,
-			0x31366241, 0x051EF495, 0xAA573B04, 0x4A805D8D,
-			0x548300D0, 0x00322A3C, 0xBF64CDDF, 0xBA57A68E,
-			0x75C6372B, 0x50AFD341, 0xA7C13275, 0x915A0BF5,
-			0x6B54BFAB, 0x2B0B1426, 0xAB4CC9D7, 0x449CCD82,
-			0xF7FBF265, 0xAB85C5F3, 0x1B55DB94, 0xAAD4E324,
-			0xCFA4BD3F, 0x2DEAA3E2, 0x9E204D02, 0xC8BD25AC,
-			0xEADF55B3, 0xD5BD9E98, 0xE31231B2, 0x2AD5AD6C,
-			0x954329DE, 0xADBE4528, 0xD8710F69, 0xAA51C90F,
-			0xAA786BF6, 0x22513F1E, 0xAA51A79B, 0x2AD344CC,
-			0x7B5A41F0, 0xD37CFBAD, 0x1B069505, 0x41ECE491,
-			0xB4C332E6, 0x032268D4, 0xC9600ACC, 0xCE387E6D,
-			0xBF6BB16C, 0x6A70FB78, 0x0D03D9C9, 0xD4DF39DE,
-			0xE01063DA, 0x4736F464, 0x5AD328D8, 0xB347CC96,
-			0x75BB0FC3, 0x98511BFB, 0x4FFBCC35, 0xB58BCF6A,
-			0xE11F0ABC, 0xBFC5FE4A, 0xA70AEC10, 0xAC39570A,
-			0x3F04442F, 0x6188B153, 0xE0397A2E, 0x5727CB79,
-			0x9CEB418F, 0x1CACD68D, 0x2AD37C96, 0x0175CB9D,
-			0xC69DFF09, 0xC75B65F0, 0xD9DB40D8, 0xEC0E7779,
-			0x4744EAD4, 0xB11C3274, 0xDD24CB9E, 0x7E1C54BD,
-			0xF01144F9, 0xD2240EB1, 0x9675B3FD, 0xA3AC3755,
-			0xD47C27AF, 0x51C85F4D, 0x56907596, 0xA5BB15E6,
-			0x580304F0, 0xCA042CF1, 0x011A37EA, 0x8DBFAADB,
-			0x35BA3E4A, 0x3526FFA0, 0xC37B4D09, 0xBC306ED9,
-			0x98A52666, 0x5648F725, 0xFF5E569D, 0x0CED63D0,
-			0x7C63B2CF, 0x700B45E1, 0xD5EA50F1, 0x85A92872,
-			0xAF1FBDA7, 0xD4234870, 0xA7870BF3, 0x2D3B4D79,
-			0x42E04198, 0x0CD0EDE7, 0x26470DB8, 0xF881814C,
-			0x474D6AD7, 0x7C0C5E5C, 0xD1231959, 0x381B7298,
-			0xF5D2F4DB, 0xAB838653, 0x6E2F1E23, 0x83719C9E,
-			0xBD91E046, 0x9A56456E, 0xDC39200C, 0x20C8C571,
-			0x962BDA1C, 0xE1E696FF, 0xB141AB08, 0x7CCA89B9,
-			0x1A69E783, 0x02CC4843, 0xA2F7C579, 0x429EF47D,
-			0x427B169C, 0x5AC9F049, 0xDD8F0F00, 0x5C8165BF
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s2 = array(
-			0x1F201094, 0xEF0BA75B, 0x69E3CF7E, 0x393F4380,
-			0xFE61CF7A, 0xEEC5207A, 0x55889C94, 0x72FC0651,
-			0xADA7EF79, 0x4E1D7235, 0xD55A63CE, 0xDE0436BA,
-			0x99C430EF, 0x5F0C0794, 0x18DCDB7D, 0xA1D6EFF3,
-			0xA0B52F7B, 0x59E83605, 0xEE15B094, 0xE9FFD909,
-			0xDC440086, 0xEF944459, 0xBA83CCB3, 0xE0C3CDFB,
-			0xD1DA4181, 0x3B092AB1, 0xF997F1C1, 0xA5E6CF7B,
-			0x01420DDB, 0xE4E7EF5B, 0x25A1FF41, 0xE180F806,
-			0x1FC41080, 0x179BEE7A, 0xD37AC6A9, 0xFE5830A4,
-			0x98DE8B7F, 0x77E83F4E, 0x79929269, 0x24FA9F7B,
-			0xE113C85B, 0xACC40083, 0xD7503525, 0xF7EA615F,
-			0x62143154, 0x0D554B63, 0x5D681121, 0xC866C359,
-			0x3D63CF73, 0xCEE234C0, 0xD4D87E87, 0x5C672B21,
-			0x071F6181, 0x39F7627F, 0x361E3084, 0xE4EB573B,
-			0x602F64A4, 0xD63ACD9C, 0x1BBC4635, 0x9E81032D,
-			0x2701F50C, 0x99847AB4, 0xA0E3DF79, 0xBA6CF38C,
-			0x10843094, 0x2537A95E, 0xF46F6FFE, 0xA1FF3B1F,
-			0x208CFB6A, 0x8F458C74, 0xD9E0A227, 0x4EC73A34,
-			0xFC884F69, 0x3E4DE8DF, 0xEF0E0088, 0x3559648D,
-			0x8A45388C, 0x1D804366, 0x721D9BFD, 0xA58684BB,
-			0xE8256333, 0x844E8212, 0x128D8098, 0xFED33FB4,
-			0xCE280AE1, 0x27E19BA5, 0xD5A6C252, 0xE49754BD,
-			0xC5D655DD, 0xEB667064, 0x77840B4D, 0xA1B6A801,
-			0x84DB26A9, 0xE0B56714, 0x21F043B7, 0xE5D05860,
-			0x54F03084, 0x066FF472, 0xA31AA153, 0xDADC4755,
-			0xB5625DBF, 0x68561BE6, 0x83CA6B94, 0x2D6ED23B,
-			0xECCF01DB, 0xA6D3D0BA, 0xB6803D5C, 0xAF77A709,
-			0x33B4A34C, 0x397BC8D6, 0x5EE22B95, 0x5F0E5304,
-			0x81ED6F61, 0x20E74364, 0xB45E1378, 0xDE18639B,
-			0x881CA122, 0xB96726D1, 0x8049A7E8, 0x22B7DA7B,
-			0x5E552D25, 0x5272D237, 0x79D2951C, 0xC60D894C,
-			0x488CB402, 0x1BA4FE5B, 0xA4B09F6B, 0x1CA815CF,
-			0xA20C3005, 0x8871DF63, 0xB9DE2FCB, 0x0CC6C9E9,
-			0x0BEEFF53, 0xE3214517, 0xB4542835, 0x9F63293C,
-			0xEE41E729, 0x6E1D2D7C, 0x50045286, 0x1E6685F3,
-			0xF33401C6, 0x30A22C95, 0x31A70850, 0x60930F13,
-			0x73F98417, 0xA1269859, 0xEC645C44, 0x52C877A9,
-			0xCDFF33A6, 0xA02B1741, 0x7CBAD9A2, 0x2180036F,
-			0x50D99C08, 0xCB3F4861, 0xC26BD765, 0x64A3F6AB,
-			0x80342676, 0x25A75E7B, 0xE4E6D1FC, 0x20C710E6,
-			0xCDF0B680, 0x17844D3B, 0x31EEF84D, 0x7E0824E4,
-			0x2CCB49EB, 0x846A3BAE, 0x8FF77888, 0xEE5D60F6,
-			0x7AF75673, 0x2FDD5CDB, 0xA11631C1, 0x30F66F43,
-			0xB3FAEC54, 0x157FD7FA, 0xEF8579CC, 0xD152DE58,
-			0xDB2FFD5E, 0x8F32CE19, 0x306AF97A, 0x02F03EF8,
-			0x99319AD5, 0xC242FA0F, 0xA7E3EBB0, 0xC68E4906,
-			0xB8DA230C, 0x80823028, 0xDCDEF3C8, 0xD35FB171,
-			0x088A1BC8, 0xBEC0C560, 0x61A3C9E8, 0xBCA8F54D,
-			0xC72FEFFA, 0x22822E99, 0x82C570B4, 0xD8D94E89,
-			0x8B1C34BC, 0x301E16E6, 0x273BE979, 0xB0FFEAA6,
-			0x61D9B8C6, 0x00B24869, 0xB7FFCE3F, 0x08DC283B,
-			0x43DAF65A, 0xF7E19798, 0x7619B72F, 0x8F1C9BA4,
-			0xDC8637A0, 0x16A7D3B1, 0x9FC393B7, 0xA7136EEB,
-			0xC6BCC63E, 0x1A513742, 0xEF6828BC, 0x520365D6,
-			0x2D6A77AB, 0x3527ED4B, 0x821FD216, 0x095C6E2E,
-			0xDB92F2FB, 0x5EEA29CB, 0x145892F5, 0x91584F7F,
-			0x5483697B, 0x2667A8CC, 0x85196048, 0x8C4BACEA,
-			0x833860D4, 0x0D23E0F9, 0x6C387E8A, 0x0AE6D249,
-			0xB284600C, 0xD835731D, 0xDCB1C647, 0xAC4C56EA,
-			0x3EBD81B3, 0x230EABB0, 0x6438BC87, 0xF0B5B1FA,
-			0x8F5EA2B3, 0xFC184642, 0x0A036B7A, 0x4FB089BD,
-			0x649DA589, 0xA345415E, 0x5C038323, 0x3E5D3BB9,
-			0x43D79572, 0x7E6DD07C, 0x06DFDF1E, 0x6C6CC4EF,
-			0x7160A539, 0x73BFBE70, 0x83877605, 0x4523ECF1
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s3 = array(
-			0x8DEFC240, 0x25FA5D9F, 0xEB903DBF, 0xE810C907,
-			0x47607FFF, 0x369FE44B, 0x8C1FC644, 0xAECECA90,
-			0xBEB1F9BF, 0xEEFBCAEA, 0xE8CF1950, 0x51DF07AE,
-			0x920E8806, 0xF0AD0548, 0xE13C8D83, 0x927010D5,
-			0x11107D9F, 0x07647DB9, 0xB2E3E4D4, 0x3D4F285E,
-			0xB9AFA820, 0xFADE82E0, 0xA067268B, 0x8272792E,
-			0x553FB2C0, 0x489AE22B, 0xD4EF9794, 0x125E3FBC,
-			0x21FFFCEE, 0x825B1BFD, 0x9255C5ED, 0x1257A240,
-			0x4E1A8302, 0xBAE07FFF, 0x528246E7, 0x8E57140E,
-			0x3373F7BF, 0x8C9F8188, 0xA6FC4EE8, 0xC982B5A5,
-			0xA8C01DB7, 0x579FC264, 0x67094F31, 0xF2BD3F5F,
-			0x40FFF7C1, 0x1FB78DFC, 0x8E6BD2C1, 0x437BE59B,
-			0x99B03DBF, 0xB5DBC64B, 0x638DC0E6, 0x55819D99,
-			0xA197C81C, 0x4A012D6E, 0xC5884A28, 0xCCC36F71,
-			0xB843C213, 0x6C0743F1, 0x8309893C, 0x0FEDDD5F,
-			0x2F7FE850, 0xD7C07F7E, 0x02507FBF, 0x5AFB9A04,
-			0xA747D2D0, 0x1651192E, 0xAF70BF3E, 0x58C31380,
-			0x5F98302E, 0x727CC3C4, 0x0A0FB402, 0x0F7FEF82,
-			0x8C96FDAD, 0x5D2C2AAE, 0x8EE99A49, 0x50DA88B8,
-			0x8427F4A0, 0x1EAC5790, 0x796FB449, 0x8252DC15,
-			0xEFBD7D9B, 0xA672597D, 0xADA840D8, 0x45F54504,
-			0xFA5D7403, 0xE83EC305, 0x4F91751A, 0x925669C2,
-			0x23EFE941, 0xA903F12E, 0x60270DF2, 0x0276E4B6,
-			0x94FD6574, 0x927985B2, 0x8276DBCB, 0x02778176,
-			0xF8AF918D, 0x4E48F79E, 0x8F616DDF, 0xE29D840E,
-			0x842F7D83, 0x340CE5C8, 0x96BBB682, 0x93B4B148,
-			0xEF303CAB, 0x984FAF28, 0x779FAF9B, 0x92DC560D,
-			0x224D1E20, 0x8437AA88, 0x7D29DC96, 0x2756D3DC,
-			0x8B907CEE, 0xB51FD240, 0xE7C07CE3, 0xE566B4A1,
-			0xC3E9615E, 0x3CF8209D, 0x6094D1E3, 0xCD9CA341,
-			0x5C76460E, 0x00EA983B, 0xD4D67881, 0xFD47572C,
-			0xF76CEDD9, 0xBDA8229C, 0x127DADAA, 0x438A074E,
-			0x1F97C090, 0x081BDB8A, 0x93A07EBE, 0xB938CA15,
-			0x97B03CFF, 0x3DC2C0F8, 0x8D1AB2EC, 0x64380E51,
-			0x68CC7BFB, 0xD90F2788, 0x12490181, 0x5DE5FFD4,
-			0xDD7EF86A, 0x76A2E214, 0xB9A40368, 0x925D958F,
-			0x4B39FFFA, 0xBA39AEE9, 0xA4FFD30B, 0xFAF7933B,
-			0x6D498623, 0x193CBCFA, 0x27627545, 0x825CF47A,
-			0x61BD8BA0, 0xD11E42D1, 0xCEAD04F4, 0x127EA392,
-			0x10428DB7, 0x8272A972, 0x9270C4A8, 0x127DE50B,
-			0x285BA1C8, 0x3C62F44F, 0x35C0EAA5, 0xE805D231,
-			0x428929FB, 0xB4FCDF82, 0x4FB66A53, 0x0E7DC15B,
-			0x1F081FAB, 0x108618AE, 0xFCFD086D, 0xF9FF2889,
-			0x694BCC11, 0x236A5CAE, 0x12DECA4D, 0x2C3F8CC5,
-			0xD2D02DFE, 0xF8EF5896, 0xE4CF52DA, 0x95155B67,
-			0x494A488C, 0xB9B6A80C, 0x5C8F82BC, 0x89D36B45,
-			0x3A609437, 0xEC00C9A9, 0x44715253, 0x0A874B49,
-			0xD773BC40, 0x7C34671C, 0x02717EF6, 0x4FEB5536,
-			0xA2D02FFF, 0xD2BF60C4, 0xD43F03C0, 0x50B4EF6D,
-			0x07478CD1, 0x006E1888, 0xA2E53F55, 0xB9E6D4BC,
-			0xA2048016, 0x97573833, 0xD7207D67, 0xDE0F8F3D,
-			0x72F87B33, 0xABCC4F33, 0x7688C55D, 0x7B00A6B0,
-			0x947B0001, 0x570075D2, 0xF9BB88F8, 0x8942019E,
-			0x4264A5FF, 0x856302E0, 0x72DBD92B, 0xEE971B69,
-			0x6EA22FDE, 0x5F08AE2B, 0xAF7A616D, 0xE5C98767,
-			0xCF1FEBD2, 0x61EFC8C2, 0xF1AC2571, 0xCC8239C2,
-			0x67214CB8, 0xB1E583D1, 0xB7DC3E62, 0x7F10BDCE,
-			0xF90A5C38, 0x0FF0443D, 0x606E6DC6, 0x60543A49,
-			0x5727C148, 0x2BE98A1D, 0x8AB41738, 0x20E1BE24,
-			0xAF96DA0F, 0x68458425, 0x99833BE5, 0x600D457D,
-			0x282F9350, 0x8334B362, 0xD91D1120, 0x2B6D8DA0,
-			0x642B1E31, 0x9C305A00, 0x52BCE688, 0x1B03588A,
-			0xF7BAEFD5, 0x4142ED9C, 0xA4315C11, 0x83323EC5,
-			0xDFEF4636, 0xA133C501, 0xE9D3531C, 0xEE353783
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s4 = array(
-			0x9DB30420, 0x1FB6E9DE, 0xA7BE7BEF, 0xD273A298,
-			0x4A4F7BDB, 0x64AD8C57, 0x85510443, 0xFA020ED1,
-			0x7E287AFF, 0xE60FB663, 0x095F35A1, 0x79EBF120,
-			0xFD059D43, 0x6497B7B1, 0xF3641F63, 0x241E4ADF,
-			0x28147F5F, 0x4FA2B8CD, 0xC9430040, 0x0CC32220,
-			0xFDD30B30, 0xC0A5374F, 0x1D2D00D9, 0x24147B15,
-			0xEE4D111A, 0x0FCA5167, 0x71FF904C, 0x2D195FFE,
-			0x1A05645F, 0x0C13FEFE, 0x081B08CA, 0x05170121,
-			0x80530100, 0xE83E5EFE, 0xAC9AF4F8, 0x7FE72701,
-			0xD2B8EE5F, 0x06DF4261, 0xBB9E9B8A, 0x7293EA25,
-			0xCE84FFDF, 0xF5718801, 0x3DD64B04, 0xA26F263B,
-			0x7ED48400, 0x547EEBE6, 0x446D4CA0, 0x6CF3D6F5,
-			0x2649ABDF, 0xAEA0C7F5, 0x36338CC1, 0x503F7E93,
-			0xD3772061, 0x11B638E1, 0x72500E03, 0xF80EB2BB,
-			0xABE0502E, 0xEC8D77DE, 0x57971E81, 0xE14F6746,
-			0xC9335400, 0x6920318F, 0x081DBB99, 0xFFC304A5,
-			0x4D351805, 0x7F3D5CE3, 0xA6C866C6, 0x5D5BCCA9,
-			0xDAEC6FEA, 0x9F926F91, 0x9F46222F, 0x3991467D,
-			0xA5BF6D8E, 0x1143C44F, 0x43958302, 0xD0214EEB,
-			0x022083B8, 0x3FB6180C, 0x18F8931E, 0x281658E6,
-			0x26486E3E, 0x8BD78A70, 0x7477E4C1, 0xB506E07C,
-			0xF32D0A25, 0x79098B02, 0xE4EABB81, 0x28123B23,
-			0x69DEAD38, 0x1574CA16, 0xDF871B62, 0x211C40B7,
-			0xA51A9EF9, 0x0014377B, 0x041E8AC8, 0x09114003,
-			0xBD59E4D2, 0xE3D156D5, 0x4FE876D5, 0x2F91A340,
-			0x557BE8DE, 0x00EAE4A7, 0x0CE5C2EC, 0x4DB4BBA6,
-			0xE756BDFF, 0xDD3369AC, 0xEC17B035, 0x06572327,
-			0x99AFC8B0, 0x56C8C391, 0x6B65811C, 0x5E146119,
-			0x6E85CB75, 0xBE07C002, 0xC2325577, 0x893FF4EC,
-			0x5BBFC92D, 0xD0EC3B25, 0xB7801AB7, 0x8D6D3B24,
-			0x20C763EF, 0xC366A5FC, 0x9C382880, 0x0ACE3205,
-			0xAAC9548A, 0xECA1D7C7, 0x041AFA32, 0x1D16625A,
-			0x6701902C, 0x9B757A54, 0x31D477F7, 0x9126B031,
-			0x36CC6FDB, 0xC70B8B46, 0xD9E66A48, 0x56E55A79,
-			0x026A4CEB, 0x52437EFF, 0x2F8F76B4, 0x0DF980A5,
-			0x8674CDE3, 0xEDDA04EB, 0x17A9BE04, 0x2C18F4DF,
-			0xB7747F9D, 0xAB2AF7B4, 0xEFC34D20, 0x2E096B7C,
-			0x1741A254, 0xE5B6A035, 0x213D42F6, 0x2C1C7C26,
-			0x61C2F50F, 0x6552DAF9, 0xD2C231F8, 0x25130F69,
-			0xD8167FA2, 0x0418F2C8, 0x001A96A6, 0x0D1526AB,
-			0x63315C21, 0x5E0A72EC, 0x49BAFEFD, 0x187908D9,
-			0x8D0DBD86, 0x311170A7, 0x3E9B640C, 0xCC3E10D7,
-			0xD5CAD3B6, 0x0CAEC388, 0xF73001E1, 0x6C728AFF,
-			0x71EAE2A1, 0x1F9AF36E, 0xCFCBD12F, 0xC1DE8417,
-			0xAC07BE6B, 0xCB44A1D8, 0x8B9B0F56, 0x013988C3,
-			0xB1C52FCA, 0xB4BE31CD, 0xD8782806, 0x12A3A4E2,
-			0x6F7DE532, 0x58FD7EB6, 0xD01EE900, 0x24ADFFC2,
-			0xF4990FC5, 0x9711AAC5, 0x001D7B95, 0x82E5E7D2,
-			0x109873F6, 0x00613096, 0xC32D9521, 0xADA121FF,
-			0x29908415, 0x7FBB977F, 0xAF9EB3DB, 0x29C9ED2A,
-			0x5CE2A465, 0xA730F32C, 0xD0AA3FE8, 0x8A5CC091,
-			0xD49E2CE7, 0x0CE454A9, 0xD60ACD86, 0x015F1919,
-			0x77079103, 0xDEA03AF6, 0x78A8565E, 0xDEE356DF,
-			0x21F05CBE, 0x8B75E387, 0xB3C50651, 0xB8A5C3EF,
-			0xD8EEB6D2, 0xE523BE77, 0xC2154529, 0x2F69EFDF,
-			0xAFE67AFB, 0xF470C4B2, 0xF3E0EB5B, 0xD6CC9876,
-			0x39E4460C, 0x1FDA8538, 0x1987832F, 0xCA007367,
-			0xA99144F8, 0x296B299E, 0x492FC295, 0x9266BEAB,
-			0xB5676E69, 0x9BD3DDDA, 0xDF7E052F, 0xDB25701C,
-			0x1B5E51EE, 0xF65324E6, 0x6AFCE36C, 0x0316CC04,
-			0x8644213E, 0xB7DC59D0, 0x7965291F, 0xCCD6FD43,
-			0x41823979, 0x932BCDF6, 0xB657C34D, 0x4EDFD282,
-			0x7AE5290C, 0x3CB9536B, 0x851E20FE, 0x9833557E,
-			0x13ECF0B0, 0xD3FFB372, 0x3F85C5C1, 0x0AEF7ED2
-		);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 16; // 128 bits;
+
+    //const BYTES_KEY = 0; // between 128, 160, 192, 224, 256 bits
+
+    /** @type integer BYTES_KEY_MAX The max key size, in bytes */
+    const BYTES_KEY_MAX = 32;
+
+    /** @type array $_s1 An array of 256 unsigned integers */
+    private static $_s1 = array();
+
+    /** @type array $_s2 An array of 256 unsigned integers */
+    private static $_s2 = array();
+
+    /** @type array $_s3 An array of 256 unsigned integers */
+    private static $_s3 = array();
+
+    /** @type array $_s4 An array of 256 unsigned integers */
+    private static $_s4 = array();
+
+    private static $_req_key_sizes = array(16, 20, 24, 28, 32);
+
+    /** @type string $_mkey The 16 byte masking subkey */
+    private $_mkey = array();
+
+    /** @type string $_rkey The 16 byte rotate subkey */
+    private $_rkey = array();
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        $keylen = strlen($key);
+
+        if($keylen > self::BYTES_KEY_MAX)
+        {
+            $key = substr($key, 0, self::BYTES_KEY_MAX);
+            $keylen = self::BYTES_KEY_MAX;
+        }
+        else if(!in_array($keylen, self::$_req_key_sizes))
+        {
+            $msg  = PHP_Crypt::CIPHER_CAST_256." requires a key size of 16, ";
+            $msg .= "20, 24, 28, or 32 bytes.";
+            trigger_error($msg, E_USER_WARNING);
+        }
+
+        // set the key, make sure the required length is set in bytes
+        parent::__construct(PHP_Crypt::CIPHER_CAST_256, $key, $keylen);
+
+        // set the block size
+        $this->blockSize(self::BYTES_BLOCK);
+
+        // initialize the sboxes constants
+        $this->initTables();
+
+        // create the sub keys using the sboxes
+        $this->createSubKeys();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data
+     *
+     * @param string $data A 128 bit block of plain data
+     * @return boolean Returns true
+     */
+    public function encrypt(&$data)
+    {
+        $this->operation(parent::ENCRYPT);
+
+        // first split the data into four 32 bit blocks, reverse
+        // the string order of each block, convert the blocks of data to integers
+        $data = str_split($data, 4);
+        $data = array_map("strrev", $data);
+        $data = array_map("parent::str2Dec", $data);
+
+        // do the first 6 loops
+        for($i = 0; $i < 6; ++$i)
+        {
+
+            $data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
+            $data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
+            $data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
+            $data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
+        }
+
+        // the second 6 loops are done in a different order
+        for($i = 6; $i < 12; ++$i)
+        {
+
+            $data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
+            $data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
+            $data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
+            $data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
+        }
+
+        // convert the decimals back to a string, reverse the string so it's
+        // in the correct order
+        $data = array_map(function($v) {
+            $v = Core::dec2Str($v, 4);
+            return strrev($v);
+        }, $data);
+
+        // glue the string back together
+        $data = implode("", $data);
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt an encrypted string, it does all the steps of encryption,
+     * but in reverse.
+     *
+     * @param string $data A 128 bit block of encrypted data
+     * @return boolean Returns true
+     */
+    public function decrypt(&$data)
+    {
+        $this->operation(parent::DECRYPT);
+
+        // first split the data into four 32 bit blocks, reverse
+        // the string order of each block, convert the blocks of data to integers
+        $data = str_split($data, 4);
+        $data = array_map("strrev", $data);
+        $data = array_map("parent::str2Dec", $data);
+
+        // do the first 6 loops
+        for($i = 11; $i >= 6; --$i)
+        {
+            $data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
+            $data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
+            $data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
+            $data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
+        }
+
+        // the second 6 loops are done in a different order
+        for($i = 5; $i >= 0; --$i)
+        {
+            $data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
+            $data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
+            $data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
+            $data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
+        }
+
+        // convert the decimals back to a string, reverse the string so it's
+        // in the correct order
+        $data = array_map(function($v) {
+            $v = Core::dec2Str($v, 4);
+            return strrev($v);
+        }, $data);
+
+        // glue the string back together
+        $data = implode("", $data);
+
+        return true;
+    }
+
+
+    /**
+     * CAST-256 F1 function
+     *
+     * @param $d integer The the data input
+     * @param $m integer The 32 bit masking key
+     * @param $r integer The round number
+     * @return integer The value after the F1 calculation
+     */
+    private function f1($d, $m, $r)
+    {
+        $n = parent::uInt32($m + $d);
+        $n = parent::uInt32(parent::rotBitsLeft32($n, $r));
+        $n = parent::dec2Str($n, 4);
+
+        return parent::uInt32(
+                ((self::$_s1[ord($n[0])] ^ self::$_s2[ord($n[1])]) -
+                self::$_s3[ord($n[2])]) + self::$_s4[ord($n[3])]
+            );
+    }
+
+
+    /**
+     * CAST-256 F2 function
+     *
+     * @param $d integer The the data input
+     * @param $m integer The 32 bit masking key
+     * @param $r integer The round number
+     * @return integer The value after the F2 calculation
+     */
+    private function f2($d, $m, $r)
+    {
+        $n = parent::uInt32($m ^ $d);
+        $n = parent::uInt32(parent::rotBitsLeft32($n, $r));
+        $n = parent::dec2Str($n, 4);
+
+        return parent::uInt32(
+                ((self::$_s1[ord($n[0])] - self::$_s2[ord($n[1])]) +
+                self::$_s3[ord($n[2])]) ^ self::$_s4[ord($n[3])]
+            );
+    }
+
+
+    /**
+     * CAST-256 F3 function
+     *
+     * @param $d integer The the data input
+     * @param $m integer The 32 bit masking key
+     * @param $r integer The round number
+     * @return integer The value after the F3 calculation
+     */
+    private function f3($d, $m, $r)
+    {
+        $n = parent::uInt32($m - $d);
+        $n = parent::uInt32(parent::rotBitsLeft32($n, $r));
+        $n = parent::dec2Str($n, 4);
+
+        return parent::uInt32(
+                ((self::$_s1[ord($n[0])] + self::$_s2[ord($n[1])]) ^
+                self::$_s3[ord($n[2])]) - self::$_s4[ord($n[3])]
+            );
+    }
+
+
+    /**
+     * Creates the subkeys $_mkey (the masking key) and
+     * $_rkey (the rotate key) which are 16 bytes each. These are
+     * created from the original key. The original key is null
+     * padded up to 16 bytes and expanded to 32 bytes. It is then
+     * split in half to create $_mkey and $_rkey
+     *
+     * @return void
+     */
+    private function createSubKeys()
+    {
+        $cm = 0x5A827999;
+        $mm = 0x6ED9EBA1;
+        $cr = 19;
+        $mr = 17;
+        $tm = array();
+        $tr = array();
+        $xkey = $this->key();
+        $tmpkey = array();
+
+        // if the key is less than 32 bytes, pad it to 32 bytes
+        // for the key expansion
+        if($this->keySize() < 32)
+            $xkey = str_pad($xkey, 32, "\0", STR_PAD_RIGHT);
+
+        // split the key up into 4 byte parts, reverse the string,
+        // then convert each part into a 32 bit integer
+        $xkey = str_split($xkey, 4);
+        $xkey = array_map("strrev", $xkey);
+        $xkey = array_map("parent::str2Dec", $xkey);
+
+        // set up the values need for creating round and masking keys
+        for($i = 0; $i < 24; ++$i)
+        {
+            $tm[$i] = array();
+            $tr[$i] = array();
+
+            for($j = 0; $j < 8; ++$j)
+            {
+                $tm[$i][$j] = $cm;
+                $cm = parent::uInt32($cm + $mm);
+                $tr[$i][$j] = $cr;
+                $cr = parent::uInt32($cr + $mr);
+            }
+        }
+
+        // now create the round and masking keys
+        for($i = 0; $i < 12; ++$i)
+        {
+            $j = 2 * $i;
+
+            $xkey[6] = parent::uInt32($xkey[6] ^ $this->f1($xkey[7], $tm[$j][0], $tr[$j][0]));
+            $xkey[5] = parent::uInt32($xkey[5] ^ $this->f2($xkey[6], $tm[$j][1], $tr[$j][1]));
+            $xkey[4] = parent::uInt32($xkey[4] ^ $this->f3($xkey[5], $tm[$j][2], $tr[$j][2]));
+            $xkey[3] = parent::uInt32($xkey[3] ^ $this->f1($xkey[4], $tm[$j][3], $tr[$j][3]));
+            $xkey[2] = parent::uInt32($xkey[2] ^ $this->f2($xkey[3], $tm[$j][4], $tr[$j][4]));
+            $xkey[1] = parent::uInt32($xkey[1] ^ $this->f3($xkey[2], $tm[$j][5], $tr[$j][5]));
+            $xkey[0] = parent::uInt32($xkey[0] ^ $this->f1($xkey[1], $tm[$j][6], $tr[$j][6]));
+            $xkey[7] = parent::uInt32($xkey[7] ^ $this->f2($xkey[0], $tm[$j][7], $tr[$j][7]));
+
+            $j =  (2 * $i) + 1;
+            $xkey[6] = parent::uInt32($xkey[6] ^ $this->f1($xkey[7], $tm[$j][0], $tr[$j][0]));
+            $xkey[5] = parent::uInt32($xkey[5] ^ $this->f2($xkey[6], $tm[$j][1], $tr[$j][1]));
+            $xkey[4] = parent::uInt32($xkey[4] ^ $this->f3($xkey[5], $tm[$j][2], $tr[$j][2]));
+            $xkey[3] = parent::uInt32($xkey[3] ^ $this->f1($xkey[4], $tm[$j][3], $tr[$j][3]));
+            $xkey[2] = parent::uInt32($xkey[2] ^ $this->f2($xkey[3], $tm[$j][4], $tr[$j][4]));
+            $xkey[1] = parent::uInt32($xkey[1] ^ $this->f3($xkey[2], $tm[$j][5], $tr[$j][5]));
+            $xkey[0] = parent::uInt32($xkey[0] ^ $this->f1($xkey[1], $tm[$j][6], $tr[$j][6]));
+            $xkey[7] = parent::uInt32($xkey[7] ^ $this->f2($xkey[0], $tm[$j][7], $tr[$j][7]));
+
+            // take the least 5 significant bits of each $xkey byte below and assign it
+            // to the round key
+            $this->_rkey[$i][0] = $xkey[0] & 31;
+            $this->_rkey[$i][1] = $xkey[2] & 31;
+            $this->_rkey[$i][2] = $xkey[4] & 31;
+            $this->_rkey[$i][3] = $xkey[6] & 31;
+
+            // now create 32 byte masking keys
+            $this->_mkey[$i][0] = $xkey[7];
+            $this->_mkey[$i][1] = $xkey[5];
+            $this->_mkey[$i][2] = $xkey[3];
+            $this->_mkey[$i][3] = $xkey[1];
+        }
+    }
+
+
+    /**
+     * Initialize the tables
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        // 256 unsigned 32 bit integers
+        self::$_s1 = array(
+            0x30FB40D4, 0x9FA0FF0B, 0x6BECCD2F, 0x3F258C7A,
+            0x1E213F2F, 0x9C004DD3, 0x6003E540, 0xCF9FC949,
+            0xBFD4AF27, 0x88BBBDB5, 0xE2034090, 0x98D09675,
+            0x6E63A0E0, 0x15C361D2, 0xC2E7661D, 0x22D4FF8E,
+            0x28683B6F, 0xC07FD059, 0xFF2379C8, 0x775F50E2,
+            0x43C340D3, 0xDF2F8656, 0x887CA41A, 0xA2D2BD2D,
+            0xA1C9E0D6, 0x346C4819, 0x61B76D87, 0x22540F2F,
+            0x2ABE32E1, 0xAA54166B, 0x22568E3A, 0xA2D341D0,
+            0x66DB40C8, 0xA784392F, 0x004DFF2F, 0x2DB9D2DE,
+            0x97943FAC, 0x4A97C1D8, 0x527644B7, 0xB5F437A7,
+            0xB82CBAEF, 0xD751D159, 0x6FF7F0ED, 0x5A097A1F,
+            0x827B68D0, 0x90ECF52E, 0x22B0C054, 0xBC8E5935,
+            0x4B6D2F7F, 0x50BB64A2, 0xD2664910, 0xBEE5812D,
+            0xB7332290, 0xE93B159F, 0xB48EE411, 0x4BFF345D,
+            0xFD45C240, 0xAD31973F, 0xC4F6D02E, 0x55FC8165,
+            0xD5B1CAAD, 0xA1AC2DAE, 0xA2D4B76D, 0xC19B0C50,
+            0x882240F2, 0x0C6E4F38, 0xA4E4BFD7, 0x4F5BA272,
+            0x564C1D2F, 0xC59C5319, 0xB949E354, 0xB04669FE,
+            0xB1B6AB8A, 0xC71358DD, 0x6385C545, 0x110F935D,
+            0x57538AD5, 0x6A390493, 0xE63D37E0, 0x2A54F6B3,
+            0x3A787D5F, 0x6276A0B5, 0x19A6FCDF, 0x7A42206A,
+            0x29F9D4D5, 0xF61B1891, 0xBB72275E, 0xAA508167,
+            0x38901091, 0xC6B505EB, 0x84C7CB8C, 0x2AD75A0F,
+            0x874A1427, 0xA2D1936B, 0x2AD286AF, 0xAA56D291,
+            0xD7894360, 0x425C750D, 0x93B39E26, 0x187184C9,
+            0x6C00B32D, 0x73E2BB14, 0xA0BEBC3C, 0x54623779,
+            0x64459EAB, 0x3F328B82, 0x7718CF82, 0x59A2CEA6,
+            0x04EE002E, 0x89FE78E6, 0x3FAB0950, 0x325FF6C2,
+            0x81383F05, 0x6963C5C8, 0x76CB5AD6, 0xD49974C9,
+            0xCA180DCF, 0x380782D5, 0xC7FA5CF6, 0x8AC31511,
+            0x35E79E13, 0x47DA91D0, 0xF40F9086, 0xA7E2419E,
+            0x31366241, 0x051EF495, 0xAA573B04, 0x4A805D8D,
+            0x548300D0, 0x00322A3C, 0xBF64CDDF, 0xBA57A68E,
+            0x75C6372B, 0x50AFD341, 0xA7C13275, 0x915A0BF5,
+            0x6B54BFAB, 0x2B0B1426, 0xAB4CC9D7, 0x449CCD82,
+            0xF7FBF265, 0xAB85C5F3, 0x1B55DB94, 0xAAD4E324,
+            0xCFA4BD3F, 0x2DEAA3E2, 0x9E204D02, 0xC8BD25AC,
+            0xEADF55B3, 0xD5BD9E98, 0xE31231B2, 0x2AD5AD6C,
+            0x954329DE, 0xADBE4528, 0xD8710F69, 0xAA51C90F,
+            0xAA786BF6, 0x22513F1E, 0xAA51A79B, 0x2AD344CC,
+            0x7B5A41F0, 0xD37CFBAD, 0x1B069505, 0x41ECE491,
+            0xB4C332E6, 0x032268D4, 0xC9600ACC, 0xCE387E6D,
+            0xBF6BB16C, 0x6A70FB78, 0x0D03D9C9, 0xD4DF39DE,
+            0xE01063DA, 0x4736F464, 0x5AD328D8, 0xB347CC96,
+            0x75BB0FC3, 0x98511BFB, 0x4FFBCC35, 0xB58BCF6A,
+            0xE11F0ABC, 0xBFC5FE4A, 0xA70AEC10, 0xAC39570A,
+            0x3F04442F, 0x6188B153, 0xE0397A2E, 0x5727CB79,
+            0x9CEB418F, 0x1CACD68D, 0x2AD37C96, 0x0175CB9D,
+            0xC69DFF09, 0xC75B65F0, 0xD9DB40D8, 0xEC0E7779,
+            0x4744EAD4, 0xB11C3274, 0xDD24CB9E, 0x7E1C54BD,
+            0xF01144F9, 0xD2240EB1, 0x9675B3FD, 0xA3AC3755,
+            0xD47C27AF, 0x51C85F4D, 0x56907596, 0xA5BB15E6,
+            0x580304F0, 0xCA042CF1, 0x011A37EA, 0x8DBFAADB,
+            0x35BA3E4A, 0x3526FFA0, 0xC37B4D09, 0xBC306ED9,
+            0x98A52666, 0x5648F725, 0xFF5E569D, 0x0CED63D0,
+            0x7C63B2CF, 0x700B45E1, 0xD5EA50F1, 0x85A92872,
+            0xAF1FBDA7, 0xD4234870, 0xA7870BF3, 0x2D3B4D79,
+            0x42E04198, 0x0CD0EDE7, 0x26470DB8, 0xF881814C,
+            0x474D6AD7, 0x7C0C5E5C, 0xD1231959, 0x381B7298,
+            0xF5D2F4DB, 0xAB838653, 0x6E2F1E23, 0x83719C9E,
+            0xBD91E046, 0x9A56456E, 0xDC39200C, 0x20C8C571,
+            0x962BDA1C, 0xE1E696FF, 0xB141AB08, 0x7CCA89B9,
+            0x1A69E783, 0x02CC4843, 0xA2F7C579, 0x429EF47D,
+            0x427B169C, 0x5AC9F049, 0xDD8F0F00, 0x5C8165BF
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s2 = array(
+            0x1F201094, 0xEF0BA75B, 0x69E3CF7E, 0x393F4380,
+            0xFE61CF7A, 0xEEC5207A, 0x55889C94, 0x72FC0651,
+            0xADA7EF79, 0x4E1D7235, 0xD55A63CE, 0xDE0436BA,
+            0x99C430EF, 0x5F0C0794, 0x18DCDB7D, 0xA1D6EFF3,
+            0xA0B52F7B, 0x59E83605, 0xEE15B094, 0xE9FFD909,
+            0xDC440086, 0xEF944459, 0xBA83CCB3, 0xE0C3CDFB,
+            0xD1DA4181, 0x3B092AB1, 0xF997F1C1, 0xA5E6CF7B,
+            0x01420DDB, 0xE4E7EF5B, 0x25A1FF41, 0xE180F806,
+            0x1FC41080, 0x179BEE7A, 0xD37AC6A9, 0xFE5830A4,
+            0x98DE8B7F, 0x77E83F4E, 0x79929269, 0x24FA9F7B,
+            0xE113C85B, 0xACC40083, 0xD7503525, 0xF7EA615F,
+            0x62143154, 0x0D554B63, 0x5D681121, 0xC866C359,
+            0x3D63CF73, 0xCEE234C0, 0xD4D87E87, 0x5C672B21,
+            0x071F6181, 0x39F7627F, 0x361E3084, 0xE4EB573B,
+            0x602F64A4, 0xD63ACD9C, 0x1BBC4635, 0x9E81032D,
+            0x2701F50C, 0x99847AB4, 0xA0E3DF79, 0xBA6CF38C,
+            0x10843094, 0x2537A95E, 0xF46F6FFE, 0xA1FF3B1F,
+            0x208CFB6A, 0x8F458C74, 0xD9E0A227, 0x4EC73A34,
+            0xFC884F69, 0x3E4DE8DF, 0xEF0E0088, 0x3559648D,
+            0x8A45388C, 0x1D804366, 0x721D9BFD, 0xA58684BB,
+            0xE8256333, 0x844E8212, 0x128D8098, 0xFED33FB4,
+            0xCE280AE1, 0x27E19BA5, 0xD5A6C252, 0xE49754BD,
+            0xC5D655DD, 0xEB667064, 0x77840B4D, 0xA1B6A801,
+            0x84DB26A9, 0xE0B56714, 0x21F043B7, 0xE5D05860,
+            0x54F03084, 0x066FF472, 0xA31AA153, 0xDADC4755,
+            0xB5625DBF, 0x68561BE6, 0x83CA6B94, 0x2D6ED23B,
+            0xECCF01DB, 0xA6D3D0BA, 0xB6803D5C, 0xAF77A709,
+            0x33B4A34C, 0x397BC8D6, 0x5EE22B95, 0x5F0E5304,
+            0x81ED6F61, 0x20E74364, 0xB45E1378, 0xDE18639B,
+            0x881CA122, 0xB96726D1, 0x8049A7E8, 0x22B7DA7B,
+            0x5E552D25, 0x5272D237, 0x79D2951C, 0xC60D894C,
+            0x488CB402, 0x1BA4FE5B, 0xA4B09F6B, 0x1CA815CF,
+            0xA20C3005, 0x8871DF63, 0xB9DE2FCB, 0x0CC6C9E9,
+            0x0BEEFF53, 0xE3214517, 0xB4542835, 0x9F63293C,
+            0xEE41E729, 0x6E1D2D7C, 0x50045286, 0x1E6685F3,
+            0xF33401C6, 0x30A22C95, 0x31A70850, 0x60930F13,
+            0x73F98417, 0xA1269859, 0xEC645C44, 0x52C877A9,
+            0xCDFF33A6, 0xA02B1741, 0x7CBAD9A2, 0x2180036F,
+            0x50D99C08, 0xCB3F4861, 0xC26BD765, 0x64A3F6AB,
+            0x80342676, 0x25A75E7B, 0xE4E6D1FC, 0x20C710E6,
+            0xCDF0B680, 0x17844D3B, 0x31EEF84D, 0x7E0824E4,
+            0x2CCB49EB, 0x846A3BAE, 0x8FF77888, 0xEE5D60F6,
+            0x7AF75673, 0x2FDD5CDB, 0xA11631C1, 0x30F66F43,
+            0xB3FAEC54, 0x157FD7FA, 0xEF8579CC, 0xD152DE58,
+            0xDB2FFD5E, 0x8F32CE19, 0x306AF97A, 0x02F03EF8,
+            0x99319AD5, 0xC242FA0F, 0xA7E3EBB0, 0xC68E4906,
+            0xB8DA230C, 0x80823028, 0xDCDEF3C8, 0xD35FB171,
+            0x088A1BC8, 0xBEC0C560, 0x61A3C9E8, 0xBCA8F54D,
+            0xC72FEFFA, 0x22822E99, 0x82C570B4, 0xD8D94E89,
+            0x8B1C34BC, 0x301E16E6, 0x273BE979, 0xB0FFEAA6,
+            0x61D9B8C6, 0x00B24869, 0xB7FFCE3F, 0x08DC283B,
+            0x43DAF65A, 0xF7E19798, 0x7619B72F, 0x8F1C9BA4,
+            0xDC8637A0, 0x16A7D3B1, 0x9FC393B7, 0xA7136EEB,
+            0xC6BCC63E, 0x1A513742, 0xEF6828BC, 0x520365D6,
+            0x2D6A77AB, 0x3527ED4B, 0x821FD216, 0x095C6E2E,
+            0xDB92F2FB, 0x5EEA29CB, 0x145892F5, 0x91584F7F,
+            0x5483697B, 0x2667A8CC, 0x85196048, 0x8C4BACEA,
+            0x833860D4, 0x0D23E0F9, 0x6C387E8A, 0x0AE6D249,
+            0xB284600C, 0xD835731D, 0xDCB1C647, 0xAC4C56EA,
+            0x3EBD81B3, 0x230EABB0, 0x6438BC87, 0xF0B5B1FA,
+            0x8F5EA2B3, 0xFC184642, 0x0A036B7A, 0x4FB089BD,
+            0x649DA589, 0xA345415E, 0x5C038323, 0x3E5D3BB9,
+            0x43D79572, 0x7E6DD07C, 0x06DFDF1E, 0x6C6CC4EF,
+            0x7160A539, 0x73BFBE70, 0x83877605, 0x4523ECF1
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s3 = array(
+            0x8DEFC240, 0x25FA5D9F, 0xEB903DBF, 0xE810C907,
+            0x47607FFF, 0x369FE44B, 0x8C1FC644, 0xAECECA90,
+            0xBEB1F9BF, 0xEEFBCAEA, 0xE8CF1950, 0x51DF07AE,
+            0x920E8806, 0xF0AD0548, 0xE13C8D83, 0x927010D5,
+            0x11107D9F, 0x07647DB9, 0xB2E3E4D4, 0x3D4F285E,
+            0xB9AFA820, 0xFADE82E0, 0xA067268B, 0x8272792E,
+            0x553FB2C0, 0x489AE22B, 0xD4EF9794, 0x125E3FBC,
+            0x21FFFCEE, 0x825B1BFD, 0x9255C5ED, 0x1257A240,
+            0x4E1A8302, 0xBAE07FFF, 0x528246E7, 0x8E57140E,
+            0x3373F7BF, 0x8C9F8188, 0xA6FC4EE8, 0xC982B5A5,
+            0xA8C01DB7, 0x579FC264, 0x67094F31, 0xF2BD3F5F,
+            0x40FFF7C1, 0x1FB78DFC, 0x8E6BD2C1, 0x437BE59B,
+            0x99B03DBF, 0xB5DBC64B, 0x638DC0E6, 0x55819D99,
+            0xA197C81C, 0x4A012D6E, 0xC5884A28, 0xCCC36F71,
+            0xB843C213, 0x6C0743F1, 0x8309893C, 0x0FEDDD5F,
+            0x2F7FE850, 0xD7C07F7E, 0x02507FBF, 0x5AFB9A04,
+            0xA747D2D0, 0x1651192E, 0xAF70BF3E, 0x58C31380,
+            0x5F98302E, 0x727CC3C4, 0x0A0FB402, 0x0F7FEF82,
+            0x8C96FDAD, 0x5D2C2AAE, 0x8EE99A49, 0x50DA88B8,
+            0x8427F4A0, 0x1EAC5790, 0x796FB449, 0x8252DC15,
+            0xEFBD7D9B, 0xA672597D, 0xADA840D8, 0x45F54504,
+            0xFA5D7403, 0xE83EC305, 0x4F91751A, 0x925669C2,
+            0x23EFE941, 0xA903F12E, 0x60270DF2, 0x0276E4B6,
+            0x94FD6574, 0x927985B2, 0x8276DBCB, 0x02778176,
+            0xF8AF918D, 0x4E48F79E, 0x8F616DDF, 0xE29D840E,
+            0x842F7D83, 0x340CE5C8, 0x96BBB682, 0x93B4B148,
+            0xEF303CAB, 0x984FAF28, 0x779FAF9B, 0x92DC560D,
+            0x224D1E20, 0x8437AA88, 0x7D29DC96, 0x2756D3DC,
+            0x8B907CEE, 0xB51FD240, 0xE7C07CE3, 0xE566B4A1,
+            0xC3E9615E, 0x3CF8209D, 0x6094D1E3, 0xCD9CA341,
+            0x5C76460E, 0x00EA983B, 0xD4D67881, 0xFD47572C,
+            0xF76CEDD9, 0xBDA8229C, 0x127DADAA, 0x438A074E,
+            0x1F97C090, 0x081BDB8A, 0x93A07EBE, 0xB938CA15,
+            0x97B03CFF, 0x3DC2C0F8, 0x8D1AB2EC, 0x64380E51,
+            0x68CC7BFB, 0xD90F2788, 0x12490181, 0x5DE5FFD4,
+            0xDD7EF86A, 0x76A2E214, 0xB9A40368, 0x925D958F,
+            0x4B39FFFA, 0xBA39AEE9, 0xA4FFD30B, 0xFAF7933B,
+            0x6D498623, 0x193CBCFA, 0x27627545, 0x825CF47A,
+            0x61BD8BA0, 0xD11E42D1, 0xCEAD04F4, 0x127EA392,
+            0x10428DB7, 0x8272A972, 0x9270C4A8, 0x127DE50B,
+            0x285BA1C8, 0x3C62F44F, 0x35C0EAA5, 0xE805D231,
+            0x428929FB, 0xB4FCDF82, 0x4FB66A53, 0x0E7DC15B,
+            0x1F081FAB, 0x108618AE, 0xFCFD086D, 0xF9FF2889,
+            0x694BCC11, 0x236A5CAE, 0x12DECA4D, 0x2C3F8CC5,
+            0xD2D02DFE, 0xF8EF5896, 0xE4CF52DA, 0x95155B67,
+            0x494A488C, 0xB9B6A80C, 0x5C8F82BC, 0x89D36B45,
+            0x3A609437, 0xEC00C9A9, 0x44715253, 0x0A874B49,
+            0xD773BC40, 0x7C34671C, 0x02717EF6, 0x4FEB5536,
+            0xA2D02FFF, 0xD2BF60C4, 0xD43F03C0, 0x50B4EF6D,
+            0x07478CD1, 0x006E1888, 0xA2E53F55, 0xB9E6D4BC,
+            0xA2048016, 0x97573833, 0xD7207D67, 0xDE0F8F3D,
+            0x72F87B33, 0xABCC4F33, 0x7688C55D, 0x7B00A6B0,
+            0x947B0001, 0x570075D2, 0xF9BB88F8, 0x8942019E,
+            0x4264A5FF, 0x856302E0, 0x72DBD92B, 0xEE971B69,
+            0x6EA22FDE, 0x5F08AE2B, 0xAF7A616D, 0xE5C98767,
+            0xCF1FEBD2, 0x61EFC8C2, 0xF1AC2571, 0xCC8239C2,
+            0x67214CB8, 0xB1E583D1, 0xB7DC3E62, 0x7F10BDCE,
+            0xF90A5C38, 0x0FF0443D, 0x606E6DC6, 0x60543A49,
+            0x5727C148, 0x2BE98A1D, 0x8AB41738, 0x20E1BE24,
+            0xAF96DA0F, 0x68458425, 0x99833BE5, 0x600D457D,
+            0x282F9350, 0x8334B362, 0xD91D1120, 0x2B6D8DA0,
+            0x642B1E31, 0x9C305A00, 0x52BCE688, 0x1B03588A,
+            0xF7BAEFD5, 0x4142ED9C, 0xA4315C11, 0x83323EC5,
+            0xDFEF4636, 0xA133C501, 0xE9D3531C, 0xEE353783
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s4 = array(
+            0x9DB30420, 0x1FB6E9DE, 0xA7BE7BEF, 0xD273A298,
+            0x4A4F7BDB, 0x64AD8C57, 0x85510443, 0xFA020ED1,
+            0x7E287AFF, 0xE60FB663, 0x095F35A1, 0x79EBF120,
+            0xFD059D43, 0x6497B7B1, 0xF3641F63, 0x241E4ADF,
+            0x28147F5F, 0x4FA2B8CD, 0xC9430040, 0x0CC32220,
+            0xFDD30B30, 0xC0A5374F, 0x1D2D00D9, 0x24147B15,
+            0xEE4D111A, 0x0FCA5167, 0x71FF904C, 0x2D195FFE,
+            0x1A05645F, 0x0C13FEFE, 0x081B08CA, 0x05170121,
+            0x80530100, 0xE83E5EFE, 0xAC9AF4F8, 0x7FE72701,
+            0xD2B8EE5F, 0x06DF4261, 0xBB9E9B8A, 0x7293EA25,
+            0xCE84FFDF, 0xF5718801, 0x3DD64B04, 0xA26F263B,
+            0x7ED48400, 0x547EEBE6, 0x446D4CA0, 0x6CF3D6F5,
+            0x2649ABDF, 0xAEA0C7F5, 0x36338CC1, 0x503F7E93,
+            0xD3772061, 0x11B638E1, 0x72500E03, 0xF80EB2BB,
+            0xABE0502E, 0xEC8D77DE, 0x57971E81, 0xE14F6746,
+            0xC9335400, 0x6920318F, 0x081DBB99, 0xFFC304A5,
+            0x4D351805, 0x7F3D5CE3, 0xA6C866C6, 0x5D5BCCA9,
+            0xDAEC6FEA, 0x9F926F91, 0x9F46222F, 0x3991467D,
+            0xA5BF6D8E, 0x1143C44F, 0x43958302, 0xD0214EEB,
+            0x022083B8, 0x3FB6180C, 0x18F8931E, 0x281658E6,
+            0x26486E3E, 0x8BD78A70, 0x7477E4C1, 0xB506E07C,
+            0xF32D0A25, 0x79098B02, 0xE4EABB81, 0x28123B23,
+            0x69DEAD38, 0x1574CA16, 0xDF871B62, 0x211C40B7,
+            0xA51A9EF9, 0x0014377B, 0x041E8AC8, 0x09114003,
+            0xBD59E4D2, 0xE3D156D5, 0x4FE876D5, 0x2F91A340,
+            0x557BE8DE, 0x00EAE4A7, 0x0CE5C2EC, 0x4DB4BBA6,
+            0xE756BDFF, 0xDD3369AC, 0xEC17B035, 0x06572327,
+            0x99AFC8B0, 0x56C8C391, 0x6B65811C, 0x5E146119,
+            0x6E85CB75, 0xBE07C002, 0xC2325577, 0x893FF4EC,
+            0x5BBFC92D, 0xD0EC3B25, 0xB7801AB7, 0x8D6D3B24,
+            0x20C763EF, 0xC366A5FC, 0x9C382880, 0x0ACE3205,
+            0xAAC9548A, 0xECA1D7C7, 0x041AFA32, 0x1D16625A,
+            0x6701902C, 0x9B757A54, 0x31D477F7, 0x9126B031,
+            0x36CC6FDB, 0xC70B8B46, 0xD9E66A48, 0x56E55A79,
+            0x026A4CEB, 0x52437EFF, 0x2F8F76B4, 0x0DF980A5,
+            0x8674CDE3, 0xEDDA04EB, 0x17A9BE04, 0x2C18F4DF,
+            0xB7747F9D, 0xAB2AF7B4, 0xEFC34D20, 0x2E096B7C,
+            0x1741A254, 0xE5B6A035, 0x213D42F6, 0x2C1C7C26,
+            0x61C2F50F, 0x6552DAF9, 0xD2C231F8, 0x25130F69,
+            0xD8167FA2, 0x0418F2C8, 0x001A96A6, 0x0D1526AB,
+            0x63315C21, 0x5E0A72EC, 0x49BAFEFD, 0x187908D9,
+            0x8D0DBD86, 0x311170A7, 0x3E9B640C, 0xCC3E10D7,
+            0xD5CAD3B6, 0x0CAEC388, 0xF73001E1, 0x6C728AFF,
+            0x71EAE2A1, 0x1F9AF36E, 0xCFCBD12F, 0xC1DE8417,
+            0xAC07BE6B, 0xCB44A1D8, 0x8B9B0F56, 0x013988C3,
+            0xB1C52FCA, 0xB4BE31CD, 0xD8782806, 0x12A3A4E2,
+            0x6F7DE532, 0x58FD7EB6, 0xD01EE900, 0x24ADFFC2,
+            0xF4990FC5, 0x9711AAC5, 0x001D7B95, 0x82E5E7D2,
+            0x109873F6, 0x00613096, 0xC32D9521, 0xADA121FF,
+            0x29908415, 0x7FBB977F, 0xAF9EB3DB, 0x29C9ED2A,
+            0x5CE2A465, 0xA730F32C, 0xD0AA3FE8, 0x8A5CC091,
+            0xD49E2CE7, 0x0CE454A9, 0xD60ACD86, 0x015F1919,
+            0x77079103, 0xDEA03AF6, 0x78A8565E, 0xDEE356DF,
+            0x21F05CBE, 0x8B75E387, 0xB3C50651, 0xB8A5C3EF,
+            0xD8EEB6D2, 0xE523BE77, 0xC2154529, 0x2F69EFDF,
+            0xAFE67AFB, 0xF470C4B2, 0xF3E0EB5B, 0xD6CC9876,
+            0x39E4460C, 0x1FDA8538, 0x1987832F, 0xCA007367,
+            0xA99144F8, 0x296B299E, 0x492FC295, 0x9266BEAB,
+            0xB5676E69, 0x9BD3DDDA, 0xDF7E052F, 0xDB25701C,
+            0x1B5E51EE, 0xF65324E6, 0x6AFCE36C, 0x0316CC04,
+            0x8644213E, 0xB7DC59D0, 0x7965291F, 0xCCD6FD43,
+            0x41823979, 0x932BCDF6, 0xB657C34D, 0x4EDFD282,
+            0x7AE5290C, 0x3CB9536B, 0x851E20FE, 0x9833557E,
+            0x13ECF0B0, 0xD3FFB372, 0x3F85C5C1, 0x0AEF7ED2
+        );
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

Spacing +11 added lines, -11 removed lines

@@ -77,12 +77,12 @@ 
 	{
 		$keylen = strlen($key);
 
-		if($keylen > self::BYTES_KEY_MAX)
+		if ($keylen > self::BYTES_KEY_MAX)
 		{
 			$key = substr($key, 0, self::BYTES_KEY_MAX);
 			$keylen = self::BYTES_KEY_MAX;
 		}
-		else if(!in_array($keylen, self::$_req_key_sizes))
+		else if (!in_array($keylen, self::$_req_key_sizes))
 		{
 			$msg  = PHP_Crypt::CIPHER_CAST_256." requires a key size of 16, ";
 			$msg .= "20, 24, 28, or 32 bytes.";
@@ -131,7 +131,7 @@ 
 		$data = array_map("parent::str2Dec", $data);
 
 		// do the first 6 loops
-		for($i = 0; $i < 6; ++$i)
+		for ($i = 0; $i < 6; ++$i)
 		{
 
 			$data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
@@ -141,7 +141,7 @@ 
 		}
 
 		// the second 6 loops are done in a different order
-		for($i = 6; $i < 12; ++$i)
+		for ($i = 6; $i < 12; ++$i)
 		{
 
 			$data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
@@ -182,7 +182,7 @@ 
 		$data = array_map("parent::str2Dec", $data);
 
 		// do the first 6 loops
-		for($i = 11; $i >= 6; --$i)
+		for ($i = 11; $i >= 6; --$i)
 		{
 			$data[2] ^= $this->f1($data[3], $this->_mkey[$i][0], $this->_rkey[$i][0]);
 			$data[1] ^= $this->f2($data[2], $this->_mkey[$i][1], $this->_rkey[$i][1]);
@@ -191,7 +191,7 @@ 
 		}
 
 		// the second 6 loops are done in a different order
-		for($i = 5; $i >= 0; --$i)
+		for ($i = 5; $i >= 0; --$i)
 		{
 			$data[3] ^= $this->f1($data[0], $this->_mkey[$i][3], $this->_rkey[$i][3]);
 			$data[0] ^= $this->f3($data[1], $this->_mkey[$i][2], $this->_rkey[$i][2]);
@@ -298,7 +298,7 @@ 
 
 		// if the key is less than 32 bytes, pad it to 32 bytes
 		// for the key expansion
-		if($this->keySize() < 32)
+		if ($this->keySize() < 32)
 			$xkey = str_pad($xkey, 32, "\0", STR_PAD_RIGHT);
 
 		// split the key up into 4 byte parts, reverse the string,
@@ -308,12 +308,12 @@ 
 		$xkey = array_map("parent::str2Dec", $xkey);
 
 		// set up the values need for creating round and masking keys
-		for($i = 0; $i < 24; ++$i)
+		for ($i = 0; $i < 24; ++$i)
 		{
 			$tm[$i] = array();
 			$tr[$i] = array();
 
-			for($j = 0; $j < 8; ++$j)
+			for ($j = 0; $j < 8; ++$j)
 			{
 				$tm[$i][$j] = $cm;
 				$cm = parent::uInt32($cm + $mm);
@@ -323,7 +323,7 @@ 
 		}
 
 		// now create the round and masking keys
-		for($i = 0; $i < 12; ++$i)
+		for ($i = 0; $i < 12; ++$i)
 		{
 			$j = 2 * $i;
 
@@ -336,7 +336,7 @@ 
 			$xkey[0] = parent::uInt32($xkey[0] ^ $this->f1($xkey[1], $tm[$j][6], $tr[$j][6]));
 			$xkey[7] = parent::uInt32($xkey[7] ^ $this->f2($xkey[0], $tm[$j][7], $tr[$j][7]));
 
-			$j =  (2 * $i) + 1;
+			$j = (2 * $i) + 1;
 			$xkey[6] = parent::uInt32($xkey[6] ^ $this->f1($xkey[7], $tm[$j][0], $tr[$j][0]));
 			$xkey[5] = parent::uInt32($xkey[5] ^ $this->f2($xkey[6], $tm[$j][1], $tr[$j][1]));
 			$xkey[4] = parent::uInt32($xkey[4] ^ $this->f3($xkey[5], $tm[$j][2], $tr[$j][2]));

Braces +4 added lines, -4 removed lines

@@ -81,8 +81,7 @@ 
 		{
 			$key = substr($key, 0, self::BYTES_KEY_MAX);
 			$keylen = self::BYTES_KEY_MAX;
-		}
-		else if(!in_array($keylen, self::$_req_key_sizes))
+		} else if(!in_array($keylen, self::$_req_key_sizes))
 		{
 			$msg  = PHP_Crypt::CIPHER_CAST_256." requires a key size of 16, ";
 			$msg .= "20, 24, 28, or 32 bytes.";
@@ -298,8 +297,9 @@ 
 
 		// if the key is less than 32 bytes, pad it to 32 bytes
 		// for the key expansion
-		if($this->keySize() < 32)
-			$xkey = str_pad($xkey, 32, "\0", STR_PAD_RIGHT);
+		if($this->keySize() < 32) {
+					$xkey = str_pad($xkey, 32, "\0", STR_PAD_RIGHT);
+		}
 
 		// split the key up into 4 byte parts, reverse the string,
 		// then convert each part into a 32 bit integer

includes/libraries/phpcrypt/ciphers/DES.php

Doc Comments +3 added lines, -5 removed lines

@@ -155,7 +155,6 @@ 
 	/**
 	 * Encrypt plain text data using DES
 	 *
-	 * @param string $data A plain text string
 	 * @return boolean Returns true
 	 */
 	public function encrypt(&$text)
@@ -168,7 +167,6 @@ 
 	/**
 	 * Decrypt a DES encrypted string
 	 *
-	 * @param string $encrypted A DES encrypted string
 	 * @return boolean Returns true
 	 */
 	public function decrypt(&$text)
@@ -296,8 +294,8 @@ 
 	 * the IP and FP are part of the DES standard and not implementing it would deviate from
 	 * the standard, so we will do it here in phpCrypt.
 	 *
-	 * @param string $m The plain text message
-	 * @return array the Initial Permutation (IP)
+	 * @param string $text
+	 * @return string the Initial Permutation (IP)
 	 */
 	private function ip($text)
 	{
@@ -318,7 +316,7 @@ 
 	 * call the use of this selection table the function E. Thus E(Rn-1) has a 32 bit input
 	 * block, and a 48 bit output block.
 	 *
-	 * @param array $r  32 bit binary, each bit in an array element
+	 * @param string $r  32 bit binary, each bit in an array element
 	 * @param string $k 48 bit binary string
 	 * @return string 48 bit binary string
 	 */

Indentation +545 added lines, -545 removed lines

@@ -38,558 +38,558 @@
  */
 class Cipher_DES extends Cipher
 {
-	/** @type integer BYTES_BLOCK The block size, in bytes */
-	const BYTES_BLOCK = 8; // 64 bits
+    /** @type integer BYTES_BLOCK The block size, in bytes */
+    const BYTES_BLOCK = 8; // 64 bits
 
-	/** @type integer BYTES_KEY The key size, in bytes */
-	const BYTES_KEY = 8; // 64 bits
+    /** @type integer BYTES_KEY The key size, in bytes */
+    const BYTES_KEY = 8; // 64 bits
 
-	/** @type array $sub_keys The permutated subkeys */
-	protected $sub_keys = array();
+    /** @type array $sub_keys The permutated subkeys */
+    protected $sub_keys = array();
 
-	/*
+    /*
 	 * Tables initialized in the initTables()
 	 */
 
-	/**
-	 * @type array $_pc1 Permutated choice 1 (PC1),
-	 * This should be considered a constant
-	 */
-	protected static $_pc1 = array();
-
-	/**
-	 * @type array $_pc2 Permutated choice 2 (PC2),
-	 * This should be considered a constant
-	 */
-	protected static $_pc2 = array();
-
-	/**
-	 * @type array $_key_sched The key schedule,
-	 * This should be considered a constant
-	 */
-	protected static $_key_sched = array();
-
-	/**
-	 * @type array $_ip The Initial Permutation (IP),
-	 * This should be considered a constant
-	 */
-	private static $_ip = array();
-
-	/**
-	 * @type array $_e The Expansion table (E),
-	 * This should be considered a constant
-	 */
-	private static $_e = array();
-
-	/**
-	 * @type array $_s The Substitution Box (S),
-	 * This should be considered a constant
-	 */
-	private static $_s = array();
-
-	/**
-	 * @type array $_p The Permutation table (P),
-	 * This should be considered a constant
-	 */
-	private static $_p = array();
-
-	/**
-	 * @type array $_ip The The Final Permutation table (FP),
-	 * This should be considered a constant
-	 */
-	private static $_fp = array();
-
-
-	/**
-	 * Constructor, used only when calling this class directly
-	 * for classes that extend this class, call __construct1()
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// set the DES key
-		parent::__construct(PHP_Crypt::CIPHER_DES, $key, self::BYTES_KEY);
-
-		// initialize variables
-		$this->initTables();
-
-		// DES requires that data is 64 bits
-		$this->blockSize(self::BYTES_BLOCK);
-
-		// create the 16 rounds of 56 bit keys
-		$this->keyPermutation();
-	}
-
-
-	/**
-	 * Second Constructor, used only by child classes that extend this class
-	 *
-	 * @param string $cipher The name of the cipher extending this class
-	 * @param string $key The key used for Encryption/Decryption
-	 * @param integer $key_byte_sz The required byte size of the extending cipher
-	 * @return void
-	 */
-	protected function __construct1($cipher, $key, $key_byte_sz)
-	{
-		// set the key and key size
-		parent::__construct($cipher, $key, $key_byte_sz);
-
-		// initialize variables
-		$this->initTables();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using DES
-	 *
-	 * @param string $data A plain text string
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->des($text);
-	}
-
-
-	/**
-	 * Decrypt a DES encrypted string
-	 *
-	 * @param string $encrypted A DES encrypted string
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->des($text);
-	}
-
-
-	/**
-	 * This is where the actual encrypt/decryption takes place. Since
-	 * encryption and decryption are the same algorithm in DES, we only
-	 * need one function to do both.
-	 *
-	 * @param string $data The string to be encrypted or decrypted
-	 * @return boolean Returns true
-	 */
-	protected function des(&$data)
-	{
-		$l = array();
-		$r = array();
-
-		// step two: Initial Permutation (IP) of plaintext
-		$data = $this->ip($data);
-
-		// divide the permuted block IP into a left half L0 of 32 bits,
-		// and a right half R0 of 32 bits
-		$l[0] = substr($data, 0, 32);
-		$r[0] = substr($data, 32, 32);
-
-		for($n = 1; $n <= 16; ++$n)
-		{
-			$l[$n] = $r[$n-1];
-
-			if($this->operation() == parent::DECRYPT)
-				$f = $this->F($r[$n-1], $this->sub_keys[16-$n]);
-			else
-				$f = $this->F($r[$n-1], $this->sub_keys[$n-1]);
-
-			// XOR F with Ln
-			$r[$n] = $this->xorBin($l[$n-1], $f);
-		}
-
-		// now we combine L[16] and R[16] back into a 64-bit string, but we reverse
-		// L[16] and R[16] so that it becomes R[16]L[16]
-		$data = $r[16].$l[16];
-
-		// now do the final permutation
-		$data = $this->fp($data);
-		$data = parent::bin2Str($data);
-
-		return true;
-	}
-
-
-	/**
-	 * The Key permutation, based on tables $_pc1 and $_pc2
-	 * Create 16 subkeys, each of which is 48-bits long.
-	 *
-	 * @return void
-	 */
-	private function keyPermutation()
-	{
-		$this->sub_keys = array();
-		$pc1m = array();
-		$pcr = array();
-		$c = array();
-		$d = array();
-
-		// convert the key to binary
-		$binkey = parent::str2Bin($this->key());
-
-		// reduce the key down to 56bits based on table $_pc1
-		for($i = 0; $i < 56; ++$i)
+    /**
+     * @type array $_pc1 Permutated choice 1 (PC1),
+     * This should be considered a constant
+     */
+    protected static $_pc1 = array();
+
+    /**
+     * @type array $_pc2 Permutated choice 2 (PC2),
+     * This should be considered a constant
+     */
+    protected static $_pc2 = array();
+
+    /**
+     * @type array $_key_sched The key schedule,
+     * This should be considered a constant
+     */
+    protected static $_key_sched = array();
+
+    /**
+     * @type array $_ip The Initial Permutation (IP),
+     * This should be considered a constant
+     */
+    private static $_ip = array();
+
+    /**
+     * @type array $_e The Expansion table (E),
+     * This should be considered a constant
+     */
+    private static $_e = array();
+
+    /**
+     * @type array $_s The Substitution Box (S),
+     * This should be considered a constant
+     */
+    private static $_s = array();
+
+    /**
+     * @type array $_p The Permutation table (P),
+     * This should be considered a constant
+     */
+    private static $_p = array();
+
+    /**
+     * @type array $_ip The The Final Permutation table (FP),
+     * This should be considered a constant
+     */
+    private static $_fp = array();
+
+
+    /**
+     * Constructor, used only when calling this class directly
+     * for classes that extend this class, call __construct1()
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // set the DES key
+        parent::__construct(PHP_Crypt::CIPHER_DES, $key, self::BYTES_KEY);
+
+        // initialize variables
+        $this->initTables();
+
+        // DES requires that data is 64 bits
+        $this->blockSize(self::BYTES_BLOCK);
+
+        // create the 16 rounds of 56 bit keys
+        $this->keyPermutation();
+    }
+
+
+    /**
+     * Second Constructor, used only by child classes that extend this class
+     *
+     * @param string $cipher The name of the cipher extending this class
+     * @param string $key The key used for Encryption/Decryption
+     * @param integer $key_byte_sz The required byte size of the extending cipher
+     * @return void
+     */
+    protected function __construct1($cipher, $key, $key_byte_sz)
+    {
+        // set the key and key size
+        parent::__construct($cipher, $key, $key_byte_sz);
+
+        // initialize variables
+        $this->initTables();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using DES
+     *
+     * @param string $data A plain text string
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->des($text);
+    }
+
+
+    /**
+     * Decrypt a DES encrypted string
+     *
+     * @param string $encrypted A DES encrypted string
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->des($text);
+    }
+
+
+    /**
+     * This is where the actual encrypt/decryption takes place. Since
+     * encryption and decryption are the same algorithm in DES, we only
+     * need one function to do both.
+     *
+     * @param string $data The string to be encrypted or decrypted
+     * @return boolean Returns true
+     */
+    protected function des(&$data)
+    {
+        $l = array();
+        $r = array();
+
+        // step two: Initial Permutation (IP) of plaintext
+        $data = $this->ip($data);
+
+        // divide the permuted block IP into a left half L0 of 32 bits,
+        // and a right half R0 of 32 bits
+        $l[0] = substr($data, 0, 32);
+        $r[0] = substr($data, 32, 32);
+
+        for($n = 1; $n <= 16; ++$n)
+        {
+            $l[$n] = $r[$n-1];
+
+            if($this->operation() == parent::DECRYPT)
+                $f = $this->F($r[$n-1], $this->sub_keys[16-$n]);
+            else
+                $f = $this->F($r[$n-1], $this->sub_keys[$n-1]);
+
+            // XOR F with Ln
+            $r[$n] = $this->xorBin($l[$n-1], $f);
+        }
+
+        // now we combine L[16] and R[16] back into a 64-bit string, but we reverse
+        // L[16] and R[16] so that it becomes R[16]L[16]
+        $data = $r[16].$l[16];
+
+        // now do the final permutation
+        $data = $this->fp($data);
+        $data = parent::bin2Str($data);
+
+        return true;
+    }
+
+
+    /**
+     * The Key permutation, based on tables $_pc1 and $_pc2
+     * Create 16 subkeys, each of which is 48-bits long.
+     *
+     * @return void
+     */
+    private function keyPermutation()
+    {
+        $this->sub_keys = array();
+        $pc1m = array();
+        $pcr = array();
+        $c = array();
+        $d = array();
+
+        // convert the key to binary
+        $binkey = parent::str2Bin($this->key());
+
+        // reduce the key down to 56bits based on table $_pc1
+        for($i = 0; $i < 56; ++$i)
             $pc1m[$i] = $binkey[self::$_pc1[$i] - 1];
 
-		// split $pc1m in half (C0 and D0)
-		$c[0] = array_slice($pc1m, 0, 28);
-		$d[0] = array_slice($pc1m, 28, 28);
-
-		// now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
-		// where 1 <= n <= 16
-		for($i = 1; $i <= 16; ++$i)
-		{
-			// now set the next Cn and Dn as the previous Cn and Dn
-			$c[$i] = $c[$i-1];
-			$d[$i] = $d[$i-1];
-
-			for($j = 0; $j < self::$_key_sched[$i-1]; ++$j)
-			{
-				// do a left shift, move each bit one place to the left,
-				// except for the first bit, which is cycled to the end
-				// of the block.
-				$c[$i][] = array_shift($c[$i]);
-				$d[$i][] = array_shift($d[$i]);
-			}
-
-			// We now form the sub_keys (Kn), for 1<=n<=16, by applying the
-			// following permutation table to each of the concatenated
-			// pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
-			// of these.
-			$CnDn = array_merge($c[$i], $d[$i]);
-			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[self::$_pc2[$j] - 1];
-		}
-
-		// the sub_keys are created, we are done with the key permutation
-	}
-
-
-	/**
-	 * Initial Permutation (IP)
-	 * Now we encode each 64-bit block of data. There is an initial permutation IP of
-	 * the 64 bits of the message data M. This rearranges the bits according to the
-	 * following table, where the entries in the table show the new arrangement of the
-	 * bits from their initial order. The 58th bit of M becomes the first bit of IP.
-	 * The 50th bit of M becomes the second bit of IP. The 7th bit of M is the last
-	 * bit of IP.
-	 *
-	 * According to the book Applied Cryptography (Bruce Schneier, 2nd edition, pg. 271):
-	 * The initial permution was used to make it easier to load plain text and cipher text
-	 * data into a DES chip in byte-sized pieces when doing DES in hardware. The IP and FP
-	 * are not necessary in software implementations and do not affect the security. However,
-	 * the IP and FP are part of the DES standard and not implementing it would deviate from
-	 * the standard, so we will do it here in phpCrypt.
-	 *
-	 * @param string $m The plain text message
-	 * @return array the Initial Permutation (IP)
-	 */
-	private function ip($text)
-	{
-		$text = parent::str2Bin($text);
-		$ip = "";
-
-		// loop through the 64 bit block, ordering it occording to $_ip
-		for($i = 0; $i < 64; ++$i)
-			$ip .= $text[self::$_ip[$i] - 1];
-
-		return $ip;
-	}
-
-
-	/**
-	 * Function F - To calculate f, we first expand each block Rn-1 from 32 bits to 48 bits.
-	 * This is done by using a selection table that repeats some of the bits in Rn-1. We'll
-	 * call the use of this selection table the function E. Thus E(Rn-1) has a 32 bit input
-	 * block, and a 48 bit output block.
-	 *
-	 * @param array $r  32 bit binary, each bit in an array element
-	 * @param string $k 48 bit binary string
-	 * @return string 48 bit binary string
-	 */
-	private function f($r, $k)
-	{
-		$bin = parent::xorBin($k, $this->E($r));
-
-		// create a 32-bit string from $bits by passing it through the S-Boxes
-		$bin = $this->s($bin);
-
-		// now send permute $bin as defined by table self::$_p
-		$bin = $this->p($bin);
-
-		return $bin;
-	}
-
-
-	/**
-	 * Function E - Let E be such that the 48 bits of its output, written as 8 blocks of
-	 * 6 bits each, are obtained by selecting the bits in its inputs in order according
-	 * to the self::$_e[] table.
-	 * This is only used in the F() function
-	 *
-	 * @param array $r 32 bit binary, each bit in an array element
-	 * @return string 48 bit binary string
-	 */
-	private function e($r)
-	{
-		$e = "";
-		for($i = 0; $i < 48; ++$i)
-			$e .= $r[self::$_e[$i] - 1];
-
-		return $e;
-	}
-
-
-	/**
-	 * S-Box
-	 * Take a 48-bit string from F() and run it through the S-Boxes, this requires
-	 * us to break up the 48-bit string into 8 groups of 6 bits before sending it
-	 * through the S-Boxes
-	 *
-	 * @param string $bits The 48-bit string from F() to be processed
-	 * @return string A 32-bit string from created from the 48-bit string after passing through S-Boxes
-	 */
-	private function s($bits)
-	{
-		$s = "";
-
-		for($i = 0; $i <= 42; $i += 6)
-		{
-			$sbits = substr($bits, $i, 6);
-
-			// we need to determine the S-Box column number and row number
-			// from the 6 bit string passed in, this is done using the following method:
-			// The First & Last bits represent a number between 0-3, used to determine which row
-			// The middle 4 bits represent a number between 0-15, used to determine the column
-			$row = bindec("{$sbits[0]}{$sbits[5]}");
-			$col = bindec("{$sbits[1]}{$sbits[2]}{$sbits[3]}{$sbits[4]}");
-
-			// determine the position in the S-BOX, S-Box table is in self::$_s[]
-			$pos = ($row * 16) + $col;
-
-			// get the integer from the S-Box and convert it to binary
-			$bin = decbin(self::$_s[($i/6)][$pos]);
-			$s .= str_pad($bin, 4, "0", STR_PAD_LEFT);
-		}
-
-		return $s;
-	}
-
-
-	/**
-	 * Permutation P
-	 * The permutation P is defined in self::$_p. P() returns a 32-bit output
-	 * from a 32-bit input from a binary string from the S-BOX by permuting
-	 * the bits of the input block.
-	 * This is only used inside of F() function
-	 *
-	 * @param string $s A 32-bit string originating from being passed through S-Box
-	 * @return string A 32-bit string, which is $s permuted through table self::$_p
-	 */
-	private function p($s)
-	{
-		$p = "";
-		for($i = 0; $i < 32; ++$i)
-			$p .= $s[self::$_p[$i] - 1];
-
-		return $p;
-	}
-
-
-	/**
-	 * Final Permutation (FP)
-	 * Read the comment about IP and FP being unecessary in software implmented DES (though
-	 * we will do it to follow the DES standard).
-	 *
-	 * @param string $bin A 64-bit binary string
-	 * @return string A 64-bit binary string that has been run through self::$_fp[] table
-	 */
-	private function fp($bin)
-	{
-		$fp = "";
-		for($i = 0; $i < 64; ++$i)
-			$fp .= $bin[self::$_fp[$i] - 1];
-
-		return $fp;
-	}
-
-
-	/**
-	 * Initialize all the tables, this function is called inside the constructor
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		// permuted choice 1 (PC1)
-		// these values are chars and should be run through chr() when used
-		self::$_pc1 = array(
-			57, 49, 41, 33, 25, 17,  9,
-			 1, 58, 50, 42, 34, 26, 18,
-			10,  2, 59, 51, 43, 35, 27,
-			19, 11,  3, 60, 52, 44, 36,
-			63, 55, 47, 39, 31, 23, 15,
-			 7, 62, 54, 46, 38, 30, 22,
-			14,  6, 61, 53, 45, 37, 29,
-			21, 13,  5, 28, 20, 12,  4
-		);
-
-		// permuted choice 2 (PC2)
-		// these values are chars and should be run through chr() when used
-		self::$_pc2 = array(
-			14, 17, 11, 24,  1,  5,
-			 3, 28, 15,  6, 21, 10,
-			23, 19, 12,  4, 26,  8,
-			16,  7, 27, 20, 13,  2,
-			41, 52, 31, 37, 47, 55,
-			30, 40, 51, 45, 33, 48,
-			44, 49, 39, 56, 34, 53,
-			46, 42, 50, 36, 29, 32
-		);
-
-		// initial permutation (IP)
-		self::$_ip = array(
-			58, 50, 42, 34, 26, 18, 10, 2,
-			60, 52, 44, 36, 28, 20, 12, 4,
-			62, 54, 46, 38, 30, 22, 14, 6,
-			64, 56, 48, 40, 32, 24, 16, 8,
-			57, 49, 41, 33, 25, 17,  9, 1,
-			59, 51, 43, 35, 27, 19, 11, 3,
-			61, 53, 45, 37, 29, 21, 13, 5,
-			63, 55, 47, 39, 31, 23, 15, 7
-		);
-
-		// expansion (E)
-		self::$_e = array(
-			32,  1,  2,  3,  4,  5,
-			 4,  5,  6,  7,  8,  9,
-			 8,  9, 10, 11, 12, 13,
-			12, 13, 14, 15, 16, 17,
-			16, 17, 18, 19, 20, 21,
-			20, 21, 22, 23, 24, 25,
-			24, 25, 26, 27, 28, 29,
-			28, 29, 30, 31, 32,  1
-		);
-
-		// substition box (S)
-		self::$_s = array(
-			/* S1 */
-			array(
-				14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
-				 0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
-				 4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
-				15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13
-			),
-
-			/* S2 */
-			array(
-				15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
-				 3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
-				 0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
-				13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9
-			),
-
-			/* S3 */
-			array(
-				10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
-				13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
-				13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
-				 1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12
-			),
-
-			/* S4 */
-			array(
-				 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
-				13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
-				10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
-				 3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14
-			),
-
-			/* S5 */
-			array(
-				 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
-				14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
-				 4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
-				11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3
-			),
-
-			/* S6 */
-			array(
-				12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
-				10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
-				 9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
-				 4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13
-			),
-
-			/* S7 */
-			array(
-				 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
-				13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
-				 1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
-				 6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12
-			),
-
-			/* S8 */
-			array(
-				13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
-				 1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
-				 7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
-				 2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
-			)
-		);
-
-		// permutation (P)
-		self::$_p = array(
-			16,  7, 20, 21,
-			29, 12, 28, 17,
-			 1, 15, 23, 26,
-			 5, 18, 31, 10,
-			 2,  8, 24, 14,
-			32, 27,  3,  9,
-			19, 13, 30,  6,
-			22, 11,  4, 25
-		);
-
-		// final permutation (FP)
-		self::$_fp = array(
-			40, 8, 48, 16, 56, 24, 64, 32,
-			39, 7, 47, 15, 55, 23, 63, 31,
-			38, 6, 46, 14, 54, 22, 62, 30,
-			37, 5, 45, 13, 53, 21, 61, 29,
-			36, 4, 44, 12, 52, 20, 60, 28,
-			35, 3, 43, 11, 51, 19, 59, 27,
-			34, 2, 42, 10, 50, 18, 58, 26,
-			33, 1, 41,  9, 49, 17, 57, 25
-		);
-
-		// key schedule used in KeyPermutation()
-		self::$_key_sched = array(1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+        // split $pc1m in half (C0 and D0)
+        $c[0] = array_slice($pc1m, 0, 28);
+        $d[0] = array_slice($pc1m, 28, 28);
+
+        // now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
+        // where 1 <= n <= 16
+        for($i = 1; $i <= 16; ++$i)
+        {
+            // now set the next Cn and Dn as the previous Cn and Dn
+            $c[$i] = $c[$i-1];
+            $d[$i] = $d[$i-1];
+
+            for($j = 0; $j < self::$_key_sched[$i-1]; ++$j)
+            {
+                // do a left shift, move each bit one place to the left,
+                // except for the first bit, which is cycled to the end
+                // of the block.
+                $c[$i][] = array_shift($c[$i]);
+                $d[$i][] = array_shift($d[$i]);
+            }
+
+            // We now form the sub_keys (Kn), for 1<=n<=16, by applying the
+            // following permutation table to each of the concatenated
+            // pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
+            // of these.
+            $CnDn = array_merge($c[$i], $d[$i]);
+            $this->sub_keys[$i-1] = "";
+            for($j = 0; $j < 48; ++$j)
+                $this->sub_keys[$i-1] .= $CnDn[self::$_pc2[$j] - 1];
+        }
+
+        // the sub_keys are created, we are done with the key permutation
+    }
+
+
+    /**
+     * Initial Permutation (IP)
+     * Now we encode each 64-bit block of data. There is an initial permutation IP of
+     * the 64 bits of the message data M. This rearranges the bits according to the
+     * following table, where the entries in the table show the new arrangement of the
+     * bits from their initial order. The 58th bit of M becomes the first bit of IP.
+     * The 50th bit of M becomes the second bit of IP. The 7th bit of M is the last
+     * bit of IP.
+     *
+     * According to the book Applied Cryptography (Bruce Schneier, 2nd edition, pg. 271):
+     * The initial permution was used to make it easier to load plain text and cipher text
+     * data into a DES chip in byte-sized pieces when doing DES in hardware. The IP and FP
+     * are not necessary in software implementations and do not affect the security. However,
+     * the IP and FP are part of the DES standard and not implementing it would deviate from
+     * the standard, so we will do it here in phpCrypt.
+     *
+     * @param string $m The plain text message
+     * @return array the Initial Permutation (IP)
+     */
+    private function ip($text)
+    {
+        $text = parent::str2Bin($text);
+        $ip = "";
+
+        // loop through the 64 bit block, ordering it occording to $_ip
+        for($i = 0; $i < 64; ++$i)
+            $ip .= $text[self::$_ip[$i] - 1];
+
+        return $ip;
+    }
+
+
+    /**
+     * Function F - To calculate f, we first expand each block Rn-1 from 32 bits to 48 bits.
+     * This is done by using a selection table that repeats some of the bits in Rn-1. We'll
+     * call the use of this selection table the function E. Thus E(Rn-1) has a 32 bit input
+     * block, and a 48 bit output block.
+     *
+     * @param array $r  32 bit binary, each bit in an array element
+     * @param string $k 48 bit binary string
+     * @return string 48 bit binary string
+     */
+    private function f($r, $k)
+    {
+        $bin = parent::xorBin($k, $this->E($r));
+
+        // create a 32-bit string from $bits by passing it through the S-Boxes
+        $bin = $this->s($bin);
+
+        // now send permute $bin as defined by table self::$_p
+        $bin = $this->p($bin);
+
+        return $bin;
+    }
+
+
+    /**
+     * Function E - Let E be such that the 48 bits of its output, written as 8 blocks of
+     * 6 bits each, are obtained by selecting the bits in its inputs in order according
+     * to the self::$_e[] table.
+     * This is only used in the F() function
+     *
+     * @param array $r 32 bit binary, each bit in an array element
+     * @return string 48 bit binary string
+     */
+    private function e($r)
+    {
+        $e = "";
+        for($i = 0; $i < 48; ++$i)
+            $e .= $r[self::$_e[$i] - 1];
+
+        return $e;
+    }
+
+
+    /**
+     * S-Box
+     * Take a 48-bit string from F() and run it through the S-Boxes, this requires
+     * us to break up the 48-bit string into 8 groups of 6 bits before sending it
+     * through the S-Boxes
+     *
+     * @param string $bits The 48-bit string from F() to be processed
+     * @return string A 32-bit string from created from the 48-bit string after passing through S-Boxes
+     */
+    private function s($bits)
+    {
+        $s = "";
+
+        for($i = 0; $i <= 42; $i += 6)
+        {
+            $sbits = substr($bits, $i, 6);
+
+            // we need to determine the S-Box column number and row number
+            // from the 6 bit string passed in, this is done using the following method:
+            // The First & Last bits represent a number between 0-3, used to determine which row
+            // The middle 4 bits represent a number between 0-15, used to determine the column
+            $row = bindec("{$sbits[0]}{$sbits[5]}");
+            $col = bindec("{$sbits[1]}{$sbits[2]}{$sbits[3]}{$sbits[4]}");
+
+            // determine the position in the S-BOX, S-Box table is in self::$_s[]
+            $pos = ($row * 16) + $col;
+
+            // get the integer from the S-Box and convert it to binary
+            $bin = decbin(self::$_s[($i/6)][$pos]);
+            $s .= str_pad($bin, 4, "0", STR_PAD_LEFT);
+        }
+
+        return $s;
+    }
+
+
+    /**
+     * Permutation P
+     * The permutation P is defined in self::$_p. P() returns a 32-bit output
+     * from a 32-bit input from a binary string from the S-BOX by permuting
+     * the bits of the input block.
+     * This is only used inside of F() function
+     *
+     * @param string $s A 32-bit string originating from being passed through S-Box
+     * @return string A 32-bit string, which is $s permuted through table self::$_p
+     */
+    private function p($s)
+    {
+        $p = "";
+        for($i = 0; $i < 32; ++$i)
+            $p .= $s[self::$_p[$i] - 1];
+
+        return $p;
+    }
+
+
+    /**
+     * Final Permutation (FP)
+     * Read the comment about IP and FP being unecessary in software implmented DES (though
+     * we will do it to follow the DES standard).
+     *
+     * @param string $bin A 64-bit binary string
+     * @return string A 64-bit binary string that has been run through self::$_fp[] table
+     */
+    private function fp($bin)
+    {
+        $fp = "";
+        for($i = 0; $i < 64; ++$i)
+            $fp .= $bin[self::$_fp[$i] - 1];
+
+        return $fp;
+    }
+
+
+    /**
+     * Initialize all the tables, this function is called inside the constructor
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        // permuted choice 1 (PC1)
+        // these values are chars and should be run through chr() when used
+        self::$_pc1 = array(
+            57, 49, 41, 33, 25, 17,  9,
+                1, 58, 50, 42, 34, 26, 18,
+            10,  2, 59, 51, 43, 35, 27,
+            19, 11,  3, 60, 52, 44, 36,
+            63, 55, 47, 39, 31, 23, 15,
+                7, 62, 54, 46, 38, 30, 22,
+            14,  6, 61, 53, 45, 37, 29,
+            21, 13,  5, 28, 20, 12,  4
+        );
+
+        // permuted choice 2 (PC2)
+        // these values are chars and should be run through chr() when used
+        self::$_pc2 = array(
+            14, 17, 11, 24,  1,  5,
+                3, 28, 15,  6, 21, 10,
+            23, 19, 12,  4, 26,  8,
+            16,  7, 27, 20, 13,  2,
+            41, 52, 31, 37, 47, 55,
+            30, 40, 51, 45, 33, 48,
+            44, 49, 39, 56, 34, 53,
+            46, 42, 50, 36, 29, 32
+        );
+
+        // initial permutation (IP)
+        self::$_ip = array(
+            58, 50, 42, 34, 26, 18, 10, 2,
+            60, 52, 44, 36, 28, 20, 12, 4,
+            62, 54, 46, 38, 30, 22, 14, 6,
+            64, 56, 48, 40, 32, 24, 16, 8,
+            57, 49, 41, 33, 25, 17,  9, 1,
+            59, 51, 43, 35, 27, 19, 11, 3,
+            61, 53, 45, 37, 29, 21, 13, 5,
+            63, 55, 47, 39, 31, 23, 15, 7
+        );
+
+        // expansion (E)
+        self::$_e = array(
+            32,  1,  2,  3,  4,  5,
+                4,  5,  6,  7,  8,  9,
+                8,  9, 10, 11, 12, 13,
+            12, 13, 14, 15, 16, 17,
+            16, 17, 18, 19, 20, 21,
+            20, 21, 22, 23, 24, 25,
+            24, 25, 26, 27, 28, 29,
+            28, 29, 30, 31, 32,  1
+        );
+
+        // substition box (S)
+        self::$_s = array(
+            /* S1 */
+            array(
+                14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
+                    0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
+                    4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
+                15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13
+            ),
+
+            /* S2 */
+            array(
+                15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
+                    3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
+                    0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
+                13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9
+            ),
+
+            /* S3 */
+            array(
+                10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
+                13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
+                13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
+                    1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12
+            ),
+
+            /* S4 */
+            array(
+                    7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
+                13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
+                10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
+                    3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14
+            ),
+
+            /* S5 */
+            array(
+                    2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
+                14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
+                    4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
+                11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3
+            ),
+
+            /* S6 */
+            array(
+                12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
+                10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
+                    9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
+                    4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13
+            ),
+
+            /* S7 */
+            array(
+                    4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
+                13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
+                    1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
+                    6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12
+            ),
+
+            /* S8 */
+            array(
+                13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
+                    1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
+                    7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
+                    2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
+            )
+        );
+
+        // permutation (P)
+        self::$_p = array(
+            16,  7, 20, 21,
+            29, 12, 28, 17,
+                1, 15, 23, 26,
+                5, 18, 31, 10,
+                2,  8, 24, 14,
+            32, 27,  3,  9,
+            19, 13, 30,  6,
+            22, 11,  4, 25
+        );
+
+        // final permutation (FP)
+        self::$_fp = array(
+            40, 8, 48, 16, 56, 24, 64, 32,
+            39, 7, 47, 15, 55, 23, 63, 31,
+            38, 6, 46, 14, 54, 22, 62, 30,
+            37, 5, 45, 13, 53, 21, 61, 29,
+            36, 4, 44, 12, 52, 20, 60, 28,
+            35, 3, 43, 11, 51, 19, 59, 27,
+            34, 2, 42, 10, 50, 18, 58, 26,
+            33, 1, 41,  9, 49, 17, 57, 25
+        );
+
+        // key schedule used in KeyPermutation()
+        self::$_key_sched = array(1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1);
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

Spacing +73 added lines, -73 removed lines

@@ -199,17 +199,17 @@ 
 		$l[0] = substr($data, 0, 32);
 		$r[0] = substr($data, 32, 32);
 
-		for($n = 1; $n <= 16; ++$n)
+		for ($n = 1; $n <= 16; ++$n)
 		{
-			$l[$n] = $r[$n-1];
+			$l[$n] = $r[$n - 1];
 
-			if($this->operation() == parent::DECRYPT)
-				$f = $this->F($r[$n-1], $this->sub_keys[16-$n]);
+			if ($this->operation() == parent::DECRYPT)
+				$f = $this->F($r[$n - 1], $this->sub_keys[16 - $n]);
 			else
-				$f = $this->F($r[$n-1], $this->sub_keys[$n-1]);
+				$f = $this->F($r[$n - 1], $this->sub_keys[$n - 1]);
 
 			// XOR F with Ln
-			$r[$n] = $this->xorBin($l[$n-1], $f);
+			$r[$n] = $this->xorBin($l[$n - 1], $f);
 		}
 
 		// now we combine L[16] and R[16] back into a 64-bit string, but we reverse
@@ -242,7 +242,7 @@ 
 		$binkey = parent::str2Bin($this->key());
 
 		// reduce the key down to 56bits based on table $_pc1
-		for($i = 0; $i < 56; ++$i)
+		for ($i = 0; $i < 56; ++$i)
             $pc1m[$i] = $binkey[self::$_pc1[$i] - 1];
 
 		// split $pc1m in half (C0 and D0)
@@ -251,13 +251,13 @@ 
 
 		// now that $c[0] and $d[0] are defined, create 16 blocks for Cn and Dn
 		// where 1 <= n <= 16
-		for($i = 1; $i <= 16; ++$i)
+		for ($i = 1; $i <= 16; ++$i)
 		{
 			// now set the next Cn and Dn as the previous Cn and Dn
-			$c[$i] = $c[$i-1];
-			$d[$i] = $d[$i-1];
+			$c[$i] = $c[$i - 1];
+			$d[$i] = $d[$i - 1];
 
-			for($j = 0; $j < self::$_key_sched[$i-1]; ++$j)
+			for ($j = 0; $j < self::$_key_sched[$i - 1]; ++$j)
 			{
 				// do a left shift, move each bit one place to the left,
 				// except for the first bit, which is cycled to the end
@@ -271,9 +271,9 @@ 
 			// pairs CnDn. Each pair has 56 bits, but PC-2 only uses 48
 			// of these.
 			$CnDn = array_merge($c[$i], $d[$i]);
-			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[self::$_pc2[$j] - 1];
+			$this->sub_keys[$i - 1] = "";
+			for ($j = 0; $j < 48; ++$j)
+				$this->sub_keys[$i - 1] .= $CnDn[self::$_pc2[$j] - 1];
 		}
 
 		// the sub_keys are created, we are done with the key permutation
@@ -305,7 +305,7 @@ 
 		$ip = "";
 
 		// loop through the 64 bit block, ordering it occording to $_ip
-		for($i = 0; $i < 64; ++$i)
+		for ($i = 0; $i < 64; ++$i)
 			$ip .= $text[self::$_ip[$i] - 1];
 
 		return $ip;
@@ -348,7 +348,7 @@ 
 	private function e($r)
 	{
 		$e = "";
-		for($i = 0; $i < 48; ++$i)
+		for ($i = 0; $i < 48; ++$i)
 			$e .= $r[self::$_e[$i] - 1];
 
 		return $e;
@@ -368,7 +368,7 @@ 
 	{
 		$s = "";
 
-		for($i = 0; $i <= 42; $i += 6)
+		for ($i = 0; $i <= 42; $i += 6)
 		{
 			$sbits = substr($bits, $i, 6);
 
@@ -383,7 +383,7 @@ 
 			$pos = ($row * 16) + $col;
 
 			// get the integer from the S-Box and convert it to binary
-			$bin = decbin(self::$_s[($i/6)][$pos]);
+			$bin = decbin(self::$_s[($i / 6)][$pos]);
 			$s .= str_pad($bin, 4, "0", STR_PAD_LEFT);
 		}
 
@@ -404,7 +404,7 @@ 
 	private function p($s)
 	{
 		$p = "";
-		for($i = 0; $i < 32; ++$i)
+		for ($i = 0; $i < 32; ++$i)
 			$p .= $s[self::$_p[$i] - 1];
 
 		return $p;
@@ -422,7 +422,7 @@ 
 	private function fp($bin)
 	{
 		$fp = "";
-		for($i = 0; $i < 64; ++$i)
+		for ($i = 0; $i < 64; ++$i)
 			$fp .= $bin[self::$_fp[$i] - 1];
 
 		return $fp;
@@ -439,23 +439,23 @@ 
 		// permuted choice 1 (PC1)
 		// these values are chars and should be run through chr() when used
 		self::$_pc1 = array(
-			57, 49, 41, 33, 25, 17,  9,
+			57, 49, 41, 33, 25, 17, 9,
 			 1, 58, 50, 42, 34, 26, 18,
-			10,  2, 59, 51, 43, 35, 27,
-			19, 11,  3, 60, 52, 44, 36,
+			10, 2, 59, 51, 43, 35, 27,
+			19, 11, 3, 60, 52, 44, 36,
 			63, 55, 47, 39, 31, 23, 15,
 			 7, 62, 54, 46, 38, 30, 22,
-			14,  6, 61, 53, 45, 37, 29,
-			21, 13,  5, 28, 20, 12,  4
+			14, 6, 61, 53, 45, 37, 29,
+			21, 13, 5, 28, 20, 12, 4
 		);
 
 		// permuted choice 2 (PC2)
 		// these values are chars and should be run through chr() when used
 		self::$_pc2 = array(
-			14, 17, 11, 24,  1,  5,
-			 3, 28, 15,  6, 21, 10,
-			23, 19, 12,  4, 26,  8,
-			16,  7, 27, 20, 13,  2,
+			14, 17, 11, 24, 1, 5,
+			 3, 28, 15, 6, 21, 10,
+			23, 19, 12, 4, 26, 8,
+			16, 7, 27, 20, 13, 2,
 			41, 52, 31, 37, 47, 55,
 			30, 40, 51, 45, 33, 48,
 			44, 49, 39, 56, 34, 53,
@@ -468,7 +468,7 @@ 
 			60, 52, 44, 36, 28, 20, 12, 4,
 			62, 54, 46, 38, 30, 22, 14, 6,
 			64, 56, 48, 40, 32, 24, 16, 8,
-			57, 49, 41, 33, 25, 17,  9, 1,
+			57, 49, 41, 33, 25, 17, 9, 1,
 			59, 51, 43, 35, 27, 19, 11, 3,
 			61, 53, 45, 37, 29, 21, 13, 5,
 			63, 55, 47, 39, 31, 23, 15, 7
@@ -476,93 +476,93 @@ 
 
 		// expansion (E)
 		self::$_e = array(
-			32,  1,  2,  3,  4,  5,
-			 4,  5,  6,  7,  8,  9,
-			 8,  9, 10, 11, 12, 13,
+			32, 1, 2, 3, 4, 5,
+			 4, 5, 6, 7, 8, 9,
+			 8, 9, 10, 11, 12, 13,
 			12, 13, 14, 15, 16, 17,
 			16, 17, 18, 19, 20, 21,
 			20, 21, 22, 23, 24, 25,
 			24, 25, 26, 27, 28, 29,
-			28, 29, 30, 31, 32,  1
+			28, 29, 30, 31, 32, 1
 		);
 
 		// substition box (S)
 		self::$_s = array(
 			/* S1 */
 			array(
-				14,  4, 13,  1,  2, 15, 11,  8,  3, 10,  6, 12,  5,  9,  0,  7,
-				 0, 15,  7,  4, 14,  2, 13,  1, 10,  6, 12, 11,  9,  5,  3,  8,
-				 4,  1, 14,  8, 13,  6,  2, 11, 15, 12,  9,  7,  3, 10,  5,  0,
-				15, 12,  8,  2,  4,  9,  1,  7,  5, 11,  3, 14, 10,  0,  6, 13
+				14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
+				 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
+				 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
+				15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13
 			),
 
 			/* S2 */
 			array(
-				15,  1,  8, 14,  6, 11,  3,  4,  9,  7,  2, 13, 12,  0,  5, 10,
-				 3, 13,  4,  7, 15,  2,  8, 14, 12,  0,  1, 10,  6,  9, 11,  5,
-				 0, 14,  7, 11, 10,  4, 13,  1,  5,  8, 12,  6,  9,  3,  2, 15,
-				13,  8, 10,  1,  3, 15,  4,  2, 11,  6,  7, 12,  0,  5, 14,  9
+				15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
+				 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
+				 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
+				13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9
 			),
 
 			/* S3 */
 			array(
-				10,  0,  9, 14,  6,  3, 15,  5,  1, 13, 12,  7, 11,  4,  2,  8,
-				13,  7,  0,  9,  3,  4,  6, 10,  2,  8,  5, 14, 12, 11, 15,  1,
-				13,  6,  4,  9,  8, 15,  3,  0, 11,  1,  2, 12,  5, 10, 14,  7,
-				 1, 10, 13,  0,  6,  9,  8,  7,  4, 15, 14,  3, 11,  5,  2, 12
+				10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
+				13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
+				13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
+				 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12
 			),
 
 			/* S4 */
 			array(
-				 7, 13, 14,  3,  0,  6,  9, 10,  1,  2,  8,  5, 11, 12,  4, 15,
-				13,  8, 11,  5,  6, 15,  0,  3,  4,  7,  2, 12,  1, 10, 14,  9,
-				10,  6,  9,  0, 12, 11,  7, 13, 15,  1,  3, 14,  5,  2,  8,  4,
-				 3, 15,  0,  6, 10,  1, 13,  8,  9,  4,  5, 11, 12,  7,  2, 14
+				 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
+				13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
+				10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
+				 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14
 			),
 
 			/* S5 */
 			array(
-				 2, 12,  4,  1,  7, 10, 11,  6,  8,  5,  3, 15, 13,  0, 14,  9,
-				14, 11,  2, 12,  4,  7, 13,  1,  5,  0, 15, 10,  3,  9,  8,  6,
-				 4,  2,  1, 11, 10, 13,  7,  8, 15,  9, 12,  5,  6,  3,  0, 14,
-				11,  8, 12,  7,  1, 14,  2, 13,  6, 15,  0,  9, 10,  4,  5,  3
+				 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
+				14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
+				 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
+				11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3
 			),
 
 			/* S6 */
 			array(
-				12,  1, 10, 15,  9,  2,  6,  8,  0, 13,  3,  4, 14,  7,  5, 11,
-				10, 15,  4,  2,  7, 12,  9,  5,  6,  1, 13, 14,  0, 11,  3,  8,
-				 9, 14, 15,  5,  2,  8, 12,  3,  7,  0,  4, 10,  1, 13, 11,  6,
-				 4,  3,  2, 12,  9,  5, 15, 10, 11, 14,  1,  7,  6,  0,  8, 13
+				12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
+				10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
+				 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
+				 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13
 			),
 
 			/* S7 */
 			array(
-				 4, 11,  2, 14, 15,  0,  8, 13,  3, 12,  9,  7,  5, 10,  6,  1,
-				13,  0, 11,  7,  4,  9,  1, 10, 14,  3,  5, 12,  2, 15,  8,  6,
-				 1,  4, 11, 13, 12,  3,  7, 14, 10, 15,  6,  8,  0,  5,  9,  2,
-				 6, 11, 13,  8,  1,  4, 10,  7,  9,  5,  0, 15, 14,  2,  3, 12
+				 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
+				13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
+				 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
+				 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12
 			),
 
 			/* S8 */
 			array(
-				13,  2,  8,  4,  6, 15, 11,  1, 10,  9,  3, 14,  5,  0, 12,  7,
-				 1, 15, 13,  8, 10,  3,  7,  4, 12,  5,  6, 11,  0, 14,  9,  2,
-				 7, 11,  4,  1,  9, 12, 14,  2,  0,  6, 10, 13, 15,  3,  5,  8,
-				 2,  1, 14,  7,  4, 10,  8, 13, 15, 12,  9,  0,  3,  5,  6, 11
+				13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
+				 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
+				 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
+				 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
 			)
 		);
 
 		// permutation (P)
 		self::$_p = array(
-			16,  7, 20, 21,
+			16, 7, 20, 21,
 			29, 12, 28, 17,
 			 1, 15, 23, 26,
 			 5, 18, 31, 10,
-			 2,  8, 24, 14,
-			32, 27,  3,  9,
-			19, 13, 30,  6,
-			22, 11,  4, 25
+			 2, 8, 24, 14,
+			32, 27, 3, 9,
+			19, 13, 30, 6,
+			22, 11, 4, 25
 		);
 
 		// final permutation (FP)
@@ -574,11 +574,11 @@ 
 			36, 4, 44, 12, 52, 20, 60, 28,
 			35, 3, 43, 11, 51, 19, 59, 27,
 			34, 2, 42, 10, 50, 18, 58, 26,
-			33, 1, 41,  9, 49, 17, 57, 25
+			33, 1, 41, 9, 49, 17, 57, 25
 		);
 
 		// key schedule used in KeyPermutation()
-		self::$_key_sched = array(1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1);
+		self::$_key_sched = array(1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1);
 	}
 
 

Braces +23 added lines, -16 removed lines

@@ -203,10 +203,11 @@ 
 		{
 			$l[$n] = $r[$n-1];
 
-			if($this->operation() == parent::DECRYPT)
-				$f = $this->F($r[$n-1], $this->sub_keys[16-$n]);
-			else
-				$f = $this->F($r[$n-1], $this->sub_keys[$n-1]);
+			if($this->operation() == parent::DECRYPT) {
+							$f = $this->F($r[$n-1], $this->sub_keys[16-$n]);
+			} else {
+							$f = $this->F($r[$n-1], $this->sub_keys[$n-1]);
+			}
 
 			// XOR F with Ln
 			$r[$n] = $this->xorBin($l[$n-1], $f);
@@ -242,8 +243,9 @@ 
 		$binkey = parent::str2Bin($this->key());
 
 		// reduce the key down to 56bits based on table $_pc1
-		for($i = 0; $i < 56; ++$i)
-            $pc1m[$i] = $binkey[self::$_pc1[$i] - 1];
+		for($i = 0; $i < 56; ++$i) {
+		            $pc1m[$i] = $binkey[self::$_pc1[$i] - 1];
+		}
 
 		// split $pc1m in half (C0 and D0)
 		$c[0] = array_slice($pc1m, 0, 28);
@@ -272,8 +274,9 @@ 
 			// of these.
 			$CnDn = array_merge($c[$i], $d[$i]);
 			$this->sub_keys[$i-1] = "";
-			for($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i-1] .= $CnDn[self::$_pc2[$j] - 1];
+			for($j = 0; $j < 48; ++$j) {
+							$this->sub_keys[$i-1] .= $CnDn[self::$_pc2[$j] - 1];
+			}
 		}
 
 		// the sub_keys are created, we are done with the key permutation
@@ -305,8 +308,9 @@ 
 		$ip = "";
 
 		// loop through the 64 bit block, ordering it occording to $_ip
-		for($i = 0; $i < 64; ++$i)
-			$ip .= $text[self::$_ip[$i] - 1];
+		for($i = 0; $i < 64; ++$i) {
+					$ip .= $text[self::$_ip[$i] - 1];
+		}
 
 		return $ip;
 	}
@@ -348,8 +352,9 @@ 
 	private function e($r)
 	{
 		$e = "";
-		for($i = 0; $i < 48; ++$i)
-			$e .= $r[self::$_e[$i] - 1];
+		for($i = 0; $i < 48; ++$i) {
+					$e .= $r[self::$_e[$i] - 1];
+		}
 
 		return $e;
 	}
@@ -404,8 +409,9 @@ 
 	private function p($s)
 	{
 		$p = "";
-		for($i = 0; $i < 32; ++$i)
-			$p .= $s[self::$_p[$i] - 1];
+		for($i = 0; $i < 32; ++$i) {
+					$p .= $s[self::$_p[$i] - 1];
+		}
 
 		return $p;
 	}
@@ -422,8 +428,9 @@ 
 	private function fp($bin)
 	{
 		$fp = "";
-		for($i = 0; $i < 64; ++$i)
-			$fp .= $bin[self::$_fp[$i] - 1];
+		for($i = 0; $i < 64; ++$i) {
+					$fp .= $bin[self::$_fp[$i] - 1];
+		}
 
 		return $fp;
 	}

includes/libraries/phpcrypt/ciphers/Rijndael.php

Doc Comments +4 added lines, -4 removed lines

@@ -618,7 +618,7 @@ 
 	 * Expands the key
 	 * The key expands based on the block size as well as the key size
 	 *
-	 * @return void
+	 * @return boolean|null
 	 */
 	protected function expandKey()
 	{
@@ -635,7 +635,7 @@ 
 	 * Expand a 16 byte key, the size it is expanded to varies
 	 * based on the block size of the Rijndael implementation chosen
 	 *
-	 * @return void
+	 * @return boolean
 	 */
 	private function expandKey128()
 	{
@@ -695,7 +695,7 @@ 
 	 * Expand a 24 byte key, the size it is expanded to varies
 	 * based on the block size of the Rijndael implementation chosen
 	 *
-	 * @return void
+	 * @return boolean
 	 */
 	private function expandKey192()
 	{
@@ -755,7 +755,7 @@ 
 	 * Expand a 32 byte key, the size it is expanded to varies
 	 * based on the block size of the Rijndael implementation chosen
 	 *
-	 * @return void
+	 * @return boolean
 	 */
 	private function expandKey256()
 	{

Indentation +982 added lines, -982 removed lines

@@ -42,1000 +42,1000 @@
  */
 abstract class Cipher_Rijndael extends Cipher
 {
-	/** @type string $xkey The expanded key */
-	private $xkey = "";
-
-	/**
-	 * @type array $_key_sizes The accepted key sizes in bytes,
-	 * this should be considered a constant
-	 */
-	private static $_key_sizes = array(16, 24, 32);
-
-
-	// THE FOLLOWING TABLES ARE INITIALIZED IN initTables()
-
-	/**
-	 * @type array $_s The sbox,
-	 * this should be considered a constant
-	 */
-	private static $_s = array();
-
-	/**
-	 * @type array $_s_inv The inverse sbox
-	 * this should be considered a constant
-	 */
-	private static $_s_inv = array();
-
-	/**
-	 * @type array $_rcon The round constant,
-	 * this should be considered a constant
-	 */
-	private static $_rcon = array();
-
-	/**
-	 * @type array $s_matrix_mult The matrix multiplication table,
-	 * this should be considered a constant
-	 */
-	private static $_matrix_mult = array();
-
-	/**
-	 * @type array $_matrix_mult_inv The matrix multiplication
-	 * inverse table, this should be considered a constant
-	 */
-	private static $_matrix_mult_inv = array();
-
-	/*
+    /** @type string $xkey The expanded key */
+    private $xkey = "";
+
+    /**
+     * @type array $_key_sizes The accepted key sizes in bytes,
+     * this should be considered a constant
+     */
+    private static $_key_sizes = array(16, 24, 32);
+
+
+    // THE FOLLOWING TABLES ARE INITIALIZED IN initTables()
+
+    /**
+     * @type array $_s The sbox,
+     * this should be considered a constant
+     */
+    private static $_s = array();
+
+    /**
+     * @type array $_s_inv The inverse sbox
+     * this should be considered a constant
+     */
+    private static $_s_inv = array();
+
+    /**
+     * @type array $_rcon The round constant,
+     * this should be considered a constant
+     */
+    private static $_rcon = array();
+
+    /**
+     * @type array $s_matrix_mult The matrix multiplication table,
+     * this should be considered a constant
+     */
+    private static $_matrix_mult = array();
+
+    /**
+     * @type array $_matrix_mult_inv The matrix multiplication
+     * inverse table, this should be considered a constant
+     */
+    private static $_matrix_mult_inv = array();
+
+    /*
 	 * Galois Multiplication lookup tables,
 	 * initialized in initTables()
 	 */
-	/**
-	 * @type array $_gm2 The Galois Multiplication table
-	 * for muliplying by 2, this should be considered a constant
-	 */
-	private static $_gm2 = array();
-
-	/**
-	 * @type array $_gm3 The Galois Multiplication table
-	 * for muliplying by 3, this should be considered a constant
-	 */
-	private static $_gm3 = array();
-
-	/**
-	 * @type array $_gm9 The Galois Multiplication table
-	 * for muliplying by 9, this should be considered a constant
-	 */
-	private static $_gm9 = array();
-
-	/**
-	 * @type array $_gm11 The Galois Multiplication table
-	 * for muliplying by 11, this should be considered a constant
-	 */
-	private static $_gm11 = array();
-
-	/**
-	 * @type array $_gm13 The Galois Multiplication table
-	 * for muliplying by 13, this should be considered a constant
-	 */
-	private static $_gm13 = array();
-
-	/**
-	 * @type array $_gm14 The Galois Multiplication table
-	 * for muliplying by 14, this should be considered a constant
-	 */
-	private static $_gm14 = array();
-
-
-	/**
-	 * Constructor
-	 * Sets the key used for encryption. Also sets the requied block size
-	 *
-	 * @param string The cipher name as set in a constant in the child class
-	 * @param string $key string containing the user supplied encryption key
-	 * @param integer $len Optional, the key size in bytes - used only by the AES child classes
-	 * @return void
-	 */
-	public function __construct($cipher_name, $key, $len = 0)
-	{
-		// AES will pass in a $len, since it has a fixed key size, other
-		// rijndael implementations can use variable key sizes, supported
-		// sizes are stored in self::$_key_sizes
-		if($len == 0)
-		{
-			// the key must be one of the following lengths: 16, 24, 32 bytes
-			$len = strlen($key);
-			if(!in_array($len, self::$_key_sizes))
-			{
-				$msg  = "Incorrect key length for ".strtoupper($cipher_name).". ";
-				$msg .= "Received $len bytes.";
-				trigger_error($msg, E_USER_WARNING);
-			}
-		}
-
-		// Setup the key
-		parent::__construct($cipher_name, $key, $len);
-
-		// initialize the tables used for rijndael/aes
-		$this->initTables();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Performs Rijndael encryption
-	 *
-	 * @param string @text The string to encrypt
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		// set the operation to decryption
-		$this->operation(parent::ENCRYPT);
-
-		$loops = 0;
-		$key_sz = $this->keySize();
-		$blk_sz = $this->blockSize();
-
-		// if the key and block size is 16, do 10 rounds
-		// if the key or block size is 24, and neither is longer than 24, do 12 rounds
-		// if either key or block size is 32, do 14 rounds
-		if($key_sz == 16 && $blk_sz == 16)
-			$loops = 10;
-		else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
-			$loops = 12;
-		else if($key_sz == 32 || $blk_sz == 32)
-			$loops = 14;
-
-		// now begin the encryption
-		$this->addRoundKey($text, 0);
-
-		for($i = 1; $i <= $loops; ++$i)
-		{
-			$this->byteSub($text);
-			$this->shiftRow($text);
-
-			// the last iteration does not use mixColumn
-			if($i < $loops)
-				$this->mixColumn($text);
-
-			$this->addRoundKey($text, $i);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Performs Rijndael decryption
-	 *
-	 * @param string @text The string to decrypt
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		// set the operation to decryption
-		$this->operation(parent::DECRYPT);
-
-		$loops = 0;
-		$key_sz = $this->keySize();
-		$blk_sz = $this->blockSize();
-
-		// if the key and block size is 16, do 10 rounds
-		// if the key or block size is 24, and neither is longer than 24, do 12 rounds
-		// if either key or block size is 32, do 14 rounds
-		if($key_sz == 16 && $blk_sz == 16)
-			$loops = 10;
-		else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
-			$loops = 12;
-		else if($key_sz == 32 || $blk_sz == 32)
-			$loops = 14;
-
-		// now begin the decryption
-		$this->addRoundKey($text, 0);
-
-		for($i = 1; $i <= $loops; ++$i)
-		{
-			$this->shiftRow($text);
-			$this->byteSub($text);
-			$this->addRoundKey($text, $i);
-
-			// the last iteration does not use mixColumn
-			if($i < $loops)
-				$this->mixColumn($text);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Indicates that this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
-
-
-	/**
-	 * Do the multiplication required in mixColumn()
-	 * We follow the description the multiplication from Wikipedia:
-	 * http://en.wikipedia.org/wiki/Advanced_Encryption_Standard#The_MixColumns_step
-	 *
-	 * @param integer $m A value from self::$_matrix_mult or self::$_matrix_mult_inv
-	 * @param integer $byte The value to multipy by $m
-	 * @return integer The result of the multiplication
-	 */
-	protected function mixColumnMultiply($m, $byte)
-	{
-		// if multiplying by 1, then we just return the same number
-		if($m == 0x01)
-			return $byte;
-
-		$hex = parent::dec2Hex($byte);
-		$row = parent::hex2Dec($hex[0]);
-		$col = parent::hex2Dec($hex[1]);
-		$pos = ($row * 16) + $col;
-
-		// multiply by 2 (comes from self::$_matrix_mult during encryption)
-		if($m == 0x02)
-			return self::$_gm2[$pos];
-
-		// multiply by 3 (comes from self::$_matrix_mult during encryption)
-		if($m == 0x03)
-			return self::$_gm3[$pos];
-
-		// multiply by 9 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x09)
-			return self::$_gm9[$pos];
-
-		// multiply by 11 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0b)
-			return self::$_gm11[$pos];
-
-		// multiply by 13 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0d)
-			return self::$_gm13[$pos];
-
-		// multiply by 14 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0e)
-			return self::$_gm14[$pos];
-	}
-
-
-	/**
-	 * Each time this function is called, it XORs the 16 bytes of $text
-	 * with the next 16 bytes from the $this->xkey. The expanded key
-	 * never has the same bytes used twice. Note that the first time
-	 * addRoundKey() is called, it will be outside of the rounds, so no
-	 * $round is given. Every call after that will be inside the rounds.
-	 *
-	 * @param string $text The text to encrypt/decrypt
-	 * @param integer $round The round we are on inside of rijndael()
-	 * @return void
-	 */
-	private function addRoundKey(&$text, $round)
-	{
-		// length of the xkey
-		$ek_len = strlen($this->xkey);
-		$len = $this->blockSize();
-
-		if($this->operation() == parent::ENCRYPT)
-			$offset = $round * $len;
-		else
-			$offset = ($ek_len - ($round * $len)) - $len;
-
-		for($i = 0; $i < $len; ++$i)
-			$text[$i] = $text[$i] ^ $this->xkey[$offset + $i];
-	}
-
-
-	/**
-	 * Applies the Sbox to each byte of the string passed in
-	 * This is used in key expansione
-	 *
-	 * @param string $text The string to peform the byte subsitution
-	 * @return void
-	 */
-	private function byteSub(&$text)
-	{
-		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
-		{
-			// the sbox is arrange in a 16 x 16 grid, where each row
-			// and column is numbered in hex (from 0 - f)
-			$hex = parent::str2Hex($text[$i]);
-			$row = parent::hex2Dec($hex[0]);
-			$col = parent::hex2Dec($hex[1]);
-			$pos = ($row * 16) + $col;
-
-			// return the corresponding value from the sbox
-			if($this->operation() == parent::ENCRYPT)
-				$text[$i] = chr(self::$_s[$pos]);
-			else // parent::DECRYPT uses the inverse sbox
-				$text[$i] = chr(self::$_s_inv[$pos]);
-		}
-	}
-
-
-	/**
-	 * This function is hard to explain, the easiest way to understand it is to read
-	 * http://www.net-security.org/dl/articles/AESbyExample.pdf, Section 5.4
-	 *
-	 * @param string $t The string to multiply bytes by the Galois Multiplication lookup tables
-	 * @return void
-	 */
-	private function mixColumn(&$t)
-	{
-		$tmp = $t;
-
-		// the matrix we use depends on if we are encrypting or decrypting
-		if($this->operation() == parent::ENCRYPT)
-			$m = self::$_matrix_mult;
-		else // parent::DECRYPT
-			$m = self::$_matrix_mult_inv;
-
-		// the number of rounds we make depends on the block size of the text
-		// used during encryption/decryption
-		// 128 has a 4x4 matrix, loop 4 times
-		// 192 has a 4x6 matrix, loop 6 times
-		// 256 has a 4x8 matrix, loop 8 times
-		$max_col = ($this->blockSize() * 8) / 32;
-
-		// loop through each column of the matrix
-		for($col = 0; $col < $max_col; ++$col)
-		{
-			$pos = $col * 4;
-
-			$a = $this->mixColumnMultiply($m[0],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[4],  ord($tmp[$pos + 1]));
-			$c = $this->mixColumnMultiply($m[8],  ord($tmp[$pos + 2]));
-			$d = $this->mixColumnMultiply($m[12], ord($tmp[$pos + 3]));
-			$t[$pos + 0] = chr($a ^ $b ^ $c ^ $d);
-
-			$a = $this->mixColumnMultiply($m[1],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[5],  ord($tmp[$pos + 1]));
-			$c = $this->mixColumnMultiply($m[9],  ord($tmp[$pos + 2]));
-			$d = $this->mixColumnMultiply($m[13], ord($tmp[$pos + 3]));
-			$t[$pos + 1] = chr($a ^ $b ^ $c ^ $d);
-
-			$a = $this->mixColumnMultiply($m[2],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[6],  ord($tmp[$pos + 1]));
-			$c = $this->mixColumnMultiply($m[10], ord($tmp[$pos + 2]));
-			$d = $this->mixColumnMultiply($m[14], ord($tmp[$pos + 3]));
-			$t[$pos + 2] = chr($a ^ $b ^ $c ^ $d);
-
-			$a = $this->mixColumnMultiply($m[3],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[7],  ord($tmp[$pos + 1]));
-			$c = $this->mixColumnMultiply($m[11], ord($tmp[$pos + 2]));
-			$d = $this->mixColumnMultiply($m[15], ord($tmp[$pos + 3]));
-			$t[$pos + 3] = chr($a ^ $b ^ $c ^ $d);
-		}
-	}
-
-
-	/**
-	 * Convert the 16, 24, or 32 bytes of $text into a matrix, and shift each row
-	 * n-bytes left for encryptiong, n-bytes right if we are decrypting.
-	 * Row shifts depend on the bit size of the block $text.
-	 * Rijndael-128/AES: 4x4 matrix
-	 * Rijndael-192:	6x4 matrix
-	 * Rijndael-256:	8x4 matrix
-	 *
-	 * @param string $text A 16, 24, or 32 byte string
-	 * @return void
-	 */
-	private function shiftRow(&$text)
-	{
-		/*
+    /**
+     * @type array $_gm2 The Galois Multiplication table
+     * for muliplying by 2, this should be considered a constant
+     */
+    private static $_gm2 = array();
+
+    /**
+     * @type array $_gm3 The Galois Multiplication table
+     * for muliplying by 3, this should be considered a constant
+     */
+    private static $_gm3 = array();
+
+    /**
+     * @type array $_gm9 The Galois Multiplication table
+     * for muliplying by 9, this should be considered a constant
+     */
+    private static $_gm9 = array();
+
+    /**
+     * @type array $_gm11 The Galois Multiplication table
+     * for muliplying by 11, this should be considered a constant
+     */
+    private static $_gm11 = array();
+
+    /**
+     * @type array $_gm13 The Galois Multiplication table
+     * for muliplying by 13, this should be considered a constant
+     */
+    private static $_gm13 = array();
+
+    /**
+     * @type array $_gm14 The Galois Multiplication table
+     * for muliplying by 14, this should be considered a constant
+     */
+    private static $_gm14 = array();
+
+
+    /**
+     * Constructor
+     * Sets the key used for encryption. Also sets the requied block size
+     *
+     * @param string The cipher name as set in a constant in the child class
+     * @param string $key string containing the user supplied encryption key
+     * @param integer $len Optional, the key size in bytes - used only by the AES child classes
+     * @return void
+     */
+    public function __construct($cipher_name, $key, $len = 0)
+    {
+        // AES will pass in a $len, since it has a fixed key size, other
+        // rijndael implementations can use variable key sizes, supported
+        // sizes are stored in self::$_key_sizes
+        if($len == 0)
+        {
+            // the key must be one of the following lengths: 16, 24, 32 bytes
+            $len = strlen($key);
+            if(!in_array($len, self::$_key_sizes))
+            {
+                $msg  = "Incorrect key length for ".strtoupper($cipher_name).". ";
+                $msg .= "Received $len bytes.";
+                trigger_error($msg, E_USER_WARNING);
+            }
+        }
+
+        // Setup the key
+        parent::__construct($cipher_name, $key, $len);
+
+        // initialize the tables used for rijndael/aes
+        $this->initTables();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Performs Rijndael encryption
+     *
+     * @param string @text The string to encrypt
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        // set the operation to decryption
+        $this->operation(parent::ENCRYPT);
+
+        $loops = 0;
+        $key_sz = $this->keySize();
+        $blk_sz = $this->blockSize();
+
+        // if the key and block size is 16, do 10 rounds
+        // if the key or block size is 24, and neither is longer than 24, do 12 rounds
+        // if either key or block size is 32, do 14 rounds
+        if($key_sz == 16 && $blk_sz == 16)
+            $loops = 10;
+        else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
+            $loops = 12;
+        else if($key_sz == 32 || $blk_sz == 32)
+            $loops = 14;
+
+        // now begin the encryption
+        $this->addRoundKey($text, 0);
+
+        for($i = 1; $i <= $loops; ++$i)
+        {
+            $this->byteSub($text);
+            $this->shiftRow($text);
+
+            // the last iteration does not use mixColumn
+            if($i < $loops)
+                $this->mixColumn($text);
+
+            $this->addRoundKey($text, $i);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Performs Rijndael decryption
+     *
+     * @param string @text The string to decrypt
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        // set the operation to decryption
+        $this->operation(parent::DECRYPT);
+
+        $loops = 0;
+        $key_sz = $this->keySize();
+        $blk_sz = $this->blockSize();
+
+        // if the key and block size is 16, do 10 rounds
+        // if the key or block size is 24, and neither is longer than 24, do 12 rounds
+        // if either key or block size is 32, do 14 rounds
+        if($key_sz == 16 && $blk_sz == 16)
+            $loops = 10;
+        else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
+            $loops = 12;
+        else if($key_sz == 32 || $blk_sz == 32)
+            $loops = 14;
+
+        // now begin the decryption
+        $this->addRoundKey($text, 0);
+
+        for($i = 1; $i <= $loops; ++$i)
+        {
+            $this->shiftRow($text);
+            $this->byteSub($text);
+            $this->addRoundKey($text, $i);
+
+            // the last iteration does not use mixColumn
+            if($i < $loops)
+                $this->mixColumn($text);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Indicates that this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
+
+
+    /**
+     * Do the multiplication required in mixColumn()
+     * We follow the description the multiplication from Wikipedia:
+     * http://en.wikipedia.org/wiki/Advanced_Encryption_Standard#The_MixColumns_step
+     *
+     * @param integer $m A value from self::$_matrix_mult or self::$_matrix_mult_inv
+     * @param integer $byte The value to multipy by $m
+     * @return integer The result of the multiplication
+     */
+    protected function mixColumnMultiply($m, $byte)
+    {
+        // if multiplying by 1, then we just return the same number
+        if($m == 0x01)
+            return $byte;
+
+        $hex = parent::dec2Hex($byte);
+        $row = parent::hex2Dec($hex[0]);
+        $col = parent::hex2Dec($hex[1]);
+        $pos = ($row * 16) + $col;
+
+        // multiply by 2 (comes from self::$_matrix_mult during encryption)
+        if($m == 0x02)
+            return self::$_gm2[$pos];
+
+        // multiply by 3 (comes from self::$_matrix_mult during encryption)
+        if($m == 0x03)
+            return self::$_gm3[$pos];
+
+        // multiply by 9 (comes from self::$_matrix_mult_inv during decryption)
+        if($m == 0x09)
+            return self::$_gm9[$pos];
+
+        // multiply by 11 (comes from self::$_matrix_mult_inv during decryption)
+        if($m == 0x0b)
+            return self::$_gm11[$pos];
+
+        // multiply by 13 (comes from self::$_matrix_mult_inv during decryption)
+        if($m == 0x0d)
+            return self::$_gm13[$pos];
+
+        // multiply by 14 (comes from self::$_matrix_mult_inv during decryption)
+        if($m == 0x0e)
+            return self::$_gm14[$pos];
+    }
+
+
+    /**
+     * Each time this function is called, it XORs the 16 bytes of $text
+     * with the next 16 bytes from the $this->xkey. The expanded key
+     * never has the same bytes used twice. Note that the first time
+     * addRoundKey() is called, it will be outside of the rounds, so no
+     * $round is given. Every call after that will be inside the rounds.
+     *
+     * @param string $text The text to encrypt/decrypt
+     * @param integer $round The round we are on inside of rijndael()
+     * @return void
+     */
+    private function addRoundKey(&$text, $round)
+    {
+        // length of the xkey
+        $ek_len = strlen($this->xkey);
+        $len = $this->blockSize();
+
+        if($this->operation() == parent::ENCRYPT)
+            $offset = $round * $len;
+        else
+            $offset = ($ek_len - ($round * $len)) - $len;
+
+        for($i = 0; $i < $len; ++$i)
+            $text[$i] = $text[$i] ^ $this->xkey[$offset + $i];
+    }
+
+
+    /**
+     * Applies the Sbox to each byte of the string passed in
+     * This is used in key expansione
+     *
+     * @param string $text The string to peform the byte subsitution
+     * @return void
+     */
+    private function byteSub(&$text)
+    {
+        $max = strlen($text);
+        for($i = 0; $i < $max; ++$i)
+        {
+            // the sbox is arrange in a 16 x 16 grid, where each row
+            // and column is numbered in hex (from 0 - f)
+            $hex = parent::str2Hex($text[$i]);
+            $row = parent::hex2Dec($hex[0]);
+            $col = parent::hex2Dec($hex[1]);
+            $pos = ($row * 16) + $col;
+
+            // return the corresponding value from the sbox
+            if($this->operation() == parent::ENCRYPT)
+                $text[$i] = chr(self::$_s[$pos]);
+            else // parent::DECRYPT uses the inverse sbox
+                $text[$i] = chr(self::$_s_inv[$pos]);
+        }
+    }
+
+
+    /**
+     * This function is hard to explain, the easiest way to understand it is to read
+     * http://www.net-security.org/dl/articles/AESbyExample.pdf, Section 5.4
+     *
+     * @param string $t The string to multiply bytes by the Galois Multiplication lookup tables
+     * @return void
+     */
+    private function mixColumn(&$t)
+    {
+        $tmp = $t;
+
+        // the matrix we use depends on if we are encrypting or decrypting
+        if($this->operation() == parent::ENCRYPT)
+            $m = self::$_matrix_mult;
+        else // parent::DECRYPT
+            $m = self::$_matrix_mult_inv;
+
+        // the number of rounds we make depends on the block size of the text
+        // used during encryption/decryption
+        // 128 has a 4x4 matrix, loop 4 times
+        // 192 has a 4x6 matrix, loop 6 times
+        // 256 has a 4x8 matrix, loop 8 times
+        $max_col = ($this->blockSize() * 8) / 32;
+
+        // loop through each column of the matrix
+        for($col = 0; $col < $max_col; ++$col)
+        {
+            $pos = $col * 4;
+
+            $a = $this->mixColumnMultiply($m[0],  ord($tmp[$pos + 0]));
+            $b = $this->mixColumnMultiply($m[4],  ord($tmp[$pos + 1]));
+            $c = $this->mixColumnMultiply($m[8],  ord($tmp[$pos + 2]));
+            $d = $this->mixColumnMultiply($m[12], ord($tmp[$pos + 3]));
+            $t[$pos + 0] = chr($a ^ $b ^ $c ^ $d);
+
+            $a = $this->mixColumnMultiply($m[1],  ord($tmp[$pos + 0]));
+            $b = $this->mixColumnMultiply($m[5],  ord($tmp[$pos + 1]));
+            $c = $this->mixColumnMultiply($m[9],  ord($tmp[$pos + 2]));
+            $d = $this->mixColumnMultiply($m[13], ord($tmp[$pos + 3]));
+            $t[$pos + 1] = chr($a ^ $b ^ $c ^ $d);
+
+            $a = $this->mixColumnMultiply($m[2],  ord($tmp[$pos + 0]));
+            $b = $this->mixColumnMultiply($m[6],  ord($tmp[$pos + 1]));
+            $c = $this->mixColumnMultiply($m[10], ord($tmp[$pos + 2]));
+            $d = $this->mixColumnMultiply($m[14], ord($tmp[$pos + 3]));
+            $t[$pos + 2] = chr($a ^ $b ^ $c ^ $d);
+
+            $a = $this->mixColumnMultiply($m[3],  ord($tmp[$pos + 0]));
+            $b = $this->mixColumnMultiply($m[7],  ord($tmp[$pos + 1]));
+            $c = $this->mixColumnMultiply($m[11], ord($tmp[$pos + 2]));
+            $d = $this->mixColumnMultiply($m[15], ord($tmp[$pos + 3]));
+            $t[$pos + 3] = chr($a ^ $b ^ $c ^ $d);
+        }
+    }
+
+
+    /**
+     * Convert the 16, 24, or 32 bytes of $text into a matrix, and shift each row
+     * n-bytes left for encryptiong, n-bytes right if we are decrypting.
+     * Row shifts depend on the bit size of the block $text.
+     * Rijndael-128/AES: 4x4 matrix
+     * Rijndael-192:	6x4 matrix
+     * Rijndael-256:	8x4 matrix
+     *
+     * @param string $text A 16, 24, or 32 byte string
+     * @return void
+     */
+    private function shiftRow(&$text)
+    {
+        /*
 		 * Rijndael-128 / AES
 		 */
-		if($this->blockSize() == 16)
-		{
-			if($this->operation() == parent::ENCRYPT)
-			{
-				// create a 4x4 matrix
-				// row 0 is unchanged,
-				// shift row 1 left 1 byte
-				// shift row 2 left 2 bytes
-				// shift row 3 left 3 bytes
-				$text = $text[0].$text[5].$text[10].$text[15].$text[4].$text[9].
-						$text[14].$text[3].$text[8].$text[13].$text[2].$text[7].
-						$text[12].$text[1].$text[6].$text[11];
-			}
-			else // parent::DECRYPT
-			{
-				// create a 4x4 matrix
-				// row 0 is unchanged,
-				// shift row 1 right 1 byte
-				// shift row 2 right 2 bytes
-				// shift row 3 right 3 bytes
-				$text = $text[0].$text[13].$text[10].$text[7].$text[4].$text[1].
-						$text[14].$text[11].$text[8].$text[5].$text[2].$text[15].
-						$text[12].$text[9].$text[6].$text[3];
-			}
-		}
-
-		/*
+        if($this->blockSize() == 16)
+        {
+            if($this->operation() == parent::ENCRYPT)
+            {
+                // create a 4x4 matrix
+                // row 0 is unchanged,
+                // shift row 1 left 1 byte
+                // shift row 2 left 2 bytes
+                // shift row 3 left 3 bytes
+                $text = $text[0].$text[5].$text[10].$text[15].$text[4].$text[9].
+                        $text[14].$text[3].$text[8].$text[13].$text[2].$text[7].
+                        $text[12].$text[1].$text[6].$text[11];
+            }
+            else // parent::DECRYPT
+            {
+                // create a 4x4 matrix
+                // row 0 is unchanged,
+                // shift row 1 right 1 byte
+                // shift row 2 right 2 bytes
+                // shift row 3 right 3 bytes
+                $text = $text[0].$text[13].$text[10].$text[7].$text[4].$text[1].
+                        $text[14].$text[11].$text[8].$text[5].$text[2].$text[15].
+                        $text[12].$text[9].$text[6].$text[3];
+            }
+        }
+
+        /*
 		 * Rijndael-192
 		 */
-		if($this->blockSize() == 24)
-		{
-			if($this->operation() == parent::ENCRYPT)
-			{
-				// create a 6x4 matrix
-				// row 0 is unchanged
-				// shift row 1 left 1 byte
-				// shift row 2 left 2 bytes
-				// shift row 3 left 3 bytes
-				$text = $text[0].$text[5].$text[10].$text[15].$text[4].$text[9].
-						$text[14].$text[19].$text[8].$text[13].$text[18].$text[23].
-						$text[12].$text[17].$text[22].$text[3].$text[16].$text[21].
-						$text[2].$text[7].$text[20].$text[1].$text[6].$text[11];
-
-			}
-			else // parent::DECRYPT
-			{
-				// create a 6x4 matrix
-				// row 0 is unchanged
-				// shift row 1 right 1 byte
-				// shift row 2 right 2 bytes
-				// shift row 3 right 3 bytes
-				$text = $text[0].$text[21].$text[18].$text[15].$text[4].$text[1].
-						$text[22].$text[19].$text[8].$text[5].$text[2].$text[23].
-						$text[12].$text[9].$text[6].$text[3].$text[16].$text[13].
-						$text[10].$text[7].$text[20].$text[17].$text[14].$text[11];
-			}
-		}
-
-		/*
+        if($this->blockSize() == 24)
+        {
+            if($this->operation() == parent::ENCRYPT)
+            {
+                // create a 6x4 matrix
+                // row 0 is unchanged
+                // shift row 1 left 1 byte
+                // shift row 2 left 2 bytes
+                // shift row 3 left 3 bytes
+                $text = $text[0].$text[5].$text[10].$text[15].$text[4].$text[9].
+                        $text[14].$text[19].$text[8].$text[13].$text[18].$text[23].
+                        $text[12].$text[17].$text[22].$text[3].$text[16].$text[21].
+                        $text[2].$text[7].$text[20].$text[1].$text[6].$text[11];
+
+            }
+            else // parent::DECRYPT
+            {
+                // create a 6x4 matrix
+                // row 0 is unchanged
+                // shift row 1 right 1 byte
+                // shift row 2 right 2 bytes
+                // shift row 3 right 3 bytes
+                $text = $text[0].$text[21].$text[18].$text[15].$text[4].$text[1].
+                        $text[22].$text[19].$text[8].$text[5].$text[2].$text[23].
+                        $text[12].$text[9].$text[6].$text[3].$text[16].$text[13].
+                        $text[10].$text[7].$text[20].$text[17].$text[14].$text[11];
+            }
+        }
+
+        /*
 		 * Rijndael-256
 		 */
-		if($this->blockSize() == 32)
-		{
-			if($this->operation() == parent::ENCRYPT)
-			{
-				// create an 8x4 matrix
-				// row 0 is unchanged
-				// shift row 1 left 1 byte
-				// shift row 2 left 3 bytes
-				// shift row 3 left 4 bytes
-				$text = $text[0].$text[5].$text[14].$text[19].$text[4].$text[9].$text[18].
-						$text[23].$text[8].$text[13].$text[22].$text[27].$text[12].$text[17].
-						$text[26].$text[31].$text[16].$text[21].$text[30].$text[3].$text[20].
-						$text[25].$text[2].$text[7].$text[24].$text[29].$text[6].$text[11].
-						$text[28].$text[1].$text[10].$text[15];
-			}
-			else // parent::DECRYPT
-			{
-				// create an 8x4 matrix
-				// row 0 is unchanged
-				// shift row 1 right 1 byte
-				// shift row 2 right 3 bytes
-				// shift row 3 right 4 bytes
-				$text = $text[0].$text[29].$text[22].$text[19].$text[4].$text[1].$text[26].
-						$text[23].$text[8].$text[5].$text[30].$text[27].$text[12].$text[9].
-						$text[2].$text[31].$text[16].$text[13].$text[6].$text[3].$text[20].
-						$text[17].$text[10].$text[7].$text[24].$text[21].$text[14].$text[11].
-						$text[28].$text[25].$text[18].$text[15];
-			}
-		}
-	}
-
-
-	/**
-	 * Applies the Sbox to each byte of the string passed in.
-	 * This is similar to subByte(), but Unlike subByte() we do not use
-	 * the _s_inv[] table. This function is only used in expandKey(),
-	 * which is implemented by the class that inherits this class
-	 *
-	 * @param string $text The string to peform the byte subsitution
-	 * @return string The string with the subsituted bytes
-	 */
-	private function subWord(&$text)
-	{
-		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
-		{
-			// the sbox is arrange in a 16 x 16 grid, where each row
-			// and column is numbered in hex (from 0 - f)
-			$hex = parent::str2Hex($text[$i]);
-			$row = parent::hex2Dec($hex[0]);
-			$col = parent::hex2Dec($hex[1]);
-			$pos = ($row * 16) + $col;
-
-			$text[$i] = chr(self::$_s[$pos]);
-		}
-	}
-
-
-	/**
-	 * Rotate a 4 byte block of the key, moving the first byte to
-	 * to the end, and shifting everything left
-	 * Used in key Expandsion
-	 *
-	 * @param string $key_block A 4 byte string
-	 * @return string The shifted 4 byte string
-	 */
-	private function rotWord($key_block)
-	{
-		return substr($key_block, 1, 3).$key_block[0];
-	}
-
-
-	/**
-	 * Returns 4 bytes from the expanded key starting at the given offset
-	 * Used during expandKey()
-	 *
-	 * @param integer $offset The offset within $this->xkey to grab the 4 bytes
-	 * @return string A 4 byte string from the key
-	 */
-	private function ek($offset)
-	{
-		return substr($this->xkey, $offset, 4);
-	}
-
-
-	/**
-	 * Returns 4 bytes of the original key from the given offset
-	 * Used during expandKey()
-	 *
-	 * @param integer $offset The offset within $this->key to grab the 4 bytes
-	 * @return string A 4 byte string from the key
-	 */
-	private function k($offset)
-	{
-		return substr($this->key(), $offset, 4);
-	}
-
-
-	/**
-	 * Return the 4 byte round constant used during expandKey().
-	 * Gets the 1 byte value from self::$_rcon and multiplies it by
-	 * 0x01000000 to create a 4 byte value
-	 *
-	 * @param integer $pos The position in self::$_rcon array to grab 1 byte
-	 * @return integer A 4 byte value
-	 */
-	private function rcon($pos)
-	{
-		return (self::$_rcon[$pos] * 0x01000000);
-	}
-
-
-	/**
-	 * Expands the key
-	 * The key expands based on the block size as well as the key size
-	 *
-	 * @return void
-	 */
-	protected function expandKey()
-	{
-		if($this->keySize() == 16)
-			return $this->expandKey128();
-		else if($this->keySize() == 24)
-			return $this->expandKey192();
-		else if($this->keySize() == 32)
-			return $this->expandKey256();
-	}
-
-
-	/**
-	 * Expand a 16 byte key, the size it is expanded to varies
-	 * based on the block size of the Rijndael implementation chosen
-	 *
-	 * @return void
-	 */
-	private function expandKey128()
-	{
-		// clear the xkey, we're creating a new one
-		$this->xkey = "";
-		$max = 0;
-
-		// the number of rounds we make depends on the block size of the text
-		// used during encryption/decryption
-		if($this->blockSize() == 16)
-			$max = 44;
-		if($this->blockSize() == 24)
-			$max = 78;
-		if($this->blockSize() == 32)
-			$max = 120;
-
-		// 16 byte key expands to 176 bytes
-		for($i = 0; $i < $max; ++$i)
-		{
-			if($i >= 0 && $i <= 3)
-				$this->xkey .= $this->k($i * 4);
-			else if(($i % 4) == 0)
-			{
-				// rotate the 4 bytes
-				$subword = $this->rotWord($this->ek(($i - 1) * 4));
-
-				// apply the sbox
-				$this->subWord($subword);
-
-				// return 4 byte value based on self::$_rcon table
-				//$rcon = $this->rcon(($i / 4) - 1);
-				$rcon = $this->rcon(($i / 4));
-
-				// grab 4 bytes from $this->extended_key
-				$ek = $this->ek(($i - 4) * 4);
-
-				$h1 = parent::str2Hex($subword);
-				$h2 = parent::dec2Hex($rcon);
-				$h3 = parent::str2Hex($ek);
-				$res = parent::xorHex($h1, $h2, $h3);
-				$this->xkey .= parent::hex2Str($res);
-			}
-			else
-			{
-				$h1 = parent::str2Hex($this->ek(($i - 1) * 4));
-				$h2 = parent::str2Hex($this->ek(($i - 4) * 4));
-				$res = parent::xorHex($h1, $h2);
-				$this->xkey .= parent::hex2Str($res);
-			}
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Expand a 24 byte key, the size it is expanded to varies
-	 * based on the block size of the Rijndael implementation chosen
-	 *
-	 * @return void
-	 */
-	private function expandKey192()
-	{
-		// clear the xkey, we're creating a new one
-		$this->xkey = "";
-		$max = 0;
-
-		// the number of rounds we make depends on the block size of the text
-		// used during encryption/decryption
-		if($this->blockSize() == 16)
-			$max = 52;
-		if($this->blockSize() == 24)
-			$max = 78;
-		if($this->blockSize() == 32)
-			$max = 120;
-
-		// 24 byte key expands to 208 bytes
-		for($i = 0; $i < $max; ++$i)
-		{
-			if($i >= 0 && $i <= 5)
-				$this->xkey .= $this->k($i * 4);
-			else if(($i % 6) == 0)
-			{
-				// rotate the 4 bytes
-				$subword = $this->rotWord($this->ek(($i - 1) * 4));
-
-				// apply the sbox
-				$this->subWord($subword);
-
-				// return 4 byte value based on self::$_rcon table
-				//$rcon = $this->rcon(($i / 6) - 1);
-				$rcon = $this->rcon(($i / 6));
-
-				// grab 4 bytes from $this->extended_key
-				$ek = $this->ek(($i - 6) * 4);
-
-				$h1 = parent::str2Hex($subword);
-				$h2 = parent::dec2Hex($rcon);
-				$h3 = parent::str2Hex($ek);
-				$res = parent::xorHex($h1, $h2, $h3);
-				$this->xkey .= parent::hex2Str($res);
-			}
-			else
-			{
-				$h1 = parent::str2Hex($this->ek(($i - 1) * 4));
-				$h2 = parent::str2Hex($this->ek(($i - 6) * 4));
-				$res = parent::xorHex($h1, $h2);
-				$this->xkey .= parent::hex2Str($res);
-			}
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Expand a 32 byte key, the size it is expanded to varies
-	 * based on the block size of the Rijndael implementation chosen
-	 *
-	 * @return void
-	 */
-	private function expandKey256()
-	{
-		// clear the xkey, we're creating a new one
-		$this->xkey = "";
-		$max = 0;
-
-		// the number of rounds we make depends on the block size of the text
-		// used during encryption/decryption
-		if($this->blockSize() == 16)
-			$max = 60;
-		if($this->blockSize() == 24)
-			$max = 90;
-		if($this->blockSize() == 32)
-			$max = 120;
-
-		// 32 byte key expands to 240 bytes
-		for($i = 0; $i < $max; ++$i)
-		{
-			if($i >= 0 && $i <= 7)
-				$this->xkey .= $this->k($i * 4);
-			else if($i % 8 == 0)
-			{
-				// rotate the 4 bytes
-				$subword = $this->rotWord($this->ek(($i - 1) * 4));
-
-				// apply the sbox
-				$this->subWord($subword);
-
-				// return 4 byte value based on self::$_rcon table
-				$rcon = $this->rcon(($i / 8));
-
-				// grab 4 bytes from $this->extended_key
-				$ek = $this->ek(($i - 8) * 4);
-
-				$h1 = parent::str2Hex($subword);
-				$h2 = parent::dec2Hex($rcon);
-				$h3 = parent::str2Hex($ek);
-				$res = parent::xorHex($h1, $h2, $h3);
-				$this->xkey .= parent::hex2Str($res);
-			}
-			else if($i % 4 == 0)
-			{
-				// get the subsitution from the s-box
-				$subword = $this->ek(($i - 1) * 4);
-				$this->subWord($subword);
-
-				// get the extended key part
-				$ek = $this->ek(($i - 8) * 4);
-
-				// xor the two parts
-				$h1 = parent::str2Hex($subword);
-				$h2 = parent::str2Hex($ek);
-				$res = parent::xorHex($h1, $h2);
-				$this->xkey .= parent::hex2Str($res);
-			}
-			else
-			{
-				$h1 = parent::str2Hex($this->ek(($i - 1) * 4));
-				$h2 = parent::str2Hex($this->ek(($i - 8) * 4));
-				$res = parent::xorHex($h1, $h2);
-				$this->xkey .= parent::hex2Str($res);
-			}
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Initalizes the tables used for Rijndael/AES encryption
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		// the sbox used for encryption
-		self::$_s = array(
-			0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
-			0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
-			0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
-			0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
-			0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
-			0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
-			0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
-			0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
-			0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
-			0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
-			0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
-			0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
-			0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
-			0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
-			0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-			0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
-		);
-
-		// the inverse sbox used for decryption
-		self::$_s_inv = array(
-			0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
-			0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
-			0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
-			0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
-			0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
-			0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
-			0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
-			0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
-			0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
-			0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
-			0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
-			0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
-			0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
-			0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
-			0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
-			0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
-		);
-
-		// used in mixColumn() during encryption
-		self::$_matrix_mult = array(
-			0x02, 0x01, 0x01, 0x03,
-			0x03, 0x02, 0x01, 0x01,
-			0x01, 0x03, 0x02, 0x01,
-			0x01, 0x01, 0x03, 0x02
-		);
-
-		// used in mixColumn() during decryption
-		self::$_matrix_mult_inv = array(
-			0x0e, 0x09, 0x0d, 0x0b,
-			0x0b, 0x0e, 0x09, 0x0d,
-			0x0d, 0x0b, 0x0e, 0x09,
-			0x09, 0x0d, 0x0b, 0x0e
-		);
-
-		// The round constants, each round is a 1 byte value which should be multiplied by 0x01000000
-		// to create a 4 byte value before being used in expandKey(). This is done in rcon()
-		// NOTE: AES only needs the first row of values, since AES only uses 16 byte blocks,
-		// the other values are used for larger block/key combinations supported by Rijndael
-		// NOTE: self::$_rcon[0] is never used
-		self::$_rcon = array(
-			0x8d, 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, 0x39,
-			0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
-			0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
-			0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
-			0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
-			0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
-			0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d
-		);
-
-		/*
+        if($this->blockSize() == 32)
+        {
+            if($this->operation() == parent::ENCRYPT)
+            {
+                // create an 8x4 matrix
+                // row 0 is unchanged
+                // shift row 1 left 1 byte
+                // shift row 2 left 3 bytes
+                // shift row 3 left 4 bytes
+                $text = $text[0].$text[5].$text[14].$text[19].$text[4].$text[9].$text[18].
+                        $text[23].$text[8].$text[13].$text[22].$text[27].$text[12].$text[17].
+                        $text[26].$text[31].$text[16].$text[21].$text[30].$text[3].$text[20].
+                        $text[25].$text[2].$text[7].$text[24].$text[29].$text[6].$text[11].
+                        $text[28].$text[1].$text[10].$text[15];
+            }
+            else // parent::DECRYPT
+            {
+                // create an 8x4 matrix
+                // row 0 is unchanged
+                // shift row 1 right 1 byte
+                // shift row 2 right 3 bytes
+                // shift row 3 right 4 bytes
+                $text = $text[0].$text[29].$text[22].$text[19].$text[4].$text[1].$text[26].
+                        $text[23].$text[8].$text[5].$text[30].$text[27].$text[12].$text[9].
+                        $text[2].$text[31].$text[16].$text[13].$text[6].$text[3].$text[20].
+                        $text[17].$text[10].$text[7].$text[24].$text[21].$text[14].$text[11].
+                        $text[28].$text[25].$text[18].$text[15];
+            }
+        }
+    }
+
+
+    /**
+     * Applies the Sbox to each byte of the string passed in.
+     * This is similar to subByte(), but Unlike subByte() we do not use
+     * the _s_inv[] table. This function is only used in expandKey(),
+     * which is implemented by the class that inherits this class
+     *
+     * @param string $text The string to peform the byte subsitution
+     * @return string The string with the subsituted bytes
+     */
+    private function subWord(&$text)
+    {
+        $max = strlen($text);
+        for($i = 0; $i < $max; ++$i)
+        {
+            // the sbox is arrange in a 16 x 16 grid, where each row
+            // and column is numbered in hex (from 0 - f)
+            $hex = parent::str2Hex($text[$i]);
+            $row = parent::hex2Dec($hex[0]);
+            $col = parent::hex2Dec($hex[1]);
+            $pos = ($row * 16) + $col;
+
+            $text[$i] = chr(self::$_s[$pos]);
+        }
+    }
+
+
+    /**
+     * Rotate a 4 byte block of the key, moving the first byte to
+     * to the end, and shifting everything left
+     * Used in key Expandsion
+     *
+     * @param string $key_block A 4 byte string
+     * @return string The shifted 4 byte string
+     */
+    private function rotWord($key_block)
+    {
+        return substr($key_block, 1, 3).$key_block[0];
+    }
+
+
+    /**
+     * Returns 4 bytes from the expanded key starting at the given offset
+     * Used during expandKey()
+     *
+     * @param integer $offset The offset within $this->xkey to grab the 4 bytes
+     * @return string A 4 byte string from the key
+     */
+    private function ek($offset)
+    {
+        return substr($this->xkey, $offset, 4);
+    }
+
+
+    /**
+     * Returns 4 bytes of the original key from the given offset
+     * Used during expandKey()
+     *
+     * @param integer $offset The offset within $this->key to grab the 4 bytes
+     * @return string A 4 byte string from the key
+     */
+    private function k($offset)
+    {
+        return substr($this->key(), $offset, 4);
+    }
+
+
+    /**
+     * Return the 4 byte round constant used during expandKey().
+     * Gets the 1 byte value from self::$_rcon and multiplies it by
+     * 0x01000000 to create a 4 byte value
+     *
+     * @param integer $pos The position in self::$_rcon array to grab 1 byte
+     * @return integer A 4 byte value
+     */
+    private function rcon($pos)
+    {
+        return (self::$_rcon[$pos] * 0x01000000);
+    }
+
+
+    /**
+     * Expands the key
+     * The key expands based on the block size as well as the key size
+     *
+     * @return void
+     */
+    protected function expandKey()
+    {
+        if($this->keySize() == 16)
+            return $this->expandKey128();
+        else if($this->keySize() == 24)
+            return $this->expandKey192();
+        else if($this->keySize() == 32)
+            return $this->expandKey256();
+    }
+
+
+    /**
+     * Expand a 16 byte key, the size it is expanded to varies
+     * based on the block size of the Rijndael implementation chosen
+     *
+     * @return void
+     */
+    private function expandKey128()
+    {
+        // clear the xkey, we're creating a new one
+        $this->xkey = "";
+        $max = 0;
+
+        // the number of rounds we make depends on the block size of the text
+        // used during encryption/decryption
+        if($this->blockSize() == 16)
+            $max = 44;
+        if($this->blockSize() == 24)
+            $max = 78;
+        if($this->blockSize() == 32)
+            $max = 120;
+
+        // 16 byte key expands to 176 bytes
+        for($i = 0; $i < $max; ++$i)
+        {
+            if($i >= 0 && $i <= 3)
+                $this->xkey .= $this->k($i * 4);
+            else if(($i % 4) == 0)
+            {
+                // rotate the 4 bytes
+                $subword = $this->rotWord($this->ek(($i - 1) * 4));
+
+                // apply the sbox
+                $this->subWord($subword);
+
+                // return 4 byte value based on self::$_rcon table
+                //$rcon = $this->rcon(($i / 4) - 1);
+                $rcon = $this->rcon(($i / 4));
+
+                // grab 4 bytes from $this->extended_key
+                $ek = $this->ek(($i - 4) * 4);
+
+                $h1 = parent::str2Hex($subword);
+                $h2 = parent::dec2Hex($rcon);
+                $h3 = parent::str2Hex($ek);
+                $res = parent::xorHex($h1, $h2, $h3);
+                $this->xkey .= parent::hex2Str($res);
+            }
+            else
+            {
+                $h1 = parent::str2Hex($this->ek(($i - 1) * 4));
+                $h2 = parent::str2Hex($this->ek(($i - 4) * 4));
+                $res = parent::xorHex($h1, $h2);
+                $this->xkey .= parent::hex2Str($res);
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Expand a 24 byte key, the size it is expanded to varies
+     * based on the block size of the Rijndael implementation chosen
+     *
+     * @return void
+     */
+    private function expandKey192()
+    {
+        // clear the xkey, we're creating a new one
+        $this->xkey = "";
+        $max = 0;
+
+        // the number of rounds we make depends on the block size of the text
+        // used during encryption/decryption
+        if($this->blockSize() == 16)
+            $max = 52;
+        if($this->blockSize() == 24)
+            $max = 78;
+        if($this->blockSize() == 32)
+            $max = 120;
+
+        // 24 byte key expands to 208 bytes
+        for($i = 0; $i < $max; ++$i)
+        {
+            if($i >= 0 && $i <= 5)
+                $this->xkey .= $this->k($i * 4);
+            else if(($i % 6) == 0)
+            {
+                // rotate the 4 bytes
+                $subword = $this->rotWord($this->ek(($i - 1) * 4));
+
+                // apply the sbox
+                $this->subWord($subword);
+
+                // return 4 byte value based on self::$_rcon table
+                //$rcon = $this->rcon(($i / 6) - 1);
+                $rcon = $this->rcon(($i / 6));
+
+                // grab 4 bytes from $this->extended_key
+                $ek = $this->ek(($i - 6) * 4);
+
+                $h1 = parent::str2Hex($subword);
+                $h2 = parent::dec2Hex($rcon);
+                $h3 = parent::str2Hex($ek);
+                $res = parent::xorHex($h1, $h2, $h3);
+                $this->xkey .= parent::hex2Str($res);
+            }
+            else
+            {
+                $h1 = parent::str2Hex($this->ek(($i - 1) * 4));
+                $h2 = parent::str2Hex($this->ek(($i - 6) * 4));
+                $res = parent::xorHex($h1, $h2);
+                $this->xkey .= parent::hex2Str($res);
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Expand a 32 byte key, the size it is expanded to varies
+     * based on the block size of the Rijndael implementation chosen
+     *
+     * @return void
+     */
+    private function expandKey256()
+    {
+        // clear the xkey, we're creating a new one
+        $this->xkey = "";
+        $max = 0;
+
+        // the number of rounds we make depends on the block size of the text
+        // used during encryption/decryption
+        if($this->blockSize() == 16)
+            $max = 60;
+        if($this->blockSize() == 24)
+            $max = 90;
+        if($this->blockSize() == 32)
+            $max = 120;
+
+        // 32 byte key expands to 240 bytes
+        for($i = 0; $i < $max; ++$i)
+        {
+            if($i >= 0 && $i <= 7)
+                $this->xkey .= $this->k($i * 4);
+            else if($i % 8 == 0)
+            {
+                // rotate the 4 bytes
+                $subword = $this->rotWord($this->ek(($i - 1) * 4));
+
+                // apply the sbox
+                $this->subWord($subword);
+
+                // return 4 byte value based on self::$_rcon table
+                $rcon = $this->rcon(($i / 8));
+
+                // grab 4 bytes from $this->extended_key
+                $ek = $this->ek(($i - 8) * 4);
+
+                $h1 = parent::str2Hex($subword);
+                $h2 = parent::dec2Hex($rcon);
+                $h3 = parent::str2Hex($ek);
+                $res = parent::xorHex($h1, $h2, $h3);
+                $this->xkey .= parent::hex2Str($res);
+            }
+            else if($i % 4 == 0)
+            {
+                // get the subsitution from the s-box
+                $subword = $this->ek(($i - 1) * 4);
+                $this->subWord($subword);
+
+                // get the extended key part
+                $ek = $this->ek(($i - 8) * 4);
+
+                // xor the two parts
+                $h1 = parent::str2Hex($subword);
+                $h2 = parent::str2Hex($ek);
+                $res = parent::xorHex($h1, $h2);
+                $this->xkey .= parent::hex2Str($res);
+            }
+            else
+            {
+                $h1 = parent::str2Hex($this->ek(($i - 1) * 4));
+                $h2 = parent::str2Hex($this->ek(($i - 8) * 4));
+                $res = parent::xorHex($h1, $h2);
+                $this->xkey .= parent::hex2Str($res);
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Initalizes the tables used for Rijndael/AES encryption
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        // the sbox used for encryption
+        self::$_s = array(
+            0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+            0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+            0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+            0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+            0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+            0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+            0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+            0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+            0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+            0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+            0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+            0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+            0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+            0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+            0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+            0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
+        );
+
+        // the inverse sbox used for decryption
+        self::$_s_inv = array(
+            0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
+            0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
+            0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
+            0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
+            0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
+            0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
+            0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
+            0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
+            0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
+            0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
+            0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
+            0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
+            0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
+            0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
+            0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+            0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
+        );
+
+        // used in mixColumn() during encryption
+        self::$_matrix_mult = array(
+            0x02, 0x01, 0x01, 0x03,
+            0x03, 0x02, 0x01, 0x01,
+            0x01, 0x03, 0x02, 0x01,
+            0x01, 0x01, 0x03, 0x02
+        );
+
+        // used in mixColumn() during decryption
+        self::$_matrix_mult_inv = array(
+            0x0e, 0x09, 0x0d, 0x0b,
+            0x0b, 0x0e, 0x09, 0x0d,
+            0x0d, 0x0b, 0x0e, 0x09,
+            0x09, 0x0d, 0x0b, 0x0e
+        );
+
+        // The round constants, each round is a 1 byte value which should be multiplied by 0x01000000
+        // to create a 4 byte value before being used in expandKey(). This is done in rcon()
+        // NOTE: AES only needs the first row of values, since AES only uses 16 byte blocks,
+        // the other values are used for larger block/key combinations supported by Rijndael
+        // NOTE: self::$_rcon[0] is never used
+        self::$_rcon = array(
+            0x8d, 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, 0x39,
+            0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+            0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+            0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+            0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+            0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 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, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+            0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d
+        );
+
+        /*
 		 * Galois Multiplication lookup tables
 		 * See http://en.wikipedia.org/wiki/Rijndael_mix_columns#InverseMixColumns
 		 */
 
-		// multiply a byte by 2 (the value 2 will come from self::$_matrix_mult)
-		self::$_gm2 = array(
-			0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
-			0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
-			0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
-			0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
-			0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
-			0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
-			0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
-			0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
-			0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
-			0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23, 0x21, 0x27, 0x25,
-			0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45,
-			0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
-			0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
-			0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
-			0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
-			0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5
-		);
-
-		// multiply a byte by 3 (the value 3 will come from self::$_matrix_mult)
-		self::$_gm3 = array(
-			0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11,
-			0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21,
-			0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
-			0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 0x44, 0x47, 0x42, 0x41,
-			0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1,
-			0xf0, 0xf3, 0xf6, 0xf5, 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
-			0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 0xb4, 0xb7, 0xb2, 0xb1,
-			0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81,
-			0x9b, 0x98, 0x9d, 0x9e, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
-			0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 0xbf, 0xbc, 0xb9, 0xba,
-			0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea,
-			0xcb, 0xc8, 0xcd, 0xce, 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
-			0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a,
-			0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a,
-			0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
-			0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a
-		);
-
-		// multiply a byte by 9 (the value 9 will come from self::$_matrix_mult_inv)
-		self::$_gm9 = array(
-			0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
-			0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
-			0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
-			0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc,
-			0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01,
-			0xe6, 0xef, 0xf4, 0xfd, 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
-			0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a,
-			0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa,
-			0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
-			0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10, 0x19, 0x02, 0x0b,
-			0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0,
-			0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
-			0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
-			0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
-			0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
-			0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46
-		);
-
-		// multiply a byte by 11 (the value 11 will come from self::$_matrix_mult_inv)
-		self::$_gm11 = array(
-			0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
-			0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
-			0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
-			0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2,
-			0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f,
-			0x46, 0x4d, 0x50, 0x5b, 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
-			0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4,
-			0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54,
-			0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
-			0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2e,
-			0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5,
-			0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
-			0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
-			0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
-			0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
-			0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3
-		);
-
-		// multiply a byte by 13 (the value 13 will come from self::$_matrix_mult_inv)
-		self::$_gm13 = array(
-			0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
-			0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
-			0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
-			0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20,
-			0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26,
-			0xbd, 0xb0, 0xa7, 0xaa, 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
-			0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d,
-			0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d,
-			0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
-			0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56, 0x5b, 0x4c, 0x41,
-			0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a,
-			0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
-			0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
-			0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
-			0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
-			0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97
-		);
-
-		// multiply a byte by 14 (the value 14 will come from self::$_matrix_mult_inv)
-		self::$_gm14 = array(
-			0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
-			0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
-			0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
-			0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61,
-			0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7,
-			0x4d, 0x43, 0x51, 0x5f, 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
-			0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c,
-			0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc,
-			0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
-			0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9, 0xe7, 0xf5, 0xfb,
-			0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0,
-			0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
-			0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
-			0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
-			0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
-			0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d
-		);
-	}
+        // multiply a byte by 2 (the value 2 will come from self::$_matrix_mult)
+        self::$_gm2 = array(
+            0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
+            0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
+            0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
+            0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
+            0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
+            0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
+            0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
+            0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
+            0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
+            0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23, 0x21, 0x27, 0x25,
+            0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45,
+            0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
+            0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
+            0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
+            0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
+            0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5
+        );
+
+        // multiply a byte by 3 (the value 3 will come from self::$_matrix_mult)
+        self::$_gm3 = array(
+            0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11,
+            0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21,
+            0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
+            0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 0x44, 0x47, 0x42, 0x41,
+            0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1,
+            0xf0, 0xf3, 0xf6, 0xf5, 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
+            0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 0xb4, 0xb7, 0xb2, 0xb1,
+            0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81,
+            0x9b, 0x98, 0x9d, 0x9e, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
+            0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 0xbf, 0xbc, 0xb9, 0xba,
+            0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea,
+            0xcb, 0xc8, 0xcd, 0xce, 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
+            0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a,
+            0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a,
+            0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
+            0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a
+        );
+
+        // multiply a byte by 9 (the value 9 will come from self::$_matrix_mult_inv)
+        self::$_gm9 = array(
+            0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
+            0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
+            0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
+            0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc,
+            0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01,
+            0xe6, 0xef, 0xf4, 0xfd, 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
+            0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a,
+            0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa,
+            0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
+            0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10, 0x19, 0x02, 0x0b,
+            0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0,
+            0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
+            0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
+            0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
+            0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
+            0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46
+        );
+
+        // multiply a byte by 11 (the value 11 will come from self::$_matrix_mult_inv)
+        self::$_gm11 = array(
+            0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
+            0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
+            0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
+            0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2,
+            0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f,
+            0x46, 0x4d, 0x50, 0x5b, 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
+            0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4,
+            0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54,
+            0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
+            0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2e,
+            0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5,
+            0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
+            0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
+            0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
+            0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
+            0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3
+        );
+
+        // multiply a byte by 13 (the value 13 will come from self::$_matrix_mult_inv)
+        self::$_gm13 = array(
+            0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
+            0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
+            0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
+            0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20,
+            0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26,
+            0xbd, 0xb0, 0xa7, 0xaa, 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
+            0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d,
+            0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d,
+            0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
+            0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56, 0x5b, 0x4c, 0x41,
+            0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a,
+            0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
+            0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
+            0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
+            0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
+            0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97
+        );
+
+        // multiply a byte by 14 (the value 14 will come from self::$_matrix_mult_inv)
+        self::$_gm14 = array(
+            0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
+            0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
+            0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
+            0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61,
+            0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7,
+            0x4d, 0x43, 0x51, 0x5f, 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
+            0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c,
+            0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc,
+            0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
+            0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9, 0xe7, 0xf5, 0xfb,
+            0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0,
+            0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
+            0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
+            0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
+            0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
+            0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d
+        );
+    }
 }
 ?>

Spacing +64 added lines, -64 removed lines

@@ -139,11 +139,11 @@ 
 		// AES will pass in a $len, since it has a fixed key size, other
 		// rijndael implementations can use variable key sizes, supported
 		// sizes are stored in self::$_key_sizes
-		if($len == 0)
+		if ($len == 0)
 		{
 			// the key must be one of the following lengths: 16, 24, 32 bytes
 			$len = strlen($key);
-			if(!in_array($len, self::$_key_sizes))
+			if (!in_array($len, self::$_key_sizes))
 			{
 				$msg  = "Incorrect key length for ".strtoupper($cipher_name).". ";
 				$msg .= "Received $len bytes.";
@@ -188,23 +188,23 @@ 
 		// if the key and block size is 16, do 10 rounds
 		// if the key or block size is 24, and neither is longer than 24, do 12 rounds
 		// if either key or block size is 32, do 14 rounds
-		if($key_sz == 16 && $blk_sz == 16)
+		if ($key_sz == 16 && $blk_sz == 16)
 			$loops = 10;
-		else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
+		else if (($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
 			$loops = 12;
-		else if($key_sz == 32 || $blk_sz == 32)
+		else if ($key_sz == 32 || $blk_sz == 32)
 			$loops = 14;
 
 		// now begin the encryption
 		$this->addRoundKey($text, 0);
 
-		for($i = 1; $i <= $loops; ++$i)
+		for ($i = 1; $i <= $loops; ++$i)
 		{
 			$this->byteSub($text);
 			$this->shiftRow($text);
 
 			// the last iteration does not use mixColumn
-			if($i < $loops)
+			if ($i < $loops)
 				$this->mixColumn($text);
 
 			$this->addRoundKey($text, $i);
@@ -232,24 +232,24 @@ 
 		// if the key and block size is 16, do 10 rounds
 		// if the key or block size is 24, and neither is longer than 24, do 12 rounds
 		// if either key or block size is 32, do 14 rounds
-		if($key_sz == 16 && $blk_sz == 16)
+		if ($key_sz == 16 && $blk_sz == 16)
 			$loops = 10;
-		else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
+		else if (($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
 			$loops = 12;
-		else if($key_sz == 32 || $blk_sz == 32)
+		else if ($key_sz == 32 || $blk_sz == 32)
 			$loops = 14;
 
 		// now begin the decryption
 		$this->addRoundKey($text, 0);
 
-		for($i = 1; $i <= $loops; ++$i)
+		for ($i = 1; $i <= $loops; ++$i)
 		{
 			$this->shiftRow($text);
 			$this->byteSub($text);
 			$this->addRoundKey($text, $i);
 
 			// the last iteration does not use mixColumn
-			if($i < $loops)
+			if ($i < $loops)
 				$this->mixColumn($text);
 		}
 
@@ -280,7 +280,7 @@ 
 	protected function mixColumnMultiply($m, $byte)
 	{
 		// if multiplying by 1, then we just return the same number
-		if($m == 0x01)
+		if ($m == 0x01)
 			return $byte;
 
 		$hex = parent::dec2Hex($byte);
@@ -289,27 +289,27 @@ 
 		$pos = ($row * 16) + $col;
 
 		// multiply by 2 (comes from self::$_matrix_mult during encryption)
-		if($m == 0x02)
+		if ($m == 0x02)
 			return self::$_gm2[$pos];
 
 		// multiply by 3 (comes from self::$_matrix_mult during encryption)
-		if($m == 0x03)
+		if ($m == 0x03)
 			return self::$_gm3[$pos];
 
 		// multiply by 9 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x09)
+		if ($m == 0x09)
 			return self::$_gm9[$pos];
 
 		// multiply by 11 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0b)
+		if ($m == 0x0b)
 			return self::$_gm11[$pos];
 
 		// multiply by 13 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0d)
+		if ($m == 0x0d)
 			return self::$_gm13[$pos];
 
 		// multiply by 14 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0e)
+		if ($m == 0x0e)
 			return self::$_gm14[$pos];
 	}
 
@@ -331,12 +331,12 @@ 
 		$ek_len = strlen($this->xkey);
 		$len = $this->blockSize();
 
-		if($this->operation() == parent::ENCRYPT)
+		if ($this->operation() == parent::ENCRYPT)
 			$offset = $round * $len;
 		else
 			$offset = ($ek_len - ($round * $len)) - $len;
 
-		for($i = 0; $i < $len; ++$i)
+		for ($i = 0; $i < $len; ++$i)
 			$text[$i] = $text[$i] ^ $this->xkey[$offset + $i];
 	}
 
@@ -351,7 +351,7 @@ 
 	private function byteSub(&$text)
 	{
 		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// the sbox is arrange in a 16 x 16 grid, where each row
 			// and column is numbered in hex (from 0 - f)
@@ -361,7 +361,7 @@ 
 			$pos = ($row * 16) + $col;
 
 			// return the corresponding value from the sbox
-			if($this->operation() == parent::ENCRYPT)
+			if ($this->operation() == parent::ENCRYPT)
 				$text[$i] = chr(self::$_s[$pos]);
 			else // parent::DECRYPT uses the inverse sbox
 				$text[$i] = chr(self::$_s_inv[$pos]);
@@ -381,7 +381,7 @@ 
 		$tmp = $t;
 
 		// the matrix we use depends on if we are encrypting or decrypting
-		if($this->operation() == parent::ENCRYPT)
+		if ($this->operation() == parent::ENCRYPT)
 			$m = self::$_matrix_mult;
 		else // parent::DECRYPT
 			$m = self::$_matrix_mult_inv;
@@ -394,30 +394,30 @@ 
 		$max_col = ($this->blockSize() * 8) / 32;
 
 		// loop through each column of the matrix
-		for($col = 0; $col < $max_col; ++$col)
+		for ($col = 0; $col < $max_col; ++$col)
 		{
 			$pos = $col * 4;
 
-			$a = $this->mixColumnMultiply($m[0],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[4],  ord($tmp[$pos + 1]));
-			$c = $this->mixColumnMultiply($m[8],  ord($tmp[$pos + 2]));
+			$a = $this->mixColumnMultiply($m[0], ord($tmp[$pos + 0]));
+			$b = $this->mixColumnMultiply($m[4], ord($tmp[$pos + 1]));
+			$c = $this->mixColumnMultiply($m[8], ord($tmp[$pos + 2]));
 			$d = $this->mixColumnMultiply($m[12], ord($tmp[$pos + 3]));
 			$t[$pos + 0] = chr($a ^ $b ^ $c ^ $d);
 
-			$a = $this->mixColumnMultiply($m[1],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[5],  ord($tmp[$pos + 1]));
-			$c = $this->mixColumnMultiply($m[9],  ord($tmp[$pos + 2]));
+			$a = $this->mixColumnMultiply($m[1], ord($tmp[$pos + 0]));
+			$b = $this->mixColumnMultiply($m[5], ord($tmp[$pos + 1]));
+			$c = $this->mixColumnMultiply($m[9], ord($tmp[$pos + 2]));
 			$d = $this->mixColumnMultiply($m[13], ord($tmp[$pos + 3]));
 			$t[$pos + 1] = chr($a ^ $b ^ $c ^ $d);
 
-			$a = $this->mixColumnMultiply($m[2],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[6],  ord($tmp[$pos + 1]));
+			$a = $this->mixColumnMultiply($m[2], ord($tmp[$pos + 0]));
+			$b = $this->mixColumnMultiply($m[6], ord($tmp[$pos + 1]));
 			$c = $this->mixColumnMultiply($m[10], ord($tmp[$pos + 2]));
 			$d = $this->mixColumnMultiply($m[14], ord($tmp[$pos + 3]));
 			$t[$pos + 2] = chr($a ^ $b ^ $c ^ $d);
 
-			$a = $this->mixColumnMultiply($m[3],  ord($tmp[$pos + 0]));
-			$b = $this->mixColumnMultiply($m[7],  ord($tmp[$pos + 1]));
+			$a = $this->mixColumnMultiply($m[3], ord($tmp[$pos + 0]));
+			$b = $this->mixColumnMultiply($m[7], ord($tmp[$pos + 1]));
 			$c = $this->mixColumnMultiply($m[11], ord($tmp[$pos + 2]));
 			$d = $this->mixColumnMultiply($m[15], ord($tmp[$pos + 3]));
 			$t[$pos + 3] = chr($a ^ $b ^ $c ^ $d);
@@ -441,9 +441,9 @@ 
 		/*
 		 * Rijndael-128 / AES
 		 */
-		if($this->blockSize() == 16)
+		if ($this->blockSize() == 16)
 		{
-			if($this->operation() == parent::ENCRYPT)
+			if ($this->operation() == parent::ENCRYPT)
 			{
 				// create a 4x4 matrix
 				// row 0 is unchanged,
@@ -470,9 +470,9 @@ 
 		/*
 		 * Rijndael-192
 		 */
-		if($this->blockSize() == 24)
+		if ($this->blockSize() == 24)
 		{
-			if($this->operation() == parent::ENCRYPT)
+			if ($this->operation() == parent::ENCRYPT)
 			{
 				// create a 6x4 matrix
 				// row 0 is unchanged
@@ -502,9 +502,9 @@ 
 		/*
 		 * Rijndael-256
 		 */
-		if($this->blockSize() == 32)
+		if ($this->blockSize() == 32)
 		{
-			if($this->operation() == parent::ENCRYPT)
+			if ($this->operation() == parent::ENCRYPT)
 			{
 				// create an 8x4 matrix
 				// row 0 is unchanged
@@ -546,7 +546,7 @@ 
 	private function subWord(&$text)
 	{
 		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// the sbox is arrange in a 16 x 16 grid, where each row
 			// and column is numbered in hex (from 0 - f)
@@ -622,11 +622,11 @@ 
 	 */
 	protected function expandKey()
 	{
-		if($this->keySize() == 16)
+		if ($this->keySize() == 16)
 			return $this->expandKey128();
-		else if($this->keySize() == 24)
+		else if ($this->keySize() == 24)
 			return $this->expandKey192();
-		else if($this->keySize() == 32)
+		else if ($this->keySize() == 32)
 			return $this->expandKey256();
 	}
 
@@ -645,19 +645,19 @@ 
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
-		if($this->blockSize() == 16)
+		if ($this->blockSize() == 16)
 			$max = 44;
-		if($this->blockSize() == 24)
+		if ($this->blockSize() == 24)
 			$max = 78;
-		if($this->blockSize() == 32)
+		if ($this->blockSize() == 32)
 			$max = 120;
 
 		// 16 byte key expands to 176 bytes
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
-			if($i >= 0 && $i <= 3)
+			if ($i >= 0 && $i <= 3)
 				$this->xkey .= $this->k($i * 4);
-			else if(($i % 4) == 0)
+			else if (($i % 4) == 0)
 			{
 				// rotate the 4 bytes
 				$subword = $this->rotWord($this->ek(($i - 1) * 4));
@@ -705,19 +705,19 @@ 
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
-		if($this->blockSize() == 16)
+		if ($this->blockSize() == 16)
 			$max = 52;
-		if($this->blockSize() == 24)
+		if ($this->blockSize() == 24)
 			$max = 78;
-		if($this->blockSize() == 32)
+		if ($this->blockSize() == 32)
 			$max = 120;
 
 		// 24 byte key expands to 208 bytes
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
-			if($i >= 0 && $i <= 5)
+			if ($i >= 0 && $i <= 5)
 				$this->xkey .= $this->k($i * 4);
-			else if(($i % 6) == 0)
+			else if (($i % 6) == 0)
 			{
 				// rotate the 4 bytes
 				$subword = $this->rotWord($this->ek(($i - 1) * 4));
@@ -765,19 +765,19 @@ 
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
-		if($this->blockSize() == 16)
+		if ($this->blockSize() == 16)
 			$max = 60;
-		if($this->blockSize() == 24)
+		if ($this->blockSize() == 24)
 			$max = 90;
-		if($this->blockSize() == 32)
+		if ($this->blockSize() == 32)
 			$max = 120;
 
 		// 32 byte key expands to 240 bytes
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
-			if($i >= 0 && $i <= 7)
+			if ($i >= 0 && $i <= 7)
 				$this->xkey .= $this->k($i * 4);
-			else if($i % 8 == 0)
+			else if ($i % 8 == 0)
 			{
 				// rotate the 4 bytes
 				$subword = $this->rotWord($this->ek(($i - 1) * 4));
@@ -797,7 +797,7 @@ 
 				$res = parent::xorHex($h1, $h2, $h3);
 				$this->xkey .= parent::hex2Str($res);
 			}
-			else if($i % 4 == 0)
+			else if ($i % 4 == 0)
 			{
 				// get the subsitution from the s-box
 				$subword = $this->ek(($i - 1) * 4);

Braces +109 added lines, -89 removed lines

@@ -188,12 +188,13 @@ 
 		// if the key and block size is 16, do 10 rounds
 		// if the key or block size is 24, and neither is longer than 24, do 12 rounds
 		// if either key or block size is 32, do 14 rounds
-		if($key_sz == 16 && $blk_sz == 16)
-			$loops = 10;
-		else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
-			$loops = 12;
-		else if($key_sz == 32 || $blk_sz == 32)
-			$loops = 14;
+		if($key_sz == 16 && $blk_sz == 16) {
+					$loops = 10;
+		} else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24) {
+					$loops = 12;
+		} else if($key_sz == 32 || $blk_sz == 32) {
+					$loops = 14;
+		}
 
 		// now begin the encryption
 		$this->addRoundKey($text, 0);
@@ -204,8 +205,9 @@ 
 			$this->shiftRow($text);
 
 			// the last iteration does not use mixColumn
-			if($i < $loops)
-				$this->mixColumn($text);
+			if($i < $loops) {
+							$this->mixColumn($text);
+			}
 
 			$this->addRoundKey($text, $i);
 		}
@@ -232,12 +234,13 @@ 
 		// if the key and block size is 16, do 10 rounds
 		// if the key or block size is 24, and neither is longer than 24, do 12 rounds
 		// if either key or block size is 32, do 14 rounds
-		if($key_sz == 16 && $blk_sz == 16)
-			$loops = 10;
-		else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24)
-			$loops = 12;
-		else if($key_sz == 32 || $blk_sz == 32)
-			$loops = 14;
+		if($key_sz == 16 && $blk_sz == 16) {
+					$loops = 10;
+		} else if(($key_sz == 24 || $blk_sz == 24) && $key_sz <= 24 && $blk_sz <= 24) {
+					$loops = 12;
+		} else if($key_sz == 32 || $blk_sz == 32) {
+					$loops = 14;
+		}
 
 		// now begin the decryption
 		$this->addRoundKey($text, 0);
@@ -249,8 +252,9 @@ 
 			$this->addRoundKey($text, $i);
 
 			// the last iteration does not use mixColumn
-			if($i < $loops)
-				$this->mixColumn($text);
+			if($i < $loops) {
+							$this->mixColumn($text);
+			}
 		}
 
 		return true;
@@ -280,8 +284,9 @@ 
 	protected function mixColumnMultiply($m, $byte)
 	{
 		// if multiplying by 1, then we just return the same number
-		if($m == 0x01)
-			return $byte;
+		if($m == 0x01) {
+					return $byte;
+		}
 
 		$hex = parent::dec2Hex($byte);
 		$row = parent::hex2Dec($hex[0]);
@@ -289,28 +294,34 @@ 
 		$pos = ($row * 16) + $col;
 
 		// multiply by 2 (comes from self::$_matrix_mult during encryption)
-		if($m == 0x02)
-			return self::$_gm2[$pos];
+		if($m == 0x02) {
+					return self::$_gm2[$pos];
+		}
 
 		// multiply by 3 (comes from self::$_matrix_mult during encryption)
-		if($m == 0x03)
-			return self::$_gm3[$pos];
+		if($m == 0x03) {
+					return self::$_gm3[$pos];
+		}
 
 		// multiply by 9 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x09)
-			return self::$_gm9[$pos];
+		if($m == 0x09) {
+					return self::$_gm9[$pos];
+		}
 
 		// multiply by 11 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0b)
-			return self::$_gm11[$pos];
+		if($m == 0x0b) {
+					return self::$_gm11[$pos];
+		}
 
 		// multiply by 13 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0d)
-			return self::$_gm13[$pos];
+		if($m == 0x0d) {
+					return self::$_gm13[$pos];
+		}
 
 		// multiply by 14 (comes from self::$_matrix_mult_inv during decryption)
-		if($m == 0x0e)
-			return self::$_gm14[$pos];
+		if($m == 0x0e) {
+					return self::$_gm14[$pos];
+		}
 	}
 
 
@@ -331,13 +342,15 @@ 
 		$ek_len = strlen($this->xkey);
 		$len = $this->blockSize();
 
-		if($this->operation() == parent::ENCRYPT)
-			$offset = $round * $len;
-		else
-			$offset = ($ek_len - ($round * $len)) - $len;
+		if($this->operation() == parent::ENCRYPT) {
+					$offset = $round * $len;
+		} else {
+					$offset = ($ek_len - ($round * $len)) - $len;
+		}
 
-		for($i = 0; $i < $len; ++$i)
-			$text[$i] = $text[$i] ^ $this->xkey[$offset + $i];
+		for($i = 0; $i < $len; ++$i) {
+					$text[$i] = $text[$i] ^ $this->xkey[$offset + $i];
+		}
 	}
 
 
@@ -361,10 +374,12 @@ 
 			$pos = ($row * 16) + $col;
 
 			// return the corresponding value from the sbox
-			if($this->operation() == parent::ENCRYPT)
-				$text[$i] = chr(self::$_s[$pos]);
-			else // parent::DECRYPT uses the inverse sbox
+			if($this->operation() == parent::ENCRYPT) {
+							$text[$i] = chr(self::$_s[$pos]);
+			} else {
+			    // parent::DECRYPT uses the inverse sbox
 				$text[$i] = chr(self::$_s_inv[$pos]);
+			}
 		}
 	}
 
@@ -381,10 +396,12 @@ 
 		$tmp = $t;
 
 		// the matrix we use depends on if we are encrypting or decrypting
-		if($this->operation() == parent::ENCRYPT)
-			$m = self::$_matrix_mult;
-		else // parent::DECRYPT
+		if($this->operation() == parent::ENCRYPT) {
+					$m = self::$_matrix_mult;
+		} else {
+		    // parent::DECRYPT
 			$m = self::$_matrix_mult_inv;
+		}
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
@@ -453,8 +470,7 @@ 
 				$text = $text[0].$text[5].$text[10].$text[15].$text[4].$text[9].
 						$text[14].$text[3].$text[8].$text[13].$text[2].$text[7].
 						$text[12].$text[1].$text[6].$text[11];
-			}
-			else // parent::DECRYPT
+			} else // parent::DECRYPT
 			{
 				// create a 4x4 matrix
 				// row 0 is unchanged,
@@ -484,8 +500,7 @@ 
 						$text[12].$text[17].$text[22].$text[3].$text[16].$text[21].
 						$text[2].$text[7].$text[20].$text[1].$text[6].$text[11];
 
-			}
-			else // parent::DECRYPT
+			} else // parent::DECRYPT
 			{
 				// create a 6x4 matrix
 				// row 0 is unchanged
@@ -516,8 +531,7 @@ 
 						$text[26].$text[31].$text[16].$text[21].$text[30].$text[3].$text[20].
 						$text[25].$text[2].$text[7].$text[24].$text[29].$text[6].$text[11].
 						$text[28].$text[1].$text[10].$text[15];
-			}
-			else // parent::DECRYPT
+			} else // parent::DECRYPT
 			{
 				// create an 8x4 matrix
 				// row 0 is unchanged
@@ -622,12 +636,13 @@ 
 	 */
 	protected function expandKey()
 	{
-		if($this->keySize() == 16)
-			return $this->expandKey128();
-		else if($this->keySize() == 24)
-			return $this->expandKey192();
-		else if($this->keySize() == 32)
-			return $this->expandKey256();
+		if($this->keySize() == 16) {
+					return $this->expandKey128();
+		} else if($this->keySize() == 24) {
+					return $this->expandKey192();
+		} else if($this->keySize() == 32) {
+					return $this->expandKey256();
+		}
 	}
 
 
@@ -645,19 +660,22 @@ 
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
-		if($this->blockSize() == 16)
-			$max = 44;
-		if($this->blockSize() == 24)
-			$max = 78;
-		if($this->blockSize() == 32)
-			$max = 120;
+		if($this->blockSize() == 16) {
+					$max = 44;
+		}
+		if($this->blockSize() == 24) {
+					$max = 78;
+		}
+		if($this->blockSize() == 32) {
+					$max = 120;
+		}
 
 		// 16 byte key expands to 176 bytes
 		for($i = 0; $i < $max; ++$i)
 		{
-			if($i >= 0 && $i <= 3)
-				$this->xkey .= $this->k($i * 4);
-			else if(($i % 4) == 0)
+			if($i >= 0 && $i <= 3) {
+							$this->xkey .= $this->k($i * 4);
+			} else if(($i % 4) == 0)
 			{
 				// rotate the 4 bytes
 				$subword = $this->rotWord($this->ek(($i - 1) * 4));
@@ -677,8 +695,7 @@ 
 				$h3 = parent::str2Hex($ek);
 				$res = parent::xorHex($h1, $h2, $h3);
 				$this->xkey .= parent::hex2Str($res);
-			}
-			else
+			} else
 			{
 				$h1 = parent::str2Hex($this->ek(($i - 1) * 4));
 				$h2 = parent::str2Hex($this->ek(($i - 4) * 4));
@@ -705,19 +722,22 @@ 
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
-		if($this->blockSize() == 16)
-			$max = 52;
-		if($this->blockSize() == 24)
-			$max = 78;
-		if($this->blockSize() == 32)
-			$max = 120;
+		if($this->blockSize() == 16) {
+					$max = 52;
+		}
+		if($this->blockSize() == 24) {
+					$max = 78;
+		}
+		if($this->blockSize() == 32) {
+					$max = 120;
+		}
 
 		// 24 byte key expands to 208 bytes
 		for($i = 0; $i < $max; ++$i)
 		{
-			if($i >= 0 && $i <= 5)
-				$this->xkey .= $this->k($i * 4);
-			else if(($i % 6) == 0)
+			if($i >= 0 && $i <= 5) {
+							$this->xkey .= $this->k($i * 4);
+			} else if(($i % 6) == 0)
 			{
 				// rotate the 4 bytes
 				$subword = $this->rotWord($this->ek(($i - 1) * 4));
@@ -737,8 +757,7 @@ 
 				$h3 = parent::str2Hex($ek);
 				$res = parent::xorHex($h1, $h2, $h3);
 				$this->xkey .= parent::hex2Str($res);
-			}
-			else
+			} else
 			{
 				$h1 = parent::str2Hex($this->ek(($i - 1) * 4));
 				$h2 = parent::str2Hex($this->ek(($i - 6) * 4));
@@ -765,19 +784,22 @@ 
 
 		// the number of rounds we make depends on the block size of the text
 		// used during encryption/decryption
-		if($this->blockSize() == 16)
-			$max = 60;
-		if($this->blockSize() == 24)
-			$max = 90;
-		if($this->blockSize() == 32)
-			$max = 120;
+		if($this->blockSize() == 16) {
+					$max = 60;
+		}
+		if($this->blockSize() == 24) {
+					$max = 90;
+		}
+		if($this->blockSize() == 32) {
+					$max = 120;
+		}
 
 		// 32 byte key expands to 240 bytes
 		for($i = 0; $i < $max; ++$i)
 		{
-			if($i >= 0 && $i <= 7)
-				$this->xkey .= $this->k($i * 4);
-			else if($i % 8 == 0)
+			if($i >= 0 && $i <= 7) {
+							$this->xkey .= $this->k($i * 4);
+			} else if($i % 8 == 0)
 			{
 				// rotate the 4 bytes
 				$subword = $this->rotWord($this->ek(($i - 1) * 4));
@@ -796,8 +818,7 @@ 
 				$h3 = parent::str2Hex($ek);
 				$res = parent::xorHex($h1, $h2, $h3);
 				$this->xkey .= parent::hex2Str($res);
-			}
-			else if($i % 4 == 0)
+			} else if($i % 4 == 0)
 			{
 				// get the subsitution from the s-box
 				$subword = $this->ek(($i - 1) * 4);
@@ -811,8 +832,7 @@ 
 				$h2 = parent::str2Hex($ek);
 				$res = parent::xorHex($h1, $h2);
 				$this->xkey .= parent::hex2Str($res);
-			}
-			else
+			} else
 			{
 				$h1 = parent::str2Hex($this->ek(($i - 1) * 4));
 				$h2 = parent::str2Hex($this->ek(($i - 8) * 4));

includes/libraries/phpcrypt/ciphers/SimpleXOR.php

Doc Comments +1 added lines, -1 removed lines

@@ -108,7 +108,7 @@
 	 * this function contains the code to do both. The SimpleXOR::Encrypt()
 	 * and SimpleXOR::Decrypt() function above just call this function
 	 *
-	 * @param string $input
+	 * @param string $text
 	 * @return boolean Always returns true
 	 */
 	private function simpleXOR(&$text)

Indentation +96 added lines, -96 removed lines

@@ -45,101 +45,101 @@
  */
 class Cipher_Simple_XOR extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 1; // 8 bits
-
-
-	/**
-	 * Constructor
-	 * Sets the key used for encryption. Also sets the requied block size
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// SimpleXOR does not have a key size requirement
-		parent::__construct(PHP_Crypt::CIPHER_SIMPLEXOR, $key);
-
-		// required block size in bits
-		$this->blockSize(self::BYTES_BLOCK);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts data using an XOR encryption scheme
-	 *
-	 * @param string $text A string to encrypt
-	 * @return boolean Always returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->simpleXOR($text);
-	}
-
-
-	/**
-	 * Decrypts data encrypted with SimpleXOR::Encrypt()
-	 *
-	 * @param string $text An encrypted string to decrypt
-	 * @return boolean Always returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->simpleXOR($text);
-	}
-
-
-	/**
-	 * Because XOR Encryption uses the same algorithm to encrypt and decrypt,
-	 * this function contains the code to do both. The SimpleXOR::Encrypt()
-	 * and SimpleXOR::Decrypt() function above just call this function
-	 *
-	 * @param string $input
-	 * @return boolean Always returns true
-	 */
-	private function simpleXOR(&$text)
-	{
-		$pos = 0;
-		$max = strlen($text);
-		$key = $this->key();
-
-		for($i = 0; $i < $max; ++$i)
-		{
-			// if the current position in the key reaches the end of the key,
-			// start over at position 0 of the key
-			if($pos >= $this->keySize())
-				$pos = 0;
-
-			$text[$i] = $text[$i] ^ $key[$pos];
-			++$pos;
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Indicates that this is stream cipher
-	 *
-	 * @return integer Returns Cipher::STREAM
-	 */
-	public function type()
-	{
-		return parent::STREAM;
-	}
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 1; // 8 bits
+
+
+    /**
+     * Constructor
+     * Sets the key used for encryption. Also sets the requied block size
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // SimpleXOR does not have a key size requirement
+        parent::__construct(PHP_Crypt::CIPHER_SIMPLEXOR, $key);
+
+        // required block size in bits
+        $this->blockSize(self::BYTES_BLOCK);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts data using an XOR encryption scheme
+     *
+     * @param string $text A string to encrypt
+     * @return boolean Always returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->simpleXOR($text);
+    }
+
+
+    /**
+     * Decrypts data encrypted with SimpleXOR::Encrypt()
+     *
+     * @param string $text An encrypted string to decrypt
+     * @return boolean Always returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->simpleXOR($text);
+    }
+
+
+    /**
+     * Because XOR Encryption uses the same algorithm to encrypt and decrypt,
+     * this function contains the code to do both. The SimpleXOR::Encrypt()
+     * and SimpleXOR::Decrypt() function above just call this function
+     *
+     * @param string $input
+     * @return boolean Always returns true
+     */
+    private function simpleXOR(&$text)
+    {
+        $pos = 0;
+        $max = strlen($text);
+        $key = $this->key();
+
+        for($i = 0; $i < $max; ++$i)
+        {
+            // if the current position in the key reaches the end of the key,
+            // start over at position 0 of the key
+            if($pos >= $this->keySize())
+                $pos = 0;
+
+            $text[$i] = $text[$i] ^ $key[$pos];
+            ++$pos;
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Indicates that this is stream cipher
+     *
+     * @return integer Returns Cipher::STREAM
+     */
+    public function type()
+    {
+        return parent::STREAM;
+    }
 }
 ?>

Spacing +2 added lines, -2 removed lines

@@ -117,11 +117,11 @@
 		$max = strlen($text);
 		$key = $this->key();
 
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// if the current position in the key reaches the end of the key,
 			// start over at position 0 of the key
-			if($pos >= $this->keySize())
+			if ($pos >= $this->keySize())
 				$pos = 0;
 
 			$text[$i] = $text[$i] ^ $key[$pos];

Braces +3 added lines, -2 removed lines

@@ -121,8 +121,9 @@
 		{
 			// if the current position in the key reaches the end of the key,
 			// start over at position 0 of the key
-			if($pos >= $this->keySize())
-				$pos = 0;
+			if($pos >= $this->keySize()) {
+							$pos = 0;
+			}
 
 			$text[$i] = $text[$i] ^ $key[$pos];
 			++$pos;

includes/libraries/phpcrypt/ciphers/Skipjack.php

Doc Comments -2 removed lines

@@ -88,7 +88,6 @@ 
 	/**
 	 * Encrypt plain text data using Skipjack
 	 *
-	 * @param string $data A plain text string, 8 bytes long
 	 * @return boolean Returns true
 	 */
 	public function encrypt(&$text)
@@ -120,7 +119,6 @@ 
 	/**
 	 * Decrypt a Skipjack encrypted string
 	 *
-	 * @param string $encrypted A Skipjack encrypted string, 8 bytes long
 	 * @return boolean Returns true
 	 */
 	public function decrypt(&$text)

Indentation +317 added lines, -317 removed lines

@@ -39,205 +39,205 @@ 
  */
 class Cipher_Skipjack extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 8; // 64 bits
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 8; // 64 bits
 
-	/** @type integer BYTES_KEY The size of the key, in bytes */
-	const BYTES_KEY = 10; // 80 bits
+    /** @type integer BYTES_KEY The size of the key, in bytes */
+    const BYTES_KEY = 10; // 80 bits
 
-	/** @type string $expanded_key The expanded key */
-	private $expanded_key = "";
+    /** @type string $expanded_key The expanded key */
+    private $expanded_key = "";
 
-	/** @type array $_f The Skipjack F-Table, this is a constant */
-	private static $_f = array();
+    /** @type array $_f The Skipjack F-Table, this is a constant */
+    private static $_f = array();
 
 
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// set the Skipjack key
-		parent::__construct(PHP_Crypt::CIPHER_SKIPJACK, $key, self::BYTES_KEY);
-
-		// initialize variables
-		$this->initTables();
-
-		// set the block size used
-		$this->blockSize(self::BYTES_BLOCK);
-
-		// expand the key from 10 bytes to 128 bytes
-		$this->expandKey();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using Skipjack
-	 *
-	 * @param string $data A plain text string, 8 bytes long
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-
-		for($i = 1; $i <= 32; ++$i)
-		{
-			$pos = (4 * $i) - 4;
-			$subkey = substr($this->expanded_key, $pos, 4);
-
-			if($i >= 1 && $i <= 8)
-				$this->ruleA($text, $subkey, $i);
-
-			if($i >= 9 && $i <= 16)
-				$this->ruleB($text, $subkey, $i);
-
-			if($i >= 17 && $i <= 24)
-				$this->ruleA($text, $subkey, $i);
-
-			if($i >= 25 && $i <= 32)
-				$this->ruleB($text, $subkey, $i);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt a Skipjack encrypted string
-	 *
-	 * @param string $encrypted A Skipjack encrypted string, 8 bytes long
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-
-		for($i = 32; $i >= 1; --$i)
-		{
-			$pos = ($i - 1) * 4;
-			$subkey = substr($this->expanded_key, $pos, 4);
-
-			if($i <= 32 && $i >= 25)
-				$this->ruleB($text, $subkey, $i);
-
-			if($i <= 24 && $i >= 17)
-				$this->ruleA($text, $subkey, $i);
-
-			if($i <= 16 && $i >= 9)
-				$this->ruleB($text, $subkey, $i);
-
-			if($i <= 8 && $i >= 1)
-				$this->ruleA($text, $subkey, $i);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * For the G Permutations, the input data is 2 Bytes The first byte is
-	 * the left side and the second is the right side.The round key is 4 bytes
-	 * long (Indices 8*i-8 to 8*i), which is split as 4 pieces: K0, K1, K2, K3
-	 *
-	 * @param string $bytes A 2 byte string
-	 * @param string $key 4 bytes of $this->expanded_key
-	 * @return string A 2 byte string, the G Permutation of $bytes
-	 */
-	private function gPermutation($bytes, $key)
-	{
-		$left = ord($bytes[0]);
-		$right = ord($bytes[1]);
-
-		if($this->operation() == parent::ENCRYPT)
-		{
-			for($i = 0; $i < 4; ++$i)
-			{
-				if($i == 0 || $i == 2)
-				{
-					$pos = $right ^ $this->str2Dec($key[$i]);
-					$left = $left ^ self::$_f[$pos];
-				}
-				else
-				{
-					$pos = $left ^ $this->str2Dec($key[$i]);
-					$right = $right ^ self::$_f[$pos];
-				}
-			}
-		}
-		else // parent::DECRYPT
-		{
-			// we do the same as in encryption, but apply the key backwards,
-			// from key[3] to key[0]
-			for($i = 3; $i >= 0; --$i)
-			{
-				if($i == 0 || $i == 2)
-				{
-					$pos = $right ^ $this->str2Dec($key[$i]);
-					$left = $left ^ self::$_f[$pos];
-				}
-				else
-				{
-					$pos = $left ^ $this->str2Dec($key[$i]);
-					$right = $right ^ self::$_f[$pos];
-				}
-			}
-		}
-
-		return $this->dec2Str($left).$this->dec2Str($right);
-	}
-
-
-	/**
-	 * Perform SkipJacks RuleA function. Split the data into 4 parts,
-	 * 2 bytes each: W0, W1, W2, W3.
-	 *
-	 * @param string $bytes An 8 byte string
-	 * @param string $key 4 bytes of $this->expanded_key
-	 * @param integer $i The round number
-	 * @return void
-	 */
-	private function ruleA(&$bytes, $key, $i)
-	{
-		$w = str_split($bytes, 2);
-
-		if($this->operation() == parent::ENCRYPT)
-		{
-			/*
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // set the Skipjack key
+        parent::__construct(PHP_Crypt::CIPHER_SKIPJACK, $key, self::BYTES_KEY);
+
+        // initialize variables
+        $this->initTables();
+
+        // set the block size used
+        $this->blockSize(self::BYTES_BLOCK);
+
+        // expand the key from 10 bytes to 128 bytes
+        $this->expandKey();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using Skipjack
+     *
+     * @param string $data A plain text string, 8 bytes long
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+
+        for($i = 1; $i <= 32; ++$i)
+        {
+            $pos = (4 * $i) - 4;
+            $subkey = substr($this->expanded_key, $pos, 4);
+
+            if($i >= 1 && $i <= 8)
+                $this->ruleA($text, $subkey, $i);
+
+            if($i >= 9 && $i <= 16)
+                $this->ruleB($text, $subkey, $i);
+
+            if($i >= 17 && $i <= 24)
+                $this->ruleA($text, $subkey, $i);
+
+            if($i >= 25 && $i <= 32)
+                $this->ruleB($text, $subkey, $i);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt a Skipjack encrypted string
+     *
+     * @param string $encrypted A Skipjack encrypted string, 8 bytes long
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+
+        for($i = 32; $i >= 1; --$i)
+        {
+            $pos = ($i - 1) * 4;
+            $subkey = substr($this->expanded_key, $pos, 4);
+
+            if($i <= 32 && $i >= 25)
+                $this->ruleB($text, $subkey, $i);
+
+            if($i <= 24 && $i >= 17)
+                $this->ruleA($text, $subkey, $i);
+
+            if($i <= 16 && $i >= 9)
+                $this->ruleB($text, $subkey, $i);
+
+            if($i <= 8 && $i >= 1)
+                $this->ruleA($text, $subkey, $i);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * For the G Permutations, the input data is 2 Bytes The first byte is
+     * the left side and the second is the right side.The round key is 4 bytes
+     * long (Indices 8*i-8 to 8*i), which is split as 4 pieces: K0, K1, K2, K3
+     *
+     * @param string $bytes A 2 byte string
+     * @param string $key 4 bytes of $this->expanded_key
+     * @return string A 2 byte string, the G Permutation of $bytes
+     */
+    private function gPermutation($bytes, $key)
+    {
+        $left = ord($bytes[0]);
+        $right = ord($bytes[1]);
+
+        if($this->operation() == parent::ENCRYPT)
+        {
+            for($i = 0; $i < 4; ++$i)
+            {
+                if($i == 0 || $i == 2)
+                {
+                    $pos = $right ^ $this->str2Dec($key[$i]);
+                    $left = $left ^ self::$_f[$pos];
+                }
+                else
+                {
+                    $pos = $left ^ $this->str2Dec($key[$i]);
+                    $right = $right ^ self::$_f[$pos];
+                }
+            }
+        }
+        else // parent::DECRYPT
+        {
+            // we do the same as in encryption, but apply the key backwards,
+            // from key[3] to key[0]
+            for($i = 3; $i >= 0; --$i)
+            {
+                if($i == 0 || $i == 2)
+                {
+                    $pos = $right ^ $this->str2Dec($key[$i]);
+                    $left = $left ^ self::$_f[$pos];
+                }
+                else
+                {
+                    $pos = $left ^ $this->str2Dec($key[$i]);
+                    $right = $right ^ self::$_f[$pos];
+                }
+            }
+        }
+
+        return $this->dec2Str($left).$this->dec2Str($right);
+    }
+
+
+    /**
+     * Perform SkipJacks RuleA function. Split the data into 4 parts,
+     * 2 bytes each: W0, W1, W2, W3.
+     *
+     * @param string $bytes An 8 byte string
+     * @param string $key 4 bytes of $this->expanded_key
+     * @param integer $i The round number
+     * @return void
+     */
+    private function ruleA(&$bytes, $key, $i)
+    {
+        $w = str_split($bytes, 2);
+
+        if($this->operation() == parent::ENCRYPT)
+        {
+            /*
 			 * Set the W3 as the old W2
 			 * Set the W2 as the old W1
 			 * Set the W1 as the G(W0)
 			 * Set the W0 as the W1 xor W4 xor i
 			 */
 
-			$w[4] = $w[3];
-			$w[3] = $w[2];
-			$w[2] = $w[1];
-			$w[1] = $this->gPermutation($w[0], $key);
-
-			$hex1 = $this->str2Hex($w[1]);
-			$hex4 = $this->str2Hex($w[4]);
-			$hexi = $this->dec2Hex($i);
-			$w[0] = $this->xorHex($hex1, $hex4, $hexi);
-			$w[0] = $this->hex2Str($w[0]);
-		}
-		else // parent::DECRYPT
-		{
-			/*
+            $w[4] = $w[3];
+            $w[3] = $w[2];
+            $w[2] = $w[1];
+            $w[1] = $this->gPermutation($w[0], $key);
+
+            $hex1 = $this->str2Hex($w[1]);
+            $hex4 = $this->str2Hex($w[4]);
+            $hexi = $this->dec2Hex($i);
+            $w[0] = $this->xorHex($hex1, $hex4, $hexi);
+            $w[0] = $this->hex2Str($w[0]);
+        }
+        else // parent::DECRYPT
+        {
+            /*
 			 * Set W4 as W0 xor W1 xor i
 			 * Set W0 as Inverse G(W1)
 			 * Set W1 as the old W2
@@ -245,60 +245,60 @@ 
 			 * Set W3 as W4
 			 */
 
-			$hex0 = $this->str2Hex($w[0]);
-			$hex1 = $this->str2Hex($w[1]);
-			$hexi = $this->dec2Hex($i);
-			$w[4] = $this->xorHex($hex0, $hex1, $hexi);
-			$w[4] = $this->hex2Str($w[4]);
-
-			$w[0] = $this->gPermutation($w[1], $key);
-			$w[1] = $w[2];
-			$w[2] = $w[3];
-			$w[3] = $w[4];
-		}
-
-		// glue all the pieces back together
-		$bytes = $w[0].$w[1].$w[2].$w[3];
-	}
-
-
-	/**
-	 * Perform SkipJacks RuleB function. Split the data into 4 parts,
-	 * 2 bytes each: W0, W1, W2, W3.
-	 *
-	 * @param string $bytes An 8 bytes string
-	 * @param string $key 4 bytes of $this->expanded_key
-	 * @param integer $i The round number
-	 * @return void
-	 */
-	private function ruleB(&$bytes, $key, $i)
-	{
-		$w = str_split($bytes, 2);
-
-		if($this->operation() == parent::ENCRYPT)
-		{
-			/*
+            $hex0 = $this->str2Hex($w[0]);
+            $hex1 = $this->str2Hex($w[1]);
+            $hexi = $this->dec2Hex($i);
+            $w[4] = $this->xorHex($hex0, $hex1, $hexi);
+            $w[4] = $this->hex2Str($w[4]);
+
+            $w[0] = $this->gPermutation($w[1], $key);
+            $w[1] = $w[2];
+            $w[2] = $w[3];
+            $w[3] = $w[4];
+        }
+
+        // glue all the pieces back together
+        $bytes = $w[0].$w[1].$w[2].$w[3];
+    }
+
+
+    /**
+     * Perform SkipJacks RuleB function. Split the data into 4 parts,
+     * 2 bytes each: W0, W1, W2, W3.
+     *
+     * @param string $bytes An 8 bytes string
+     * @param string $key 4 bytes of $this->expanded_key
+     * @param integer $i The round number
+     * @return void
+     */
+    private function ruleB(&$bytes, $key, $i)
+    {
+        $w = str_split($bytes, 2);
+
+        if($this->operation() == parent::ENCRYPT)
+        {
+            /*
 			 * Set the new W3 as the old W2
 			 * Set the new W2 as the old W0 xor old W1 xor i
 			 * Set the new W1 as G(old W0)
 			 * Set the new W0 as the old W3
 			 */
 
-			$w[4] = $w[3];
-			$w[3] = $w[2];
-
-			$hex0 = $this->str2Hex($w[0]);
-			$hex1 = $this->str2Hex($w[1]);
-			$hexi = $this->dec2Hex($i);
-			$w[2] = $this->xorHex($hex0, $hex1, $hexi);
-			$w[2] = $this->hex2Str($w[2]);
-
-			$w[1] = $this->gPermutation($w[0], $key);
-			$w[0] = $w[4];
-		}
-		else // parent::DECRYPT
-		{
-			/*
+            $w[4] = $w[3];
+            $w[3] = $w[2];
+
+            $hex0 = $this->str2Hex($w[0]);
+            $hex1 = $this->str2Hex($w[1]);
+            $hexi = $this->dec2Hex($i);
+            $w[2] = $this->xorHex($hex0, $hex1, $hexi);
+            $w[2] = $this->hex2Str($w[2]);
+
+            $w[1] = $this->gPermutation($w[0], $key);
+            $w[0] = $w[4];
+        }
+        else // parent::DECRYPT
+        {
+            /*
 			 * Set W4 as the old W0
 			 * Set new W0 as Inverse G(old W1)
 			 * Set new W1 as Inverse G(old W1) xor old W2 xor i
@@ -306,86 +306,86 @@ 
 			 * Set new W0 as the old W4
 			 */
 
-			$w[4] = $w[0];
-			$w[0] = $this->gPermutation($w[1], $key);
-
-			$hex0 = $this->str2Hex($w[0]);
-			$hex2 = $this->str2Hex($w[2]);
-			$hexi = $this->dec2Hex($i);
-			$w[1] = $this->xorHex($hex0, $hex2, $hexi);
-			$w[1] = $this->hex2Str($w[1]);
-
-			$w[2] = $w[3];
-			$w[3] = $w[4];
-		}
-
-		$bytes = $w[0].$w[1].$w[2].$w[3];
-	}
-
-
-	/**
-	 * Expands the key from 10 bytes, to 128 bytes
-	 * This is done by copying the key 1 byte at a time and
-	 * appending it to $this->expanded_key, when we reach the
-	 * end of the key, we start over at position 0 and continue
-	 * until we reach 128 bytes
-	 *
-	 * @return void
-	 */
-	private function expandKey()
-	{
-		$this->expanded_key = "";
-		$key_bytes = $this->keySize();
-		$key = $this->key();
-		$pos = 0;
-
-		for($i = 0; $i < 128; ++$i)
-		{
-			if($pos == $key_bytes)
-				$pos = 0;
-
-			$this->expanded_key .= $key[$pos];
-			++$pos;
-		}
-	}
-
-
-	/**
-	 * Initialize all the tables, this function is called inside the constructor
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		self::$_f = array(
-			0xa3, 0xd7, 0x09, 0x83, 0xf8, 0x48, 0xf6, 0xf4, 0xb3, 0x21, 0x15, 0x78, 0x99, 0xb1, 0xaf, 0xf9,
-			0xe7, 0x2d, 0x4d, 0x8a, 0xce, 0x4c, 0xca, 0x2e, 0x52, 0x95, 0xd9, 0x1e, 0x4e, 0x38, 0x44, 0x28,
-			0x0a, 0xdf, 0x02, 0xa0, 0x17, 0xf1, 0x60, 0x68, 0x12, 0xb7, 0x7a, 0xc3, 0xe9, 0xfa, 0x3d, 0x53,
-			0x96, 0x84, 0x6b, 0xba, 0xf2, 0x63, 0x9a, 0x19, 0x7c, 0xae, 0xe5, 0xf5, 0xf7, 0x16, 0x6a, 0xa2,
-			0x39, 0xb6, 0x7b, 0x0f, 0xc1, 0x93, 0x81, 0x1b, 0xee, 0xb4, 0x1a, 0xea, 0xd0, 0x91, 0x2f, 0xb8,
-			0x55, 0xb9, 0xda, 0x85, 0x3f, 0x41, 0xbf, 0xe0, 0x5a, 0x58, 0x80, 0x5f, 0x66, 0x0b, 0xd8, 0x90,
-			0x35, 0xd5, 0xc0, 0xa7, 0x33, 0x06, 0x65, 0x69, 0x45, 0x00, 0x94, 0x56, 0x6d, 0x98, 0x9b, 0x76,
-			0x97, 0xfc, 0xb2, 0xc2, 0xb0, 0xfe, 0xdb, 0x20, 0xe1, 0xeb, 0xd6, 0xe4, 0xdd, 0x47, 0x4a, 0x1d,
-			0x42, 0xed, 0x9e, 0x6e, 0x49, 0x3c, 0xcd, 0x43, 0x27, 0xd2, 0x07, 0xd4, 0xde, 0xc7, 0x67, 0x18,
-			0x89, 0xcb, 0x30, 0x1f, 0x8d, 0xc6, 0x8f, 0xaa, 0xc8, 0x74, 0xdc, 0xc9, 0x5d, 0x5c, 0x31, 0xa4,
-			0x70, 0x88, 0x61, 0x2c, 0x9f, 0x0d, 0x2b, 0x87, 0x50, 0x82, 0x54, 0x64, 0x26, 0x7d, 0x03, 0x40,
-			0x34, 0x4b, 0x1c, 0x73, 0xd1, 0xc4, 0xfd, 0x3b, 0xcc, 0xfb, 0x7f, 0xab, 0xe6, 0x3e, 0x5b, 0xa5,
-			0xad, 0x04, 0x23, 0x9c, 0x14, 0x51, 0x22, 0xf0, 0x29, 0x79, 0x71, 0x7e, 0xff, 0x8c, 0x0e, 0xe2,
-			0x0c, 0xef, 0xbc, 0x72, 0x75, 0x6f, 0x37, 0xa1, 0xec, 0xd3, 0x8e, 0x62, 0x8b, 0x86, 0x10, 0xe8,
-			0x08, 0x77, 0x11, 0xbe, 0x92, 0x4f, 0x24, 0xc5, 0x32, 0x36, 0x9d, 0xcf, 0xf3, 0xa6, 0xbb, 0xac,
-			0x5e, 0x6c, 0xa9, 0x13, 0x57, 0x25, 0xb5, 0xe3, 0xbd, 0xa8, 0x3a, 0x01, 0x05, 0x59, 0x2a, 0x46
-		);
-	}
-
-
-	/**
-	 * Indicates that this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+            $w[4] = $w[0];
+            $w[0] = $this->gPermutation($w[1], $key);
+
+            $hex0 = $this->str2Hex($w[0]);
+            $hex2 = $this->str2Hex($w[2]);
+            $hexi = $this->dec2Hex($i);
+            $w[1] = $this->xorHex($hex0, $hex2, $hexi);
+            $w[1] = $this->hex2Str($w[1]);
+
+            $w[2] = $w[3];
+            $w[3] = $w[4];
+        }
+
+        $bytes = $w[0].$w[1].$w[2].$w[3];
+    }
+
+
+    /**
+     * Expands the key from 10 bytes, to 128 bytes
+     * This is done by copying the key 1 byte at a time and
+     * appending it to $this->expanded_key, when we reach the
+     * end of the key, we start over at position 0 and continue
+     * until we reach 128 bytes
+     *
+     * @return void
+     */
+    private function expandKey()
+    {
+        $this->expanded_key = "";
+        $key_bytes = $this->keySize();
+        $key = $this->key();
+        $pos = 0;
+
+        for($i = 0; $i < 128; ++$i)
+        {
+            if($pos == $key_bytes)
+                $pos = 0;
+
+            $this->expanded_key .= $key[$pos];
+            ++$pos;
+        }
+    }
+
+
+    /**
+     * Initialize all the tables, this function is called inside the constructor
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        self::$_f = array(
+            0xa3, 0xd7, 0x09, 0x83, 0xf8, 0x48, 0xf6, 0xf4, 0xb3, 0x21, 0x15, 0x78, 0x99, 0xb1, 0xaf, 0xf9,
+            0xe7, 0x2d, 0x4d, 0x8a, 0xce, 0x4c, 0xca, 0x2e, 0x52, 0x95, 0xd9, 0x1e, 0x4e, 0x38, 0x44, 0x28,
+            0x0a, 0xdf, 0x02, 0xa0, 0x17, 0xf1, 0x60, 0x68, 0x12, 0xb7, 0x7a, 0xc3, 0xe9, 0xfa, 0x3d, 0x53,
+            0x96, 0x84, 0x6b, 0xba, 0xf2, 0x63, 0x9a, 0x19, 0x7c, 0xae, 0xe5, 0xf5, 0xf7, 0x16, 0x6a, 0xa2,
+            0x39, 0xb6, 0x7b, 0x0f, 0xc1, 0x93, 0x81, 0x1b, 0xee, 0xb4, 0x1a, 0xea, 0xd0, 0x91, 0x2f, 0xb8,
+            0x55, 0xb9, 0xda, 0x85, 0x3f, 0x41, 0xbf, 0xe0, 0x5a, 0x58, 0x80, 0x5f, 0x66, 0x0b, 0xd8, 0x90,
+            0x35, 0xd5, 0xc0, 0xa7, 0x33, 0x06, 0x65, 0x69, 0x45, 0x00, 0x94, 0x56, 0x6d, 0x98, 0x9b, 0x76,
+            0x97, 0xfc, 0xb2, 0xc2, 0xb0, 0xfe, 0xdb, 0x20, 0xe1, 0xeb, 0xd6, 0xe4, 0xdd, 0x47, 0x4a, 0x1d,
+            0x42, 0xed, 0x9e, 0x6e, 0x49, 0x3c, 0xcd, 0x43, 0x27, 0xd2, 0x07, 0xd4, 0xde, 0xc7, 0x67, 0x18,
+            0x89, 0xcb, 0x30, 0x1f, 0x8d, 0xc6, 0x8f, 0xaa, 0xc8, 0x74, 0xdc, 0xc9, 0x5d, 0x5c, 0x31, 0xa4,
+            0x70, 0x88, 0x61, 0x2c, 0x9f, 0x0d, 0x2b, 0x87, 0x50, 0x82, 0x54, 0x64, 0x26, 0x7d, 0x03, 0x40,
+            0x34, 0x4b, 0x1c, 0x73, 0xd1, 0xc4, 0xfd, 0x3b, 0xcc, 0xfb, 0x7f, 0xab, 0xe6, 0x3e, 0x5b, 0xa5,
+            0xad, 0x04, 0x23, 0x9c, 0x14, 0x51, 0x22, 0xf0, 0x29, 0x79, 0x71, 0x7e, 0xff, 0x8c, 0x0e, 0xe2,
+            0x0c, 0xef, 0xbc, 0x72, 0x75, 0x6f, 0x37, 0xa1, 0xec, 0xd3, 0x8e, 0x62, 0x8b, 0x86, 0x10, 0xe8,
+            0x08, 0x77, 0x11, 0xbe, 0x92, 0x4f, 0x24, 0xc5, 0x32, 0x36, 0x9d, 0xcf, 0xf3, 0xa6, 0xbb, 0xac,
+            0x5e, 0x6c, 0xa9, 0x13, 0x57, 0x25, 0xb5, 0xe3, 0xbd, 0xa8, 0x3a, 0x01, 0x05, 0x59, 0x2a, 0x46
+        );
+    }
+
+
+    /**
+     * Indicates that this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

Spacing +19 added lines, -19 removed lines

@@ -95,21 +95,21 @@ 
 	{
 		$this->operation(parent::ENCRYPT);
 
-		for($i = 1; $i <= 32; ++$i)
+		for ($i = 1; $i <= 32; ++$i)
 		{
 			$pos = (4 * $i) - 4;
 			$subkey = substr($this->expanded_key, $pos, 4);
 
-			if($i >= 1 && $i <= 8)
+			if ($i >= 1 && $i <= 8)
 				$this->ruleA($text, $subkey, $i);
 
-			if($i >= 9 && $i <= 16)
+			if ($i >= 9 && $i <= 16)
 				$this->ruleB($text, $subkey, $i);
 
-			if($i >= 17 && $i <= 24)
+			if ($i >= 17 && $i <= 24)
 				$this->ruleA($text, $subkey, $i);
 
-			if($i >= 25 && $i <= 32)
+			if ($i >= 25 && $i <= 32)
 				$this->ruleB($text, $subkey, $i);
 		}
 
@@ -127,21 +127,21 @@ 
 	{
 		$this->operation(parent::DECRYPT);
 
-		for($i = 32; $i >= 1; --$i)
+		for ($i = 32; $i >= 1; --$i)
 		{
 			$pos = ($i - 1) * 4;
 			$subkey = substr($this->expanded_key, $pos, 4);
 
-			if($i <= 32 && $i >= 25)
+			if ($i <= 32 && $i >= 25)
 				$this->ruleB($text, $subkey, $i);
 
-			if($i <= 24 && $i >= 17)
+			if ($i <= 24 && $i >= 17)
 				$this->ruleA($text, $subkey, $i);
 
-			if($i <= 16 && $i >= 9)
+			if ($i <= 16 && $i >= 9)
 				$this->ruleB($text, $subkey, $i);
 
-			if($i <= 8 && $i >= 1)
+			if ($i <= 8 && $i >= 1)
 				$this->ruleA($text, $subkey, $i);
 		}
 
@@ -163,11 +163,11 @@ 
 		$left = ord($bytes[0]);
 		$right = ord($bytes[1]);
 
-		if($this->operation() == parent::ENCRYPT)
+		if ($this->operation() == parent::ENCRYPT)
 		{
-			for($i = 0; $i < 4; ++$i)
+			for ($i = 0; $i < 4; ++$i)
 			{
-				if($i == 0 || $i == 2)
+				if ($i == 0 || $i == 2)
 				{
 					$pos = $right ^ $this->str2Dec($key[$i]);
 					$left = $left ^ self::$_f[$pos];
@@ -183,9 +183,9 @@ 
 		{
 			// we do the same as in encryption, but apply the key backwards,
 			// from key[3] to key[0]
-			for($i = 3; $i >= 0; --$i)
+			for ($i = 3; $i >= 0; --$i)
 			{
-				if($i == 0 || $i == 2)
+				if ($i == 0 || $i == 2)
 				{
 					$pos = $right ^ $this->str2Dec($key[$i]);
 					$left = $left ^ self::$_f[$pos];
@@ -215,7 +215,7 @@ 
 	{
 		$w = str_split($bytes, 2);
 
-		if($this->operation() == parent::ENCRYPT)
+		if ($this->operation() == parent::ENCRYPT)
 		{
 			/*
 			 * Set the W3 as the old W2
@@ -275,7 +275,7 @@ 
 	{
 		$w = str_split($bytes, 2);
 
-		if($this->operation() == parent::ENCRYPT)
+		if ($this->operation() == parent::ENCRYPT)
 		{
 			/*
 			 * Set the new W3 as the old W2
@@ -339,9 +339,9 @@ 
 		$key = $this->key();
 		$pos = 0;
 
-		for($i = 0; $i < 128; ++$i)
+		for ($i = 0; $i < 128; ++$i)
 		{
-			if($pos == $key_bytes)
+			if ($pos == $key_bytes)
 				$pos = 0;
 
 			$this->expanded_key .= $key[$pos];

Braces +32 added lines, -28 removed lines

@@ -100,17 +100,21 @@ 
 			$pos = (4 * $i) - 4;
 			$subkey = substr($this->expanded_key, $pos, 4);
 
-			if($i >= 1 && $i <= 8)
-				$this->ruleA($text, $subkey, $i);
+			if($i >= 1 && $i <= 8) {
+							$this->ruleA($text, $subkey, $i);
+			}
 
-			if($i >= 9 && $i <= 16)
-				$this->ruleB($text, $subkey, $i);
+			if($i >= 9 && $i <= 16) {
+							$this->ruleB($text, $subkey, $i);
+			}
 
-			if($i >= 17 && $i <= 24)
-				$this->ruleA($text, $subkey, $i);
+			if($i >= 17 && $i <= 24) {
+							$this->ruleA($text, $subkey, $i);
+			}
 
-			if($i >= 25 && $i <= 32)
-				$this->ruleB($text, $subkey, $i);
+			if($i >= 25 && $i <= 32) {
+							$this->ruleB($text, $subkey, $i);
+			}
 		}
 
 		return true;
@@ -132,17 +136,21 @@ 
 			$pos = ($i - 1) * 4;
 			$subkey = substr($this->expanded_key, $pos, 4);
 
-			if($i <= 32 && $i >= 25)
-				$this->ruleB($text, $subkey, $i);
+			if($i <= 32 && $i >= 25) {
+							$this->ruleB($text, $subkey, $i);
+			}
 
-			if($i <= 24 && $i >= 17)
-				$this->ruleA($text, $subkey, $i);
+			if($i <= 24 && $i >= 17) {
+							$this->ruleA($text, $subkey, $i);
+			}
 
-			if($i <= 16 && $i >= 9)
-				$this->ruleB($text, $subkey, $i);
+			if($i <= 16 && $i >= 9) {
+							$this->ruleB($text, $subkey, $i);
+			}
 
-			if($i <= 8 && $i >= 1)
-				$this->ruleA($text, $subkey, $i);
+			if($i <= 8 && $i >= 1) {
+							$this->ruleA($text, $subkey, $i);
+			}
 		}
 
 		return true;
@@ -171,15 +179,13 @@ 
 				{
 					$pos = $right ^ $this->str2Dec($key[$i]);
 					$left = $left ^ self::$_f[$pos];
-				}
-				else
+				} else
 				{
 					$pos = $left ^ $this->str2Dec($key[$i]);
 					$right = $right ^ self::$_f[$pos];
 				}
 			}
-		}
-		else // parent::DECRYPT
+		} else // parent::DECRYPT
 		{
 			// we do the same as in encryption, but apply the key backwards,
 			// from key[3] to key[0]
@@ -189,8 +195,7 @@ 
 				{
 					$pos = $right ^ $this->str2Dec($key[$i]);
 					$left = $left ^ self::$_f[$pos];
-				}
-				else
+				} else
 				{
 					$pos = $left ^ $this->str2Dec($key[$i]);
 					$right = $right ^ self::$_f[$pos];
@@ -234,8 +239,7 @@ 
 			$hexi = $this->dec2Hex($i);
 			$w[0] = $this->xorHex($hex1, $hex4, $hexi);
 			$w[0] = $this->hex2Str($w[0]);
-		}
-		else // parent::DECRYPT
+		} else // parent::DECRYPT
 		{
 			/*
 			 * Set W4 as W0 xor W1 xor i
@@ -295,8 +299,7 @@ 
 
 			$w[1] = $this->gPermutation($w[0], $key);
 			$w[0] = $w[4];
-		}
-		else // parent::DECRYPT
+		} else // parent::DECRYPT
 		{
 			/*
 			 * Set W4 as the old W0
@@ -341,8 +344,9 @@ 
 
 		for($i = 0; $i < 128; ++$i)
 		{
-			if($pos == $key_bytes)
-				$pos = 0;
+			if($pos == $key_bytes) {
+							$pos = 0;
+			}
 
 			$this->expanded_key .= $key[$pos];
 			++$pos;

includes/libraries/phpcrypt/ciphers/Vigenere.php

Doc Comments -2 removed lines

@@ -77,7 +77,6 @@ 
 	/**
 	 * Encrypt plain text data using Vigenere cipher
 	 *
-	 * @param string $data A plain text string
 	 * @return boolean Returns true
 	 */
 	public function encrypt(&$text)
@@ -114,7 +113,6 @@ 
 	/**
 	 * Decrypt a Vigenere encrypted string
 	 *
-	 * @param string $encrypted A Vigenere encrypted string
 	 * @return boolean Returns true
 	 */
 	public function decrypt(&$text)

Indentation +201 added lines, -201 removed lines

@@ -44,206 +44,206 @@
  */
 class Cipher_Vigenere extends Cipher
 {
-	/** @type array $_vtable The Vigenere table */
-	private static $_vtable = null;
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// set the key
-		parent::__construct(PHP_Crypt::CIPHER_VIGENERE, $key);
-
-		$this->initTables();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using Vigenere cipher
-	 *
-	 * @param string $data A plain text string
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-
-		// convert to uppercase, and remove any non alphabetic characters
-		$text = strtoupper($text);
-		$text = preg_replace("/[^A-Z]/", "", $text);
-		$len = strlen($text);
-
-		// prepare the key for the cipher
-		$this->keyPrep($len);
-
-		// loop through each letter of the message
-		for($i = 0; $i < $len; ++$i)
-		{
-			// get the Cipher letter from the Vigenere table, using the
-			// current letter from the key as the row, and the current letter
-			// from the text, as the column, subtract 65 because ascii upper case
-			// letters start at 65
-			$row = ord($this->expanded_key[$i]) - 65;
-			$col = ord($text[$i]) - 65;
-			$pos = ($row * 26) + $col;
-
-			// convert the plain text to cipher text
-			$text[$i] = self::$_vtable[$pos];
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt a Vigenere encrypted string
-	 *
-	 * @param string $encrypted A Vigenere encrypted string
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-
-		// ensure the cipher text is all uppercase
-		$text = strtoupper($text);
-		$len = strlen($text);
-
-		// prepare the key for the cipher
-		$this->keyPrep($len);
-
-		// go to the row corresponding to the letter from the key
-		for($i = 0; $i < $len; ++$i)
-		{
-			// find the row from the current character of the key, we subtract 65
-			// because uppercase letters start at ASCII 65
-			$row = (ord($this->expanded_key[$i]) - 65) * 26;
-
-			// loop throw the entire row in the table until we find the letter
-			// that matches the letter from the encrypted text
-			for($j = 0; $j < 26; ++$j)
-			{
-				// save the position we are in in the row
-				$pos = $row + $j;
-
-				// compare the letter from the table to the letter in the cipher text
-				if(self::$_vtable[$pos] == $text[$i])
-				{
-					// bingo, we found it. The plain text is the letter associated with
-					// with the column position, again add 65 because ascii capital
-					// letters start at 65
-					$text[$i] = chr($j + 65);
-					break;
-				}
-			}
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Prepare the key. The key can only contain uppercase letters.
-	 * All other characters are stripped out. The key length must match
-	 * The length of the message
-	 *
-	 * @param integer $len The length of message
-	 * @return void
-	 */
-	private function keyPrep($len)
-	{
-		// we never modify the actual key, so we save it into another variable
-		$this->expanded_key = $this->key();
-		$this->expanded_key = strtoupper($this->expanded_key);
-		$this->expanded_key = preg_replace("/[^A-Z]/", "", $this->expanded_key);
-		$keylen = strlen($this->expanded_key);
-
-		// The key must be prepared so that it is the same length as the
-		// message. If it is longer or shorter we need to modify it
-		// to make it the correct length
-		if($keylen > $len)
-			$this->expanded_key = substr($this->expanded_key, 0, $len);
-		else if($len > $keylen)
-		{
-			// if the key is shorter than the message, then we need pad the key
-			// by repeating it until it is the correct length
-			$diff = $len - $keylen;
-			$pos = 0;
-
-			for($i = 0; $i < $diff; ++$i)
-			{
-				if($pos >= $keylen)
-					$pos = 0;
-
-				$this->expanded_key .= $this->expanded_key[$pos];
-				++$pos;
-			}
-		}
-	}
-
-
-	/**
-	 * Initialize the Vigenere table used for encryption & decryption
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		self::$_vtable = array(
-			'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
-			'B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A',
-			'C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B',
-			'D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C',
-			'E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D',
-			'F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E',
-			'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F',
-			'H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G',
-			'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H',
-			'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I',
-			'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J',
-			'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K',
-			'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L',
-			'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M',
-			'O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N',
-			'P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
-			'Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
-			'R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
-			'S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R',
-			'T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S',
-			'U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',
-			'V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U',
-			'W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',
-			'X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W',
-			'Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X',
-			'Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'
-		);
-	}
-
-
-	/**
-	 * Indicates that this is a stream cipher
-	 *
-	 * @return integer Returns Cipher::STREAM
-	 */
-	public function type()
-	{
-		return parent::STREAM;
-	}
+    /** @type array $_vtable The Vigenere table */
+    private static $_vtable = null;
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // set the key
+        parent::__construct(PHP_Crypt::CIPHER_VIGENERE, $key);
+
+        $this->initTables();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using Vigenere cipher
+     *
+     * @param string $data A plain text string
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+
+        // convert to uppercase, and remove any non alphabetic characters
+        $text = strtoupper($text);
+        $text = preg_replace("/[^A-Z]/", "", $text);
+        $len = strlen($text);
+
+        // prepare the key for the cipher
+        $this->keyPrep($len);
+
+        // loop through each letter of the message
+        for($i = 0; $i < $len; ++$i)
+        {
+            // get the Cipher letter from the Vigenere table, using the
+            // current letter from the key as the row, and the current letter
+            // from the text, as the column, subtract 65 because ascii upper case
+            // letters start at 65
+            $row = ord($this->expanded_key[$i]) - 65;
+            $col = ord($text[$i]) - 65;
+            $pos = ($row * 26) + $col;
+
+            // convert the plain text to cipher text
+            $text[$i] = self::$_vtable[$pos];
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt a Vigenere encrypted string
+     *
+     * @param string $encrypted A Vigenere encrypted string
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+
+        // ensure the cipher text is all uppercase
+        $text = strtoupper($text);
+        $len = strlen($text);
+
+        // prepare the key for the cipher
+        $this->keyPrep($len);
+
+        // go to the row corresponding to the letter from the key
+        for($i = 0; $i < $len; ++$i)
+        {
+            // find the row from the current character of the key, we subtract 65
+            // because uppercase letters start at ASCII 65
+            $row = (ord($this->expanded_key[$i]) - 65) * 26;
+
+            // loop throw the entire row in the table until we find the letter
+            // that matches the letter from the encrypted text
+            for($j = 0; $j < 26; ++$j)
+            {
+                // save the position we are in in the row
+                $pos = $row + $j;
+
+                // compare the letter from the table to the letter in the cipher text
+                if(self::$_vtable[$pos] == $text[$i])
+                {
+                    // bingo, we found it. The plain text is the letter associated with
+                    // with the column position, again add 65 because ascii capital
+                    // letters start at 65
+                    $text[$i] = chr($j + 65);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Prepare the key. The key can only contain uppercase letters.
+     * All other characters are stripped out. The key length must match
+     * The length of the message
+     *
+     * @param integer $len The length of message
+     * @return void
+     */
+    private function keyPrep($len)
+    {
+        // we never modify the actual key, so we save it into another variable
+        $this->expanded_key = $this->key();
+        $this->expanded_key = strtoupper($this->expanded_key);
+        $this->expanded_key = preg_replace("/[^A-Z]/", "", $this->expanded_key);
+        $keylen = strlen($this->expanded_key);
+
+        // The key must be prepared so that it is the same length as the
+        // message. If it is longer or shorter we need to modify it
+        // to make it the correct length
+        if($keylen > $len)
+            $this->expanded_key = substr($this->expanded_key, 0, $len);
+        else if($len > $keylen)
+        {
+            // if the key is shorter than the message, then we need pad the key
+            // by repeating it until it is the correct length
+            $diff = $len - $keylen;
+            $pos = 0;
+
+            for($i = 0; $i < $diff; ++$i)
+            {
+                if($pos >= $keylen)
+                    $pos = 0;
+
+                $this->expanded_key .= $this->expanded_key[$pos];
+                ++$pos;
+            }
+        }
+    }
+
+
+    /**
+     * Initialize the Vigenere table used for encryption & decryption
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        self::$_vtable = array(
+            'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+            'B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A',
+            'C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B',
+            'D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C',
+            'E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D',
+            'F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E',
+            'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F',
+            'H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G',
+            'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H',
+            'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I',
+            'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J',
+            'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K',
+            'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L',
+            'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M',
+            'O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N',
+            'P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
+            'Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
+            'R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
+            'S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R',
+            'T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S',
+            'U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',
+            'V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U',
+            'W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',
+            'X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W',
+            'Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X',
+            'Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'
+        );
+    }
+
+
+    /**
+     * Indicates that this is a stream cipher
+     *
+     * @return integer Returns Cipher::STREAM
+     */
+    public function type()
+    {
+        return parent::STREAM;
+    }
 }
 ?>

Spacing +34 added lines, -34 removed lines

@@ -93,7 +93,7 @@ 
 		$this->keyPrep($len);
 
 		// loop through each letter of the message
-		for($i = 0; $i < $len; ++$i)
+		for ($i = 0; $i < $len; ++$i)
 		{
 			// get the Cipher letter from the Vigenere table, using the
 			// current letter from the key as the row, and the current letter
@@ -129,7 +129,7 @@ 
 		$this->keyPrep($len);
 
 		// go to the row corresponding to the letter from the key
-		for($i = 0; $i < $len; ++$i)
+		for ($i = 0; $i < $len; ++$i)
 		{
 			// find the row from the current character of the key, we subtract 65
 			// because uppercase letters start at ASCII 65
@@ -137,13 +137,13 @@ 
 
 			// loop throw the entire row in the table until we find the letter
 			// that matches the letter from the encrypted text
-			for($j = 0; $j < 26; ++$j)
+			for ($j = 0; $j < 26; ++$j)
 			{
 				// save the position we are in in the row
 				$pos = $row + $j;
 
 				// compare the letter from the table to the letter in the cipher text
-				if(self::$_vtable[$pos] == $text[$i])
+				if (self::$_vtable[$pos] == $text[$i])
 				{
 					// bingo, we found it. The plain text is the letter associated with
 					// with the column position, again add 65 because ascii capital
@@ -177,18 +177,18 @@ 
 		// The key must be prepared so that it is the same length as the
 		// message. If it is longer or shorter we need to modify it
 		// to make it the correct length
-		if($keylen > $len)
+		if ($keylen > $len)
 			$this->expanded_key = substr($this->expanded_key, 0, $len);
-		else if($len > $keylen)
+		else if ($len > $keylen)
 		{
 			// if the key is shorter than the message, then we need pad the key
 			// by repeating it until it is the correct length
 			$diff = $len - $keylen;
 			$pos = 0;
 
-			for($i = 0; $i < $diff; ++$i)
+			for ($i = 0; $i < $diff; ++$i)
 			{
-				if($pos >= $keylen)
+				if ($pos >= $keylen)
 					$pos = 0;
 
 				$this->expanded_key .= $this->expanded_key[$pos];
@@ -206,32 +206,32 @@ 
 	private function initTables()
 	{
 		self::$_vtable = array(
-			'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
-			'B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A',
-			'C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B',
-			'D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C',
-			'E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D',
-			'F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E',
-			'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F',
-			'H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G',
-			'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H',
-			'J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I',
-			'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J',
-			'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K',
-			'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L',
-			'N','O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M',
-			'O','P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N',
-			'P','Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
-			'Q','R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
-			'R','S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q',
-			'S','T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R',
-			'T','U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S',
-			'U','V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',
-			'V','W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U',
-			'W','X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V',
-			'X','Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W',
-			'Y','Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X',
-			'Z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y'
+			'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+			'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A',
+			'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B',
+			'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C',
+			'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D',
+			'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E',
+			'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F',
+			'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+			'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+			'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+			'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+			'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+			'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
+			'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+			'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
+			'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+			'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+			'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
+			'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+			'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+			'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+			'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+			'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+			'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+			'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+			'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y'
 		);
 	}
 

Braces +6 added lines, -5 removed lines

@@ -177,9 +177,9 @@ 
 		// The key must be prepared so that it is the same length as the
 		// message. If it is longer or shorter we need to modify it
 		// to make it the correct length
-		if($keylen > $len)
-			$this->expanded_key = substr($this->expanded_key, 0, $len);
-		else if($len > $keylen)
+		if($keylen > $len) {
+					$this->expanded_key = substr($this->expanded_key, 0, $len);
+		} else if($len > $keylen)
 		{
 			// if the key is shorter than the message, then we need pad the key
 			// by repeating it until it is the correct length
@@ -188,8 +188,9 @@ 
 
 			for($i = 0; $i < $diff; ++$i)
 			{
-				if($pos >= $keylen)
-					$pos = 0;
+				if($pos >= $keylen) {
+									$pos = 0;
+				}
 
 				$this->expanded_key .= $this->expanded_key[$pos];
 				++$pos;

includes/libraries/phpcrypt/Core.php

Doc Comments +1 added lines, -2 removed lines

@@ -155,6 +155,7 @@ 
 	 * Convert a binary string (ie: 01101011) to a decimal number
 	 *
 	 * @param string A string representation of a binary number
+	 * @param string $bin
 	 * @return integer The number converted from the binary string
 	 */
 	public static function bin2Dec($bin)
@@ -478,7 +479,6 @@ 
 	/**
 	 * Rotates bits Left, appending the bits pushed off the left onto the right
 	 *
-	 * @param integer $n The integer to rotate bits to the left
 	 * @param integer $shifts The number of shifts left to make
 	 * @return integer The resulting value from the rotation
 	 */
@@ -504,7 +504,6 @@ 
 	/**
 	 * Rotates bits right, appending the bits pushed off the right onto the left
 	 *
-	 * @param integer $n The integer to rotate bits to the right
 	 * @param integer $shifts The number of shifts right to make
 	 * @return integer The resulting value from the rotation
 	 */

Indentation +585 added lines, -585 removed lines

@@ -33,590 +33,590 @@
  */
 class Core
 {
-	/** @type integer HASH_LEN The length of md5() hash string */
-	const HASH_LEN = 16;
-
-
-	/**
-	 * Constructor
-	 *
-	 */
-	protected function __construct()
-	{
-
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 */
-	protected function __destruct()
-	{
-
-	}
-
-
-	/**
-	 * Convert hexidecimal to a binary string (ex: "00110110")
-	 *
-	 * @param string $hex A string containing a hexidecimal number
-	 * @return string A string representation of a binary
-	 */
-	public static function hex2Bin($hex)
-	{
-		// if we do not have an even number of hex characters
-		// append a 0 to the beginning to make it even
-		if(strlen($hex) % 2)
-			$hex = "0$hex";
-
-		$parts = str_split($hex, 2);
-		$parts = array_map(function($v) {
-				$v = base_convert($v, 16, 2);
-				return str_pad($v, 8, "0", STR_PAD_LEFT);
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Convert hex to a string
-	 *
-	 * @param string $hex A string representation of Hex (IE: "1a2b3c" not 0x1a2b3c)
-	 * @return string a string
-	 */
-	public static function hex2Str($hex)
-	{
-		// php version >= 5.4 have a hex2bin function, use it
-		// if it exists
-		if(function_exists("hex2bin"))
-			return hex2bin($hex);
-
-		$parts = str_split($hex, 2);
-		$parts = array_map(function($v) {
-				return chr(Core::hex2Dec($v));
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Converts Hex to Decimal
-	 * This function just calls php's hexdec() function,  but I
-	 * encapsulated it in this function to keep things uniform
-	 * and have all possible conversion function available in
-	 * the Cipher class
-	 *
-	 * @param string $hex A hex number to convert to decimal
-	 * @return integer A decimal number
-	 */
-	public static function hex2Dec($hex)
-	{
-		return hexdec($hex);
-	}
-
-
-	/**
-	 * Convert binary string (ie 00110110) to hex
-	 *
-	 * @param string $bin A binary string
-	 * @return string A string representation of hexidecimal number
-	 */
-	public static function bin2Hex($bin)
-	{
-		$parts = str_split($bin, 8);
-
-		$parts = array_map(function($v) {
-			$v = str_pad($v, 8, "0", STR_PAD_LEFT);
-			$v = dechex(bindec($v));
-			return str_pad($v, 2, "0", STR_PAD_LEFT);
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Converts a binary representation (ie 01101011)  back to a string
-	 *
-	 * @param string $bin a binary representation string
-	 * @return string A string of characters representing the binary
-	 */
-	public static function bin2Str($bin)
-	{
-		$hex = self::bin2Hex($bin);
-		return self::hex2Str($hex);
-	}
-
-
-	/**
-	 * Convert a binary string (ie: 01101011) to a decimal number
-	 *
-	 * @param string A string representation of a binary number
-	 * @return integer The number converted from the binary string
-	 */
-	public static function bin2Dec($bin)
-	{
-		return bindec($bin);
-	}
-
-
-	/**
-	 * Convert a string to hex
-	 * This function calls the PHP bin2hex(), and is here
-	 * for consistency with the other string functions
-	 *
-	 * @param string $str A string
-	 * @return string A string representation of hexidecimal number
-	 */
-	public static function str2Hex($str)
-	{
-		return bin2hex($str);
-	}
-
-
-	/**
-	 * Convert a string of characters to a decimal number
-	 *
-	 * @param string $str The string to convert to decimal
-	 * @return integer The integer converted from the string
-	 */
-	public static function str2Dec($str)
-	{
-		$hex = self::str2Hex($str);
-		return self::hex2Dec($hex);
-	}
-
-
-	/**
-	 * Converts a string to binary representation (ie 01101011)
-	 *
-	 * @param string $str A string
-	 * @return string A binary representation of the the string
-	 */
-	public static function str2Bin($str)
-	{
-		$hex = self::str2Hex($str);
-		$parts = str_split($hex, 2);
-
-		$parts = array_map(function($v) {
-			return Core::hex2Bin($v);
-		}, $parts);
-
-		return implode("", $parts);
-	}
-
-
-	/**
-	 * Converts Decimal to Hex
-	 * This function just calls php's dechex() function,  but I
-	 * encapsulated it in this function to keep things uniform
-	 * and have all possible conversion function available in
-	 * the Cipher class
-	 *
-	 * The parameter $req_bytes will pad the return hex with NULL (00)
-	 * until the hex represents the number of bytes given to $req_bytes
-	 * This is because dechex() drops null bytes from the Hex, which may
-	 * be needed in some cases
-	 *
-	 * @param integer $dec A decimal number to convert
-	 * @param integer $req_bytes Optional, forces the string to be at least
-	 *	$req_bytes in size, this is needed because on occasion left most null bytes
-	 *	are dropped in dechex(), causing the string to have a shorter byte
-	 *	size than the initial integer.
-	 * @return string A hexidecimal representation of the decimal number
-	 */
-	public static function dec2Hex($dec, $req_bytes = 0)
-	{
-		$hex = dechex($dec);
-
-		// if we do not have an even number of hex characters
-		// append a 0 to the beginning. dechex() drops leading 0's
-		if(strlen($hex) % 2)
-			$hex = "0$hex";
-
-		// if the number of bytes in the hex is less than
-		// what we need it to be, add null bytes to the
-		// front of the hex to padd it to the required size
-		if(($req_bytes * 2) > strlen($hex))
-			$hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
-
-		return $hex;
-	}
-
-
-	/**
-	 * Converts Decimal to Binary
-	 * This function just calls php's decbin() function,  but I
-	 * encapsulated it in this function to keep things uniform
-	 * and have all possible conversion function available in
-	 * the Cipher class
-	 *
-	 * @param integer $dec A decimal number to convert
-	 * @param integer $req_bytes Optional, forces the string to be at least
-	 *	$req_bytes in size, this is needed because on occasion left most null bytes
-	 *	are dropped in dechex(), causing the string to have a shorter byte
-	 *	size than the initial integer.
-	 * @return string A binary representation of the decimal number
-	 */
-	public static function dec2Bin($dec, $req_bytes = 0)
-	{
-		$hex = self::dec2Hex($dec, $req_bytes);
-		return self::hex2Bin($hex);
-	}
-
-
-	/**
-	 * Convert a decimal to a string of bytes
-	 *
-	 * @param integer $dec A decimal number
-	 * @param integer $req_bytes Optional, forces the string to be at least
-	 *	$req_bytes in size, this is needed because on occasion left most null bytes
-	 *	are dropped in dechex(), causing the string to have a shorter byte
-	 *	size than the initial integer.
-	 * @return string A string with the number of bytes equal to $dec
-	 */
-	public static function dec2Str($dec, $req_bytes = 0)
-	{
-		$hex = self::dec2Hex($dec, $req_bytes);
-		return self::hex2Str($hex);
-	}
-
-
-	/**
-	 * XORs two binary strings (representation of binary, ie 01101011),
-	 * assumed to be equal length
-	 *
-	 * @param string $a A string that represents binary
-	 * @param string $b A string that represents binary
-	 * @return string A representation of binary
-	 */
-	public static function xorBin($a, $b)
-	{
-		$len_a = strlen($a);
-		$len_b = strlen($b);
-		$width = $len_a;
-
-		// first determine if the two binary strings are the same length,
-		// and if not get them to the same length
-		if($len_a > $len_b)
-		{
-			$width = $len_a;
-			$b = str_pad($b, $width, "0", STR_PAD_LEFT);
-		}
-		else if($len_a < $len_b)
-		{
-			$width = $len_b;
-			$a = str_pad($a, $width, "0", STR_PAD_LEFT);
-		}
-
-		// fortunately PHP knows how to XOR each byte in a string
-		// so we don't have to loop to do it
-		$bin = self::bin2Str($a) ^ self::bin2Str($b);
-		return self::str2Bin($bin);
-	}
-
-
-	/**
-	 * ExclusiveOR hex values. Supports an unlimited number of parameters.
-	 * The values are string representations of hex values
-	 * IE: "0a1b2c3d" not 0x0a1b2c3d
-	 *
-	 * @param string Unlimited number parameters, each a string representation of hex
-	 * @return string A string representation of the result in Hex
-	 */
-	public static function xorHex()
-	{
-		$hex   = func_get_args();
-		$count = func_num_args();
-
-		// we need a minimum of 2 values
-		if($count < 2)
-			return false;
-
-		// first get all hex values to an even number
-		array_walk($hex, function(&$val, $i){
-			if(strlen($val) % 2)
-				$val = "0".$val;
-		});
-
-		$res = 0;
-		for($i = 0; $i < $count; ++$i)
-		{
-			// if this is the first loop, set the 'result' to the first
-			// hex value
-			if($i == 0)
-				$res = $hex[0];
-			else
-			{
-				// to make the code easier to follow
-				$h1 = $res;
-				$h2 = $hex[$i];
-
-				// get lengths
-				$len1 = strlen($h1);
-				$len2 = strlen($h2);
-
-				// now check that both hex values are the same length,
-				// if not pad them with 0's until they are
-				if($len1 > $len2)
-					$h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
-				else if($len1 < $len2)
-					$h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
-
-				// PHP knows how to XOR each byte in a string, so convert the
-				// hex to a string, XOR, and convert back
-				$res = self::hex2Str($h1) ^ self::hex2Str($h2);
-				$res = self::str2Hex($res);
-			}
-		}
-
-		return $res;
-	}
-
-
-	/**
-	 * Forces an integer to be signed
-	 *
-	 * @param integer $int An integer
-	 * @return integer An signed integer
-	 */
-	public static function sInt($int)
-	{
-		$arr = unpack("i", pack("i", $int));
-		return $arr[1];
-	}
-
-
-	/**
-	 * Forces an integer to be unsigned
-	 *
-	 * @param integer $int A signed integer
-	 * @return integer An unsigned integer
-	 */
-	public static function uInt($int)
-	{
-		$arr = unpack("I", pack("I", $int));
-		$ret = $arr[1];
-
-		// On 32 bit platforms unpack() and pack() do not convert
-		// from signed to unsigned properly all the time, it will return
-		// the same negative number given to it, the work around is
-		// to use sprintf().
-		// Tested with php 5.3.x on Windows XP & Linux 32bit
-		if($ret < 0)
-			$ret = sprintf("%u", $ret) + 0; // convert from string to int
-
-		return $ret;
-	}
-
-
-	/**
-	 * Forces an integer to be a 32 bit signed integer
-	 *
-	 * @param integer $int An integer
-	 * @return integer An signed 32 bit integer
-	 */
-	public static function sInt32($int)
-	{
-		if(PHP_INT_SIZE === 4) // 32 bit
-			return self::sInt($int);
-		else // PHP_INT_SIZE === 8 // 64 bit
-		{
-			$arr = unpack("l", pack("l", $int));
-			return $arr[1];
-		}
-	}
-
-
-	/**
-	 * Force an integer to be a 32 bit unsigned integer
-	 *
-	 * @param integer $int An integer
-	 * @return integer An unsigned 32 bit integer
-	 */
-	public static function uInt32($int)
-	{
-		if(PHP_INT_SIZE === 4) // 32 bit
-			return self::uInt($int);
-		else // PHP_INT_SIZE === 8  // 64 bit
-		{
-			$arr = unpack("L", pack("L", $int));
-			return $arr[1];
-		}
-	}
-
-
-	/**
-	 * Converts an integer to the value for an signed char
-	 *
-	 * @param integer $int The integer to convert to a signed char
-	 * @return integer A signed integer, representing a signed char
-	 */
-	public static function sChar($int)
-	{
-		$arr = unpack("c", pack("c", $int));
-		return $arr[1];
-	}
-
-
-	/**
-	 * Converts an integer to the value for an unsigned char
-	 *
-	 * @param integer $int The integer to convert to a unsigned char
-	 * @return integer An unsigned integer, representing a unsigned char
-	 */
-	public static function uChar($int)
-	{
-		$arr = unpack("C", pack("C", $int));
-		return $arr[1];
-	}
-
-
-	/**
-	 * Rotates bits Left, appending the bits pushed off the left onto the right
-	 *
-	 * @param integer $n The integer to rotate bits to the left
-	 * @param integer $shifts The number of shifts left to make
-	 * @return integer The resulting value from the rotation
-	 */
-	public static function rotBitsLeft32($i, $shifts)
-	{
-		if($shifts <= 0)
-			return $i;
-
-		$shifts &= 0x1f; /* higher rotates would not bring anything */
-
-		// this is causing problems on 32 bit platform
-		//return self::uInt32(($i << $shifts) | ($i >> (32 - $shifts)));
-
-		// so lets cheat: convert to binary string, rotate left, and
-		// convert back to decimal
-		$i = self::dec2Bin(self::uInt32($i), 4);
-		$i = substr($i, $shifts).substr($i, 0, $shifts);
-		return self::bin2Dec($i);
-
-	}
-
-
-	/**
-	 * Rotates bits right, appending the bits pushed off the right onto the left
-	 *
-	 * @param integer $n The integer to rotate bits to the right
-	 * @param integer $shifts The number of shifts right to make
-	 * @return integer The resulting value from the rotation
-	 */
-	public static function rotBitsRight32($i, $shifts)
-	{
-		if($shifts <= 0)
-			return $i;
-
-		$shifts &= 0x1f; /* higher rotates would not bring anything */
-
-		// this might cause problems on 32 bit platforms since rotBitsLeft32 was
-		// having a problem with some bit shifts on 32 bits
-		// return self::uInt32(($i >> $shifts) | ($i << (32 - $shifts)));
-
-		// so lets cheat: convert to binary string, rotate right,
-		// and convert back to decimal
-		$i = self::dec2Bin($i, 4);
-		$i = substr($i, (-1 * $shifts)).substr($i, 0, (-1 * $shifts));
-		return self::bin2Dec($i);
-	}
-
-
-	/**
-	 * Create a string of random bytes, used for creating an IV
-	 * and a random key. See PHP_Crypt::createKey() and PHP_Crypt::createIV()
-	 * There are 4 ways to auto generate random bytes by setting $src parameter
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, Use the $src to create the random bytes
-	 * 	by default PHP_Crypt::RAND is used when $src is not specified
-	 * @param integer $byte_len The length of the byte string to create
-	 * @return string A random string of bytes
-	 */
-	public static function randBytes($src = PHP_Crypt::RAND, $byte_len = PHP_Crypt::RAND_DEFAULT_SZ)
-	{
-		$bytes = "";
-		$err_msg = "";
-
-		if($src == PHP_Crypt::RAND_DEV_RAND)
-		{
-			if(file_exists(PHP_Crypt::RAND_DEV_RAND))
-				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
-			else
-				$err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
-		}
-		else if($src == PHP_Crypt::RAND_DEV_URAND)
-		{
-			if(file_exists(PHP_Crypt::RAND_DEV_URAND))
-				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
-			else
-				$err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
-		}
-		else if($src == PHP_Crypt::RAND_WIN_COM)
-		{
-			if(extension_loaded('com_dotnet'))
-			{
-				// http://msdn.microsoft.com/en-us/library/aa388176(VS.85).aspx
-				try
-				{
-					// request a random number in $byte_len bytes, returned
-					// as base_64 encoded string. This is because PHP munges the
-					// binary data on Windows
-					$com = @new \COM("CAPICOM.Utilities.1");
-					$bytes = $com->GetRandom($byte_len, 0);
-				}
-				catch(Exception $e)
-				{
-					$err_msg  = "Windows COM exception: ".$e->getMessage();
-				}
-
-				if(!$bytes)
-					$err_msg  = "Windows COM failed to create random string of bytes";
-			}
-			else
-				$err_msg = "The COM_DOTNET extension is not loaded";
-		}
-
-		// trigger a warning if something went wrong
-		if($err_msg != "")
-			trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
-
-		// if the random bytes where not created properly or PHP_Crypt::RAND was
-		// passed as the $src param, create the bytes using mt_rand(). It's not
-		// the most secure option but we have no other choice
-		if(strlen($bytes) < $byte_len)
-		{
-			$bytes = "";
-
-			// md5() hash a random number to get a 16 byte string, keep looping
-			// until we have a string as long or longer than the ciphers block size
-			for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
-				$bytes .= md5(mt_rand(), true);
-		}
-
-		// because $bytes may have come from mt_rand() or /dev/urandom which are not
-		// cryptographically secure, lets add another layer of 'randomness' before
-		// the final md5() below
-		$bytes = str_shuffle($bytes);
-
-		// md5() the $bytes to add extra randomness. Since md5() only returns
-		// 16 bytes, we may need to loop to generate a string of $bytes big enough for
-		// some ciphers which have a block size larger than 16 bytes
-		$tmp = "";
-		$loop = ceil(strlen($bytes) / self::HASH_LEN);
-		for($i = 0; $i < $loop; ++$i)
-			$tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
-
-		// grab the number of bytes equal to the requested $byte_len
-		return substr($tmp, 0, $byte_len);
-	}
+    /** @type integer HASH_LEN The length of md5() hash string */
+    const HASH_LEN = 16;
+
+
+    /**
+     * Constructor
+     *
+     */
+    protected function __construct()
+    {
+
+    }
+
+
+    /**
+     * Destructor
+     *
+     */
+    protected function __destruct()
+    {
+
+    }
+
+
+    /**
+     * Convert hexidecimal to a binary string (ex: "00110110")
+     *
+     * @param string $hex A string containing a hexidecimal number
+     * @return string A string representation of a binary
+     */
+    public static function hex2Bin($hex)
+    {
+        // if we do not have an even number of hex characters
+        // append a 0 to the beginning to make it even
+        if(strlen($hex) % 2)
+            $hex = "0$hex";
+
+        $parts = str_split($hex, 2);
+        $parts = array_map(function($v) {
+                $v = base_convert($v, 16, 2);
+                return str_pad($v, 8, "0", STR_PAD_LEFT);
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Convert hex to a string
+     *
+     * @param string $hex A string representation of Hex (IE: "1a2b3c" not 0x1a2b3c)
+     * @return string a string
+     */
+    public static function hex2Str($hex)
+    {
+        // php version >= 5.4 have a hex2bin function, use it
+        // if it exists
+        if(function_exists("hex2bin"))
+            return hex2bin($hex);
+
+        $parts = str_split($hex, 2);
+        $parts = array_map(function($v) {
+                return chr(Core::hex2Dec($v));
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Converts Hex to Decimal
+     * This function just calls php's hexdec() function,  but I
+     * encapsulated it in this function to keep things uniform
+     * and have all possible conversion function available in
+     * the Cipher class
+     *
+     * @param string $hex A hex number to convert to decimal
+     * @return integer A decimal number
+     */
+    public static function hex2Dec($hex)
+    {
+        return hexdec($hex);
+    }
+
+
+    /**
+     * Convert binary string (ie 00110110) to hex
+     *
+     * @param string $bin A binary string
+     * @return string A string representation of hexidecimal number
+     */
+    public static function bin2Hex($bin)
+    {
+        $parts = str_split($bin, 8);
+
+        $parts = array_map(function($v) {
+            $v = str_pad($v, 8, "0", STR_PAD_LEFT);
+            $v = dechex(bindec($v));
+            return str_pad($v, 2, "0", STR_PAD_LEFT);
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Converts a binary representation (ie 01101011)  back to a string
+     *
+     * @param string $bin a binary representation string
+     * @return string A string of characters representing the binary
+     */
+    public static function bin2Str($bin)
+    {
+        $hex = self::bin2Hex($bin);
+        return self::hex2Str($hex);
+    }
+
+
+    /**
+     * Convert a binary string (ie: 01101011) to a decimal number
+     *
+     * @param string A string representation of a binary number
+     * @return integer The number converted from the binary string
+     */
+    public static function bin2Dec($bin)
+    {
+        return bindec($bin);
+    }
+
+
+    /**
+     * Convert a string to hex
+     * This function calls the PHP bin2hex(), and is here
+     * for consistency with the other string functions
+     *
+     * @param string $str A string
+     * @return string A string representation of hexidecimal number
+     */
+    public static function str2Hex($str)
+    {
+        return bin2hex($str);
+    }
+
+
+    /**
+     * Convert a string of characters to a decimal number
+     *
+     * @param string $str The string to convert to decimal
+     * @return integer The integer converted from the string
+     */
+    public static function str2Dec($str)
+    {
+        $hex = self::str2Hex($str);
+        return self::hex2Dec($hex);
+    }
+
+
+    /**
+     * Converts a string to binary representation (ie 01101011)
+     *
+     * @param string $str A string
+     * @return string A binary representation of the the string
+     */
+    public static function str2Bin($str)
+    {
+        $hex = self::str2Hex($str);
+        $parts = str_split($hex, 2);
+
+        $parts = array_map(function($v) {
+            return Core::hex2Bin($v);
+        }, $parts);
+
+        return implode("", $parts);
+    }
+
+
+    /**
+     * Converts Decimal to Hex
+     * This function just calls php's dechex() function,  but I
+     * encapsulated it in this function to keep things uniform
+     * and have all possible conversion function available in
+     * the Cipher class
+     *
+     * The parameter $req_bytes will pad the return hex with NULL (00)
+     * until the hex represents the number of bytes given to $req_bytes
+     * This is because dechex() drops null bytes from the Hex, which may
+     * be needed in some cases
+     *
+     * @param integer $dec A decimal number to convert
+     * @param integer $req_bytes Optional, forces the string to be at least
+     *	$req_bytes in size, this is needed because on occasion left most null bytes
+     *	are dropped in dechex(), causing the string to have a shorter byte
+     *	size than the initial integer.
+     * @return string A hexidecimal representation of the decimal number
+     */
+    public static function dec2Hex($dec, $req_bytes = 0)
+    {
+        $hex = dechex($dec);
+
+        // if we do not have an even number of hex characters
+        // append a 0 to the beginning. dechex() drops leading 0's
+        if(strlen($hex) % 2)
+            $hex = "0$hex";
+
+        // if the number of bytes in the hex is less than
+        // what we need it to be, add null bytes to the
+        // front of the hex to padd it to the required size
+        if(($req_bytes * 2) > strlen($hex))
+            $hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
+
+        return $hex;
+    }
+
+
+    /**
+     * Converts Decimal to Binary
+     * This function just calls php's decbin() function,  but I
+     * encapsulated it in this function to keep things uniform
+     * and have all possible conversion function available in
+     * the Cipher class
+     *
+     * @param integer $dec A decimal number to convert
+     * @param integer $req_bytes Optional, forces the string to be at least
+     *	$req_bytes in size, this is needed because on occasion left most null bytes
+     *	are dropped in dechex(), causing the string to have a shorter byte
+     *	size than the initial integer.
+     * @return string A binary representation of the decimal number
+     */
+    public static function dec2Bin($dec, $req_bytes = 0)
+    {
+        $hex = self::dec2Hex($dec, $req_bytes);
+        return self::hex2Bin($hex);
+    }
+
+
+    /**
+     * Convert a decimal to a string of bytes
+     *
+     * @param integer $dec A decimal number
+     * @param integer $req_bytes Optional, forces the string to be at least
+     *	$req_bytes in size, this is needed because on occasion left most null bytes
+     *	are dropped in dechex(), causing the string to have a shorter byte
+     *	size than the initial integer.
+     * @return string A string with the number of bytes equal to $dec
+     */
+    public static function dec2Str($dec, $req_bytes = 0)
+    {
+        $hex = self::dec2Hex($dec, $req_bytes);
+        return self::hex2Str($hex);
+    }
+
+
+    /**
+     * XORs two binary strings (representation of binary, ie 01101011),
+     * assumed to be equal length
+     *
+     * @param string $a A string that represents binary
+     * @param string $b A string that represents binary
+     * @return string A representation of binary
+     */
+    public static function xorBin($a, $b)
+    {
+        $len_a = strlen($a);
+        $len_b = strlen($b);
+        $width = $len_a;
+
+        // first determine if the two binary strings are the same length,
+        // and if not get them to the same length
+        if($len_a > $len_b)
+        {
+            $width = $len_a;
+            $b = str_pad($b, $width, "0", STR_PAD_LEFT);
+        }
+        else if($len_a < $len_b)
+        {
+            $width = $len_b;
+            $a = str_pad($a, $width, "0", STR_PAD_LEFT);
+        }
+
+        // fortunately PHP knows how to XOR each byte in a string
+        // so we don't have to loop to do it
+        $bin = self::bin2Str($a) ^ self::bin2Str($b);
+        return self::str2Bin($bin);
+    }
+
+
+    /**
+     * ExclusiveOR hex values. Supports an unlimited number of parameters.
+     * The values are string representations of hex values
+     * IE: "0a1b2c3d" not 0x0a1b2c3d
+     *
+     * @param string Unlimited number parameters, each a string representation of hex
+     * @return string A string representation of the result in Hex
+     */
+    public static function xorHex()
+    {
+        $hex   = func_get_args();
+        $count = func_num_args();
+
+        // we need a minimum of 2 values
+        if($count < 2)
+            return false;
+
+        // first get all hex values to an even number
+        array_walk($hex, function(&$val, $i){
+            if(strlen($val) % 2)
+                $val = "0".$val;
+        });
+
+        $res = 0;
+        for($i = 0; $i < $count; ++$i)
+        {
+            // if this is the first loop, set the 'result' to the first
+            // hex value
+            if($i == 0)
+                $res = $hex[0];
+            else
+            {
+                // to make the code easier to follow
+                $h1 = $res;
+                $h2 = $hex[$i];
+
+                // get lengths
+                $len1 = strlen($h1);
+                $len2 = strlen($h2);
+
+                // now check that both hex values are the same length,
+                // if not pad them with 0's until they are
+                if($len1 > $len2)
+                    $h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
+                else if($len1 < $len2)
+                    $h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
+
+                // PHP knows how to XOR each byte in a string, so convert the
+                // hex to a string, XOR, and convert back
+                $res = self::hex2Str($h1) ^ self::hex2Str($h2);
+                $res = self::str2Hex($res);
+            }
+        }
+
+        return $res;
+    }
+
+
+    /**
+     * Forces an integer to be signed
+     *
+     * @param integer $int An integer
+     * @return integer An signed integer
+     */
+    public static function sInt($int)
+    {
+        $arr = unpack("i", pack("i", $int));
+        return $arr[1];
+    }
+
+
+    /**
+     * Forces an integer to be unsigned
+     *
+     * @param integer $int A signed integer
+     * @return integer An unsigned integer
+     */
+    public static function uInt($int)
+    {
+        $arr = unpack("I", pack("I", $int));
+        $ret = $arr[1];
+
+        // On 32 bit platforms unpack() and pack() do not convert
+        // from signed to unsigned properly all the time, it will return
+        // the same negative number given to it, the work around is
+        // to use sprintf().
+        // Tested with php 5.3.x on Windows XP & Linux 32bit
+        if($ret < 0)
+            $ret = sprintf("%u", $ret) + 0; // convert from string to int
+
+        return $ret;
+    }
+
+
+    /**
+     * Forces an integer to be a 32 bit signed integer
+     *
+     * @param integer $int An integer
+     * @return integer An signed 32 bit integer
+     */
+    public static function sInt32($int)
+    {
+        if(PHP_INT_SIZE === 4) // 32 bit
+            return self::sInt($int);
+        else // PHP_INT_SIZE === 8 // 64 bit
+        {
+            $arr = unpack("l", pack("l", $int));
+            return $arr[1];
+        }
+    }
+
+
+    /**
+     * Force an integer to be a 32 bit unsigned integer
+     *
+     * @param integer $int An integer
+     * @return integer An unsigned 32 bit integer
+     */
+    public static function uInt32($int)
+    {
+        if(PHP_INT_SIZE === 4) // 32 bit
+            return self::uInt($int);
+        else // PHP_INT_SIZE === 8  // 64 bit
+        {
+            $arr = unpack("L", pack("L", $int));
+            return $arr[1];
+        }
+    }
+
+
+    /**
+     * Converts an integer to the value for an signed char
+     *
+     * @param integer $int The integer to convert to a signed char
+     * @return integer A signed integer, representing a signed char
+     */
+    public static function sChar($int)
+    {
+        $arr = unpack("c", pack("c", $int));
+        return $arr[1];
+    }
+
+
+    /**
+     * Converts an integer to the value for an unsigned char
+     *
+     * @param integer $int The integer to convert to a unsigned char
+     * @return integer An unsigned integer, representing a unsigned char
+     */
+    public static function uChar($int)
+    {
+        $arr = unpack("C", pack("C", $int));
+        return $arr[1];
+    }
+
+
+    /**
+     * Rotates bits Left, appending the bits pushed off the left onto the right
+     *
+     * @param integer $n The integer to rotate bits to the left
+     * @param integer $shifts The number of shifts left to make
+     * @return integer The resulting value from the rotation
+     */
+    public static function rotBitsLeft32($i, $shifts)
+    {
+        if($shifts <= 0)
+            return $i;
+
+        $shifts &= 0x1f; /* higher rotates would not bring anything */
+
+        // this is causing problems on 32 bit platform
+        //return self::uInt32(($i << $shifts) | ($i >> (32 - $shifts)));
+
+        // so lets cheat: convert to binary string, rotate left, and
+        // convert back to decimal
+        $i = self::dec2Bin(self::uInt32($i), 4);
+        $i = substr($i, $shifts).substr($i, 0, $shifts);
+        return self::bin2Dec($i);
+
+    }
+
+
+    /**
+     * Rotates bits right, appending the bits pushed off the right onto the left
+     *
+     * @param integer $n The integer to rotate bits to the right
+     * @param integer $shifts The number of shifts right to make
+     * @return integer The resulting value from the rotation
+     */
+    public static function rotBitsRight32($i, $shifts)
+    {
+        if($shifts <= 0)
+            return $i;
+
+        $shifts &= 0x1f; /* higher rotates would not bring anything */
+
+        // this might cause problems on 32 bit platforms since rotBitsLeft32 was
+        // having a problem with some bit shifts on 32 bits
+        // return self::uInt32(($i >> $shifts) | ($i << (32 - $shifts)));
+
+        // so lets cheat: convert to binary string, rotate right,
+        // and convert back to decimal
+        $i = self::dec2Bin($i, 4);
+        $i = substr($i, (-1 * $shifts)).substr($i, 0, (-1 * $shifts));
+        return self::bin2Dec($i);
+    }
+
+
+    /**
+     * Create a string of random bytes, used for creating an IV
+     * and a random key. See PHP_Crypt::createKey() and PHP_Crypt::createIV()
+     * There are 4 ways to auto generate random bytes by setting $src parameter
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, Use the $src to create the random bytes
+     * 	by default PHP_Crypt::RAND is used when $src is not specified
+     * @param integer $byte_len The length of the byte string to create
+     * @return string A random string of bytes
+     */
+    public static function randBytes($src = PHP_Crypt::RAND, $byte_len = PHP_Crypt::RAND_DEFAULT_SZ)
+    {
+        $bytes = "";
+        $err_msg = "";
+
+        if($src == PHP_Crypt::RAND_DEV_RAND)
+        {
+            if(file_exists(PHP_Crypt::RAND_DEV_RAND))
+                $bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
+            else
+                $err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
+        }
+        else if($src == PHP_Crypt::RAND_DEV_URAND)
+        {
+            if(file_exists(PHP_Crypt::RAND_DEV_URAND))
+                $bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
+            else
+                $err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
+        }
+        else if($src == PHP_Crypt::RAND_WIN_COM)
+        {
+            if(extension_loaded('com_dotnet'))
+            {
+                // http://msdn.microsoft.com/en-us/library/aa388176(VS.85).aspx
+                try
+                {
+                    // request a random number in $byte_len bytes, returned
+                    // as base_64 encoded string. This is because PHP munges the
+                    // binary data on Windows
+                    $com = @new \COM("CAPICOM.Utilities.1");
+                    $bytes = $com->GetRandom($byte_len, 0);
+                }
+                catch(Exception $e)
+                {
+                    $err_msg  = "Windows COM exception: ".$e->getMessage();
+                }
+
+                if(!$bytes)
+                    $err_msg  = "Windows COM failed to create random string of bytes";
+            }
+            else
+                $err_msg = "The COM_DOTNET extension is not loaded";
+        }
+
+        // trigger a warning if something went wrong
+        if($err_msg != "")
+            trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
+
+        // if the random bytes where not created properly or PHP_Crypt::RAND was
+        // passed as the $src param, create the bytes using mt_rand(). It's not
+        // the most secure option but we have no other choice
+        if(strlen($bytes) < $byte_len)
+        {
+            $bytes = "";
+
+            // md5() hash a random number to get a 16 byte string, keep looping
+            // until we have a string as long or longer than the ciphers block size
+            for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
+                $bytes .= md5(mt_rand(), true);
+        }
+
+        // because $bytes may have come from mt_rand() or /dev/urandom which are not
+        // cryptographically secure, lets add another layer of 'randomness' before
+        // the final md5() below
+        $bytes = str_shuffle($bytes);
+
+        // md5() the $bytes to add extra randomness. Since md5() only returns
+        // 16 bytes, we may need to loop to generate a string of $bytes big enough for
+        // some ciphers which have a block size larger than 16 bytes
+        $tmp = "";
+        $loop = ceil(strlen($bytes) / self::HASH_LEN);
+        for($i = 0; $i < $loop; ++$i)
+            $tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
+
+        // grab the number of bytes equal to the requested $byte_len
+        return substr($tmp, 0, $byte_len);
+    }
 }
 ?>

Spacing +32 added lines, -32 removed lines

@@ -67,7 +67,7 @@ 
 	{
 		// if we do not have an even number of hex characters
 		// append a 0 to the beginning to make it even
-		if(strlen($hex) % 2)
+		if (strlen($hex) % 2)
 			$hex = "0$hex";
 
 		$parts = str_split($hex, 2);
@@ -90,7 +90,7 @@ 
 	{
 		// php version >= 5.4 have a hex2bin function, use it
 		// if it exists
-		if(function_exists("hex2bin"))
+		if (function_exists("hex2bin"))
 			return hex2bin($hex);
 
 		$parts = str_split($hex, 2);
@@ -234,13 +234,13 @@ 
 
 		// if we do not have an even number of hex characters
 		// append a 0 to the beginning. dechex() drops leading 0's
-		if(strlen($hex) % 2)
+		if (strlen($hex) % 2)
 			$hex = "0$hex";
 
 		// if the number of bytes in the hex is less than
 		// what we need it to be, add null bytes to the
 		// front of the hex to padd it to the required size
-		if(($req_bytes * 2) > strlen($hex))
+		if (($req_bytes * 2) > strlen($hex))
 			$hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
 
 		return $hex;
@@ -301,12 +301,12 @@ 
 
 		// first determine if the two binary strings are the same length,
 		// and if not get them to the same length
-		if($len_a > $len_b)
+		if ($len_a > $len_b)
 		{
 			$width = $len_a;
 			$b = str_pad($b, $width, "0", STR_PAD_LEFT);
 		}
-		else if($len_a < $len_b)
+		else if ($len_a < $len_b)
 		{
 			$width = $len_b;
 			$a = str_pad($a, $width, "0", STR_PAD_LEFT);
@@ -333,21 +333,21 @@ 
 		$count = func_num_args();
 
 		// we need a minimum of 2 values
-		if($count < 2)
+		if ($count < 2)
 			return false;
 
 		// first get all hex values to an even number
-		array_walk($hex, function(&$val, $i){
-			if(strlen($val) % 2)
+		array_walk($hex, function(&$val, $i) {
+			if (strlen($val) % 2)
 				$val = "0".$val;
 		});
 
 		$res = 0;
-		for($i = 0; $i < $count; ++$i)
+		for ($i = 0; $i < $count; ++$i)
 		{
 			// if this is the first loop, set the 'result' to the first
 			// hex value
-			if($i == 0)
+			if ($i == 0)
 				$res = $hex[0];
 			else
 			{
@@ -361,9 +361,9 @@ 
 
 				// now check that both hex values are the same length,
 				// if not pad them with 0's until they are
-				if($len1 > $len2)
+				if ($len1 > $len2)
 					$h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
-				else if($len1 < $len2)
+				else if ($len1 < $len2)
 					$h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
 
 				// PHP knows how to XOR each byte in a string, so convert the
@@ -406,7 +406,7 @@ 
 		// the same negative number given to it, the work around is
 		// to use sprintf().
 		// Tested with php 5.3.x on Windows XP & Linux 32bit
-		if($ret < 0)
+		if ($ret < 0)
 			$ret = sprintf("%u", $ret) + 0; // convert from string to int
 
 		return $ret;
@@ -421,7 +421,7 @@ 
 	 */
 	public static function sInt32($int)
 	{
-		if(PHP_INT_SIZE === 4) // 32 bit
+		if (PHP_INT_SIZE === 4) // 32 bit
 			return self::sInt($int);
 		else // PHP_INT_SIZE === 8 // 64 bit
 		{
@@ -439,7 +439,7 @@ 
 	 */
 	public static function uInt32($int)
 	{
-		if(PHP_INT_SIZE === 4) // 32 bit
+		if (PHP_INT_SIZE === 4) // 32 bit
 			return self::uInt($int);
 		else // PHP_INT_SIZE === 8  // 64 bit
 		{
@@ -484,7 +484,7 @@ 
 	 */
 	public static function rotBitsLeft32($i, $shifts)
 	{
-		if($shifts <= 0)
+		if ($shifts <= 0)
 			return $i;
 
 		$shifts &= 0x1f; /* higher rotates would not bring anything */
@@ -510,7 +510,7 @@ 
 	 */
 	public static function rotBitsRight32($i, $shifts)
 	{
-		if($shifts <= 0)
+		if ($shifts <= 0)
 			return $i;
 
 		$shifts &= 0x1f; /* higher rotates would not bring anything */
@@ -546,23 +546,23 @@ 
 		$bytes = "";
 		$err_msg = "";
 
-		if($src == PHP_Crypt::RAND_DEV_RAND)
+		if ($src == PHP_Crypt::RAND_DEV_RAND)
 		{
-			if(file_exists(PHP_Crypt::RAND_DEV_RAND))
+			if (file_exists(PHP_Crypt::RAND_DEV_RAND))
 				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
 			else
 				$err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
 		}
-		else if($src == PHP_Crypt::RAND_DEV_URAND)
+		else if ($src == PHP_Crypt::RAND_DEV_URAND)
 		{
-			if(file_exists(PHP_Crypt::RAND_DEV_URAND))
+			if (file_exists(PHP_Crypt::RAND_DEV_URAND))
 				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
 			else
 				$err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
 		}
-		else if($src == PHP_Crypt::RAND_WIN_COM)
+		else if ($src == PHP_Crypt::RAND_WIN_COM)
 		{
-			if(extension_loaded('com_dotnet'))
+			if (extension_loaded('com_dotnet'))
 			{
 				// http://msdn.microsoft.com/en-us/library/aa388176(VS.85).aspx
 				try
@@ -573,32 +573,32 @@ 
 					$com = @new \COM("CAPICOM.Utilities.1");
 					$bytes = $com->GetRandom($byte_len, 0);
 				}
-				catch(Exception $e)
+				catch (Exception $e)
 				{
-					$err_msg  = "Windows COM exception: ".$e->getMessage();
+					$err_msg = "Windows COM exception: ".$e->getMessage();
 				}
 
-				if(!$bytes)
-					$err_msg  = "Windows COM failed to create random string of bytes";
+				if (!$bytes)
+					$err_msg = "Windows COM failed to create random string of bytes";
 			}
 			else
 				$err_msg = "The COM_DOTNET extension is not loaded";
 		}
 
 		// trigger a warning if something went wrong
-		if($err_msg != "")
+		if ($err_msg != "")
 			trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
 
 		// if the random bytes where not created properly or PHP_Crypt::RAND was
 		// passed as the $src param, create the bytes using mt_rand(). It's not
 		// the most secure option but we have no other choice
-		if(strlen($bytes) < $byte_len)
+		if (strlen($bytes) < $byte_len)
 		{
 			$bytes = "";
 
 			// md5() hash a random number to get a 16 byte string, keep looping
 			// until we have a string as long or longer than the ciphers block size
-			for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
+			for ($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
 				$bytes .= md5(mt_rand(), true);
 		}
 
@@ -612,7 +612,7 @@ 
 		// some ciphers which have a block size larger than 16 bytes
 		$tmp = "";
 		$loop = ceil(strlen($bytes) / self::HASH_LEN);
-		for($i = 0; $i < $loop; ++$i)
+		for ($i = 0; $i < $loop; ++$i)
 			$tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
 
 		// grab the number of bytes equal to the requested $byte_len

Braces +70 added lines, -55 removed lines

@@ -67,8 +67,9 @@ 
 	{
 		// if we do not have an even number of hex characters
 		// append a 0 to the beginning to make it even
-		if(strlen($hex) % 2)
-			$hex = "0$hex";
+		if(strlen($hex) % 2) {
+					$hex = "0$hex";
+		}
 
 		$parts = str_split($hex, 2);
 		$parts = array_map(function($v) {
@@ -90,8 +91,9 @@ 
 	{
 		// php version >= 5.4 have a hex2bin function, use it
 		// if it exists
-		if(function_exists("hex2bin"))
-			return hex2bin($hex);
+		if(function_exists("hex2bin")) {
+					return hex2bin($hex);
+		}
 
 		$parts = str_split($hex, 2);
 		$parts = array_map(function($v) {
@@ -234,14 +236,16 @@ 
 
 		// if we do not have an even number of hex characters
 		// append a 0 to the beginning. dechex() drops leading 0's
-		if(strlen($hex) % 2)
-			$hex = "0$hex";
+		if(strlen($hex) % 2) {
+					$hex = "0$hex";
+		}
 
 		// if the number of bytes in the hex is less than
 		// what we need it to be, add null bytes to the
 		// front of the hex to padd it to the required size
-		if(($req_bytes * 2) > strlen($hex))
-			$hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
+		if(($req_bytes * 2) > strlen($hex)) {
+					$hex = str_pad($hex, ($req_bytes * 2), "0", STR_PAD_LEFT);
+		}
 
 		return $hex;
 	}
@@ -305,8 +309,7 @@ 
 		{
 			$width = $len_a;
 			$b = str_pad($b, $width, "0", STR_PAD_LEFT);
-		}
-		else if($len_a < $len_b)
+		} else if($len_a < $len_b)
 		{
 			$width = $len_b;
 			$a = str_pad($a, $width, "0", STR_PAD_LEFT);
@@ -333,13 +336,15 @@ 
 		$count = func_num_args();
 
 		// we need a minimum of 2 values
-		if($count < 2)
-			return false;
+		if($count < 2) {
+					return false;
+		}
 
 		// first get all hex values to an even number
 		array_walk($hex, function(&$val, $i){
-			if(strlen($val) % 2)
-				$val = "0".$val;
+			if(strlen($val) % 2) {
+							$val = "0".$val;
+			}
 		});
 
 		$res = 0;
@@ -347,9 +352,9 @@ 
 		{
 			// if this is the first loop, set the 'result' to the first
 			// hex value
-			if($i == 0)
-				$res = $hex[0];
-			else
+			if($i == 0) {
+							$res = $hex[0];
+			} else
 			{
 				// to make the code easier to follow
 				$h1 = $res;
@@ -361,10 +366,11 @@ 
 
 				// now check that both hex values are the same length,
 				// if not pad them with 0's until they are
-				if($len1 > $len2)
-					$h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
-				else if($len1 < $len2)
-					$h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
+				if($len1 > $len2) {
+									$h2 = str_pad($h2, $len1, "0", STR_PAD_LEFT);
+				} else if($len1 < $len2) {
+									$h1 = str_pad($h1, $len2, "0", STR_PAD_LEFT);
+				}
 
 				// PHP knows how to XOR each byte in a string, so convert the
 				// hex to a string, XOR, and convert back
@@ -406,8 +412,10 @@ 
 		// the same negative number given to it, the work around is
 		// to use sprintf().
 		// Tested with php 5.3.x on Windows XP & Linux 32bit
-		if($ret < 0)
-			$ret = sprintf("%u", $ret) + 0; // convert from string to int
+		if($ret < 0) {
+					$ret = sprintf("%u", $ret) + 0;
+		}
+		// convert from string to int
 
 		return $ret;
 	}
@@ -421,9 +429,10 @@ 
 	 */
 	public static function sInt32($int)
 	{
-		if(PHP_INT_SIZE === 4) // 32 bit
+		if(PHP_INT_SIZE === 4) {
+		    // 32 bit
 			return self::sInt($int);
-		else // PHP_INT_SIZE === 8 // 64 bit
+		} else // PHP_INT_SIZE === 8 // 64 bit
 		{
 			$arr = unpack("l", pack("l", $int));
 			return $arr[1];
@@ -439,9 +448,10 @@ 
 	 */
 	public static function uInt32($int)
 	{
-		if(PHP_INT_SIZE === 4) // 32 bit
+		if(PHP_INT_SIZE === 4) {
+		    // 32 bit
 			return self::uInt($int);
-		else // PHP_INT_SIZE === 8  // 64 bit
+		} else // PHP_INT_SIZE === 8  // 64 bit
 		{
 			$arr = unpack("L", pack("L", $int));
 			return $arr[1];
@@ -484,8 +494,9 @@ 
 	 */
 	public static function rotBitsLeft32($i, $shifts)
 	{
-		if($shifts <= 0)
-			return $i;
+		if($shifts <= 0) {
+					return $i;
+		}
 
 		$shifts &= 0x1f; /* higher rotates would not bring anything */
 
@@ -510,8 +521,9 @@ 
 	 */
 	public static function rotBitsRight32($i, $shifts)
 	{
-		if($shifts <= 0)
-			return $i;
+		if($shifts <= 0) {
+					return $i;
+		}
 
 		$shifts &= 0x1f; /* higher rotates would not bring anything */
 
@@ -548,19 +560,19 @@ 
 
 		if($src == PHP_Crypt::RAND_DEV_RAND)
 		{
-			if(file_exists(PHP_Crypt::RAND_DEV_RAND))
-				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
-			else
-				$err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
-		}
-		else if($src == PHP_Crypt::RAND_DEV_URAND)
+			if(file_exists(PHP_Crypt::RAND_DEV_RAND)) {
+							$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_RAND, false, null, 0, $byte_len);
+			} else {
+							$err_msg = PHP_Crypt::RAND_DEV_RAND." not found";
+			}
+		} else if($src == PHP_Crypt::RAND_DEV_URAND)
 		{
-			if(file_exists(PHP_Crypt::RAND_DEV_URAND))
-				$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
-			else
-				$err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
-		}
-		else if($src == PHP_Crypt::RAND_WIN_COM)
+			if(file_exists(PHP_Crypt::RAND_DEV_URAND)) {
+							$bytes = file_get_contents(PHP_CRYPT::RAND_DEV_URAND, false, null, 0, $byte_len);
+			} else {
+							$err_msg = PHP_Crypt::RAND_DEV_URAND." not found";
+			}
+		} else if($src == PHP_Crypt::RAND_WIN_COM)
 		{
 			if(extension_loaded('com_dotnet'))
 			{
@@ -572,22 +584,23 @@ 
 					// binary data on Windows
 					$com = @new \COM("CAPICOM.Utilities.1");
 					$bytes = $com->GetRandom($byte_len, 0);
-				}
-				catch(Exception $e)
+				} catch(Exception $e)
 				{
 					$err_msg  = "Windows COM exception: ".$e->getMessage();
 				}
 
-				if(!$bytes)
-					$err_msg  = "Windows COM failed to create random string of bytes";
+				if(!$bytes) {
+									$err_msg  = "Windows COM failed to create random string of bytes";
+				}
+			} else {
+							$err_msg = "The COM_DOTNET extension is not loaded";
 			}
-			else
-				$err_msg = "The COM_DOTNET extension is not loaded";
 		}
 
 		// trigger a warning if something went wrong
-		if($err_msg != "")
-			trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
+		if($err_msg != "") {
+					trigger_error("$err_msg. Defaulting to PHP_Crypt::RAND", E_USER_WARNING);
+		}
 
 		// if the random bytes where not created properly or PHP_Crypt::RAND was
 		// passed as the $src param, create the bytes using mt_rand(). It's not
@@ -598,8 +611,9 @@ 
 
 			// md5() hash a random number to get a 16 byte string, keep looping
 			// until we have a string as long or longer than the ciphers block size
-			for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i)
-				$bytes .= md5(mt_rand(), true);
+			for($i = 0; ($i * self::HASH_LEN) < $byte_len; ++$i) {
+							$bytes .= md5(mt_rand(), true);
+			}
 		}
 
 		// because $bytes may have come from mt_rand() or /dev/urandom which are not
@@ -612,8 +626,9 @@ 
 		// some ciphers which have a block size larger than 16 bytes
 		$tmp = "";
 		$loop = ceil(strlen($bytes) / self::HASH_LEN);
-		for($i = 0; $i < $loop; ++$i)
-			$tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
+		for($i = 0; $i < $loop; ++$i) {
+					$tmp .= md5(substr($bytes, ($i * self::HASH_LEN), self::HASH_LEN), true);
+		}
 
 		// grab the number of bytes equal to the requested $byte_len
 		return substr($tmp, 0, $byte_len);

includes/libraries/phpcrypt/Mode.php

Doc Comments +1 added lines, -1 removed lines

@@ -240,7 +240,7 @@
 	 * returns the the padding type only.
 	 *
 	 * @param string $type One of the predefined padding types
-	 * @return void
+	 * @return string
 	 */
 	public function padding($type = "")
 	{

Indentation +269 added lines, -269 removed lines

@@ -36,299 +36,299 @@
  */
 abstract class Mode
 {
-	/**
-	 * @type object $cipher The cipher object used within the mode
-	 */
-	protected $cipher = null;
-
-	/**
-	 * @type string $iv The IV used for the mode, not all Modes
-	 * use an IV so this may be empty
-	 */
-	protected $iv = "";
-
-	/**
-	 * @type string $register For modes that use a register to do
-	 * encryption/decryption. This stores the unencrypted register.
-	 */
-	protected $register = "";
-
-	/**
-	 * @type string $enc_register For modes that use a register to do
-	 * encryption/decryption. This stores the encrypted register
-	 */
-	protected $enc_register = "";
-
-	/**
-	 * @type integer $block_size The byte size of the block to
-	 * encrypt/decrypt for the Mode
-	 */
-	private $block_size = 0;
-
-	/** @type string $mode_name The name of mode currently used */
-	private $mode_name = "";
-
-	/**
-	 * @type string $padding The type of padding to use when required.
-	 * Padding types are defined in phpCrypt class. Defaults to
-	 * PHP_Crypt::PAD_ZERO
-	 */
-	private $padding = PHP_Crypt::PAD_ZERO;
-
-
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher One of the phpCrypt encryption cipher objects
-	 * @param string $mode_name The name of phpCrypt's modes, as defined in the mode
-	 * @return void
-	 */
-	protected function __construct($mode_name, $cipher)
-	{
-		$this->name($mode_name);
-		$this->cipher($cipher);
-		$this->block_size = $this->cipher->blockSize();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	protected function __destruct()
-	{
-
-	}
-
-
-
-	/**********************************************************************
+    /**
+     * @type object $cipher The cipher object used within the mode
+     */
+    protected $cipher = null;
+
+    /**
+     * @type string $iv The IV used for the mode, not all Modes
+     * use an IV so this may be empty
+     */
+    protected $iv = "";
+
+    /**
+     * @type string $register For modes that use a register to do
+     * encryption/decryption. This stores the unencrypted register.
+     */
+    protected $register = "";
+
+    /**
+     * @type string $enc_register For modes that use a register to do
+     * encryption/decryption. This stores the encrypted register
+     */
+    protected $enc_register = "";
+
+    /**
+     * @type integer $block_size The byte size of the block to
+     * encrypt/decrypt for the Mode
+     */
+    private $block_size = 0;
+
+    /** @type string $mode_name The name of mode currently used */
+    private $mode_name = "";
+
+    /**
+     * @type string $padding The type of padding to use when required.
+     * Padding types are defined in phpCrypt class. Defaults to
+     * PHP_Crypt::PAD_ZERO
+     */
+    private $padding = PHP_Crypt::PAD_ZERO;
+
+
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher One of the phpCrypt encryption cipher objects
+     * @param string $mode_name The name of phpCrypt's modes, as defined in the mode
+     * @return void
+     */
+    protected function __construct($mode_name, $cipher)
+    {
+        $this->name($mode_name);
+        $this->cipher($cipher);
+        $this->block_size = $this->cipher->blockSize();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    protected function __destruct()
+    {
+
+    }
+
+
+
+    /**********************************************************************
 	 * ABSTRACT METHODS
 	 *
 	 * The abstract methods required by inheriting classes to implement
 	 **********************************************************************/
 
-	/**
-	 * All modes must have encrypt(), which implements
-	 * the mode using the cipher's encrypiton algorithm
-	 *
-	 * @param string $text A String to encrypt
-	 * @return boolean Always returns true
-	 */
-	abstract public function encrypt(&$text);
+    /**
+     * All modes must have encrypt(), which implements
+     * the mode using the cipher's encrypiton algorithm
+     *
+     * @param string $text A String to encrypt
+     * @return boolean Always returns true
+     */
+    abstract public function encrypt(&$text);
 
 
-	/**
-	 * All modes must have decrypt(), which implements
-	 * the mode using the cipher's encryption algorithm
-	 *
-	 * @param string $text A String to decrypt
-	 * @return boolean Always returns true
-	 */
-	abstract public function decrypt(&$text);
+    /**
+     * All modes must have decrypt(), which implements
+     * the mode using the cipher's encryption algorithm
+     *
+     * @param string $text A String to decrypt
+     * @return boolean Always returns true
+     */
+    abstract public function decrypt(&$text);
 
 
-	/**
-	 * Indicates whether or not a mode requires an IV
-	 *
-	 * @return boolean Always returns true or false
-	 */
-	abstract public function requiresIV();
+    /**
+     * Indicates whether or not a mode requires an IV
+     *
+     * @return boolean Always returns true or false
+     */
+    abstract public function requiresIV();
 
 
 
 
-	/**********************************************************************
+    /**********************************************************************
 	 * PUBLIC METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Create an IV if the Mode used requires an IV.
-	 * The IV should be saved and used for Encryption/Decryption
-	 * of the same blocks of data.
-	 * There are 3 ways to auto generate an IV by setting $src parameter
-	 * PHP_Crypt::RAND - Default, uses mt_rand()
-	 * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
-	 * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
-	 * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
-	 *
-	 * @param string $src Optional, Sets how the IV is generated, must be
-	 *	one of the predefined PHP_Crypt RAND constants. Defaults to
-	 *	PHP_Crypt::RAND if none is given.
-	 * @return string The IV that is being used by the mode
-	 */
-	public function createIV($src = PHP_Crypt::RAND)
-	{
-		// if the mode does not use an IV, lets not waste time
-		if(!$this->requiresIV())
-			return false;
-
-		$iv = Core::randBytes($src, $this->block_size);
-		return $this->IV($iv);
-	}
-
-
-	/**
-	 * Sets or Returns an IV for the mode to use. If the $iv parameter
-	 * is not given, this function only returns the current IV in use.
-	 *
-	 * @param string $iv Optional, An IV to use for the mode and cipher selected
-	 * @return string The current IV being used
-	 */
-	public function IV($iv = null)
-	{
-		if($iv != null)
-		{
-			// check that the iv is the correct length,
-			$len = strlen($iv);
-			if($len != $this->block_size)
-			{
-				$msg = "Incorrect IV size. Supplied length: $len bytes, Required: {$this->block_size} bytes";
-				trigger_error($msg, E_USER_WARNING);
-			}
-
-			$this->clearRegisters();
-			$this->register = $iv;
-			$this->iv = $iv;
-		}
-
-		return $this->iv;
-	}
-
-
-	/**
-	 * Checks to see if the current mode requires an IV and that it is set
-	 * if it is required. Triggers E_USER_WARNING an IV is required and not set
-	 *
-	 * @return void
-	 */
-	public function checkIV()
-	{
-		if($this->requiresIV() && strlen($this->register) == 0)
-		{
-			$msg = strtoupper($this->mode_name)." mode requires an IV or the IV is empty";
-			trigger_error($msg, E_USER_WARNING);
-		}
-	}
-
-
-	/**
-	 * Sets and returns the name of the mode being used
-	 * If $name parameter is set, sets the mode. If
-	 * $name is not set, returns the current mode in use
-	 *
-	 * @param string $name Optional, One of the predefined
-	 * 	phpCrypt mode constant names
-	 * @return string One of the predefined phpCrypt mode
-	 * 	constant mode names
-	 */
-	public function name($name = "")
-	{
-		if($name != "")
-			$this->mode_name = $name;
-
-		return $this->mode_name;
-	}
-
-
-	/**
-	 * Sets or Returns the padding type used with the mode
-	 * If the $type parameter is not given, this function
-	 * returns the the padding type only.
-	 *
-	 * @param string $type One of the predefined padding types
-	 * @return void
-	 */
-	public function padding($type = "")
-	{
-		if($type != "")
-			$this->padding = $type;
-
-		return $this->padding;
-	}
-
-
-	/**
-	 * Returns or Sets the cipher object being used
-	 * If the $cipher parameter is set with a cipher object,
-	 * the cipher current cipher will be set to this cipher.
-	 * If the $cipher parameter is not set, returns the
-	 * current cipher object being used.
-	 *
-	 * @param object $cipher Optional, An object of type Cipher
-	 * @return object An object of type Cipher
-	 */
-	public function cipher($cipher = null)
-	{
-		if(is_object($cipher))
-			$this->cipher = $cipher;
-
-		return $this->cipher;
-	}
-
-
-
-
-	/**********************************************************************
+    /**
+     * Create an IV if the Mode used requires an IV.
+     * The IV should be saved and used for Encryption/Decryption
+     * of the same blocks of data.
+     * There are 3 ways to auto generate an IV by setting $src parameter
+     * PHP_Crypt::RAND - Default, uses mt_rand()
+     * PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
+     * PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
+     * PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
+     *
+     * @param string $src Optional, Sets how the IV is generated, must be
+     *	one of the predefined PHP_Crypt RAND constants. Defaults to
+     *	PHP_Crypt::RAND if none is given.
+     * @return string The IV that is being used by the mode
+     */
+    public function createIV($src = PHP_Crypt::RAND)
+    {
+        // if the mode does not use an IV, lets not waste time
+        if(!$this->requiresIV())
+            return false;
+
+        $iv = Core::randBytes($src, $this->block_size);
+        return $this->IV($iv);
+    }
+
+
+    /**
+     * Sets or Returns an IV for the mode to use. If the $iv parameter
+     * is not given, this function only returns the current IV in use.
+     *
+     * @param string $iv Optional, An IV to use for the mode and cipher selected
+     * @return string The current IV being used
+     */
+    public function IV($iv = null)
+    {
+        if($iv != null)
+        {
+            // check that the iv is the correct length,
+            $len = strlen($iv);
+            if($len != $this->block_size)
+            {
+                $msg = "Incorrect IV size. Supplied length: $len bytes, Required: {$this->block_size} bytes";
+                trigger_error($msg, E_USER_WARNING);
+            }
+
+            $this->clearRegisters();
+            $this->register = $iv;
+            $this->iv = $iv;
+        }
+
+        return $this->iv;
+    }
+
+
+    /**
+     * Checks to see if the current mode requires an IV and that it is set
+     * if it is required. Triggers E_USER_WARNING an IV is required and not set
+     *
+     * @return void
+     */
+    public function checkIV()
+    {
+        if($this->requiresIV() && strlen($this->register) == 0)
+        {
+            $msg = strtoupper($this->mode_name)." mode requires an IV or the IV is empty";
+            trigger_error($msg, E_USER_WARNING);
+        }
+    }
+
+
+    /**
+     * Sets and returns the name of the mode being used
+     * If $name parameter is set, sets the mode. If
+     * $name is not set, returns the current mode in use
+     *
+     * @param string $name Optional, One of the predefined
+     * 	phpCrypt mode constant names
+     * @return string One of the predefined phpCrypt mode
+     * 	constant mode names
+     */
+    public function name($name = "")
+    {
+        if($name != "")
+            $this->mode_name = $name;
+
+        return $this->mode_name;
+    }
+
+
+    /**
+     * Sets or Returns the padding type used with the mode
+     * If the $type parameter is not given, this function
+     * returns the the padding type only.
+     *
+     * @param string $type One of the predefined padding types
+     * @return void
+     */
+    public function padding($type = "")
+    {
+        if($type != "")
+            $this->padding = $type;
+
+        return $this->padding;
+    }
+
+
+    /**
+     * Returns or Sets the cipher object being used
+     * If the $cipher parameter is set with a cipher object,
+     * the cipher current cipher will be set to this cipher.
+     * If the $cipher parameter is not set, returns the
+     * current cipher object being used.
+     *
+     * @param object $cipher Optional, An object of type Cipher
+     * @return object An object of type Cipher
+     */
+    public function cipher($cipher = null)
+    {
+        if(is_object($cipher))
+            $this->cipher = $cipher;
+
+        return $this->cipher;
+    }
+
+
+
+
+    /**********************************************************************
 	 * PROTECTED METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Pads str so that final block is $block_bits in size, if the final block
-	 * is $block_bits, then an additional block is added that is $block_bits in size
-	 * The padding should be set by phpCrypt::setPadding()
-	 *
-	 * @param string $str the string to be padded
-	 * @return boolean Returns true
-	 */
-	protected function pad(&$str)
-	{
-		$len = strlen($str);
-		$bytes = $this->cipher->blockSize(); // returns bytes
-
-		// now determine the next multiple of blockSize(), then find
-		// the difference between that and the length of $str,
-		// this is how many padding bytes we will need
-		$num = ceil($len / $bytes) * $bytes;
-		$num = $num - $len;
-
-		Padding::pad($str, $num, $this->padding);
-		return true;
-	}
-
-
-	/**
-	 * Strip out the padded blocks created from Pad().
-	 * Padding type should be set by phpCrypt::setPadding()
-	 *
-	 * @param string $str the string to strip padding from
-	 * @return boolean Returns True
-	 */
-	protected function strip(&$str)
-	{
-		Padding::strip($str, $this->padding);
-		return true;
-	}
-
-
-	/**********************************************************************
+    /**
+     * Pads str so that final block is $block_bits in size, if the final block
+     * is $block_bits, then an additional block is added that is $block_bits in size
+     * The padding should be set by phpCrypt::setPadding()
+     *
+     * @param string $str the string to be padded
+     * @return boolean Returns true
+     */
+    protected function pad(&$str)
+    {
+        $len = strlen($str);
+        $bytes = $this->cipher->blockSize(); // returns bytes
+
+        // now determine the next multiple of blockSize(), then find
+        // the difference between that and the length of $str,
+        // this is how many padding bytes we will need
+        $num = ceil($len / $bytes) * $bytes;
+        $num = $num - $len;
+
+        Padding::pad($str, $num, $this->padding);
+        return true;
+    }
+
+
+    /**
+     * Strip out the padded blocks created from Pad().
+     * Padding type should be set by phpCrypt::setPadding()
+     *
+     * @param string $str the string to strip padding from
+     * @return boolean Returns True
+     */
+    protected function strip(&$str)
+    {
+        Padding::strip($str, $this->padding);
+        return true;
+    }
+
+
+    /**********************************************************************
 	 * PRIVATE METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Clears the registers used for some modes
-	 *
-	 * @return void
-	 */
-	private function clearRegisters()
-	{
-		$this->register = "";
-		$this->enc_register = "";
-	}
+    /**
+     * Clears the registers used for some modes
+     *
+     * @return void
+     */
+    private function clearRegisters()
+    {
+        $this->register = "";
+        $this->enc_register = "";
+    }
 }
 ?>

Spacing +7 added lines, -7 removed lines

@@ -163,7 +163,7 @@ 
 	public function createIV($src = PHP_Crypt::RAND)
 	{
 		// if the mode does not use an IV, lets not waste time
-		if(!$this->requiresIV())
+		if (!$this->requiresIV())
 			return false;
 
 		$iv = Core::randBytes($src, $this->block_size);
@@ -180,11 +180,11 @@ 
 	 */
 	public function IV($iv = null)
 	{
-		if($iv != null)
+		if ($iv != null)
 		{
 			// check that the iv is the correct length,
 			$len = strlen($iv);
-			if($len != $this->block_size)
+			if ($len != $this->block_size)
 			{
 				$msg = "Incorrect IV size. Supplied length: $len bytes, Required: {$this->block_size} bytes";
 				trigger_error($msg, E_USER_WARNING);
@@ -207,7 +207,7 @@ 
 	 */
 	public function checkIV()
 	{
-		if($this->requiresIV() && strlen($this->register) == 0)
+		if ($this->requiresIV() && strlen($this->register) == 0)
 		{
 			$msg = strtoupper($this->mode_name)." mode requires an IV or the IV is empty";
 			trigger_error($msg, E_USER_WARNING);
@@ -227,7 +227,7 @@ 
 	 */
 	public function name($name = "")
 	{
-		if($name != "")
+		if ($name != "")
 			$this->mode_name = $name;
 
 		return $this->mode_name;
@@ -244,7 +244,7 @@ 
 	 */
 	public function padding($type = "")
 	{
-		if($type != "")
+		if ($type != "")
 			$this->padding = $type;
 
 		return $this->padding;
@@ -263,7 +263,7 @@ 
 	 */
 	public function cipher($cipher = null)
 	{
-		if(is_object($cipher))
+		if (is_object($cipher))
 			$this->cipher = $cipher;
 
 		return $this->cipher;

Braces +12 added lines, -8 removed lines

@@ -163,8 +163,9 @@ 
 	public function createIV($src = PHP_Crypt::RAND)
 	{
 		// if the mode does not use an IV, lets not waste time
-		if(!$this->requiresIV())
-			return false;
+		if(!$this->requiresIV()) {
+					return false;
+		}
 
 		$iv = Core::randBytes($src, $this->block_size);
 		return $this->IV($iv);
@@ -227,8 +228,9 @@ 
 	 */
 	public function name($name = "")
 	{
-		if($name != "")
-			$this->mode_name = $name;
+		if($name != "") {
+					$this->mode_name = $name;
+		}
 
 		return $this->mode_name;
 	}
@@ -244,8 +246,9 @@ 
 	 */
 	public function padding($type = "")
 	{
-		if($type != "")
-			$this->padding = $type;
+		if($type != "") {
+					$this->padding = $type;
+		}
 
 		return $this->padding;
 	}
@@ -263,8 +266,9 @@ 
 	 */
 	public function cipher($cipher = null)
 	{
-		if(is_object($cipher))
-			$this->cipher = $cipher;
+		if(is_object($cipher)) {
+					$this->cipher = $cipher;
+		}
 
 		return $this->cipher;
 	}

includes/libraries/phpcrypt/modes/ECB.php

Doc Comments -1 removed lines

@@ -41,7 +41,6 @@
 	 * Sets the cipher object that will be used for encryption
 	 *
 	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @param int $block_size The size of blocks (in bits) used for encryption
 	 * @return void
 	 */
 	public function __construct($cipher)

Indentation +102 added lines, -102 removed lines

@@ -36,107 +36,107 @@
  */
 class Mode_ECB extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @param int $block_size The size of blocks (in bits) used for encryption
-	 * @return void
-	 */
-	public function __construct($cipher)
-	{
-		parent::__construct(PHP_Crypt::MODE_ECB, $cipher);
-
-		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts an the entire string $plain_text using the cipher passed
-	 * to the constructor in ECB mode
-	 *
-	 * @param string $text The string to be encrypted in ECB mode
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->pad($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// get the current position within $text
-			$pos = $i * $blocksz;
-
-			// grab a block of text
-			$block = substr($text, $pos, $blocksz);
-
-			// encrypt the block
-			$this->cipher->encrypt($block);
-
-			// replace the plain text with the cipher text
-			$text = substr_replace($text, $block, $pos, $blocksz);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypts an the entire string $plain_text using the cipher passed
-	 * to the constructor in ECB mode
-	 *
-	 * @param string $text The string to be decrypted in ECB mode
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$blocksz = $this->cipher->blockSize();
-
-		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// get the current position within $text
-			$pos = $i * $blocksz;
-
-			// get a block of cipher text
-			$block = substr($text, $pos, $blocksz);
-
-			// decrypt the block
-			$this->cipher->decrypt($block);
-
-			// replace the block of cipher text with plain text
-			$text = substr_replace($text, $block, $pos, $blocksz);
-		}
-
-		$this->strip($text);
-		return true;
-	}
-
-
-	/**
-	 * This mode does not require an IV
-	 *
-	 * @return boolean Returns false
-	 */
-	public function requiresIV()
-	{
-		return false;
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @param int $block_size The size of blocks (in bits) used for encryption
+     * @return void
+     */
+    public function __construct($cipher)
+    {
+        parent::__construct(PHP_Crypt::MODE_ECB, $cipher);
+
+        // this works with only block Ciphers
+        if($cipher->type() != Cipher::BLOCK)
+            trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts an the entire string $plain_text using the cipher passed
+     * to the constructor in ECB mode
+     *
+     * @param string $text The string to be encrypted in ECB mode
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->pad($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = strlen($text) / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // get the current position within $text
+            $pos = $i * $blocksz;
+
+            // grab a block of text
+            $block = substr($text, $pos, $blocksz);
+
+            // encrypt the block
+            $this->cipher->encrypt($block);
+
+            // replace the plain text with the cipher text
+            $text = substr_replace($text, $block, $pos, $blocksz);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypts an the entire string $plain_text using the cipher passed
+     * to the constructor in ECB mode
+     *
+     * @param string $text The string to be decrypted in ECB mode
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $blocksz = $this->cipher->blockSize();
+
+        $max = strlen($text) / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // get the current position within $text
+            $pos = $i * $blocksz;
+
+            // get a block of cipher text
+            $block = substr($text, $pos, $blocksz);
+
+            // decrypt the block
+            $this->cipher->decrypt($block);
+
+            // replace the block of cipher text with plain text
+            $text = substr_replace($text, $block, $pos, $blocksz);
+        }
+
+        $this->strip($text);
+        return true;
+    }
+
+
+    /**
+     * This mode does not require an IV
+     *
+     * @return boolean Returns false
+     */
+    public function requiresIV()
+    {
+        return false;
+    }
 }
 ?>

Spacing +3 added lines, -3 removed lines

@@ -49,7 +49,7 @@ 
 		parent::__construct(PHP_Crypt::MODE_ECB, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
+		if ($cipher->type() != Cipher::BLOCK)
 			trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
 	}
 
@@ -78,7 +78,7 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// get the current position within $text
 			$pos = $i * $blocksz;
@@ -109,7 +109,7 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// get the current position within $text
 			$pos = $i * $blocksz;

Braces +3 added lines, -2 removed lines

@@ -49,8 +49,9 @@
 		parent::__construct(PHP_Crypt::MODE_ECB, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
+		if($cipher->type() != Cipher::BLOCK) {
+					trigger_error("ECB mode requires a block cipher", E_USER_WARNING);
+		}
 	}