nilsteampassnet / TeamPass

includes/libraries/phpcrypt/ciphers/Rijndael.php

Braces +103 added lines, -77 removed lines

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

includes/libraries/phpcrypt/ciphers/SimpleXOR.php

Braces +3 added lines, -2 removed lines

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

includes/libraries/phpcrypt/ciphers/ARC4.php

Braces +6 added lines, -4 removed lines

@@ -106,8 +106,9 @@ 
         $len = strlen($text);
         $this->prga($len);
 
-        for ($i = 0; $i < $len; ++$i)
-            $text[$i] = $text[$i] ^ $this->_key_stream[$i];
+        for ($i = 0; $i < $len; ++$i) {
+                    $text[$i] = $text[$i] ^ $this->_key_stream[$i];
+        }
 
         return true;
     }
@@ -126,8 +127,9 @@ 
         $key = $this->key();
 
         // fill $this->_s with all the values from 0-255
-        for ($i = 0; $i < 256; ++$i)
-            $this->_s[$i] = $i;
+        for ($i = 0; $i < 256; ++$i) {
+                    $this->_s[$i] = $i;
+        }
 
         // the changing S List
         for ($i = 0; $i < 256; ++$i)

includes/libraries/phpcrypt/ciphers/CAST256.php

Braces +4 added lines, -4 removed lines

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

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

Braces +8 added lines, -6 removed lines

@@ -140,10 +140,11 @@ 
         $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::ENCRYPT) {
+                    $rcon = self::$_rcon_enc;
+        } else {
+                    $rcon = self::$_rcon_dec;
+        }
 
         if ($this->operation() == parent::DECRYPT)
         {
@@ -168,8 +169,9 @@ 
 
         $this->theta($data);
 
-        if ($this->operation() == parent::DECRYPT)
-            $this->invertBits($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).

includes/libraries/phpcrypt/ciphers/Vigenere.php

Braces +6 added lines, -5 removed lines

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

includes/libraries/phpcrypt/ciphers/DES.php

Indentation +552 added lines, -552 removed lines

@@ -38,563 +38,563 @@
  */
 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
-	 *
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-		return $this->des($text);
-	}
-
-
-	/**
-	 * Decrypt 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 $text
-	 * @return string 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 string $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 string $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;
-	}
+    /**
+     * @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
+     *
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+        return $this->des($text);
+    }
+
+
+    /**
+     * Decrypt 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 $text
+     * @return string 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 string $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 string $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/Cipher.php

Braces +18 added lines, -14 removed lines

@@ -150,8 +150,9 @@ 
      */
     public function operation($op = 0)
     {
-        if ($op == self::ENCRYPT || $op == self::DECRYPT)
-            $this->operation = $op;
+        if ($op == self::ENCRYPT || $op == self::DECRYPT) {
+                    $this->operation = $op;
+        }
 
         return $this->operation;
     }
@@ -164,8 +165,9 @@ 
      */
     public function name($name = "")
     {
-        if ($name != "")
-            $this->cipher_name = $name;
+        if ($name != "") {
+                    $this->cipher_name = $name;
+        }
 
         return $this->cipher_name;
     }
@@ -179,13 +181,15 @@ 
      */
     public function blockSize($bytes = 0)
     {
-        if ($bytes > 0)
-            $this->block_size = $bytes;
+        if ($bytes > 0) {
+                    $this->block_size = $bytes;
+        }
 
         // in some cases a blockSize is not set, such as stream ciphers.
         // so just return 0 for the block size
-        if (!isset($this->block_size))
-            return 0;
+        if (!isset($this->block_size)) {
+                    return 0;
+        }
 
         return $this->block_size;
     }
@@ -224,10 +228,11 @@ 
             // given, we need to make sure the new key meets the size
             // requirements. This can be determined from the $this->key_len
             // member set from the previous key
-            if ($this->key_len > 0 && $req_sz == 0)
-                $req_sz = $this->key_len;
-            else
-                $this->key_len = strlen($key);
+            if ($this->key_len > 0 && $req_sz == 0) {
+                            $req_sz = $this->key_len;
+            } else {
+                            $this->key_len = strlen($key);
+            }
 
             if ($req_sz > 0)
             {
@@ -236,8 +241,7 @@ 
                     // shorten the key length
                     $key = substr($key, 0, $req_sz);
                     $this->key_len = $req_sz;
-                }
-                else if ($this->key_len < $req_sz)
+                } else if ($this->key_len < $req_sz)
                 {
                     // send a notice that the key was too small
                     // NEVER PAD THE KEY, THIS WOULD BE INSECURE!!!!!

includes/libraries/phpcrypt/Mode.php

Braces +12 added lines, -8 removed lines

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