nilsteampassnet / TeamPass

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

Braces +28 added lines, -20 removed lines

@@ -99,17 +99,21 @@ 
 			$pos = (4 * $i) - 4;
 			$subkey = substr($this->expanded_key, $pos, 4);
 
-			if ($i >= 1 && $i <= 8)
-				$this->ruleA($text, $subkey, $i);
+			if ($i >= 1 && $i <= 8) {
+							$this->ruleA($text, $subkey, $i);
+			}
 
-			if ($i >= 9 && $i <= 16)
-				$this->ruleB($text, $subkey, $i);
+			if ($i >= 9 && $i <= 16) {
+							$this->ruleB($text, $subkey, $i);
+			}
 
-			if ($i >= 17 && $i <= 24)
-				$this->ruleA($text, $subkey, $i);
+			if ($i >= 17 && $i <= 24) {
+							$this->ruleA($text, $subkey, $i);
+			}
 
-			if ($i >= 25 && $i <= 32)
-				$this->ruleB($text, $subkey, $i);
+			if ($i >= 25 && $i <= 32) {
+							$this->ruleB($text, $subkey, $i);
+			}
 		}
 
 		return true;
@@ -130,17 +134,21 @@ 
 			$pos = ($i - 1) * 4;
 			$subkey = substr($this->expanded_key, $pos, 4);
 
-			if ($i <= 32 && $i >= 25)
-				$this->ruleB($text, $subkey, $i);
+			if ($i <= 32 && $i >= 25) {
+							$this->ruleB($text, $subkey, $i);
+			}
 
-			if ($i <= 24 && $i >= 17)
-				$this->ruleA($text, $subkey, $i);
+			if ($i <= 24 && $i >= 17) {
+							$this->ruleA($text, $subkey, $i);
+			}
 
-			if ($i <= 16 && $i >= 9)
-				$this->ruleB($text, $subkey, $i);
+			if ($i <= 16 && $i >= 9) {
+							$this->ruleB($text, $subkey, $i);
+			}
 
-			if ($i <= 8 && $i >= 1)
-				$this->ruleA($text, $subkey, $i);
+			if ($i <= 8 && $i >= 1) {
+							$this->ruleA($text, $subkey, $i);
+			}
 		}
 
 		return true;
@@ -289,8 +297,7 @@ 
 
             $w[1] = $this->gPermutation($w[0], $key);
             $w[0] = $w[4];
-        }
-        else // parent::DECRYPT
+        } else // parent::DECRYPT
         {
             /*
 			 * Set W4 as the old W0
@@ -335,8 +342,9 @@ 
 
         for($i = 0; $i < 128; ++$i)
         {
-            if($pos == $key_bytes)
-                $pos = 0;
+            if($pos == $key_bytes) {
+                            $pos = 0;
+            }
 
             $this->expanded_key .= $key[$pos];
             ++$pos;

includes/libraries/phpcrypt/ciphers/Vigenere.php

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/3DES.php

Braces +22 added lines, -13 removed lines

@@ -61,9 +61,9 @@ 
 	{
 		$key_len = strlen($key);
 
-		if ($key_len == 8 || $key_len == 16)
-			$key = self::expandKey($key, $key_len);
-		else if ($key_len < self::BYTES_KEY)
+		if ($key_len == 8 || $key_len == 16) {
+					$key = self::expandKey($key, $key_len);
+		} else if ($key_len < self::BYTES_KEY)
 		{
 			$msg  = PHP_Crypt::CIPHER_3DES." requires an 8, 16, or 24 byte key. ";
 			$msg .= "$key_len bytes received.";
@@ -109,10 +109,13 @@ 
 			$key = substr($this->key(), ($i * 8), $blocksz);
 			$this->keyPermutation($key);
 
-			if ($i % 2) // round 1
+			if ($i % 2) {
+			    // round 1
 				$this->operation(parent::DECRYPT);
-			else // rounds 0 and 2
+			} else {
+			    // rounds 0 and 2
 				$this->operation(parent::ENCRYPT);
+			}
 
 			$this->des($text);
 		}
@@ -138,10 +141,13 @@ 
 			$key = substr($this->key(), ($i * 8), $blocksz);
 			$this->keyPermutation($key);
 
-			if ($i % 2) // round 1
+			if ($i % 2) {
+			    // round 1
 				$this->operation(parent::ENCRYPT);
-			else // round 0 and 2
+			} else {
+			    // round 0 and 2
 				$this->operation(parent::DECRYPT);
+			}
 
 			$this->des($text);
 		}
@@ -210,8 +216,9 @@ 
 			// of these.
 			$CnDn = array_merge($c[$i], $d[$i]);
 			$this->sub_keys[$i - 1] = "";
-			for ($j = 0; $j < 48; ++$j)
-				$this->sub_keys[$i - 1] .= $CnDn[parent::$_pc2[$j] - 1];
+			for ($j = 0; $j < 48; ++$j) {
+							$this->sub_keys[$i - 1] .= $CnDn[parent::$_pc2[$j] - 1];
+			}
 		}
 
 		// the sub_keys are created, we are done with the key permutation
@@ -235,13 +242,15 @@ 
 	{
 		// if we were given an 8 byte key, repeat it
 		// 3 times to produce a 24 byte key
-		if ($len == 8)
-			$key = str_repeat($key, 3);
+		if ($len == 8) {
+					$key = str_repeat($key, 3);
+		}
 
 		// if we were given a 16 byte key, add the first
 		// 8 bytes to the end of the key to produce 24 bytes
-		if ($len == 16)
-			$key .= substr($key, 0, 8);
+		if ($len == 16) {
+					$key .= substr($key, 0, 8);
+		}
 
 		// return the key
 		return $key;

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

Braces +7 added lines, -6 removed lines

@@ -92,8 +92,7 @@ 
 		{
 			$key = substr($key, 0, self::BYTES_KEY_MAX);
 			$keylen = self::BYTES_KEY_MAX;
-		}
-		else if ($keylen < self::BYTES_KEY_MIN)
+		} else if ($keylen < self::BYTES_KEY_MIN)
 		{
 			$msg  = PHP_Crypt::CIPHER_CAST_128." requires a key size between ";
 			$msg .= "5 - 16 bytes.";
@@ -341,8 +340,9 @@ 
 
 		// the max length of the key is 16 bytes, however if it is
 		// less, pad it with null to get ito to 16 bytes
-		if ($this->keySize() < self::BYTES_KEY_MAX)
-			$x = str_pad($x, self::BYTES_KEY_MAX, "\0", STR_PAD_RIGHT);
+		if ($this->keySize() < self::BYTES_KEY_MAX) {
+					$x = str_pad($x, self::BYTES_KEY_MAX, "\0", STR_PAD_RIGHT);
+		}
 
 		/*
 		 * NOW FOR THE UGLY PART, THIS IS TAKEN FROM PAGE 3-4 OF
@@ -639,8 +639,9 @@ 
 
 		// there is 4kb in the s5 - s8 sboxes, which are not needed after we
 		// create the subkeys, so free up the memory. unset() doesn't work here
-		for ($i = 5; $i <= 8; ++$i)
-			self::${"_s$i"} = null;
+		for ($i = 5; $i <= 8; ++$i) {
+					self::${"_s$i"} = null;
+		}
 	}
 
 

includes/libraries/phpcrypt/Core.php

Braces +70 added lines, -55 removed lines

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

includes/libraries/phpcrypt/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!!!!!