340 lines
8.4 KiB
PHP
340 lines
8.4 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Pure-PHP implementation of RC4.
|
|
*
|
|
* Uses mcrypt, if available, and an internal implementation, otherwise.
|
|
*
|
|
* PHP version 5
|
|
*
|
|
* Useful resources are as follows:
|
|
*
|
|
* - {@link http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt ARCFOUR Algorithm}
|
|
* - {@link http://en.wikipedia.org/wiki/RC4 - Wikipedia: RC4}
|
|
*
|
|
* RC4 is also known as ARCFOUR or ARC4. The reason is elaborated upon at Wikipedia. This class is named RC4 and not
|
|
* ARCFOUR or ARC4 because RC4 is how it is referred to in the SSH1 specification.
|
|
*
|
|
* Here's a short example of how to use this library:
|
|
* <code>
|
|
* <?php
|
|
* include 'vendor/autoload.php';
|
|
*
|
|
* $rc4 = new \phpseclib\Crypt\RC4();
|
|
*
|
|
* $rc4->setKey('abcdefgh');
|
|
*
|
|
* $size = 10 * 1024;
|
|
* $plaintext = '';
|
|
* for ($i = 0; $i < $size; $i++) {
|
|
* $plaintext.= 'a';
|
|
* }
|
|
*
|
|
* echo $rc4->decrypt($rc4->encrypt($plaintext));
|
|
* ?>
|
|
* </code>
|
|
*
|
|
* @category Crypt
|
|
* @package RC4
|
|
* @author Jim Wigginton <terrafrost@php.net>
|
|
* @copyright 2007 Jim Wigginton
|
|
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
|
* @link http://phpseclib.sourceforge.net
|
|
*/
|
|
|
|
namespace phpseclib\Crypt;
|
|
|
|
/**
|
|
* Pure-PHP implementation of RC4.
|
|
*
|
|
* @package RC4
|
|
* @author Jim Wigginton <terrafrost@php.net>
|
|
* @access public
|
|
*/
|
|
class RC4 extends Base
|
|
{
|
|
/**#@+
|
|
* @access private
|
|
* @see \phpseclib\Crypt\RC4::_crypt()
|
|
*/
|
|
const ENCRYPT = 0;
|
|
const DECRYPT = 1;
|
|
/**#@-*/
|
|
|
|
/**
|
|
* Block Length of the cipher
|
|
*
|
|
* RC4 is a stream cipher
|
|
* so we the block_size to 0
|
|
*
|
|
* @see \phpseclib\Crypt\Base::block_size
|
|
* @var int
|
|
* @access private
|
|
*/
|
|
var $block_size = 0;
|
|
|
|
/**
|
|
* Key Length (in bytes)
|
|
*
|
|
* @see \phpseclib\Crypt\RC4::setKeyLength()
|
|
* @var int
|
|
* @access private
|
|
*/
|
|
var $key_length = 128; // = 1024 bits
|
|
|
|
/**
|
|
* The mcrypt specific name of the cipher
|
|
*
|
|
* @see \phpseclib\Crypt\Base::cipher_name_mcrypt
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $cipher_name_mcrypt = 'arcfour';
|
|
|
|
/**
|
|
* Holds whether performance-optimized $inline_crypt() can/should be used.
|
|
*
|
|
* @see \phpseclib\Crypt\Base::inline_crypt
|
|
* @var mixed
|
|
* @access private
|
|
*/
|
|
var $use_inline_crypt = false; // currently not available
|
|
|
|
/**
|
|
* The Key
|
|
*
|
|
* @see self::setKey()
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $key = "\0";
|
|
|
|
/**
|
|
* The Key Stream for decryption and encryption
|
|
*
|
|
* @see self::setKey()
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
var $stream;
|
|
|
|
/**
|
|
* Default Constructor.
|
|
*
|
|
* Determines whether or not the mcrypt extension should be used.
|
|
*
|
|
* @see \phpseclib\Crypt\Base::__construct()
|
|
* @return \phpseclib\Crypt\RC4
|
|
* @access public
|
|
*/
|
|
function __construct()
|
|
{
|
|
parent::__construct(Base::MODE_STREAM);
|
|
}
|
|
|
|
/**
|
|
* Test for engine validity
|
|
*
|
|
* This is mainly just a wrapper to set things up for \phpseclib\Crypt\Base::isValidEngine()
|
|
*
|
|
* @see \phpseclib\Crypt\Base::__construct()
|
|
* @param int $engine
|
|
* @access public
|
|
* @return bool
|
|
*/
|
|
function isValidEngine($engine)
|
|
{
|
|
switch ($engine) {
|
|
case Base::ENGINE_OPENSSL:
|
|
switch (strlen($this->key)) {
|
|
case 5:
|
|
$this->cipher_name_openssl = 'rc4-40';
|
|
break;
|
|
case 8:
|
|
$this->cipher_name_openssl = 'rc4-64';
|
|
break;
|
|
case 16:
|
|
$this->cipher_name_openssl = 'rc4';
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return parent::isValidEngine($engine);
|
|
}
|
|
|
|
/**
|
|
* Dummy function.
|
|
*
|
|
* Some protocols, such as WEP, prepend an "initialization vector" to the key, effectively creating a new key [1].
|
|
* If you need to use an initialization vector in this manner, feel free to prepend it to the key, yourself, before
|
|
* calling setKey().
|
|
*
|
|
* [1] WEP's initialization vectors (IV's) are used in a somewhat insecure way. Since, in that protocol,
|
|
* the IV's are relatively easy to predict, an attack described by
|
|
* {@link http://www.drizzle.com/~aboba/IEEE/rc4_ksaproc.pdf Scott Fluhrer, Itsik Mantin, and Adi Shamir}
|
|
* can be used to quickly guess at the rest of the key. The following links elaborate:
|
|
*
|
|
* {@link http://www.rsa.com/rsalabs/node.asp?id=2009 http://www.rsa.com/rsalabs/node.asp?id=2009}
|
|
* {@link http://en.wikipedia.org/wiki/Related_key_attack http://en.wikipedia.org/wiki/Related_key_attack}
|
|
*
|
|
* @param string $iv
|
|
* @see self::setKey()
|
|
* @access public
|
|
*/
|
|
function setIV($iv)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Sets the key length
|
|
*
|
|
* Keys can be between 1 and 256 bytes long.
|
|
*
|
|
* @access public
|
|
* @param int $length
|
|
*/
|
|
function setKeyLength($length)
|
|
{
|
|
if ($length < 8) {
|
|
$this->key_length = 1;
|
|
} elseif ($length > 2048) {
|
|
$this->key_length = 256;
|
|
} else {
|
|
$this->key_length = $length >> 3;
|
|
}
|
|
|
|
parent::setKeyLength($length);
|
|
}
|
|
|
|
/**
|
|
* Encrypts a message.
|
|
*
|
|
* @see \phpseclib\Crypt\Base::decrypt()
|
|
* @see self::_crypt()
|
|
* @access public
|
|
* @param string $plaintext
|
|
* @return string $ciphertext
|
|
*/
|
|
function encrypt($plaintext)
|
|
{
|
|
if ($this->engine != Base::ENGINE_INTERNAL) {
|
|
return parent::encrypt($plaintext);
|
|
}
|
|
return $this->_crypt($plaintext, self::ENCRYPT);
|
|
}
|
|
|
|
/**
|
|
* Decrypts a message.
|
|
*
|
|
* $this->decrypt($this->encrypt($plaintext)) == $this->encrypt($this->encrypt($plaintext)).
|
|
* At least if the continuous buffer is disabled.
|
|
*
|
|
* @see \phpseclib\Crypt\Base::encrypt()
|
|
* @see self::_crypt()
|
|
* @access public
|
|
* @param string $ciphertext
|
|
* @return string $plaintext
|
|
*/
|
|
function decrypt($ciphertext)
|
|
{
|
|
if ($this->engine != Base::ENGINE_INTERNAL) {
|
|
return parent::decrypt($ciphertext);
|
|
}
|
|
return $this->_crypt($ciphertext, self::DECRYPT);
|
|
}
|
|
|
|
/**
|
|
* Encrypts a block
|
|
*
|
|
* @access private
|
|
* @param string $in
|
|
*/
|
|
function _encryptBlock($in)
|
|
{
|
|
// RC4 does not utilize this method
|
|
}
|
|
|
|
/**
|
|
* Decrypts a block
|
|
*
|
|
* @access private
|
|
* @param string $in
|
|
*/
|
|
function _decryptBlock($in)
|
|
{
|
|
// RC4 does not utilize this method
|
|
}
|
|
|
|
/**
|
|
* Setup the key (expansion)
|
|
*
|
|
* @see \phpseclib\Crypt\Base::_setupKey()
|
|
* @access private
|
|
*/
|
|
function _setupKey()
|
|
{
|
|
$key = $this->key;
|
|
$keyLength = strlen($key);
|
|
$keyStream = range(0, 255);
|
|
$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[self::DECRYPT] = $this->stream[self::ENCRYPT] = array(
|
|
0, // index $i
|
|
0, // index $j
|
|
$keyStream
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Encrypts or decrypts a message.
|
|
*
|
|
* @see self::encrypt()
|
|
* @see self::decrypt()
|
|
* @access private
|
|
* @param string $text
|
|
* @param int $mode
|
|
* @return string $text
|
|
*/
|
|
function _crypt($text, $mode)
|
|
{
|
|
if ($this->changed) {
|
|
$this->_setup();
|
|
$this->changed = false;
|
|
}
|
|
|
|
$stream = &$this->stream[$mode];
|
|
if ($this->continuousBuffer) {
|
|
$i = &$stream[0];
|
|
$j = &$stream[1];
|
|
$keyStream = &$stream[2];
|
|
} else {
|
|
$i = $stream[0];
|
|
$j = $stream[1];
|
|
$keyStream = $stream[2];
|
|
}
|
|
|
|
$len = strlen($text);
|
|
for ($k = 0; $k < $len; ++$k) {
|
|
$i = ($i + 1) & 255;
|
|
$ksi = $keyStream[$i];
|
|
$j = ($j + $ksi) & 255;
|
|
$ksj = $keyStream[$j];
|
|
|
|
$keyStream[$i] = $ksj;
|
|
$keyStream[$j] = $ksi;
|
|
$text[$k] = $text[$k] ^ chr($keyStream[($ksj + $ksi) & 255]);
|
|
}
|
|
|
|
return $text;
|
|
}
|
|
}
|