Spade
Mini Shell
| Directory:~$ /home/lmsyaran/public_html/joomla4/ |
| [Home] [System Details] [Kill Me] |
index.html000064400000000054151161525240006542 0ustar00<html><body
bgcolor="#FFFFFF"></body></html>src/Encrypt/AES/Abstraction.php000064400000005174151161525250012363
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt\AES;
/**
* Abstract AES encryption class
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
abstract class Abstraction
{
/**
* 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($key, $size)
{
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, $blockSize)
{
$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);
}
}
src/Encrypt/AES/AesInterface.php000064400000007702151161525250012442
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt\AES;
use VDM\Joomla\FOF\Utils\Phpfunc;
/**
* Interface for AES encryption adapters
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
interface AesInterface
{
/**
* Sets the AES encryption mode.
*
* WARNING: The strength is deprecated as it has a different effect in
MCrypt and OpenSSL. MCrypt was abandoned in
* 2003 before the Rijndael-128 algorithm was officially the Advanced
Encryption Standard (AES). MCrypt also offered
* Rijndael-192 and Rijndael-256 algorithms with different block sizes.
These are NOT used in AES. OpenSSL, however,
* implements AES correctly. It always uses a 128-bit (16 byte) block. The
192 and 256 bit strengths refer to the
* key size, not the block size. Therefore using different strengths in
MCrypt and OpenSSL will result in different
* and incompatible ciphertexts.
*
* TL;DR: Always use $strength = 128!
*
* @param string $mode Choose between CBC (recommended) or ECB
* @param int $strength Bit strength of the key (128, 192 or 256
bits). DEPRECATED. READ NOTES ABOVE.
*
* @return mixed
*/
public function setEncryptionMode($mode = 'cbc', $strength =
128);
/**
* 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($plainText, $key, $iv = null);
/**
* 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($cipherText, $key);
/**
* Returns the encryption block size in bytes
*
* @return int
*/
public function getBlockSize();
/**
* Is this adapter supported?
*
* @param Phpfunc $phpfunc
*
* @return bool
*/
public function isSupported(Phpfunc $phpfunc = null);
}
src/Encrypt/AES/index.html000064400000000054151161525250011366
0ustar00<html><body
bgcolor="#FFFFFF"></body></html>src/Encrypt/AES/Mcrypt.php000064400000010050151161525250011355
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt\AES;
use VDM\Joomla\FOF\Encrypt\Randval;
use VDM\Joomla\FOF\Utils\Phpfunc;
use VDM\Joomla\FOF\Encrypt\AES\AesInterface;
use VDM\Joomla\FOF\Encrypt\AES\Abstraction;
/**
* Mcrypt AES encryption class
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
class Mcrypt extends Abstraction implements AesInterface
{
protected $cipherType = MCRYPT_RIJNDAEL_128;
protected $cipherMode = MCRYPT_MODE_CBC;
public function setEncryptionMode($mode = 'cbc', $strength =
128)
{
switch ((int) $strength)
{
default:
case '128':
$this->cipherType = MCRYPT_RIJNDAEL_128;
break;
case '192':
$this->cipherType = MCRYPT_RIJNDAEL_192;
break;
case '256':
$this->cipherType = MCRYPT_RIJNDAEL_256;
break;
}
switch (strtolower($mode))
{
case 'ecb':
$this->cipherMode = MCRYPT_MODE_ECB;
break;
default:
case 'cbc':
$this->cipherMode = MCRYPT_MODE_CBC;
break;
}
}
public function encrypt($plainText, $key, $iv = null)
{
$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);
}
$cipherText = mcrypt_encrypt($this->cipherType, $key, $plainText,
$this->cipherMode, $iv);
$cipherText = $iv . $cipherText;
return $cipherText;
}
public function decrypt($cipherText, $key)
{
$iv_size = $this->getBlockSize();
$key = $this->resizeKey($key, $iv_size);
$iv = substr($cipherText, 0, $iv_size);
$cipherText = substr($cipherText, $iv_size);
$plainText = mcrypt_decrypt($this->cipherType, $key, $cipherText,
$this->cipherMode, $iv);
return $plainText;
}
public function isSupported(Phpfunc $phpfunc = null)
{
if (!is_object($phpfunc) || !($phpfunc instanceof $phpfunc))
{
$phpfunc = new Phpfunc();
}
if (!$phpfunc->function_exists('mcrypt_get_key_size'))
{
return false;
}
if (!$phpfunc->function_exists('mcrypt_get_iv_size'))
{
return false;
}
if (!$phpfunc->function_exists('mcrypt_create_iv'))
{
return false;
}
if (!$phpfunc->function_exists('mcrypt_encrypt'))
{
return false;
}
if (!$phpfunc->function_exists('mcrypt_decrypt'))
{
return false;
}
if (!$phpfunc->function_exists('mcrypt_list_algorithms'))
{
return false;
}
if (!$phpfunc->function_exists('hash'))
{
return false;
}
if (!$phpfunc->function_exists('hash_algos'))
{
return false;
}
$algorightms = $phpfunc->mcrypt_list_algorithms();
if (!in_array('rijndael-128', $algorightms))
{
return false;
}
if (!in_array('rijndael-192', $algorightms))
{
return false;
}
if (!in_array('rijndael-256', $algorightms))
{
return false;
}
$algorightms = $phpfunc->hash_algos();
if (!in_array('sha256', $algorightms))
{
return false;
}
return true;
}
public function getBlockSize()
{
return mcrypt_get_iv_size($this->cipherType, $this->cipherMode);
}
}
src/Encrypt/AES/Openssl.php000064400000010757151161525250011540
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt\AES;
use VDM\Joomla\FOF\Encrypt\Randval;
use VDM\Joomla\FOF\Utils\Phpfunc;
use VDM\Joomla\FOF\Encrypt\AES\AesInterface;
use VDM\Joomla\FOF\Encrypt\AES\Abstraction;
/**
* Openssl AES encryption class
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
class Openssl extends Abstraction implements AesInterface
{
/**
* The OpenSSL options for encryption / decryption
*
* @var int
*/
protected $openSSLOptions = 0;
/**
* The encryption method to use
*
* @var string
*/
protected $method = 'aes-128-cbc';
public function __construct()
{
$this->openSSLOptions = OPENSSL_RAW_DATA | OPENSSL_ZERO_PADDING;
}
public function setEncryptionMode($mode = 'cbc', $strength =
128)
{
static $availableAlgorithms = null;
static $defaultAlgo = 'aes-128-cbc';
if (!is_array($availableAlgorithms))
{
$availableAlgorithms = openssl_get_cipher_methods();
foreach (array('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;
}
}
}
$strength = (int) $strength;
$mode = strtolower($mode);
if (!in_array($strength, array(128, 192, 256)))
{
$strength = 256;
}
if (!in_array($mode, array('cbc', 'ebc')))
{
$mode = 'cbc';
}
$algo = 'aes-' . $strength . '-' . $mode;
if (!in_array($algo, $availableAlgorithms))
{
$algo = $defaultAlgo;
}
$this->method = $algo;
}
public function encrypt($plainText, $key, $iv = null)
{
$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);
$cipherText = $iv . $cipherText;
return $cipherText;
}
public function decrypt($cipherText, $key)
{
$iv_size = $this->getBlockSize();
$key = $this->resizeKey($key, $iv_size);
$iv = substr($cipherText, 0, $iv_size);
$cipherText = substr($cipherText, $iv_size);
$plainText = openssl_decrypt($cipherText, $this->method, $key,
$this->openSSLOptions, $iv);
return $plainText;
}
public function isSupported(Phpfunc $phpfunc = null)
{
if (!is_object($phpfunc) || !($phpfunc instanceof $phpfunc))
{
$phpfunc = new Phpfunc();
}
if
(!$phpfunc->function_exists('openssl_get_cipher_methods'))
{
return false;
}
if
(!$phpfunc->function_exists('openssl_random_pseudo_bytes'))
{
return false;
}
if (!$phpfunc->function_exists('openssl_cipher_iv_length'))
{
return false;
}
if (!$phpfunc->function_exists('openssl_encrypt'))
{
return false;
}
if (!$phpfunc->function_exists('openssl_decrypt'))
{
return false;
}
if (!$phpfunc->function_exists('hash'))
{
return false;
}
if (!$phpfunc->function_exists('hash_algos'))
{
return false;
}
$algorightms = $phpfunc->openssl_get_cipher_methods();
if (!in_array('aes-128-cbc', $algorightms))
{
return false;
}
$algorightms = $phpfunc->hash_algos();
if (!in_array('sha256', $algorightms))
{
return false;
}
return true;
}
/**
* @return int
*/
public function getBlockSize()
{
return openssl_cipher_iv_length($this->method);
}
}
src/Encrypt/AES.php000064400000020252151161525250010104 0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt;
use VDM\Joomla\FOF\Encrypt\AES\AesInterface;
use VDM\Joomla\FOF\Encrypt\AES\Mcrypt;
use VDM\Joomla\FOF\Encrypt\AES\Openssl;
use VDM\Joomla\FOF\Utils\Phpfunc;
/**
* AES encryption class
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
class AES
{
/**
* The cipher key.
*
* @var string
*/
protected $key = '';
/**
* The AES encryption adapter in use.
*
* @var AesInterface
*/
protected $adapter;
/**
* Initialise the AES encryption object.
*
* Note: If the key is not 16 bytes this class will do a stupid key
expansion for legacy reasons (produce the
* SHA-256 of the key string and throw away half of it).
*
* @param string $key The encryption key (password). It
can be a raw key (16 bytes) or a passphrase.
* @param int $strength Bit strength (128, 192 or 256) –
ALWAYS USE 128 BITS. THIS PARAMETER IS DEPRECATED.
* @param string $mode Encryption mode. Can be ebc or cbc.
We recommend using cbc.
* @param Phpfunc $phpfunc For testing
* @param string $priority Priority which adapter we should try
first
*/
public function __construct($key, $strength = 128, $mode =
'cbc', Phpfunc $phpfunc = null, $priority = 'openssl')
{
if ($priority == 'openssl')
{
$this->adapter = new Openssl();
if (!$this->adapter->isSupported($phpfunc))
{
$this->adapter = new Mcrypt();
}
}
else
{
$this->adapter = new Mcrypt();
if (!$this->adapter->isSupported($phpfunc))
{
$this->adapter = new Openssl();
}
}
$this->adapter->setEncryptionMode($mode, $strength);
$this->setPassword($key, true);
}
/**
* Sets the password for this instance.
*
* WARNING: Do not use the legacy mode, it's insecure
*
* @param string $password The password (either user-provided password
or binary encryption key) to use
* @param bool $legacyMode True to use the legacy key expansion. We
recommend against using it.
*/
public function setPassword($password, $legacyMode = false)
{
$this->key = $password;
$passLength = strlen($password);
if (function_exists('mb_strlen'))
{
$passLength = mb_strlen($password, 'ASCII');
}
// Legacy mode was doing something stupid, requiring a key of 32 bytes.
DO NOT USE LEGACY MODE!
if ($legacyMode && ($passLength != 32))
{
// Legacy mode: use the sha256 of the password
$this->key = hash('sha256', $password, true);
// We have to trim or zero pad the password (we end up throwing half of
it away in Rijndael-128 / AES...)
$this->key = $this->adapter->resizeKey($this->key,
$this->adapter->getBlockSize());
}
}
/**
* Encrypts a string using AES
*
* @param string $stringToEncrypt The plaintext to encrypt
* @param bool $base64encoded Should I Base64-encode the result?
*
* @return string The cryptotext. Please note that the first 16 bytes
of
* the raw string is the IV (initialisation vector)
which
* is necessary for decoding the string.
*/
public function encryptString($stringToEncrypt, $base64encoded = true)
{
$blockSize = $this->adapter->getBlockSize();
$randVal = new Randval();
$iv = $randVal->generate($blockSize);
$key = $this->getExpandedKey($blockSize, $iv);
$cipherText = $this->adapter->encrypt($stringToEncrypt, $key,
$iv);
// Optionally pass the result through Base64 encoding
if ($base64encoded)
{
$cipherText = base64_encode((string) $cipherText);
}
// Return the result
return $cipherText;
}
/**
* Decrypts a ciphertext into a plaintext string using AES
*
* @param string $stringToDecrypt The ciphertext to decrypt. The first
16 bytes of the raw string must contain
* the IV (initialisation vector).
* @param bool $base64encoded Should I Base64-decode the data before
decryption?
*
* @return string The plain text string
*/
public function decryptString($stringToDecrypt, $base64encoded = true)
{
if ($base64encoded)
{
$stringToDecrypt = base64_decode($stringToDecrypt);
}
// Extract IV
$iv_size = $this->adapter->getBlockSize();
$iv = substr($stringToDecrypt, 0, $iv_size);
$key = $this->getExpandedKey($iv_size, $iv);
// Decrypt the data
$plainText = $this->adapter->decrypt($stringToDecrypt, $key);
return $plainText;
}
/**
* Is AES encryption supported by this PHP installation?
*
* @param Phpfunc $phpfunc
*
* @return boolean
*/
public static function isSupported(Phpfunc $phpfunc = null)
{
if (!is_object($phpfunc) || !($phpfunc instanceof $phpfunc))
{
$phpfunc = new Phpfunc();
}
$adapter = new Openssl();
if (!$adapter->isSupported($phpfunc))
{
$adapter = new Mcrypt();
if (!$adapter->isSupported($phpfunc))
{
return false;
}
}
if (!$phpfunc->function_exists('base64_encode'))
{
return false;
}
if (!$phpfunc->function_exists('base64_decode'))
{
return false;
}
if (!$phpfunc->function_exists('hash_algos'))
{
return false;
}
$algorightms = $phpfunc->hash_algos();
if (!in_array('sha256', $algorightms))
{
return false;
}
return true;
}
/**
* @param $blockSize
* @param $iv
*
* @return string
*/
public function getExpandedKey($blockSize, $iv)
{
$key = $this->key;
$passLength = strlen($key);
if (function_exists('mb_strlen'))
{
$passLength = mb_strlen($key, 'ASCII');
}
if ($passLength != $blockSize)
{
$iterations = 1000;
$salt = $this->adapter->resizeKey($iv, 16);
$key = hash_pbkdf2('sha256', $this->key, $salt,
$iterations, $blockSize, true);
}
return $key;
}
}
if (!function_exists('hash_pbkdf2'))
{
function hash_pbkdf2($algo, $password, $salt, $count, $length = 0,
$raw_output = false)
{
if (!in_array(strtolower((string) $algo), hash_algos()))
{
trigger_error(__FUNCTION__ . '(): Unknown hashing algorithm: '
. $algo, E_USER_WARNING);
}
if (!is_numeric($count))
{
trigger_error(__FUNCTION__ . '(): expects parameter 4 to be long,
' . gettype($count) . ' given', E_USER_WARNING);
}
if (!is_numeric($length))
{
trigger_error(__FUNCTION__ . '(): expects parameter 5 to be long,
' . gettype($length) . ' given', E_USER_WARNING);
}
if ($count <= 0)
{
trigger_error(__FUNCTION__ . '(): Iterations must be a positive
integer: ' . $count, E_USER_WARNING);
}
if ($length < 0)
{
trigger_error(__FUNCTION__ . '(): Length must be greater than or
equal to 0: ' . $length, E_USER_WARNING);
}
$output = '';
$block_count = $length ? ceil($length / strlen(hash((string) $algo,
'', $raw_output))) : 1;
for ($i = 1; $i <= $block_count; $i++)
{
$last = $xorsum = hash_hmac((string) $algo, $salt . pack('N',
$i), (string) $password, true);
for ($j = 1; $j < $count; $j++)
{
$xorsum ^= ($last = hash_hmac((string) $algo, $last, (string)
$password, true));
}
$output .= $xorsum;
}
if (!$raw_output)
{
$output = bin2hex($output);
}
return $length ? substr($output, 0, $length) : $output;
}
}
src/Encrypt/index.html000064400000000054151161525250010756
0ustar00<html><body
bgcolor="#FFFFFF"></body></html>src/Encrypt/Randval.php000064400000005230151161525250011062
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt;
use VDM\Joomla\FOF\Encrypt\Randvalinterface;
/**
* Generates cryptographically-secure random values.
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
class Randval implements Randvalinterface
{
/**
* Returns a cryptographically secure random value.
*
* Since we only run on PHP 7+ we can use random_bytes(), which internally
uses a crypto safe PRNG. If the function
* doesn't exist, Joomla already loads a secure polyfill.
*
* The reason this method exists is backwards compatibility with older
versions of FOF. It also allows us to quickly
* address any future issues if Joomla drops the polyfill or otherwise
find problems with PHP's random_bytes() on
* some weird host (you can't be too careful when releasing
mass-distributed software).
*
* @param integer $bytes How many bytes to return
*
* @return string
*/
public function generate($bytes = 32)
{
return random_bytes($bytes);
}
/**
* Generate random bytes. Adapted from Joomla! 3.2.
*
* Since we only run on PHP 7+ we can use random_bytes(), which internally
uses a crypto safe PRNG. If the function
* doesn't exist, Joomla already loads a secure polyfill.
*
* The reason this method exists is backwards compatibility with older
versions of FOF. It also allows us to quickly
* address any future issues if Joomla drops the polyfill or otherwise
find problems with PHP's random_bytes() on
* some weird host (you can't be too careful when releasing
mass-distributed software).
*
* @param integer $length Length of the random data to generate
*
* @return string Random binary data
*/
public function genRandomBytes($length = 32)
{
return random_bytes($length);
}
}
src/Encrypt/Randvalinterface.php000064400000002275151161525250012751
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Encryption
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
* - Do not use this in new projects.
* - Expect no updates.
* - This is outdated.
* - Not best choice for encryption.
* - Use phpseclib/phpseclib version 3 Instead.
* - Checkout the JCB Crypt Suite.
<https://git.vdm.dev/joomla/phpseclib>
*/
namespace VDM\Joomla\FOF\Encrypt;
/**
* Randvalinterface
*
* @package FrameworkOnFramework
* @since 1.0
* @deprecated Use phpseclib/phpseclib version 3 Instead.
*/
interface Randvalinterface
{
/**
*
* Returns a cryptographically secure random value.
*
* @return string
*
*/
public function generate();
}
src/Utils/index.html000064400000000054151161525250010432
0ustar00<html><body
bgcolor="#FFFFFF"></body></html>src/Utils/Phpfunc.php000064400000002365151161525250010560
0ustar00<?php
/**
* @package FrameworkOnFramework
* @subpackage Utilities
* @copyright Copyright (C) 2010-2016 Nicholas K. Dionysopoulos /
Akeeba Ltd. All rights reserved.
* @license GNU General Public License version 2 or later; see
LICENSE.txt
* @note This file has been modified by the Joomla! Project (and VDM)
and no longer reflects the original work of its author.
* @depreciation This was ported for the sake of those who have stuff
encrypted with the FOF encryption suite.
*/
namespace VDM\Joomla\FOF\Utils;
/**
* Intercept calls to PHP functions.
*
* @method function_exists(string $function)
* @method mcrypt_list_algorithms()
* @method hash_algos()
* @method extension_loaded(string $ext)
* @method mcrypt_create_iv(int $bytes, int $source)
* @method openssl_get_cipher_methods()
*
* @package FrameworkOnFramework
* @since 1.0
*/
class Phpfunc
{
/**
*
* Magic call to intercept any function pass to it.
*
* @param string $func The function to call.
*
* @param array $args Arguments passed to the function.
*
* @return mixed The result of the function call.
*
*/
public function __call($func, $args)
{
return call_user_func_array($func, $args);
}
}