nilsteampassnet / TeamPass

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;

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

Spacing +1 added lines, -1 removed lines

@@ -119,7 +119,7 @@
         // mpint     e
         // mpint     n
         $RSAPublicKey = pack('Na*Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($publicExponent), $publicExponent, strlen($modulus), $modulus);
-        $RSAPublicKey = 'ssh-rsa ' . Base64::encode($RSAPublicKey) . ' ' . self::$comment;
+        $RSAPublicKey = 'ssh-rsa '.Base64::encode($RSAPublicKey).' '.self::$comment;
 
         return $RSAPublicKey;
     }

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

Indentation +3 added lines, -3 removed lines

@@ -693,9 +693,9 @@
             // Creates the inline-crypt function
             $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
                 array(
-                   'init_crypt'    => $init_crypt,
-                   'encrypt_block' => $encrypt_block,
-                   'decrypt_block' => $decrypt_block
+                    'init_crypt'    => $init_crypt,
+                    'encrypt_block' => $encrypt_block,
+                    'decrypt_block' => $decrypt_block
                 )
             );
         }

Spacing +15 added lines, -15 removed lines

@@ -295,7 +295,7 @@ 
                     return false;
                 }
                 $this->cipher_name_openssl_ecb = 'rc2-ecb';
-                $this->cipher_name_openssl = 'rc2-' . $this->_openssl_translate_mode();
+                $this->cipher_name_openssl = 'rc2-'.$this->_openssl_translate_mode();
         }
 
         return parent::isValidEngine($engine);
@@ -315,7 +315,7 @@ 
     function setKeyLength($length)
     {
         if ($length < 8 || $length > 1024) {
-            throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys between 1 and 1024 bits, inclusive, are supported');
+            throw new \LengthException('Key size of '.$length.' bits is not supported by this algorithm. Only keys between 1 and 1024 bits, inclusive, are supported');
         }
 
         $this->default_key_length = $this->current_key_length = $length;
@@ -358,7 +358,7 @@ 
         }
 
         if ($t1 < 1 || $t1 > 1024) {
-            throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys between 1 and 1024 bits, inclusive, are supported');
+            throw new \LengthException('Key size of '.$length.' bits is not supported by this algorithm. Only keys between 1 and 1024 bits, inclusive, are supported');
         }
 
         $this->current_key_length = $t1;
@@ -575,18 +575,18 @@ 
      */
     function _setupInlineCrypt()
     {
-        $lambda_functions =& self::_getLambdaFunctions();
+        $lambda_functions = & self::_getLambdaFunctions();
 
         // The first 10 generated $lambda_functions will use the $keys hardcoded as integers
         // for the mixing rounds, for better inline crypt performance [~20% faster].
         // But for memory reason we have to limit those ultra-optimized $lambda_functions to an amount of 10.
         // (Currently, for Crypt_RC2, one generated $lambda_function cost on php5.5@32bit ~60kb unfreeable mem and ~100kb 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_RC2, {$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);
         }
 
         // Is there a re-usable $lambda_functions in there?
@@ -601,7 +601,7 @@ 
                 default:
                     $keys = array();
                     foreach ($this->keys as $k => $v) {
-                        $keys[$k] = '$keys[' . $k . ']';
+                        $keys[$k] = '$keys['.$k.']';
                     }
             }
 
@@ -622,16 +622,16 @@ 
             for (;;) {
                 // Mixing round.
                 $encrypt_block .= '
-                    $r0 = (($r0 + ' . $keys[$j++] . ' +
+                    $r0 = (($r0 + ' . $keys[$j++].' +
                            ((($r1 ^ $r2) & $r3) ^ $r1)) & 0xFFFF) << 1;
                     $r0 |= $r0 >> 16;
-                    $r1 = (($r1 + ' . $keys[$j++] . ' +
+                    $r1 = (($r1 + ' . $keys[$j++].' +
                            ((($r2 ^ $r3) & $r0) ^ $r2)) & 0xFFFF) << 2;
                     $r1 |= $r1 >> 16;
-                    $r2 = (($r2 + ' . $keys[$j++] . ' +
+                    $r2 = (($r2 + ' . $keys[$j++].' +
                            ((($r3 ^ $r0) & $r1) ^ $r3)) & 0xFFFF) << 3;
                     $r2 |= $r2 >> 16;
-                    $r3 = (($r3 + ' . $keys[$j++] . ' +
+                    $r3 = (($r3 + ' . $keys[$j++].' +
                            ((($r0 ^ $r1) & $r2) ^ $r0)) & 0xFFFF) << 5;
                     $r3 |= $r3 >> 16;';
 
@@ -661,16 +661,16 @@ 
                 // R-mixing round.
                 $decrypt_block .= '
                     $r3 = ($r3 | ($r3 << 16)) >> 5;
-                    $r3 = ($r3 - ' . $keys[--$j] . ' -
+                    $r3 = ($r3 - ' . $keys[--$j].' -
                            ((($r0 ^ $r1) & $r2) ^ $r0)) & 0xFFFF;
                     $r2 = ($r2 | ($r2 << 16)) >> 3;
-                    $r2 = ($r2 - ' . $keys[--$j] . ' -
+                    $r2 = ($r2 - ' . $keys[--$j].' -
                            ((($r3 ^ $r0) & $r1) ^ $r3)) & 0xFFFF;
                     $r1 = ($r1 | ($r1 << 16)) >> 2;
-                    $r1 = ($r1 - ' . $keys[--$j] . ' -
+                    $r1 = ($r1 - ' . $keys[--$j].' -
                            ((($r2 ^ $r3) & $r0) ^ $r2)) & 0xFFFF;
                     $r0 = ($r0 | ($r0 << 16)) >> 1;
-                    $r0 = ($r0 - ' . $keys[--$j] . ' -
+                    $r0 = ($r0 - ' . $keys[--$j].' -
                            ((($r1 ^ $r2) & $r3) ^ $r1)) & 0xFFFF;';
 
                 if ($j === $limit) {

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

Indentation +6 added lines, -6 removed lines

@@ -96,12 +96,12 @@
             session_start();
 
             $v = (isset($_SERVER) ? self::safe_serialize($_SERVER) : '') .
-                 (isset($_POST) ? self::safe_serialize($_POST) : '') .
-                 (isset($_GET) ? self::safe_serialize($_GET) : '') .
-                 (isset($_COOKIE) ? self::safe_serialize($_COOKIE) : '') .
-                 self::safe_serialize($GLOBALS) .
-                 self::safe_serialize($_SESSION) .
-                 self::safe_serialize($_OLD_SESSION);
+                    (isset($_POST) ? self::safe_serialize($_POST) : '') .
+                    (isset($_GET) ? self::safe_serialize($_GET) : '') .
+                    (isset($_COOKIE) ? self::safe_serialize($_COOKIE) : '') .
+                    self::safe_serialize($GLOBALS) .
+                    self::safe_serialize($_SESSION) .
+                    self::safe_serialize($_OLD_SESSION);
             $v = $seed = $_SESSION['seed'] = sha1($v, true);
             if (!isset($_SESSION['count'])) {
                 $_SESSION['count'] = 0;

Spacing +10 added lines, -10 removed lines

@@ -95,12 +95,12 @@ 
             session_cache_limiter('');
             session_start();
 
-            $v = (isset($_SERVER) ? self::safe_serialize($_SERVER) : '') .
-                 (isset($_POST) ? self::safe_serialize($_POST) : '') .
-                 (isset($_GET) ? self::safe_serialize($_GET) : '') .
-                 (isset($_COOKIE) ? self::safe_serialize($_COOKIE) : '') .
-                 self::safe_serialize($GLOBALS) .
-                 self::safe_serialize($_SESSION) .
+            $v = (isset($_SERVER) ? self::safe_serialize($_SERVER) : '').
+                 (isset($_POST) ? self::safe_serialize($_POST) : '').
+                 (isset($_GET) ? self::safe_serialize($_GET) : '').
+                 (isset($_COOKIE) ? self::safe_serialize($_COOKIE) : '').
+                 self::safe_serialize($GLOBALS).
+                 self::safe_serialize($_SESSION).
                  self::safe_serialize($_OLD_SESSION);
             $v = $seed = $_SESSION['seed'] = sha1($v, true);
             if (!isset($_SESSION['count'])) {
@@ -133,8 +133,8 @@ 
             // http://tools.ietf.org/html/rfc4253#section-7.2
             //
             // see the is_string($crypto) part for an example of how to expand the keys
-            $key = sha1($seed . 'A', true);
-            $iv = sha1($seed . 'C', true);
+            $key = sha1($seed.'A', true);
+            $iv = sha1($seed.'C', true);
 
             // ciphers are used as per the nist.gov link below. also, see this link:
             //
@@ -159,7 +159,7 @@ 
                     $crypto = new RC4();
                     break;
                 default:
-                    throw new \RuntimeException(__CLASS__ . ' requires at least one symmetric cipher be loaded');
+                    throw new \RuntimeException(__CLASS__.' requires at least one symmetric cipher be loaded');
             }
 
             $crypto->setKey(substr($key, 0, $crypto->getKeyLength() >> 3));
@@ -182,7 +182,7 @@ 
             $i = $crypto->encrypt(microtime()); // strlen(microtime()) == 21
             $r = $crypto->encrypt($i ^ $v); // strlen($v) == 20
             $v = $crypto->encrypt($r ^ $i); // strlen($r) == 20
-            $result.= $r;
+            $result .= $r;
         }
         return substr($result, 0, $length);
     }

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

Indentation +15 added lines, -15 removed lines

@@ -372,9 +372,9 @@ 
         // subWord
         for ($i = 0; $i < $Nb; ++$i) {
             $state[$i] =   $sbox[$state[$i]       & 0x000000FF]        |
-                          ($sbox[$state[$i] >>  8 & 0x000000FF] <<  8) |
-                          ($sbox[$state[$i] >> 16 & 0x000000FF] << 16) |
-                          ($sbox[$state[$i] >> 24 & 0x000000FF] << 24);
+                            ($sbox[$state[$i] >>  8 & 0x000000FF] <<  8) |
+                            ($sbox[$state[$i] >> 16 & 0x000000FF] << 16) |
+                            ($sbox[$state[$i] >> 24 & 0x000000FF] << 24);
         }
 
         // shiftRows + addRoundKey
@@ -387,7 +387,7 @@ 
                         ($state[$j] & 0x00FF0000) ^
                         ($state[$k] & 0x0000FF00) ^
                         ($state[$l] & 0x000000FF) ^
-                         $w[$i];
+                            $w[$i];
             ++$i;
             $j = ($j + 1) % $Nb;
             $k = ($k + 1) % $Nb;
@@ -475,9 +475,9 @@ 
                     ($state[$l] & 0x000000FF);
 
             $temp[$i] = $dw[$i] ^ ($isbox[$word       & 0x000000FF]        |
-                                  ($isbox[$word >>  8 & 0x000000FF] <<  8) |
-                                  ($isbox[$word >> 16 & 0x000000FF] << 16) |
-                                  ($isbox[$word >> 24 & 0x000000FF] << 24));
+                                    ($isbox[$word >>  8 & 0x000000FF] <<  8) |
+                                    ($isbox[$word >> 16 & 0x000000FF] << 16) |
+                                    ($isbox[$word >> 24 & 0x000000FF] << 24));
             ++$i;
             $j = ($j + 1) % $Nb;
             $k = ($k + 1) % $Nb;
@@ -625,9 +625,9 @@ 
         }
 
         return  $sbox[$word       & 0x000000FF]        |
-               ($sbox[$word >>  8 & 0x000000FF] <<  8) |
-               ($sbox[$word >> 16 & 0x000000FF] << 16) |
-               ($sbox[$word >> 24 & 0x000000FF] << 24);
+                ($sbox[$word >>  8 & 0x000000FF] <<  8) |
+                ($sbox[$word >> 16 & 0x000000FF] << 16) |
+                ($sbox[$word >> 24 & 0x000000FF] << 24);
     }
 
     /**
@@ -966,11 +966,11 @@ 
 
             $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
                 array(
-                   'init_crypt'    => '',
-                   'init_encrypt'  => $init_encrypt,
-                   'init_decrypt'  => $init_decrypt,
-                   'encrypt_block' => $encrypt_block,
-                   'decrypt_block' => $decrypt_block
+                    'init_crypt'    => '',
+                    'init_encrypt'  => $init_encrypt,
+                    'init_decrypt'  => $init_decrypt,
+                    'encrypt_block' => $encrypt_block,
+                    'decrypt_block' => $decrypt_block
                 )
             );
         }

Spacing +40 added lines, -40 removed lines

@@ -217,7 +217,7 @@ 
                 $this->key_length = $length >> 3;
                 break;
             default:
-                throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys of sizes 128, 160, 192, 224 or 256 bits are supported');
+                throw new \LengthException('Key size of '.$length.' bits is not supported by this algorithm. Only keys of sizes 128, 160, 192, 224 or 256 bits are supported');
         }
 
         parent::setKeyLength($length);
@@ -243,7 +243,7 @@ 
             case 32:
                 break;
             default:
-                throw new \LengthException('Key of size ' . strlen($key) . ' not supported by this algorithm. Only keys of sizes 16, 20, 24, 28 or 32 are supported');
+                throw new \LengthException('Key of size '.strlen($key).' not supported by this algorithm. Only keys of sizes 16, 20, 24, 28 or 32 are supported');
         }
 
         parent::setKey($key);
@@ -267,7 +267,7 @@ 
             case 256:
                 break;
             default:
-                throw new \LengthException('Key size of ' . $length . ' bits is not supported by this algorithm. Only keys of sizes 128, 160, 192, 224 or 256 bits are supported');
+                throw new \LengthException('Key size of '.$length.' bits is not supported by this algorithm. Only keys of sizes 128, 160, 192, 224 or 256 bits are supported');
         }
 
         $this->Nb = $length >> 5;
@@ -293,11 +293,11 @@ 
                 if ($this->block_size != 16) {
                     return false;
                 }
-                $this->cipher_name_openssl_ecb = 'aes-' . ($this->key_length << 3) . '-ecb';
-                $this->cipher_name_openssl = 'aes-' . ($this->key_length << 3) . '-' . $this->_openssl_translate_mode();
+                $this->cipher_name_openssl_ecb = 'aes-'.($this->key_length << 3).'-ecb';
+                $this->cipher_name_openssl = 'aes-'.($this->key_length << 3).'-'.$this->_openssl_translate_mode();
                 break;
             case self::ENGINE_MCRYPT:
-                $this->cipher_name_mcrypt = 'rijndael-' . ($this->block_size << 3);
+                $this->cipher_name_mcrypt = 'rijndael-'.($this->block_size << 3);
                 if ($this->key_length % 8) { // is it a 160/224-bit key?
                     // mcrypt is not usable for them, only for 128/192/256-bit keys
                     return false;
@@ -358,8 +358,8 @@ 
             while ($i < $Nb) {
                 $temp[$i] = $t0[$state[$i] >> 24 & 0x000000FF] ^
                             $t1[$state[$j] >> 16 & 0x000000FF] ^
-                            $t2[$state[$k] >>  8 & 0x000000FF] ^
-                            $t3[$state[$l]       & 0x000000FF] ^
+                            $t2[$state[$k] >> 8 & 0x000000FF] ^
+                            $t3[$state[$l] & 0x000000FF] ^
                             $w[++$wc];
                 ++$i;
                 $j = ($j + 1) % $Nb;
@@ -371,8 +371,8 @@ 
 
         // subWord
         for ($i = 0; $i < $Nb; ++$i) {
-            $state[$i] =   $sbox[$state[$i]       & 0x000000FF]        |
-                          ($sbox[$state[$i] >>  8 & 0x000000FF] <<  8) |
+            $state[$i] = $sbox[$state[$i] & 0x000000FF] |
+                          ($sbox[$state[$i] >> 8 & 0x000000FF] << 8) |
                           ($sbox[$state[$i] >> 16 & 0x000000FF] << 16) |
                           ($sbox[$state[$i] >> 24 & 0x000000FF] << 24);
         }
@@ -451,8 +451,8 @@ 
             while ($i < $Nb) {
                 $temp[$i] = $dt0[$state[$i] >> 24 & 0x000000FF] ^
                             $dt1[$state[$j] >> 16 & 0x000000FF] ^
-                            $dt2[$state[$k] >>  8 & 0x000000FF] ^
-                            $dt3[$state[$l]       & 0x000000FF] ^
+                            $dt2[$state[$k] >> 8 & 0x000000FF] ^
+                            $dt3[$state[$l] & 0x000000FF] ^
                             $dw[++$wc];
                 ++$i;
                 $j = ($j + 1) % $Nb;
@@ -474,8 +474,8 @@ 
                     ($state[$k] & 0x0000FF00) |
                     ($state[$l] & 0x000000FF);
 
-            $temp[$i] = $dw[$i] ^ ($isbox[$word       & 0x000000FF]        |
-                                  ($isbox[$word >>  8 & 0x000000FF] <<  8) |
+            $temp[$i] = $dw[$i] ^ ($isbox[$word & 0x000000FF] |
+                                  ($isbox[$word >> 8 & 0x000000FF] << 8) |
                                   ($isbox[$word >> 16 & 0x000000FF] << 16) |
                                   ($isbox[$word >> 24 & 0x000000FF] << 24));
             ++$i;
@@ -582,8 +582,8 @@ 
                         $dw = $this->_subWord($this->w[$row][$j]);
                         $temp[$j] = $dt0[$dw >> 24 & 0x000000FF] ^
                                     $dt1[$dw >> 16 & 0x000000FF] ^
-                                    $dt2[$dw >>  8 & 0x000000FF] ^
-                                    $dt3[$dw       & 0x000000FF];
+                                    $dt2[$dw >> 8 & 0x000000FF] ^
+                                    $dt3[$dw & 0x000000FF];
                         $j++;
                     }
                     $this->dw[$row] = $temp;
@@ -621,11 +621,11 @@ 
     {
         static $sbox;
         if (empty($sbox)) {
-            list(, , , , $sbox) = $this->_getTables();
+            list(,,,, $sbox) = $this->_getTables();
         }
 
-        return  $sbox[$word       & 0x000000FF]        |
-               ($sbox[$word >>  8 & 0x000000FF] <<  8) |
+        return  $sbox[$word & 0x000000FF] |
+               ($sbox[$word >> 8 & 0x000000FF] << 8) |
                ($sbox[$word >> 16 & 0x000000FF] << 16) |
                ($sbox[$word >> 24 & 0x000000FF] << 24);
     }
@@ -684,9 +684,9 @@ 
             ));
 
             foreach ($t3 as $t3i) {
-                $t0[] = (($t3i << 24) & 0xFF000000) | (($t3i >>  8) & 0x00FFFFFF);
+                $t0[] = (($t3i << 24) & 0xFF000000) | (($t3i >> 8) & 0x00FFFFFF);
                 $t1[] = (($t3i << 16) & 0xFFFF0000) | (($t3i >> 16) & 0x0000FFFF);
-                $t2[] = (($t3i <<  8) & 0xFFFFFF00) | (($t3i >> 24) & 0x000000FF);
+                $t2[] = (($t3i << 8) & 0xFFFFFF00) | (($t3i >> 24) & 0x000000FF);
             }
 
             $tables = array(
@@ -768,9 +768,9 @@ 
             ));
 
             foreach ($dt3 as $dt3i) {
-                $dt0[] = (($dt3i << 24) & 0xFF000000) | (($dt3i >>  8) & 0x00FFFFFF);
+                $dt0[] = (($dt3i << 24) & 0xFF000000) | (($dt3i >> 8) & 0x00FFFFFF);
                 $dt1[] = (($dt3i << 16) & 0xFFFF0000) | (($dt3i >> 16) & 0x0000FFFF);
-                $dt2[] = (($dt3i <<  8) & 0xFFFFFF00) | (($dt3i >> 24) & 0x000000FF);
+                $dt2[] = (($dt3i << 8) & 0xFFFFFF00) | (($dt3i >> 24) & 0x000000FF);
             };
 
             $tables = array(
@@ -815,17 +815,17 @@ 
         // So here we are'nt under the same heavy timing-stress as we are in _de/encryptBlock() or de/encrypt().
         // However...the here generated function- $code, stored as php callback in $this->inline_crypt, must work as fast as even possible.
 
-        $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 Crypt_Rijndael/AES, one generated $lambda_function cost on php5.5@32bit ~80kb unfreeable mem and ~130kb 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 uniqe hash for our generated code
         $code_hash = "Crypt_Rijndael, {$this->mode}, {$this->Nr}, {$this->Nb}";
         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])) {
@@ -839,8 +839,8 @@ 
                     break;
                 default:
                     for ($i = 0, $cw = count($this->w); $i < $cw; ++$i) {
-                        $w[]  = '$w['  . $i . ']';
-                        $dw[] = '$dw[' . $i . ']';
+                        $w[]  = '$w['.$i.']';
+                        $dw[] = '$dw['.$i.']';
                     }
                     $init_encrypt = '$w  = $self->w;';
                     $init_decrypt = '$dw = $self->dw;';
@@ -851,7 +851,7 @@ 
             $c  = $this->c;
 
             // Generating encrypt code:
-            $init_encrypt.= '
+            $init_encrypt .= '
                 static $tables;
                 if (empty($tables)) {
                     $tables = &$self->_getTables();
@@ -877,9 +877,9 @@ 
             for ($round = 1; $round < $Nr; ++$round) {
                 list($s, $e) = array($e, $s);
                 for ($i = 0; $i < $Nb; ++$i) {
-                    $encrypt_block.=
+                    $encrypt_block .=
                         '$'.$e.$i.' =
-                        $t0[($'.$s.$i                  .' >> 24) & 0xff] ^
+                        $t0[($'.$s.$i.' >> 24) & 0xff] ^
                         $t1[($'.$s.(($i + $c[1]) % $Nb).' >> 16) & 0xff] ^
                         $t2[($'.$s.(($i + $c[2]) % $Nb).' >>  8) & 0xff] ^
                         $t3[ $'.$s.(($i + $c[3]) % $Nb).'        & 0xff] ^
@@ -889,7 +889,7 @@ 
 
             // Finalround: subWord + shiftRows + addRoundKey
             for ($i = 0; $i < $Nb; ++$i) {
-                $encrypt_block.=
+                $encrypt_block .=
                     '$'.$e.$i.' =
                      $sbox[ $'.$e.$i.'        & 0xff]        |
                     ($sbox[($'.$e.$i.' >>  8) & 0xff] <<  8) |
@@ -898,8 +898,8 @@ 
             }
             $encrypt_block .= '$in = pack("N*"'."\n";
             for ($i = 0; $i < $Nb; ++$i) {
-                $encrypt_block.= ',
-                    ($'.$e.$i                  .' & '.((int)0xFF000000).') ^
+                $encrypt_block .= ',
+                    ($'.$e.$i.' & '.((int) 0xFF000000).') ^
                     ($'.$e.(($i + $c[1]) % $Nb).' &         0x00FF0000   ) ^
                     ($'.$e.(($i + $c[2]) % $Nb).' &         0x0000FF00   ) ^
                     ($'.$e.(($i + $c[3]) % $Nb).' &         0x000000FF   ) ^
@@ -908,7 +908,7 @@ 
             $encrypt_block .= ');';
 
             // Generating decrypt code:
-            $init_decrypt.= '
+            $init_decrypt .= '
                 static $invtables;
                 if (empty($invtables)) {
                     $invtables = &$self->_getInvTables();
@@ -934,9 +934,9 @@ 
             for ($round = 1; $round < $Nr; ++$round) {
                 list($s, $e) = array($e, $s);
                 for ($i = 0; $i < $Nb; ++$i) {
-                    $decrypt_block.=
+                    $decrypt_block .=
                         '$'.$e.$i.' =
-                        $dt0[($'.$s.$i                        .' >> 24) & 0xff] ^
+                        $dt0[($'.$s.$i.' >> 24) & 0xff] ^
                         $dt1[($'.$s.(($Nb + $i - $c[1]) % $Nb).' >> 16) & 0xff] ^
                         $dt2[($'.$s.(($Nb + $i - $c[2]) % $Nb).' >>  8) & 0xff] ^
                         $dt3[ $'.$s.(($Nb + $i - $c[3]) % $Nb).'        & 0xff] ^
@@ -946,7 +946,7 @@ 
 
             // Finalround: subWord + shiftRows + addRoundKey
             for ($i = 0; $i < $Nb; ++$i) {
-                $decrypt_block.=
+                $decrypt_block .=
                     '$'.$e.$i.' =
                      $isbox[ $'.$e.$i.'        & 0xff]        |
                     ($isbox[($'.$e.$i.' >>  8) & 0xff] <<  8) |
@@ -955,8 +955,8 @@ 
             }
             $decrypt_block .= '$in = pack("N*"'."\n";
             for ($i = 0; $i < $Nb; ++$i) {
-                $decrypt_block.= ',
-                    ($'.$e.$i.                        ' & '.((int)0xFF000000).') ^
+                $decrypt_block .= ',
+                    ($'.$e.$i.' & '.((int) 0xFF000000).') ^
                     ($'.$e.(($Nb + $i - $c[1]) % $Nb).' &         0x00FF0000   ) ^
                     ($'.$e.(($Nb + $i - $c[2]) % $Nb).' &         0x0000FF00   ) ^
                     ($'.$e.(($Nb + $i - $c[3]) % $Nb).' &         0x000000FF   ) ^

includes/libraries/Authentication/phpseclib/Common/Functions/ASN1.php

Spacing +1 added lines, -1 removed lines

@@ -37,7 +37,7 @@
     {
         $length = ord(Strings::shift($string));
         if ($length & 0x80) { // definite length, long form
-            $length&= 0x7F;
+            $length &= 0x7F;
             $temp = Strings::shift($string, $length);
             list(, $length) = unpack('N', substr(str_pad($temp, 4, chr(0), STR_PAD_LEFT), -4));
         }