nilsteampassnet / TeamPass

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/RC2.php

Indentation +273 added lines, -273 removed lines

@@ -44,298 +44,298 @@
  */
 class Cipher_RC2 extends Cipher
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 8; // 64 bits
-
-	// rc2 has a variable length key, between 1 - 128 bytes (8-1024 bits)
-	//const BYTES_KEY = 0;
-
-	/** @type array $_sbox RC2's sBox, initialized in initTables() */
-	private static $_sbox = array();
-
-	/** @type string $xkey The expanded key */
-	private $xkey = "";
-
-
-	/**
-	 * Constructor
-	 *
-	 * @param string $key The key used for Encryption/Decryption
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// the key must be between 1 and 128 bytes, keys larger than
-		// 128 bytes are truncated in expandedKey()
-		$keylen = strlen($key);
-		if($keylen < 1)
-		{
-			$err = "Key size is $keylen bits, Key size must be between 1 and 128 bytes";
-			trigger_error($err, E_USER_WARNING);
-		}
-
-		// set the key
-		parent::__construct(PHP_Crypt::CIPHER_RC2, $key, $keylen);
-
-		// set the block size
-		$this->blockSize(self::BYTES_BLOCK);
-
-		// initialize the tables
-		$this->initTables();
-
-		// expand the key to 128 bytes
-		$this->expandKey();
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypt plain text data using RC2
-	 *
-	 * @param string $text A 64 bit (8 byte) plain text string
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->operation(parent::ENCRYPT);
-
-		// split up the message and key into 4 16 bit parts (2 byte words),
-		// then convert each array element to an integer
-		$w = self::splitBytes($text);
-		$k = self::splitBytes($this->xkey);
-		$j = 0; // the key index
-
-		for($i = 0; $i < 16; ++$i)
-		{
-			$j = $i * 4;
-
-			/* This is where it gets ugly, RC2 relies on unsigned ints. PHP does
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 8; // 64 bits
+
+    // rc2 has a variable length key, between 1 - 128 bytes (8-1024 bits)
+    //const BYTES_KEY = 0;
+
+    /** @type array $_sbox RC2's sBox, initialized in initTables() */
+    private static $_sbox = array();
+
+    /** @type string $xkey The expanded key */
+    private $xkey = "";
+
+
+    /**
+     * Constructor
+     *
+     * @param string $key The key used for Encryption/Decryption
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // the key must be between 1 and 128 bytes, keys larger than
+        // 128 bytes are truncated in expandedKey()
+        $keylen = strlen($key);
+        if($keylen < 1)
+        {
+            $err = "Key size is $keylen bits, Key size must be between 1 and 128 bytes";
+            trigger_error($err, E_USER_WARNING);
+        }
+
+        // set the key
+        parent::__construct(PHP_Crypt::CIPHER_RC2, $key, $keylen);
+
+        // set the block size
+        $this->blockSize(self::BYTES_BLOCK);
+
+        // initialize the tables
+        $this->initTables();
+
+        // expand the key to 128 bytes
+        $this->expandKey();
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypt plain text data using RC2
+     *
+     * @param string $text A 64 bit (8 byte) plain text string
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->operation(parent::ENCRYPT);
+
+        // split up the message and key into 4 16 bit parts (2 byte words),
+        // then convert each array element to an integer
+        $w = self::splitBytes($text);
+        $k = self::splitBytes($this->xkey);
+        $j = 0; // the key index
+
+        for($i = 0; $i < 16; ++$i)
+        {
+            $j = $i * 4;
+
+            /* This is where it gets ugly, RC2 relies on unsigned ints. PHP does
 			 * not have a nice way to handle unsigned ints, so we have to rely on sprintf.
 			 * To make RC2 compatible with mCrypt, I also forced everything to 32 bit
 			 * When I test against mcrypt and the original rc2 C source, I get 32 bit
 			 * results, even on a 64 bit platform
 			 */
 
-			// 16 rounds of RC2's Mixing algorithm for each 2 byte 'word' as
-			// required by RC2
-			$w[0] += parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
-			$w[0]  = sprintf("%u", $w[0] << 1) + sprintf("%u", $w[0] >> 15 & 1);
-			$w[0]  = parent::uInt32($w[0]);
-
-			$w[1] += parent::uInt($w[2] & ~$w[0]) + parent::uInt($w[3] & $w[0]) + $k[$j + 1];
-			$w[1]  = parent::uInt($w[1] << 2) + parent::uInt($w[1] >> 14 & 3);
-			$w[1]  = parent::uInt32($w[1]);
-
-			$w[2] += parent::uInt($w[3] & ~$w[1]) + parent::uInt($w[0] & $w[1]) + $k[$j + 2];
-			$w[2]  = parent::uInt($w[2] << 3) + parent::uInt($w[2] >> 13 & 7);
-			$w[2]  = parent::uInt32($w[2]);
-
-			$w[3] += parent::uInt($w[0] & ~$w[2]) + parent::uInt($w[1] & $w[2]) + $k[$j + 3];
-			$w[3]  = parent::uInt($w[3] << 5) + parent::uInt($w[3] >> 11 & 31);
-			$w[3]  = parent::uInt32($w[3]);
-
-			// rounds 5 and 11 get rc2's Mash
-			if($i == 4 || $i == 10)
-			{
-				$w[0] += $k[$w[3] & 63];
-				$w[1] += $k[$w[0] & 63];
-				$w[2] += $k[$w[1] & 63];
-				$w[3] += $k[$w[2] & 63];
-			}
-		}
-
-		/* truthfully, I am not clear why this is required. It was not mentioned
+            // 16 rounds of RC2's Mixing algorithm for each 2 byte 'word' as
+            // required by RC2
+            $w[0] += parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
+            $w[0]  = sprintf("%u", $w[0] << 1) + sprintf("%u", $w[0] >> 15 & 1);
+            $w[0]  = parent::uInt32($w[0]);
+
+            $w[1] += parent::uInt($w[2] & ~$w[0]) + parent::uInt($w[3] & $w[0]) + $k[$j + 1];
+            $w[1]  = parent::uInt($w[1] << 2) + parent::uInt($w[1] >> 14 & 3);
+            $w[1]  = parent::uInt32($w[1]);
+
+            $w[2] += parent::uInt($w[3] & ~$w[1]) + parent::uInt($w[0] & $w[1]) + $k[$j + 2];
+            $w[2]  = parent::uInt($w[2] << 3) + parent::uInt($w[2] >> 13 & 7);
+            $w[2]  = parent::uInt32($w[2]);
+
+            $w[3] += parent::uInt($w[0] & ~$w[2]) + parent::uInt($w[1] & $w[2]) + $k[$j + 3];
+            $w[3]  = parent::uInt($w[3] << 5) + parent::uInt($w[3] >> 11 & 31);
+            $w[3]  = parent::uInt32($w[3]);
+
+            // rounds 5 and 11 get rc2's Mash
+            if($i == 4 || $i == 10)
+            {
+                $w[0] += $k[$w[3] & 63];
+                $w[1] += $k[$w[0] & 63];
+                $w[2] += $k[$w[1] & 63];
+                $w[3] += $k[$w[2] & 63];
+            }
+        }
+
+        /* truthfully, I am not clear why this is required. It was not mentioned
 		 * in any of the documentation I read, however reading the original RC2 C
 		 * source code, this was done and in order for me to get the
 		 * correct results in PHP I needed to do this as well
 		 */
-		$max = count($w);
-		for($i = 0; $i < $max; ++$i)
-		{
-			$pos = $i * 2;
-			$text[$pos]   = chr($w[$i]);
-			$text[$pos+1] = chr($w[$i] >> 8);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt a RC2 encrypted string
-	 *
-	 * @param string $text A RC2 encrypted string
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$this->operation(parent::DECRYPT);
-
-		// first split up the message into four 16 bit parts (2 bytes),
-		// then convert each array element to an integer
-		$w = self::splitBytes($text);
-		$k = self::splitBytes($this->xkey);
-		$j = 0; // the key index
-
-		for($i = 15; $i >= 0; --$i)
-		{
-			$j = $i * 4;
-
-			/* This is where it gets ugly, RC2 relies on unsigned ints. PHP does
+        $max = count($w);
+        for($i = 0; $i < $max; ++$i)
+        {
+            $pos = $i * 2;
+            $text[$pos]   = chr($w[$i]);
+            $text[$pos+1] = chr($w[$i] >> 8);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt a RC2 encrypted string
+     *
+     * @param string $text A RC2 encrypted string
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $this->operation(parent::DECRYPT);
+
+        // first split up the message into four 16 bit parts (2 bytes),
+        // then convert each array element to an integer
+        $w = self::splitBytes($text);
+        $k = self::splitBytes($this->xkey);
+        $j = 0; // the key index
+
+        for($i = 15; $i >= 0; --$i)
+        {
+            $j = $i * 4;
+
+            /* This is where it gets ugly, RC2 relies on unsigned ints. PHP does
 			 * not have a nice way to handle unsigned ints, so we have to rely on sprintf.
 			 * To make RC2 compatible with mCrypt, I also forced everything to 32 bit
 			 * When I test against mcrypt and the original rc2 C source, I get 32 bit
 			 * results, even on a 64 bit platform
 			 */
 
-			$w[3] &= 65535;
-			$w[3]  = parent::uInt($w[3] << 11) + parent::uInt($w[3] >> 5);
-			$w[3] -= parent::uInt($w[0] & ~$w[2]) + parent::uInt($w[1] & $w[2]) + $k[$j + 3];
-			$w[3]  = parent::uInt32($w[3]);
-
-			$w[2] &= 65535;
-			$w[2]  = parent::uInt($w[2] << 13) + parent::uInt($w[2] >> 3);
-			$w[2] -= parent::uInt($w[3] & ~$w[1]) + parent::uInt($w[0] & $w[1]) + $k[$j + 2];
-			$w[2]  = parent::uInt32($w[2]);
-
-			$w[1] &= 65535;
-			$w[1]  = parent::uInt($w[1] << 14) + parent::uInt($w[1] >> 2);
-			$w[1] -= parent::uInt($w[2] & ~$w[0]) + parent::uInt($w[3] & $w[0]) + $k[$j + 1];
-			$w[1]  = parent::uInt32($w[1]);
-
-			$w[0] &= 65535;
-			$w[0]  = parent::uInt($w[0] << 15) + parent::uInt($w[0] >> 1);
-			$w[0] -= parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
-			$w[0]  = parent::uInt32($w[0]);
-
-			if($i == 5 || $i == 11)
-			{
-				$w[3] -= $k[$w[2] & 63];
-				$w[2] -= $k[$w[1] & 63];
-				$w[1] -= $k[$w[0] & 63];
-				$w[0] -= $k[$w[3] & 63];
-			}
-		}
-
-
-		/* I am not clear why this is required. It was not mentioned
+            $w[3] &= 65535;
+            $w[3]  = parent::uInt($w[3] << 11) + parent::uInt($w[3] >> 5);
+            $w[3] -= parent::uInt($w[0] & ~$w[2]) + parent::uInt($w[1] & $w[2]) + $k[$j + 3];
+            $w[3]  = parent::uInt32($w[3]);
+
+            $w[2] &= 65535;
+            $w[2]  = parent::uInt($w[2] << 13) + parent::uInt($w[2] >> 3);
+            $w[2] -= parent::uInt($w[3] & ~$w[1]) + parent::uInt($w[0] & $w[1]) + $k[$j + 2];
+            $w[2]  = parent::uInt32($w[2]);
+
+            $w[1] &= 65535;
+            $w[1]  = parent::uInt($w[1] << 14) + parent::uInt($w[1] >> 2);
+            $w[1] -= parent::uInt($w[2] & ~$w[0]) + parent::uInt($w[3] & $w[0]) + $k[$j + 1];
+            $w[1]  = parent::uInt32($w[1]);
+
+            $w[0] &= 65535;
+            $w[0]  = parent::uInt($w[0] << 15) + parent::uInt($w[0] >> 1);
+            $w[0] -= parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
+            $w[0]  = parent::uInt32($w[0]);
+
+            if($i == 5 || $i == 11)
+            {
+                $w[3] -= $k[$w[2] & 63];
+                $w[2] -= $k[$w[1] & 63];
+                $w[1] -= $k[$w[0] & 63];
+                $w[0] -= $k[$w[3] & 63];
+            }
+        }
+
+
+        /* I am not clear why this is required. It was not mentioned
 		 * in any of the documentation I read, however reading the original RC2 C
 		 * source code, this was done and in order for me to get the
 		 * correct results in PHP I needed to do this as well
 		 */
-		$max = count($w);
-		for($i = 0; $i < $max; ++$i)
-		{
-			$pos = $i * 2;
-			$text[$pos]   = chr($w[$i]);
-			$text[$pos+1] = chr($w[$i] >> 8);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Splits an 8 byte string into four array elements of 2 bytes each, swaps the bytes
-	 * of each array element, and converts the result into an integer
-	 *
-	 * @param string $str The 8 byte string to split and convert
-	 * @return array An array of 4 elements, each with 2 bytes
-	 */
-	private static function splitBytes($str)
-	{
-		$arr = str_split($str, 2);
-
-		return array_map(function($b){
-			return Core::str2Dec($b[1].$b[0]);
-		}, $arr);
-	}
-
-
-	/**
-	 * Expands the key to 128 bits. RC2 uses an initial key size between
-	 * 8 - 128 bits, then takes the initial key and expands it out to 128
-	 * bits, which is used for encryption
-	 *
-	 * @return void
-	 */
-	private function expandKey()
-	{
-		// start by copying the key to the xkey variable
-		$this->xkey = $this->key();
-		$len = $this->keySize();
-
-		// the max length of the key is 128 bytes
-		if($len > 128)
-			$this->xkey = substr($this->xkey, 0, 128);
-
-		// now expanded the rest of the key to 128 bytes, using the sbox
-		for($i = $len; $i < 128; ++$i)
-		{
-			$byte1 = ord($this->xkey[$i - $len]);
-			$byte2 = ord($this->xkey[$i - 1]);
-			$pos = ($byte1 + $byte2);
-
-			// the sbox is only 255 bytes, so if we extend past that
-			// we need to modulo 256 so we have a valid position
-			if($pos > 255)
-				$pos -= 256;
-
-			$this->xkey .= chr(self::$_sbox[$pos]);
-		}
-
-		// now replace the first byte of the key with it's position in the sbox
-		$pos = ord($this->xkey[0]);
-		$this->xkey[0] = chr(self::$_sbox[$pos]);
-	}
-
-
-	/**
-	 * Initialize tables
-	 *
-	 * @return void
-	 */
-	private function initTables()
-	{
-		self::$_sbox = array(
-			0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
-			0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
-			0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,
-			0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,
-			0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,
-			0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,
-			0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,
-			0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,
-			0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,
-			0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,
-			0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,
-			0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,
-			0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,
-			0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,
-			0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,
-			0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad
-		);
-	}
-
-
-	/**
-	 * Indicates this is a block cipher
-	 *
-	 * @return integer Returns Cipher::BLOCK
-	 */
-	public function type()
-	{
-		return parent::BLOCK;
-	}
+        $max = count($w);
+        for($i = 0; $i < $max; ++$i)
+        {
+            $pos = $i * 2;
+            $text[$pos]   = chr($w[$i]);
+            $text[$pos+1] = chr($w[$i] >> 8);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Splits an 8 byte string into four array elements of 2 bytes each, swaps the bytes
+     * of each array element, and converts the result into an integer
+     *
+     * @param string $str The 8 byte string to split and convert
+     * @return array An array of 4 elements, each with 2 bytes
+     */
+    private static function splitBytes($str)
+    {
+        $arr = str_split($str, 2);
+
+        return array_map(function($b){
+            return Core::str2Dec($b[1].$b[0]);
+        }, $arr);
+    }
+
+
+    /**
+     * Expands the key to 128 bits. RC2 uses an initial key size between
+     * 8 - 128 bits, then takes the initial key and expands it out to 128
+     * bits, which is used for encryption
+     *
+     * @return void
+     */
+    private function expandKey()
+    {
+        // start by copying the key to the xkey variable
+        $this->xkey = $this->key();
+        $len = $this->keySize();
+
+        // the max length of the key is 128 bytes
+        if($len > 128)
+            $this->xkey = substr($this->xkey, 0, 128);
+
+        // now expanded the rest of the key to 128 bytes, using the sbox
+        for($i = $len; $i < 128; ++$i)
+        {
+            $byte1 = ord($this->xkey[$i - $len]);
+            $byte2 = ord($this->xkey[$i - 1]);
+            $pos = ($byte1 + $byte2);
+
+            // the sbox is only 255 bytes, so if we extend past that
+            // we need to modulo 256 so we have a valid position
+            if($pos > 255)
+                $pos -= 256;
+
+            $this->xkey .= chr(self::$_sbox[$pos]);
+        }
+
+        // now replace the first byte of the key with it's position in the sbox
+        $pos = ord($this->xkey[0]);
+        $this->xkey[0] = chr(self::$_sbox[$pos]);
+    }
+
+
+    /**
+     * Initialize tables
+     *
+     * @return void
+     */
+    private function initTables()
+    {
+        self::$_sbox = array(
+            0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
+            0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
+            0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,
+            0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,
+            0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,
+            0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,
+            0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,
+            0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,
+            0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,
+            0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,
+            0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,
+            0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,
+            0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,
+            0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,
+            0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,
+            0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad
+        );
+    }
+
+
+    /**
+     * Indicates this is a block cipher
+     *
+     * @return integer Returns Cipher::BLOCK
+     */
+    public function type()
+    {
+        return parent::BLOCK;
+    }
 }
 ?>

Spacing +13 added lines, -13 removed lines

@@ -68,7 +68,7 @@ 
 		// the key must be between 1 and 128 bytes, keys larger than
 		// 128 bytes are truncated in expandedKey()
 		$keylen = strlen($key);
-		if($keylen < 1)
+		if ($keylen < 1)
 		{
 			$err = "Key size is $keylen bits, Key size must be between 1 and 128 bytes";
 			trigger_error($err, E_USER_WARNING);
@@ -115,7 +115,7 @@ 
 		$k = self::splitBytes($this->xkey);
 		$j = 0; // the key index
 
-		for($i = 0; $i < 16; ++$i)
+		for ($i = 0; $i < 16; ++$i)
 		{
 			$j = $i * 4;
 
@@ -145,7 +145,7 @@ 
 			$w[3]  = parent::uInt32($w[3]);
 
 			// rounds 5 and 11 get rc2's Mash
-			if($i == 4 || $i == 10)
+			if ($i == 4 || $i == 10)
 			{
 				$w[0] += $k[$w[3] & 63];
 				$w[1] += $k[$w[0] & 63];
@@ -160,11 +160,11 @@ 
 		 * correct results in PHP I needed to do this as well
 		 */
 		$max = count($w);
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			$pos = $i * 2;
 			$text[$pos]   = chr($w[$i]);
-			$text[$pos+1] = chr($w[$i] >> 8);
+			$text[$pos + 1] = chr($w[$i] >> 8);
 		}
 
 		return true;
@@ -187,7 +187,7 @@ 
 		$k = self::splitBytes($this->xkey);
 		$j = 0; // the key index
 
-		for($i = 15; $i >= 0; --$i)
+		for ($i = 15; $i >= 0; --$i)
 		{
 			$j = $i * 4;
 
@@ -218,7 +218,7 @@ 
 			$w[0] -= parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
 			$w[0]  = parent::uInt32($w[0]);
 
-			if($i == 5 || $i == 11)
+			if ($i == 5 || $i == 11)
 			{
 				$w[3] -= $k[$w[2] & 63];
 				$w[2] -= $k[$w[1] & 63];
@@ -234,11 +234,11 @@ 
 		 * correct results in PHP I needed to do this as well
 		 */
 		$max = count($w);
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			$pos = $i * 2;
 			$text[$pos]   = chr($w[$i]);
-			$text[$pos+1] = chr($w[$i] >> 8);
+			$text[$pos + 1] = chr($w[$i] >> 8);
 		}
 
 		return true;
@@ -256,7 +256,7 @@ 
 	{
 		$arr = str_split($str, 2);
 
-		return array_map(function($b){
+		return array_map(function($b) {
 			return Core::str2Dec($b[1].$b[0]);
 		}, $arr);
 	}
@@ -276,11 +276,11 @@ 
 		$len = $this->keySize();
 
 		// the max length of the key is 128 bytes
-		if($len > 128)
+		if ($len > 128)
 			$this->xkey = substr($this->xkey, 0, 128);
 
 		// now expanded the rest of the key to 128 bytes, using the sbox
-		for($i = $len; $i < 128; ++$i)
+		for ($i = $len; $i < 128; ++$i)
 		{
 			$byte1 = ord($this->xkey[$i - $len]);
 			$byte2 = ord($this->xkey[$i - 1]);
@@ -288,7 +288,7 @@ 
 
 			// the sbox is only 255 bytes, so if we extend past that
 			// we need to modulo 256 so we have a valid position
-			if($pos > 255)
+			if ($pos > 255)
 				$pos -= 256;
 
 			$this->xkey .= chr(self::$_sbox[$pos]);

Braces +6 added lines, -4 removed lines

@@ -276,8 +276,9 @@ 
 		$len = $this->keySize();
 
 		// the max length of the key is 128 bytes
-		if($len > 128)
-			$this->xkey = substr($this->xkey, 0, 128);
+		if($len > 128) {
+					$this->xkey = substr($this->xkey, 0, 128);
+		}
 
 		// now expanded the rest of the key to 128 bytes, using the sbox
 		for($i = $len; $i < 128; ++$i)
@@ -288,8 +289,9 @@ 
 
 			// the sbox is only 255 bytes, so if we extend past that
 			// we need to modulo 256 so we have a valid position
-			if($pos > 255)
-				$pos -= 256;
+			if($pos > 255) {
+							$pos -= 256;
+			}
 
 			$this->xkey .= chr(self::$_sbox[$pos]);
 		}

includes/libraries/phpcrypt/ciphers/Rijndael192.php

Indentation +28 added lines, -28 removed lines

@@ -38,39 +38,39 @@
  */
 class Cipher_Rijndael_192 extends Cipher_Rijndael
 {
-	/** @type integer BYTES_BLOCK The size of the block, in bytes */
-	const BYTES_BLOCK = 24; // 192 bits
+    /** @type integer BYTES_BLOCK The size of the block, in bytes */
+    const BYTES_BLOCK = 24; // 192 bits
 
-	//const BITS_KEY = 0;
+    //const BITS_KEY = 0;
 
 
-	/**
-	 * Constructor
-	 * Sets the key used for encryption. Also sets the requied block size
-	 *
-	 * @param string $key string containing the user supplied encryption key
-	 * @return void
-	 */
-	public function __construct($key)
-	{
-		// Set up the key
-		parent::__construct(PHP_CRYPT::CIPHER_RIJNDAEL_192, $key);
+    /**
+     * Constructor
+     * Sets the key used for encryption. Also sets the requied block size
+     *
+     * @param string $key string containing the user supplied encryption key
+     * @return void
+     */
+    public function __construct($key)
+    {
+        // Set up the key
+        parent::__construct(PHP_CRYPT::CIPHER_RIJNDAEL_192, $key);
 
-		// required block size in bits
-		$this->blockSize(self::BYTES_BLOCK);
+        // required block size in bits
+        $this->blockSize(self::BYTES_BLOCK);
 
-		// expand the key now that we know the key size, and the bit size
-		$this->expandKey();
-	}
+        // expand the key now that we know the key size, and the bit size
+        $this->expandKey();
+    }
 
 
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 }

includes/libraries/phpcrypt/Cipher.php

Indentation +182 added lines, -182 removed lines

@@ -36,222 +36,222 @@
  */
 abstract class Cipher extends Core
 {
-	/** @type integer ENCRYPT Indicates when we are in encryption mode */
-	const ENCRYPT = 1;
+    /** @type integer ENCRYPT Indicates when we are in encryption mode */
+    const ENCRYPT = 1;
 
-	/** @type integer DECRYPT Indicates when we are in decryption mode */
-	const DECRYPT = 2;
+    /** @type integer DECRYPT Indicates when we are in decryption mode */
+    const DECRYPT = 2;
 
-	/** @type integer BLOCK Indicates that a cipher is a block cipher */
-	const BLOCK = 1;
+    /** @type integer BLOCK Indicates that a cipher is a block cipher */
+    const BLOCK = 1;
 
-	/** @type integer STREAM Indicates that a cipher is a stream cipher */
-	const STREAM = 2;
+    /** @type integer STREAM Indicates that a cipher is a stream cipher */
+    const STREAM = 2;
 
-	/** @type string $cipher_name Stores the name of the cipher */
-	protected $cipher_name = "";
+    /** @type string $cipher_name Stores the name of the cipher */
+    protected $cipher_name = "";
 
-	/** @type integer $block_size The block size of the cipher in bytes */
-	protected $block_size = 0;
+    /** @type integer $block_size The block size of the cipher in bytes */
+    protected $block_size = 0;
 
-	/**
-	 * @type integer $operation Indicates if a cipher is Encrypting or Decrypting
-	 * this can be set to either Cipher::ENCRYPT or Cipher::DECRYPT
-	 */
-	protected $operation = self::ENCRYPT; // can be either Cipher::ENCRYPT | Cipher::DECRYPT;
+    /**
+     * @type integer $operation Indicates if a cipher is Encrypting or Decrypting
+     * this can be set to either Cipher::ENCRYPT or Cipher::DECRYPT
+     */
+    protected $operation = self::ENCRYPT; // can be either Cipher::ENCRYPT | Cipher::DECRYPT;
 
-	/** @type string $key Stores the key for the Cipher */
-	private $key = "";
+    /** @type string $key Stores the key for the Cipher */
+    private $key = "";
 
-	/** @type integer $key_len Keep track of the key length, so we don't
+    /** @type integer $key_len Keep track of the key length, so we don't
 	have to make repeated calls to strlen() to find the length */
-	private $key_len = 0;
+    private $key_len = 0;
 
 
-	/**
-	 * Constructor
-	 *
-	 * @param string $name one of the predefined ciphers
-	 * @param string $key The key used for encryption
-	 * @param int Optional, the required size of a key for the cipher
-	 * @return void
-	 */
-	protected function __construct($name, $key = "", $required_key_sz = 0)
-	{
-		$this->name($name);
-		$this->key($key, $required_key_sz);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	protected function __destruct()
-	{
+    /**
+     * Constructor
+     *
+     * @param string $name one of the predefined ciphers
+     * @param string $key The key used for encryption
+     * @param int Optional, the required size of a key for the cipher
+     * @return void
+     */
+    protected function __construct($name, $key = "", $required_key_sz = 0)
+    {
+        $this->name($name);
+        $this->key($key, $required_key_sz);
+    }
+
 
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    protected function __destruct()
+    {
 
+    }
 
 
-	/**********************************************************************
+
+    /**********************************************************************
 	 * ABSTRACT METHODS
 	 *
 	 * The abstract methods required by inheriting classes to implement
 	 **********************************************************************/
 
-	/**
-	 * The cipher's encryption function. Must be defined
-	 * by the class inheriting this Cipher object. This function
-	 * will most often be called from within the Mode object
-	 *
-	 * @param string $text The text to be encrypted
-	 * @return boolean Always returns false
-	 */
-	abstract public function encrypt(&$text);
+    /**
+     * The cipher's encryption function. Must be defined
+     * by the class inheriting this Cipher object. This function
+     * will most often be called from within the Mode object
+     *
+     * @param string $text The text to be encrypted
+     * @return boolean Always returns false
+     */
+    abstract public function encrypt(&$text);
 
 
-	/**
-	 * The cipher's decryption function. Must be defined
-	 * by the class inheriting this Cipher object. This function
-	 * will most often be called from within the Mode object
-	 *
-	 * @param string $text The text to decrypt
-	 * @return boolean Always returns false
-	 */
-	abstract public function decrypt(&$text);
+    /**
+     * The cipher's decryption function. Must be defined
+     * by the class inheriting this Cipher object. This function
+     * will most often be called from within the Mode object
+     *
+     * @param string $text The text to decrypt
+     * @return boolean Always returns false
+     */
+    abstract public function decrypt(&$text);
 
 
-	/**
-	 * Indiciates whether the cipher is a block or stream cipher
-	 *
-	 * @return integer Returns either Cipher::BLOCK or Cipher::STREAM
-	 */
-	abstract public function type();
+    /**
+     * Indiciates whether the cipher is a block or stream cipher
+     *
+     * @return integer Returns either Cipher::BLOCK or Cipher::STREAM
+     */
+    abstract public function type();
 
 
 
 
-	/**********************************************************************
+    /**********************************************************************
 	 * PUBLIC METHODS
 	 *
 	 **********************************************************************/
 
-	/**
-	 * Determine if we are Encrypting or Decrypting
-	 * Since some ciphers use the same algorithm to Encrypt or Decrypt but with only
-	 * slight differences, we need a way to check if we are Encrypting or Decrypting
-	 * An example is DES, which uses the same algorithm except that when Decrypting
-	 * the sub_keys are reversed
-	 *
-	 * @param integer $op Sets the operation to Cipher::ENCRYPT or Cipher::DECRYPT
-	 * @return integer The current operation, either Cipher::ENCRYPT or Cipher::DECRYPT
-	 */
-	public function operation($op = 0)
-	{
-		if($op == self::ENCRYPT || $op == self::DECRYPT)
-			$this->operation = $op;
-
-		return $this->operation;
-	}
-
-
-	/**
-	 * Return the name of cipher that is currently being used
-	 *
-	 * @return string The cipher name
-	 */
-	public function name($name = "")
-	{
-		if($name != "")
-			$this->cipher_name = $name;
-
-		return $this->cipher_name;
-	}
-
-
-	/**
-	 * Size of the data in Bits that get used during encryption
-	 *
-	 * @param integer $bytes Number of bytes each block of data is required by the cipher
-	 * @return integer The number of bytes each block of data required by the cipher
-	 */
-	public function blockSize($bytes = 0)
-	{
-		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;
-
-		return $this->block_size;
-	}
-
-
-	/**
-	 * Returns the size (in bytes) required by the cipher.
-	 *
-	 * @return integer The number of bytes the cipher requires the key to be
-	 */
-	public function keySize()
-	{
-		return $this->key_len;
-	}
-
-
-	/**
-	 * Set the cipher key used for encryption/decryption. This function
-	 * may lengthen or shorten the key to meet the size requirements of
-	 * the cipher.
-	 *
-	 * If the $key parameter is not given, this function simply returns the
-	 * current key being used.
-	 *
-	 * @param string $key Optional, A key for the cipher
-	 * @param integer $req_sz The byte size required for the key
-	 * @return string They key, which may have been modified to fit size
-	 *	requirements
-	 */
-	public function key($key = "", $req_sz = 0)
-	{
-		if($key != "" && $key != null)
-		{
-			// in the case where the key is changed changed after
-			// creating a new Cipher object and the $req_sz was not
-			// 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($req_sz > 0)
-			{
-				if($this->key_len > $req_sz)
-				{
-					// shorten the key length
-					$key = substr($key, 0, $req_sz);
-					$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!!!!!
-					$msg = strtoupper($this->name())." requires a $req_sz byte key, {$this->key_len} bytes received";
-					trigger_error($msg, E_USER_WARNING);
+    /**
+     * Determine if we are Encrypting or Decrypting
+     * Since some ciphers use the same algorithm to Encrypt or Decrypt but with only
+     * slight differences, we need a way to check if we are Encrypting or Decrypting
+     * An example is DES, which uses the same algorithm except that when Decrypting
+     * the sub_keys are reversed
+     *
+     * @param integer $op Sets the operation to Cipher::ENCRYPT or Cipher::DECRYPT
+     * @return integer The current operation, either Cipher::ENCRYPT or Cipher::DECRYPT
+     */
+    public function operation($op = 0)
+    {
+        if($op == self::ENCRYPT || $op == self::DECRYPT)
+            $this->operation = $op;
+
+        return $this->operation;
+    }
+
+
+    /**
+     * Return the name of cipher that is currently being used
+     *
+     * @return string The cipher name
+     */
+    public function name($name = "")
+    {
+        if($name != "")
+            $this->cipher_name = $name;
+
+        return $this->cipher_name;
+    }
+
+
+    /**
+     * Size of the data in Bits that get used during encryption
+     *
+     * @param integer $bytes Number of bytes each block of data is required by the cipher
+     * @return integer The number of bytes each block of data required by the cipher
+     */
+    public function blockSize($bytes = 0)
+    {
+        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;
+
+        return $this->block_size;
+    }
+
+
+    /**
+     * Returns the size (in bytes) required by the cipher.
+     *
+     * @return integer The number of bytes the cipher requires the key to be
+     */
+    public function keySize()
+    {
+        return $this->key_len;
+    }
+
+
+    /**
+     * Set the cipher key used for encryption/decryption. This function
+     * may lengthen or shorten the key to meet the size requirements of
+     * the cipher.
+     *
+     * If the $key parameter is not given, this function simply returns the
+     * current key being used.
+     *
+     * @param string $key Optional, A key for the cipher
+     * @param integer $req_sz The byte size required for the key
+     * @return string They key, which may have been modified to fit size
+     *	requirements
+     */
+    public function key($key = "", $req_sz = 0)
+    {
+        if($key != "" && $key != null)
+        {
+            // in the case where the key is changed changed after
+            // creating a new Cipher object and the $req_sz was not
+            // 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($req_sz > 0)
+            {
+                if($this->key_len > $req_sz)
+                {
+                    // shorten the key length
+                    $key = substr($key, 0, $req_sz);
+                    $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!!!!!
+                    $msg = strtoupper($this->name())." requires a $req_sz byte key, {$this->key_len} bytes received";
+                    trigger_error($msg, E_USER_WARNING);
 					
-					return false;
-				}
-			}
+                    return false;
+                }
+            }
 
-			$this->key = $key;
-		}
+            $this->key = $key;
+        }
 
-		return $this->key;
-	}
+        return $this->key;
+    }
 }
 ?>

Spacing +9 added lines, -9 removed lines

@@ -150,7 +150,7 @@ 
 	 */
 	public function operation($op = 0)
 	{
-		if($op == self::ENCRYPT || $op == self::DECRYPT)
+		if ($op == self::ENCRYPT || $op == self::DECRYPT)
 			$this->operation = $op;
 
 		return $this->operation;
@@ -164,7 +164,7 @@ 
 	 */
 	public function name($name = "")
 	{
-		if($name != "")
+		if ($name != "")
 			$this->cipher_name = $name;
 
 		return $this->cipher_name;
@@ -179,12 +179,12 @@ 
 	 */
 	public function blockSize($bytes = 0)
 	{
-		if($bytes > 0)
+		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))
+		if (!isset($this->block_size))
 			return 0;
 
 		return $this->block_size;
@@ -217,27 +217,27 @@ 
 	 */
 	public function key($key = "", $req_sz = 0)
 	{
-		if($key != "" && $key != null)
+		if ($key != "" && $key != null)
 		{
 			// in the case where the key is changed changed after
 			// creating a new Cipher object and the $req_sz was not
 			// 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)
+			if ($this->key_len > 0 && $req_sz == 0)
 				$req_sz = $this->key_len;
 			else
 				$this->key_len = strlen($key);
 
-			if($req_sz > 0)
+			if ($req_sz > 0)
 			{
-				if($this->key_len > $req_sz)
+				if ($this->key_len > $req_sz)
 				{
 					// 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!!!!!

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/modes/CTR.php

Indentation +162 added lines, -162 removed lines

@@ -36,167 +36,167 @@
  */
 class Mode_CTR extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	function __construct($cipher)
-	{
-		parent::__construct(PHP_CRYPT::MODE_CTR, $cipher);
-
-		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("CTR mode requires a block cipher", E_USER_WARNING);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts an encrypted string
-	 *
-	 * @param string $text the string to be encrypted
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$len = strlen($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// get the current position in $text
-			$pos = $i * $blocksz;
-
-			// make sure we don't extend past the length of $text
-			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
-				$byte_len -= ($pos + $byte_len) - $len;
-
-			// encrypt the register
-			$this->enc_register = $this->register;
-			$this->cipher->encrypt($this->enc_register);
-
-			// grab a block of plain text
-			$block = substr($text, $pos, $byte_len);
-
-			// xor the block
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
-
-			// replace the plain text block with the encrypted block
-			$text = substr_replace($text, $block, $pos, $byte_len);
-
-			// increment the counter
-			$this->counter();
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypt an encrypted string
-	 *
-	 * @param string $text The string to be decrypted
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$len = strlen($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// get the current position in $text
-			$pos = $i * $blocksz;
-
-			// make sure we don't extend past the length of $text
-			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
-				$byte_len -= ($pos + $byte_len) - $len;
-
-			// encrypt the register
-			$this->enc_register = $this->register;
-			$this->cipher->encrypt($this->enc_register);
-
-			// grab a block of plain text
-			$block = substr($text, $pos, $byte_len);
-
-			// xor the block with the register (which contains the IV)
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
-
-			// replace the encrypted block with the plain text
-			$text = substr_replace($text, $block, $pos, $byte_len);
-
-			// increment the counter
-			$this->counter();
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * This mode requires an IV
-	 *
-	 * @return boolean True
-	 */
-	public function requiresIV()
-	{
-		return true;
-	}
-
-
-	/**
-	 * Increments the counter (which is initially the IV) by one byte starting at the
-	 * last byte. Once that byte has reached 0xff, it is then set to 0x00, and the
-	 * next byte is then incremented. On the following incrementation, the last byte
-	 * is incremented again. An example:
-	 * PASS 1:   2037e9ae63f73dfe
-	 * PASS 2:   2037e9ae63f73dff
-	 * PASS 3:   2037e9ae63f73e00
-	 * PASS 4:   2037e9ae63f73e01
-	 * ...
-	 * PASS N:   2100000000000001
-	 * PASS N+1: 2100000000000002
-	 *
-	 * @return void
-	 */
-	private function counter()
-	{
-		$pos = $this->cipher->blockSize() - 1;
-
-		// starting at the last byte, loop through each byte until
-		// we find one that can be incremented
-		for($i = $pos; $i >= 0; --$i)
-		{
-			// if we reached the last byte, set it to 0x00, then
-			// loop one more time to increment the next byte
-			if(ord($this->register[$i]) == 0xff)
-				$this->register[$i] = chr(0x00);
-			else
-			{
-				// now increment the byte by 1
-				$this->register[$i] = chr(ord($this->register[$i]) + 1);
-				break;
-			}
-		}
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    function __construct($cipher)
+    {
+        parent::__construct(PHP_CRYPT::MODE_CTR, $cipher);
+
+        // this works with only block Ciphers
+        if($cipher->type() != Cipher::BLOCK)
+            trigger_error("CTR mode requires a block cipher", E_USER_WARNING);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts an encrypted string
+     *
+     * @param string $text the string to be encrypted
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $len = strlen($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = $len / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // get the current position in $text
+            $pos = $i * $blocksz;
+
+            // make sure we don't extend past the length of $text
+            $byte_len = $blocksz;
+            if(($pos + $byte_len) > $len)
+                $byte_len -= ($pos + $byte_len) - $len;
+
+            // encrypt the register
+            $this->enc_register = $this->register;
+            $this->cipher->encrypt($this->enc_register);
+
+            // grab a block of plain text
+            $block = substr($text, $pos, $byte_len);
+
+            // xor the block
+            for($j = 0; $j < $byte_len; ++$j)
+                $block[$j] = $block[$j] ^ $this->enc_register[$j];
+
+            // replace the plain text block with the encrypted block
+            $text = substr_replace($text, $block, $pos, $byte_len);
+
+            // increment the counter
+            $this->counter();
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypt an encrypted string
+     *
+     * @param string $text The string to be decrypted
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $len = strlen($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = $len / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // get the current position in $text
+            $pos = $i * $blocksz;
+
+            // make sure we don't extend past the length of $text
+            $byte_len = $blocksz;
+            if(($pos + $byte_len) > $len)
+                $byte_len -= ($pos + $byte_len) - $len;
+
+            // encrypt the register
+            $this->enc_register = $this->register;
+            $this->cipher->encrypt($this->enc_register);
+
+            // grab a block of plain text
+            $block = substr($text, $pos, $byte_len);
+
+            // xor the block with the register (which contains the IV)
+            for($j = 0; $j < $byte_len; ++$j)
+                $block[$j] = $block[$j] ^ $this->enc_register[$j];
+
+            // replace the encrypted block with the plain text
+            $text = substr_replace($text, $block, $pos, $byte_len);
+
+            // increment the counter
+            $this->counter();
+        }
+
+        return true;
+    }
+
+
+    /**
+     * This mode requires an IV
+     *
+     * @return boolean True
+     */
+    public function requiresIV()
+    {
+        return true;
+    }
+
+
+    /**
+     * Increments the counter (which is initially the IV) by one byte starting at the
+     * last byte. Once that byte has reached 0xff, it is then set to 0x00, and the
+     * next byte is then incremented. On the following incrementation, the last byte
+     * is incremented again. An example:
+     * PASS 1:   2037e9ae63f73dfe
+     * PASS 2:   2037e9ae63f73dff
+     * PASS 3:   2037e9ae63f73e00
+     * PASS 4:   2037e9ae63f73e01
+     * ...
+     * PASS N:   2100000000000001
+     * PASS N+1: 2100000000000002
+     *
+     * @return void
+     */
+    private function counter()
+    {
+        $pos = $this->cipher->blockSize() - 1;
+
+        // starting at the last byte, loop through each byte until
+        // we find one that can be incremented
+        for($i = $pos; $i >= 0; --$i)
+        {
+            // if we reached the last byte, set it to 0x00, then
+            // loop one more time to increment the next byte
+            if(ord($this->register[$i]) == 0xff)
+                $this->register[$i] = chr(0x00);
+            else
+            {
+                // now increment the byte by 1
+                $this->register[$i] = chr(ord($this->register[$i]) + 1);
+                break;
+            }
+        }
+    }
 }
 ?>

Spacing +9 added lines, -9 removed lines

@@ -48,7 +48,7 @@ 
 		parent::__construct(PHP_CRYPT::MODE_CTR, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
+		if ($cipher->type() != Cipher::BLOCK)
 			trigger_error("CTR mode requires a block cipher", E_USER_WARNING);
 	}
 
@@ -76,14 +76,14 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// get the current position in $text
 			$pos = $i * $blocksz;
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
+			if (($pos + $byte_len) > $len)
 				$byte_len -= ($pos + $byte_len) - $len;
 
 			// encrypt the register
@@ -94,7 +94,7 @@ 
 			$block = substr($text, $pos, $byte_len);
 
 			// xor the block
-			for($j = 0; $j < $byte_len; ++$j)
+			for ($j = 0; $j < $byte_len; ++$j)
 				$block[$j] = $block[$j] ^ $this->enc_register[$j];
 
 			// replace the plain text block with the encrypted block
@@ -120,14 +120,14 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// get the current position in $text
 			$pos = $i * $blocksz;
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
+			if (($pos + $byte_len) > $len)
 				$byte_len -= ($pos + $byte_len) - $len;
 
 			// encrypt the register
@@ -138,7 +138,7 @@ 
 			$block = substr($text, $pos, $byte_len);
 
 			// xor the block with the register (which contains the IV)
-			for($j = 0; $j < $byte_len; ++$j)
+			for ($j = 0; $j < $byte_len; ++$j)
 				$block[$j] = $block[$j] ^ $this->enc_register[$j];
 
 			// replace the encrypted block with the plain text
@@ -184,11 +184,11 @@ 
 
 		// starting at the last byte, loop through each byte until
 		// we find one that can be incremented
-		for($i = $pos; $i >= 0; --$i)
+		for ($i = $pos; $i >= 0; --$i)
 		{
 			// if we reached the last byte, set it to 0x00, then
 			// loop one more time to increment the next byte
-			if(ord($this->register[$i]) == 0xff)
+			if (ord($this->register[$i]) == 0xff)
 				$this->register[$i] = chr(0x00);
 			else
 			{

Braces +18 added lines, -13 removed lines

@@ -48,8 +48,9 @@ 
 		parent::__construct(PHP_CRYPT::MODE_CTR, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("CTR mode requires a block cipher", E_USER_WARNING);
+		if($cipher->type() != Cipher::BLOCK) {
+					trigger_error("CTR mode requires a block cipher", E_USER_WARNING);
+		}
 	}
 
 
@@ -83,8 +84,9 @@ 
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
-				$byte_len -= ($pos + $byte_len) - $len;
+			if(($pos + $byte_len) > $len) {
+							$byte_len -= ($pos + $byte_len) - $len;
+			}
 
 			// encrypt the register
 			$this->enc_register = $this->register;
@@ -94,8 +96,9 @@ 
 			$block = substr($text, $pos, $byte_len);
 
 			// xor the block
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			for($j = 0; $j < $byte_len; ++$j) {
+							$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			}
 
 			// replace the plain text block with the encrypted block
 			$text = substr_replace($text, $block, $pos, $byte_len);
@@ -127,8 +130,9 @@ 
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
-				$byte_len -= ($pos + $byte_len) - $len;
+			if(($pos + $byte_len) > $len) {
+							$byte_len -= ($pos + $byte_len) - $len;
+			}
 
 			// encrypt the register
 			$this->enc_register = $this->register;
@@ -138,8 +142,9 @@ 
 			$block = substr($text, $pos, $byte_len);
 
 			// xor the block with the register (which contains the IV)
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			for($j = 0; $j < $byte_len; ++$j) {
+							$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			}
 
 			// replace the encrypted block with the plain text
 			$text = substr_replace($text, $block, $pos, $byte_len);
@@ -188,9 +193,9 @@ 
 		{
 			// if we reached the last byte, set it to 0x00, then
 			// loop one more time to increment the next byte
-			if(ord($this->register[$i]) == 0xff)
-				$this->register[$i] = chr(0x00);
-			else
+			if(ord($this->register[$i]) == 0xff) {
+							$this->register[$i] = chr(0x00);
+			} else
 			{
 				// now increment the byte by 1
 				$this->register[$i] = chr(ord($this->register[$i]) + 1);

includes/libraries/phpcrypt/modes/NOFB.php

Indentation +123 added lines, -123 removed lines

@@ -37,128 +37,128 @@
  */
 class Mode_NOFB extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	public function __construct($cipher)
-	{
-		parent::__construct(PHP_Crypt::MODE_NOFB, $cipher);
-
-		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("NOFB mode requires a block cipher", E_USER_WARNING);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts an the entire string $plain_text using the cipher passed
-	 *
-	 * @param string $text the string to be encrypted
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$len = strlen($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// current position in the text
-			$pos = $i * $blocksz;
-
-			// make sure we don't extend past the length of $text
-			$byte_len = $blocksz;
-			if(($pos + $blocksz) > $len)
-				$byte_len -= ($pos + $blocksz) - $len;
-
-			// encrypt the register
-			$this->enc_register = $this->register;
-			$this->cipher->encrypt($this->enc_register);
-
-			// now grab a block of text and a block of from the register, and XOR them
-			$block = substr($text, $pos, $byte_len);
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
-
-			// replace the plain text block with encrypted text
-			$text = substr_replace($text, $block, $pos, $byte_len);
-
-			// shift the register left n-bytes, append n-bytes of encrypted register
-			$this->register = substr($this->register, $byte_len);
-			$this->register .= substr($this->enc_register, 0, $byte_len);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypts an the entire string $plain_text using the cipher passed
-	 *
-	 * @param string $text the string to be decrypted
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$len = strlen($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// current position within $text
-			$pos = $i * $blocksz;
-
-			// make sure we don't extend past the length of $text
-			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
-				$byte_len -= ($pos + $byte_len) - $len;
-
-			// encrypt the register
-			$this->enc_register = $this->register;
-			$this->cipher->encrypt($this->enc_register);
-
-			// shift the register left n-bytes, append n-bytes of encrypted register
-			$this->register = substr($this->register, $byte_len);
-			$this->register .= substr($this->enc_register, 0, $byte_len);
-
-			// now grab a block of text and xor with the register
-			$block = substr($text, $pos, $byte_len);
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
-
-			// replace the encrypted block with plain text
-			$text = substr_replace($text, $block, $pos, $byte_len);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * This mode requires an IV
-	 *
-	 * @return boolean true
-	 */
-	public function requiresIV()
-	{
-		return true;
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    public function __construct($cipher)
+    {
+        parent::__construct(PHP_Crypt::MODE_NOFB, $cipher);
+
+        // this works with only block Ciphers
+        if($cipher->type() != Cipher::BLOCK)
+            trigger_error("NOFB mode requires a block cipher", E_USER_WARNING);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts an the entire string $plain_text using the cipher passed
+     *
+     * @param string $text the string to be encrypted
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $len = strlen($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = $len / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // current position in the text
+            $pos = $i * $blocksz;
+
+            // make sure we don't extend past the length of $text
+            $byte_len = $blocksz;
+            if(($pos + $blocksz) > $len)
+                $byte_len -= ($pos + $blocksz) - $len;
+
+            // encrypt the register
+            $this->enc_register = $this->register;
+            $this->cipher->encrypt($this->enc_register);
+
+            // now grab a block of text and a block of from the register, and XOR them
+            $block = substr($text, $pos, $byte_len);
+            for($j = 0; $j < $byte_len; ++$j)
+                $block[$j] = $block[$j] ^ $this->enc_register[$j];
+
+            // replace the plain text block with encrypted text
+            $text = substr_replace($text, $block, $pos, $byte_len);
+
+            // shift the register left n-bytes, append n-bytes of encrypted register
+            $this->register = substr($this->register, $byte_len);
+            $this->register .= substr($this->enc_register, 0, $byte_len);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypts an the entire string $plain_text using the cipher passed
+     *
+     * @param string $text the string to be decrypted
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $len = strlen($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = $len / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // current position within $text
+            $pos = $i * $blocksz;
+
+            // make sure we don't extend past the length of $text
+            $byte_len = $blocksz;
+            if(($pos + $byte_len) > $len)
+                $byte_len -= ($pos + $byte_len) - $len;
+
+            // encrypt the register
+            $this->enc_register = $this->register;
+            $this->cipher->encrypt($this->enc_register);
+
+            // shift the register left n-bytes, append n-bytes of encrypted register
+            $this->register = substr($this->register, $byte_len);
+            $this->register .= substr($this->enc_register, 0, $byte_len);
+
+            // now grab a block of text and xor with the register
+            $block = substr($text, $pos, $byte_len);
+            for($j = 0; $j < $byte_len; ++$j)
+                $block[$j] = $block[$j] ^ $this->enc_register[$j];
+
+            // replace the encrypted block with plain text
+            $text = substr_replace($text, $block, $pos, $byte_len);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * This mode requires an IV
+     *
+     * @return boolean true
+     */
+    public function requiresIV()
+    {
+        return true;
+    }
 }
 ?>

Spacing +7 added lines, -7 removed lines

@@ -49,7 +49,7 @@ 
 		parent::__construct(PHP_Crypt::MODE_NOFB, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
+		if ($cipher->type() != Cipher::BLOCK)
 			trigger_error("NOFB mode requires a block cipher", E_USER_WARNING);
 	}
 
@@ -77,14 +77,14 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// current position in the text
 			$pos = $i * $blocksz;
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $blocksz) > $len)
+			if (($pos + $blocksz) > $len)
 				$byte_len -= ($pos + $blocksz) - $len;
 
 			// encrypt the register
@@ -93,7 +93,7 @@ 
 
 			// now grab a block of text and a block of from the register, and XOR them
 			$block = substr($text, $pos, $byte_len);
-			for($j = 0; $j < $byte_len; ++$j)
+			for ($j = 0; $j < $byte_len; ++$j)
 				$block[$j] = $block[$j] ^ $this->enc_register[$j];
 
 			// replace the plain text block with encrypted text
@@ -120,14 +120,14 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = $len / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// current position within $text
 			$pos = $i * $blocksz;
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
+			if (($pos + $byte_len) > $len)
 				$byte_len -= ($pos + $byte_len) - $len;
 
 			// encrypt the register
@@ -140,7 +140,7 @@ 
 
 			// now grab a block of text and xor with the register
 			$block = substr($text, $pos, $byte_len);
-			for($j = 0; $j < $byte_len; ++$j)
+			for ($j = 0; $j < $byte_len; ++$j)
 				$block[$j] = $block[$j] ^ $this->enc_register[$j];
 
 			// replace the encrypted block with plain text

Braces +15 added lines, -10 removed lines

@@ -49,8 +49,9 @@ 
 		parent::__construct(PHP_Crypt::MODE_NOFB, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("NOFB mode requires a block cipher", E_USER_WARNING);
+		if($cipher->type() != Cipher::BLOCK) {
+					trigger_error("NOFB mode requires a block cipher", E_USER_WARNING);
+		}
 	}
 
 
@@ -84,8 +85,9 @@ 
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $blocksz) > $len)
-				$byte_len -= ($pos + $blocksz) - $len;
+			if(($pos + $blocksz) > $len) {
+							$byte_len -= ($pos + $blocksz) - $len;
+			}
 
 			// encrypt the register
 			$this->enc_register = $this->register;
@@ -93,8 +95,9 @@ 
 
 			// now grab a block of text and a block of from the register, and XOR them
 			$block = substr($text, $pos, $byte_len);
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			for($j = 0; $j < $byte_len; ++$j) {
+							$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			}
 
 			// replace the plain text block with encrypted text
 			$text = substr_replace($text, $block, $pos, $byte_len);
@@ -127,8 +130,9 @@ 
 
 			// make sure we don't extend past the length of $text
 			$byte_len = $blocksz;
-			if(($pos + $byte_len) > $len)
-				$byte_len -= ($pos + $byte_len) - $len;
+			if(($pos + $byte_len) > $len) {
+							$byte_len -= ($pos + $byte_len) - $len;
+			}
 
 			// encrypt the register
 			$this->enc_register = $this->register;
@@ -140,8 +144,9 @@ 
 
 			// now grab a block of text and xor with the register
 			$block = substr($text, $pos, $byte_len);
-			for($j = 0; $j < $byte_len; ++$j)
-				$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			for($j = 0; $j < $byte_len; ++$j) {
+							$block[$j] = $block[$j] ^ $this->enc_register[$j];
+			}
 
 			// replace the encrypted block with plain text
 			$text = substr_replace($text, $block, $pos, $byte_len);

includes/libraries/phpcrypt/modes/CBC.php

Indentation +127 added lines, -127 removed lines

@@ -36,132 +36,132 @@
  */
 class Mode_CBC extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	function __construct($cipher)
-	{
-		parent::__construct(PHP_Crypt::MODE_CBC, $cipher);
-
-		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("CBC mode requires a block cipher", E_USER_WARNING);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts an the entire string $plain_text using the cipher passed
-	 * to the constructor in CBC mode
-	 * The steps to encrypt using CBC are as follows
-	 * 1) Get a block of plain text data to use in the Cipher
-	 * 2) XOR the block with IV (if it's the first round) or the previous
-	 *	round's encrypted result
-	 * 3) Encrypt the block using the cipher
-	 * 4) Save the encrypted block to use in the next round
-	 *
-	 * @param string $text the string to be encrypted in CBC mode
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$this->pad($text);
-		$blocksz = $this->cipher->blockSize();
-
-		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// get the current position in $text
-			$pos = $i * $blocksz;
-
-			// grab a block of plain text
-			$block = substr($text, $pos, $blocksz);
-
-			// xor the block with the register
-			for($j = 0; $j < $blocksz; ++$j)
-				$block[$j] = $block[$j] ^ $this->register[$j];
-
-			// encrypt the block, and save it back to the register
-			$this->cipher->encrypt($block);
-			$this->register = $block;
-
-			// replace the plain text block with the cipher text
-			$text = substr_replace($text, $this->register, $pos, $blocksz);
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypts an the entire string $plain_text using the cipher passed
-	 * to the constructor in CBC mode
-	 * The decryption algorithm requires the following steps
-	 * 1) Get the first block of encrypted text, save it
-	 * 2) Decrypt the block
-	 * 3) XOR the decrypted block (if it's the first pass use the IV,
-	 *	else use the encrypted block from step 1
-	 * 4) the result from the XOR will be a plain text block, save it
-	 * 5) assign the encrypted block from step 1 to use in the next round
-	 *
-	 * @param string $text the string to be decrypted in CBC mode
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$blocksz = $this->cipher->blockSize();
-
-		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
-		{
-			// get the current position in $text
-			$pos = $i * $blocksz;
-
-			// grab a block of cipher text, and save it for use later
-			$block = substr($text, $pos, $blocksz);
-			$tmp_block = $block;
-
-			// decrypt the block of cipher text
-			$this->cipher->decrypt($block);
-
-			// xor the block with the register
-			for($j = 0; $j < $blocksz; ++$j)
-				$block[$j] = $block[$j] ^ $this->register[$j];
-
-			// replace the block of cipher text with plain text
-			$text = substr_replace($text, $block, $pos, $blocksz);
-
-			// save the cipher text block to the register
-			$this->register = $tmp_block;
-		}
-
-		$this->strip($text);
-		return true;
-	}
-
-
-	/**
-	 * This mode requires an IV
-	 *
-	 * @return boolean Returns True
-	 */
-	public function requiresIV()
-	{
-		return true;
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    function __construct($cipher)
+    {
+        parent::__construct(PHP_Crypt::MODE_CBC, $cipher);
+
+        // this works with only block Ciphers
+        if($cipher->type() != Cipher::BLOCK)
+            trigger_error("CBC mode requires a block cipher", E_USER_WARNING);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts an the entire string $plain_text using the cipher passed
+     * to the constructor in CBC mode
+     * The steps to encrypt using CBC are as follows
+     * 1) Get a block of plain text data to use in the Cipher
+     * 2) XOR the block with IV (if it's the first round) or the previous
+     *	round's encrypted result
+     * 3) Encrypt the block using the cipher
+     * 4) Save the encrypted block to use in the next round
+     *
+     * @param string $text the string to be encrypted in CBC mode
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $this->pad($text);
+        $blocksz = $this->cipher->blockSize();
+
+        $max = strlen($text) / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // get the current position in $text
+            $pos = $i * $blocksz;
+
+            // grab a block of plain text
+            $block = substr($text, $pos, $blocksz);
+
+            // xor the block with the register
+            for($j = 0; $j < $blocksz; ++$j)
+                $block[$j] = $block[$j] ^ $this->register[$j];
+
+            // encrypt the block, and save it back to the register
+            $this->cipher->encrypt($block);
+            $this->register = $block;
+
+            // replace the plain text block with the cipher text
+            $text = substr_replace($text, $this->register, $pos, $blocksz);
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypts an the entire string $plain_text using the cipher passed
+     * to the constructor in CBC mode
+     * The decryption algorithm requires the following steps
+     * 1) Get the first block of encrypted text, save it
+     * 2) Decrypt the block
+     * 3) XOR the decrypted block (if it's the first pass use the IV,
+     *	else use the encrypted block from step 1
+     * 4) the result from the XOR will be a plain text block, save it
+     * 5) assign the encrypted block from step 1 to use in the next round
+     *
+     * @param string $text the string to be decrypted in CBC mode
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $blocksz = $this->cipher->blockSize();
+
+        $max = strlen($text) / $blocksz;
+        for($i = 0; $i < $max; ++$i)
+        {
+            // get the current position in $text
+            $pos = $i * $blocksz;
+
+            // grab a block of cipher text, and save it for use later
+            $block = substr($text, $pos, $blocksz);
+            $tmp_block = $block;
+
+            // decrypt the block of cipher text
+            $this->cipher->decrypt($block);
+
+            // xor the block with the register
+            for($j = 0; $j < $blocksz; ++$j)
+                $block[$j] = $block[$j] ^ $this->register[$j];
+
+            // replace the block of cipher text with plain text
+            $text = substr_replace($text, $block, $pos, $blocksz);
+
+            // save the cipher text block to the register
+            $this->register = $tmp_block;
+        }
+
+        $this->strip($text);
+        return true;
+    }
+
+
+    /**
+     * This mode requires an IV
+     *
+     * @return boolean Returns True
+     */
+    public function requiresIV()
+    {
+        return true;
+    }
 }
 ?>

Spacing +5 added lines, -5 removed lines

@@ -48,7 +48,7 @@ 
 		parent::__construct(PHP_Crypt::MODE_CBC, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
+		if ($cipher->type() != Cipher::BLOCK)
 			trigger_error("CBC mode requires a block cipher", E_USER_WARNING);
 	}
 
@@ -83,7 +83,7 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// get the current position in $text
 			$pos = $i * $blocksz;
@@ -92,7 +92,7 @@ 
 			$block = substr($text, $pos, $blocksz);
 
 			// xor the block with the register
-			for($j = 0; $j < $blocksz; ++$j)
+			for ($j = 0; $j < $blocksz; ++$j)
 				$block[$j] = $block[$j] ^ $this->register[$j];
 
 			// encrypt the block, and save it back to the register
@@ -126,7 +126,7 @@ 
 		$blocksz = $this->cipher->blockSize();
 
 		$max = strlen($text) / $blocksz;
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			// get the current position in $text
 			$pos = $i * $blocksz;
@@ -139,7 +139,7 @@ 
 			$this->cipher->decrypt($block);
 
 			// xor the block with the register
-			for($j = 0; $j < $blocksz; ++$j)
+			for ($j = 0; $j < $blocksz; ++$j)
 				$block[$j] = $block[$j] ^ $this->register[$j];
 
 			// replace the block of cipher text with plain text

Braces +9 added lines, -6 removed lines

@@ -48,8 +48,9 @@ 
 		parent::__construct(PHP_Crypt::MODE_CBC, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("CBC mode requires a block cipher", E_USER_WARNING);
+		if($cipher->type() != Cipher::BLOCK) {
+					trigger_error("CBC mode requires a block cipher", E_USER_WARNING);
+		}
 	}
 
 
@@ -92,8 +93,9 @@ 
 			$block = substr($text, $pos, $blocksz);
 
 			// xor the block with the register
-			for($j = 0; $j < $blocksz; ++$j)
-				$block[$j] = $block[$j] ^ $this->register[$j];
+			for($j = 0; $j < $blocksz; ++$j) {
+							$block[$j] = $block[$j] ^ $this->register[$j];
+			}
 
 			// encrypt the block, and save it back to the register
 			$this->cipher->encrypt($block);
@@ -139,8 +141,9 @@ 
 			$this->cipher->decrypt($block);
 
 			// xor the block with the register
-			for($j = 0; $j < $blocksz; ++$j)
-				$block[$j] = $block[$j] ^ $this->register[$j];
+			for($j = 0; $j < $blocksz; ++$j) {
+							$block[$j] = $block[$j] ^ $this->register[$j];
+			}
 
 			// replace the block of cipher text with plain text
 			$text = substr_replace($text, $block, $pos, $blocksz);

includes/libraries/phpcrypt/modes/Stream.php

Indentation +24 added lines, -24 removed lines

@@ -38,32 +38,32 @@
  */
 class Mode_Stream extends Mode_Raw
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	public function __construct($cipher)
-	{
-		// call the secondary 'constructor' from the parent
-		parent::__construct1(PHP_Crypt::MODE_STREAM, $cipher);
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    public function __construct($cipher)
+    {
+        // call the secondary 'constructor' from the parent
+        parent::__construct1(PHP_Crypt::MODE_STREAM, $cipher);
 
-		// this works with only stream Ciphers
-		if($cipher->type() != Cipher::STREAM)
-			trigger_error("Stream mode requires a stream cipher", E_USER_WARNING);
-	}
+        // this works with only stream Ciphers
+        if($cipher->type() != Cipher::STREAM)
+            trigger_error("Stream mode requires a stream cipher", E_USER_WARNING);
+    }
 
 
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
 }
 ?>

Spacing +1 added lines, -1 removed lines

@@ -51,7 +51,7 @@
 		parent::__construct1(PHP_Crypt::MODE_STREAM, $cipher);
 
 		// this works with only stream Ciphers
-		if($cipher->type() != Cipher::STREAM)
+		if ($cipher->type() != Cipher::STREAM)
 			trigger_error("Stream mode requires a stream cipher", E_USER_WARNING);
 	}
 

Braces +3 added lines, -2 removed lines

@@ -51,8 +51,9 @@
 		parent::__construct1(PHP_Crypt::MODE_STREAM, $cipher);
 
 		// this works with only stream Ciphers
-		if($cipher->type() != Cipher::STREAM)
-			trigger_error("Stream mode requires a stream cipher", E_USER_WARNING);
+		if($cipher->type() != Cipher::STREAM) {
+					trigger_error("Stream mode requires a stream cipher", E_USER_WARNING);
+		}
 	}
 
 

includes/libraries/phpcrypt/modes/OFB.php

Indentation +86 added lines, -86 removed lines

@@ -36,91 +36,91 @@
  */
 class Mode_OFB extends Mode
 {
-	/**
-	 * Constructor
-	 * Sets the cipher object that will be used for encryption
-	 *
-	 * @param object $cipher one of the phpCrypt encryption cipher objects
-	 * @return void
-	 */
-	public function __construct($cipher)
-	{
-		parent::__construct(PHP_Crypt::MODE_OFB, $cipher);
-
-		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
-			trigger_error("OFB mode requires a block cipher", E_USER_WARNING);
-	}
-
-
-	/**
-	 * Destructor
-	 *
-	 * @return void
-	 */
-	public function __destruct()
-	{
-		parent::__destruct();
-	}
-
-
-	/**
-	 * Encrypts an the entire string $plain_text using the cipher passed
-	 *
-	 * @param string $text the string to be encrypted
-	 * @return boolean Returns true
-	 */
-	public function encrypt(&$text)
-	{
-		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
-		{
-			$this->enc_register = $this->register;
-			$this->cipher->encrypt($this->enc_register);
-			$text[$i] = $text[$i] ^ $this->enc_register[0];
-
-			// shift the register left
-			$this->register = substr($this->register, 1);
-			$this->register .= $this->enc_register[0];
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * Decrypts an the entire string $plain_text using the cipher passed
-	 *
-	 * @param string $text the string to be decrypted
-	 * @return boolean Returns true
-	 */
-	public function decrypt(&$text)
-	{
-		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
-		{
-			$this->enc_register = $this->register;
-			$this->cipher->encrypt($this->enc_register);
-
-			// shift the register left
-			$this->register = substr($this->register, 1);
-			$this->register .= $this->enc_register[0];
-
-			$text[$i] = $text[$i] ^ $this->enc_register[0];
-		}
-
-		return true;
-	}
-
-
-	/**
-	 * This mode requires an IV
-	 *
-	 * @return boolean true
-	 */
-	public function requiresIV()
-	{
-		return true;
-	}
+    /**
+     * Constructor
+     * Sets the cipher object that will be used for encryption
+     *
+     * @param object $cipher one of the phpCrypt encryption cipher objects
+     * @return void
+     */
+    public function __construct($cipher)
+    {
+        parent::__construct(PHP_Crypt::MODE_OFB, $cipher);
+
+        // this works with only block Ciphers
+        if($cipher->type() != Cipher::BLOCK)
+            trigger_error("OFB mode requires a block cipher", E_USER_WARNING);
+    }
+
+
+    /**
+     * Destructor
+     *
+     * @return void
+     */
+    public function __destruct()
+    {
+        parent::__destruct();
+    }
+
+
+    /**
+     * Encrypts an the entire string $plain_text using the cipher passed
+     *
+     * @param string $text the string to be encrypted
+     * @return boolean Returns true
+     */
+    public function encrypt(&$text)
+    {
+        $max = strlen($text);
+        for($i = 0; $i < $max; ++$i)
+        {
+            $this->enc_register = $this->register;
+            $this->cipher->encrypt($this->enc_register);
+            $text[$i] = $text[$i] ^ $this->enc_register[0];
+
+            // shift the register left
+            $this->register = substr($this->register, 1);
+            $this->register .= $this->enc_register[0];
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Decrypts an the entire string $plain_text using the cipher passed
+     *
+     * @param string $text the string to be decrypted
+     * @return boolean Returns true
+     */
+    public function decrypt(&$text)
+    {
+        $max = strlen($text);
+        for($i = 0; $i < $max; ++$i)
+        {
+            $this->enc_register = $this->register;
+            $this->cipher->encrypt($this->enc_register);
+
+            // shift the register left
+            $this->register = substr($this->register, 1);
+            $this->register .= $this->enc_register[0];
+
+            $text[$i] = $text[$i] ^ $this->enc_register[0];
+        }
+
+        return true;
+    }
+
+
+    /**
+     * This mode requires an IV
+     *
+     * @return boolean true
+     */
+    public function requiresIV()
+    {
+        return true;
+    }
 }
 ?>

Spacing +3 added lines, -3 removed lines

@@ -48,7 +48,7 @@ 
 		parent::__construct(PHP_Crypt::MODE_OFB, $cipher);
 
 		// this works with only block Ciphers
-		if($cipher->type() != Cipher::BLOCK)
+		if ($cipher->type() != Cipher::BLOCK)
 			trigger_error("OFB mode requires a block cipher", E_USER_WARNING);
 	}
 
@@ -73,7 +73,7 @@ 
 	public function encrypt(&$text)
 	{
 		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			$this->enc_register = $this->register;
 			$this->cipher->encrypt($this->enc_register);
@@ -97,7 +97,7 @@ 
 	public function decrypt(&$text)
 	{
 		$max = strlen($text);
-		for($i = 0; $i < $max; ++$i)
+		for ($i = 0; $i < $max; ++$i)
 		{
 			$this->enc_register = $this->register;
 			$this->cipher->encrypt($this->enc_register);

Braces +3 added lines, -2 removed lines

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