Your IP : 216.73.216.248
AbstractAdapter.php 0000644 00000003503 15235531562 0010331 0 ustar 00 <?php
/**
* @package FOF
* @copyright Copyright (c)2010-2022 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace FOF40\Encrypt\AesAdapter;
defined('_JEXEC') || die();
/**
* Abstract AES encryption class
*/
abstract class AbstractAdapter
{
/**
* Trims or zero-pads a key / IV
*
* @param string $key The key or IV to treat
* @param int $size The block size of the currently used algorithm
*
* @return null|string Null if $key is null, treated string of $size byte length otherwise
*/
public function resizeKey(string $key, int $size): ?string
{
if (empty($key))
{
return null;
}
$keyLength = strlen($key);
if (function_exists('mb_strlen'))
{
$keyLength = mb_strlen($key, 'ASCII');
}
if ($keyLength === $size)
{
return $key;
}
if ($keyLength > $size)
{
if (function_exists('mb_substr'))
{
return mb_substr($key, 0, $size, 'ASCII');
}
return substr($key, 0, $size);
}
return $key . str_repeat("\0", ($size - $keyLength));
}
/**
* Returns null bytes to append to the string so that it's zero padded to the specified block size
*
* @param string $string The binary string which will be zero padded
* @param int $blockSize The block size
*
* @return string The zero bytes to append to the string to zero pad it to $blockSize
*/
protected function getZeroPadding(string $string, int $blockSize): string
{
$stringSize = strlen($string);
if (function_exists('mb_strlen'))
{
$stringSize = mb_strlen($string, 'ASCII');
}
if ($stringSize === $blockSize)
{
return '';
}
if ($stringSize < $blockSize)
{
return str_repeat("\0", $blockSize - $stringSize);
}
$paddingBytes = $stringSize % $blockSize;
return str_repeat("\0", $blockSize - $paddingBytes);
}
}
AdapterInterface.php 0000644 00000004444 15235531562 0010473 0 ustar 00 <?php
/**
* @package FOF
* @copyright Copyright (c)2010-2022 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace FOF40\Encrypt\AesAdapter;
defined('_JEXEC') || die;
/**
* Interface for AES encryption adapters
*/
interface AdapterInterface
{
/**
* Sets the AES encryption mode.
*
* @param string $mode Choose between CBC (recommended) or ECB
*
* @return void
*/
public function setEncryptionMode(string $mode = 'cbc'): void;
/**
* Encrypts a string. Returns the raw binary ciphertext.
*
* WARNING: The plaintext is zero-padded to the algorithm's block size. You are advised to store the size of the
* plaintext and trim the string to that length upon decryption.
*
* @param string $plainText The plaintext to encrypt
* @param string $key The raw binary key (will be zero-padded or chopped if its size is different than the block size)
* @param null|string $iv The initialization vector (for CBC mode algorithms)
*
* @return string The raw encrypted binary string.
*/
public function encrypt(string $plainText, string $key, ?string $iv = null): string;
/**
* Decrypts a string. Returns the raw binary plaintext.
*
* $ciphertext MUST start with the IV followed by the ciphertext, even for EBC data (the first block of data is
* dropped in EBC mode since there is no concept of IV in EBC).
*
* WARNING: The returned plaintext is zero-padded to the algorithm's block size during encryption. You are advised
* to trim the string to the original plaintext's length upon decryption. While rtrim($decrypted, "\0") sounds
* appealing it's NOT the correct approach for binary data (zero bytes may actually be part of your plaintext, not
* just padding!).
*
* @param string $cipherText The ciphertext to encrypt
* @param string $key The raw binary key (will be zero-padded or chopped if its size is different than the block size)
*
* @return string The raw unencrypted binary string.
*/
public function decrypt(string $cipherText, string $key): string;
/**
* Returns the encryption block size in bytes
*
* @return int
*/
public function getBlockSize(): int;
/**
* Is this adapter supported?
*
* @return bool
*/
public function isSupported(): bool;
}
OpenSSL.php 0000644 00000007131 15235531562 0006551 0 ustar 00 <?php
/**
* @package FOF
* @copyright Copyright (c)2010-2022 Nicholas K. Dionysopoulos / Akeeba Ltd
* @license GNU General Public License version 3, or later
*/
namespace FOF40\Encrypt\AesAdapter;
defined('_JEXEC') || die;
use FOF40\Encrypt\Randval;
class OpenSSL extends AbstractAdapter implements AdapterInterface
{
/**
* The OpenSSL options for encryption / decryption
*
* PHP 5.3 does not have the constants OPENSSL_RAW_DATA and OPENSSL_ZERO_PADDING. In fact, the parameter
* is called $raw_data and is a boolean. Since integer 1 is equivalent to boolean TRUE in PHP we can get
* away with initializing this parameter with the integer 1.
*
* @var int
*/
protected $openSSLOptions = 1;
/**
* The encryption method to use
*
* @var string
*/
protected $method = 'aes-128-cbc';
public function __construct()
{
/**
* PHP 5.4 and later replaced the $raw_data parameter with the $options parameter. Instead of a boolean we need
* to pass some flags.
*
* See http://stackoverflow.com/questions/24707007/using-openssl-raw-data-param-in-openssl-decrypt-with-php-5-3#24707117
*/
$this->openSSLOptions = OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING;
}
public function setEncryptionMode(string $mode = 'cbc'): void
{
static $availableAlgorithms = null;
static $defaultAlgo = 'aes-128-cbc';
if (!is_array($availableAlgorithms))
{
$availableAlgorithms = openssl_get_cipher_methods();
foreach ([
'aes-256-cbc', 'aes-256-ecb', 'aes-192-cbc',
'aes-192-ecb', 'aes-128-cbc', 'aes-128-ecb',
] as $algo)
{
if (in_array($algo, $availableAlgorithms))
{
$defaultAlgo = $algo;
break;
}
}
}
$mode = strtolower($mode);
if (!in_array($mode, ['cbc', 'ebc']))
{
$mode = 'cbc';
}
$algo = 'aes-128-' . $mode;
if (!in_array($algo, $availableAlgorithms))
{
$algo = $defaultAlgo;
}
$this->method = $algo;
}
public function encrypt(string $plainText, string $key, ?string $iv = null): string
{
$iv_size = $this->getBlockSize();
$key = $this->resizeKey($key, $iv_size);
$iv = $this->resizeKey($iv, $iv_size);
if (empty($iv))
{
$randVal = new Randval();
$iv = $randVal->generate($iv_size);
}
$plainText .= $this->getZeroPadding($plainText, $iv_size);
$cipherText = openssl_encrypt($plainText, $this->method, $key, $this->openSSLOptions, $iv);
return $iv . $cipherText;
}
public function decrypt(string $cipherText, string $key): string
{
$iv_size = $this->getBlockSize();
$key = $this->resizeKey($key, $iv_size);
$iv = substr($cipherText, 0, $iv_size);
$cipherText = substr($cipherText, $iv_size);
return openssl_decrypt($cipherText, $this->method, $key, $this->openSSLOptions, $iv);
}
public function isSupported(): bool
{
if (!\function_exists('openssl_get_cipher_methods'))
{
return false;
}
if (!\function_exists('openssl_random_pseudo_bytes'))
{
return false;
}
if (!\function_exists('openssl_cipher_iv_length'))
{
return false;
}
if (!\function_exists('openssl_encrypt'))
{
return false;
}
if (!\function_exists('openssl_decrypt'))
{
return false;
}
if (!\function_exists('hash'))
{
return false;
}
if (!\function_exists('hash_algos'))
{
return false;
}
$algorithms = \openssl_get_cipher_methods();
if (!in_array('aes-128-cbc', $algorithms))
{
return false;
}
$algorithms = \hash_algos();
return in_array('sha256', $algorithms);
}
/**
* @return int
*/
public function getBlockSize(): int
{
return openssl_cipher_iv_length($this->method);
}
}