nilsteampassnet / TeamPass

includes/libraries/phpcrypt/Padding.php

Braces +20 added lines, -15 removed lines

@@ -67,8 +67,9 @@ 
     {
         // if the size of padding is not greater than 1
         // just return true, no padding will be done
-        if (!($bytes > 0))
-            return true;
+        if (!($bytes > 0)) {
+                    return true;
+        }
 
         switch ($type)
         {
@@ -196,11 +197,11 @@ 
         $pos = strlen($text) - 1;
         $c = ord($text[$pos]);
 
-        if ($c == 0)
-            return true;
-        else if ($c == 1)
-            $text = substr($text, 0, -1);
-        else
+        if ($c == 0) {
+                    return true;
+        } else if ($c == 1) {
+                    $text = substr($text, 0, -1);
+        } else
         {
             // the total null bytes are 1 less than the value of the final byte
             $nc = $c - 1;
@@ -226,8 +227,9 @@ 
         // create the random pad bytes, we do one less than
         // needed because the last byte is reserved for the
         // number of padded bytes
-        for ($i = 0; $i < ($bytes - 1); ++$i)
-            $text .= chr(mt_rand(0, 255));
+        for ($i = 0; $i < ($bytes - 1); ++$i) {
+                    $text .= chr(mt_rand(0, 255));
+        }
 
         // add the byte to indicate the padding length
         $text .= chr($bytes);
@@ -248,8 +250,9 @@ 
 
         // if we got a null byte at the end of the string,
         // just return
-        if ($c == 0)
-            return true;
+        if ($c == 0) {
+                    return true;
+        }
 
         $text = substr($text, 0, $c);
         return true;
@@ -285,8 +288,9 @@ 
         $pos = strlen($text) - 1;
         $c = ord($text[$pos]);
 
-        if ($c == 0)
-            return true;
+        if ($c == 0) {
+                    return true;
+        }
 
         $text = preg_replace('/'.preg_quote(chr($c)).'{'.$c.'}$/', "", $text);
         return true;
@@ -309,8 +313,9 @@ 
 
         // if we are only padding one byte, then 0x80 is all we need
         // else we follow up with null bytes
-        if ($bytes > 1)
-            $text = str_pad($text, ($len - 1), chr(0), STR_PAD_RIGHT);
+        if ($bytes > 1) {
+                    $text = str_pad($text, ($len - 1), chr(0), STR_PAD_RIGHT);
+        }
 
         return true;
     }

includes/libraries/phpcrypt/ciphers/Skipjack.php

Braces +27 added lines, -18 removed lines

@@ -99,17 +99,21 @@ 
             $pos = (4 * $i) - 4;
             $subkey = substr($this->expanded_key, $pos, 4);
 
-            if ($i >= 1 && $i <= 8)
-                $this->ruleA($text, $subkey, $i);
+            if ($i >= 1 && $i <= 8) {
+                            $this->ruleA($text, $subkey, $i);
+            }
 
-            if ($i >= 9 && $i <= 16)
-                $this->ruleB($text, $subkey, $i);
+            if ($i >= 9 && $i <= 16) {
+                            $this->ruleB($text, $subkey, $i);
+            }
 
-            if ($i >= 17 && $i <= 24)
-                $this->ruleA($text, $subkey, $i);
+            if ($i >= 17 && $i <= 24) {
+                            $this->ruleA($text, $subkey, $i);
+            }
 
-            if ($i >= 25 && $i <= 32)
-                $this->ruleB($text, $subkey, $i);
+            if ($i >= 25 && $i <= 32) {
+                            $this->ruleB($text, $subkey, $i);
+            }
         }
 
         return true;
@@ -130,17 +134,21 @@ 
             $pos = ($i - 1) * 4;
             $subkey = substr($this->expanded_key, $pos, 4);
 
-            if ($i <= 32 && $i >= 25)
-                $this->ruleB($text, $subkey, $i);
+            if ($i <= 32 && $i >= 25) {
+                            $this->ruleB($text, $subkey, $i);
+            }
 
-            if ($i <= 24 && $i >= 17)
-                $this->ruleA($text, $subkey, $i);
+            if ($i <= 24 && $i >= 17) {
+                            $this->ruleA($text, $subkey, $i);
+            }
 
-            if ($i <= 16 && $i >= 9)
-                $this->ruleB($text, $subkey, $i);
+            if ($i <= 16 && $i >= 9) {
+                            $this->ruleB($text, $subkey, $i);
+            }
 
-            if ($i <= 8 && $i >= 1)
-                $this->ruleA($text, $subkey, $i);
+            if ($i <= 8 && $i >= 1) {
+                            $this->ruleA($text, $subkey, $i);
+            }
         }
 
         return true;
@@ -334,8 +342,9 @@ 
 
         for ($i = 0; $i < 128; ++$i)
         {
-            if ($pos == $key_bytes)
-                $pos = 0;
+            if ($pos == $key_bytes) {
+                            $pos = 0;
+            }
 
             $this->expanded_key .= $key[$pos];
             ++$pos;

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

Braces +22 added lines, -13 removed lines

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

includes/libraries/phpcrypt/ciphers/Blowfish.php

Braces +13 added lines, -16 removed lines

@@ -79,8 +79,7 @@ 
         {
             $key = substr($key, 0, 56);
             $keylen = 56;
-        }
-        else if ($keylen < 1)
+        } else if ($keylen < 1)
         {
             $msg = "No key given. The key must be between 1 - 56 bytes.";
             trigger_error($msg, E_USER_WARNING);
@@ -148,10 +147,11 @@ 
 
         for ($i = 0; $i < 16; ++$i)
         {
-            if ($this->operation() == parent::ENCRYPT)
-                $xl ^= self::$_p[$i];
-            else
-                $xl ^= self::$_p[17 - $i];
+            if ($this->operation() == parent::ENCRYPT) {
+                            $xl ^= self::$_p[$i];
+            } else {
+                            $xl ^= self::$_p[17 - $i];
+            }
 
             // perform F() on the left half, and XOR with the right half
             $xr = $this->F($xl) ^ $xr;
@@ -242,23 +242,19 @@ 
             {
                 self::$_p[$i] = $z0;
                 self::$_p[$i + 1] = $z1;
-            }
-            else if ($i >= 18 && $i < 274)
+            } else if ($i >= 18 && $i < 274)
             {
                 self::$_sbox1[$i - 18] = $z0;
                 self::$_sbox1[$i - 18 + 1] = $z1;
-            }
-            else if ($i >= 274 && $i < 530)
+            } else if ($i >= 274 && $i < 530)
             {
                 self::$_sbox2[$i - 274] = $z0;
                 self::$_sbox2[$i - 274 + 1] = $z1;
-            }
-            else if ($i >= 530 && $i < 786)
+            } else if ($i >= 530 && $i < 786)
             {
                 self::$_sbox3[$i - 530] = $z0;
                 self::$_sbox3[$i - 530 + 1] = $z1;
-            }
-            else if ($i >= 786 && $i < 1042)
+            } else if ($i >= 786 && $i < 1042)
             {
                 self::$_sbox4[$i - 786] = $z0;
                 self::$_sbox4[$i - 786 + 1] = $z1;
@@ -283,8 +279,9 @@ 
      */
     private function keyChunk($size = 1, $reset = false)
     {
-        if ($reset || $this->key_pos >= $this->keySize())
-            $this->key_pos = 0;
+        if ($reset || $this->key_pos >= $this->keySize()) {
+                    $this->key_pos = 0;
+        }
 
         $bytes = substr($this->key(), $this->key_pos, $size);
         $len = strlen($bytes);

includes/libraries/phpcrypt/ciphers/Enigma.php

Braces +15 added lines, -10 removed lines

@@ -158,8 +158,9 @@ 
                 $this->n1 = 0;
                 $this->n2++;
 
-                if ($this->n2 == self::ROTORSZ)
-                    $this->n2 = 0;
+                if ($this->n2 == self::ROTORSZ) {
+                                    $this->n2 = 0;
+                }
 
                 $this->nr2 = $this->n2;
             }
@@ -189,12 +190,14 @@ 
         $klen = $this->keySize();
 
         // get the key to exactly 13 bytes if it's less than 13
-        if ($klen < 13)
-            $this->xkey = str_pad($this->xkey, 13, chr(0), STR_PAD_RIGHT);
+        if ($klen < 13) {
+                    $this->xkey = str_pad($this->xkey, 13, chr(0), STR_PAD_RIGHT);
+        }
 
         $seed = 123;
-        for ($i = 0; $i < 13; ++$i)
-            $seed = parent::sInt32($seed) * ord($this->xkey[$i]) + $i;
+        for ($i = 0; $i < 13; ++$i) {
+                    $seed = parent::sInt32($seed) * ord($this->xkey[$i]) + $i;
+        }
 
         // sets $t1 and $deck
         for ($i = 0; $i < self::ROTORSZ; ++$i)
@@ -223,12 +226,14 @@ 
             $temp = $this->t1[$k];
             $this->t1[$k] = $this->t1[$ic];
             $this->t1[$ic] = $temp;
-            if ($this->t3[$k] != 0)
-                continue;
+            if ($this->t3[$k] != 0) {
+                            continue;
+            }
 
             $ic = ($random & self::MASK) % $k;
-            while ($this->t3[$ic] != 0)
-                $ic = ($ic + 1) % $k;
+            while ($this->t3[$ic] != 0) {
+                            $ic = ($ic + 1) % $k;
+            }
 
             $this->t3[$k] = $ic;
             $this->t3[$ic] = $k;

includes/libraries/phpcrypt/ciphers/RC2.php

Braces +6 added lines, -4 removed lines

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

includes/libraries/phpcrypt/ciphers/CAST128.php

Braces +7 added lines, -6 removed lines

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

includes/libraries/phpcrypt/ciphers/Rijndael.php

Braces +103 added lines, -77 removed lines

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

includes/libraries/phpcrypt/ciphers/SimpleXOR.php

Braces +3 added lines, -2 removed lines

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