You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
10 KiB
341 lines
10 KiB
<?php
|
|
/*
|
|
* Author: Ryan Gilfether
|
|
* URL: http://www.gilfether.com/phpCrypt
|
|
* Date: May 5, 2013
|
|
* Copyright (C) 2013 Ryan Gilfether
|
|
*
|
|
* This file is part of phpCrypt
|
|
*
|
|
* phpCrypt is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
namespace PHP_CRYPT;
|
|
require_once(dirname(__FILE__)."/../Cipher.php");
|
|
require_once(dirname(__FILE__)."/../phpCrypt.php");
|
|
|
|
|
|
/**
|
|
* Implements RC2 Encryption
|
|
* The key size must be a multiple of 8 bits, between 8-128 bits
|
|
* Most of this was implemented by reading the original RC2
|
|
* C source code, and recreating it in PHP
|
|
*
|
|
* Resources used to implement this algorithm
|
|
* https://groups.google.com/forum/?fromgroups=#!msg/sci.crypt/m1UFiFMC89Y/cLyO5tr1g_MJ
|
|
* http://tools.ietf.org/html/rfc2268
|
|
* http://www.ipa.go.jp/security/rfc/RFC2268EN.html
|
|
* http://www.umich.edu/~x509/ssleay/rrc2.html
|
|
*
|
|
* @author Ryan Gilfether
|
|
* @link http://www.gilfether.com/phpcrypt
|
|
* @copyright 2013 Ryan Gilfether
|
|
*/
|
|
class Cipher_RC2 extends Cipher
|
|
{
|
|
/** @type integer BYTES_BLOCK The size of the block, in bytes */
|
|
const BYTES_BLOCK = 8; // 64 bits
|
|
|
|
// rc2 has a variable length key, between 1 - 128 bytes (8-1024 bits)
|
|
//const BYTES_KEY = 0;
|
|
|
|
/** @type array $_sbox RC2's sBox, initialized in initTables() */
|
|
private static $_sbox = array();
|
|
|
|
/** @type string $xkey The expanded key */
|
|
private $xkey = "";
|
|
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @param string $key The key used for Encryption/Decryption
|
|
* @return void
|
|
*/
|
|
public function __construct($key)
|
|
{
|
|
// the key must be between 1 and 128 bytes, keys larger than
|
|
// 128 bytes are truncated in expandedKey()
|
|
$keylen = strlen($key);
|
|
if($keylen < 1)
|
|
{
|
|
$err = "Key size is $keylen bits, Key size must be between 1 and 128 bytes";
|
|
trigger_error($err, E_USER_WARNING);
|
|
}
|
|
|
|
// set the key
|
|
parent::__construct(PHP_Crypt::CIPHER_RC2, $key, $keylen);
|
|
|
|
// set the block size
|
|
$this->blockSize(self::BYTES_BLOCK);
|
|
|
|
// initialize the tables
|
|
$this->initTables();
|
|
|
|
// expand the key to 128 bytes
|
|
$this->expandKey();
|
|
}
|
|
|
|
|
|
/**
|
|
* Destructor
|
|
*
|
|
* @return void
|
|
*/
|
|
public function __destruct()
|
|
{
|
|
parent::__destruct();
|
|
}
|
|
|
|
|
|
/**
|
|
* Encrypt plain text data using RC2
|
|
*
|
|
* @param string $text A 64 bit (8 byte) plain text string
|
|
* @return boolean Returns true
|
|
*/
|
|
public function encrypt(&$text)
|
|
{
|
|
$this->operation(parent::ENCRYPT);
|
|
|
|
// split up the message and key into 4 16 bit parts (2 byte words),
|
|
// then convert each array element to an integer
|
|
$w = self::splitBytes($text);
|
|
$k = self::splitBytes($this->xkey);
|
|
$j = 0; // the key index
|
|
|
|
for($i = 0; $i < 16; ++$i)
|
|
{
|
|
$j = $i * 4;
|
|
|
|
/* This is where it gets ugly, RC2 relies on unsigned ints. PHP does
|
|
* not have a nice way to handle unsigned ints, so we have to rely on sprintf.
|
|
* To make RC2 compatible with mCrypt, I also forced everything to 32 bit
|
|
* When I test against mcrypt and the original rc2 C source, I get 32 bit
|
|
* results, even on a 64 bit platform
|
|
*/
|
|
|
|
// 16 rounds of RC2's Mixing algorithm for each 2 byte 'word' as
|
|
// required by RC2
|
|
$w[0] += parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
|
|
$w[0] = sprintf("%u", $w[0] << 1) + sprintf("%u", $w[0] >> 15 & 1);
|
|
$w[0] = parent::uInt32($w[0]);
|
|
|
|
$w[1] += parent::uInt($w[2] & ~$w[0]) + parent::uInt($w[3] & $w[0]) + $k[$j + 1];
|
|
$w[1] = parent::uInt($w[1] << 2) + parent::uInt($w[1] >> 14 & 3);
|
|
$w[1] = parent::uInt32($w[1]);
|
|
|
|
$w[2] += parent::uInt($w[3] & ~$w[1]) + parent::uInt($w[0] & $w[1]) + $k[$j + 2];
|
|
$w[2] = parent::uInt($w[2] << 3) + parent::uInt($w[2] >> 13 & 7);
|
|
$w[2] = parent::uInt32($w[2]);
|
|
|
|
$w[3] += parent::uInt($w[0] & ~$w[2]) + parent::uInt($w[1] & $w[2]) + $k[$j + 3];
|
|
$w[3] = parent::uInt($w[3] << 5) + parent::uInt($w[3] >> 11 & 31);
|
|
$w[3] = parent::uInt32($w[3]);
|
|
|
|
// rounds 5 and 11 get rc2's Mash
|
|
if($i == 4 || $i == 10)
|
|
{
|
|
$w[0] += $k[$w[3] & 63];
|
|
$w[1] += $k[$w[0] & 63];
|
|
$w[2] += $k[$w[1] & 63];
|
|
$w[3] += $k[$w[2] & 63];
|
|
}
|
|
}
|
|
|
|
/* truthfully, I am not clear why this is required. It was not mentioned
|
|
* in any of the documentation I read, however reading the original RC2 C
|
|
* source code, this was done and in order for me to get the
|
|
* correct results in PHP I needed to do this as well
|
|
*/
|
|
$max = count($w);
|
|
for($i = 0; $i < $max; ++$i)
|
|
{
|
|
$pos = $i * 2;
|
|
$text[$pos] = chr($w[$i]);
|
|
$text[$pos+1] = chr($w[$i] >> 8);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Decrypt a RC2 encrypted string
|
|
*
|
|
* @param string $text A RC2 encrypted string
|
|
* @return boolean Returns true
|
|
*/
|
|
public function decrypt(&$text)
|
|
{
|
|
$this->operation(parent::DECRYPT);
|
|
|
|
// first split up the message into four 16 bit parts (2 bytes),
|
|
// then convert each array element to an integer
|
|
$w = self::splitBytes($text);
|
|
$k = self::splitBytes($this->xkey);
|
|
$j = 0; // the key index
|
|
|
|
for($i = 15; $i >= 0; --$i)
|
|
{
|
|
$j = $i * 4;
|
|
|
|
/* This is where it gets ugly, RC2 relies on unsigned ints. PHP does
|
|
* not have a nice way to handle unsigned ints, so we have to rely on sprintf.
|
|
* To make RC2 compatible with mCrypt, I also forced everything to 32 bit
|
|
* When I test against mcrypt and the original rc2 C source, I get 32 bit
|
|
* results, even on a 64 bit platform
|
|
*/
|
|
|
|
$w[3] &= 65535;
|
|
$w[3] = parent::uInt($w[3] << 11) + parent::uInt($w[3] >> 5);
|
|
$w[3] -= parent::uInt($w[0] & ~$w[2]) + parent::uInt($w[1] & $w[2]) + $k[$j + 3];
|
|
$w[3] = parent::uInt32($w[3]);
|
|
|
|
$w[2] &= 65535;
|
|
$w[2] = parent::uInt($w[2] << 13) + parent::uInt($w[2] >> 3);
|
|
$w[2] -= parent::uInt($w[3] & ~$w[1]) + parent::uInt($w[0] & $w[1]) + $k[$j + 2];
|
|
$w[2] = parent::uInt32($w[2]);
|
|
|
|
$w[1] &= 65535;
|
|
$w[1] = parent::uInt($w[1] << 14) + parent::uInt($w[1] >> 2);
|
|
$w[1] -= parent::uInt($w[2] & ~$w[0]) + parent::uInt($w[3] & $w[0]) + $k[$j + 1];
|
|
$w[1] = parent::uInt32($w[1]);
|
|
|
|
$w[0] &= 65535;
|
|
$w[0] = parent::uInt($w[0] << 15) + parent::uInt($w[0] >> 1);
|
|
$w[0] -= parent::uInt($w[1] & ~$w[3]) + parent::uInt($w[2] & $w[3]) + $k[$j + 0];
|
|
$w[0] = parent::uInt32($w[0]);
|
|
|
|
if($i == 5 || $i == 11)
|
|
{
|
|
$w[3] -= $k[$w[2] & 63];
|
|
$w[2] -= $k[$w[1] & 63];
|
|
$w[1] -= $k[$w[0] & 63];
|
|
$w[0] -= $k[$w[3] & 63];
|
|
}
|
|
}
|
|
|
|
|
|
/* I am not clear why this is required. It was not mentioned
|
|
* in any of the documentation I read, however reading the original RC2 C
|
|
* source code, this was done and in order for me to get the
|
|
* correct results in PHP I needed to do this as well
|
|
*/
|
|
$max = count($w);
|
|
for($i = 0; $i < $max; ++$i)
|
|
{
|
|
$pos = $i * 2;
|
|
$text[$pos] = chr($w[$i]);
|
|
$text[$pos+1] = chr($w[$i] >> 8);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Splits an 8 byte string into four array elements of 2 bytes each, swaps the bytes
|
|
* of each array element, and converts the result into an integer
|
|
*
|
|
* @param string $str The 8 byte string to split and convert
|
|
* @return array An array of 4 elements, each with 2 bytes
|
|
*/
|
|
private static function splitBytes($str)
|
|
{
|
|
$arr = str_split($str, 2);
|
|
|
|
return array_map(function($b){
|
|
return Core::str2Dec($b[1].$b[0]);
|
|
}, $arr);
|
|
}
|
|
|
|
|
|
/**
|
|
* Expands the key to 128 bits. RC2 uses an initial key size between
|
|
* 8 - 128 bits, then takes the initial key and expands it out to 128
|
|
* bits, which is used for encryption
|
|
*
|
|
* @return void
|
|
*/
|
|
private function expandKey()
|
|
{
|
|
// start by copying the key to the xkey variable
|
|
$this->xkey = $this->key();
|
|
$len = $this->keySize();
|
|
|
|
// the max length of the key is 128 bytes
|
|
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)
|
|
{
|
|
$byte1 = ord($this->xkey[$i - $len]);
|
|
$byte2 = ord($this->xkey[$i - 1]);
|
|
$pos = ($byte1 + $byte2);
|
|
|
|
// 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;
|
|
|
|
$this->xkey .= chr(self::$_sbox[$pos]);
|
|
}
|
|
|
|
// now replace the first byte of the key with it's position in the sbox
|
|
$pos = ord($this->xkey[0]);
|
|
$this->xkey[0] = chr(self::$_sbox[$pos]);
|
|
}
|
|
|
|
|
|
/**
|
|
* Initialize tables
|
|
*
|
|
* @return void
|
|
*/
|
|
private function initTables()
|
|
{
|
|
self::$_sbox = array(
|
|
0xd9, 0x78, 0xf9, 0xc4, 0x19, 0xdd, 0xb5, 0xed, 0x28, 0xe9, 0xfd, 0x79, 0x4a, 0xa0, 0xd8, 0x9d,
|
|
0xc6, 0x7e, 0x37, 0x83, 0x2b, 0x76, 0x53, 0x8e, 0x62, 0x4c, 0x64, 0x88, 0x44, 0x8b, 0xfb, 0xa2,
|
|
0x17, 0x9a, 0x59, 0xf5, 0x87, 0xb3, 0x4f, 0x13, 0x61, 0x45, 0x6d, 0x8d, 0x09, 0x81, 0x7d, 0x32,
|
|
0xbd, 0x8f, 0x40, 0xeb, 0x86, 0xb7, 0x7b, 0x0b, 0xf0, 0x95, 0x21, 0x22, 0x5c, 0x6b, 0x4e, 0x82,
|
|
0x54, 0xd6, 0x65, 0x93, 0xce, 0x60, 0xb2, 0x1c, 0x73, 0x56, 0xc0, 0x14, 0xa7, 0x8c, 0xf1, 0xdc,
|
|
0x12, 0x75, 0xca, 0x1f, 0x3b, 0xbe, 0xe4, 0xd1, 0x42, 0x3d, 0xd4, 0x30, 0xa3, 0x3c, 0xb6, 0x26,
|
|
0x6f, 0xbf, 0x0e, 0xda, 0x46, 0x69, 0x07, 0x57, 0x27, 0xf2, 0x1d, 0x9b, 0xbc, 0x94, 0x43, 0x03,
|
|
0xf8, 0x11, 0xc7, 0xf6, 0x90, 0xef, 0x3e, 0xe7, 0x06, 0xc3, 0xd5, 0x2f, 0xc8, 0x66, 0x1e, 0xd7,
|
|
0x08, 0xe8, 0xea, 0xde, 0x80, 0x52, 0xee, 0xf7, 0x84, 0xaa, 0x72, 0xac, 0x35, 0x4d, 0x6a, 0x2a,
|
|
0x96, 0x1a, 0xd2, 0x71, 0x5a, 0x15, 0x49, 0x74, 0x4b, 0x9f, 0xd0, 0x5e, 0x04, 0x18, 0xa4, 0xec,
|
|
0xc2, 0xe0, 0x41, 0x6e, 0x0f, 0x51, 0xcb, 0xcc, 0x24, 0x91, 0xaf, 0x50, 0xa1, 0xf4, 0x70, 0x39,
|
|
0x99, 0x7c, 0x3a, 0x85, 0x23, 0xb8, 0xb4, 0x7a, 0xfc, 0x02, 0x36, 0x5b, 0x25, 0x55, 0x97, 0x31,
|
|
0x2d, 0x5d, 0xfa, 0x98, 0xe3, 0x8a, 0x92, 0xae, 0x05, 0xdf, 0x29, 0x10, 0x67, 0x6c, 0xba, 0xc9,
|
|
0xd3, 0x00, 0xe6, 0xcf, 0xe1, 0x9e, 0xa8, 0x2c, 0x63, 0x16, 0x01, 0x3f, 0x58, 0xe2, 0x89, 0xa9,
|
|
0x0d, 0x38, 0x34, 0x1b, 0xab, 0x33, 0xff, 0xb0, 0xbb, 0x48, 0x0c, 0x5f, 0xb9, 0xb1, 0xcd, 0x2e,
|
|
0xc5, 0xf3, 0xdb, 0x47, 0xe5, 0xa5, 0x9c, 0x77, 0x0a, 0xa6, 0x20, 0x68, 0xfe, 0x7f, 0xc1, 0xad
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
* Indicates this is a block cipher
|
|
*
|
|
* @return integer Returns Cipher::BLOCK
|
|
*/
|
|
public function type()
|
|
{
|
|
return parent::BLOCK;
|
|
}
|
|
}
|
|
?>
|