nilsteampassnet / TeamPass

includes/libraries/phpcrypt/ciphers/3Way.php

Indentation +277 added lines, -277 removed lines

@@ -51,186 +51,186 @@ 
  */
 class Cipher_3Way extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 12; // 96 bits;
-
-	/** @type integer BYTES_KEY The size of the key, in bytes */
-	const BYTES_KEY = 12; // 96 bits;
-
-	/** @type integer ROUNDS The number of rounds to implement */
-	const ROUNDS = 11;
-
-	/** @type array $_rconst_enc The round constants for encryption */
-	private static $_rcon_enc = array();
-
-	/** @type array $_rconst_enc The round constants for decryption */
-	private static $_rcon_dec = array();
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// set the key, make sure the required length is set in bytes
-		parent::__construct(PHP_Crypt::CIPHER_3WAY, $key, self::BYTES_KEY);
-
-		// set the block size
-		$this->blockSize(self::BYTES_BLOCK);
-
-		// initialize the round constants
-		$this->initTables();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data
-	 *
-	 * @param string $data A 96 bit plain data
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$data)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->threeway($data);
-	}
-
-
-	/**
-	 * Decrypt an encrypted string
-	 *
-	 * @param string $data A 96 bit block encrypted data
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$data)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->threeway($data);
-	}
-
-
-	/**
-	 * The same alorigthm is used for both Encryption, and Decryption
-	 *
-	 * @param string $data A 96 bit block of data
-	 * @return boolean Returns true
-	 */
-	private function threeway(&$data)
-	{
-		// first split $data into three 32 bit parts
-		$data = str_split($data, 4);
-		$data = array_map("parent::str2Dec", $data);
-
-		// split the key into three 32 bit parts
-		$key = str_split($this->key(), 4);
-		$key = array_map("parent::str2Dec", $key);
-
-		// determine which round constant to use
-		if($this->operation() == parent::ENCRYPT)
-			$rcon = self::$_rcon_enc;
-		else
-			$rcon = self::$_rcon_dec;
-
-		if($this->operation() == parent::DECRYPT)
-		{
-			$this->theta($key);
-			$this->invertBits($key);
-			$this->invertBits($data);
-		}
-
-		// 3Way uses 11 rounds
-		for($i = 0; $i < self::ROUNDS; ++$i)
-		{
-			$data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[$i] << 16));
-			$data[1] = parent::uInt32($data[1] ^ $key[1]);
-			$data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[$i]);
-
-			$this->rho($data);
-		}
-
-		$data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[self::ROUNDS] << 16));
-		$data[1] = parent::uInt32($data[1] ^ $key[1]);
-		$data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[self::ROUNDS]);
-
-		$this->theta($data);
-
-		if($this->operation() == parent::DECRYPT)
-			$this->invertBits($data);
-
-		// assemble the three 32 bit parts back to a 96 bit string
-		$data = parent::dec2Str($data[0], 4).parent::dec2Str($data[1], 4).
-				parent::dec2Str($data[2], 4);
-
-		return true;
-	}
-
-
-	/**
-	 * 3-Way's Theta function
-	 * This was translated from mcrypt's 3-Way theta() function
-	 *
-	 * @param array $d A 3 element array of 32 bit integers
-	 * @return void
-	 */
-	private function theta(&$d)
-	{
-		$tmp = array();
-
-		$tmp[0] = parent::uInt32(
-					$d[0] ^ ($d[0] >> 16) ^ ($d[1] << 16) ^ ($d[1] >> 16) ^ ($d[2] << 16) ^
-					($d[1] >> 24) ^ ($d[2] << 8) ^ ($d[2] >> 8) ^ ($d[0] << 24) ^ ($d[2] >> 16) ^
-					($d[0] << 16) ^ ($d[2] >> 24) ^ ($d[0] << 8)
-				);
-
-		$tmp[1] = parent::uInt32(
-					$d[1] ^ ($d[1] >> 16) ^ ($d[2] << 16) ^ ($d[2] >> 16) ^ ($d[0] << 16) ^
-					($d[2] >> 24) ^ ($d[0] << 8) ^ ($d[0] >> 8) ^ ($d[1] << 24) ^ ($d[0] >> 16) ^
-					($d[1] << 16) ^ ($d[0] >> 24) ^ ($d[1] << 8)
-				);
-
-		$tmp[2] = parent::uInt32(
-					$d[2] ^ ($d[2] >> 16) ^ ($d[0] << 16) ^ ($d[0] >> 16) ^ ($d[1] << 16) ^
-					($d[0] >> 24) ^ ($d[1] << 8) ^ ($d[1] >> 8) ^ ($d[2] << 24) ^ ($d[1] >> 16) ^
-					($d[2] << 16) ^ ($d[1] >> 24) ^ ($d[2] << 8)
-				);
-
-		$d = $tmp;
-	}
-
-
-	/**
-	 * 3-Ways gamma() function
-	 * NOTE: After extensive testing against mcrypt's 3way, it appears
-	 * mcrypt's 3way gamma() function does not modify the array passed into
-	 * it. During testing mcrypt's 3way gamma() function returned the exact
-	 * same values sent into it. I'm confused as to why this is, and
-	 * can't find enough information about 3-Way to know if this is correct
-	 * though I suspect it's not. For compatibility, I am going to make
-	 * phpCrypt's 3way gamma() function leave the values unmodified. I will change
-	 * this at a later date if I find this is incorrect and mcrypt has a bug
-	 *
-	 * This was translated from mcrypt's 3-Way gamma() function
-	 *
-	 * @param array $d A 3 element array of 32 bit integers
-	 * @return void
-	 */
-	private function gamma(&$d)
-	{
-		/*
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 12; // 96 bits;
+
+    /** @type integer BYTES_KEY The size of the key, in bytes */
+    const BYTES_KEY = 12; // 96 bits;
+
+    /** @type integer ROUNDS The number of rounds to implement */
+    const ROUNDS = 11;
+
+    /** @type array $_rconst_enc The round constants for encryption */
+    private static $_rcon_enc = array();
+
+    /** @type array $_rconst_enc The round constants for decryption */
+    private static $_rcon_dec = array();
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // set the key, make sure the required length is set in bytes
+        parent::__construct(PHP_Crypt::CIPHER_3WAY, $key, self::BYTES_KEY);
+
+        // set the block size
+        $this->blockSize(self::BYTES_BLOCK);
+
+        // initialize the round constants
+        $this->initTables();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data
+     *
+     * @param string $data A 96 bit plain data
+     * @return boolean Returns true
+     */
+    public function encrypt(&$data)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->threeway($data);
+    }
+
+
+    /**
+     * Decrypt an encrypted string
+     *
+     * @param string $data A 96 bit block encrypted data
+     * @return boolean Returns true
+     */
+    public function decrypt(&$data)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->threeway($data);
+    }
+
+
+    /**
+     * The same alorigthm is used for both Encryption, and Decryption
+     *
+     * @param string $data A 96 bit block of data
+     * @return boolean Returns true
+     */
+    private function threeway(&$data)
+    {
+        // first split $data into three 32 bit parts
+        $data = str_split($data, 4);
+        $data = array_map("parent::str2Dec", $data);
+
+        // split the key into three 32 bit parts
+        $key = str_split($this->key(), 4);
+        $key = array_map("parent::str2Dec", $key);
+
+        // determine which round constant to use
+        if($this->operation() == parent::ENCRYPT)
+            $rcon = self::$_rcon_enc;
+        else
+            $rcon = self::$_rcon_dec;
+
+        if($this->operation() == parent::DECRYPT)
+        {
+            $this->theta($key);
+            $this->invertBits($key);
+            $this->invertBits($data);
+        }
+
+        // 3Way uses 11 rounds
+        for($i = 0; $i < self::ROUNDS; ++$i)
+        {
+            $data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[$i] << 16));
+            $data[1] = parent::uInt32($data[1] ^ $key[1]);
+            $data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[$i]);
+
+            $this->rho($data);
+        }
+
+        $data[0] = parent::uInt32($data[0] ^ $key[0] ^ ($rcon[self::ROUNDS] << 16));
+        $data[1] = parent::uInt32($data[1] ^ $key[1]);
+        $data[2] = parent::uInt32($data[2] ^ $key[2] ^ $rcon[self::ROUNDS]);
+
+        $this->theta($data);
+
+        if($this->operation() == parent::DECRYPT)
+            $this->invertBits($data);
+
+        // assemble the three 32 bit parts back to a 96 bit string
+        $data = parent::dec2Str($data[0], 4).parent::dec2Str($data[1], 4).
+                parent::dec2Str($data[2], 4);
+
+        return true;
+    }
+
+
+    /**
+     * 3-Way's Theta function
+     * This was translated from mcrypt's 3-Way theta() function
+     *
+     * @param array $d A 3 element array of 32 bit integers
+     * @return void
+     */
+    private function theta(&$d)
+    {
+        $tmp = array();
+
+        $tmp[0] = parent::uInt32(
+                    $d[0] ^ ($d[0] >> 16) ^ ($d[1] << 16) ^ ($d[1] >> 16) ^ ($d[2] << 16) ^
+                    ($d[1] >> 24) ^ ($d[2] << 8) ^ ($d[2] >> 8) ^ ($d[0] << 24) ^ ($d[2] >> 16) ^
+                    ($d[0] << 16) ^ ($d[2] >> 24) ^ ($d[0] << 8)
+                );
+
+        $tmp[1] = parent::uInt32(
+                    $d[1] ^ ($d[1] >> 16) ^ ($d[2] << 16) ^ ($d[2] >> 16) ^ ($d[0] << 16) ^
+                    ($d[2] >> 24) ^ ($d[0] << 8) ^ ($d[0] >> 8) ^ ($d[1] << 24) ^ ($d[0] >> 16) ^
+                    ($d[1] << 16) ^ ($d[0] >> 24) ^ ($d[1] << 8)
+                );
+
+        $tmp[2] = parent::uInt32(
+                    $d[2] ^ ($d[2] >> 16) ^ ($d[0] << 16) ^ ($d[0] >> 16) ^ ($d[1] << 16) ^
+                    ($d[0] >> 24) ^ ($d[1] << 8) ^ ($d[1] >> 8) ^ ($d[2] << 24) ^ ($d[1] >> 16) ^
+                    ($d[2] << 16) ^ ($d[1] >> 24) ^ ($d[2] << 8)
+                );
+
+        $d = $tmp;
+    }
+
+
+    /**
+     * 3-Ways gamma() function
+     * NOTE: After extensive testing against mcrypt's 3way, it appears
+     * mcrypt's 3way gamma() function does not modify the array passed into
+     * it. During testing mcrypt's 3way gamma() function returned the exact
+     * same values sent into it. I'm confused as to why this is, and
+     * can't find enough information about 3-Way to know if this is correct
+     * though I suspect it's not. For compatibility, I am going to make
+     * phpCrypt's 3way gamma() function leave the values unmodified. I will change
+     * this at a later date if I find this is incorrect and mcrypt has a bug
+     *
+     * This was translated from mcrypt's 3-Way gamma() function
+     *
+     * @param array $d A 3 element array of 32 bit integers
+     * @return void
+     */
+    private function gamma(&$d)
+    {
+        /*
 		$tmp = array();
 
 		$tmp[0] = parent::uInt32($d[0] ^ ($d[1] | (~$d[2])));
@@ -239,102 +239,102 @@ 
 
 		$d = $tmp;
 		*/
-	}
-
-
-	/**
-	 * Applies several of 3Way's functions used for encryption and decryption
-	 * NOTE: Please read the comments in the $this->gamma() function. This
-	 * function calls the $this->gamma() function which does not do anything.
-	 *
-	 * @param array $d A 3 element 32 bit integer array
-	 * @return void
-	 */
-	private function rho(&$d)
-	{
-		$this->theta($d);
-		$this->pi1($d);
-		$this->gamma($d);
-		$this->pi2($d);
-	}
-
-
-	/**
-	 * 3Way's PI_1 function
-	 * This was taken from mcrypt's 3-way pi_1() function
-	 *
-	 * @param array $d A 3 element 32 bit integer array
-	 * @return void
-	 */
-	private function pi1(&$d)
-	{
-		$d[0] = parent::uInt32(($d[0] >> 10) ^ ($d[0] << 22));
-		$d[2] = parent::uInt32(($d[2] << 1) ^ ($d[2] >> 31));
-	}
-
-
-	/**
-	 * 3Way's PI_2 function
-	 * This was taken from mcrypt's 3-way pi_2() function
-	 *
-	 * @param array $d A 3 element 32 bit integer array
-	 * @return void
-	 */
-	private function pi2(&$d)
-	{
-		$d[0] = parent::uInt32(($d[0] << 1) ^ ($d[0] >> 31));
-		$d[2] = parent::uInt32(($d[2] >> 10) ^ ($d[2] << 22));
-	}
-
-
-	/**
-	 * Reverse the bits of each element of array $d, and
-	 * reverses the order of array $d, used only during
-	 * decryption
-	 *
-	 * @param array $d A 3 element array of a 32 bit integers
-	 * @return void
-	 */
-	private function invertBits(&$d)
-	{
-		$d = array_map("parent::dec2Bin", $d);
-		$d = array_map("strrev", $d);
-		$d = array_map("parent::bin2Dec", $d);
-		$d = array_reverse($d);
-	}
-
-
-	/**
-	 * Initialize the tables used in 3Way Encryption.
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		// round constants for encryption
-		self::$_rcon_enc = array(
-			0x0B0B, 0x1616, 0x2C2C, 0x5858,
-			0xB0B0, 0x7171, 0xE2E2, 0xD5D5,
-			0xBBBB, 0x6767, 0xCECE, 0x8D8D
-		);
-
-		// round constants for decryption
-		self::$_rcon_dec = array(
-			0xB1B1, 0x7373, 0xE6E6, 0xDDDD,
-			0xABAB, 0x4747, 0x8E8E, 0x0D0D,
-			0x1A1A, 0x3434, 0x6868, 0xD0D0
-		);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+    }
+
+
+    /**
+     * Applies several of 3Way's functions used for encryption and decryption
+     * NOTE: Please read the comments in the $this->gamma() function. This
+     * function calls the $this->gamma() function which does not do anything.
+     *
+     * @param array $d A 3 element 32 bit integer array
+     * @return void
+     */
+    private function rho(&$d)
+    {
+        $this->theta($d);
+        $this->pi1($d);
+        $this->gamma($d);
+        $this->pi2($d);
+    }
+
+
+    /**
+     * 3Way's PI_1 function
+     * This was taken from mcrypt's 3-way pi_1() function
+     *
+     * @param array $d A 3 element 32 bit integer array
+     * @return void
+     */
+    private function pi1(&$d)
+    {
+        $d[0] = parent::uInt32(($d[0] >> 10) ^ ($d[0] << 22));
+        $d[2] = parent::uInt32(($d[2] << 1) ^ ($d[2] >> 31));
+    }
+
+
+    /**
+     * 3Way's PI_2 function
+     * This was taken from mcrypt's 3-way pi_2() function
+     *
+     * @param array $d A 3 element 32 bit integer array
+     * @return void
+     */
+    private function pi2(&$d)
+    {
+        $d[0] = parent::uInt32(($d[0] << 1) ^ ($d[0] >> 31));
+        $d[2] = parent::uInt32(($d[2] >> 10) ^ ($d[2] << 22));
+    }
+
+
+    /**
+     * Reverse the bits of each element of array $d, and
+     * reverses the order of array $d, used only during
+     * decryption
+     *
+     * @param array $d A 3 element array of a 32 bit integers
+     * @return void
+     */
+    private function invertBits(&$d)
+    {
+        $d = array_map("parent::dec2Bin", $d);
+        $d = array_map("strrev", $d);
+        $d = array_map("parent::bin2Dec", $d);
+        $d = array_reverse($d);
+    }
+
+
+    /**
+     * Initialize the tables used in 3Way Encryption.
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        // round constants for encryption
+        self::$_rcon_enc = array(
+            0x0B0B, 0x1616, 0x2C2C, 0x5858,
+            0xB0B0, 0x7171, 0xE2E2, 0xD5D5,
+            0xBBBB, 0x6767, 0xCECE, 0x8D8D
+        );
+
+        // round constants for decryption
+        self::$_rcon_dec = array(
+            0xB1B1, 0x7373, 0xE6E6, 0xDDDD,
+            0xABAB, 0x4747, 0x8E8E, 0x0D0D,
+            0x1A1A, 0x3434, 0x6868, 0xD0D0
+        );
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/Blowfish.php

Indentation +550 added lines, -550 removed lines

@@ -40,563 +40,563 @@
  */
 class Cipher_Blowfish 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;
 
-	// a variable length key, between 8 - 448 bits
-	//const BYTES_KEY = 0;
+    // a variable length key, between 8 - 448 bits
+    //const BYTES_KEY = 0;
 
-	/** @type array $_sbox1 S-Box 1 */
-	private static $_sbox1 = array();
+    /** @type array $_sbox1 S-Box 1 */
+    private static $_sbox1 = array();
 
-	/** @type string $_sbox2 S-Box 2 */
-	private static $_sbox2 = array();
+    /** @type string $_sbox2 S-Box 2 */
+    private static $_sbox2 = array();
 
-	/** @type string $_sbox3 S-Box 3 */
-	private static $_sbox3 = array();
+    /** @type string $_sbox3 S-Box 3 */
+    private static $_sbox3 = array();
 
-	/** @type string $_sbox4 S-Box 4 */
-	private static $_sbox4 = array();
+    /** @type string $_sbox4 S-Box 4 */
+    private static $_sbox4 = array();
 
-	/** @type array $_p The P-Array, 18 elements long */
-	private static $_p = array();
+    /** @type array $_p The P-Array, 18 elements long */
+    private static $_p = array();
 
-	/** @type integer $key_pos Used for keyChunk(), to determine the current
+    /** @type integer $key_pos Used for keyChunk(), to determine the current
 	position in the key */
-	private $key_pos = 0;
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// the max length of the key is 448 bits (56 bytes)
-		$keylen = strlen($key);
-		if($keylen > 56)
-		{
-			$key = substr($key, 0, 56);
-			$keylen = 56;
-		}
-		else if($keylen < 1)
-		{
-			$msg  = "No key given. The key must be between 1 - 56 bytes.";
-			trigger_error($msg, E_USER_WARNING);
-		}
-
-		// set the key, make sure the required length is set in bits
-		parent::__construct(PHP_Crypt::CIPHER_BLOWFISH, $key, $keylen);
-
-		// set the block size
-		$this->blockSize(self::BYTES_BLOCK);
-
-		$this->initTables();
-		$this->subKeys();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data
-	 *
-	 * @param string $data A 64 bit (8 byte) plain text string
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$data)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->blowfish($data);
-	}
-
-
-	/**
-	 * Decrypt an encrypted string
-	 *
-	 * @param string $data A 64 bit block of Blowfish encrypted data
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$data)
-	{
-		$this->operation(parent::DECRYPT);
-		return $this->blowfish($data);
-	}
-
-
-	/**
-	 * The same alorigthm is used for both Encryption, and Decryption
-	 *
-	 * @param string $data A 64 bit block of data
-	 * @return boolean Returns true
-	 */
-	private function blowfish(&$data)
-	{
-		// divide the data into into two 32 bit halves
-		$xl = parent::str2Dec(substr($data, 0, 4));
-		$xr = parent::str2Dec(substr($data, 4, 4));
-
-		for($i = 0; $i < 16; ++$i)
-		{
-			if($this->operation() == parent::ENCRYPT)
-				$xl ^= self::$_p[$i];
-			else
-				$xl ^= self::$_p[17-$i];
-
-			// perform F() on the left half, and XOR with the right half
-			$xr = $this->F($xl) ^ $xr;
-
-			// swap $xl and $xr
-			$tmp = $xr;
-			$xr = $xl;
-			$xl = $tmp;
-		}
-
-		// swap $xl and $xr after the 16th round to undo the last swap
-		$tmp = $xl;
-		$xl  = $xr;
-		$xr  = $tmp;
-
-		// XOR the final two elements of $_p
-		if($this->operation() == parent::ENCRYPT)
-		{
-			$xr ^= self::$_p[16];
-			$xl  = $xl ^ self::$_p[17];
-		}
-		else // parent::DECRYPT
-		{
-			$xr ^= self::$_p[1];
-			$xl ^= self::$_p[0];
-		}
-
-		// recombine the two halves, force them to be 4 bytes each
-		$data = parent::dec2Str($xl, 4).parent::dec2Str($xr, 4);
-
-		return true;
-	}
-
-
-	/**
-	 * Blowfish's F() function
-	 *
-	 * @param string $i A 32 bit integer
-	 */
-	private function F($i)
-	{
-		// split the 32 bits into four 8 bit parts
-		$x[0] = $i & 0xff; // first byte
-		$x[1] = ($i >> 8)  & 0xff; // second byte
-		$x[2] = ($i >> 16) & 0xff; // third byte
-		$x[3] = ($i >> 24) & 0xff; // fourth byte
-
-		// perform F(), make sure all values returned are
-		// unsigned 32 bit
-		$f  = parent::uInt32(self::$_sbox1[$x[3]] + self::$_sbox2[$x[2]]);
-		$f  = parent::uInt32($f ^ self::$_sbox3[$x[1]]);
-		$f  = parent::uInt32($f + self::$_sbox4[$x[0]]);
-
-		return $f;
-	}
-
-
-	/**
-	 * Generates the subkeys used in Blowfish
-	 *
-	 * @return void
-	 */
-	private function subKeys()
-	{
-		// now xor each element of $_p with 32 bits from the key
-		for($i = 0; $i < 18; ++$i)
-		{
-			$c = $this->keyChunk(4);
-			self::$_p[$i] ^= parent::str2Dec($c);
-		}
-
-		// start with an 8 byte null string
-		$zero = "\0\0\0\0\0\0\0\0";
-
-		// now we loop, each loop replacing elements of $_p, or an $_sbox with the
-		// repeatedly encrypted zero string
-		for($i = 0; $i < 1042; $i += 2)
-		{
-			// encrypt the 64 bit null string
-			$this->encrypt($zero);
-
-			// split the encrypted null string into two 32 bit parts
-			$z0 = parent::str2Dec(substr($zero, 0, 4));
-			$z1 = parent::str2Dec(substr($zero, 4, 4));
-
-			// now fill the $_p, $_sbox1, $_sbox2, $_sbox3, $_sbox4
-			// with 4 bytes from the repeatedly encrypted 8 byte null string
-			if($i < 18)
-			{
-				self::$_p[$i] = $z0;
-				self::$_p[$i + 1] = $z1;
-			}
-			else if($i >= 18 && $i < 274)
-			{
-				self::$_sbox1[$i - 18] = $z0;
-				self::$_sbox1[$i - 18 + 1] = $z1;
-			}
-			else if($i >= 274 && $i < 530)
-			{
-				self::$_sbox2[$i - 274] = $z0;
-				self::$_sbox2[$i - 274 + 1] = $z1;
-			}
-			else if($i >= 530 && $i < 786)
-			{
-				self::$_sbox3[$i - 530] = $z0;
-				self::$_sbox3[$i - 530 + 1] = $z1;
-			}
-			else if($i >= 786 && $i < 1042)
-			{
-				self::$_sbox4[$i -786] = $z0;
-				self::$_sbox4[$i - 786 + 1] = $z1;
-			}
-		}
-	}
-
-
-	/**
-	 * Returns a substring of $this->key. The size of the substring is set in the
-	 * parameter $size. Each call to this function returns a substring starting
-	 * in the position where the last substring ended. Effectively it rotates
-	 * through the key, when it reaches the end, it starts over at the
-	 * beginning of the key and continues on. You can reset the current position
-	 * by setting the parameter $reset=true, which will start the key back at the
-	 * first byte of the $this->key string.
-	 *
-	 * @param integer $size The size of the substring to return, in bytes
-	 * @param bool $reset If set to true, sets the position back to 0, the first
-	 *	byte of the key string
-	 * @return string The next substring of the key
-	 */
-	private function keyChunk($size = 1, $reset = false)
-	{
-		if($reset || $this->key_pos >= $this->keySize())
-			$this->key_pos = 0;
-
-		$bytes = substr($this->key(), $this->key_pos, $size);
-		$len = strlen($bytes);
-		if($len < $size)
-		{
-			$bytes .= substr($this->key(), 0, $size - $len);
-			$this->key_pos = $size - $len;
-		}
-		else
-			$this->key_pos += $size;
-
-		return $bytes;
-	}
-
-
-	/**
-	 * Initialize the tables used in Blowfish Encryption. These
-	 * are calculated from the value of PI. We grabbed
-	 * these from the mcrypt blowfish source, which already had
-	 * these values calculated
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		self::$_sbox1 = array(
-			0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
-			0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
-			0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
-			0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
-			0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
-			0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
-			0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
-			0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
-			0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
-			0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
-			0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
-			0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
-			0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
-			0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
-			0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-			0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
-			0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
-			0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
-			0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
-			0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
-			0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
-			0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
-			0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
-			0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
-			0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
-			0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
-			0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
-			0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
-			0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
-			0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-			0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
-			0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
-			0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
-			0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
-			0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
-			0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
-			0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
-			0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
-			0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
-			0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
-			0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
-			0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
-			0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
-			0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
-			0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-			0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
-			0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
-			0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
-			0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
-			0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
-			0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
-			0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
-			0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
-			0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
-			0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
-			0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
-			0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
-			0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
-			0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
-			0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-			0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
-			0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
-			0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
-			0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
-		);
-
-		self::$_sbox2 = array(
-			0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
-			0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
-			0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
-			0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
-			0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
-			0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-			0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
-			0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
-			0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
-			0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
-			0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
-			0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
-			0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
-			0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
-			0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
-			0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
-			0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
-			0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
-			0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
-			0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
-			0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-			0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
-			0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
-			0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
-			0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
-			0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
-			0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
-			0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
-			0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
-			0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
-			0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
-			0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
-			0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
-			0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
-			0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
-			0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-			0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
-			0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
-			0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
-			0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
-			0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
-			0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
-			0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
-			0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
-			0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
-			0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
-			0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
-			0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
-			0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
-			0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
-			0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-			0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
-			0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
-			0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
-			0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
-			0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
-			0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
-			0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
-			0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
-			0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
-			0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
-			0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
-			0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
-			0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
-		);
-
-		self::$_sbox3 = array(
-			0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
-			0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
-			0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
-			0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
-			0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
-			0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
-			0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
-			0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
-			0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
-			0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
-			0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
-			0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-			0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
-			0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
-			0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
-			0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
-			0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
-			0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
-			0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
-			0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
-			0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
-			0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
-			0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
-			0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
-			0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
-			0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
-			0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-			0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
-			0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
-			0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
-			0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
-			0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
-			0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
-			0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
-			0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
-			0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
-			0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
-			0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
-			0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
-			0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
-			0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
-			0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-			0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
-			0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
-			0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
-			0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
-			0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
-			0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
-			0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
-			0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
-			0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
-			0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
-			0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
-			0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
-			0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
-			0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
-			0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-			0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
-			0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
-			0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
-			0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
-			0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
-			0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
-			0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
-		);
-
-		self::$_sbox4 = array(
-			0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
-			0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
-			0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-			0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
-			0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
-			0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
-			0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
-			0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
-			0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
-			0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
-			0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
-			0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
-			0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
-			0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
-			0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
-			0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
-			0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
-			0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-			0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
-			0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
-			0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
-			0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
-			0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
-			0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
-			0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
-			0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
-			0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
-			0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
-			0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
-			0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
-			0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
-			0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
-			0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-			0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
-			0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
-			0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
-			0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
-			0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
-			0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
-			0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
-			0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
-			0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
-			0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
-			0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
-			0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
-			0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
-			0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
-			0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-			0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
-			0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
-			0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
-			0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
-			0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
-			0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
-			0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
-			0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
-			0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
-			0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
-			0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
-			0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
-			0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
-			0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
-			0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-			0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
-		);
-
-		self::$_p = array(
-			0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
-			0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
-			0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
-			0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
-			0x9216d5d9, 0x8979fb1b
-		);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+    private $key_pos = 0;
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // the max length of the key is 448 bits (56 bytes)
+        $keylen = strlen($key);
+        if($keylen > 56)
+        {
+            $key = substr($key, 0, 56);
+            $keylen = 56;
+        }
+        else if($keylen < 1)
+        {
+            $msg  = "No key given. The key must be between 1 - 56 bytes.";
+            trigger_error($msg, E_USER_WARNING);
+        }
+
+        // set the key, make sure the required length is set in bits
+        parent::__construct(PHP_Crypt::CIPHER_BLOWFISH, $key, $keylen);
+
+        // set the block size
+        $this->blockSize(self::BYTES_BLOCK);
+
+        $this->initTables();
+        $this->subKeys();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data
+     *
+     * @param string $data A 64 bit (8 byte) plain text string
+     * @return boolean Returns true
+     */
+    public function encrypt(&$data)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->blowfish($data);
+    }
+
+
+    /**
+     * Decrypt an encrypted string
+     *
+     * @param string $data A 64 bit block of Blowfish encrypted data
+     * @return boolean Returns true
+     */
+    public function decrypt(&$data)
+    {
+        $this->operation(parent::DECRYPT);
+        return $this->blowfish($data);
+    }
+
+
+    /**
+     * The same alorigthm is used for both Encryption, and Decryption
+     *
+     * @param string $data A 64 bit block of data
+     * @return boolean Returns true
+     */
+    private function blowfish(&$data)
+    {
+        // divide the data into into two 32 bit halves
+        $xl = parent::str2Dec(substr($data, 0, 4));
+        $xr = parent::str2Dec(substr($data, 4, 4));
+
+        for($i = 0; $i < 16; ++$i)
+        {
+            if($this->operation() == parent::ENCRYPT)
+                $xl ^= self::$_p[$i];
+            else
+                $xl ^= self::$_p[17-$i];
+
+            // perform F() on the left half, and XOR with the right half
+            $xr = $this->F($xl) ^ $xr;
+
+            // swap $xl and $xr
+            $tmp = $xr;
+            $xr = $xl;
+            $xl = $tmp;
+        }
+
+        // swap $xl and $xr after the 16th round to undo the last swap
+        $tmp = $xl;
+        $xl  = $xr;
+        $xr  = $tmp;
+
+        // XOR the final two elements of $_p
+        if($this->operation() == parent::ENCRYPT)
+        {
+            $xr ^= self::$_p[16];
+            $xl  = $xl ^ self::$_p[17];
+        }
+        else // parent::DECRYPT
+        {
+            $xr ^= self::$_p[1];
+            $xl ^= self::$_p[0];
+        }
+
+        // recombine the two halves, force them to be 4 bytes each
+        $data = parent::dec2Str($xl, 4).parent::dec2Str($xr, 4);
+
+        return true;
+    }
+
+
+    /**
+     * Blowfish's F() function
+     *
+     * @param string $i A 32 bit integer
+     */
+    private function F($i)
+    {
+        // split the 32 bits into four 8 bit parts
+        $x[0] = $i & 0xff; // first byte
+        $x[1] = ($i >> 8)  & 0xff; // second byte
+        $x[2] = ($i >> 16) & 0xff; // third byte
+        $x[3] = ($i >> 24) & 0xff; // fourth byte
+
+        // perform F(), make sure all values returned are
+        // unsigned 32 bit
+        $f  = parent::uInt32(self::$_sbox1[$x[3]] + self::$_sbox2[$x[2]]);
+        $f  = parent::uInt32($f ^ self::$_sbox3[$x[1]]);
+        $f  = parent::uInt32($f + self::$_sbox4[$x[0]]);
+
+        return $f;
+    }
+
+
+    /**
+     * Generates the subkeys used in Blowfish
+     *
+     * @return void
+     */
+    private function subKeys()
+    {
+        // now xor each element of $_p with 32 bits from the key
+        for($i = 0; $i < 18; ++$i)
+        {
+            $c = $this->keyChunk(4);
+            self::$_p[$i] ^= parent::str2Dec($c);
+        }
+
+        // start with an 8 byte null string
+        $zero = "\0\0\0\0\0\0\0\0";
+
+        // now we loop, each loop replacing elements of $_p, or an $_sbox with the
+        // repeatedly encrypted zero string
+        for($i = 0; $i < 1042; $i += 2)
+        {
+            // encrypt the 64 bit null string
+            $this->encrypt($zero);
+
+            // split the encrypted null string into two 32 bit parts
+            $z0 = parent::str2Dec(substr($zero, 0, 4));
+            $z1 = parent::str2Dec(substr($zero, 4, 4));
+
+            // now fill the $_p, $_sbox1, $_sbox2, $_sbox3, $_sbox4
+            // with 4 bytes from the repeatedly encrypted 8 byte null string
+            if($i < 18)
+            {
+                self::$_p[$i] = $z0;
+                self::$_p[$i + 1] = $z1;
+            }
+            else if($i >= 18 && $i < 274)
+            {
+                self::$_sbox1[$i - 18] = $z0;
+                self::$_sbox1[$i - 18 + 1] = $z1;
+            }
+            else if($i >= 274 && $i < 530)
+            {
+                self::$_sbox2[$i - 274] = $z0;
+                self::$_sbox2[$i - 274 + 1] = $z1;
+            }
+            else if($i >= 530 && $i < 786)
+            {
+                self::$_sbox3[$i - 530] = $z0;
+                self::$_sbox3[$i - 530 + 1] = $z1;
+            }
+            else if($i >= 786 && $i < 1042)
+            {
+                self::$_sbox4[$i -786] = $z0;
+                self::$_sbox4[$i - 786 + 1] = $z1;
+            }
+        }
+    }
+
+
+    /**
+     * Returns a substring of $this->key. The size of the substring is set in the
+     * parameter $size. Each call to this function returns a substring starting
+     * in the position where the last substring ended. Effectively it rotates
+     * through the key, when it reaches the end, it starts over at the
+     * beginning of the key and continues on. You can reset the current position
+     * by setting the parameter $reset=true, which will start the key back at the
+     * first byte of the $this->key string.
+     *
+     * @param integer $size The size of the substring to return, in bytes
+     * @param bool $reset If set to true, sets the position back to 0, the first
+     *	byte of the key string
+     * @return string The next substring of the key
+     */
+    private function keyChunk($size = 1, $reset = false)
+    {
+        if($reset || $this->key_pos >= $this->keySize())
+            $this->key_pos = 0;
+
+        $bytes = substr($this->key(), $this->key_pos, $size);
+        $len = strlen($bytes);
+        if($len < $size)
+        {
+            $bytes .= substr($this->key(), 0, $size - $len);
+            $this->key_pos = $size - $len;
+        }
+        else
+            $this->key_pos += $size;
+
+        return $bytes;
+    }
+
+
+    /**
+     * Initialize the tables used in Blowfish Encryption. These
+     * are calculated from the value of PI. We grabbed
+     * these from the mcrypt blowfish source, which already had
+     * these values calculated
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        self::$_sbox1 = array(
+            0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+            0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+            0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+            0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+            0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+            0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+            0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+            0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+            0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+            0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+            0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+            0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+            0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+            0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+            0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+            0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+            0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+            0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+            0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+            0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+            0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+            0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+            0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+            0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+            0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+            0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+            0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+            0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+            0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+            0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+            0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+            0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+            0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+            0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+            0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+            0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+            0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+            0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+            0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+            0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+            0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+            0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+            0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+            0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+            0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+            0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+            0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+            0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+            0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+            0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+            0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+            0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+            0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+            0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+            0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+            0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+            0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+            0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+            0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+            0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+            0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+            0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+            0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+            0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
+        );
+
+        self::$_sbox2 = array(
+            0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+            0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+            0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+            0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+            0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+            0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+            0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+            0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+            0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+            0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+            0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+            0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+            0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+            0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+            0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+            0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+            0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+            0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+            0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+            0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+            0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+            0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+            0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+            0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+            0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+            0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+            0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+            0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+            0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+            0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+            0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+            0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+            0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+            0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+            0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+            0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+            0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+            0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+            0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+            0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+            0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+            0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+            0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+            0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+            0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+            0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+            0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+            0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+            0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+            0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+            0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+            0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+            0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+            0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+            0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+            0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+            0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+            0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+            0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+            0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+            0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+            0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+            0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+            0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
+        );
+
+        self::$_sbox3 = array(
+            0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+            0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+            0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+            0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+            0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+            0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+            0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+            0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+            0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+            0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+            0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+            0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+            0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+            0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+            0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+            0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+            0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+            0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+            0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+            0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+            0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+            0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+            0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+            0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+            0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+            0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+            0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+            0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+            0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+            0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+            0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+            0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+            0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+            0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+            0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+            0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+            0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+            0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+            0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+            0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+            0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+            0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+            0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+            0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+            0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+            0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+            0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+            0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+            0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+            0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+            0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+            0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+            0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+            0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+            0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+            0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+            0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+            0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+            0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+            0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+            0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+            0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+            0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+            0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
+        );
+
+        self::$_sbox4 = array(
+            0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+            0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+            0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+            0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+            0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+            0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+            0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+            0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+            0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+            0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+            0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+            0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+            0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+            0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+            0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+            0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+            0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+            0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+            0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+            0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+            0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+            0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+            0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+            0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+            0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+            0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+            0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+            0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+            0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+            0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+            0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+            0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+            0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+            0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+            0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+            0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+            0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+            0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+            0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+            0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+            0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+            0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+            0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+            0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+            0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+            0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+            0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+            0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+            0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+            0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+            0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+            0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+            0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+            0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+            0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+            0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+            0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+            0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+            0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+            0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+            0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+            0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+            0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+            0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+        );
+
+        self::$_p = array(
+            0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+            0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+            0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+            0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+            0x9216d5d9, 0x8979fb1b
+        );
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/AES192.php

Indentation +26 added lines, -26 removed lines

@@ -38,35 +38,35 @@
  */
 class Cipher_AES_192 extends Cipher_Rijndael_128
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 16; // 128 bits;
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 16; // 128 bits;
 
-	/** @type integer BYTES_KEY The size of the key, in bytes */
-	const BYTES_KEY = 24; // 192 bits;
+    /** @type integer BYTES_KEY The size of the key, in bytes */
+    const BYTES_KEY = 24; // 192 bits;
 
-	/**
-	 * Constructor
-	 * Sets the key used for encryption.
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// Setup AES by calling the second constructor in Rijndael_128
-		// The block size is set here too, since all AES implementations use 128 bit blocks
-		parent::__construct1(PHP_Crypt::CIPHER_AES_192, $key, self::BYTES_KEY);
-	}
+    /**
+     * Constructor
+     * Sets the key used for encryption.
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // Setup AES by calling the second constructor in Rijndael_128
+        // The block size is set here too, since all AES implementations use 128 bit blocks
+        parent::__construct1(PHP_Crypt::CIPHER_AES_192, $key, self::BYTES_KEY);
+    }
 
 
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/Rijndael128.php

Indentation +46 added lines, -46 removed lines

@@ -38,61 +38,61 @@
  */
 class Cipher_Rijndael_128 extends Cipher_Rijndael
 {
-	/** @type integer BITS_BLOCK The size of the block, in bits */
-	const BYTES_BLOCK = 16;
+    /** @type integer BITS_BLOCK The size of the block, in bits */
+    const BYTES_BLOCK = 16;
 
-	//const BITS_KEY = 0;
+    //const BITS_KEY = 0;
 
 
-	/**
-	 * Constructor
-	 * Sets the key used for encryption. Also sets the requied block size
-	 * This should only be used when calling this class directly, for classes
-	 * that extend this class, they should call __construct1()
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// Set up the key
-		parent::__construct(PHP_Crypt::CIPHER_RIJNDAEL_128, $key);
+    /**
+     * Constructor
+     * Sets the key used for encryption. Also sets the requied block size
+     * This should only be used when calling this class directly, for classes
+     * that extend this class, they should call __construct1()
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // Set up the key
+        parent::__construct(PHP_Crypt::CIPHER_RIJNDAEL_128, $key);
 
-		// required block size in bits
-		$this->blockSize(self::BYTES_BLOCK);
+        // required block size in bits
+        $this->blockSize(self::BYTES_BLOCK);
 
-		// expand the key
-		$this->expandKey();
-	}
+        // expand the key
+        $this->expandKey();
+    }
 
 
-	/**
-	 * Constructor, used only by classes that extend this class
-	 *
-	 * @param string $cipher_name The pre-defined cipher name of the child class
-	 * @param string $key The key used for encryption/decryption
-	 * @param integer $req_key_len The required key length, in bits
-	 * @return void
-	 */
-	protected function __construct1($cipher_name, $key, $req_key_len)
-	{
-		parent::__construct($cipher_name, $key, $req_key_len);
+    /**
+     * Constructor, used only by classes that extend this class
+     *
+     * @param string $cipher_name The pre-defined cipher name of the child class
+     * @param string $key The key used for encryption/decryption
+     * @param integer $req_key_len The required key length, in bits
+     * @return void
+     */
+    protected function __construct1($cipher_name, $key, $req_key_len)
+    {
+        parent::__construct($cipher_name, $key, $req_key_len);
 
-		// required block size in bits
-		$this->blockSize(self::BYTES_BLOCK);
+        // required block size in bits
+        $this->blockSize(self::BYTES_BLOCK);
 
-		// expand the key
-		$this->expandKey();
-	}
+        // expand the key
+        $this->expandKey();
+    }
 
 
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 }

includes/libraries/phpcrypt/ciphers/CAST128.php

Indentation +1164 added lines, -1164 removed lines

@@ -38,1173 +38,1173 @@
  */
 class Cipher_CAST_128 extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 8; // 64 bits;
-
-	//const BYTES_KEY = 0; // between 40 - 128 bits
-
-	const BYTES_KEY_SMALL = 10;
-	const BYTES_KEY_MAX   = 16;
-	const BYTES_KEY_MIN   =  5;
-
-	/** @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();
-
-	/** @type array $_s5 An array of 256 unsigned integers */
-	private static $_s5 = array();
-
-	/** @type array $_s6 An array of 256 unsigned integers */
-	private static $_s6 = array();
-
-	/** @type array $_s7 An array of 256 unsigned integers */
-	private static $_s7 = array();
-
-	/** @type array $_s8 An array of 256 unsigned integers */
-	private static $_s8 = array();
-
-	/** @type string $_mkey The 16 byte masking subkey */
-	private $_mkey = "";
-
-	/** @type string $_rkey The 16 byte rotate subkey */
-	private $_rkey = "";
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// the length of the key is is between 5 - 16 bytes (40 - 128 bits)
-		$keylen = strlen($key);
-		if($keylen > self::BYTES_KEY_MAX)
-		{
-			$key = substr($key, 0, self::BYTES_KEY_MAX);
-			$keylen = self::BYTES_KEY_MAX;
-		}
-		else if($keylen < self::BYTES_KEY_MIN)
-		{
-			$msg  = PHP_Crypt::CIPHER_CAST_128." requires a key size between ";
-			$msg .= "5 - 16 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_128, $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 block of plain data
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$data)
-	{
-		$this->operation(parent::ENCRYPT);
-
-		// split the block in half, left and right
-		$l = parent::str2Dec(substr($data, 0, 4));
-		$r = parent::str2Dec(substr($data, 4, 4));
-
-		// We do only 12 rounds if we have a key 10 bytes or less.
-		// If we have a key greater than 10 bytes, we do the 12 rounds
-		// then proceed to the additional 4 rounds for a total of 16
-		for($i = 0; $i < 12; $i += 3)
-		{
-			// f1
-			$tmp = $r;
-			$r = $l ^ $this->f1($r, $i);
-			$l = $tmp;
-
-			// f2
-			$tmp = $r;
-			$r = $l ^ $this->f2($r, $i + 1);
-			$l = $tmp;
-
-			// f3
-			$tmp = $r;
-			$r = $l ^ $this->f3($r, $i + 2);
-			$l = $tmp;
-		}
-
-		// only do the full 16 rounds if the key is longer than
-		// 10 bytes (80 bits)
-		if($this->keySize() > self::BYTES_KEY_SMALL)
-		{
-			// f1
-			$tmp = $r;
-			$r = $l ^ $this->f1($r, 12);
-			$l = $tmp;
-
-			// f2
-			$tmp = $r;
-			$r = $l ^ $this->f2($r, 13);
-			$l = $tmp;
-
-			// f3
-			$tmp = $r;
-			$r = $l ^ $this->f3($r, 14);
-			$l = $tmp;
-
-			// f1
-			$tmp = $r;
-			$r = $l ^ $this->f1($r, 15);
-			$l = $tmp;
-		}
-
-		// swap the two halfs
-		$data = parent::dec2Str($r, 4).parent::dec2Str($l, 4);
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt an encrypted string, it does all the steps of encryption,
-	 * but in reverse.
-	 *
-	 * @param string $data A block of encrypted data
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$data)
-	{
-		$this->operation(parent::DECRYPT);
-
-		// split the block in half, left and right
-		$l = parent::str2Dec(substr($data, 0, 4));
-		$r = parent::str2Dec(substr($data, 4, 4));
-
-		// only do the full 16 rounds if the key is longer than
-		// 10 bytes (80 bits)
-		if($this->keySize() > self::BYTES_KEY_SMALL)
-		{
-			// f1
-			$tmp = $r;
-			$r = $l ^ $this->f1($r, 15);
-			$l = $tmp;
-
-			// f3
-			$tmp = $r;
-			$r = $l ^ $this->f3($r, 14);
-			$l = $tmp;
-
-			// f2
-			$tmp = $r;
-			$r = $l ^ $this->f2($r, 13);
-			$l = $tmp;
-
-			// f1
-			$tmp = $r;
-			$r = $l ^ $this->f1($r, 12);
-			$l = $tmp;
-		}
-
-		// We do only 12 rounds if we have a key 10 bytes or less.
-		for($i = 11; $i >= 2; $i -= 3)
-		{
-			// f3
-			$tmp = $r;
-			$r = $l ^ $this->f3($r, $i);
-			$l = $tmp;
-
-			// f2
-			$tmp = $r;
-			$r = $l ^ $this->f2($r, $i - 1);
-			$l = $tmp;
-
-			// f1
-			$tmp = $r;
-			$r = $l ^ $this->f1($r, $i - 2);
-			$l = $tmp;
-		}
-
-		// swap the two halfs
-		$data = parent::dec2Str($r, 4).parent::dec2Str($l, 4);
-
-		return true;
-	}
-
-
-	/**
-	 * Cast 128 F1 function
-	 *
-	 * @param $r integer The right half of the data being encrypted in cast_128()
-	 * @param $i integer The round number (1-16) in cast_128()
-	 * @return integer The value after the F1 transformation
-	 */
-	private function f1($r, $i)
-	{
-		$n = $this->_mkey[$i] + $r;
-		$n = parent::uInt32(parent::rotBitsLeft32($n, $this->_rkey[$i]));
-		$n = parent::dec2Str($n, 4);
-
-		$f = parent::uInt32(
-				((self::$_s1[ord($n[0])] ^ self::$_s2[ord($n[1])]) -
-				self::$_s3[ord($n[2])]) + self::$_s4[ord($n[3])]
-			);
-
-		return $f;
-	}
-
-
-	/**
-	 * Cast 128 F2 function
-	 *
-	 * @param $r integer The right half of the data being encrypted in cast_128()
-	 * @param $i integer The round number (1-16) in cast_128()
-	 * @return integer The value after the F2 transformation
-	 */
-	private function f2($r, $i)
-	{
-		$n = $this->_mkey[$i] ^ $r;
-		$n = parent::uInt32(parent::rotBitsLeft32($n, $this->_rkey[$i]));
-		$n = parent::dec2Str($n, 4);
-
-		$f = parent::uInt32(
-				((self::$_s1[ord($n[0])] - self::$_s2[ord($n[1])]) +
-				self::$_s3[ord($n[2])]) ^ self::$_s4[ord($n[3])]
-			);
-
-		return $f;
-	}
-
-
-	/**
-	 * Cast 128 F3 function
-	 *
-	 * @param $r integer The right half of the data being encrypted in cast_128()
-	 * @param $i integer The round number (1-16) in cast_128()
-	 * @return integer The value after the F3 transformation
-	 */
-	private function f3($r, $i)
-	{
-		$n = $this->_mkey[$i] - $r;
-		$n = parent::uInt32(parent::rotBitsLeft32($n, $this->_rkey[$i]));
-		$n = parent::dec2Str($n, 4);
-
-		$f = parent::uInt32(
-				((self::$_s1[ord($n[0])] + self::$_s2[ord($n[1])]) ^
-				self::$_s3[ord($n[2])]) - self::$_s4[ord($n[3])]
-			);
-
-		return $f;
-	}
-
-
-	/**
-	 * 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()
-	{
-		$x = $this->key();
-		$z = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; // init to 16 bytes
-		$skey = array();
-
-		// the max length of the key is 16 bytes, however if it is
-		// less, pad it with null to get ito to 16 bytes
-		if($this->keySize() < self::BYTES_KEY_MAX)
-			$x = str_pad($x, self::BYTES_KEY_MAX, "\0", STR_PAD_RIGHT);
-
-		/*
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 8; // 64 bits;
+
+    //const BYTES_KEY = 0; // between 40 - 128 bits
+
+    const BYTES_KEY_SMALL = 10;
+    const BYTES_KEY_MAX   = 16;
+    const BYTES_KEY_MIN   =  5;
+
+    /** @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();
+
+    /** @type array $_s5 An array of 256 unsigned integers */
+    private static $_s5 = array();
+
+    /** @type array $_s6 An array of 256 unsigned integers */
+    private static $_s6 = array();
+
+    /** @type array $_s7 An array of 256 unsigned integers */
+    private static $_s7 = array();
+
+    /** @type array $_s8 An array of 256 unsigned integers */
+    private static $_s8 = array();
+
+    /** @type string $_mkey The 16 byte masking subkey */
+    private $_mkey = "";
+
+    /** @type string $_rkey The 16 byte rotate subkey */
+    private $_rkey = "";
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // the length of the key is is between 5 - 16 bytes (40 - 128 bits)
+        $keylen = strlen($key);
+        if($keylen > self::BYTES_KEY_MAX)
+        {
+            $key = substr($key, 0, self::BYTES_KEY_MAX);
+            $keylen = self::BYTES_KEY_MAX;
+        }
+        else if($keylen < self::BYTES_KEY_MIN)
+        {
+            $msg  = PHP_Crypt::CIPHER_CAST_128." requires a key size between ";
+            $msg .= "5 - 16 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_128, $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 block of plain data
+     * @return boolean Returns true
+     */
+    public function encrypt(&$data)
+    {
+        $this->operation(parent::ENCRYPT);
+
+        // split the block in half, left and right
+        $l = parent::str2Dec(substr($data, 0, 4));
+        $r = parent::str2Dec(substr($data, 4, 4));
+
+        // We do only 12 rounds if we have a key 10 bytes or less.
+        // If we have a key greater than 10 bytes, we do the 12 rounds
+        // then proceed to the additional 4 rounds for a total of 16
+        for($i = 0; $i < 12; $i += 3)
+        {
+            // f1
+            $tmp = $r;
+            $r = $l ^ $this->f1($r, $i);
+            $l = $tmp;
+
+            // f2
+            $tmp = $r;
+            $r = $l ^ $this->f2($r, $i + 1);
+            $l = $tmp;
+
+            // f3
+            $tmp = $r;
+            $r = $l ^ $this->f3($r, $i + 2);
+            $l = $tmp;
+        }
+
+        // only do the full 16 rounds if the key is longer than
+        // 10 bytes (80 bits)
+        if($this->keySize() > self::BYTES_KEY_SMALL)
+        {
+            // f1
+            $tmp = $r;
+            $r = $l ^ $this->f1($r, 12);
+            $l = $tmp;
+
+            // f2
+            $tmp = $r;
+            $r = $l ^ $this->f2($r, 13);
+            $l = $tmp;
+
+            // f3
+            $tmp = $r;
+            $r = $l ^ $this->f3($r, 14);
+            $l = $tmp;
+
+            // f1
+            $tmp = $r;
+            $r = $l ^ $this->f1($r, 15);
+            $l = $tmp;
+        }
+
+        // swap the two halfs
+        $data = parent::dec2Str($r, 4).parent::dec2Str($l, 4);
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt an encrypted string, it does all the steps of encryption,
+     * but in reverse.
+     *
+     * @param string $data A block of encrypted data
+     * @return boolean Returns true
+     */
+    public function decrypt(&$data)
+    {
+        $this->operation(parent::DECRYPT);
+
+        // split the block in half, left and right
+        $l = parent::str2Dec(substr($data, 0, 4));
+        $r = parent::str2Dec(substr($data, 4, 4));
+
+        // only do the full 16 rounds if the key is longer than
+        // 10 bytes (80 bits)
+        if($this->keySize() > self::BYTES_KEY_SMALL)
+        {
+            // f1
+            $tmp = $r;
+            $r = $l ^ $this->f1($r, 15);
+            $l = $tmp;
+
+            // f3
+            $tmp = $r;
+            $r = $l ^ $this->f3($r, 14);
+            $l = $tmp;
+
+            // f2
+            $tmp = $r;
+            $r = $l ^ $this->f2($r, 13);
+            $l = $tmp;
+
+            // f1
+            $tmp = $r;
+            $r = $l ^ $this->f1($r, 12);
+            $l = $tmp;
+        }
+
+        // We do only 12 rounds if we have a key 10 bytes or less.
+        for($i = 11; $i >= 2; $i -= 3)
+        {
+            // f3
+            $tmp = $r;
+            $r = $l ^ $this->f3($r, $i);
+            $l = $tmp;
+
+            // f2
+            $tmp = $r;
+            $r = $l ^ $this->f2($r, $i - 1);
+            $l = $tmp;
+
+            // f1
+            $tmp = $r;
+            $r = $l ^ $this->f1($r, $i - 2);
+            $l = $tmp;
+        }
+
+        // swap the two halfs
+        $data = parent::dec2Str($r, 4).parent::dec2Str($l, 4);
+
+        return true;
+    }
+
+
+    /**
+     * Cast 128 F1 function
+     *
+     * @param $r integer The right half of the data being encrypted in cast_128()
+     * @param $i integer The round number (1-16) in cast_128()
+     * @return integer The value after the F1 transformation
+     */
+    private function f1($r, $i)
+    {
+        $n = $this->_mkey[$i] + $r;
+        $n = parent::uInt32(parent::rotBitsLeft32($n, $this->_rkey[$i]));
+        $n = parent::dec2Str($n, 4);
+
+        $f = parent::uInt32(
+                ((self::$_s1[ord($n[0])] ^ self::$_s2[ord($n[1])]) -
+                self::$_s3[ord($n[2])]) + self::$_s4[ord($n[3])]
+            );
+
+        return $f;
+    }
+
+
+    /**
+     * Cast 128 F2 function
+     *
+     * @param $r integer The right half of the data being encrypted in cast_128()
+     * @param $i integer The round number (1-16) in cast_128()
+     * @return integer The value after the F2 transformation
+     */
+    private function f2($r, $i)
+    {
+        $n = $this->_mkey[$i] ^ $r;
+        $n = parent::uInt32(parent::rotBitsLeft32($n, $this->_rkey[$i]));
+        $n = parent::dec2Str($n, 4);
+
+        $f = parent::uInt32(
+                ((self::$_s1[ord($n[0])] - self::$_s2[ord($n[1])]) +
+                self::$_s3[ord($n[2])]) ^ self::$_s4[ord($n[3])]
+            );
+
+        return $f;
+    }
+
+
+    /**
+     * Cast 128 F3 function
+     *
+     * @param $r integer The right half of the data being encrypted in cast_128()
+     * @param $i integer The round number (1-16) in cast_128()
+     * @return integer The value after the F3 transformation
+     */
+    private function f3($r, $i)
+    {
+        $n = $this->_mkey[$i] - $r;
+        $n = parent::uInt32(parent::rotBitsLeft32($n, $this->_rkey[$i]));
+        $n = parent::dec2Str($n, 4);
+
+        $f = parent::uInt32(
+                ((self::$_s1[ord($n[0])] + self::$_s2[ord($n[1])]) ^
+                self::$_s3[ord($n[2])]) - self::$_s4[ord($n[3])]
+            );
+
+        return $f;
+    }
+
+
+    /**
+     * 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()
+    {
+        $x = $this->key();
+        $z = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; // init to 16 bytes
+        $skey = array();
+
+        // the max length of the key is 16 bytes, however if it is
+        // less, pad it with null to get ito to 16 bytes
+        if($this->keySize() < self::BYTES_KEY_MAX)
+            $x = str_pad($x, self::BYTES_KEY_MAX, "\0", STR_PAD_RIGHT);
+
+        /*
 		 * NOW FOR THE UGLY PART, THIS IS TAKEN FROM PAGE 3-4 OF
 		 * http://tools.ietf.org/html/rfc2144
 		 */
 
-		 // two loops, each loop does 16 bytes for a total of 32 bytes
-		 for($i = 0; $i < 2; ++$i)
-		 {
-			// z0z1z2z3 = x0x1x2x3 ^ S5[xD] ^ S6[xF] ^ S7[xC] ^ S8[xE] ^ S7[x8]
-			$tmp = substr($x, 0x00, 4);
-			$tmp = parent::dec2Str(
-					parent::uInt32(
-						parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0d])] ^
-						self::$_s6[ord($x[0x0f])] ^ self::$_s7[ord($x[0x0c])] ^
-						self::$_s8[ord($x[0x0e])] ^ self::$_s7[ord($x[0x08])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x00, 4);
-
-			//print "Z0: ".parent::str2Hex($z)." (".strlen($z).")\n";
-
-			// z4z5z6z7 = x8x9xAxB ^ S5[z0] ^ S6[z2] ^ S7[z1] ^ S8[z3] ^ S8[xA]
-			$tmp = substr($x, 0x08, 4);
-			$tmp = parent::dec2Str(
-					parent::uInt32(
-						parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x00])] ^
-						self::$_s6[ord($z[0x02])] ^ self::$_s7[ord($z[0x01])] ^
-						self::$_s8[ord($z[0x03])] ^ self::$_s8[ord($x[0x0a])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x04, 4);
-
-			// z8z9zAzB = xCxDxExF ^ S5[z7] ^ S6[z6] ^ S7[z5] ^ S8[z4] ^ S5[x9]
-			$tmp = substr($x, 0x0c, 4);
-			$tmp = parent::dec2Str(
-					parent::uInt32(
-						parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x07])] ^
-						self::$_s6[ord($z[0x06])] ^ self::$_s7[ord($z[0x05])] ^
-						self::$_s8[ord($z[0x04])] ^ self::$_s5[ord($x[0x09])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x08, 4);
-
-			// zCzDzEzF = x4x5x6x7 ^ S5[zA] ^ S6[z9] ^ S7[zB] ^ S8[z8] ^ S6[xB]
-			$tmp = substr($x, 0x04, 4);
-			$tmp = parent::dec2Str(
-					parent::uInt32(
-						parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x0a])] ^
-						self::$_s6[ord($z[0x09])] ^ self::$_s7[ord($z[0x0b])] ^
-						self::$_s8[ord($z[0x08])] ^ self::$_s6[ord($x[0x0b])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x0c, 4);
-
-			//print "Z: ".parent::str2Hex($z)." (".strlen($z).")\n";
-
-			// K1  = S5[z8] ^ S6[z9] ^ S7[z7] ^ S8[z6] ^ S5[z2]
-			$skey[] = parent::uInt32(self::$_s5[ord($z[0x08])] ^ self::$_s6[ord($z[0x09])] ^
-						self::$_s7[ord($z[0x07])] ^ self::$_s8[ord($z[0x06])] ^
-						self::$_s5[ord($z[0x02])]
-					);
-
-			// K2  = S5[zA] ^ S6[zB] ^ S7[z5] ^ S8[z4] ^ S6[z6]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x0a])] ^ self::$_s6[ord($z[0x0b])] ^
-						self::$_s7[ord($z[0x05])] ^ self::$_s8[ord($z[0x04])] ^
-						self::$_s6[ord($z[0x06])]
-					);
-
-			// K3  = S5[zC] ^ S6[zD] ^ S7[z3] ^ S8[z2] ^ S7[z9]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x0c])] ^ self::$_s6[ord($z[0x0d])] ^
-						self::$_s7[ord($z[0x03])] ^ self::$_s8[ord($z[0x02])] ^
-						self::$_s7[ord($z[0x09])]
-					);
-
-			// K4  = S5[zE] ^ S6[zF] ^ S7[z1] ^ S8[z0] ^ S8[zC]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x0e])] ^ self::$_s6[ord($z[0x0f])] ^
-						self::$_s7[ord($z[0x01])] ^ self::$_s8[ord($z[0x00])] ^
-						self::$_s8[ord($z[0x0c])]
-					);
-
-			// x0x1x2x3 = z8z9zAzB ^ S5[z5] ^ S6[z7] ^ S7[z4] ^ S8[z6] ^ S7[z0]
-			$tmp = substr($z, 0x08, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x05])] ^
-							self::$_s6[ord($z[0x07])] ^ self::$_s7[ord($z[0x04])] ^
-							self::$_s8[ord($z[0x06])] ^ self::$_s7[ord($z[0x00])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x00, 4);
-
-			// x4x5x6x7 = z0z1z2z3 ^ S5[x0] ^ S6[x2] ^ S7[x1] ^ S8[x3] ^ S8[z2]
-			$tmp = substr($z, 0x00, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x00])] ^
-							self::$_s6[ord($x[0x02])] ^ self::$_s7[ord($x[0x01])] ^
-							self::$_s8[ord($x[0x03])] ^ self::$_s8[ord($z[0x02])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x04, 4);
-
-			// x8x9xAxB = z4z5z6z7 ^ S5[x7] ^ S6[x6] ^ S7[x5] ^ S8[x4] ^ S5[z1]
-			$tmp = substr($z, 0x04, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x07])] ^
-							self::$_s6[ord($x[0x06])] ^ self::$_s7[ord($x[0x05])] ^
-							self::$_s8[ord($x[0x04])] ^ self::$_s5[ord($z[0x01])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x08, 4);
-
-			// xCxDxExF = zCzDzEzF ^ S5[xA] ^ S6[x9] ^ S7[xB] ^ S8[x8] ^ S6[z3]
-			$tmp = substr($z, 0x0c, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0a])] ^
-							self::$_s6[ord($x[0x09])] ^ self::$_s7[ord($x[0x0b])] ^
-							self::$_s8[ord($x[0x08])] ^ self::$_s6[ord($z[0x03])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x0c, 4);
-
-			// K5  = S5[x3] ^ S6[x2] ^ S7[xC] ^ S8[xD] ^ S5[x8]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x03])] ^ self::$_s6[ord($x[0x02])] ^
-						self::$_s7[ord($x[0x0c])] ^ self::$_s8[ord($x[0x0d])] ^
-						self::$_s5[ord($x[0x08])]
-					);
-
-			// K6  = S5[x1] ^ S6[x0] ^ S7[xE] ^ S8[xF] ^ S6[xD]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x01])] ^ self::$_s6[ord($x[0x00])] ^
-						self::$_s7[ord($x[0x0e])] ^ self::$_s8[ord($x[0x0f])] ^
-						self::$_s6[ord($x[0x0d])]
-					);
-
-			// K7  = S5[x7] ^ S6[x6] ^ S7[x8] ^ S8[x9] ^ S7[x3]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x07])] ^ self::$_s6[ord($x[0x06])] ^
-						self::$_s7[ord($x[0x08])] ^ self::$_s8[ord($x[0x09])] ^
-						self::$_s7[ord($x[0x03])]
-					);
-
-			// K8  = S5[x5] ^ S6[x4] ^ S7[xA] ^ S8[xB] ^ S8[x7]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x05])] ^ self::$_s6[ord($x[0x04])] ^
-						self::$_s7[ord($x[0x0a])] ^ self::$_s8[ord($x[0x0b])] ^
-						self::$_s8[ord($x[0x07])]
-					);
-
-			// z0z1z2z3 = x0x1x2x3 ^ S5[xD] ^ S6[xF] ^ S7[xC] ^ S8[xE] ^ S7[x8]
-			$tmp = substr($x, 0x00, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0d])] ^
-							self::$_s6[ord($x[0x0f])] ^ self::$_s7[ord($x[0x0c])] ^
-							self::$_s8[ord($x[0x0e])] ^ self::$_s7[ord($x[0x08])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x00, 4);
-
-			// z4z5z6z7 = x8x9xAxB ^ S5[z0] ^ S6[z2] ^ S7[z1] ^ S8[z3] ^ S8[xA]
-			$tmp = substr($x, 0x08, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x00])] ^
-							self::$_s6[ord($z[0x02])] ^ self::$_s7[ord($z[0x01])] ^
-							self::$_s8[ord($z[0x03])] ^ self::$_s8[ord($x[0x0a])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x04, 4);
-
-			// z8z9zAzB = xCxDxExF ^ S5[z7] ^ S6[z6] ^ S7[z5] ^ S8[z4] ^ S5[x9]
-			$tmp = substr($x, 0x0c, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x07])] ^
-							self::$_s6[ord($z[0x06])] ^ self::$_s7[ord($z[0x05])] ^
-							self::$_s8[ord($z[0x04])] ^ self::$_s5[ord($x[0x09])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x08, 4);
-
-			// zCzDzEzF = x4x5x6x7 ^ S5[zA] ^ S6[z9] ^ S7[zB] ^ S8[z8] ^ S6[xB]
-			$tmp = substr($x, 0x04, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x0a])] ^
-							self::$_s6[ord($z[0x09])] ^ self::$_s7[ord($z[0x0b])] ^
-							self::$_s8[ord($z[0x08])] ^ self::$_s6[ord($x[0x0b])]
-					), 4);
-			$z = substr_replace($z, $tmp, 0x0c, 4);
-
-			// K9  = S5[z3] ^ S6[z2] ^ S7[zC] ^ S8[zD] ^ S5[z9]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x03])] ^ self::$_s6[ord($z[0x02])] ^
-						self::$_s7[ord($z[0x0c])] ^ self::$_s8[ord($z[0x0d])] ^
-						self::$_s5[ord($z[0x09])]
-					);
-
-			// K10 = S5[z1] ^ S6[z0] ^ S7[zE] ^ S8[zF] ^ S6[zC]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x01])] ^ self::$_s6[ord($z[0x00])] ^
-						self::$_s7[ord($z[0x0e])] ^ self::$_s8[ord($z[0x0f])] ^
-						self::$_s6[ord($z[0x0c])]
-					);
-
-			// K11 = S5[z7] ^ S6[z6] ^ S7[z8] ^ S8[z9] ^ S7[z2]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x07])] ^ self::$_s6[ord($z[0x06])] ^
-						self::$_s7[ord($z[0x08])] ^ self::$_s8[ord($z[0x09])] ^
-						self::$_s7[ord($z[0x02])]
-					);
-
-			// K12 = S5[z5] ^ S6[z4] ^ S7[zA] ^ S8[zB] ^ S8[z6]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($z[0x05])] ^ self::$_s6[ord($z[0x04])] ^
-						self::$_s7[ord($z[0x0a])] ^ self::$_s8[ord($z[0x0b])] ^
-						self::$_s8[ord($z[0x06])]
-					);
-
-			// x0x1x2x3 = z8z9zAzB ^ S5[z5] ^ S6[z7] ^ S7[z4] ^ S8[z6] ^ S7[z0]
-			$tmp = substr($z, 0x08, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x05])] ^
-							self::$_s6[ord($z[0x07])] ^ self::$_s7[ord($z[0x04])] ^
-							self::$_s8[ord($z[0x06])] ^ self::$_s7[ord($z[0x00])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x00, 4);
-
-			// x4x5x6x7 = z0z1z2z3 ^ S5[x0] ^ S6[x2] ^ S7[x1] ^ S8[x3] ^ S8[z2]
-			$tmp = substr($z, 0x00, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x00])] ^
-							self::$_s6[ord($x[0x02])] ^ self::$_s7[ord($x[0x01])] ^
-							self::$_s8[ord($x[0x03])] ^ self::$_s8[ord($z[0x02])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x04, 4);
-
-			// x8x9xAxB = z4z5z6z7 ^ S5[x7] ^ S6[x6] ^ S7[x5] ^ S8[x4] ^ S5[z1]
-			$tmp = substr($z, 0x04, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x07])] ^
-							self::$_s6[ord($x[0x06])] ^ self::$_s7[ord($x[0x05])] ^
-							self::$_s8[ord($x[0x04])] ^ self::$_s5[ord($z[0x01])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x08, 4);
-
-			// xCxDxExF = zCzDzEzF ^ S5[xA] ^ S6[x9] ^ S7[xB] ^ S8[x8] ^ S6[z3]
-			$tmp = substr($z, 0x0c, 4);
-			$tmp = parent::dec2Str(
-						parent::uInt32(
-							parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0a])] ^
-							self::$_s6[ord($x[0x09])] ^ self::$_s7[ord($x[0x0b])] ^
-							self::$_s8[ord($x[0x08])] ^ self::$_s6[ord($z[0x03])]
-					), 4);
-			$x = substr_replace($x, $tmp, 0x0c, 4);
-
-			// K13 = S5[x8] ^ S6[x9] ^ S7[x7] ^ S8[x6] ^ S5[x3]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x08])] ^ self::$_s6[ord($x[0x09])] ^
-						self::$_s7[ord($x[0x07])] ^ self::$_s8[ord($x[0x06])] ^
-						self::$_s5[ord($x[0x03])]
-					);
-
-			// K14 = S5[xA] ^ S6[xB] ^ S7[x5] ^ S8[x4] ^ S6[x7]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x0a])] ^ self::$_s6[ord($x[0x0b])] ^
-						self::$_s7[ord($x[0x05])] ^ self::$_s8[ord($x[0x04])] ^
-						self::$_s6[ord($x[0x07])]
-					);
-
-			// K15 = S5[xC] ^ S6[xD] ^ S7[x3] ^ S8[x2] ^ S7[x8]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x0c])] ^ self::$_s6[ord($x[0x0d])] ^
-						self::$_s7[ord($x[0x03])] ^ self::$_s8[ord($x[0x02])] ^
-						self::$_s7[ord($x[0x08])]
-					);
-
-			// K16 = S5[xE] ^ S6[xF] ^ S7[x1] ^ S8[x0] ^ S8[xD]
-			$skey[] = parent::uInt32(
-						self::$_s5[ord($x[0x0e])] ^ self::$_s6[ord($x[0x0f])] ^
-						self::$_s7[ord($x[0x01])] ^ self::$_s8[ord($x[0x00])] ^
-						self::$_s8[ord($x[0x0d])]
-					);
-		}
-
-		// create the 16 byte masking and rotate subkeys
-		$this->_mkey = array_slice($skey,  0, 16);
-		$this->_rkey = array_slice($skey, 16, 16);
-
-		// $_rkey only uses the least significant 5 bits
-		$this->_rkey = array_map(function($v) {
-			return $v &= 31;
-		}, $this->_rkey);
-
-		// there is 4kb in the s5 - s8 sboxes, which are not needed after we
-		// create the subkeys, so free up the memory. unset() doesn't work here
-		for($i = 5; $i <= 8; ++$i)
-			self::${"_s$i"} = null;
-	}
-
-
-	/**
-	 * 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
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s5 = array(
-			0x7EC90C04, 0x2C6E74B9, 0x9B0E66DF, 0xA6337911,
-			0xB86A7FFF, 0x1DD358F5, 0x44DD9D44, 0x1731167F,
-			0x08FBF1FA, 0xE7F511CC, 0xD2051B00, 0x735ABA00,
-			0x2AB722D8, 0x386381CB, 0xACF6243A, 0x69BEFD7A,
-			0xE6A2E77F, 0xF0C720CD, 0xC4494816, 0xCCF5C180,
-			0x38851640, 0x15B0A848, 0xE68B18CB, 0x4CAADEFF,
-			0x5F480A01, 0x0412B2AA, 0x259814FC, 0x41D0EFE2,
-			0x4E40B48D, 0x248EB6FB, 0x8DBA1CFE, 0x41A99B02,
-			0x1A550A04, 0xBA8F65CB, 0x7251F4E7, 0x95A51725,
-			0xC106ECD7, 0x97A5980A, 0xC539B9AA, 0x4D79FE6A,
-			0xF2F3F763, 0x68AF8040, 0xED0C9E56, 0x11B4958B,
-			0xE1EB5A88, 0x8709E6B0, 0xD7E07156, 0x4E29FEA7,
-			0x6366E52D, 0x02D1C000, 0xC4AC8E05, 0x9377F571,
-			0x0C05372A, 0x578535F2, 0x2261BE02, 0xD642A0C9,
-			0xDF13A280, 0x74B55BD2, 0x682199C0, 0xD421E5EC,
-			0x53FB3CE8, 0xC8ADEDB3, 0x28A87FC9, 0x3D959981,
-			0x5C1FF900, 0xFE38D399, 0x0C4EFF0B, 0x062407EA,
-			0xAA2F4FB1, 0x4FB96976, 0x90C79505, 0xB0A8A774,
-			0xEF55A1FF, 0xE59CA2C2, 0xA6B62D27, 0xE66A4263,
-			0xDF65001F, 0x0EC50966, 0xDFDD55BC, 0x29DE0655,
-			0x911E739A, 0x17AF8975, 0x32C7911C, 0x89F89468,
-			0x0D01E980, 0x524755F4, 0x03B63CC9, 0x0CC844B2,
-			0xBCF3F0AA, 0x87AC36E9, 0xE53A7426, 0x01B3D82B,
-			0x1A9E7449, 0x64EE2D7E, 0xCDDBB1DA, 0x01C94910,
-			0xB868BF80, 0x0D26F3FD, 0x9342EDE7, 0x04A5C284,
-			0x636737B6, 0x50F5B616, 0xF24766E3, 0x8ECA36C1,
-			0x136E05DB, 0xFEF18391, 0xFB887A37, 0xD6E7F7D4,
-			0xC7FB7DC9, 0x3063FCDF, 0xB6F589DE, 0xEC2941DA,
-			0x26E46695, 0xB7566419, 0xF654EFC5, 0xD08D58B7,
-			0x48925401, 0xC1BACB7F, 0xE5FF550F, 0xB6083049,
-			0x5BB5D0E8, 0x87D72E5A, 0xAB6A6EE1, 0x223A66CE,
-			0xC62BF3CD, 0x9E0885F9, 0x68CB3E47, 0x086C010F,
-			0xA21DE820, 0xD18B69DE, 0xF3F65777, 0xFA02C3F6,
-			0x407EDAC3, 0xCBB3D550, 0x1793084D, 0xB0D70EBA,
-			0x0AB378D5, 0xD951FB0C, 0xDED7DA56, 0x4124BBE4,
-			0x94CA0B56, 0x0F5755D1, 0xE0E1E56E, 0x6184B5BE,
-			0x580A249F, 0x94F74BC0, 0xE327888E, 0x9F7B5561,
-			0xC3DC0280, 0x05687715, 0x646C6BD7, 0x44904DB3,
-			0x66B4F0A3, 0xC0F1648A, 0x697ED5AF, 0x49E92FF6,
-			0x309E374F, 0x2CB6356A, 0x85808573, 0x4991F840,
-			0x76F0AE02, 0x083BE84D, 0x28421C9A, 0x44489406,
-			0x736E4CB8, 0xC1092910, 0x8BC95FC6, 0x7D869CF4,
-			0x134F616F, 0x2E77118D, 0xB31B2BE1, 0xAA90B472,
-			0x3CA5D717, 0x7D161BBA, 0x9CAD9010, 0xAF462BA2,
-			0x9FE459D2, 0x45D34559, 0xD9F2DA13, 0xDBC65487,
-			0xF3E4F94E, 0x176D486F, 0x097C13EA, 0x631DA5C7,
-			0x445F7382, 0x175683F4, 0xCDC66A97, 0x70BE0288,
-			0xB3CDCF72, 0x6E5DD2F3, 0x20936079, 0x459B80A5,
-			0xBE60E2DB, 0xA9C23101, 0xEBA5315C, 0x224E42F2,
-			0x1C5C1572, 0xF6721B2C, 0x1AD2FFF3, 0x8C25404E,
-			0x324ED72F, 0x4067B7FD, 0x0523138E, 0x5CA3BC78,
-			0xDC0FD66E, 0x75922283, 0x784D6B17, 0x58EBB16E,
-			0x44094F85, 0x3F481D87, 0xFCFEAE7B, 0x77B5FF76,
-			0x8C2302BF, 0xAAF47556, 0x5F46B02A, 0x2B092801,
-			0x3D38F5F7, 0x0CA81F36, 0x52AF4A8A, 0x66D5E7C0,
-			0xDF3B0874, 0x95055110, 0x1B5AD7A8, 0xF61ED5AD,
-			0x6CF6E479, 0x20758184, 0xD0CEFA65, 0x88F7BE58,
-			0x4A046826, 0x0FF6F8F3, 0xA09C7F70, 0x5346ABA0,
-			0x5CE96C28, 0xE176EDA3, 0x6BAC307F, 0x376829D2,
-			0x85360FA9, 0x17E3FE2A, 0x24B79767, 0xF5A96B20,
-			0xD6CD2595, 0x68FF1EBF, 0x7555442C, 0xF19F06BE,
-			0xF9E0659A, 0xEEB9491D, 0x34010718, 0xBB30CAB8,
-			0xE822FE15, 0x88570983, 0x750E6249, 0xDA627E55,
-			0x5E76FFA8, 0xB1534546, 0x6D47DE08, 0xEFE9E7D4
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s6 = array(
-			0xF6FA8F9D, 0x2CAC6CE1, 0x4CA34867, 0xE2337F7C,
-			0x95DB08E7, 0x016843B4, 0xECED5CBC, 0x325553AC,
-			0xBF9F0960, 0xDFA1E2ED, 0x83F0579D, 0x63ED86B9,
-			0x1AB6A6B8, 0xDE5EBE39, 0xF38FF732, 0x8989B138,
-			0x33F14961, 0xC01937BD, 0xF506C6DA, 0xE4625E7E,
-			0xA308EA99, 0x4E23E33C, 0x79CBD7CC, 0x48A14367,
-			0xA3149619, 0xFEC94BD5, 0xA114174A, 0xEAA01866,
-			0xA084DB2D, 0x09A8486F, 0xA888614A, 0x2900AF98,
-			0x01665991, 0xE1992863, 0xC8F30C60, 0x2E78EF3C,
-			0xD0D51932, 0xCF0FEC14, 0xF7CA07D2, 0xD0A82072,
-			0xFD41197E, 0x9305A6B0, 0xE86BE3DA, 0x74BED3CD,
-			0x372DA53C, 0x4C7F4448, 0xDAB5D440, 0x6DBA0EC3,
-			0x083919A7, 0x9FBAEED9, 0x49DBCFB0, 0x4E670C53,
-			0x5C3D9C01, 0x64BDB941, 0x2C0E636A, 0xBA7DD9CD,
-			0xEA6F7388, 0xE70BC762, 0x35F29ADB, 0x5C4CDD8D,
-			0xF0D48D8C, 0xB88153E2, 0x08A19866, 0x1AE2EAC8,
-			0x284CAF89, 0xAA928223, 0x9334BE53, 0x3B3A21BF,
-			0x16434BE3, 0x9AEA3906, 0xEFE8C36E, 0xF890CDD9,
-			0x80226DAE, 0xC340A4A3, 0xDF7E9C09, 0xA694A807,
-			0x5B7C5ECC, 0x221DB3A6, 0x9A69A02F, 0x68818A54,
-			0xCEB2296F, 0x53C0843A, 0xFE893655, 0x25BFE68A,
-			0xB4628ABC, 0xCF222EBF, 0x25AC6F48, 0xA9A99387,
-			0x53BDDB65, 0xE76FFBE7, 0xE967FD78, 0x0BA93563,
-			0x8E342BC1, 0xE8A11BE9, 0x4980740D, 0xC8087DFC,
-			0x8DE4BF99, 0xA11101A0, 0x7FD37975, 0xDA5A26C0,
-			0xE81F994F, 0x9528CD89, 0xFD339FED, 0xB87834BF,
-			0x5F04456D, 0x22258698, 0xC9C4C83B, 0x2DC156BE,
-			0x4F628DAA, 0x57F55EC5, 0xE2220ABE, 0xD2916EBF,
-			0x4EC75B95, 0x24F2C3C0, 0x42D15D99, 0xCD0D7FA0,
-			0x7B6E27FF, 0xA8DC8AF0, 0x7345C106, 0xF41E232F,
-			0x35162386, 0xE6EA8926, 0x3333B094, 0x157EC6F2,
-			0x372B74AF, 0x692573E4, 0xE9A9D848, 0xF3160289,
-			0x3A62EF1D, 0xA787E238, 0xF3A5F676, 0x74364853,
-			0x20951063, 0x4576698D, 0xB6FAD407, 0x592AF950,
-			0x36F73523, 0x4CFB6E87, 0x7DA4CEC0, 0x6C152DAA,
-			0xCB0396A8, 0xC50DFE5D, 0xFCD707AB, 0x0921C42F,
-			0x89DFF0BB, 0x5FE2BE78, 0x448F4F33, 0x754613C9,
-			0x2B05D08D, 0x48B9D585, 0xDC049441, 0xC8098F9B,
-			0x7DEDE786, 0xC39A3373, 0x42410005, 0x6A091751,
-			0x0EF3C8A6, 0x890072D6, 0x28207682, 0xA9A9F7BE,
-			0xBF32679D, 0xD45B5B75, 0xB353FD00, 0xCBB0E358,
-			0x830F220A, 0x1F8FB214, 0xD372CF08, 0xCC3C4A13,
-			0x8CF63166, 0x061C87BE, 0x88C98F88, 0x6062E397,
-			0x47CF8E7A, 0xB6C85283, 0x3CC2ACFB, 0x3FC06976,
-			0x4E8F0252, 0x64D8314D, 0xDA3870E3, 0x1E665459,
-			0xC10908F0, 0x513021A5, 0x6C5B68B7, 0x822F8AA0,
-			0x3007CD3E, 0x74719EEF, 0xDC872681, 0x073340D4,
-			0x7E432FD9, 0x0C5EC241, 0x8809286C, 0xF592D891,
-			0x08A930F6, 0x957EF305, 0xB7FBFFBD, 0xC266E96F,
-			0x6FE4AC98, 0xB173ECC0, 0xBC60B42A, 0x953498DA,
-			0xFBA1AE12, 0x2D4BD736, 0x0F25FAAB, 0xA4F3FCEB,
-			0xE2969123, 0x257F0C3D, 0x9348AF49, 0x361400BC,
-			0xE8816F4A, 0x3814F200, 0xA3F94043, 0x9C7A54C2,
-			0xBC704F57, 0xDA41E7F9, 0xC25AD33A, 0x54F4A084,
-			0xB17F5505, 0x59357CBE, 0xEDBD15C8, 0x7F97C5AB,
-			0xBA5AC7B5, 0xB6F6DEAF, 0x3A479C3A, 0x5302DA25,
-			0x653D7E6A, 0x54268D49, 0x51A477EA, 0x5017D55B,
-			0xD7D25D88, 0x44136C76, 0x0404A8C8, 0xB8E5A121,
-			0xB81A928A, 0x60ED5869, 0x97C55B96, 0xEAEC991B,
-			0x29935913, 0x01FDB7F1, 0x088E8DFA, 0x9AB6F6F5,
-			0x3B4CBF9F, 0x4A5DE3AB, 0xE6051D35, 0xA0E1D855,
-			0xD36B4CF1, 0xF544EDEB, 0xB0E93524, 0xBEBB8FBD,
-			0xA2D762CF, 0x49C92F54, 0x38B5F331, 0x7128A454,
-			0x48392905, 0xA65B1DB8, 0x851C97BD, 0xD675CF2F
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s7 = array(
-			0x85E04019, 0x332BF567, 0x662DBFFF, 0xCFC65693,
-			0x2A8D7F6F, 0xAB9BC912, 0xDE6008A1, 0x2028DA1F,
-			0x0227BCE7, 0x4D642916, 0x18FAC300, 0x50F18B82,
-			0x2CB2CB11, 0xB232E75C, 0x4B3695F2, 0xB28707DE,
-			0xA05FBCF6, 0xCD4181E9, 0xE150210C, 0xE24EF1BD,
-			0xB168C381, 0xFDE4E789, 0x5C79B0D8, 0x1E8BFD43,
-			0x4D495001, 0x38BE4341, 0x913CEE1D, 0x92A79C3F,
-			0x089766BE, 0xBAEEADF4, 0x1286BECF, 0xB6EACB19,
-			0x2660C200, 0x7565BDE4, 0x64241F7A, 0x8248DCA9,
-			0xC3B3AD66, 0x28136086, 0x0BD8DFA8, 0x356D1CF2,
-			0x107789BE, 0xB3B2E9CE, 0x0502AA8F, 0x0BC0351E,
-			0x166BF52A, 0xEB12FF82, 0xE3486911, 0xD34D7516,
-			0x4E7B3AFF, 0x5F43671B, 0x9CF6E037, 0x4981AC83,
-			0x334266CE, 0x8C9341B7, 0xD0D854C0, 0xCB3A6C88,
-			0x47BC2829, 0x4725BA37, 0xA66AD22B, 0x7AD61F1E,
-			0x0C5CBAFA, 0x4437F107, 0xB6E79962, 0x42D2D816,
-			0x0A961288, 0xE1A5C06E, 0x13749E67, 0x72FC081A,
-			0xB1D139F7, 0xF9583745, 0xCF19DF58, 0xBEC3F756,
-			0xC06EBA30, 0x07211B24, 0x45C28829, 0xC95E317F,
-			0xBC8EC511, 0x38BC46E9, 0xC6E6FA14, 0xBAE8584A,
-			0xAD4EBC46, 0x468F508B, 0x7829435F, 0xF124183B,
-			0x821DBA9F, 0xAFF60FF4, 0xEA2C4E6D, 0x16E39264,
-			0x92544A8B, 0x009B4FC3, 0xABA68CED, 0x9AC96F78,
-			0x06A5B79A, 0xB2856E6E, 0x1AEC3CA9, 0xBE838688,
-			0x0E0804E9, 0x55F1BE56, 0xE7E5363B, 0xB3A1F25D,
-			0xF7DEBB85, 0x61FE033C, 0x16746233, 0x3C034C28,
-			0xDA6D0C74, 0x79AAC56C, 0x3CE4E1AD, 0x51F0C802,
-			0x98F8F35A, 0x1626A49F, 0xEED82B29, 0x1D382FE3,
-			0x0C4FB99A, 0xBB325778, 0x3EC6D97B, 0x6E77A6A9,
-			0xCB658B5C, 0xD45230C7, 0x2BD1408B, 0x60C03EB7,
-			0xB9068D78, 0xA33754F4, 0xF430C87D, 0xC8A71302,
-			0xB96D8C32, 0xEBD4E7BE, 0xBE8B9D2D, 0x7979FB06,
-			0xE7225308, 0x8B75CF77, 0x11EF8DA4, 0xE083C858,
-			0x8D6B786F, 0x5A6317A6, 0xFA5CF7A0, 0x5DDA0033,
-			0xF28EBFB0, 0xF5B9C310, 0xA0EAC280, 0x08B9767A,
-			0xA3D9D2B0, 0x79D34217, 0x021A718D, 0x9AC6336A,
-			0x2711FD60, 0x438050E3, 0x069908A8, 0x3D7FEDC4,
-			0x826D2BEF, 0x4EEB8476, 0x488DCF25, 0x36C9D566,
-			0x28E74E41, 0xC2610ACA, 0x3D49A9CF, 0xBAE3B9DF,
-			0xB65F8DE6, 0x92AEAF64, 0x3AC7D5E6, 0x9EA80509,
-			0xF22B017D, 0xA4173F70, 0xDD1E16C3, 0x15E0D7F9,
-			0x50B1B887, 0x2B9F4FD5, 0x625ABA82, 0x6A017962,
-			0x2EC01B9C, 0x15488AA9, 0xD716E740, 0x40055A2C,
-			0x93D29A22, 0xE32DBF9A, 0x058745B9, 0x3453DC1E,
-			0xD699296E, 0x496CFF6F, 0x1C9F4986, 0xDFE2ED07,
-			0xB87242D1, 0x19DE7EAE, 0x053E561A, 0x15AD6F8C,
-			0x66626C1C, 0x7154C24C, 0xEA082B2A, 0x93EB2939,
-			0x17DCB0F0, 0x58D4F2AE, 0x9EA294FB, 0x52CF564C,
-			0x9883FE66, 0x2EC40581, 0x763953C3, 0x01D6692E,
-			0xD3A0C108, 0xA1E7160E, 0xE4F2DFA6, 0x693ED285,
-			0x74904698, 0x4C2B0EDD, 0x4F757656, 0x5D393378,
-			0xA132234F, 0x3D321C5D, 0xC3F5E194, 0x4B269301,
-			0xC79F022F, 0x3C997E7E, 0x5E4F9504, 0x3FFAFBBD,
-			0x76F7AD0E, 0x296693F4, 0x3D1FCE6F, 0xC61E45BE,
-			0xD3B5AB34, 0xF72BF9B7, 0x1B0434C0, 0x4E72B567,
-			0x5592A33D, 0xB5229301, 0xCFD2A87F, 0x60AEB767,
-			0x1814386B, 0x30BCC33D, 0x38A0C07D, 0xFD1606F2,
-			0xC363519B, 0x589DD390, 0x5479F8E6, 0x1CB8D647,
-			0x97FD61A9, 0xEA7759F4, 0x2D57539D, 0x569A58CF,
-			0xE84E63AD, 0x462E1B78, 0x6580F87E, 0xF3817914,
-			0x91DA55F4, 0x40A230F3, 0xD1988F35, 0xB6E318D2,
-			0x3FFA50BC, 0x3D40F021, 0xC3C0BDAE, 0x4958C24C,
-			0x518F36B2, 0x84B1D370, 0x0FEDCE83, 0x878DDADA,
-			0xF2A279C7, 0x94E01BE8, 0x90716F4B, 0x954B8AA3
-		);
-
-		// 256 unsigned 32 bit integers
-		self::$_s8 = array(
-			0xE216300D, 0xBBDDFFFC, 0xA7EBDABD, 0x35648095,
-			0x7789F8B7, 0xE6C1121B, 0x0E241600, 0x052CE8B5,
-			0x11A9CFB0, 0xE5952F11, 0xECE7990A, 0x9386D174,
-			0x2A42931C, 0x76E38111, 0xB12DEF3A, 0x37DDDDFC,
-			0xDE9ADEB1, 0x0A0CC32C, 0xBE197029, 0x84A00940,
-			0xBB243A0F, 0xB4D137CF, 0xB44E79F0, 0x049EEDFD,
-			0x0B15A15D, 0x480D3168, 0x8BBBDE5A, 0x669DED42,
-			0xC7ECE831, 0x3F8F95E7, 0x72DF191B, 0x7580330D,
-			0x94074251, 0x5C7DCDFA, 0xABBE6D63, 0xAA402164,
-			0xB301D40A, 0x02E7D1CA, 0x53571DAE, 0x7A3182A2,
-			0x12A8DDEC, 0xFDAA335D, 0x176F43E8, 0x71FB46D4,
-			0x38129022, 0xCE949AD4, 0xB84769AD, 0x965BD862,
-			0x82F3D055, 0x66FB9767, 0x15B80B4E, 0x1D5B47A0,
-			0x4CFDE06F, 0xC28EC4B8, 0x57E8726E, 0x647A78FC,
-			0x99865D44, 0x608BD593, 0x6C200E03, 0x39DC5FF6,
-			0x5D0B00A3, 0xAE63AFF2, 0x7E8BD632, 0x70108C0C,
-			0xBBD35049, 0x2998DF04, 0x980CF42A, 0x9B6DF491,
-			0x9E7EDD53, 0x06918548, 0x58CB7E07, 0x3B74EF2E,
-			0x522FFFB1, 0xD24708CC, 0x1C7E27CD, 0xA4EB215B,
-			0x3CF1D2E2, 0x19B47A38, 0x424F7618, 0x35856039,
-			0x9D17DEE7, 0x27EB35E6, 0xC9AFF67B, 0x36BAF5B8,
-			0x09C467CD, 0xC18910B1, 0xE11DBF7B, 0x06CD1AF8,
-			0x7170C608, 0x2D5E3354, 0xD4DE495A, 0x64C6D006,
-			0xBCC0C62C, 0x3DD00DB3, 0x708F8F34, 0x77D51B42,
-			0x264F620F, 0x24B8D2BF, 0x15C1B79E, 0x46A52564,
-			0xF8D7E54E, 0x3E378160, 0x7895CDA5, 0x859C15A5,
-			0xE6459788, 0xC37BC75F, 0xDB07BA0C, 0x0676A3AB,
-			0x7F229B1E, 0x31842E7B, 0x24259FD7, 0xF8BEF472,
-			0x835FFCB8, 0x6DF4C1F2, 0x96F5B195, 0xFD0AF0FC,
-			0xB0FE134C, 0xE2506D3D, 0x4F9B12EA, 0xF215F225,
-			0xA223736F, 0x9FB4C428, 0x25D04979, 0x34C713F8,
-			0xC4618187, 0xEA7A6E98, 0x7CD16EFC, 0x1436876C,
-			0xF1544107, 0xBEDEEE14, 0x56E9AF27, 0xA04AA441,
-			0x3CF7C899, 0x92ECBAE6, 0xDD67016D, 0x151682EB,
-			0xA842EEDF, 0xFDBA60B4, 0xF1907B75, 0x20E3030F,
-			0x24D8C29E, 0xE139673B, 0xEFA63FB8, 0x71873054,
-			0xB6F2CF3B, 0x9F326442, 0xCB15A4CC, 0xB01A4504,
-			0xF1E47D8D, 0x844A1BE5, 0xBAE7DFDC, 0x42CBDA70,
-			0xCD7DAE0A, 0x57E85B7A, 0xD53F5AF6, 0x20CF4D8C,
-			0xCEA4D428, 0x79D130A4, 0x3486EBFB, 0x33D3CDDC,
-			0x77853B53, 0x37EFFCB5, 0xC5068778, 0xE580B3E6,
-			0x4E68B8F4, 0xC5C8B37E, 0x0D809EA2, 0x398FEB7C,
-			0x132A4F94, 0x43B7950E, 0x2FEE7D1C, 0x223613BD,
-			0xDD06CAA2, 0x37DF932B, 0xC4248289, 0xACF3EBC3,
-			0x5715F6B7, 0xEF3478DD, 0xF267616F, 0xC148CBE4,
-			0x9052815E, 0x5E410FAB, 0xB48A2465, 0x2EDA7FA4,
-			0xE87B40E4, 0xE98EA084, 0x5889E9E1, 0xEFD390FC,
-			0xDD07D35B, 0xDB485694, 0x38D7E5B2, 0x57720101,
-			0x730EDEBC, 0x5B643113, 0x94917E4F, 0x503C2FBA,
-			0x646F1282, 0x7523D24A, 0xE0779695, 0xF9C17A8F,
-			0x7A5B2121, 0xD187B896, 0x29263A4D, 0xBA510CDF,
-			0x81F47C9F, 0xAD1163ED, 0xEA7B5965, 0x1A00726E,
-			0x11403092, 0x00DA6D77, 0x4A0CDD61, 0xAD1F4603,
-			0x605BDFB0, 0x9EEDC364, 0x22EBE6A8, 0xCEE7D28A,
-			0xA0E736A0, 0x5564A6B9, 0x10853209, 0xC7EB8F37,
-			0x2DE705CA, 0x8951570F, 0xDF09822B, 0xBD691A6C,
-			0xAA12E4F2, 0x87451C0F, 0xE0F6A27A, 0x3ADA4819,
-			0x4CF1764F, 0x0D771C2B, 0x67CDB156, 0x350D8384,
-			0x5938FA0F, 0x42399EF3, 0x36997B07, 0x0E84093D,
-			0x4AA93E61, 0x8360D87B, 0x1FA98B0C, 0x1149382C,
-			0xE97625A5, 0x0614D1B7, 0x0E25244B, 0x0C768347,
-			0x589E8D82, 0x0D2059D1, 0xA466BB1E, 0xF8DA0A82,
-			0x04F19130, 0xBA6E4EC0, 0x99265164, 0x1EE7230D,
-			0x50B2AD80, 0xEAEE6801, 0x8DB2A283, 0xEA8BF59E
-		);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+            // two loops, each loop does 16 bytes for a total of 32 bytes
+            for($i = 0; $i < 2; ++$i)
+            {
+            // z0z1z2z3 = x0x1x2x3 ^ S5[xD] ^ S6[xF] ^ S7[xC] ^ S8[xE] ^ S7[x8]
+            $tmp = substr($x, 0x00, 4);
+            $tmp = parent::dec2Str(
+                    parent::uInt32(
+                        parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0d])] ^
+                        self::$_s6[ord($x[0x0f])] ^ self::$_s7[ord($x[0x0c])] ^
+                        self::$_s8[ord($x[0x0e])] ^ self::$_s7[ord($x[0x08])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x00, 4);
+
+            //print "Z0: ".parent::str2Hex($z)." (".strlen($z).")\n";
+
+            // z4z5z6z7 = x8x9xAxB ^ S5[z0] ^ S6[z2] ^ S7[z1] ^ S8[z3] ^ S8[xA]
+            $tmp = substr($x, 0x08, 4);
+            $tmp = parent::dec2Str(
+                    parent::uInt32(
+                        parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x00])] ^
+                        self::$_s6[ord($z[0x02])] ^ self::$_s7[ord($z[0x01])] ^
+                        self::$_s8[ord($z[0x03])] ^ self::$_s8[ord($x[0x0a])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x04, 4);
+
+            // z8z9zAzB = xCxDxExF ^ S5[z7] ^ S6[z6] ^ S7[z5] ^ S8[z4] ^ S5[x9]
+            $tmp = substr($x, 0x0c, 4);
+            $tmp = parent::dec2Str(
+                    parent::uInt32(
+                        parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x07])] ^
+                        self::$_s6[ord($z[0x06])] ^ self::$_s7[ord($z[0x05])] ^
+                        self::$_s8[ord($z[0x04])] ^ self::$_s5[ord($x[0x09])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x08, 4);
+
+            // zCzDzEzF = x4x5x6x7 ^ S5[zA] ^ S6[z9] ^ S7[zB] ^ S8[z8] ^ S6[xB]
+            $tmp = substr($x, 0x04, 4);
+            $tmp = parent::dec2Str(
+                    parent::uInt32(
+                        parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x0a])] ^
+                        self::$_s6[ord($z[0x09])] ^ self::$_s7[ord($z[0x0b])] ^
+                        self::$_s8[ord($z[0x08])] ^ self::$_s6[ord($x[0x0b])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x0c, 4);
+
+            //print "Z: ".parent::str2Hex($z)." (".strlen($z).")\n";
+
+            // K1  = S5[z8] ^ S6[z9] ^ S7[z7] ^ S8[z6] ^ S5[z2]
+            $skey[] = parent::uInt32(self::$_s5[ord($z[0x08])] ^ self::$_s6[ord($z[0x09])] ^
+                        self::$_s7[ord($z[0x07])] ^ self::$_s8[ord($z[0x06])] ^
+                        self::$_s5[ord($z[0x02])]
+                    );
+
+            // K2  = S5[zA] ^ S6[zB] ^ S7[z5] ^ S8[z4] ^ S6[z6]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x0a])] ^ self::$_s6[ord($z[0x0b])] ^
+                        self::$_s7[ord($z[0x05])] ^ self::$_s8[ord($z[0x04])] ^
+                        self::$_s6[ord($z[0x06])]
+                    );
+
+            // K3  = S5[zC] ^ S6[zD] ^ S7[z3] ^ S8[z2] ^ S7[z9]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x0c])] ^ self::$_s6[ord($z[0x0d])] ^
+                        self::$_s7[ord($z[0x03])] ^ self::$_s8[ord($z[0x02])] ^
+                        self::$_s7[ord($z[0x09])]
+                    );
+
+            // K4  = S5[zE] ^ S6[zF] ^ S7[z1] ^ S8[z0] ^ S8[zC]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x0e])] ^ self::$_s6[ord($z[0x0f])] ^
+                        self::$_s7[ord($z[0x01])] ^ self::$_s8[ord($z[0x00])] ^
+                        self::$_s8[ord($z[0x0c])]
+                    );
+
+            // x0x1x2x3 = z8z9zAzB ^ S5[z5] ^ S6[z7] ^ S7[z4] ^ S8[z6] ^ S7[z0]
+            $tmp = substr($z, 0x08, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x05])] ^
+                            self::$_s6[ord($z[0x07])] ^ self::$_s7[ord($z[0x04])] ^
+                            self::$_s8[ord($z[0x06])] ^ self::$_s7[ord($z[0x00])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x00, 4);
+
+            // x4x5x6x7 = z0z1z2z3 ^ S5[x0] ^ S6[x2] ^ S7[x1] ^ S8[x3] ^ S8[z2]
+            $tmp = substr($z, 0x00, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x00])] ^
+                            self::$_s6[ord($x[0x02])] ^ self::$_s7[ord($x[0x01])] ^
+                            self::$_s8[ord($x[0x03])] ^ self::$_s8[ord($z[0x02])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x04, 4);
+
+            // x8x9xAxB = z4z5z6z7 ^ S5[x7] ^ S6[x6] ^ S7[x5] ^ S8[x4] ^ S5[z1]
+            $tmp = substr($z, 0x04, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x07])] ^
+                            self::$_s6[ord($x[0x06])] ^ self::$_s7[ord($x[0x05])] ^
+                            self::$_s8[ord($x[0x04])] ^ self::$_s5[ord($z[0x01])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x08, 4);
+
+            // xCxDxExF = zCzDzEzF ^ S5[xA] ^ S6[x9] ^ S7[xB] ^ S8[x8] ^ S6[z3]
+            $tmp = substr($z, 0x0c, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0a])] ^
+                            self::$_s6[ord($x[0x09])] ^ self::$_s7[ord($x[0x0b])] ^
+                            self::$_s8[ord($x[0x08])] ^ self::$_s6[ord($z[0x03])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x0c, 4);
+
+            // K5  = S5[x3] ^ S6[x2] ^ S7[xC] ^ S8[xD] ^ S5[x8]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x03])] ^ self::$_s6[ord($x[0x02])] ^
+                        self::$_s7[ord($x[0x0c])] ^ self::$_s8[ord($x[0x0d])] ^
+                        self::$_s5[ord($x[0x08])]
+                    );
+
+            // K6  = S5[x1] ^ S6[x0] ^ S7[xE] ^ S8[xF] ^ S6[xD]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x01])] ^ self::$_s6[ord($x[0x00])] ^
+                        self::$_s7[ord($x[0x0e])] ^ self::$_s8[ord($x[0x0f])] ^
+                        self::$_s6[ord($x[0x0d])]
+                    );
+
+            // K7  = S5[x7] ^ S6[x6] ^ S7[x8] ^ S8[x9] ^ S7[x3]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x07])] ^ self::$_s6[ord($x[0x06])] ^
+                        self::$_s7[ord($x[0x08])] ^ self::$_s8[ord($x[0x09])] ^
+                        self::$_s7[ord($x[0x03])]
+                    );
+
+            // K8  = S5[x5] ^ S6[x4] ^ S7[xA] ^ S8[xB] ^ S8[x7]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x05])] ^ self::$_s6[ord($x[0x04])] ^
+                        self::$_s7[ord($x[0x0a])] ^ self::$_s8[ord($x[0x0b])] ^
+                        self::$_s8[ord($x[0x07])]
+                    );
+
+            // z0z1z2z3 = x0x1x2x3 ^ S5[xD] ^ S6[xF] ^ S7[xC] ^ S8[xE] ^ S7[x8]
+            $tmp = substr($x, 0x00, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0d])] ^
+                            self::$_s6[ord($x[0x0f])] ^ self::$_s7[ord($x[0x0c])] ^
+                            self::$_s8[ord($x[0x0e])] ^ self::$_s7[ord($x[0x08])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x00, 4);
+
+            // z4z5z6z7 = x8x9xAxB ^ S5[z0] ^ S6[z2] ^ S7[z1] ^ S8[z3] ^ S8[xA]
+            $tmp = substr($x, 0x08, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x00])] ^
+                            self::$_s6[ord($z[0x02])] ^ self::$_s7[ord($z[0x01])] ^
+                            self::$_s8[ord($z[0x03])] ^ self::$_s8[ord($x[0x0a])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x04, 4);
+
+            // z8z9zAzB = xCxDxExF ^ S5[z7] ^ S6[z6] ^ S7[z5] ^ S8[z4] ^ S5[x9]
+            $tmp = substr($x, 0x0c, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x07])] ^
+                            self::$_s6[ord($z[0x06])] ^ self::$_s7[ord($z[0x05])] ^
+                            self::$_s8[ord($z[0x04])] ^ self::$_s5[ord($x[0x09])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x08, 4);
+
+            // zCzDzEzF = x4x5x6x7 ^ S5[zA] ^ S6[z9] ^ S7[zB] ^ S8[z8] ^ S6[xB]
+            $tmp = substr($x, 0x04, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x0a])] ^
+                            self::$_s6[ord($z[0x09])] ^ self::$_s7[ord($z[0x0b])] ^
+                            self::$_s8[ord($z[0x08])] ^ self::$_s6[ord($x[0x0b])]
+                    ), 4);
+            $z = substr_replace($z, $tmp, 0x0c, 4);
+
+            // K9  = S5[z3] ^ S6[z2] ^ S7[zC] ^ S8[zD] ^ S5[z9]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x03])] ^ self::$_s6[ord($z[0x02])] ^
+                        self::$_s7[ord($z[0x0c])] ^ self::$_s8[ord($z[0x0d])] ^
+                        self::$_s5[ord($z[0x09])]
+                    );
+
+            // K10 = S5[z1] ^ S6[z0] ^ S7[zE] ^ S8[zF] ^ S6[zC]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x01])] ^ self::$_s6[ord($z[0x00])] ^
+                        self::$_s7[ord($z[0x0e])] ^ self::$_s8[ord($z[0x0f])] ^
+                        self::$_s6[ord($z[0x0c])]
+                    );
+
+            // K11 = S5[z7] ^ S6[z6] ^ S7[z8] ^ S8[z9] ^ S7[z2]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x07])] ^ self::$_s6[ord($z[0x06])] ^
+                        self::$_s7[ord($z[0x08])] ^ self::$_s8[ord($z[0x09])] ^
+                        self::$_s7[ord($z[0x02])]
+                    );
+
+            // K12 = S5[z5] ^ S6[z4] ^ S7[zA] ^ S8[zB] ^ S8[z6]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($z[0x05])] ^ self::$_s6[ord($z[0x04])] ^
+                        self::$_s7[ord($z[0x0a])] ^ self::$_s8[ord($z[0x0b])] ^
+                        self::$_s8[ord($z[0x06])]
+                    );
+
+            // x0x1x2x3 = z8z9zAzB ^ S5[z5] ^ S6[z7] ^ S7[z4] ^ S8[z6] ^ S7[z0]
+            $tmp = substr($z, 0x08, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($z[0x05])] ^
+                            self::$_s6[ord($z[0x07])] ^ self::$_s7[ord($z[0x04])] ^
+                            self::$_s8[ord($z[0x06])] ^ self::$_s7[ord($z[0x00])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x00, 4);
+
+            // x4x5x6x7 = z0z1z2z3 ^ S5[x0] ^ S6[x2] ^ S7[x1] ^ S8[x3] ^ S8[z2]
+            $tmp = substr($z, 0x00, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x00])] ^
+                            self::$_s6[ord($x[0x02])] ^ self::$_s7[ord($x[0x01])] ^
+                            self::$_s8[ord($x[0x03])] ^ self::$_s8[ord($z[0x02])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x04, 4);
+
+            // x8x9xAxB = z4z5z6z7 ^ S5[x7] ^ S6[x6] ^ S7[x5] ^ S8[x4] ^ S5[z1]
+            $tmp = substr($z, 0x04, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x07])] ^
+                            self::$_s6[ord($x[0x06])] ^ self::$_s7[ord($x[0x05])] ^
+                            self::$_s8[ord($x[0x04])] ^ self::$_s5[ord($z[0x01])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x08, 4);
+
+            // xCxDxExF = zCzDzEzF ^ S5[xA] ^ S6[x9] ^ S7[xB] ^ S8[x8] ^ S6[z3]
+            $tmp = substr($z, 0x0c, 4);
+            $tmp = parent::dec2Str(
+                        parent::uInt32(
+                            parent::str2Dec($tmp) ^ self::$_s5[ord($x[0x0a])] ^
+                            self::$_s6[ord($x[0x09])] ^ self::$_s7[ord($x[0x0b])] ^
+                            self::$_s8[ord($x[0x08])] ^ self::$_s6[ord($z[0x03])]
+                    ), 4);
+            $x = substr_replace($x, $tmp, 0x0c, 4);
+
+            // K13 = S5[x8] ^ S6[x9] ^ S7[x7] ^ S8[x6] ^ S5[x3]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x08])] ^ self::$_s6[ord($x[0x09])] ^
+                        self::$_s7[ord($x[0x07])] ^ self::$_s8[ord($x[0x06])] ^
+                        self::$_s5[ord($x[0x03])]
+                    );
+
+            // K14 = S5[xA] ^ S6[xB] ^ S7[x5] ^ S8[x4] ^ S6[x7]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x0a])] ^ self::$_s6[ord($x[0x0b])] ^
+                        self::$_s7[ord($x[0x05])] ^ self::$_s8[ord($x[0x04])] ^
+                        self::$_s6[ord($x[0x07])]
+                    );
+
+            // K15 = S5[xC] ^ S6[xD] ^ S7[x3] ^ S8[x2] ^ S7[x8]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x0c])] ^ self::$_s6[ord($x[0x0d])] ^
+                        self::$_s7[ord($x[0x03])] ^ self::$_s8[ord($x[0x02])] ^
+                        self::$_s7[ord($x[0x08])]
+                    );
+
+            // K16 = S5[xE] ^ S6[xF] ^ S7[x1] ^ S8[x0] ^ S8[xD]
+            $skey[] = parent::uInt32(
+                        self::$_s5[ord($x[0x0e])] ^ self::$_s6[ord($x[0x0f])] ^
+                        self::$_s7[ord($x[0x01])] ^ self::$_s8[ord($x[0x00])] ^
+                        self::$_s8[ord($x[0x0d])]
+                    );
+        }
+
+        // create the 16 byte masking and rotate subkeys
+        $this->_mkey = array_slice($skey,  0, 16);
+        $this->_rkey = array_slice($skey, 16, 16);
+
+        // $_rkey only uses the least significant 5 bits
+        $this->_rkey = array_map(function($v) {
+            return $v &= 31;
+        }, $this->_rkey);
+
+        // there is 4kb in the s5 - s8 sboxes, which are not needed after we
+        // create the subkeys, so free up the memory. unset() doesn't work here
+        for($i = 5; $i <= 8; ++$i)
+            self::${"_s$i"} = null;
+    }
+
+
+    /**
+     * 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
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s5 = array(
+            0x7EC90C04, 0x2C6E74B9, 0x9B0E66DF, 0xA6337911,
+            0xB86A7FFF, 0x1DD358F5, 0x44DD9D44, 0x1731167F,
+            0x08FBF1FA, 0xE7F511CC, 0xD2051B00, 0x735ABA00,
+            0x2AB722D8, 0x386381CB, 0xACF6243A, 0x69BEFD7A,
+            0xE6A2E77F, 0xF0C720CD, 0xC4494816, 0xCCF5C180,
+            0x38851640, 0x15B0A848, 0xE68B18CB, 0x4CAADEFF,
+            0x5F480A01, 0x0412B2AA, 0x259814FC, 0x41D0EFE2,
+            0x4E40B48D, 0x248EB6FB, 0x8DBA1CFE, 0x41A99B02,
+            0x1A550A04, 0xBA8F65CB, 0x7251F4E7, 0x95A51725,
+            0xC106ECD7, 0x97A5980A, 0xC539B9AA, 0x4D79FE6A,
+            0xF2F3F763, 0x68AF8040, 0xED0C9E56, 0x11B4958B,
+            0xE1EB5A88, 0x8709E6B0, 0xD7E07156, 0x4E29FEA7,
+            0x6366E52D, 0x02D1C000, 0xC4AC8E05, 0x9377F571,
+            0x0C05372A, 0x578535F2, 0x2261BE02, 0xD642A0C9,
+            0xDF13A280, 0x74B55BD2, 0x682199C0, 0xD421E5EC,
+            0x53FB3CE8, 0xC8ADEDB3, 0x28A87FC9, 0x3D959981,
+            0x5C1FF900, 0xFE38D399, 0x0C4EFF0B, 0x062407EA,
+            0xAA2F4FB1, 0x4FB96976, 0x90C79505, 0xB0A8A774,
+            0xEF55A1FF, 0xE59CA2C2, 0xA6B62D27, 0xE66A4263,
+            0xDF65001F, 0x0EC50966, 0xDFDD55BC, 0x29DE0655,
+            0x911E739A, 0x17AF8975, 0x32C7911C, 0x89F89468,
+            0x0D01E980, 0x524755F4, 0x03B63CC9, 0x0CC844B2,
+            0xBCF3F0AA, 0x87AC36E9, 0xE53A7426, 0x01B3D82B,
+            0x1A9E7449, 0x64EE2D7E, 0xCDDBB1DA, 0x01C94910,
+            0xB868BF80, 0x0D26F3FD, 0x9342EDE7, 0x04A5C284,
+            0x636737B6, 0x50F5B616, 0xF24766E3, 0x8ECA36C1,
+            0x136E05DB, 0xFEF18391, 0xFB887A37, 0xD6E7F7D4,
+            0xC7FB7DC9, 0x3063FCDF, 0xB6F589DE, 0xEC2941DA,
+            0x26E46695, 0xB7566419, 0xF654EFC5, 0xD08D58B7,
+            0x48925401, 0xC1BACB7F, 0xE5FF550F, 0xB6083049,
+            0x5BB5D0E8, 0x87D72E5A, 0xAB6A6EE1, 0x223A66CE,
+            0xC62BF3CD, 0x9E0885F9, 0x68CB3E47, 0x086C010F,
+            0xA21DE820, 0xD18B69DE, 0xF3F65777, 0xFA02C3F6,
+            0x407EDAC3, 0xCBB3D550, 0x1793084D, 0xB0D70EBA,
+            0x0AB378D5, 0xD951FB0C, 0xDED7DA56, 0x4124BBE4,
+            0x94CA0B56, 0x0F5755D1, 0xE0E1E56E, 0x6184B5BE,
+            0x580A249F, 0x94F74BC0, 0xE327888E, 0x9F7B5561,
+            0xC3DC0280, 0x05687715, 0x646C6BD7, 0x44904DB3,
+            0x66B4F0A3, 0xC0F1648A, 0x697ED5AF, 0x49E92FF6,
+            0x309E374F, 0x2CB6356A, 0x85808573, 0x4991F840,
+            0x76F0AE02, 0x083BE84D, 0x28421C9A, 0x44489406,
+            0x736E4CB8, 0xC1092910, 0x8BC95FC6, 0x7D869CF4,
+            0x134F616F, 0x2E77118D, 0xB31B2BE1, 0xAA90B472,
+            0x3CA5D717, 0x7D161BBA, 0x9CAD9010, 0xAF462BA2,
+            0x9FE459D2, 0x45D34559, 0xD9F2DA13, 0xDBC65487,
+            0xF3E4F94E, 0x176D486F, 0x097C13EA, 0x631DA5C7,
+            0x445F7382, 0x175683F4, 0xCDC66A97, 0x70BE0288,
+            0xB3CDCF72, 0x6E5DD2F3, 0x20936079, 0x459B80A5,
+            0xBE60E2DB, 0xA9C23101, 0xEBA5315C, 0x224E42F2,
+            0x1C5C1572, 0xF6721B2C, 0x1AD2FFF3, 0x8C25404E,
+            0x324ED72F, 0x4067B7FD, 0x0523138E, 0x5CA3BC78,
+            0xDC0FD66E, 0x75922283, 0x784D6B17, 0x58EBB16E,
+            0x44094F85, 0x3F481D87, 0xFCFEAE7B, 0x77B5FF76,
+            0x8C2302BF, 0xAAF47556, 0x5F46B02A, 0x2B092801,
+            0x3D38F5F7, 0x0CA81F36, 0x52AF4A8A, 0x66D5E7C0,
+            0xDF3B0874, 0x95055110, 0x1B5AD7A8, 0xF61ED5AD,
+            0x6CF6E479, 0x20758184, 0xD0CEFA65, 0x88F7BE58,
+            0x4A046826, 0x0FF6F8F3, 0xA09C7F70, 0x5346ABA0,
+            0x5CE96C28, 0xE176EDA3, 0x6BAC307F, 0x376829D2,
+            0x85360FA9, 0x17E3FE2A, 0x24B79767, 0xF5A96B20,
+            0xD6CD2595, 0x68FF1EBF, 0x7555442C, 0xF19F06BE,
+            0xF9E0659A, 0xEEB9491D, 0x34010718, 0xBB30CAB8,
+            0xE822FE15, 0x88570983, 0x750E6249, 0xDA627E55,
+            0x5E76FFA8, 0xB1534546, 0x6D47DE08, 0xEFE9E7D4
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s6 = array(
+            0xF6FA8F9D, 0x2CAC6CE1, 0x4CA34867, 0xE2337F7C,
+            0x95DB08E7, 0x016843B4, 0xECED5CBC, 0x325553AC,
+            0xBF9F0960, 0xDFA1E2ED, 0x83F0579D, 0x63ED86B9,
+            0x1AB6A6B8, 0xDE5EBE39, 0xF38FF732, 0x8989B138,
+            0x33F14961, 0xC01937BD, 0xF506C6DA, 0xE4625E7E,
+            0xA308EA99, 0x4E23E33C, 0x79CBD7CC, 0x48A14367,
+            0xA3149619, 0xFEC94BD5, 0xA114174A, 0xEAA01866,
+            0xA084DB2D, 0x09A8486F, 0xA888614A, 0x2900AF98,
+            0x01665991, 0xE1992863, 0xC8F30C60, 0x2E78EF3C,
+            0xD0D51932, 0xCF0FEC14, 0xF7CA07D2, 0xD0A82072,
+            0xFD41197E, 0x9305A6B0, 0xE86BE3DA, 0x74BED3CD,
+            0x372DA53C, 0x4C7F4448, 0xDAB5D440, 0x6DBA0EC3,
+            0x083919A7, 0x9FBAEED9, 0x49DBCFB0, 0x4E670C53,
+            0x5C3D9C01, 0x64BDB941, 0x2C0E636A, 0xBA7DD9CD,
+            0xEA6F7388, 0xE70BC762, 0x35F29ADB, 0x5C4CDD8D,
+            0xF0D48D8C, 0xB88153E2, 0x08A19866, 0x1AE2EAC8,
+            0x284CAF89, 0xAA928223, 0x9334BE53, 0x3B3A21BF,
+            0x16434BE3, 0x9AEA3906, 0xEFE8C36E, 0xF890CDD9,
+            0x80226DAE, 0xC340A4A3, 0xDF7E9C09, 0xA694A807,
+            0x5B7C5ECC, 0x221DB3A6, 0x9A69A02F, 0x68818A54,
+            0xCEB2296F, 0x53C0843A, 0xFE893655, 0x25BFE68A,
+            0xB4628ABC, 0xCF222EBF, 0x25AC6F48, 0xA9A99387,
+            0x53BDDB65, 0xE76FFBE7, 0xE967FD78, 0x0BA93563,
+            0x8E342BC1, 0xE8A11BE9, 0x4980740D, 0xC8087DFC,
+            0x8DE4BF99, 0xA11101A0, 0x7FD37975, 0xDA5A26C0,
+            0xE81F994F, 0x9528CD89, 0xFD339FED, 0xB87834BF,
+            0x5F04456D, 0x22258698, 0xC9C4C83B, 0x2DC156BE,
+            0x4F628DAA, 0x57F55EC5, 0xE2220ABE, 0xD2916EBF,
+            0x4EC75B95, 0x24F2C3C0, 0x42D15D99, 0xCD0D7FA0,
+            0x7B6E27FF, 0xA8DC8AF0, 0x7345C106, 0xF41E232F,
+            0x35162386, 0xE6EA8926, 0x3333B094, 0x157EC6F2,
+            0x372B74AF, 0x692573E4, 0xE9A9D848, 0xF3160289,
+            0x3A62EF1D, 0xA787E238, 0xF3A5F676, 0x74364853,
+            0x20951063, 0x4576698D, 0xB6FAD407, 0x592AF950,
+            0x36F73523, 0x4CFB6E87, 0x7DA4CEC0, 0x6C152DAA,
+            0xCB0396A8, 0xC50DFE5D, 0xFCD707AB, 0x0921C42F,
+            0x89DFF0BB, 0x5FE2BE78, 0x448F4F33, 0x754613C9,
+            0x2B05D08D, 0x48B9D585, 0xDC049441, 0xC8098F9B,
+            0x7DEDE786, 0xC39A3373, 0x42410005, 0x6A091751,
+            0x0EF3C8A6, 0x890072D6, 0x28207682, 0xA9A9F7BE,
+            0xBF32679D, 0xD45B5B75, 0xB353FD00, 0xCBB0E358,
+            0x830F220A, 0x1F8FB214, 0xD372CF08, 0xCC3C4A13,
+            0x8CF63166, 0x061C87BE, 0x88C98F88, 0x6062E397,
+            0x47CF8E7A, 0xB6C85283, 0x3CC2ACFB, 0x3FC06976,
+            0x4E8F0252, 0x64D8314D, 0xDA3870E3, 0x1E665459,
+            0xC10908F0, 0x513021A5, 0x6C5B68B7, 0x822F8AA0,
+            0x3007CD3E, 0x74719EEF, 0xDC872681, 0x073340D4,
+            0x7E432FD9, 0x0C5EC241, 0x8809286C, 0xF592D891,
+            0x08A930F6, 0x957EF305, 0xB7FBFFBD, 0xC266E96F,
+            0x6FE4AC98, 0xB173ECC0, 0xBC60B42A, 0x953498DA,
+            0xFBA1AE12, 0x2D4BD736, 0x0F25FAAB, 0xA4F3FCEB,
+            0xE2969123, 0x257F0C3D, 0x9348AF49, 0x361400BC,
+            0xE8816F4A, 0x3814F200, 0xA3F94043, 0x9C7A54C2,
+            0xBC704F57, 0xDA41E7F9, 0xC25AD33A, 0x54F4A084,
+            0xB17F5505, 0x59357CBE, 0xEDBD15C8, 0x7F97C5AB,
+            0xBA5AC7B5, 0xB6F6DEAF, 0x3A479C3A, 0x5302DA25,
+            0x653D7E6A, 0x54268D49, 0x51A477EA, 0x5017D55B,
+            0xD7D25D88, 0x44136C76, 0x0404A8C8, 0xB8E5A121,
+            0xB81A928A, 0x60ED5869, 0x97C55B96, 0xEAEC991B,
+            0x29935913, 0x01FDB7F1, 0x088E8DFA, 0x9AB6F6F5,
+            0x3B4CBF9F, 0x4A5DE3AB, 0xE6051D35, 0xA0E1D855,
+            0xD36B4CF1, 0xF544EDEB, 0xB0E93524, 0xBEBB8FBD,
+            0xA2D762CF, 0x49C92F54, 0x38B5F331, 0x7128A454,
+            0x48392905, 0xA65B1DB8, 0x851C97BD, 0xD675CF2F
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s7 = array(
+            0x85E04019, 0x332BF567, 0x662DBFFF, 0xCFC65693,
+            0x2A8D7F6F, 0xAB9BC912, 0xDE6008A1, 0x2028DA1F,
+            0x0227BCE7, 0x4D642916, 0x18FAC300, 0x50F18B82,
+            0x2CB2CB11, 0xB232E75C, 0x4B3695F2, 0xB28707DE,
+            0xA05FBCF6, 0xCD4181E9, 0xE150210C, 0xE24EF1BD,
+            0xB168C381, 0xFDE4E789, 0x5C79B0D8, 0x1E8BFD43,
+            0x4D495001, 0x38BE4341, 0x913CEE1D, 0x92A79C3F,
+            0x089766BE, 0xBAEEADF4, 0x1286BECF, 0xB6EACB19,
+            0x2660C200, 0x7565BDE4, 0x64241F7A, 0x8248DCA9,
+            0xC3B3AD66, 0x28136086, 0x0BD8DFA8, 0x356D1CF2,
+            0x107789BE, 0xB3B2E9CE, 0x0502AA8F, 0x0BC0351E,
+            0x166BF52A, 0xEB12FF82, 0xE3486911, 0xD34D7516,
+            0x4E7B3AFF, 0x5F43671B, 0x9CF6E037, 0x4981AC83,
+            0x334266CE, 0x8C9341B7, 0xD0D854C0, 0xCB3A6C88,
+            0x47BC2829, 0x4725BA37, 0xA66AD22B, 0x7AD61F1E,
+            0x0C5CBAFA, 0x4437F107, 0xB6E79962, 0x42D2D816,
+            0x0A961288, 0xE1A5C06E, 0x13749E67, 0x72FC081A,
+            0xB1D139F7, 0xF9583745, 0xCF19DF58, 0xBEC3F756,
+            0xC06EBA30, 0x07211B24, 0x45C28829, 0xC95E317F,
+            0xBC8EC511, 0x38BC46E9, 0xC6E6FA14, 0xBAE8584A,
+            0xAD4EBC46, 0x468F508B, 0x7829435F, 0xF124183B,
+            0x821DBA9F, 0xAFF60FF4, 0xEA2C4E6D, 0x16E39264,
+            0x92544A8B, 0x009B4FC3, 0xABA68CED, 0x9AC96F78,
+            0x06A5B79A, 0xB2856E6E, 0x1AEC3CA9, 0xBE838688,
+            0x0E0804E9, 0x55F1BE56, 0xE7E5363B, 0xB3A1F25D,
+            0xF7DEBB85, 0x61FE033C, 0x16746233, 0x3C034C28,
+            0xDA6D0C74, 0x79AAC56C, 0x3CE4E1AD, 0x51F0C802,
+            0x98F8F35A, 0x1626A49F, 0xEED82B29, 0x1D382FE3,
+            0x0C4FB99A, 0xBB325778, 0x3EC6D97B, 0x6E77A6A9,
+            0xCB658B5C, 0xD45230C7, 0x2BD1408B, 0x60C03EB7,
+            0xB9068D78, 0xA33754F4, 0xF430C87D, 0xC8A71302,
+            0xB96D8C32, 0xEBD4E7BE, 0xBE8B9D2D, 0x7979FB06,
+            0xE7225308, 0x8B75CF77, 0x11EF8DA4, 0xE083C858,
+            0x8D6B786F, 0x5A6317A6, 0xFA5CF7A0, 0x5DDA0033,
+            0xF28EBFB0, 0xF5B9C310, 0xA0EAC280, 0x08B9767A,
+            0xA3D9D2B0, 0x79D34217, 0x021A718D, 0x9AC6336A,
+            0x2711FD60, 0x438050E3, 0x069908A8, 0x3D7FEDC4,
+            0x826D2BEF, 0x4EEB8476, 0x488DCF25, 0x36C9D566,
+            0x28E74E41, 0xC2610ACA, 0x3D49A9CF, 0xBAE3B9DF,
+            0xB65F8DE6, 0x92AEAF64, 0x3AC7D5E6, 0x9EA80509,
+            0xF22B017D, 0xA4173F70, 0xDD1E16C3, 0x15E0D7F9,
+            0x50B1B887, 0x2B9F4FD5, 0x625ABA82, 0x6A017962,
+            0x2EC01B9C, 0x15488AA9, 0xD716E740, 0x40055A2C,
+            0x93D29A22, 0xE32DBF9A, 0x058745B9, 0x3453DC1E,
+            0xD699296E, 0x496CFF6F, 0x1C9F4986, 0xDFE2ED07,
+            0xB87242D1, 0x19DE7EAE, 0x053E561A, 0x15AD6F8C,
+            0x66626C1C, 0x7154C24C, 0xEA082B2A, 0x93EB2939,
+            0x17DCB0F0, 0x58D4F2AE, 0x9EA294FB, 0x52CF564C,
+            0x9883FE66, 0x2EC40581, 0x763953C3, 0x01D6692E,
+            0xD3A0C108, 0xA1E7160E, 0xE4F2DFA6, 0x693ED285,
+            0x74904698, 0x4C2B0EDD, 0x4F757656, 0x5D393378,
+            0xA132234F, 0x3D321C5D, 0xC3F5E194, 0x4B269301,
+            0xC79F022F, 0x3C997E7E, 0x5E4F9504, 0x3FFAFBBD,
+            0x76F7AD0E, 0x296693F4, 0x3D1FCE6F, 0xC61E45BE,
+            0xD3B5AB34, 0xF72BF9B7, 0x1B0434C0, 0x4E72B567,
+            0x5592A33D, 0xB5229301, 0xCFD2A87F, 0x60AEB767,
+            0x1814386B, 0x30BCC33D, 0x38A0C07D, 0xFD1606F2,
+            0xC363519B, 0x589DD390, 0x5479F8E6, 0x1CB8D647,
+            0x97FD61A9, 0xEA7759F4, 0x2D57539D, 0x569A58CF,
+            0xE84E63AD, 0x462E1B78, 0x6580F87E, 0xF3817914,
+            0x91DA55F4, 0x40A230F3, 0xD1988F35, 0xB6E318D2,
+            0x3FFA50BC, 0x3D40F021, 0xC3C0BDAE, 0x4958C24C,
+            0x518F36B2, 0x84B1D370, 0x0FEDCE83, 0x878DDADA,
+            0xF2A279C7, 0x94E01BE8, 0x90716F4B, 0x954B8AA3
+        );
+
+        // 256 unsigned 32 bit integers
+        self::$_s8 = array(
+            0xE216300D, 0xBBDDFFFC, 0xA7EBDABD, 0x35648095,
+            0x7789F8B7, 0xE6C1121B, 0x0E241600, 0x052CE8B5,
+            0x11A9CFB0, 0xE5952F11, 0xECE7990A, 0x9386D174,
+            0x2A42931C, 0x76E38111, 0xB12DEF3A, 0x37DDDDFC,
+            0xDE9ADEB1, 0x0A0CC32C, 0xBE197029, 0x84A00940,
+            0xBB243A0F, 0xB4D137CF, 0xB44E79F0, 0x049EEDFD,
+            0x0B15A15D, 0x480D3168, 0x8BBBDE5A, 0x669DED42,
+            0xC7ECE831, 0x3F8F95E7, 0x72DF191B, 0x7580330D,
+            0x94074251, 0x5C7DCDFA, 0xABBE6D63, 0xAA402164,
+            0xB301D40A, 0x02E7D1CA, 0x53571DAE, 0x7A3182A2,
+            0x12A8DDEC, 0xFDAA335D, 0x176F43E8, 0x71FB46D4,
+            0x38129022, 0xCE949AD4, 0xB84769AD, 0x965BD862,
+            0x82F3D055, 0x66FB9767, 0x15B80B4E, 0x1D5B47A0,
+            0x4CFDE06F, 0xC28EC4B8, 0x57E8726E, 0x647A78FC,
+            0x99865D44, 0x608BD593, 0x6C200E03, 0x39DC5FF6,
+            0x5D0B00A3, 0xAE63AFF2, 0x7E8BD632, 0x70108C0C,
+            0xBBD35049, 0x2998DF04, 0x980CF42A, 0x9B6DF491,
+            0x9E7EDD53, 0x06918548, 0x58CB7E07, 0x3B74EF2E,
+            0x522FFFB1, 0xD24708CC, 0x1C7E27CD, 0xA4EB215B,
+            0x3CF1D2E2, 0x19B47A38, 0x424F7618, 0x35856039,
+            0x9D17DEE7, 0x27EB35E6, 0xC9AFF67B, 0x36BAF5B8,
+            0x09C467CD, 0xC18910B1, 0xE11DBF7B, 0x06CD1AF8,
+            0x7170C608, 0x2D5E3354, 0xD4DE495A, 0x64C6D006,
+            0xBCC0C62C, 0x3DD00DB3, 0x708F8F34, 0x77D51B42,
+            0x264F620F, 0x24B8D2BF, 0x15C1B79E, 0x46A52564,
+            0xF8D7E54E, 0x3E378160, 0x7895CDA5, 0x859C15A5,
+            0xE6459788, 0xC37BC75F, 0xDB07BA0C, 0x0676A3AB,
+            0x7F229B1E, 0x31842E7B, 0x24259FD7, 0xF8BEF472,
+            0x835FFCB8, 0x6DF4C1F2, 0x96F5B195, 0xFD0AF0FC,
+            0xB0FE134C, 0xE2506D3D, 0x4F9B12EA, 0xF215F225,
+            0xA223736F, 0x9FB4C428, 0x25D04979, 0x34C713F8,
+            0xC4618187, 0xEA7A6E98, 0x7CD16EFC, 0x1436876C,
+            0xF1544107, 0xBEDEEE14, 0x56E9AF27, 0xA04AA441,
+            0x3CF7C899, 0x92ECBAE6, 0xDD67016D, 0x151682EB,
+            0xA842EEDF, 0xFDBA60B4, 0xF1907B75, 0x20E3030F,
+            0x24D8C29E, 0xE139673B, 0xEFA63FB8, 0x71873054,
+            0xB6F2CF3B, 0x9F326442, 0xCB15A4CC, 0xB01A4504,
+            0xF1E47D8D, 0x844A1BE5, 0xBAE7DFDC, 0x42CBDA70,
+            0xCD7DAE0A, 0x57E85B7A, 0xD53F5AF6, 0x20CF4D8C,
+            0xCEA4D428, 0x79D130A4, 0x3486EBFB, 0x33D3CDDC,
+            0x77853B53, 0x37EFFCB5, 0xC5068778, 0xE580B3E6,
+            0x4E68B8F4, 0xC5C8B37E, 0x0D809EA2, 0x398FEB7C,
+            0x132A4F94, 0x43B7950E, 0x2FEE7D1C, 0x223613BD,
+            0xDD06CAA2, 0x37DF932B, 0xC4248289, 0xACF3EBC3,
+            0x5715F6B7, 0xEF3478DD, 0xF267616F, 0xC148CBE4,
+            0x9052815E, 0x5E410FAB, 0xB48A2465, 0x2EDA7FA4,
+            0xE87B40E4, 0xE98EA084, 0x5889E9E1, 0xEFD390FC,
+            0xDD07D35B, 0xDB485694, 0x38D7E5B2, 0x57720101,
+            0x730EDEBC, 0x5B643113, 0x94917E4F, 0x503C2FBA,
+            0x646F1282, 0x7523D24A, 0xE0779695, 0xF9C17A8F,
+            0x7A5B2121, 0xD187B896, 0x29263A4D, 0xBA510CDF,
+            0x81F47C9F, 0xAD1163ED, 0xEA7B5965, 0x1A00726E,
+            0x11403092, 0x00DA6D77, 0x4A0CDD61, 0xAD1F4603,
+            0x605BDFB0, 0x9EEDC364, 0x22EBE6A8, 0xCEE7D28A,
+            0xA0E736A0, 0x5564A6B9, 0x10853209, 0xC7EB8F37,
+            0x2DE705CA, 0x8951570F, 0xDF09822B, 0xBD691A6C,
+            0xAA12E4F2, 0x87451C0F, 0xE0F6A27A, 0x3ADA4819,
+            0x4CF1764F, 0x0D771C2B, 0x67CDB156, 0x350D8384,
+            0x5938FA0F, 0x42399EF3, 0x36997B07, 0x0E84093D,
+            0x4AA93E61, 0x8360D87B, 0x1FA98B0C, 0x1149382C,
+            0xE97625A5, 0x0614D1B7, 0x0E25244B, 0x0C768347,
+            0x589E8D82, 0x0D2059D1, 0xA466BB1E, 0xF8DA0A82,
+            0x04F19130, 0xBA6E4EC0, 0x99265164, 0x1EE7230D,
+            0x50B2AD80, 0xEAEE6801, 0x8DB2A283, 0xEA8BF59E
+        );
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/DES.php

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;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/Vigenere.php

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;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/CAST256.php

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;
+    }
 }
 ?>

includes/libraries/phpcrypt/ciphers/Skipjack.php

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;
+    }
 }
 ?>