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.
457 lines
11 KiB
457 lines
11 KiB
<?php
|
|
/*
|
|
* Author: Ryan Gilfether
|
|
* URL: http://www.gilfether.com/phpCrypt
|
|
* Date: Sep 4, 2005
|
|
* Copyright (C) 2005 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__)."/Core.php");
|
|
require_once(dirname(__FILE__)."/Includes.inc.php");
|
|
|
|
/**
|
|
* The phpCrypt class, a front end to all the Ciphers and Modes phpCrypt supports
|
|
*
|
|
* @author Ryan Gilfether
|
|
* @link http://www.gilfether.com/phpcrypt
|
|
* @copyright 2005 Ryan Gilfether
|
|
*/
|
|
class PHP_Crypt
|
|
{
|
|
// Ciphers
|
|
const CIPHER_3DES = "3DES";
|
|
const CIPHER_3WAY = "3-Way";
|
|
const CIPHER_AES_128 = "AES-128";
|
|
const CIPHER_AES_192 = "AES-192";
|
|
const CIPHER_AES_256 = "AES-256";
|
|
const CIPHER_ARC4 = "ARC4"; // Alternative RC4
|
|
const CIPHER_BLOWFISH = "Blowfish";
|
|
const CIPHER_CAST_128 = "CAST-128";
|
|
const CIPHER_CAST_256 = "CAST-256";
|
|
const CIPHER_DES = "DES";
|
|
const CIPHER_ENIGMA = "Enigma";
|
|
const CIPHER_GOST = "GOST";
|
|
const CIPHER_RC2 = "RC2";
|
|
const CIPHER_RIJNDAEL_128 = "Rijndael-128";
|
|
const CIPHER_RIJNDAEL_192 = "Rijndael-192";
|
|
const CIPHER_RIJNDAEL_256 = "Rijndael-256";
|
|
const CIPHER_SKIPJACK = "Skipjack";
|
|
const CIPHER_SIMPLEXOR = "SimpleXOR";
|
|
const CIPHER_VIGENERE = "Vigenere"; // historical
|
|
|
|
// Modes
|
|
const MODE_CBC = "CBC";
|
|
const MODE_CFB = "CFB"; // 8 bit cfb mode
|
|
const MODE_CTR = "CTR";
|
|
const MODE_ECB = "ECB";
|
|
const MODE_NCFB = "NCFB"; // blocksize cfb mode
|
|
const MODE_NOFB = "NOFB"; // blocksize ofb mode
|
|
const MODE_OFB = "OFB"; // 8 bit ofb mode
|
|
const MODE_PCBC = "PCBC";
|
|
const MODE_RAW = "Raw"; // raw encryption, with no mode
|
|
const MODE_STREAM = "Stream"; // used only for stream ciphers
|
|
|
|
// The source of random data used to create keys and IV's
|
|
// Used for PHP_Crypt::createKey(), PHP_Crypt::createIV()
|
|
const RAND = "rand"; // uses mt_rand(), windows & unix
|
|
const RAND_DEV_RAND = "/dev/random"; // unix only
|
|
const RAND_DEV_URAND= "/dev/urandom";// unix only
|
|
const RAND_WIN_COM = "wincom"; // windows only, COM extension
|
|
const RAND_DEFAULT_SZ = 32; // the default number of bytes returned
|
|
|
|
// Padding types
|
|
const PAD_ZERO = 0;
|
|
const PAD_ANSI_X923 = 1;
|
|
const PAD_ISO_10126 = 2;
|
|
const PAD_PKCS7 = 3;
|
|
const PAD_ISO_7816_4 = 4;
|
|
|
|
|
|
/** @type object $cipher An instance of the cipher object selected */
|
|
private $cipher = null;
|
|
|
|
/** @type object $mode An instance of the mode object selected */
|
|
private $mode = null;
|
|
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @param string $key The key to use for the selected Cipher
|
|
* @param string $cipher The type of cipher to use
|
|
* @param string $mode The encrypt mode to use with the cipher
|
|
* @param string $padding The padding type to use. Defaults to PAD_ZERO
|
|
* @return void
|
|
*/
|
|
public function __construct($key, $cipher = self::CIPHER_AES_128, $mode = self::MODE_ECB, $padding = self::PAD_ZERO)
|
|
{
|
|
/*
|
|
* CIPHERS
|
|
*/
|
|
switch($cipher)
|
|
{
|
|
case self::CIPHER_3DES:
|
|
$this->cipher = new Cipher_3DES($key);
|
|
break;
|
|
|
|
case self::CIPHER_3WAY:
|
|
$this->cipher = new Cipher_3WAY($key);
|
|
break;
|
|
|
|
case self::CIPHER_AES_128:
|
|
$this->cipher = new Cipher_AES_128($key);
|
|
break;
|
|
|
|
case self::CIPHER_AES_192:
|
|
$this->cipher = new Cipher_AES_192($key);
|
|
break;
|
|
|
|
case self::CIPHER_AES_256:
|
|
$this->cipher = new Cipher_AES_256($key);
|
|
break;
|
|
|
|
case self::CIPHER_ARC4: // an alternative to RC4
|
|
$this->cipher = new Cipher_ARC4($key);
|
|
break;
|
|
|
|
case self::CIPHER_BLOWFISH:
|
|
$this->cipher = new Cipher_Blowfish($key);
|
|
break;
|
|
|
|
case self::CIPHER_CAST_128:
|
|
$this->cipher = new Cipher_CAST_128($key);
|
|
break;
|
|
|
|
case self::CIPHER_CAST_256:
|
|
$this->cipher = new Cipher_CAST_256($key);
|
|
break;
|
|
|
|
case self::CIPHER_DES:
|
|
$this->cipher = new Cipher_DES($key);
|
|
break;
|
|
|
|
case self::CIPHER_ENIGMA:
|
|
$this->cipher = new Cipher_Enigma($key);
|
|
break;
|
|
|
|
case self::CIPHER_GOST:
|
|
$this->cipher = new Cipher_GOST($key);
|
|
break;
|
|
|
|
case self::CIPHER_RC2:
|
|
$this->cipher = new Cipher_RC2($key);
|
|
break;
|
|
|
|
case self::CIPHER_RIJNDAEL_128:
|
|
$this->cipher = new Cipher_Rijndael_128($key);
|
|
break;
|
|
|
|
case self::CIPHER_RIJNDAEL_192:
|
|
$this->cipher = new Cipher_Rijndael_192($key);
|
|
break;
|
|
|
|
case self::CIPHER_RIJNDAEL_256:
|
|
$this->cipher = new Cipher_Rijndael_256($key);
|
|
break;
|
|
|
|
case self::CIPHER_SIMPLEXOR:
|
|
$this->cipher = new Cipher_Simple_XOR($key);
|
|
break;
|
|
|
|
case self::CIPHER_SKIPJACK:
|
|
$this->cipher = new Cipher_Skipjack($key);
|
|
break;
|
|
|
|
case self::CIPHER_VIGENERE:
|
|
$this->cipher = new Cipher_Vigenere($key);
|
|
break;
|
|
|
|
default:
|
|
trigger_error("$cipher is not a valid cipher", E_USER_WARNING);
|
|
}
|
|
|
|
|
|
/*
|
|
* MODES
|
|
*/
|
|
switch($mode)
|
|
{
|
|
case self::MODE_CBC:
|
|
$this->mode = new Mode_CBC($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_CFB:
|
|
$this->mode = new Mode_CFB($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_CTR:
|
|
$this->mode = new Mode_CTR($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_ECB:
|
|
$this->mode = new Mode_ECB($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_NCFB:
|
|
$this->mode = new Mode_NCFB($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_NOFB:
|
|
$this->mode = new Mode_NOFB($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_OFB:
|
|
$this->mode = new Mode_OFB($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_PCBC:
|
|
$this->mode = new Mode_PCBC($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_RAW:
|
|
$this->mode = new Mode_RAW($this->cipher);
|
|
break;
|
|
|
|
case self::MODE_STREAM:
|
|
$this->mode = new Mode_Stream($this->cipher);
|
|
break;
|
|
|
|
default:
|
|
trigger_error("$mode is not a valid mode", E_USER_WARNING);
|
|
}
|
|
|
|
// set the default padding
|
|
$this->padding($padding);
|
|
}
|
|
|
|
|
|
/**
|
|
* Destructor
|
|
*
|
|
* @return void
|
|
*/
|
|
public function __destruct()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Encrypt a plain text message using the Mode and Cipher selected.
|
|
* Some stream modes require this function to be called in a loop
|
|
* which requires the use of $result parameter to retrieve
|
|
* the decrypted data.
|
|
*
|
|
* @param string $text The plain text string
|
|
* @return string The encrypted string
|
|
*/
|
|
public function encrypt($text)
|
|
{
|
|
// check that an iv is set, if required by the mode
|
|
$this->mode->checkIV();
|
|
|
|
// the encryption is done inside the mode
|
|
$this->mode->encrypt($text);
|
|
return $text;
|
|
}
|
|
|
|
|
|
/**
|
|
* Decrypt an encrypted message using the Mode and Cipher selected.
|
|
* Some stream modes require this function to be called in a loop
|
|
* which requires the use of $result parameter to retrieve
|
|
* the decrypted data.
|
|
*
|
|
* @param string $text The encrypted string
|
|
* @return string The decrypted string
|
|
*/
|
|
public function decrypt($text)
|
|
{
|
|
// check that an iv is set, if required by the mode
|
|
$this->mode->checkIV();
|
|
|
|
// the decryption is done inside the mode
|
|
$this->mode->decrypt($text);
|
|
return $text;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the cipher object being used
|
|
*
|
|
* @return object The Cipher object
|
|
*/
|
|
public function cipher()
|
|
{
|
|
return $this->cipher;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the mode object being used
|
|
*
|
|
* @return object The Mode object
|
|
*/
|
|
public function mode()
|
|
{
|
|
return $this->mode;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the name of the cipher being used
|
|
*
|
|
* @return string The name of the cipher currently in use,
|
|
* it will be one of the predefined phpCrypt cipher constants
|
|
*/
|
|
public function cipherName()
|
|
{
|
|
return $this->cipher->name();
|
|
}
|
|
|
|
|
|
/**
|
|
* Return the name of the mode being used
|
|
*
|
|
* @return string The name of the mode in use, it will
|
|
* be one of the predefined phpCrypt mode constants
|
|
*/
|
|
public function modeName()
|
|
{
|
|
return $this->mode->name();
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns Ciphers required block size in bytes
|
|
*
|
|
* @return integer The cipher data block size, in bytes
|
|
*/
|
|
public function cipherBlockSize()
|
|
{
|
|
return $this->cipher->blockSize();
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the cipher's required key size, in bytes
|
|
*
|
|
* @return integer The cipher's key size requirement, in bytes
|
|
*/
|
|
public function cipherKeySize()
|
|
{
|
|
return $this->cipher->keySize();
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets and/or returns the key to be used. Normally you set
|
|
* the key in the phpCrypt constructor. This can be usefully
|
|
* if you need to change the key on the fly and don't want
|
|
* to create a new instance of phpCrypt.
|
|
*
|
|
* If the $key parameter is not given, this function will simply
|
|
* return the key currently in use.
|
|
*
|
|
* @param string $key Optional, The key to set
|
|
* @return string The key being used
|
|
*/
|
|
public function cipherKey($key = "")
|
|
{
|
|
return $this->cipher->key($key);
|
|
}
|
|
|
|
|
|
/**
|
|
* A helper function which will create a random key. Calls
|
|
* Core::randBytes(). By default it will use PHP_Crypt::RAND for
|
|
* the random source of bytes, and return a PHP_Crypt::RAND_DEFAULT_SZ
|
|
* byte string. There are 4 ways to create a random byte string by
|
|
* setting the $src parameter:
|
|
* PHP_Crypt::RAND - Default, uses mt_rand()
|
|
* PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
|
|
* PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
|
|
* PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
|
|
*
|
|
* @param string $src Optional, The source to use to create random bytes
|
|
* @param integer $len Optional, The number of random bytes to return
|
|
* @return string A random string of bytes
|
|
*/
|
|
public static function createKey($src = self::RAND, $len = self::RAND_DEFAULT_SZ)
|
|
{
|
|
return Core::randBytes($src, $len);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the IV to use. Note that you do not need to call
|
|
* this function if creating an IV using createIV(). This
|
|
* function is used when an IV has already been created
|
|
* outside of phpCrypt and needs to be set. Alternatively
|
|
* you can just pass the $iv parameter to the encrypt()
|
|
* or decrypt() functions
|
|
*
|
|
* When the $iv parameter is not given, the function will
|
|
* return the current IV being used. See createIV() if you
|
|
* need to create an IV.
|
|
*
|
|
* @param string $iv Optional, The IV to use during Encryption/Decryption
|
|
* @return void
|
|
*/
|
|
public function IV($iv = "")
|
|
{
|
|
return $this->mode->IV($iv);
|
|
}
|
|
|
|
|
|
/**
|
|
* Creates an IV for the the Cipher selected, if one is required.
|
|
* If you already have an IV to use, this function does not need
|
|
* to be called, instead set it with setIV(). If you create an
|
|
* IV with createIV(), you do not need to set it with setIV(),
|
|
* as it is automatically set in this function
|
|
*
|
|
* $src values are:
|
|
* PHP_Crypt::RAND - Default, uses mt_rand()
|
|
* PHP_Crypt::RAND_DEV_RAND - Unix only, uses /dev/random
|
|
* PHP_Crypt::RAND_DEV_URAND - Unix only, uses /dev/urandom
|
|
* PHP_Crypt::RAND_WIN_COM - Windows only, uses Microsoft's CAPICOM SDK
|
|
*
|
|
* @param string $src Optional, how the IV is generated
|
|
* @return string The IV that was created, and set for the mode
|
|
*/
|
|
public function createIV($src = self::RAND)
|
|
{
|
|
return $this->mode->createIV($src);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the type of padding to be used within the specified Mode
|
|
*
|
|
* @param string $type One of the predefined padding types
|
|
* @return void
|
|
*/
|
|
public function padding($type = "")
|
|
{
|
|
return $this->mode->padding($type);
|
|
}
|
|
}
|
|
?>
|