nilsteampassnet / TeamPass

includes/libraries/Authentication/agses/axs/axs/code2gif.php

Indentation +53 added lines, -53 removed lines

@@ -43,73 +43,73 @@
      *                 created gif files by almost 50%.
      */
 
-	// path to data files
-	$path = './images_gif';
+    // path to data files
+    $path = './images_gif';
 	
-	// get code from GET request, use dummy pattern if code not defined
-	$code = isset($_GET['code']) ? $_GET['code'] : '20100804020102040810';
+    // get code from GET request, use dummy pattern if code not defined
+    $code = isset($_GET['code']) ? $_GET['code'] : '20100804020102040810';
 
-	// get frame delay from GET request, default to "safe speed" if delay not
-	// defined or invalid. delay is specified in ms in the request and needs
-	// to be converted to 1/100s for use in GIF files
-	$delay = isset($_GET['delay']) ? ($_GET['delay']+0)/10 : 8;
-	$delay = ($delay > 0) ? $delay : 8;
+    // get frame delay from GET request, default to "safe speed" if delay not
+    // defined or invalid. delay is specified in ms in the request and needs
+    // to be converted to 1/100s for use in GIF files
+    $delay = isset($_GET['delay']) ? ($_GET['delay']+0)/10 : 8;
+    $delay = ($delay > 0) ? $delay : 8;
 
-	// code string must only contain hex characters, code length is limited to
-	// 1024 characters (512 frames)
-	$codelen = strlen($code);
-	if ( ctype_xdigit($code) && $codelen < 1024 ) {
+    // code string must only contain hex characters, code length is limited to
+    // 1024 characters (512 frames)
+    $codelen = strlen($code);
+    if ( ctype_xdigit($code) && $codelen < 1024 ) {
 	
-		// get prepared gif file header
-		$gif  = file_get_contents($path.'/head.bin');
+        // get prepared gif file header
+        $gif  = file_get_contents($path.'/head.bin');
 		
-		// build graphic control extension block
-		// disposal method   = 0
-		// transparent color = 255
-		$ext = "\x21\xf9\x04\x01".chr($delay&0xff).chr(($delay>>8)&0xff)."\xff\x00";
+        // build graphic control extension block
+        // disposal method   = 0
+        // transparent color = 255
+        $ext = "\x21\xf9\x04\x01".chr($delay&0xff).chr(($delay>>8)&0xff)."\xff\x00";
 		
-		// output image header
-		header('Content-type:image/gif');
-		print($gif);
+        // output image header
+        header('Content-type:image/gif');
+        print($gif);
 	
-		// append image data blocks as necessary
-		$size = filesize($path.'/data.bin');
-		$data = fopen($path.'/data.bin','r');
-		if ($data) {
+        // append image data blocks as necessary
+        $size = filesize($path.'/data.bin');
+        $data = fopen($path.'/data.bin','r');
+        if ($data) {
 
-			// load the index from the data file and unpack it into a PHP array.
-			// the index array contains the file offsets of the 4096 delta and
-			// base images inside the data file.
-			$index = unpack("V*", fread($data, 64*64*4));
+            // load the index from the data file and unpack it into a PHP array.
+            // the index array contains the file offsets of the 4096 delta and
+            // base images inside the data file.
+            $index = unpack("V*", fread($data, 64*64*4));
 
-			// when a code is repeated (prev and curr have the same value) a
-			// base image is inserted instead of a delta image. the first frame
-			// in the animation must be a base image, so we peek at the flicker
-			// code and set $prev to the first value in the string
-			$prev = hexdec(substr($code, 0, 2));
-			for ($i = 0; $i < $codelen; $i+=2) {
+            // when a code is repeated (prev and curr have the same value) a
+            // base image is inserted instead of a delta image. the first frame
+            // in the animation must be a base image, so we peek at the flicker
+            // code and set $prev to the first value in the string
+            $prev = hexdec(substr($code, 0, 2));
+            for ($i = 0; $i < $codelen; $i+=2) {
 
-				// get current code
-				$curr = hexdec(substr($code, $i, 2));
+                // get current code
+                $curr = hexdec(substr($code, $i, 2));
 						
-				// locate image block in data file
-				$blockIdx = $prev*64+$curr+1;	// array starts at 1
-				$blockPos = $index[$blockIdx];
-				$blockLen = ($blockIdx < 4096 ? $index[$blockIdx+1] : $size) - $blockPos;
+                // locate image block in data file
+                $blockIdx = $prev*64+$curr+1;	// array starts at 1
+                $blockPos = $index[$blockIdx];
+                $blockLen = ($blockIdx < 4096 ? $index[$blockIdx+1] : $size) - $blockPos;
 				
-				// output extension header
-				print($ext);
+                // output extension header
+                print($ext);
 
-				// output image block
-				fseek($data, $blockPos);
-				print(fread($data, $blockLen));
+                // output image block
+                fseek($data, $blockPos);
+                print(fread($data, $blockLen));
 			
-				$prev = $curr;
-			}
+                $prev = $curr;
+            }
 
-			// file terminator
-			print(";");
-		}
-	}
+            // file terminator
+            print(";");
+        }
+    }
     /******/
 ?>
\ No newline at end of file

Spacing +9 added lines, -9 removed lines

@@ -52,21 +52,21 @@ 
 	// get frame delay from GET request, default to "safe speed" if delay not
 	// defined or invalid. delay is specified in ms in the request and needs
 	// to be converted to 1/100s for use in GIF files
-	$delay = isset($_GET['delay']) ? ($_GET['delay']+0)/10 : 8;
+	$delay = isset($_GET['delay']) ? ($_GET['delay'] + 0) / 10 : 8;
 	$delay = ($delay > 0) ? $delay : 8;
 
 	// code string must only contain hex characters, code length is limited to
 	// 1024 characters (512 frames)
 	$codelen = strlen($code);
-	if ( ctype_xdigit($code) && $codelen < 1024 ) {
+	if (ctype_xdigit($code) && $codelen < 1024) {
 	
 		// get prepared gif file header
-		$gif  = file_get_contents($path.'/head.bin');
+		$gif = file_get_contents($path.'/head.bin');
 		
 		// build graphic control extension block
 		// disposal method   = 0
 		// transparent color = 255
-		$ext = "\x21\xf9\x04\x01".chr($delay&0xff).chr(($delay>>8)&0xff)."\xff\x00";
+		$ext = "\x21\xf9\x04\x01".chr($delay & 0xff).chr(($delay >> 8) & 0xff)."\xff\x00";
 		
 		// output image header
 		header('Content-type:image/gif');
@@ -74,28 +74,28 @@ 
 	
 		// append image data blocks as necessary
 		$size = filesize($path.'/data.bin');
-		$data = fopen($path.'/data.bin','r');
+		$data = fopen($path.'/data.bin', 'r');
 		if ($data) {
 
 			// load the index from the data file and unpack it into a PHP array.
 			// the index array contains the file offsets of the 4096 delta and
 			// base images inside the data file.
-			$index = unpack("V*", fread($data, 64*64*4));
+			$index = unpack("V*", fread($data, 64 * 64 * 4));
 
 			// when a code is repeated (prev and curr have the same value) a
 			// base image is inserted instead of a delta image. the first frame
 			// in the animation must be a base image, so we peek at the flicker
 			// code and set $prev to the first value in the string
 			$prev = hexdec(substr($code, 0, 2));
-			for ($i = 0; $i < $codelen; $i+=2) {
+			for ($i = 0; $i < $codelen; $i += 2) {
 
 				// get current code
 				$curr = hexdec(substr($code, $i, 2));
 						
 				// locate image block in data file
-				$blockIdx = $prev*64+$curr+1;	// array starts at 1
+				$blockIdx = $prev * 64 + $curr + 1; // array starts at 1
 				$blockPos = $index[$blockIdx];
-				$blockLen = ($blockIdx < 4096 ? $index[$blockIdx+1] : $size) - $blockPos;
+				$blockLen = ($blockIdx < 4096 ? $index[$blockIdx + 1] : $size) - $blockPos;
 				
 				// output extension header
 				print($ext);

includes/libraries/Authentication/phpseclib/Crypt/TripleDES.php

Spacing +7 added lines, -7 removed lines

@@ -191,7 +191,7 @@ 
         if ($engine == self::ENGINE_OPENSSL) {
             $this->cipher_name_openssl_ecb = 'des-ede3';
             $mode = $this->_openssl_translate_mode();
-            $this->cipher_name_openssl = $mode == 'ecb' ? 'des-ede3' : 'des-ede3-' . $mode;
+            $this->cipher_name_openssl = $mode == 'ecb' ? 'des-ede3' : 'des-ede3-'.$mode;
         }
 
         return parent::isValidEngine($engine);
@@ -235,7 +235,7 @@ 
             case 192:
                 break;
             default:
-                throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys of sizes 128 or 192 bits are supported');
+                throw new \LengthException('Key size of '.$length.' bits is not supported by this algorithm. Only keys of sizes 128 or 192 bits are supported');
         }
 
         parent::setKeyLength($length);
@@ -257,16 +257,16 @@ 
     function setKey($key)
     {
         if ($this->explicit_key_length !== false && strlen($key) != $this->explicit_key_length) {
-            throw new \LengthException('Key length has already been set to ' . $this->explicit_key_length . ' bytes and this key is ' . strlen($key) . ' bytes');
+            throw new \LengthException('Key length has already been set to '.$this->explicit_key_length.' bytes and this key is '.strlen($key).' bytes');
         }
 
         switch (strlen($key)) {
             case 16:
-                $key.= substr($key, 0, 8);
+                $key .= substr($key, 0, 8);
             case 24:
                 break;
             default:
-                throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of sizes 16 or 24 are supported');
+                throw new \LengthException('Key of size '.strlen($key).' not supported by this algorithm. Only keys of sizes 16 or 24 are supported');
         }
 
         // copied from self::setKey()
@@ -276,8 +276,8 @@ 
         $this->_setEngine();
 
         if ($this->mode_3cbc) {
-            $this->des[0]->setKey(substr($key,  0, 8));
-            $this->des[1]->setKey(substr($key,  8, 8));
+            $this->des[0]->setKey(substr($key, 0, 8));
+            $this->des[1]->setKey(substr($key, 8, 8));
             $this->des[2]->setKey(substr($key, 16, 8));
         }
     }

includes/libraries/Authentication/phpseclib/Crypt/Twofish.php

Indentation +53 added lines, -53 removed lines

@@ -464,13 +464,13 @@ 
                 list($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[3], $le_longs[4]);
                 for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
                     $A = $m0[$q0[$q0[$i] ^ $key[ 9]] ^ $key[1]] ^
-                         $m1[$q0[$q1[$i] ^ $key[10]] ^ $key[2]] ^
-                         $m2[$q1[$q0[$i] ^ $key[11]] ^ $key[3]] ^
-                         $m3[$q1[$q1[$i] ^ $key[12]] ^ $key[4]];
+                            $m1[$q0[$q1[$i] ^ $key[10]] ^ $key[2]] ^
+                            $m2[$q1[$q0[$i] ^ $key[11]] ^ $key[3]] ^
+                            $m3[$q1[$q1[$i] ^ $key[12]] ^ $key[4]];
                     $B = $m0[$q0[$q0[$j] ^ $key[13]] ^ $key[5]] ^
-                         $m1[$q0[$q1[$j] ^ $key[14]] ^ $key[6]] ^
-                         $m2[$q1[$q0[$j] ^ $key[15]] ^ $key[7]] ^
-                         $m3[$q1[$q1[$j] ^ $key[16]] ^ $key[8]];
+                            $m1[$q0[$q1[$j] ^ $key[14]] ^ $key[6]] ^
+                            $m2[$q1[$q0[$j] ^ $key[15]] ^ $key[7]] ^
+                            $m3[$q1[$q1[$j] ^ $key[16]] ^ $key[8]];
                     $B = ($B << 8) | ($B >> 24 & 0xff);
                     $K[] = $A+= $B;
                     $K[] = (($A+= $B) << 9 | $A >> 23 & 0x1ff);
@@ -488,13 +488,13 @@ 
                 list($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[5], $le_longs[6]);
                 for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
                     $A = $m0[$q0[$q0[$q1[$i] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^
-                         $m1[$q0[$q1[$q1[$i] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
-                         $m2[$q1[$q0[$q0[$i] ^ $key[19]] ^ $key[11]] ^ $key[3]] ^
-                         $m3[$q1[$q1[$q0[$i] ^ $key[20]] ^ $key[12]] ^ $key[4]];
+                            $m1[$q0[$q1[$q1[$i] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
+                            $m2[$q1[$q0[$q0[$i] ^ $key[19]] ^ $key[11]] ^ $key[3]] ^
+                            $m3[$q1[$q1[$q0[$i] ^ $key[20]] ^ $key[12]] ^ $key[4]];
                     $B = $m0[$q0[$q0[$q1[$j] ^ $key[21]] ^ $key[13]] ^ $key[5]] ^
-                         $m1[$q0[$q1[$q1[$j] ^ $key[22]] ^ $key[14]] ^ $key[6]] ^
-                         $m2[$q1[$q0[$q0[$j] ^ $key[23]] ^ $key[15]] ^ $key[7]] ^
-                         $m3[$q1[$q1[$q0[$j] ^ $key[24]] ^ $key[16]] ^ $key[8]];
+                            $m1[$q0[$q1[$q1[$j] ^ $key[22]] ^ $key[14]] ^ $key[6]] ^
+                            $m2[$q1[$q0[$q0[$j] ^ $key[23]] ^ $key[15]] ^ $key[7]] ^
+                            $m3[$q1[$q1[$q0[$j] ^ $key[24]] ^ $key[16]] ^ $key[8]];
                     $B = ($B << 8) | ($B >> 24 & 0xff);
                     $K[] = $A+= $B;
                     $K[] = (($A+= $B) << 9 | $A >> 23 & 0x1ff);
@@ -513,13 +513,13 @@ 
                 list($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[7], $le_longs[8]);
                 for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
                     $A = $m0[$q0[$q0[$q1[$q1[$i] ^ $key[25]] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^
-                         $m1[$q0[$q1[$q1[$q0[$i] ^ $key[26]] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
-                         $m2[$q1[$q0[$q0[$q0[$i] ^ $key[27]] ^ $key[19]] ^ $key[11]] ^ $key[3]] ^
-                         $m3[$q1[$q1[$q0[$q1[$i] ^ $key[28]] ^ $key[20]] ^ $key[12]] ^ $key[4]];
+                            $m1[$q0[$q1[$q1[$q0[$i] ^ $key[26]] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
+                            $m2[$q1[$q0[$q0[$q0[$i] ^ $key[27]] ^ $key[19]] ^ $key[11]] ^ $key[3]] ^
+                            $m3[$q1[$q1[$q0[$q1[$i] ^ $key[28]] ^ $key[20]] ^ $key[12]] ^ $key[4]];
                     $B = $m0[$q0[$q0[$q1[$q1[$j] ^ $key[29]] ^ $key[21]] ^ $key[13]] ^ $key[5]] ^
-                         $m1[$q0[$q1[$q1[$q0[$j] ^ $key[30]] ^ $key[22]] ^ $key[14]] ^ $key[6]] ^
-                         $m2[$q1[$q0[$q0[$q0[$j] ^ $key[31]] ^ $key[23]] ^ $key[15]] ^ $key[7]] ^
-                         $m3[$q1[$q1[$q0[$q1[$j] ^ $key[32]] ^ $key[24]] ^ $key[16]] ^ $key[8]];
+                            $m1[$q0[$q1[$q1[$q0[$j] ^ $key[30]] ^ $key[22]] ^ $key[14]] ^ $key[6]] ^
+                            $m2[$q1[$q0[$q0[$q0[$j] ^ $key[31]] ^ $key[23]] ^ $key[15]] ^ $key[7]] ^
+                            $m3[$q1[$q1[$q0[$q1[$j] ^ $key[32]] ^ $key[24]] ^ $key[16]] ^ $key[8]];
                     $B = ($B << 8) | ($B >> 24 & 0xff);
                     $K[] = $A+= $B;
                     $K[] = (($A+= $B) << 9 | $A >> 23 & 0x1ff);
@@ -611,25 +611,25 @@ 
         $ki = 7;
         while ($ki < 39) {
             $t0 = $S0[ $R0        & 0xff] ^
-                  $S1[($R0 >>  8) & 0xff] ^
-                  $S2[($R0 >> 16) & 0xff] ^
-                  $S3[($R0 >> 24) & 0xff];
+                    $S1[($R0 >>  8) & 0xff] ^
+                    $S2[($R0 >> 16) & 0xff] ^
+                    $S3[($R0 >> 24) & 0xff];
             $t1 = $S0[($R1 >> 24) & 0xff] ^
-                  $S1[ $R1        & 0xff] ^
-                  $S2[($R1 >>  8) & 0xff] ^
-                  $S3[($R1 >> 16) & 0xff];
+                    $S1[ $R1        & 0xff] ^
+                    $S2[($R1 >>  8) & 0xff] ^
+                    $S3[($R1 >> 16) & 0xff];
             $R2^= $t0 + $t1 + $K[++$ki];
             $R2 = ($R2 >> 1 & 0x7fffffff) | ($R2 << 31);
             $R3 = ((($R3 >> 31) & 1) | ($R3 << 1)) ^ ($t0 + ($t1 << 1) + $K[++$ki]);
 
             $t0 = $S0[ $R2        & 0xff] ^
-                  $S1[($R2 >>  8) & 0xff] ^
-                  $S2[($R2 >> 16) & 0xff] ^
-                  $S3[($R2 >> 24) & 0xff];
+                    $S1[($R2 >>  8) & 0xff] ^
+                    $S2[($R2 >> 16) & 0xff] ^
+                    $S3[($R2 >> 24) & 0xff];
             $t1 = $S0[($R3 >> 24) & 0xff] ^
-                  $S1[ $R3        & 0xff] ^
-                  $S2[($R3 >>  8) & 0xff] ^
-                  $S3[($R3 >> 16) & 0xff];
+                    $S1[ $R3        & 0xff] ^
+                    $S2[($R3 >>  8) & 0xff] ^
+                    $S3[($R3 >> 16) & 0xff];
             $R0^= ($t0 + $t1 + $K[++$ki]);
             $R0 = ($R0 >> 1 & 0x7fffffff) | ($R0 << 31);
             $R1 = ((($R1 >> 31) & 1) | ($R1 << 1)) ^ ($t0 + ($t1 << 1) + $K[++$ki]);
@@ -637,9 +637,9 @@ 
 
         // @codingStandardsIgnoreStart
         return pack("V4", $K[4] ^ $R2,
-                          $K[5] ^ $R3,
-                          $K[6] ^ $R0,
-                          $K[7] ^ $R1);
+                            $K[5] ^ $R3,
+                            $K[6] ^ $R0,
+                            $K[7] ^ $R1);
         // @codingStandardsIgnoreEnd
     }
 
@@ -667,25 +667,25 @@ 
         $ki = 40;
         while ($ki > 8) {
             $t0 = $S0[$R0       & 0xff] ^
-                  $S1[$R0 >>  8 & 0xff] ^
-                  $S2[$R0 >> 16 & 0xff] ^
-                  $S3[$R0 >> 24 & 0xff];
+                    $S1[$R0 >>  8 & 0xff] ^
+                    $S2[$R0 >> 16 & 0xff] ^
+                    $S3[$R0 >> 24 & 0xff];
             $t1 = $S0[$R1 >> 24 & 0xff] ^
-                  $S1[$R1       & 0xff] ^
-                  $S2[$R1 >>  8 & 0xff] ^
-                  $S3[$R1 >> 16 & 0xff];
+                    $S1[$R1       & 0xff] ^
+                    $S2[$R1 >>  8 & 0xff] ^
+                    $S3[$R1 >> 16 & 0xff];
             $R3^= $t0 + ($t1 << 1) + $K[--$ki];
             $R3 = $R3 >> 1 & 0x7fffffff | $R3 << 31;
             $R2 = ($R2 >> 31 & 0x1 | $R2 << 1) ^ ($t0 + $t1 + $K[--$ki]);
 
             $t0 = $S0[$R2       & 0xff] ^
-                  $S1[$R2 >>  8 & 0xff] ^
-                  $S2[$R2 >> 16 & 0xff] ^
-                  $S3[$R2 >> 24 & 0xff];
+                    $S1[$R2 >>  8 & 0xff] ^
+                    $S2[$R2 >> 16 & 0xff] ^
+                    $S3[$R2 >> 24 & 0xff];
             $t1 = $S0[$R3 >> 24 & 0xff] ^
-                  $S1[$R3       & 0xff] ^
-                  $S2[$R3 >>  8 & 0xff] ^
-                  $S3[$R3 >> 16 & 0xff];
+                    $S1[$R3       & 0xff] ^
+                    $S2[$R3 >>  8 & 0xff] ^
+                    $S3[$R3 >> 16 & 0xff];
             $R1^= $t0 + ($t1 << 1) + $K[--$ki];
             $R1 = $R1 >> 1 & 0x7fffffff | $R1 << 31;
             $R0 = ($R0 >> 31 & 0x1 | $R0 << 1) ^ ($t0 + $t1 + $K[--$ki]);
@@ -693,9 +693,9 @@ 
 
         // @codingStandardsIgnoreStart
         return pack("V4", $K[0] ^ $R2,
-                          $K[1] ^ $R3,
-                          $K[2] ^ $R0,
-                          $K[3] ^ $R1);
+                            $K[1] ^ $R3,
+                            $K[2] ^ $R0,
+                            $K[3] ^ $R1);
         // @codingStandardsIgnoreEnd
     }
 
@@ -835,11 +835,11 @@ 
 
             $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
                 array(
-                   'init_crypt'    => $init_crypt,
-                   'init_encrypt'  => '',
-                   'init_decrypt'  => '',
-                   'encrypt_block' => $encrypt_block,
-                   'decrypt_block' => $decrypt_block
+                    'init_crypt'    => $init_crypt,
+                    'init_encrypt'  => '',
+                    'init_decrypt'  => '',
+                    'encrypt_block' => $encrypt_block,
+                    'decrypt_block' => $decrypt_block
                 )
             );
         }

Spacing +50 added lines, -50 removed lines

@@ -402,7 +402,7 @@ 
             case 256:
                 break;
             default:
-                throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
+                throw new \LengthException('Key of size '.strlen($key).' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
         }
 
         parent::setKeyLength($length);
@@ -426,7 +426,7 @@ 
             case 32:
                 break;
             default:
-                throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
+                throw new \LengthException('Key of size '.strlen($key).' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
         }
 
         parent::setKey($key);
@@ -462,8 +462,8 @@ 
             case 16:
                 list($s7, $s6, $s5, $s4) = $this->_mdsrem($le_longs[1], $le_longs[2]);
                 list($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[3], $le_longs[4]);
-                for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
-                    $A = $m0[$q0[$q0[$i] ^ $key[ 9]] ^ $key[1]] ^
+                for ($i = 0, $j = 1; $i < 40; $i += 2, $j += 2) {
+                    $A = $m0[$q0[$q0[$i] ^ $key[9]] ^ $key[1]] ^
                          $m1[$q0[$q1[$i] ^ $key[10]] ^ $key[2]] ^
                          $m2[$q1[$q0[$i] ^ $key[11]] ^ $key[3]] ^
                          $m3[$q1[$q1[$i] ^ $key[12]] ^ $key[4]];
@@ -472,8 +472,8 @@ 
                          $m2[$q1[$q0[$j] ^ $key[15]] ^ $key[7]] ^
                          $m3[$q1[$q1[$j] ^ $key[16]] ^ $key[8]];
                     $B = ($B << 8) | ($B >> 24 & 0xff);
-                    $K[] = $A+= $B;
-                    $K[] = (($A+= $B) << 9 | $A >> 23 & 0x1ff);
+                    $K[] = $A += $B;
+                    $K[] = (($A += $B) << 9 | $A >> 23 & 0x1ff);
                 }
                 for ($i = 0; $i < 256; ++$i) {
                     $S0[$i] = $m0[$q0[$q0[$i] ^ $s4] ^ $s0];
@@ -486,8 +486,8 @@ 
                 list($sb, $sa, $s9, $s8) = $this->_mdsrem($le_longs[1], $le_longs[2]);
                 list($s7, $s6, $s5, $s4) = $this->_mdsrem($le_longs[3], $le_longs[4]);
                 list($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[5], $le_longs[6]);
-                for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
-                    $A = $m0[$q0[$q0[$q1[$i] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^
+                for ($i = 0, $j = 1; $i < 40; $i += 2, $j += 2) {
+                    $A = $m0[$q0[$q0[$q1[$i] ^ $key[17]] ^ $key[9]] ^ $key[1]] ^
                          $m1[$q0[$q1[$q1[$i] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
                          $m2[$q1[$q0[$q0[$i] ^ $key[19]] ^ $key[11]] ^ $key[3]] ^
                          $m3[$q1[$q1[$q0[$i] ^ $key[20]] ^ $key[12]] ^ $key[4]];
@@ -496,8 +496,8 @@ 
                          $m2[$q1[$q0[$q0[$j] ^ $key[23]] ^ $key[15]] ^ $key[7]] ^
                          $m3[$q1[$q1[$q0[$j] ^ $key[24]] ^ $key[16]] ^ $key[8]];
                     $B = ($B << 8) | ($B >> 24 & 0xff);
-                    $K[] = $A+= $B;
-                    $K[] = (($A+= $B) << 9 | $A >> 23 & 0x1ff);
+                    $K[] = $A += $B;
+                    $K[] = (($A += $B) << 9 | $A >> 23 & 0x1ff);
                 }
                 for ($i = 0; $i < 256; ++$i) {
                     $S0[$i] = $m0[$q0[$q0[$q1[$i] ^ $s8] ^ $s4] ^ $s0];
@@ -511,8 +511,8 @@ 
                 list($sb, $sa, $s9, $s8) = $this->_mdsrem($le_longs[3], $le_longs[4]);
                 list($s7, $s6, $s5, $s4) = $this->_mdsrem($le_longs[5], $le_longs[6]);
                 list($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[7], $le_longs[8]);
-                for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
-                    $A = $m0[$q0[$q0[$q1[$q1[$i] ^ $key[25]] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^
+                for ($i = 0, $j = 1; $i < 40; $i += 2, $j += 2) {
+                    $A = $m0[$q0[$q0[$q1[$q1[$i] ^ $key[25]] ^ $key[17]] ^ $key[9]] ^ $key[1]] ^
                          $m1[$q0[$q1[$q1[$q0[$i] ^ $key[26]] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
                          $m2[$q1[$q0[$q0[$q0[$i] ^ $key[27]] ^ $key[19]] ^ $key[11]] ^ $key[3]] ^
                          $m3[$q1[$q1[$q0[$q1[$i] ^ $key[28]] ^ $key[20]] ^ $key[12]] ^ $key[4]];
@@ -521,8 +521,8 @@ 
                          $m2[$q1[$q0[$q0[$q0[$j] ^ $key[31]] ^ $key[23]] ^ $key[15]] ^ $key[7]] ^
                          $m3[$q1[$q1[$q0[$q1[$j] ^ $key[32]] ^ $key[24]] ^ $key[16]] ^ $key[8]];
                     $B = ($B << 8) | ($B >> 24 & 0xff);
-                    $K[] = $A+= $B;
-                    $K[] = (($A+= $B) << 9 | $A >> 23 & 0x1ff);
+                    $K[] = $A += $B;
+                    $K[] = (($A += $B) << 9 | $A >> 23 & 0x1ff);
                 }
                 for ($i = 0; $i < 256; ++$i) {
                     $S0[$i] = $m0[$q0[$q0[$q1[$q1[$i] ^ $sc] ^ $s8] ^ $s4] ^ $s0];
@@ -556,34 +556,34 @@ 
 
             // Shift the others up.
             $B = ($B << 8) | (0xff & ($A >> 24));
-            $A<<= 8;
+            $A <<= 8;
 
             $u = $t << 1;
 
             // Subtract the modular polynomial on overflow.
             if ($t & 0x80) {
-                $u^= 0x14d;
+                $u ^= 0x14d;
             }
 
             // Remove t * (a * x^2 + 1).
             $B ^= $t ^ ($u << 16);
 
             // Form u = a*t + t/a = t*(a + 1/a).
-            $u^= 0x7fffffff & ($t >> 1);
+            $u ^= 0x7fffffff & ($t >> 1);
 
             // Add the modular polynomial on underflow.
             if ($t & 0x01) {
-                $u^= 0xa6 ;
+                $u ^= 0xa6;
             }
 
             // Remove t * (a + 1/a) * (x^3 + x).
-            $B^= ($u << 24) | ($u << 8);
+            $B ^= ($u << 24) | ($u << 8);
         }
 
         return array(
             0xff & $B >> 24,
             0xff & $B >> 16,
-            0xff & $B >>  8,
+            0xff & $B >> 8,
             0xff & $B);
     }
 
@@ -610,27 +610,27 @@ 
 
         $ki = 7;
         while ($ki < 39) {
-            $t0 = $S0[ $R0        & 0xff] ^
-                  $S1[($R0 >>  8) & 0xff] ^
+            $t0 = $S0[$R0 & 0xff] ^
+                  $S1[($R0 >> 8) & 0xff] ^
                   $S2[($R0 >> 16) & 0xff] ^
                   $S3[($R0 >> 24) & 0xff];
             $t1 = $S0[($R1 >> 24) & 0xff] ^
-                  $S1[ $R1        & 0xff] ^
-                  $S2[($R1 >>  8) & 0xff] ^
+                  $S1[$R1 & 0xff] ^
+                  $S2[($R1 >> 8) & 0xff] ^
                   $S3[($R1 >> 16) & 0xff];
-            $R2^= $t0 + $t1 + $K[++$ki];
+            $R2 ^= $t0 + $t1 + $K[++$ki];
             $R2 = ($R2 >> 1 & 0x7fffffff) | ($R2 << 31);
             $R3 = ((($R3 >> 31) & 1) | ($R3 << 1)) ^ ($t0 + ($t1 << 1) + $K[++$ki]);
 
-            $t0 = $S0[ $R2        & 0xff] ^
-                  $S1[($R2 >>  8) & 0xff] ^
+            $t0 = $S0[$R2 & 0xff] ^
+                  $S1[($R2 >> 8) & 0xff] ^
                   $S2[($R2 >> 16) & 0xff] ^
                   $S3[($R2 >> 24) & 0xff];
             $t1 = $S0[($R3 >> 24) & 0xff] ^
-                  $S1[ $R3        & 0xff] ^
-                  $S2[($R3 >>  8) & 0xff] ^
+                  $S1[$R3 & 0xff] ^
+                  $S2[($R3 >> 8) & 0xff] ^
                   $S3[($R3 >> 16) & 0xff];
-            $R0^= ($t0 + $t1 + $K[++$ki]);
+            $R0 ^= ($t0 + $t1 + $K[++$ki]);
             $R0 = ($R0 >> 1 & 0x7fffffff) | ($R0 << 31);
             $R1 = ((($R1 >> 31) & 1) | ($R1 << 1)) ^ ($t0 + ($t1 << 1) + $K[++$ki]);
         }
@@ -666,27 +666,27 @@ 
 
         $ki = 40;
         while ($ki > 8) {
-            $t0 = $S0[$R0       & 0xff] ^
-                  $S1[$R0 >>  8 & 0xff] ^
+            $t0 = $S0[$R0 & 0xff] ^
+                  $S1[$R0 >> 8 & 0xff] ^
                   $S2[$R0 >> 16 & 0xff] ^
                   $S3[$R0 >> 24 & 0xff];
             $t1 = $S0[$R1 >> 24 & 0xff] ^
-                  $S1[$R1       & 0xff] ^
-                  $S2[$R1 >>  8 & 0xff] ^
+                  $S1[$R1 & 0xff] ^
+                  $S2[$R1 >> 8 & 0xff] ^
                   $S3[$R1 >> 16 & 0xff];
-            $R3^= $t0 + ($t1 << 1) + $K[--$ki];
+            $R3 ^= $t0 + ($t1 << 1) + $K[--$ki];
             $R3 = $R3 >> 1 & 0x7fffffff | $R3 << 31;
             $R2 = ($R2 >> 31 & 0x1 | $R2 << 1) ^ ($t0 + $t1 + $K[--$ki]);
 
-            $t0 = $S0[$R2       & 0xff] ^
-                  $S1[$R2 >>  8 & 0xff] ^
+            $t0 = $S0[$R2 & 0xff] ^
+                  $S1[$R2 >> 8 & 0xff] ^
                   $S2[$R2 >> 16 & 0xff] ^
                   $S3[$R2 >> 24 & 0xff];
             $t1 = $S0[$R3 >> 24 & 0xff] ^
-                  $S1[$R3       & 0xff] ^
-                  $S2[$R3 >>  8 & 0xff] ^
+                  $S1[$R3 & 0xff] ^
+                  $S2[$R3 >> 8 & 0xff] ^
                   $S3[$R3 >> 16 & 0xff];
-            $R1^= $t0 + ($t1 << 1) + $K[--$ki];
+            $R1 ^= $t0 + ($t1 << 1) + $K[--$ki];
             $R1 = $R1 >> 1 & 0x7fffffff | $R1 << 31;
             $R0 = ($R0 >> 31 & 0x1 | $R0 << 1) ^ ($t0 + $t1 + $K[--$ki]);
         }
@@ -707,16 +707,16 @@ 
      */
     function _setupInlineCrypt()
     {
-        $lambda_functions =& self::_getLambdaFunctions();
+        $lambda_functions = & self::_getLambdaFunctions();
 
         // Max. 10 Ultra-Hi-optimized inline-crypt functions. After that, we'll (still) create very fast code, but not the ultimate fast one.
         // (Currently, for Crypt_Twofish, one generated $lambda_function cost on php5.5@32bit ~140kb unfreeable mem and ~240kb on php5.5@64bit)
-        $gen_hi_opt_code = (bool)(count($lambda_functions) < 10);
+        $gen_hi_opt_code = (bool) (count($lambda_functions) < 10);
 
         // Generation of a unique hash for our generated code
         $code_hash = "Crypt_Twofish, {$this->mode}";
         if ($gen_hi_opt_code) {
-            $code_hash = str_pad($code_hash, 32) . $this->_hashInlineCryptFunction($this->key);
+            $code_hash = str_pad($code_hash, 32).$this->_hashInlineCryptFunction($this->key);
         }
 
         if (!isset($lambda_functions[$code_hash])) {
@@ -736,16 +736,16 @@ 
                     ';
                     break;
                 default:
-                    $K   = array();
+                    $K = array();
                     for ($i = 0; $i < 40; ++$i) {
-                        $K[] = '$K_' . $i;
+                        $K[] = '$K_'.$i;
                     }
                     $init_crypt = '
                         $S0 = $self->S0;
                         $S1 = $self->S1;
                         $S2 = $self->S2;
                         $S3 = $self->S3;
-                        list(' . implode(',', $K) . ') = $self->K;
+                        list(' . implode(',', $K).') = $self->K;
                     ';
             }
 
@@ -758,7 +758,7 @@ 
                 $R3 = '.$K[3].' ^ $in[4];
             ';
             for ($ki = 7, $i = 0; $i < 8; ++$i) {
-                $encrypt_block.= '
+                $encrypt_block .= '
                     $t0 = $S0[ $R0        & 0xff] ^
                           $S1[($R0 >>  8) & 0xff] ^
                           $S2[($R0 >> 16) & 0xff] ^
@@ -784,7 +784,7 @@ 
                     $R1 = ((($R1 >> 31) & 1) | ($R1 << 1)) ^ ($t0 + ($t1 << 1) + '.$K[++$ki].');
                 ';
             }
-            $encrypt_block.= '
+            $encrypt_block .= '
                 $in = pack("V4", '.$K[4].' ^ $R2,
                                  '.$K[5].' ^ $R3,
                                  '.$K[6].' ^ $R0,
@@ -800,7 +800,7 @@ 
                 $R3 = '.$K[7].' ^ $in[4];
             ';
             for ($ki = 40, $i = 0; $i < 8; ++$i) {
-                $decrypt_block.= '
+                $decrypt_block .= '
                     $t0 = $S0[$R0       & 0xff] ^
                           $S1[$R0 >>  8 & 0xff] ^
                           $S2[$R0 >> 16 & 0xff] ^
@@ -826,7 +826,7 @@ 
                     $R0 = ($R0 >> 31 & 0x1 | $R0 << 1) ^ ($t0 + $t1 + '.$K[--$ki].');
                 ';
             }
-            $decrypt_block.= '
+            $decrypt_block .= '
                 $in = pack("V4", '.$K[0].' ^ $R2,
                                  '.$K[1].' ^ $R3,
                                  '.$K[2].' ^ $R0,

includes/libraries/Authentication/phpseclib/Crypt/Blowfish.php

Indentation +9 added lines, -9 removed lines

@@ -423,13 +423,13 @@ 
             $l^= $p[$i];
             $r^= ($sb_0[$l >> 24 & 0xff]  +
                   $sb_1[$l >> 16 & 0xff]  ^
-                  $sb_2[$l >>  8 & 0xff]) +
+                    $sb_2[$l >>  8 & 0xff]) +
                   $sb_3[$l       & 0xff];
 
             $r^= $p[$i + 1];
             $l^= ($sb_0[$r >> 24 & 0xff]  +
                   $sb_1[$r >> 16 & 0xff]  ^
-                  $sb_2[$r >>  8 & 0xff]) +
+                    $sb_2[$r >>  8 & 0xff]) +
                   $sb_3[$r       & 0xff];
         }
         return pack("N*", $r ^ $p[17], $l ^ $p[16]);
@@ -458,13 +458,13 @@ 
             $l^= $p[$i];
             $r^= ($sb_0[$l >> 24 & 0xff]  +
                   $sb_1[$l >> 16 & 0xff]  ^
-                  $sb_2[$l >>  8 & 0xff]) +
+                    $sb_2[$l >>  8 & 0xff]) +
                   $sb_3[$l       & 0xff];
 
             $r^= $p[$i - 1];
             $l^= ($sb_0[$r >> 24 & 0xff]  +
                   $sb_1[$r >> 16 & 0xff]  ^
-                  $sb_2[$r >>  8 & 0xff]) +
+                    $sb_2[$r >>  8 & 0xff]) +
                   $sb_3[$r       & 0xff];
         }
         return pack("N*", $r ^ $p[0], $l ^ $p[1]);
@@ -577,11 +577,11 @@ 
 
             $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
                 array(
-                   'init_crypt'    => $init_crypt,
-                   'init_encrypt'  => '',
-                   'init_decrypt'  => '',
-                   'encrypt_block' => $encrypt_block,
-                   'decrypt_block' => $decrypt_block
+                    'init_crypt'    => $init_crypt,
+                    'init_encrypt'  => '',
+                    'init_decrypt'  => '',
+                    'encrypt_block' => $encrypt_block,
+                    'decrypt_block' => $decrypt_block
                 )
             );
         }

Spacing +48 added lines, -48 removed lines

@@ -312,7 +312,7 @@ 
     function setKeyLength($length)
     {
         if ($length < 32 || $length > 448) {
-                throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys of sizes between 32 and 448 bits are supported');
+                throw new \LengthException('Key size of '.$length.' bits is not supported by this algorithm. Only keys of sizes between 32 and 448 bits are supported');
         }
 
         $this->key_length = $length >> 3;
@@ -337,7 +337,7 @@ 
                 return false;
             }
             $this->cipher_name_openssl_ecb = 'bf-ecb';
-            $this->cipher_name_openssl = 'bf-' . $this->_openssl_translate_mode();
+            $this->cipher_name_openssl = 'bf-'.$this->_openssl_translate_mode();
         }
 
         return parent::isValidEngine($engine);
@@ -387,13 +387,13 @@ 
         $data = "\0\0\0\0\0\0\0\0";
         for ($i = 0; $i < 18; $i += 2) {
             list($l, $r) = array_values(unpack('N*', $data = $this->_encryptBlock($data)));
-            $this->bctx['p'][$i    ] = $l;
+            $this->bctx['p'][$i] = $l;
             $this->bctx['p'][$i + 1] = $r;
         }
         for ($i = 0; $i < 4; ++$i) {
             for ($j = 0; $j < 256; $j += 2) {
                 list($l, $r) = array_values(unpack('N*', $data = $this->_encryptBlock($data)));
-                $this->bctx['sb'][$i][$j    ] = $l;
+                $this->bctx['sb'][$i][$j] = $l;
                 $this->bctx['sb'][$i][$j + 1] = $r;
             }
         }
@@ -419,18 +419,18 @@ 
         $l = $in[1];
         $r = $in[2];
 
-        for ($i = 0; $i < 16; $i+= 2) {
-            $l^= $p[$i];
-            $r^= ($sb_0[$l >> 24 & 0xff]  +
-                  $sb_1[$l >> 16 & 0xff]  ^
-                  $sb_2[$l >>  8 & 0xff]) +
-                  $sb_3[$l       & 0xff];
-
-            $r^= $p[$i + 1];
-            $l^= ($sb_0[$r >> 24 & 0xff]  +
-                  $sb_1[$r >> 16 & 0xff]  ^
-                  $sb_2[$r >>  8 & 0xff]) +
-                  $sb_3[$r       & 0xff];
+        for ($i = 0; $i < 16; $i += 2) {
+            $l ^= $p[$i];
+            $r ^= ($sb_0[$l >> 24 & 0xff] +
+                  $sb_1[$l >> 16 & 0xff] ^
+                  $sb_2[$l >> 8 & 0xff]) +
+                  $sb_3[$l & 0xff];
+
+            $r ^= $p[$i + 1];
+            $l ^= ($sb_0[$r >> 24 & 0xff] +
+                  $sb_1[$r >> 16 & 0xff] ^
+                  $sb_2[$r >> 8 & 0xff]) +
+                  $sb_3[$r & 0xff];
         }
         return pack("N*", $r ^ $p[17], $l ^ $p[16]);
     }
@@ -454,18 +454,18 @@ 
         $l = $in[1];
         $r = $in[2];
 
-        for ($i = 17; $i > 2; $i-= 2) {
-            $l^= $p[$i];
-            $r^= ($sb_0[$l >> 24 & 0xff]  +
-                  $sb_1[$l >> 16 & 0xff]  ^
-                  $sb_2[$l >>  8 & 0xff]) +
-                  $sb_3[$l       & 0xff];
-
-            $r^= $p[$i - 1];
-            $l^= ($sb_0[$r >> 24 & 0xff]  +
-                  $sb_1[$r >> 16 & 0xff]  ^
-                  $sb_2[$r >>  8 & 0xff]) +
-                  $sb_3[$r       & 0xff];
+        for ($i = 17; $i > 2; $i -= 2) {
+            $l ^= $p[$i];
+            $r ^= ($sb_0[$l >> 24 & 0xff] +
+                  $sb_1[$l >> 16 & 0xff] ^
+                  $sb_2[$l >> 8 & 0xff]) +
+                  $sb_3[$l & 0xff];
+
+            $r ^= $p[$i - 1];
+            $l ^= ($sb_0[$r >> 24 & 0xff] +
+                  $sb_1[$r >> 16 & 0xff] ^
+                  $sb_2[$r >> 8 & 0xff]) +
+                  $sb_3[$r & 0xff];
         }
         return pack("N*", $r ^ $p[0], $l ^ $p[1]);
     }
@@ -478,17 +478,17 @@ 
      */
     function _setupInlineCrypt()
     {
-        $lambda_functions =& self::_getLambdaFunctions();
+        $lambda_functions = & self::_getLambdaFunctions();
 
         // We create max. 10 hi-optimized code for memory reason. Means: For each $key one ultra fast inline-crypt function.
         // (Currently, for Blowfish, one generated $lambda_function cost on php5.5@32bit ~100kb unfreeable mem and ~180kb on php5.5@64bit)
         // After that, we'll still create very fast optimized code but not the hi-ultimative code, for each $mode one.
-        $gen_hi_opt_code = (bool)(count($lambda_functions) < 10);
+        $gen_hi_opt_code = (bool) (count($lambda_functions) < 10);
 
         // Generation of a unique hash for our generated code
         $code_hash = "Crypt_Blowfish, {$this->mode}";
         if ($gen_hi_opt_code) {
-            $code_hash = str_pad($code_hash, 32) . $this->_hashInlineCryptFunction($this->key);
+            $code_hash = str_pad($code_hash, 32).$this->_hashInlineCryptFunction($this->key);
         }
 
         if (!isset($lambda_functions[$code_hash])) {
@@ -506,13 +506,13 @@ 
                     ';
                     break;
                 default:
-                    $p   = array();
+                    $p = array();
                     for ($i = 0; $i < 18; ++$i) {
-                        $p[] = '$p_' . $i;
+                        $p[] = '$p_'.$i;
                     }
                     $init_crypt = '
                         list($sb_0, $sb_1, $sb_2, $sb_3) = $self->bctx["sb"];
-                        list(' . implode(',', $p) . ') = $self->bctx["p"];
+                        list(' . implode(',', $p).') = $self->bctx["p"];
 
                     ';
             }
@@ -523,25 +523,25 @@ 
                 $l = $in[1];
                 $r = $in[2];
             ';
-            for ($i = 0; $i < 16; $i+= 2) {
-                $encrypt_block.= '
-                    $l^= ' . $p[$i] . ';
+            for ($i = 0; $i < 16; $i += 2) {
+                $encrypt_block .= '
+                    $l^= ' . $p[$i].';
                     $r^= ($sb_0[$l >> 24 & 0xff]  +
                           $sb_1[$l >> 16 & 0xff]  ^
                           $sb_2[$l >>  8 & 0xff]) +
                           $sb_3[$l       & 0xff];
 
-                    $r^= ' . $p[$i + 1] . ';
+                    $r^= ' . $p[$i + 1].';
                     $l^= ($sb_0[$r >> 24 & 0xff]  +
                           $sb_1[$r >> 16 & 0xff]  ^
                           $sb_2[$r >>  8 & 0xff]) +
                           $sb_3[$r       & 0xff];
                 ';
             }
-            $encrypt_block.= '
+            $encrypt_block .= '
                 $in = pack("N*",
-                    $r ^ ' . $p[17] . ',
-                    $l ^ ' . $p[16] . '
+                    $r ^ ' . $p[17].',
+                    $l ^ ' . $p[16].'
                 );
             ';
 
@@ -552,15 +552,15 @@ 
                 $r = $in[2];
             ';
 
-            for ($i = 17; $i > 2; $i-= 2) {
-                $decrypt_block.= '
-                    $l^= ' . $p[$i] . ';
+            for ($i = 17; $i > 2; $i -= 2) {
+                $decrypt_block .= '
+                    $l^= ' . $p[$i].';
                     $r^= ($sb_0[$l >> 24 & 0xff]  +
                           $sb_1[$l >> 16 & 0xff]  ^
                           $sb_2[$l >>  8 & 0xff]) +
                           $sb_3[$l       & 0xff];
 
-                    $r^= ' . $p[$i - 1] . ';
+                    $r^= ' . $p[$i - 1].';
                     $l^= ($sb_0[$r >> 24 & 0xff]  +
                           $sb_1[$r >> 16 & 0xff]  ^
                           $sb_2[$r >>  8 & 0xff]) +
@@ -568,10 +568,10 @@ 
                 ';
             }
 
-            $decrypt_block.= '
+            $decrypt_block .= '
                 $in = pack("N*",
-                    $r ^ ' . $p[0] . ',
-                    $l ^ ' . $p[1] . '
+                    $r ^ ' . $p[0].',
+                    $l ^ ' . $p[1].'
                 );
             ';
 

includes/libraries/Authentication/phpseclib/Crypt/AES.php

Spacing +2 added lines, -2 removed lines

@@ -91,7 +91,7 @@ 
             case 256:
                 break;
             default:
-                throw new \LengthException('Key of size ' . $length . ' not supported by this algorithm. Only keys of sizes 128, 192 or 256 supported');
+                throw new \LengthException('Key of size '.$length.' not supported by this algorithm. Only keys of sizes 128, 192 or 256 supported');
         }
         parent::setKeyLength($length);
     }
@@ -115,7 +115,7 @@ 
             case 32:
                 break;
             default:
-                throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
+                throw new \LengthException('Key of size '.strlen($key).' not supported by this algorithm. Only keys of sizes 16, 24 or 32 supported');
         }
 
         parent::setKey($key);

includes/libraries/Authentication/phpseclib/Crypt/DES.php

Indentation +31 added lines, -31 removed lines

@@ -709,13 +709,13 @@ 
         $t = unpack('Nl/Nr', $block);
         list($l, $r) = array($t['l'], $t['r']);
         $block = ($shuffleip[ $r        & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") |
-                 ($shuffleip[($r >>  8) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
-                 ($shuffleip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
-                 ($shuffleip[($r >> 24) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
-                 ($shuffleip[ $l        & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
-                 ($shuffleip[($l >>  8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
-                 ($shuffleip[($l >> 16) & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
-                 ($shuffleip[($l >> 24) & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
+                    ($shuffleip[($r >>  8) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
+                    ($shuffleip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
+                    ($shuffleip[($r >> 24) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
+                    ($shuffleip[ $l        & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
+                    ($shuffleip[($l >>  8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
+                    ($shuffleip[($l >> 16) & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
+                    ($shuffleip[($l >> 24) & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
 
         // Extract L0 and R0.
         $t = unpack('Nl/Nr', $block);
@@ -732,9 +732,9 @@ 
 
                 // S-box indexing.
                 $t = $sbox1[($b1 >> 24) & 0x3F] ^ $sbox2[($b2 >> 24) & 0x3F] ^
-                     $sbox3[($b1 >> 16) & 0x3F] ^ $sbox4[($b2 >> 16) & 0x3F] ^
-                     $sbox5[($b1 >>  8) & 0x3F] ^ $sbox6[($b2 >>  8) & 0x3F] ^
-                     $sbox7[ $b1        & 0x3F] ^ $sbox8[ $b2        & 0x3F] ^ $l;
+                        $sbox3[($b1 >> 16) & 0x3F] ^ $sbox4[($b2 >> 16) & 0x3F] ^
+                        $sbox5[($b1 >>  8) & 0x3F] ^ $sbox6[($b2 >>  8) & 0x3F] ^
+                        $sbox7[ $b1        & 0x3F] ^ $sbox8[ $b2        & 0x3F] ^ $l;
                 // end of "the Feistel (F) function"
 
                 $l = $r;
@@ -749,13 +749,13 @@ 
 
         // Perform the inverse IP permutation.
         return ($shuffleinvip[($r >> 24) & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") |
-               ($shuffleinvip[($l >> 24) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
-               ($shuffleinvip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
-               ($shuffleinvip[($l >> 16) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
-               ($shuffleinvip[($r >>  8) & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
-               ($shuffleinvip[($l >>  8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
-               ($shuffleinvip[ $r        & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
-               ($shuffleinvip[ $l        & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
+                ($shuffleinvip[($l >> 24) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
+                ($shuffleinvip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
+                ($shuffleinvip[($l >> 16) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
+                ($shuffleinvip[($r >>  8) & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
+                ($shuffleinvip[($l >>  8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
+                ($shuffleinvip[ $r        & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
+                ($shuffleinvip[ $l        & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
     }
 
     /**
@@ -1230,13 +1230,13 @@ 
             $t = unpack('Nl/Nr', $key);
             list($l, $r) = array($t['l'], $t['r']);
             $key = ($this->shuffle[$pc1map[ $r        & 0xFF]] & "\x80\x80\x80\x80\x80\x80\x80\x00") |
-                   ($this->shuffle[$pc1map[($r >>  8) & 0xFF]] & "\x40\x40\x40\x40\x40\x40\x40\x00") |
-                   ($this->shuffle[$pc1map[($r >> 16) & 0xFF]] & "\x20\x20\x20\x20\x20\x20\x20\x00") |
-                   ($this->shuffle[$pc1map[($r >> 24) & 0xFF]] & "\x10\x10\x10\x10\x10\x10\x10\x00") |
-                   ($this->shuffle[$pc1map[ $l        & 0xFF]] & "\x08\x08\x08\x08\x08\x08\x08\x00") |
-                   ($this->shuffle[$pc1map[($l >>  8) & 0xFF]] & "\x04\x04\x04\x04\x04\x04\x04\x00") |
-                   ($this->shuffle[$pc1map[($l >> 16) & 0xFF]] & "\x02\x02\x02\x02\x02\x02\x02\x00") |
-                   ($this->shuffle[$pc1map[($l >> 24) & 0xFF]] & "\x01\x01\x01\x01\x01\x01\x01\x00");
+                    ($this->shuffle[$pc1map[($r >>  8) & 0xFF]] & "\x40\x40\x40\x40\x40\x40\x40\x00") |
+                    ($this->shuffle[$pc1map[($r >> 16) & 0xFF]] & "\x20\x20\x20\x20\x20\x20\x20\x00") |
+                    ($this->shuffle[$pc1map[($r >> 24) & 0xFF]] & "\x10\x10\x10\x10\x10\x10\x10\x00") |
+                    ($this->shuffle[$pc1map[ $l        & 0xFF]] & "\x08\x08\x08\x08\x08\x08\x08\x00") |
+                    ($this->shuffle[$pc1map[($l >>  8) & 0xFF]] & "\x04\x04\x04\x04\x04\x04\x04\x00") |
+                    ($this->shuffle[$pc1map[($l >> 16) & 0xFF]] & "\x02\x02\x02\x02\x02\x02\x02\x00") |
+                    ($this->shuffle[$pc1map[($l >> 24) & 0xFF]] & "\x01\x01\x01\x01\x01\x01\x01\x00");
             $key = unpack('Nc/Nd', $key);
             $c = ( $key['c'] >> 4) & 0x0FFFFFFF;
             $d = (($key['d'] >> 4) & 0x0FFFFFF0) | ($key['c'] & 0x0F);
@@ -1253,9 +1253,9 @@ 
 
                 // Perform the PC-2 transformation.
                 $cp = $pc2mapc1[ $c >> 24        ] | $pc2mapc2[($c >> 16) & 0xFF] |
-                      $pc2mapc3[($c >>  8) & 0xFF] | $pc2mapc4[ $c        & 0xFF];
+                        $pc2mapc3[($c >>  8) & 0xFF] | $pc2mapc4[ $c        & 0xFF];
                 $dp = $pc2mapd1[ $d >> 24        ] | $pc2mapd2[($d >> 16) & 0xFF] |
-                      $pc2mapd3[($d >>  8) & 0xFF] | $pc2mapd4[ $d        & 0xFF];
+                        $pc2mapd3[($d >>  8) & 0xFF] | $pc2mapd4[ $d        & 0xFF];
 
                 // Reorder: odd bytes/even bytes. Push the result in key schedule.
                 $val1 = ( $cp        & 0xFF000000) | (($cp <<  8) & 0x00FF0000) |
@@ -1440,11 +1440,11 @@ 
             // Creates the inline-crypt function
             $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
                 array(
-                   'init_crypt'    => $init_crypt,
-                   'init_encrypt'  => $init_encrypt,
-                   'init_decrypt'  => $init_decrypt,
-                   'encrypt_block' => $crypt_block[self::ENCRYPT],
-                   'decrypt_block' => $crypt_block[self::DECRYPT]
+                    'init_crypt'    => $init_crypt,
+                    'init_encrypt'  => $init_encrypt,
+                    'init_decrypt'  => $init_decrypt,
+                    'encrypt_block' => $crypt_block[self::ENCRYPT],
+                    'decrypt_block' => $crypt_block[self::DECRYPT]
                 )
             );
         }

Spacing +45 added lines, -45 removed lines

@@ -611,7 +611,7 @@ 
         if ($this->key_length_max == 8) {
             if ($engine == self::ENGINE_OPENSSL) {
                 $this->cipher_name_openssl_ecb = 'des-ecb';
-                $this->cipher_name_openssl = 'des-' . $this->_openssl_translate_mode();
+                $this->cipher_name_openssl = 'des-'.$this->_openssl_translate_mode();
             }
         }
 
@@ -632,7 +632,7 @@ 
     function setKey($key)
     {
         if (!($this instanceof TripleDES) && strlen($key) != 8) {
-            throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of size 8 are supported');
+            throw new \LengthException('Key of size '.strlen($key).' not supported by this algorithm. Only keys of size 8 are supported');
         }
 
         // Sets the key
@@ -697,8 +697,8 @@ 
             $sbox8 = array_map("intval", $this->sbox8);
             /* Merge $shuffle with $[inv]ipmap */
             for ($i = 0; $i < 256; ++$i) {
-                $shuffleip[]    =  $this->shuffle[$this->ipmap[$i]];
-                $shuffleinvip[] =  $this->shuffle[$this->invipmap[$i]];
+                $shuffleip[]    = $this->shuffle[$this->ipmap[$i]];
+                $shuffleinvip[] = $this->shuffle[$this->invipmap[$i]];
             }
         }
 
@@ -708,12 +708,12 @@ 
         // Do the initial IP permutation.
         $t = unpack('Nl/Nr', $block);
         list($l, $r) = array($t['l'], $t['r']);
-        $block = ($shuffleip[ $r        & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") |
-                 ($shuffleip[($r >>  8) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
+        $block = ($shuffleip[$r & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") |
+                 ($shuffleip[($r >> 8) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
                  ($shuffleip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
                  ($shuffleip[($r >> 24) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
-                 ($shuffleip[ $l        & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
-                 ($shuffleip[($l >>  8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
+                 ($shuffleip[$l & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
+                 ($shuffleip[($l >> 8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
                  ($shuffleip[($l >> 16) & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
                  ($shuffleip[($l >> 24) & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
 
@@ -727,14 +727,14 @@ 
                 // start of "the Feistel (F) function" - see the following URL:
                 // http://en.wikipedia.org/wiki/Image:Data_Encryption_Standard_InfoBox_Diagram.png
                 // Merge key schedule.
-                $b1 = (($r >>  3) & 0x1FFFFFFF) ^ ($r << 29) ^ $keys[++$ki];
-                $b2 = (($r >> 31) & 0x00000001) ^ ($r <<  1) ^ $keys[++$ki];
+                $b1 = (($r >> 3) & 0x1FFFFFFF) ^ ($r << 29) ^ $keys[++$ki];
+                $b2 = (($r >> 31) & 0x00000001) ^ ($r << 1) ^ $keys[++$ki];
 
                 // S-box indexing.
                 $t = $sbox1[($b1 >> 24) & 0x3F] ^ $sbox2[($b2 >> 24) & 0x3F] ^
                      $sbox3[($b1 >> 16) & 0x3F] ^ $sbox4[($b2 >> 16) & 0x3F] ^
-                     $sbox5[($b1 >>  8) & 0x3F] ^ $sbox6[($b2 >>  8) & 0x3F] ^
-                     $sbox7[ $b1        & 0x3F] ^ $sbox8[ $b2        & 0x3F] ^ $l;
+                     $sbox5[($b1 >> 8) & 0x3F] ^ $sbox6[($b2 >> 8) & 0x3F] ^
+                     $sbox7[$b1 & 0x3F] ^ $sbox8[$b2 & 0x3F] ^ $l;
                 // end of "the Feistel (F) function"
 
                 $l = $r;
@@ -752,10 +752,10 @@ 
                ($shuffleinvip[($l >> 24) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
                ($shuffleinvip[($r >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |
                ($shuffleinvip[($l >> 16) & 0xFF] & "\x10\x10\x10\x10\x10\x10\x10\x10") |
-               ($shuffleinvip[($r >>  8) & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
-               ($shuffleinvip[($l >>  8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
-               ($shuffleinvip[ $r        & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
-               ($shuffleinvip[ $l        & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
+               ($shuffleinvip[($r >> 8) & 0xFF] & "\x08\x08\x08\x08\x08\x08\x08\x08") |
+               ($shuffleinvip[($l >> 8) & 0xFF] & "\x04\x04\x04\x04\x04\x04\x04\x04") |
+               ($shuffleinvip[$r & 0xFF] & "\x02\x02\x02\x02\x02\x02\x02\x02") |
+               ($shuffleinvip[$l & 0xFF] & "\x01\x01\x01\x01\x01\x01\x01\x01");
     }
 
     /**
@@ -1229,43 +1229,43 @@ 
             // Perform the PC/1 transformation and compute C and D.
             $t = unpack('Nl/Nr', $key);
             list($l, $r) = array($t['l'], $t['r']);
-            $key = ($this->shuffle[$pc1map[ $r        & 0xFF]] & "\x80\x80\x80\x80\x80\x80\x80\x00") |
-                   ($this->shuffle[$pc1map[($r >>  8) & 0xFF]] & "\x40\x40\x40\x40\x40\x40\x40\x00") |
+            $key = ($this->shuffle[$pc1map[$r & 0xFF]] & "\x80\x80\x80\x80\x80\x80\x80\x00") |
+                   ($this->shuffle[$pc1map[($r >> 8) & 0xFF]] & "\x40\x40\x40\x40\x40\x40\x40\x00") |
                    ($this->shuffle[$pc1map[($r >> 16) & 0xFF]] & "\x20\x20\x20\x20\x20\x20\x20\x00") |
                    ($this->shuffle[$pc1map[($r >> 24) & 0xFF]] & "\x10\x10\x10\x10\x10\x10\x10\x00") |
-                   ($this->shuffle[$pc1map[ $l        & 0xFF]] & "\x08\x08\x08\x08\x08\x08\x08\x00") |
-                   ($this->shuffle[$pc1map[($l >>  8) & 0xFF]] & "\x04\x04\x04\x04\x04\x04\x04\x00") |
+                   ($this->shuffle[$pc1map[$l & 0xFF]] & "\x08\x08\x08\x08\x08\x08\x08\x00") |
+                   ($this->shuffle[$pc1map[($l >> 8) & 0xFF]] & "\x04\x04\x04\x04\x04\x04\x04\x00") |
                    ($this->shuffle[$pc1map[($l >> 16) & 0xFF]] & "\x02\x02\x02\x02\x02\x02\x02\x00") |
                    ($this->shuffle[$pc1map[($l >> 24) & 0xFF]] & "\x01\x01\x01\x01\x01\x01\x01\x00");
             $key = unpack('Nc/Nd', $key);
-            $c = ( $key['c'] >> 4) & 0x0FFFFFFF;
+            $c = ($key['c'] >> 4) & 0x0FFFFFFF;
             $d = (($key['d'] >> 4) & 0x0FFFFFF0) | ($key['c'] & 0x0F);
 
             $keys[$des_round] = array(
                 self::ENCRYPT => array(),
                 self::DECRYPT => array_fill(0, 32, 0)
             );
-            for ($i = 0, $ki = 31; $i < 16; ++$i, $ki-= 2) {
+            for ($i = 0, $ki = 31; $i < 16; ++$i, $ki -= 2) {
                 $c <<= $shifts[$i];
                 $c = ($c | ($c >> 28)) & 0x0FFFFFFF;
                 $d <<= $shifts[$i];
                 $d = ($d | ($d >> 28)) & 0x0FFFFFFF;
 
                 // Perform the PC-2 transformation.
-                $cp = $pc2mapc1[ $c >> 24        ] | $pc2mapc2[($c >> 16) & 0xFF] |
-                      $pc2mapc3[($c >>  8) & 0xFF] | $pc2mapc4[ $c        & 0xFF];
-                $dp = $pc2mapd1[ $d >> 24        ] | $pc2mapd2[($d >> 16) & 0xFF] |
-                      $pc2mapd3[($d >>  8) & 0xFF] | $pc2mapd4[ $d        & 0xFF];
+                $cp = $pc2mapc1[$c >> 24] | $pc2mapc2[($c >> 16) & 0xFF] |
+                      $pc2mapc3[($c >> 8) & 0xFF] | $pc2mapc4[$c & 0xFF];
+                $dp = $pc2mapd1[$d >> 24] | $pc2mapd2[($d >> 16) & 0xFF] |
+                      $pc2mapd3[($d >> 8) & 0xFF] | $pc2mapd4[$d & 0xFF];
 
                 // Reorder: odd bytes/even bytes. Push the result in key schedule.
-                $val1 = ( $cp        & 0xFF000000) | (($cp <<  8) & 0x00FF0000) |
-                        (($dp >> 16) & 0x0000FF00) | (($dp >>  8) & 0x000000FF);
-                $val2 = (($cp <<  8) & 0xFF000000) | (($cp << 16) & 0x00FF0000) |
-                        (($dp >>  8) & 0x0000FF00) | ( $dp        & 0x000000FF);
-                $keys[$des_round][self::ENCRYPT][       ] = $val1;
+                $val1 = ($cp & 0xFF000000) | (($cp << 8) & 0x00FF0000) |
+                        (($dp >> 16) & 0x0000FF00) | (($dp >> 8) & 0x000000FF);
+                $val2 = (($cp << 8) & 0xFF000000) | (($cp << 16) & 0x00FF0000) |
+                        (($dp >> 8) & 0x0000FF00) | ($dp & 0x000000FF);
+                $keys[$des_round][self::ENCRYPT][] = $val1;
                 $keys[$des_round][self::DECRYPT][$ki - 1] = $val1;
-                $keys[$des_round][self::ENCRYPT][       ] = $val2;
-                $keys[$des_round][self::DECRYPT][$ki    ] = $val2;
+                $keys[$des_round][self::ENCRYPT][] = $val2;
+                $keys[$des_round][self::DECRYPT][$ki] = $val2;
             }
         }
 
@@ -1301,7 +1301,7 @@ 
      */
     function _setupInlineCrypt()
     {
-        $lambda_functions =& self::_getLambdaFunctions();
+        $lambda_functions = & self::_getLambdaFunctions();
 
         // Engine configuration for:
         // -  DES ($des_rounds == 1) or
@@ -1312,7 +1312,7 @@ 
         // (Currently, for DES, one generated $lambda_function cost on php5.5@32bit ~135kb unfreeable mem and ~230kb on php5.5@64bit)
         // (Currently, for TripleDES, one generated $lambda_function cost on php5.5@32bit ~240kb unfreeable mem and ~340kb on php5.5@64bit)
         // After that, we'll still create very fast optimized code but not the hi-ultimative code, for each $mode one
-        $gen_hi_opt_code = (bool)( count($lambda_functions) < 10 );
+        $gen_hi_opt_code = (bool) (count($lambda_functions) < 10);
 
         // Generation of a unique hash for our generated code
         $code_hash = "Crypt_DES, $des_rounds, {$this->mode}";
@@ -1322,7 +1322,7 @@ 
             // After max 10 hi-optimized functions, we create generic
             // (still very fast.. but not ultra) functions for each $mode/$des_rounds
             // Currently 2 * 5 generic functions will be then max. possible.
-            $code_hash = str_pad($code_hash, 32) . $this->_hashInlineCryptFunction($this->key);
+            $code_hash = str_pad($code_hash, 32).$this->_hashInlineCryptFunction($this->key);
         }
 
         // Is there a re-usable $lambda_functions in there? If not, we have to create it.
@@ -1338,7 +1338,7 @@ 
                     $sbox6 = array_map("intval", $self->sbox6);
                     $sbox7 = array_map("intval", $self->sbox7);
                     $sbox8 = array_map("intval", $self->sbox8);'
-                    /* Merge $shuffle with $[inv]ipmap */ . '
+                    /* Merge $shuffle with $[inv]ipmap */.'
                     for ($i = 0; $i < 256; ++$i) {
                         $shuffleip[]    =  $self->shuffle[$self->ipmap[$i]];
                         $shuffleinvip[] =  $self->shuffle[$self->invipmap[$i]];
@@ -1366,8 +1366,8 @@ 
                         self::DECRYPT => array()
                     );
                     for ($i = 0, $c = count($this->keys[self::ENCRYPT]); $i < $c; ++$i) {
-                        $k[self::ENCRYPT][$i] = '$ke[' . $i . ']';
-                        $k[self::DECRYPT][$i] = '$kd[' . $i . ']';
+                        $k[self::ENCRYPT][$i] = '$ke['.$i.']';
+                        $k[self::DECRYPT][$i] = '$kd['.$i.']';
                     }
                     $init_encrypt = '$ke = $self->keys[self::ENCRYPT];';
                     $init_decrypt = '$kd = $self->keys[self::DECRYPT];';
@@ -1407,14 +1407,14 @@ 
                         // start of "the Feistel (F) function" - see the following URL:
                         // http://en.wikipedia.org/wiki/Image:Data_Encryption_Standard_InfoBox_Diagram.png
                         // Merge key schedule.
-                        $crypt_block[$c].= '
-                            $b1 = ((' . $r . ' >>  3) & 0x1FFFFFFF)  ^ (' . $r . ' << 29) ^ ' . $k[$c][++$ki] . ';
-                            $b2 = ((' . $r . ' >> 31) & 0x00000001)  ^ (' . $r . ' <<  1) ^ ' . $k[$c][++$ki] . ';' .
+                        $crypt_block[$c] .= '
+                            $b1 = ((' . $r.' >>  3) & 0x1FFFFFFF)  ^ ('.$r.' << 29) ^ '.$k[$c][++$ki].';
+                            $b2 = ((' . $r.' >> 31) & 0x00000001)  ^ ('.$r.' <<  1) ^ '.$k[$c][++$ki].';'.
                             /* S-box indexing. */
-                            $l . ' = $sbox1[($b1 >> 24) & 0x3F] ^ $sbox2[($b2 >> 24) & 0x3F] ^
+                            $l.' = $sbox1[($b1 >> 24) & 0x3F] ^ $sbox2[($b2 >> 24) & 0x3F] ^
                                      $sbox3[($b1 >> 16) & 0x3F] ^ $sbox4[($b2 >> 16) & 0x3F] ^
                                      $sbox5[($b1 >>  8) & 0x3F] ^ $sbox6[($b2 >>  8) & 0x3F] ^
-                                     $sbox7[ $b1        & 0x3F] ^ $sbox8[ $b2        & 0x3F] ^ ' . $l . ';
+                                     $sbox7[ $b1        & 0x3F] ^ $sbox8[ $b2        & 0x3F] ^ ' . $l.';
                         ';
                         // end of "the Feistel (F) function"
 
@@ -1425,7 +1425,7 @@ 
                 }
 
                 // Perform the inverse IP permutation.
-                $crypt_block[$c].= '$in =
+                $crypt_block[$c] .= '$in =
                     ($shuffleinvip[($l >> 24) & 0xFF] & "\x80\x80\x80\x80\x80\x80\x80\x80") |
                     ($shuffleinvip[($r >> 24) & 0xFF] & "\x40\x40\x40\x40\x40\x40\x40\x40") |
                     ($shuffleinvip[($l >> 16) & 0xFF] & "\x20\x20\x20\x20\x20\x20\x20\x20") |

includes/libraries/Authentication/phpseclib/Crypt/RSA/MSBLOB.php

Spacing +10 added lines, -10 removed lines

@@ -176,14 +176,14 @@ 
         $n = strrev($n->toBytes());
         $e = str_pad(strrev($e->toBytes()), 4, "\0");
         $key = pack('aavV', chr(self::PRIVATEKEYBLOB), chr(2), 0, self::CALG_RSA_KEYX);
-        $key.= pack('VVa*', self::RSA2, 8 * strlen($n), $e);
-        $key.= $n;
-        $key.= strrev($primes[1]->toBytes());
-        $key.= strrev($primes[2]->toBytes());
-        $key.= strrev($exponents[1]->toBytes());
-        $key.= strrev($exponents[2]->toBytes());
-        $key.= strrev($coefficients[1]->toBytes());
-        $key.= strrev($d->toBytes());
+        $key .= pack('VVa*', self::RSA2, 8 * strlen($n), $e);
+        $key .= $n;
+        $key .= strrev($primes[1]->toBytes());
+        $key .= strrev($primes[2]->toBytes());
+        $key .= strrev($exponents[1]->toBytes());
+        $key .= strrev($exponents[2]->toBytes());
+        $key .= strrev($coefficients[1]->toBytes());
+        $key .= strrev($d->toBytes());
 
         return Base64::encode($key);
     }
@@ -201,8 +201,8 @@ 
         $n = strrev($n->toBytes());
         $e = str_pad(strrev($e->toBytes()), 4, "\0");
         $key = pack('aavV', chr(self::PUBLICKEYBLOB), chr(2), 0, self::CALG_RSA_KEYX);
-        $key.= pack('VVa*', self::RSA1, 8 * strlen($n), $e);
-        $key.= $n;
+        $key .= pack('VVa*', self::RSA1, 8 * strlen($n), $e);
+        $key .= $n;
 
         return Base64::encode($key);
     }

includes/libraries/Authentication/phpseclib/Crypt/RSA/XML.php

Indentation +12 added lines, -12 removed lines

@@ -119,15 +119,15 @@ 
             return false;
         }
         return "<RSAKeyValue>\r\n" .
-               '  <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
-               '  <Exponent>' . Base64::encode($e->toBytes()) . "</Exponent>\r\n" .
-               '  <P>' . Base64::encode($primes[1]->toBytes()) . "</P>\r\n" .
-               '  <Q>' . Base64::encode($primes[2]->toBytes()) . "</Q>\r\n" .
-               '  <DP>' . Base64::encode($exponents[1]->toBytes()) . "</DP>\r\n" .
-               '  <DQ>' . Base64::encode($exponents[2]->toBytes()) . "</DQ>\r\n" .
-               '  <InverseQ>' . Base64::encode($coefficients[2]->toBytes()) . "</InverseQ>\r\n" .
-               '  <D>' . Base64::encode($d->toBytes()) . "</D>\r\n" .
-               '</RSAKeyValue>';
+                '  <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
+                '  <Exponent>' . Base64::encode($e->toBytes()) . "</Exponent>\r\n" .
+                '  <P>' . Base64::encode($primes[1]->toBytes()) . "</P>\r\n" .
+                '  <Q>' . Base64::encode($primes[2]->toBytes()) . "</Q>\r\n" .
+                '  <DP>' . Base64::encode($exponents[1]->toBytes()) . "</DP>\r\n" .
+                '  <DQ>' . Base64::encode($exponents[2]->toBytes()) . "</DQ>\r\n" .
+                '  <InverseQ>' . Base64::encode($coefficients[2]->toBytes()) . "</InverseQ>\r\n" .
+                '  <D>' . Base64::encode($d->toBytes()) . "</D>\r\n" .
+                '</RSAKeyValue>';
     }
 
     /**
@@ -141,8 +141,8 @@ 
     static function savePublicKey(BigInteger $n, BigInteger $e)
     {
         return "<RSAKeyValue>\r\n" .
-               '  <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
-               '  <Exponent>' . Base64::encode($e->toBytes()) . "</Exponent>\r\n" .
-               '</RSAKeyValue>';
+                '  <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
+                '  <Exponent>' . Base64::encode($e->toBytes()) . "</Exponent>\r\n" .
+                '</RSAKeyValue>';
     }
 }

Spacing +13 added lines, -13 removed lines

@@ -56,7 +56,7 @@ 
         $use_errors = libxml_use_internal_errors(true);
 
         $dom = new \DOMDocument();
-        if (!$dom->loadXML('<xml>' . $key . '</xml>')) {
+        if (!$dom->loadXML('<xml>'.$key.'</xml>')) {
             return false;
         }
         $xpath = new \DOMXPath($dom);
@@ -118,15 +118,15 @@ 
         if (count($primes) != 2) {
             return false;
         }
-        return "<RSAKeyValue>\r\n" .
-               '  <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
-               '  <Exponent>' . Base64::encode($e->toBytes()) . "</Exponent>\r\n" .
-               '  <P>' . Base64::encode($primes[1]->toBytes()) . "</P>\r\n" .
-               '  <Q>' . Base64::encode($primes[2]->toBytes()) . "</Q>\r\n" .
-               '  <DP>' . Base64::encode($exponents[1]->toBytes()) . "</DP>\r\n" .
-               '  <DQ>' . Base64::encode($exponents[2]->toBytes()) . "</DQ>\r\n" .
-               '  <InverseQ>' . Base64::encode($coefficients[2]->toBytes()) . "</InverseQ>\r\n" .
-               '  <D>' . Base64::encode($d->toBytes()) . "</D>\r\n" .
+        return "<RSAKeyValue>\r\n".
+               '  <Modulus>'.Base64::encode($n->toBytes())."</Modulus>\r\n".
+               '  <Exponent>'.Base64::encode($e->toBytes())."</Exponent>\r\n".
+               '  <P>'.Base64::encode($primes[1]->toBytes())."</P>\r\n".
+               '  <Q>'.Base64::encode($primes[2]->toBytes())."</Q>\r\n".
+               '  <DP>'.Base64::encode($exponents[1]->toBytes())."</DP>\r\n".
+               '  <DQ>'.Base64::encode($exponents[2]->toBytes())."</DQ>\r\n".
+               '  <InverseQ>'.Base64::encode($coefficients[2]->toBytes())."</InverseQ>\r\n".
+               '  <D>'.Base64::encode($d->toBytes())."</D>\r\n".
                '</RSAKeyValue>';
     }
 
@@ -140,9 +140,9 @@ 
      */
     static function savePublicKey(BigInteger $n, BigInteger $e)
     {
-        return "<RSAKeyValue>\r\n" .
-               '  <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
-               '  <Exponent>' . Base64::encode($e->toBytes()) . "</Exponent>\r\n" .
+        return "<RSAKeyValue>\r\n".
+               '  <Modulus>'.Base64::encode($n->toBytes())."</Modulus>\r\n".
+               '  <Exponent>'.Base64::encode($e->toBytes())."</Exponent>\r\n".
                '</RSAKeyValue>';
     }
 }

includes/libraries/Authentication/phpseclib/Crypt/RSA/PKCS8.php

Indentation +4 added lines, -4 removed lines

@@ -150,12 +150,12 @@
             $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
 
             $RSAPrivateKey = "-----BEGIN ENCRYPTED PRIVATE KEY-----\r\n" .
-                 chunk_split(Base64::encode($RSAPrivateKey), 64) .
-                 '-----END ENCRYPTED PRIVATE KEY-----';
+                    chunk_split(Base64::encode($RSAPrivateKey), 64) .
+                    '-----END ENCRYPTED PRIVATE KEY-----';
         } else {
             $RSAPrivateKey = "-----BEGIN PRIVATE KEY-----\r\n" .
-                 chunk_split(Base64::encode($RSAPrivateKey), 64) .
-                 '-----END PRIVATE KEY-----';
+                    chunk_split(Base64::encode($RSAPrivateKey), 64) .
+                    '-----END PRIVATE KEY-----';
         }
 
         return $RSAPrivateKey;

Spacing +14 added lines, -14 removed lines

@@ -88,11 +88,11 @@ 
                 //     coefficient       INTEGER   -- ti
                 // }
                 $OtherPrimeInfo = pack('Ca*a*', self::ASN1_INTEGER, ASN1::encodeLength(strlen($primes[$i]->toBytes(true))), $primes[$i]->toBytes(true));
-                $OtherPrimeInfo.= pack('Ca*a*', self::ASN1_INTEGER, ASN1::encodeLength(strlen($exponents[$i]->toBytes(true))), $exponents[$i]->toBytes(true));
-                $OtherPrimeInfo.= pack('Ca*a*', self::ASN1_INTEGER, ASN1::encodeLength(strlen($coefficients[$i]->toBytes(true))), $coefficients[$i]->toBytes(true));
-                $OtherPrimeInfos.= pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($OtherPrimeInfo)), $OtherPrimeInfo);
+                $OtherPrimeInfo .= pack('Ca*a*', self::ASN1_INTEGER, ASN1::encodeLength(strlen($exponents[$i]->toBytes(true))), $exponents[$i]->toBytes(true));
+                $OtherPrimeInfo .= pack('Ca*a*', self::ASN1_INTEGER, ASN1::encodeLength(strlen($coefficients[$i]->toBytes(true))), $coefficients[$i]->toBytes(true));
+                $OtherPrimeInfos .= pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($OtherPrimeInfo)), $OtherPrimeInfo);
             }
-            $RSAPrivateKey.= pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($OtherPrimeInfos)), $OtherPrimeInfos);
+            $RSAPrivateKey .= pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($OtherPrimeInfos)), $OtherPrimeInfos);
         }
 
         $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
@@ -149,12 +149,12 @@ 
 
             $RSAPrivateKey = pack('Ca*a*', self::ASN1_SEQUENCE, ASN1::encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);
 
-            $RSAPrivateKey = "-----BEGIN ENCRYPTED PRIVATE KEY-----\r\n" .
-                 chunk_split(Base64::encode($RSAPrivateKey), 64) .
+            $RSAPrivateKey = "-----BEGIN ENCRYPTED PRIVATE KEY-----\r\n".
+                 chunk_split(Base64::encode($RSAPrivateKey), 64).
                  '-----END ENCRYPTED PRIVATE KEY-----';
         } else {
-            $RSAPrivateKey = "-----BEGIN PRIVATE KEY-----\r\n" .
-                 chunk_split(Base64::encode($RSAPrivateKey), 64) .
+            $RSAPrivateKey = "-----BEGIN PRIVATE KEY-----\r\n".
+                 chunk_split(Base64::encode($RSAPrivateKey), 64).
                  '-----END PRIVATE KEY-----';
         }
 
@@ -194,18 +194,18 @@ 
 
         // sequence(oid(1.2.840.113549.1.1.1), null)) = rsaEncryption.
         $rsaOID = "\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00"; // hex version of MA0GCSqGSIb3DQEBAQUA
-        $RSAPublicKey = chr(0) . $RSAPublicKey;
-        $RSAPublicKey = chr(3) . ASN1::encodeLength(strlen($RSAPublicKey)) . $RSAPublicKey;
+        $RSAPublicKey = chr(0).$RSAPublicKey;
+        $RSAPublicKey = chr(3).ASN1::encodeLength(strlen($RSAPublicKey)).$RSAPublicKey;
 
         $RSAPublicKey = pack(
             'Ca*a*',
             self::ASN1_SEQUENCE,
-            ASN1::encodeLength(strlen($rsaOID . $RSAPublicKey)),
-            $rsaOID . $RSAPublicKey
+            ASN1::encodeLength(strlen($rsaOID.$RSAPublicKey)),
+            $rsaOID.$RSAPublicKey
         );
 
-        $RSAPublicKey = "-----BEGIN PUBLIC KEY-----\r\n" .
-                        chunk_split(Base64::encode($RSAPublicKey), 64) .
+        $RSAPublicKey = "-----BEGIN PUBLIC KEY-----\r\n".
+                        chunk_split(Base64::encode($RSAPublicKey), 64).
                         '-----END PUBLIC KEY-----';
 
         return $RSAPublicKey;