SymmetricCiphers: don't cache "hi-optimized code"

Also add a new engine - ENGINE_EVAL. Previously ENGINE_INTERNAL
had three different modes - a "hi-optimized" version, a
"lo-optimized" version and a version that didn't depend on
create_function and there wasn't a way to really isolate these
modes and test them individually.

phpseclib/Crypt/Blowfish.php

@@ -478,22 +478,6 @@ class Blowfish extends BlockCipher
      */
     protected function setupInlineCrypt()
     {
-        $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);
-
-        // 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);
-        }
-
-        if (!isset($lambda_functions[$code_hash])) {
-            switch (true) {
-                case $gen_hi_opt_code:
         $p = $this->bctx['p'];
         $init_crypt = '
             static $sb_0, $sb_1, $sb_2, $sb_3;
@@ -504,18 +488,6 @@ class Blowfish extends BlockCipher
                 $sb_3 = $this->bctx["sb"][3];
             }
         ';
-                    break;
-                default:
-                    $p   = [];
-                    for ($i = 0; $i < 18; ++$i) {
-                        $p[] = '$p_' . $i;
-                    }
-                    $init_crypt = '
-                        list($sb_0, $sb_1, $sb_2, $sb_3) = $this->bctx["sb"];
-                        list(' . implode(',', $p) . ') = $this->bctx["p"];
-
-                    ';
-            }
 
         // Generating encrypt code:
         $encrypt_block = '
@@ -544,7 +516,6 @@ class Blowfish extends BlockCipher
                 $l ^ ' . $p[16] . '
             );
         ';
-
          // Generating decrypt code:
         $decrypt_block = '
             $in = unpack("N*", $in);
@@ -575,7 +546,7 @@ class Blowfish extends BlockCipher
             );
         ';
 
-            $lambda_functions[$code_hash] = $this->createInlineCryptFunction(
+        $this->inline_crypt = $this->createInlineCryptFunction(
             [
                'init_crypt'    => $init_crypt,
                'init_encrypt'  => '',
@@ -585,6 +556,4 @@ class Blowfish extends BlockCipher
             ]
         );
     }
-        $this->inline_crypt = \Closure::bind($lambda_functions[$code_hash], $this, $this->getClassContext());
-    }
 }

phpseclib/Crypt/Common/SymmetricKey.php

@@ -92,15 +92,6 @@ abstract class SymmetricKey
     const MODE_STREAM = 5;
     /**#@-*/
 
-    /**
-     * Whirlpool available flag
-     *
-     * @see \phpseclib\Crypt\Common\SymmetricKey::_hashInlineCryptFunction()
-     * @var bool
-     * @access private
-     */
-    private static $WHIRLPOOL_AVAILABLE;
-
     /**#@+
      * @access private
      * @see \phpseclib\Crypt\Common\SymmetricKey::__construct()
@@ -110,13 +101,17 @@ abstract class SymmetricKey
      */
     const ENGINE_INTERNAL = 1;
     /**
-     * Base value for the mcrypt implementation $engine switch
+     * Base value for the eval() implementation $engine switch
      */
-    const ENGINE_MCRYPT = 2;
+    const ENGINE_EVAL = 2;
     /**
      * Base value for the mcrypt implementation $engine switch
      */
-    const ENGINE_OPENSSL = 3;
+    const ENGINE_MCRYPT = 3;
+    /**
+     * Base value for the mcrypt implementation $engine switch
+     */
+    const ENGINE_OPENSSL = 4;
     /**#@-*/
 
     /**
@@ -480,11 +475,6 @@ abstract class SymmetricKey
         }
 
         $this->mode = $mode;
-
-        // Determining whether inline crypting can be used by the cipher
-        if ($this->use_inline_crypt !== false) {
-            $this->use_inline_crypt = true;
-        }
     }
 
     /**
@@ -982,7 +972,7 @@ abstract class SymmetricKey
             $this->setup();
             $this->changed = false;
         }
-        if ($this->use_inline_crypt) {
+        if ($this->engine === self::ENGINE_EVAL) {
             $inline = $this->inline_crypt;
             return $inline('encrypt', $plaintext);
         }
@@ -1266,7 +1256,7 @@ abstract class SymmetricKey
             $this->setup();
             $this->changed = false;
         }
-        if ($this->use_inline_crypt) {
+        if ($this->engine === self::ENGINE_EVAL) {
             $inline = $this->inline_crypt;
             return $inline('decrypt', $ciphertext);
         }
@@ -1696,9 +1686,7 @@ abstract class SymmetricKey
                 }
                 $this->openssl_emulate_ctr = false;
                 $result = $this->cipher_name_openssl &&
-                          extension_loaded('openssl') &&
+                          extension_loaded('openssl');
-                          // PHP 5.3.0 - 5.3.2 did not let you set IV's
-                          version_compare(PHP_VERSION, '5.3.3', '>=');
                 if (!$result) {
                     return false;
                 }
@@ -1721,6 +1709,8 @@ abstract class SymmetricKey
                 return $this->cipher_name_mcrypt &&
                        extension_loaded('mcrypt') &&
                        in_array($this->cipher_name_mcrypt, @mcrypt_list_algorithms());
+            case self::ENGINE_EVAL:
+                return method_exists($this, 'setupInlineCrypt');
             case self::ENGINE_INTERNAL:
                 return true;
         }
@@ -1737,7 +1727,9 @@ abstract class SymmetricKey
      *
      * - \phpseclib\Crypt\Common\SymmetricKey::ENGINE_MCRYPT   [fast]
      *
-     * - \phpseclib\Crypt\Common\SymmetricKey::ENGINE_INTERNAL [slow]
+     * - \phpseclib\Crypt\Common\SymmetricKey::ENGINE_EVAL     [slow]
+     *
+     * - \phpseclib\Crypt\Common\SymmetricKey::ENGINE_INTERNAL [slowest]
      *
      * If the preferred crypt engine is not available the fastest available one will be used
      *
@@ -1751,6 +1743,7 @@ abstract class SymmetricKey
             //case self::ENGINE_OPENSSL;
             case self::ENGINE_MCRYPT:
             case self::ENGINE_INTERNAL:
+            case self::ENGINE_EVAL:
                 $this->preferredEngine = $engine;
                 break;
             default:
@@ -1784,7 +1777,8 @@ abstract class SymmetricKey
         $candidateEngines = [
             $this->preferredEngine,
             self::ENGINE_OPENSSL,
-            self::ENGINE_MCRYPT
+            self::ENGINE_MCRYPT,
+            self::ENGINE_EVAL
         ];
         foreach ($candidateEngines as $engine) {
             if ($this->isValidEngine($engine)) {
@@ -1876,7 +1870,7 @@ abstract class SymmetricKey
         $this->clearBuffers();
         $this->setupKey();
 
-        if ($this->use_inline_crypt) {
+        if ($this->engine === self::ENGINE_EVAL) {
             $this->setupInlineCrypt();
         }
     }
@@ -2064,9 +2058,7 @@ abstract class SymmetricKey
      *
      *     _setupInlineCrypt() would be called only if:
      *
-     *     - $engine == self::ENGINE_INTERNAL and
+     *     - $this->engine === self::ENGINE_EVAL
-     *
-     *     - $use_inline_crypt === true
      *
      *     - each time on _setup(), after(!) _setupKey()
      *
@@ -2114,16 +2106,7 @@ abstract class SymmetricKey
      * @access private
      * @internal If a Crypt_* class providing inline crypting it must extend _setupInlineCrypt()
      */
-    protected function setupInlineCrypt()
+    //protected function setupInlineCrypt();
-    {
-        // If, for any reason, an extending \phpseclib\Crypt\Common\SymmetricKey() \phpseclib\Crypt\* class
-        // not using inline crypting then it must be ensured that: $this->use_inline_crypt = false
-        // ie in the class var declaration of $use_inline_crypt in general for the \phpseclib\Crypt\* class,
-        // in the constructor at object instance-time
-        // or, if it's runtime-specific, at runtime
-
-        $this->use_inline_crypt = false;
-    }
 
     /**
      * Creates the performance-optimized function for en/decrypt()
@@ -2586,63 +2569,7 @@ abstract class SymmetricKey
 
         eval('$func = function ($_action, $_text) { ' . $init_crypt . 'if ($_action == "encrypt") { ' . $encrypt . ' } else { ' . $decrypt . ' }};');
 
-        return $func;
+        return \Closure::bind($func, $this, $this->getClassContext());
-    }
-
-    /**
-     * Holds the lambda_functions table (classwide)
-     *
-     * Each name of the lambda function, created from
-     * _setupInlineCrypt() && _createInlineCryptFunction()
-     * is stored, classwide (!), here for reusing.
-     *
-     * The string-based index of $function is a classwide
-     * unique value representing, at least, the $mode of
-     * operation (or more... depends of the optimizing level)
-     * for which $mode the lambda function was created.
-     *
-     * @access private
-     * @return array &$functions
-     */
-    protected function &getLambdaFunctions()
-    {
-        static $functions = [];
-        return $functions;
-    }
-
-    /**
-     * Generates a digest from $bytes
-     *
-     * @see self::setupInlineCrypt()
-     * @access private
-     * @param $bytes
-     * @return string
-     */
-    protected function hashInlineCryptFunction($bytes)
-    {
-        if (!isset(self::$WHIRLPOOL_AVAILABLE)) {
-            self::$WHIRLPOOL_AVAILABLE = extension_loaded('hash') && in_array('whirlpool', hash_algos());
-        }
-
-        $result = '';
-        $hash = $bytes;
-
-        switch (true) {
-            case self::$WHIRLPOOL_AVAILABLE:
-                foreach (str_split($bytes, 64) as $t) {
-                    $hash = hash('whirlpool', $hash, true);
-                    $result .= $t ^ $hash;
-                }
-                return $result . hash('whirlpool', $hash, true);
-            default:
-                $len = strlen($bytes);
-                for ($i = 0; $i < $len; $i+=20) {
-                    $t = substr($bytes, $i, 20);
-                    $hash = sha1($hash, true);
-                    $result .= $t ^ $hash;
-                }
-                return $result . sha1($hash, true);
-        }
     }
 
     /**

phpseclib/Crypt/DES.php

@@ -1301,33 +1301,11 @@ class DES extends BlockCipher
      */
     protected function setupInlineCrypt()
     {
-        $lambda_functions =& self::getLambdaFunctions();
-
         // Engine configuration for:
         // -  DES ($des_rounds == 1) or
         // - 3DES ($des_rounds == 3)
         $des_rounds = $this->des_rounds;
 
-        // We create max. 10 hi-optimized code for memory reason. Means: For each $key one ultra fast inline-crypt function.
-        // (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 );
-
-        // Generation of a unique hash for our generated code
-        $code_hash = "Crypt_DES, $des_rounds, {$this->mode}";
-        if ($gen_hi_opt_code) {
-            // For hi-optimized code, we create for each combination of
-            // $mode, $des_rounds and $this->key its own encrypt/decrypt function.
-            // 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);
-        }
-
-        // Is there a re-usable $lambda_functions in there? If not, we have to create it.
-        if (!isset($lambda_functions[$code_hash])) {
-            // Init code for both, encrypt and decrypt.
         $init_crypt = 'static $sbox1, $sbox2, $sbox3, $sbox4, $sbox5, $sbox6, $sbox7, $sbox8, $shuffleip, $shuffleinvip;
             if (!$sbox1) {
                 $sbox1 = array_map("intval", $this->sbox1);
@@ -1346,33 +1324,12 @@ class DES extends BlockCipher
             }
         ';
 
-            switch (true) {
-                case $gen_hi_opt_code:
-                    // In Hi-optimized code mode, we use our [3]DES key schedule as hardcoded integers.
-                    // No futher initialisation of the $keys schedule is necessary.
-                    // That is the extra performance boost.
         $k = [
             self::ENCRYPT => $this->keys[self::ENCRYPT],
             self::DECRYPT => $this->keys[self::DECRYPT]
         ];
         $init_encrypt = '';
         $init_decrypt = '';
-                    break;
-                default:
-                    // In generic optimized code mode, we have to use, as the best compromise [currently],
-                    // our key schedule as $ke/$kd arrays. (with hardcoded indexes...)
-                    $k = [
-                        self::ENCRYPT => [],
-                        self::DECRYPT => []
-                    ];
-                    for ($i = 0, $c = count($this->keys[self::ENCRYPT]); $i < $c; ++$i) {
-                        $k[self::ENCRYPT][$i] = '$ke[' . $i . ']';
-                        $k[self::DECRYPT][$i] = '$kd[' . $i . ']';
-                    }
-                    $init_encrypt = '$ke = $this->keys[self::ENCRYPT];';
-                    $init_decrypt = '$kd = $this->keys[self::DECRYPT];';
-                    break;
-            }
 
         // Creating code for en- and decryption.
         $crypt_block = [];
@@ -1438,7 +1395,7 @@ class DES extends BlockCipher
         }
 
         // Creates the inline-crypt function
-            $lambda_functions[$code_hash] = $this->createInlineCryptFunction(
+        $this->inline_crypt = $this->createInlineCryptFunction(
             [
                'init_crypt'    => $init_crypt,
                'init_encrypt'  => $init_encrypt,
@@ -1448,8 +1405,4 @@ class DES extends BlockCipher
             ]
         );
     }
-
-        // Set the inline-crypt function as callback in: $this->inline_crypt
-        $this->inline_crypt = \Closure::bind($lambda_functions[$code_hash], $this, $this->getClassContext());
-    }
 }

phpseclib/Crypt/RC2.php

@@ -578,35 +578,10 @@ class RC2 extends BlockCipher
      */
     protected function setupInlineCrypt()
     {
-        $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);
-
-        // 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);
-        }
-
-        // Is there a re-usable $lambda_functions in there?
-        // If not, we have to create it.
-        if (!isset($lambda_functions[$code_hash])) {
         // Init code for both, encrypt and decrypt.
         $init_crypt = '$keys = $this->keys;';
 
-            switch (true) {
-                case $gen_hi_opt_code:
         $keys = $this->keys;
-                default:
-                    $keys = [];
-                    foreach ($this->keys as $k => $v) {
-                        $keys[$k] = '$keys[' . $k . ']';
-                    }
-            }
 
         // $in is the current 8 bytes block which has to be en/decrypt
         $encrypt_block = $decrypt_block = '
@@ -694,7 +669,7 @@ class RC2 extends BlockCipher
         $decrypt_block .= '$in = pack("v4", $r0, $r1, $r2, $r3);';
 
         // Creates the inline-crypt function
-            $lambda_functions[$code_hash] = $this->createInlineCryptFunction(
+        $this->inline_crypt = $this->createInlineCryptFunction(
             [
                'init_crypt'    => $init_crypt,
                'encrypt_block' => $encrypt_block,
@@ -702,8 +677,4 @@ class RC2 extends BlockCipher
             ]
         );
     }
-
-        // Set the inline-crypt function as callback in: $this->inline_crypt
-        $this->inline_crypt = \Closure::bind($lambda_functions[$code_hash], $this, $this->getClassContext());
-    }
 }

phpseclib/Crypt/Rijndael.php

@@ -811,40 +811,10 @@ class Rijndael extends BlockCipher
      */
     protected function setupInlineCrypt()
     {
-        // Note: _setupInlineCrypt() will be called only if $this->changed === true
-        // 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();
-
-        // 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);
-
-        // 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);
-        }
-
-        if (!isset($lambda_functions[$code_hash])) {
-            switch (true) {
-                case $gen_hi_opt_code:
-                    // The hi-optimized $lambda_functions will use the key-words hardcoded for better performance.
         $w  = $this->w;
         $dw = $this->dw;
         $init_encrypt = '';
         $init_decrypt = '';
-                    break;
-                default:
-                    for ($i = 0, $cw = count($this->w); $i < $cw; ++$i) {
-                        $w[]  = '$w['  . $i . ']';
-                        $dw[] = '$dw[' . $i . ']';
-                    }
-                    $init_encrypt = '$w  = $this->w;';
-                    $init_decrypt = '$dw = $this->dw;';
-            }
 
         $Nr = $this->Nr;
         $Nb = $this->Nb;
@@ -964,7 +934,7 @@ class Rijndael extends BlockCipher
         }
         $decrypt_block .= ');';
 
-            $lambda_functions[$code_hash] = $this->createInlineCryptFunction(
+        $this->inline_crypt = $this->createInlineCryptFunction(
             [
                'init_crypt'    => '',
                'init_encrypt'  => $init_encrypt,
@@ -974,7 +944,4 @@ class Rijndael extends BlockCipher
             ]
         );
     }
-
-        $this->inline_crypt = \Closure::bind($lambda_functions[$code_hash], $this, $this->getClassContext());
-    }
 }

phpseclib/Crypt/Twofish.php

@@ -707,21 +707,6 @@ class Twofish extends BlockCipher
      */
     protected function setupInlineCrypt()
     {
-        $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);
-
-        // 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);
-        }
-
-        if (!isset($lambda_functions[$code_hash])) {
-            switch (true) {
-                case $gen_hi_opt_code:
         $K = $this->K;
         $init_crypt = '
             static $S0, $S1, $S2, $S3;
@@ -734,20 +719,6 @@ class Twofish extends BlockCipher
                 }
             }
         ';
-                    break;
-                default:
-                    $K   = [];
-                    for ($i = 0; $i < 40; ++$i) {
-                        $K[] = '$K_' . $i;
-                    }
-                    $init_crypt = '
-                        $S0 = $this->S0;
-                        $S1 = $this->S1;
-                        $S2 = $this->S2;
-                        $S3 = $this->S3;
-                        list(' . implode(',', $K) . ') = $this->K;
-                    ';
-            }
 
         // Generating encrypt code:
         $encrypt_block = '
@@ -833,7 +804,7 @@ class Twofish extends BlockCipher
                              '.$K[3].' ^ $R1);
         ';
 
-            $lambda_functions[$code_hash] = $this->createInlineCryptFunction(
+        $this->inline_crypt = $this->createInlineCryptFunction(
             [
                'init_crypt'    => $init_crypt,
                'init_encrypt'  => '',
@@ -843,6 +814,4 @@ class Twofish extends BlockCipher
             ]
         );
     }
-        $this->inline_crypt = \Closure::bind($lambda_functions[$code_hash], $this, $this->getClassContext());
-    }
 }

tests/Unit/Crypt/AES/EvalTest.php

@@ -0,0 +1,16 @@
+<?php
+/**
+ * @author    Andreas Fischer <bantu@phpbb.com>
+ * @copyright 2013 Andreas Fischer
+ * @license   http://www.opensource.org/licenses/mit-license.html  MIT License
+ */
+
+use phpseclib\Crypt\Common\BlockCipher;
+
+class Unit_Crypt_AES_EvalTest extends Unit_Crypt_AES_TestCase
+{
+    protected function setUp()
+    {
+        $this->engine = BlockCipher::ENGINE_EVAL;
+    }
+}

tests/Unit/Crypt/BlowfishTest.php

@@ -14,6 +14,7 @@ class Unit_Crypt_BlowfishTest extends PhpseclibTestCase
     {
         $engines = array(
             BlockCipher::ENGINE_INTERNAL => 'internal',
+            BlockCipher::ENGINE_EVAL => 'eval',
             BlockCipher::ENGINE_MCRYPT => 'mcrypt',
             BlockCipher::ENGINE_OPENSSL => 'OpenSSL',
         );

tests/Unit/Crypt/RC2Test.php

@@ -12,6 +12,7 @@ class Unit_Crypt_RC2Test extends PhpseclibTestCase
 {
     var $engines = array(
         BlockCipher::ENGINE_INTERNAL => 'internal',
+        BlockCipher::ENGINE_EVAL => 'eval',
         BlockCipher::ENGINE_MCRYPT => 'mcrypt',
         BlockCipher::ENGINE_OPENSSL => 'OpenSSL',
     );

tests/Unit/Crypt/TripleDESTest.php

@@ -12,6 +12,7 @@ class Unit_Crypt_TripleDESTest extends PhpseclibTestCase
 {
     var $engines = array(
         BlockCipher::ENGINE_INTERNAL => 'internal',
+        BlockCipher::ENGINE_EVAL => 'eval',
         BlockCipher::ENGINE_MCRYPT => 'mcrypt',
         BlockCipher::ENGINE_OPENSSL => 'OpenSSL',
     );

tests/Unit/Crypt/TwofishTest.php

@@ -14,6 +14,7 @@ class Unit_Crypt_TwofishTest extends PhpseclibTestCase
     {
         $engines = array(
             BlockCipher::ENGINE_INTERNAL => 'internal',
+            BlockCipher::ENGINE_EVAL => 'eval',
             BlockCipher::ENGINE_MCRYPT => 'mcrypt',
             BlockCipher::ENGINE_OPENSSL => 'OpenSSL',
         );