octoleo/phpseclib
1
0
Fork 0
mirror of https://github.com/phpseclib/phpseclib.git synced 2024-12-31 21:21:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

CS and method namings

Browse Source
This commit is contained in:
Hans-Jürgen Petrich 2013-05-25 09:05:24 +07:00
parent 72fa880aa2
commit 995c09cb67
7 changed files with 426 additions and 404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

572
phpseclib/Crypt/Base.php
View File

@ -72,7 +72,8 @@ define('CRYPT_MODE_CFB', 3);
*/ */
define('CRYPT_MODE_OFB', 4); define('CRYPT_MODE_OFB', 4);
/** /**
* Streaming mode * Encrypt / decrypt using streaming mode.
*
*/ */
define('CRYPT_MODE_STREAM', 5); define('CRYPT_MODE_STREAM', 5);
/**#@-*/ /**#@-*/
@ -97,7 +98,7 @@ define('CRYPT_MODE_MCRYPT', 2);
* @author Jim Wigginton <terrafrost@php.net> * @author Jim Wigginton <terrafrost@php.net>
* @author Hans-Juergen Petrich <petrich@tronic-media.com> * @author Hans-Juergen Petrich <petrich@tronic-media.com>
* @version 1.0.0 * @version 1.0.0
* @access internal * @access public
* @package Crypt_Base * @package Crypt_Base
*/ */
class Crypt_Base { class Crypt_Base {
@ -140,7 +141,7 @@ class Crypt_Base {
* A "sliding" Initialization Vector * A "sliding" Initialization Vector
* *
* @see Crypt_Base::enableContinuousBuffer() * @see Crypt_Base::enableContinuousBuffer()
* @see Crypt_Base::clearBuffers() * @see Crypt_Base::_clearBuffers()
* @var String * @var String
* @access private * @access private
*/ */
@ -150,7 +151,7 @@ class Crypt_Base {
* A "sliding" Initialization Vector * A "sliding" Initialization Vector
* *
* @see Crypt_Base::enableContinuousBuffer() * @see Crypt_Base::enableContinuousBuffer()
* @see Crypt_Base::clearBuffers() * @see Crypt_Base::_clearBuffers()
* @var String * @var String
* @access private * @access private
*/ */
@ -169,7 +170,7 @@ class Crypt_Base {
* Encryption buffer for CTR, OFB and CFB modes * Encryption buffer for CTR, OFB and CFB modes
* *
* @see Crypt_Base::encrypt() * @see Crypt_Base::encrypt()
* @see Crypt_Base::clearBuffers() * @see Crypt_Base::_clearBuffers()
* @var Array * @var Array
* @access private * @access private
*/ */
@ -179,7 +180,7 @@ class Crypt_Base {
* Decryption buffer for CTR, OFB and CFB modes * Decryption buffer for CTR, OFB and CFB modes
* *
* @see Crypt_Base::decrypt() * @see Crypt_Base::decrypt()
* @see Crypt_Base::clearBuffers() * @see Crypt_Base::_clearBuffers()
* @var Array * @var Array
* @access private * @access private
*/ */
@ -382,7 +383,7 @@ class Crypt_Base {
* *
* @see Crypt_Base::encrypt() * @see Crypt_Base::encrypt()
* @see Crypt_Base::decrypt() * @see Crypt_Base::decrypt()
* @see Crypt_Base::inline_crypt_setup() * @see Crypt_Base::_inlineCryptSetup()
* @see Crypt_Base::$use_inline_crypt * @see Crypt_Base::$use_inline_crypt
* @var Callback * @var Callback
* @access private * @access private
@ -465,7 +466,7 @@ class Crypt_Base {
} }
// Determining whether inline crypting can be used by the cipher // Determining whether inline crypting can be used by the cipher
if ($this->use_inline_crypt !== false && function_exists('create_function') && is_callable('create_function')) { if ($this->use_inline_crypt !== false && function_exists('create_function')) {
$this->use_inline_crypt = true; $this->use_inline_crypt = true;
} }
} }
@ -715,15 +716,15 @@ class Crypt_Base {
for ($i = 0; $i < strlen($plaintext); $i+=$block_size) { for ($i = 0; $i < strlen($plaintext); $i+=$block_size) {
$block = substr($plaintext, $i, $block_size); $block = substr($plaintext, $i, $block_size);
if (strlen($block) > strlen($buffer['encrypted'])) { if (strlen($block) > strlen($buffer['encrypted'])) {
$buffer['encrypted'].= $this->_encryptBlock($this->_generate_xor($block_size, $xor)); $buffer['encrypted'].= $this->_encryptBlock($this->_generateXor($block_size, $xor));
} }
$key = $this->_string_shift($buffer['encrypted'], $block_size); $key = $this->_stringShift($buffer['encrypted'], $block_size);
$ciphertext.= $block ^ $key; $ciphertext.= $block ^ $key;
} }
} else { } else {
for ($i = 0; $i < strlen($plaintext); $i+=$block_size) { for ($i = 0; $i < strlen($plaintext); $i+=$block_size) {
$block = substr($plaintext, $i, $block_size); $block = substr($plaintext, $i, $block_size);
$key = $this->_encryptBlock($this->_generate_xor($block_size, $xor)); $key = $this->_encryptBlock($this->_generateXor($block_size, $xor));
$ciphertext.= $block ^ $key; $ciphertext.= $block ^ $key;
} }
} }
@ -785,7 +786,7 @@ class Crypt_Base {
$xor = $this->_encryptBlock($xor); $xor = $this->_encryptBlock($xor);
$buffer['xor'].= $xor; $buffer['xor'].= $xor;
} }
$key = $this->_string_shift($buffer['xor'], $block_size); $key = $this->_stringShift($buffer['xor'], $block_size);
$ciphertext.= $block ^ $key; $ciphertext.= $block ^ $key;
} }
} else { } else {
@ -929,15 +930,15 @@ class Crypt_Base {
for ($i = 0; $i < strlen($ciphertext); $i+=$block_size) { for ($i = 0; $i < strlen($ciphertext); $i+=$block_size) {
$block = substr($ciphertext, $i, $block_size); $block = substr($ciphertext, $i, $block_size);
if (strlen($block) > strlen($buffer['ciphertext'])) { if (strlen($block) > strlen($buffer['ciphertext'])) {
$buffer['ciphertext'].= $this->_encryptBlock($this->_generate_xor($block_size, $xor)); $buffer['ciphertext'].= $this->_encryptBlock($this->_generateXor($block_size, $xor));
} }
$key = $this->_string_shift($buffer['ciphertext'], $block_size); $key = $this->_stringShift($buffer['ciphertext'], $block_size);
$plaintext.= $block ^ $key; $plaintext.= $block ^ $key;
} }
} else { } else {
for ($i = 0; $i < strlen($ciphertext); $i+=$block_size) { for ($i = 0; $i < strlen($ciphertext); $i+=$block_size) {
$block = substr($ciphertext, $i, $block_size); $block = substr($ciphertext, $i, $block_size);
$key = $this->_encryptBlock($this->_generate_xor($block_size, $xor)); $key = $this->_encryptBlock($this->_generateXor($block_size, $xor));
$plaintext.= $block ^ $key; $plaintext.= $block ^ $key;
} }
} }
@ -998,7 +999,7 @@ class Crypt_Base {
$xor = $this->_encryptBlock($xor); $xor = $this->_encryptBlock($xor);
$buffer['xor'].= $xor; $buffer['xor'].= $xor;
} }
$key = $this->_string_shift($buffer['xor'], $block_size); $key = $this->_stringShift($buffer['xor'], $block_size);
$plaintext.= $block ^ $key; $plaintext.= $block ^ $key;
} }
} else { } else {
@ -1022,130 +1023,6 @@ class Crypt_Base {
return $this->paddable ? $this->_unpad($plaintext) : $plaintext; return $this->paddable ? $this->_unpad($plaintext) : $plaintext;
} }
/**
* Encrypts a block
*
* Note: Must extend by the child Crypt_* class
*
* @access private
* @param String $in
* @return String
*/
function _encryptBlock($in)
{
echo basename(dirname(__FILE__)) . '/' . basename(__FILE__) . ':' . __LINE__ . ' ' . ( version_compare(PHP_VERSION, '5.0.0', '>=') ? __METHOD__ : __FUNCTION__ ) . '() must extend by ' . get_class($this);
}
/**
* Decrypts a block
*
* Note: Must extend by the child Crypt_* class
*
* @access private
* @param String $in
* @return String
*/
function _decryptBlock($in)
{
echo basename(dirname(__FILE__)) . '/' . basename(__FILE__) . ':' . __LINE__ . ' ' . ( version_compare(PHP_VERSION, '5.0.0', '>=') ? __METHOD__ : __FUNCTION__ ) . '() must extend by ' . get_class($this);
}
/**
* Setup the CRYPT_MODE_INTERNAL $engine
*
* (re)init, if necessary, the internal cipher $engine and flush all $buffers
* Used (only) if $engine == CRYPT_MODE_INTERNAL
*
* _setup() will be called each time if $changed === true
* typically this happens when using one or more of following public methods:
* - setKey()
* - setIV()
* - disableContinuousBuffer()
* - First run of encrypt() / decrypt() with no init-settings
*
* Internally: _setup() will, if necessary always called before(!) en/decryption.
*
* Note: Could, but not must, extend by the child Crypt_* class
*
* @see setKey()
* @see setIV()
* @see disableContinuousBuffer()
* @access private
*/
function _setup()
{
$this->clearBuffers();
$this->_setupKey();
if ($this->use_inline_crypt) {
$this->inline_crypt_setup();
}
}
/**
* Setup the CRYPT_MODE_MCRYPT $engine
*
* (re)init, if necessary, the (ext)mcrypt resources and flush all $buffers
* Used (only) if $engine = CRYPT_MODE_MCRYPT
*
* _mcryptSetup() will be called each time if $changed === true
* typically this happens when using one or more of following public methods:
* - setKey()
* - setIV()
* - disableContinuousBuffer()
* - First run of encrypt() / decrypt()
*
* Note: Could, but not must, extend by the child Crypt_* class
*
* @see setKey()
* @see setIV()
* @see disableContinuousBuffer()
* @access private
*/
function _mcryptSetup()
{
$this->clearBuffers();
$this->enchanged = $this->dechanged = true;
if (!isset($this->enmcrypt)) {
static $mcrypt_modes = array(
CRYPT_MODE_CTR => 'ctr',
CRYPT_MODE_ECB => MCRYPT_MODE_ECB,
CRYPT_MODE_CBC => MCRYPT_MODE_CBC,
CRYPT_MODE_CFB => 'ncfb',
CRYPT_MODE_OFB => MCRYPT_MODE_NOFB,
CRYPT_MODE_STREAM => MCRYPT_MODE_STREAM,
);
$this->demcrypt = mcrypt_module_open($this->cipher_name_mcrypt, '', $mcrypt_modes[$this->mode], '');
$this->enmcrypt = mcrypt_module_open($this->cipher_name_mcrypt, '', $mcrypt_modes[$this->mode], '');
if ($this->mode == CRYPT_MODE_CFB) {
$this->ecb = mcrypt_module_open($this->cipher_name_mcrypt, '', MCRYPT_MODE_ECB, '');
}
} // else should mcrypt_generic_deinit be called?
if ($this->mode == CRYPT_MODE_CFB) {
mcrypt_generic_init($this->ecb, $this->key, str_repeat("\0", $this->block_size));
}
}
/**
* Setup the key (expansion)
*
* Only used if $engine == CRYPT_MODE_INTERNAL
*
* Note: Must extend by the child Crypt_* class
*
* @see Crypt_Base::_setup()
* @access private
*/
function _setupKey()
{
echo basename(dirname(__FILE__)) . '/' . basename(__FILE__) . ':' . __LINE__ . ' ' . ( version_compare(PHP_VERSION, '5.0.0', '>=') ? __METHOD__ : __FUNCTION__ ) . '() must extend by ' . get_class($this);
}
/** /**
* Pad "packets". * Pad "packets".
* *
@ -1177,60 +1054,6 @@ class Crypt_Base {
$this->padding = false; $this->padding = false;
} }
/**
* Pads a string
*
* Pads a string using the RSA PKCS padding standards so that its length is a multiple of the blocksize.
* $this->block_size - (strlen($text) % $this->block_size) bytes are added, each of which is equal to
* chr($this->block_size - (strlen($text) % $this->block_size)
*
* If padding is disabled and $text is not a multiple of the blocksize, the string will be padded regardless
* and padding will, hence forth, be enabled.
*
* @see Crypt_Base::_unpad()
* @access private
*/
function _pad($text)
{
$length = strlen($text);
if (!$this->padding) {
if ($length % $this->block_size == 0) {
return $text;
} else {
user_error("The plaintext's length ($length) is not a multiple of the block size ({$this->block_size})");
$this->padding = true;
}
}
$pad = $this->block_size - ($length % $this->block_size);
return str_pad($text, $length + $pad, chr($pad));
}
/**
* Unpads a string.
*
* If padding is enabled and the reported padding length is invalid the encryption key will be assumed to be wrong
* and false will be returned.
*
* @see Crypt_Base::_pad()
* @access private
*/
function _unpad($text)
{
if (!$this->padding) {
return $text;
}
$length = ord($text[strlen($text) - 1]);
if (!$length || $length > $this->block_size) {
return false;
}
return substr($text, 0, -$length);
}
/** /**
* Treat consecutive "packets" as if they are a continuous buffer. * Treat consecutive "packets" as if they are a continuous buffer.
* *
@ -1302,6 +1125,187 @@ class Crypt_Base {
$this->changed = true; $this->changed = true;
} }
/**
* Encrypts a block
*
* Note: Must extend by the child Crypt_* class
*
* @access private
* @param String $in
* @return String
*/
function _encryptBlock($in)
{
echo basename(dirname(__FILE__)) . '/' . basename(__FILE__) . ':' . __LINE__ . ' ' . ( version_compare(PHP_VERSION, '5.0.0', '>=') ? __METHOD__ : __FUNCTION__ ) . '() must extend by ' . get_class($this);
}
/**
* Decrypts a block
*
* Note: Must extend by the child Crypt_* class
*
* @access private
* @param String $in
* @return String
*/
function _decryptBlock($in)
{
echo basename(dirname(__FILE__)) . '/' . basename(__FILE__) . ':' . __LINE__ . ' ' . ( version_compare(PHP_VERSION, '5.0.0', '>=') ? __METHOD__ : __FUNCTION__ ) . '() must extend by ' . get_class($this);
}
/**
* Setup the CRYPT_MODE_INTERNAL $engine
*
* (re)init, if necessary, the internal cipher $engine and flush all $buffers
* Used (only) if $engine == CRYPT_MODE_INTERNAL
*
* _setup() will be called each time if $changed === true
* typically this happens when using one or more of following public methods:
* - setKey()
* - setIV()
* - disableContinuousBuffer()
* - First run of encrypt() / decrypt() with no init-settings
*
* Internally: _setup() will, if necessary always called before(!) en/decryption.
*
* Note: Could, but not must, extend by the child Crypt_* class
*
* @see setKey()
* @see setIV()
* @see disableContinuousBuffer()
* @access private
*/
function _setup()
{
$this->_clearBuffers();
$this->_setupKey();
if ($this->use_inline_crypt) {
$this->_inlineCryptSetup();
}
}
/**
* Setup the CRYPT_MODE_MCRYPT $engine
*
* (re)init, if necessary, the (ext)mcrypt resources and flush all $buffers
* Used (only) if $engine = CRYPT_MODE_MCRYPT
*
* _mcryptSetup() will be called each time if $changed === true
* typically this happens when using one or more of following public methods:
* - setKey()
* - setIV()
* - disableContinuousBuffer()
* - First run of encrypt() / decrypt()
*
* Note: Could, but not must, extend by the child Crypt_* class
*
* @see setKey()
* @see setIV()
* @see disableContinuousBuffer()
* @access private
*/
function _mcryptSetup()
{
$this->_clearBuffers();
$this->enchanged = $this->dechanged = true;
if (!isset($this->enmcrypt)) {
static $mcrypt_modes = array(
CRYPT_MODE_CTR => 'ctr',
CRYPT_MODE_ECB => MCRYPT_MODE_ECB,
CRYPT_MODE_CBC => MCRYPT_MODE_CBC,
CRYPT_MODE_CFB => 'ncfb',
CRYPT_MODE_OFB => MCRYPT_MODE_NOFB,
CRYPT_MODE_STREAM => MCRYPT_MODE_STREAM,
);
$this->demcrypt = mcrypt_module_open($this->cipher_name_mcrypt, '', $mcrypt_modes[$this->mode], '');
$this->enmcrypt = mcrypt_module_open($this->cipher_name_mcrypt, '', $mcrypt_modes[$this->mode], '');
if ($this->mode == CRYPT_MODE_CFB) {
$this->ecb = mcrypt_module_open($this->cipher_name_mcrypt, '', MCRYPT_MODE_ECB, '');
}
} // else should mcrypt_generic_deinit be called?
if ($this->mode == CRYPT_MODE_CFB) {
mcrypt_generic_init($this->ecb, $this->key, str_repeat("\0", $this->block_size));
}
}
/**
* Setup the key (expansion)
*
* Only used if $engine == CRYPT_MODE_INTERNAL
*
* Note: Must extend by the child Crypt_* class
*
* @see Crypt_Base::_setup()
* @access private
*/
function _setupKey()
{
echo basename(dirname(__FILE__)) . '/' . basename(__FILE__) . ':' . __LINE__ . ' ' . ( version_compare(PHP_VERSION, '5.0.0', '>=') ? __METHOD__ : __FUNCTION__ ) . '() must extend by ' . get_class($this);
}
/**
* Pads a string
*
* Pads a string using the RSA PKCS padding standards so that its length is a multiple of the blocksize.
* $this->block_size - (strlen($text) % $this->block_size) bytes are added, each of which is equal to
* chr($this->block_size - (strlen($text) % $this->block_size)
*
* If padding is disabled and $text is not a multiple of the blocksize, the string will be padded regardless
* and padding will, hence forth, be enabled.
*
* @see Crypt_Base::_unpad()
* @param String $text
* @access private
*/
function _pad($text)
{
$length = strlen($text);
if (!$this->padding) {
if ($length % $this->block_size == 0) {
return $text;
} else {
user_error("The plaintext's length ($length) is not a multiple of the block size ({$this->block_size})");
$this->padding = true;
}
}
$pad = $this->block_size - ($length % $this->block_size);
return str_pad($text, $length + $pad, chr($pad));
}
/**
* Unpads a string.
*
* If padding is enabled and the reported padding length is invalid the encryption key will be assumed to be wrong
* and false will be returned.
*
* @see Crypt_Base::_pad()
* @param String $text
* @access private
*/
function _unpad($text)
{
if (!$this->padding) {
return $text;
}
$length = ord($text[strlen($text) - 1]);
if (!$length || $length > $this->block_size) {
return false;
}
return substr($text, 0, -$length);
}
/** /**
* Clears internal buffers * Clears internal buffers
* *
@ -1312,9 +1316,8 @@ class Crypt_Base {
* Note: Could, but not must, extend by the child Crypt_* class * Note: Could, but not must, extend by the child Crypt_* class
* *
* @access public * @access public
* @param String $iv
*/ */
function clearBuffers() function _clearBuffers()
{ {
$this->enbuffer = array('encrypted' => '', 'xor' => '', 'pos' => 0, 'enmcrypt_init' => true); $this->enbuffer = array('encrypted' => '', 'xor' => '', 'pos' => 0, 'enmcrypt_init' => true);
$this->debuffer = array('ciphertext' => '', 'xor' => '', 'pos' => 0, 'demcrypt_init' => true); $this->debuffer = array('ciphertext' => '', 'xor' => '', 'pos' => 0, 'demcrypt_init' => true);
@ -1334,7 +1337,7 @@ class Crypt_Base {
* @return String * @return String
* @access private * @access private
*/ */
function _string_shift(&$string, $index = 1) function _stringShift(&$string, $index = 1)
{ {
$substr = substr($string, 0, $index); $substr = substr($string, 0, $index);
$string = substr($string, $index); $string = substr($string, $index);
@ -1353,7 +1356,7 @@ class Crypt_Base {
* @param Integer $length * @param Integer $length
* @param String $iv * @param String $iv
*/ */
function _generate_xor($length, &$iv) function _generateXor($length, &$iv)
{ {
$xor = ''; $xor = '';
$block_size = $this->block_size; $block_size = $this->block_size;
@ -1387,25 +1390,31 @@ class Crypt_Base {
* in $this->inline_crypt * in $this->inline_crypt
* *
* Internally for phpseclib developers: * Internally for phpseclib developers:
* inline_crypt_setup() would be called only if *
* _inlineCryptSetup() would be called only if:
*
* - $engine == CRYPT_MODE_INTERNAL and * - $engine == CRYPT_MODE_INTERNAL and
*
* - $use_inline_crypt === true * - $use_inline_crypt === true
*
* - each time on _setup(), after(!) _setupKey() * - each time on _setup(), after(!) _setupKey()
* *
* This ensures that inline_crypt_setup() has allways a *
* This ensures that _inlineCryptSetup() has allways a
* full ready2go initializated internal cipher $engine state * full ready2go initializated internal cipher $engine state
* where, for example, the keys allready expanded, * where, for example, the keys allready expanded,
* keys/block_size calculated and such. * keys/block_size calculated and such.
* *
* It is, each time if called, the responsibility of inline_crypt_setup(): * It is, each time if called, the responsibility of _inlineCryptSetup():
*
* - to set $this->inline_crypt to a valid and fully working callback function * - to set $this->inline_crypt to a valid and fully working callback function
* as a (faster) replacement for encrypt() / decrypt() * as a (faster) replacement for encrypt() / decrypt()
* *
* - NOT to create unlimited callback functions (for memory reasons!) * - NOT to create unlimited callback functions (for memory reasons!)
* no matter how often inline_crypt_setup() would be called. At some * no matter how often _inlineCryptSetup() would be called. At some
* point of amount they must be generic re-useable. * point of amount they must be generic re-useable.
* *
* - the code of inline_crypt_setup() it self, * - the code of _inlineCryptSetup() it self,
* and the generated callback code, * and the generated callback code,
* must be, in following order: * must be, in following order:
* - 100% safe * - 100% safe
@ -1414,23 +1423,23 @@ class Crypt_Base {
* compatibility (down to php4) or fallback is provided * compatibility (down to php4) or fallback is provided
* - readable/maintainable/understandable/commented and... not-cryptic-styled-code :-) * - readable/maintainable/understandable/commented and... not-cryptic-styled-code :-)
* - >= 10% faster than encrypt()/decrypt() [which is, by the way, * - >= 10% faster than encrypt()/decrypt() [which is, by the way,
* the reason for the existence of inline_crypt_setup() :-)] * the reason for the existence of _inlineCryptSetup() :-)]
* - memory-nice * - memory-nice
* - short (as good as possible) * - short (as good as possible)
* *
* Note: inline_crypt_setup() is using createInlineCryptFunction() to create the full callback function code. * Note: _inlineCryptSetup() is using _createInlineCryptFunction() to create the full callback function code.
* *
* Note: In case of using inline crypting, it must extend by the child Crypt_* class * Note: In case of using inline crypting, it must extend by the child Crypt_* class
* *
* @see Crypt_Base::_setup() * @see Crypt_Base::_setup()
* @see Crypt_Base::createInlineCryptFunction() * @see Crypt_Base::_createInlineCryptFunction()
* @see Crypt_Base::encrypt() * @see Crypt_Base::encrypt()
* @see Crypt_Base::decrypt() * @see Crypt_Base::decrypt()
* @access private * @access private
*/ */
function inline_crypt_setup() function _inlineCryptSetup()
{ {
// If a Crypt_* class providing inline crypting it must extend inline_crypt_setup() // If a Crypt_* class providing inline crypting it must extend _inlineCryptSetup()
// If, for any reason, an extending Crypt_Base() Crypt_* class // If, for any reason, an extending Crypt_Base() Crypt_* class
// not using inline crypting then it must be ensured that: $this->use_inline_crypt = false // not using inline crypting then it must be ensured that: $this->use_inline_crypt = false
@ -1446,15 +1455,22 @@ class Crypt_Base {
* *
* Internally for phpseclib developers: * Internally for phpseclib developers:
* *
* createInlineCryptFunction() * _createInlineCryptFunction():
* a) merge the $cipher_code [setup'ed by inline_crypt_setup()] *
* with the current [$this->]mode of operation code * - merge the $cipher_code [setup'ed by _inlineCryptSetup()]
* b) create the $inline function, which called by encrypt() / decrypt() * with the current [$this->]mode of operation code
* as its replacement to speed up the en/decryption operations. *
* c) return the name of the created $inline callback function * - create the $inline function, which called by encrypt() / decrypt()
* d) used to speed up en/decryption * as its replacement to speed up the en/decryption operations.
*
* - return the name of the created $inline callback function
*
* - used to speed up en/decryption
*
*
* *
* The main reason why can speed up things [up to 50%] this way are: * The main reason why can speed up things [up to 50%] this way are:
*
* - using variables more effective then regular. * - using variables more effective then regular.
* (ie no use of expensive arrays but integers $k_0, $k_1 ... * (ie no use of expensive arrays but integers $k_0, $k_1 ...
* or even, for example, the pure $key[] values hardcoded) * or even, for example, the pure $key[] values hardcoded)
@ -1469,59 +1485,62 @@ class Crypt_Base {
* The basic code architectur of the generated $inline en/decrypt() * The basic code architectur of the generated $inline en/decrypt()
* lambda function, in pseudo php, is: * lambda function, in pseudo php, is:
* *
* +-------------------------------------------------------------------------------------------------+ * <code>
* | callback $inline = create_function: | * +----------------------------------------------------------------------------------------------+
* | lambda_function_0001_crypt_ECB($action, $text) | * | callback $inline = create_function: |
* | { | * | lambda_function_0001_crypt_ECB($action, $text) |
* | INSERT PHP CODE OF: | * | { |
* | $cipher_code['init_crypt']; // general init code. | * | INSERT PHP CODE OF: |
* | // ie: $sbox'es declarations used for | * | $cipher_code['init_crypt']; // general init code. |
* | // encrypt and decrypt'ing. | * | // ie: $sbox'es declarations used for |
* | | * | // encrypt and decrypt'ing. |
* | switch ($action) { | * | |
* | case 'encrypt': | * | switch ($action) { |
* | INSERT PHP CODE OF: | * | case 'encrypt': |
* | $cipher_code['init_encrypt']; // encrypt sepcific init code. | * | INSERT PHP CODE OF: |
* | ie: specified $key or $box | * | $cipher_code['init_encrypt']; // encrypt sepcific init code. |
* | declarations for encrypt'ing. | * | ie: specified $key or $box |
* | | * | declarations for encrypt'ing. |
* | foreach ($ciphertext) { | * | |
* | $in = $block_size of $ciphertext; | * | foreach ($ciphertext) { |
* | | * | $in = $block_size of $ciphertext; |
* | INSERT PHP CODE OF: | * | |
* | $cipher_code['encrypt_block']; // encrypt's (string) $in, which is always: | * | INSERT PHP CODE OF: |
* | // strlen($in) == $this->block_size | * | $cipher_code['encrypt_block']; // encrypt's (string) $in, which is always: |
* | // here comes the cipher algorithm in action | * | // strlen($in) == $this->block_size |
* | // for encryption. | * | // here comes the cipher algorithm in action |
* | | * | // for encryption. |
* | $plaintext .= $in; | * | |
* | } | * | $plaintext .= $in; |
* | return $plaintext; | * | } |
* | | * | return $plaintext; |
* | case 'decrypt': | * | |
* | INSERT PHP CODE OF: | * | case 'decrypt': |
* | $cipher_code['init_decrypt']; // decrypt sepcific init code | * | INSERT PHP CODE OF: |
* | ie: specified $key or $box | * | $cipher_code['init_decrypt']; // decrypt sepcific init code |
* | declarations for decrypt'ing. | * | ie: specified $key or $box |
* | foreach ($plaintext) { | * | declarations for decrypt'ing. |
* | $in = $block_size of $plaintext; | * | foreach ($plaintext) { |
* | | * | $in = $block_size of $plaintext; |
* | INSERT PHP CODE OF: | * | |
* | $cipher_code['decrypt_block']; // decrypt's (string) $in, which is always | * | INSERT PHP CODE OF: |
* | // strlen($in) == $this->block_size | * | $cipher_code['decrypt_block']; // decrypt's (string) $in, which is always |
* | // here comes the cipher algorithm in action | * | // strlen($in) == $this->block_size |
* | // for decryption. | * | // here comes the cipher algorithm in action |
* | $ciphertext .= $in; | * | // for decryption. |
* | } | * | $ciphertext .= $in; |
* | return $ciphertext; | * | } |
* | } | * | return $ciphertext; |
* | } | * | } |
* +-------------------------------------------------------------------------------------------------+ * | } |
* +----------------------------------------------------------------------------------------------+
* </code>
* *
* See also the Crypt_*::inline_crypt_setup()'s for * See also the Crypt_*::_inlineCryptSetup()'s for
* productive inline $cipher_code's how they works. * productive inline $cipher_code's how they works.
* *
* Structure of: * Structure of:
* <code>
* $cipher_code = array( * $cipher_code = array(
* 'init_crypt' => (string) '', // optional * 'init_crypt' => (string) '', // optional
* 'init_encrypt' => (string) '', // optional * 'init_encrypt' => (string) '', // optional
@ -1529,15 +1548,16 @@ class Crypt_Base {
* 'encrypt_block' => (string) '', // required * 'encrypt_block' => (string) '', // required
* 'decrypt_block' => (string) '' // required * 'decrypt_block' => (string) '' // required
* ); * );
* </code>
* *
* @see Crypt_Base::inline_crypt_setup() * @see Crypt_Base::_inlineCryptSetup()
* @see Crypt_Base::encrypt() * @see Crypt_Base::encrypt()
* @see Crypt_Base::decrypt() * @see Crypt_Base::decrypt()
* @param Array $cipher_code * @param Array $cipher_code
* @access private * @access private
* @return String (the name of the created callback function) * @return String (the name of the created callback function)
*/ */
function createInlineCryptFunction($cipher_code) function _createInlineCryptFunction($cipher_code)
{ {
$block_size = $this->block_size; $block_size = $this->block_size;
@ -1593,17 +1613,17 @@ class Crypt_Base {
for ($i = 0; $i < $plaintext_len; $i+= '.$block_size.') { for ($i = 0; $i < $plaintext_len; $i+= '.$block_size.') {
$block = substr($text, $i, '.$block_size.'); $block = substr($text, $i, '.$block_size.');
if (strlen($block) > strlen($buffer["encrypted"])) { if (strlen($block) > strlen($buffer["encrypted"])) {
$in = $self->_generate_xor('.$block_size.', $xor); $in = $self->_generateXor('.$block_size.', $xor);
'.$encrypt_block.' '.$encrypt_block.'
$buffer["encrypted"].= $in; $buffer["encrypted"].= $in;
} }
$key = $self->_string_shift($buffer["encrypted"], '.$block_size.'); $key = $self->_stringShift($buffer["encrypted"], '.$block_size.');
$ciphertext.= $block ^ $key; $ciphertext.= $block ^ $key;
} }
} else { } else {
for ($i = 0; $i < $plaintext_len; $i+= '.$block_size.') { for ($i = 0; $i < $plaintext_len; $i+= '.$block_size.') {
$block = substr($text, $i, '.$block_size.'); $block = substr($text, $i, '.$block_size.');
$in = $self->_generate_xor('.$block_size.', $xor); $in = $self->_generateXor('.$block_size.', $xor);
'.$encrypt_block.' '.$encrypt_block.'
$key = $in; $key = $in;
$ciphertext.= $block ^ $key; $ciphertext.= $block ^ $key;
@ -1629,17 +1649,17 @@ class Crypt_Base {
for ($i = 0; $i < $ciphertext_len; $i+= '.$block_size.') { for ($i = 0; $i < $ciphertext_len; $i+= '.$block_size.') {
$block = substr($text, $i, '.$block_size.'); $block = substr($text, $i, '.$block_size.');
if (strlen($block) > strlen($buffer["ciphertext"])) { if (strlen($block) > strlen($buffer["ciphertext"])) {
$in = $self->_generate_xor('.$block_size.', $xor); $in = $self->_generateXor('.$block_size.', $xor);
'.$encrypt_block.' '.$encrypt_block.'
$buffer["ciphertext"].= $in; $buffer["ciphertext"].= $in;
} }
$key = $self->_string_shift($buffer["ciphertext"], '.$block_size.'); $key = $self->_stringShift($buffer["ciphertext"], '.$block_size.');
$plaintext.= $block ^ $key; $plaintext.= $block ^ $key;
} }
} else { } else {
for ($i = 0; $i < $ciphertext_len; $i+= '.$block_size.') { for ($i = 0; $i < $ciphertext_len; $i+= '.$block_size.') {
$block = substr($text, $i, '.$block_size.'); $block = substr($text, $i, '.$block_size.');
$in = $self->_generate_xor('.$block_size.', $xor); $in = $self->_generateXor('.$block_size.', $xor);
'.$encrypt_block.' '.$encrypt_block.'
$key = $in; $key = $in;
$plaintext.= $block ^ $key; $plaintext.= $block ^ $key;
@ -1770,7 +1790,7 @@ class Crypt_Base {
$xor = $in; $xor = $in;
$buffer["xor"].= $xor; $buffer["xor"].= $xor;
} }
$key = $self->_string_shift($buffer["xor"], '.$block_size.'); $key = $self->_stringShift($buffer["xor"], '.$block_size.');
$ciphertext.= $block ^ $key; $ciphertext.= $block ^ $key;
} }
} else { } else {
@ -1806,7 +1826,7 @@ class Crypt_Base {
$xor = $in; $xor = $in;
$buffer["xor"].= $xor; $buffer["xor"].= $xor;
} }
$key = $self->_string_shift($buffer["xor"], '.$block_size.'); $key = $self->_stringShift($buffer["xor"], '.$block_size.');
$plaintext.= $block ^ $key; $plaintext.= $block ^ $key;
} }
} else { } else {
@ -1892,7 +1912,7 @@ class Crypt_Base {
* Holds the lambda_functions table (classwide) * Holds the lambda_functions table (classwide)
* *
* Each name of the lambda function, created from * Each name of the lambda function, created from
* inline_crypt_setup() && createInlineCryptFunction() * _inlineCryptSetup() && _createInlineCryptFunction()
* is stored, classwide (!), here for reusing. * is stored, classwide (!), here for reusing.
* *
* The string-based index of $function is a classwide * The string-based index of $function is a classwide
@ -1903,7 +1923,7 @@ class Crypt_Base {
* @return Array * @return Array
* @access private * @access private
*/ */
function &get_lambda_functions() function &_getLambdaFunctions()
{ {
static $functions = array(); static $functions = array();
return $functions; return $functions;

8
phpseclib/Crypt/Blowfish.php
View File

@ -552,12 +552,12 @@ class Crypt_Blowfish extends Crypt_Base {
/** /**
* Setup the performance-optimized function for de/encrypt() * Setup the performance-optimized function for de/encrypt()
* *
* @see Crypt_Base::inline_crypt_setup() * @see Crypt_Base::_inlineCryptSetup()
* @access private * @access private
*/ */
function inline_crypt_setup() function _inlineCryptSetup()
{ {
$lambda_functions =& Crypt_Blowfish::get_lambda_functions(); $lambda_functions =& Crypt_Blowfish::_getLambdaFunctions();
// We create max. 10 hi-optimized code for memory reason. Means: For each $key one ultra fast inline-crypt function. // We create max. 10 hi-optimized code for memory reason. Means: For each $key one ultra fast inline-crypt function.
// After that, we'll still create very fast optimized code but not the hi-ultimative code, for each $mode one. // After that, we'll still create very fast optimized code but not the hi-ultimative code, for each $mode one.
@ -655,7 +655,7 @@ class Crypt_Blowfish extends Crypt_Base {
); );
'; ';
$lambda_functions[$code_hash] = $this->createInlineCryptFunction( $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
array( array(
'init_crypt' => $init_crypt, 'init_crypt' => $init_crypt,
'init_encrypt' => '', 'init_encrypt' => '',

8
phpseclib/Crypt/DES.php
View File

@ -1368,12 +1368,12 @@ class Crypt_DES extends Crypt_Base {
/** /**
* Setup the performance-optimized function for de/encrypt() * Setup the performance-optimized function for de/encrypt()
* *
* @see Crypt_Base::inline_crypt_setup() * @see Crypt_Base::_inlineCryptSetup()
* @access private * @access private
*/ */
function inline_crypt_setup() function _inlineCryptSetup()
{ {
$lambda_functions =& Crypt_DES::get_lambda_functions(); $lambda_functions =& Crypt_DES::_getLambdaFunctions();
// Engine configuration for: // Engine configuration for:
// - DES ($des_rounds == 1) or // - DES ($des_rounds == 1) or
@ -1512,7 +1512,7 @@ class Crypt_DES extends Crypt_Base {
} }
// Creates the inline-crypt function // Creates the inline-crypt function
$lambda_functions[$code_hash] = $this->createInlineCryptFunction( $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
array( array(
'init_crypt' => $init_crypt, 'init_crypt' => $init_crypt,
'init_encrypt' => $init_encrypt, 'init_encrypt' => $init_encrypt,

91
phpseclib/Crypt/RC4.php
View File

@ -184,51 +184,6 @@ class Crypt_RC4 extends Crypt_Base {
parent::Crypt_Base(CRYPT_MODE_STREAM); parent::Crypt_Base(CRYPT_MODE_STREAM);
} }
/**
* Sets the key.
*
* Keys can be between 1 and 256 bytes long. If they are longer then 256 bytes, the first 256 bytes will
* be used. If no key is explicitly set, it'll be assumed to be a single null byte.
*
* @access public
* @see Crypt_Base::setKey()
* @param String $key
*/
function setKey($key)
{
parent::setKey(substr($key, 0, 256));
}
/**
* Setup the key (expansion)
*
* @see Crypt_Base::_setupKey()
* @access private
*/
function _setupKey()
{
$key = $this->key;
$keyLength = strlen($key);
$keyStream = array();
for ($i = 0; $i < 256; $i++) {
$keyStream[$i] = $i;
}
$j = 0;
for ($i = 0; $i < 256; $i++) {
$j = ($j + $keyStream[$i] + ord($key[$i % $keyLength])) & 255;
$temp = $keyStream[$i];
$keyStream[$i] = $keyStream[$j];
$keyStream[$j] = $temp;
}
$this->stream = array();
$this->stream[CRYPT_RC4_DECRYPT] = $this->stream[CRYPT_RC4_ENCRYPT] = array(
0, // index $i
0, // index $j
$keyStream
);
}
/** /**
* Dummy function. * Dummy function.
* *
@ -252,6 +207,21 @@ class Crypt_RC4 extends Crypt_Base {
{ {
} }
/**
* Sets the key.
*
* Keys can be between 1 and 256 bytes long. If they are longer then 256 bytes, the first 256 bytes will
* be used. If no key is explicitly set, it'll be assumed to be a single null byte.
*
* @access public
* @see Crypt_Base::setKey()
* @param String $key
*/
function setKey($key)
{
parent::setKey(substr($key, 0, 256));
}
/** /**
* Encrypts a message. * Encrypts a message.
* *
@ -289,6 +259,37 @@ class Crypt_RC4 extends Crypt_Base {
return $this->_crypt($ciphertext, CRYPT_RC4_DECRYPT); return $this->_crypt($ciphertext, CRYPT_RC4_DECRYPT);
} }
/**
* Setup the key (expansion)
*
* @see Crypt_Base::_setupKey()
* @access private
*/
function _setupKey()
{
$key = $this->key;
$keyLength = strlen($key);
$keyStream = array();
for ($i = 0; $i < 256; $i++) {
$keyStream[$i] = $i;
}
$j = 0;
for ($i = 0; $i < 256; $i++) {
$j = ($j + $keyStream[$i] + ord($key[$i % $keyLength])) & 255;
$temp = $keyStream[$i];
$keyStream[$i] = $keyStream[$j];
$keyStream[$j] = $temp;
}
$this->stream = array();
$this->stream[CRYPT_RC4_DECRYPT] = $this->stream[CRYPT_RC4_ENCRYPT] = array(
0, // index $i
0, // index $j
$keyStream
);
}
/** /**
* Encrypts or decrypts a message. * Encrypts or decrypts a message.
* *

11
phpseclib/Crypt/Rijndael.php
View File

@ -1077,6 +1077,7 @@ class Crypt_Rijndael extends Crypt_Base {
* Performs S-Box substitutions * Performs S-Box substitutions
* *
* @access private * @access private
* @param Integer $word
*/ */
function _subWord($word) function _subWord($word)
{ {
@ -1091,16 +1092,16 @@ class Crypt_Rijndael extends Crypt_Base {
/** /**
* Setup the performance-optimized function for de/encrypt() * Setup the performance-optimized function for de/encrypt()
* *
* @see Crypt_Base::inline_crypt_setup() * @see Crypt_Base::_inlineCryptSetup()
* @access private * @access private
*/ */
function inline_crypt_setup() function _inlineCryptSetup()
{ {
// Note: inline_crypt_setup() will be called only if $this->changed === true // Note: _inlineCryptSetup() 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(). // 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. // However...the here generated function- $code, stored as php callback in $this->inline_crypt, must work as fast as even possible.
$lambda_functions =& Crypt_Rijndael::get_lambda_functions(); $lambda_functions =& Crypt_Rijndael::_getLambdaFunctions();
// The first 10 generated $lambda_functions will use the key-words hardcoded for better performance. // The first 10 generated $lambda_functions will use the key-words hardcoded for better performance.
// For memory reason we limit those ultra-optimized functions. // For memory reason we limit those ultra-optimized functions.
@ -1242,7 +1243,7 @@ class Crypt_Rijndael extends Crypt_Base {
} }
$decrypt_block .= ');'; $decrypt_block .= ');';
$lambda_functions[$code_hash] = $this->createInlineCryptFunction( $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
array( array(
'init_crypt' => '', 'init_crypt' => '',
'init_encrypt' => $init_encrypt, 'init_encrypt' => $init_encrypt,

110
phpseclib/Crypt/TripleDES.php
View File

@ -209,6 +209,26 @@ class Crypt_TripleDES extends Crypt_DES {
} }
} }
/**
* Sets the initialization vector. (optional)
*
* SetIV is not required when CRYPT_DES_MODE_ECB is being used. If not explictly set, it'll be assumed
* to be all zero's.
*
* @see Crypt_Base::setIV()
* @access public
* @param String $iv
*/
function setIV($iv)
{
parent::setIV($iv);
if ($this->mode_3cbc) {
$this->des[0]->setIV($iv);
$this->des[1]->setIV($iv);
$this->des[2]->setIV($iv);
}
}
/** /**
* Sets the key. * Sets the key.
* *
@ -248,61 +268,6 @@ class Crypt_TripleDES extends Crypt_DES {
} }
} }
/**
* Creates the key schedule
*
* @see Crypt_DES::_setupKey()
* @see Crypt_Base::_setupKey()
* @access private
*/
function _setupKey()
{
switch (true) {
// if $key <= 64bits we configure our internal pure-php cipher engine
// to act as regular [1]DES, not as 3DES. mcrypt.so::tripledes does the same.
case strlen($this->key) <= 8:
$this->des_rounds = 1;
break;
// otherwise, if $key > 64bits, we configure our engine to work as 3DES.
default:
$this->des_rounds = 3;
// (only) if 3CBC is used we have, of course, to setup the $des[0-2] keys also separately.
if ($this->mode_3cbc) {
$this->des[0]->_setupKey();
$this->des[1]->_setupKey();
$this->des[2]->_setupKey();
// because $des[0-2] will, now, do all the work we can return here
// not need unnecessary stress parent::_setupKey() with our, now unused, $key.
return;
}
}
// setup our key
parent::_setupKey();
}
/**
* Sets the initialization vector. (optional)
*
* SetIV is not required when CRYPT_DES_MODE_ECB is being used. If not explictly set, it'll be assumed
* to be all zero's.
*
* @see Crypt_Base::setIV()
* @access public
* @param String $iv
*/
function setIV($iv)
{
parent::setIV($iv);
if ($this->mode_3cbc) {
$this->des[0]->setIV($iv);
$this->des[1]->setIV($iv);
$this->des[2]->setIV($iv);
}
}
/** /**
* Encrypts a message. * Encrypts a message.
* *
@ -411,6 +376,41 @@ class Crypt_TripleDES extends Crypt_DES {
$this->des[2]->disableContinuousBuffer(); $this->des[2]->disableContinuousBuffer();
} }
} }
/**
* Creates the key schedule
*
* @see Crypt_DES::_setupKey()
* @see Crypt_Base::_setupKey()
* @access private
*/
function _setupKey()
{
switch (true) {
// if $key <= 64bits we configure our internal pure-php cipher engine
// to act as regular [1]DES, not as 3DES. mcrypt.so::tripledes does the same.
case strlen($this->key) <= 8:
$this->des_rounds = 1;
break;
// otherwise, if $key > 64bits, we configure our engine to work as 3DES.
default:
$this->des_rounds = 3;
// (only) if 3CBC is used we have, of course, to setup the $des[0-2] keys also separately.
if ($this->mode_3cbc) {
$this->des[0]->_setupKey();
$this->des[1]->_setupKey();
$this->des[2]->_setupKey();
// because $des[0-2] will, now, do all the work we can return here
// not need unnecessary stress parent::_setupKey() with our, now unused, $key.
return;
}
}
// setup our key
parent::_setupKey();
}
} }
// vim: ts=4:sw=4:et: // vim: ts=4:sw=4:et:

30
phpseclib/Crypt/Twofish.php
View File

@ -531,8 +531,8 @@ class Crypt_Twofish extends Crypt_Base {
switch (strlen($this->key)) { switch (strlen($this->key)) {
case 16: case 16:
list ($s7, $s6, $s5, $s4) = $this->mds_rem($le_longs[1], $le_longs[2]); list ($s7, $s6, $s5, $s4) = $this->_mdsrem($le_longs[1], $le_longs[2]);
list ($s3, $s2, $s1, $s0) = $this->mds_rem($le_longs[3], $le_longs[4]); list ($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[3], $le_longs[4]);
for ($i = 0, $j = 1; $i < 40; $i+= 2,$j+= 2) { for ($i = 0, $j = 1; $i < 40; $i+= 2,$j+= 2) {
$A = $m0[$q0[$q0[$i] ^ $key[ 9]] ^ $key[1]] ^ $A = $m0[$q0[$q0[$i] ^ $key[ 9]] ^ $key[1]] ^
$m1[$q0[$q1[$i] ^ $key[10]] ^ $key[2]] ^ $m1[$q0[$q1[$i] ^ $key[10]] ^ $key[2]] ^
@ -554,9 +554,9 @@ class Crypt_Twofish extends Crypt_Base {
} }
break; break;
case 24: case 24:
list ($sb, $sa, $s9, $s8) = $this->mds_rem($le_longs[1], $le_longs[2]); list ($sb, $sa, $s9, $s8) = $this->_mdsrem($le_longs[1], $le_longs[2]);
list ($s7, $s6, $s5, $s4) = $this->mds_rem($le_longs[3], $le_longs[4]); list ($s7, $s6, $s5, $s4) = $this->_mdsrem($le_longs[3], $le_longs[4]);
list ($s3, $s2, $s1, $s0) = $this->mds_rem($le_longs[5], $le_longs[6]); list ($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[5], $le_longs[6]);
for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) { for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
$A = $m0[$q0[$q0[$q1[$i] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^ $A = $m0[$q0[$q0[$q1[$i] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^
$m1[$q0[$q1[$q1[$i] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^ $m1[$q0[$q1[$q1[$i] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
@ -578,10 +578,10 @@ class Crypt_Twofish extends Crypt_Base {
} }
break; break;
default: // 32 default: // 32
list ($sf, $se, $sd, $sc) = $this->mds_rem($le_longs[1], $le_longs[2]); list ($sf, $se, $sd, $sc) = $this->_mdsrem($le_longs[1], $le_longs[2]);
list ($sb, $sa, $s9, $s8) = $this->mds_rem($le_longs[3], $le_longs[4]); list ($sb, $sa, $s9, $s8) = $this->_mdsrem($le_longs[3], $le_longs[4]);
list ($s7, $s6, $s5, $s4) = $this->mds_rem($le_longs[5], $le_longs[6]); list ($s7, $s6, $s5, $s4) = $this->_mdsrem($le_longs[5], $le_longs[6]);
list ($s3, $s2, $s1, $s0) = $this->mds_rem($le_longs[7], $le_longs[8]); list ($s3, $s2, $s1, $s0) = $this->_mdsrem($le_longs[7], $le_longs[8]);
for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) { for ($i = 0, $j = 1; $i < 40; $i+= 2, $j+= 2) {
$A = $m0[$q0[$q0[$q1[$q1[$i] ^ $key[25]] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^ $A = $m0[$q0[$q0[$q1[$q1[$i] ^ $key[25]] ^ $key[17]] ^ $key[ 9]] ^ $key[1]] ^
$m1[$q0[$q1[$q1[$q0[$i] ^ $key[26]] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^ $m1[$q0[$q1[$q1[$q0[$i] ^ $key[26]] ^ $key[18]] ^ $key[10]] ^ $key[2]] ^
@ -611,14 +611,14 @@ class Crypt_Twofish extends Crypt_Base {
} }
/** /**
* mds_rem function using by the twofish cipher algorithm * _mdsrem function using by the twofish cipher algorithm
* *
* @access private * @access private
* @param String $A * @param String $A
* @param String $B * @param String $B
* @return Array * @return Array
*/ */
function mds_rem($A, $B) function _mdsrem($A, $B)
{ {
// No gain by unrolling this loop. // No gain by unrolling this loop.
for ($i = 0; $i < 8; ++$i) { for ($i = 0; $i < 8; ++$i) {
@ -767,12 +767,12 @@ class Crypt_Twofish extends Crypt_Base {
/** /**
* Setup the performance-optimized function for de/encrypt() * Setup the performance-optimized function for de/encrypt()
* *
* @see Crypt_Base::inline_crypt_setup() * @see Crypt_Base::_inlineCryptSetup()
* @access private * @access private
*/ */
function inline_crypt_setup() function _inlineCryptSetup()
{ {
$lambda_functions =& Crypt_Twofish::get_lambda_functions(); $lambda_functions =& Crypt_Twofish::_getLambdaFunctions();
// Max. 10 Ultra-Hi-optimized inline-crypt functions. After that, we'll (still) create very fast code, but not the ultimate fast one. // Max. 10 Ultra-Hi-optimized inline-crypt functions. After that, we'll (still) create very fast code, but not the ultimate fast one.
$gen_hi_opt_code = (bool)( count($lambda_functions) < 10 ); $gen_hi_opt_code = (bool)( count($lambda_functions) < 10 );
@ -901,7 +901,7 @@ class Crypt_Twofish extends Crypt_Base {
'.$K[3].' ^ $R1); '.$K[3].' ^ $R1);
'; ';
$lambda_functions[$code_hash] = $this->createInlineCryptFunction( $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
array( array(
'init_crypt' => $init_crypt, 'init_crypt' => $init_crypt,
'init_encrypt' => '', 'init_encrypt' => '',