mirror of
https://github.com/danog/tgseclib.git
synced 2024-12-05 13:39:22 +01:00
Merge branch 'master' of https://github.com/phpseclib/phpseclib
This commit is contained in:
commit
200c2a9a88
@ -36,7 +36,7 @@ AES, Blowfish, Twofish, SSH-1, SSH-2, SFTP, and X.509
|
||||
* Composer compatible (PSR-0 autoloading)
|
||||
* Install using Composer: `composer require phpseclib/phpseclib ~1.0`
|
||||
* Install using PEAR: See [phpseclib PEAR Channel Documentation](http://phpseclib.sourceforge.net/pear.htm)
|
||||
* [Download 1.0.5 as ZIP](http://sourceforge.net/projects/phpseclib/files/phpseclib1.0.5.zip/download)
|
||||
* [Download 1.0.6 as ZIP](http://sourceforge.net/projects/phpseclib/files/phpseclib1.0.6.zip/download)
|
||||
|
||||
## Support
|
||||
|
||||
|
@ -15,6 +15,8 @@
|
||||
|
||||
namespace phpseclib\Common\Functions;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
||||
/**
|
||||
* Common String Functions
|
||||
*
|
||||
@ -56,4 +58,171 @@ abstract class Strings
|
||||
$string = substr($string, 0, -$index);
|
||||
return $substr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs blinded equality testing on strings
|
||||
*
|
||||
* Protects against a particular type of timing attack described.
|
||||
*
|
||||
* See {@link http://codahale.com/a-lesson-in-timing-attacks/ A Lesson In Timing Attacks (or, Don't use MessageDigest.isEquals)}
|
||||
*
|
||||
* Thanks for the heads up singpolyma!
|
||||
*
|
||||
* @access public
|
||||
* @param string $x
|
||||
* @param string $y
|
||||
* @return bool
|
||||
*/
|
||||
public static function equals($x, $y)
|
||||
{
|
||||
if (strlen($x) != strlen($y)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$result = 0;
|
||||
for ($i = 0; $i < strlen($x); $i++) {
|
||||
$result |= ord($x[$i]) ^ ord($y[$i]);
|
||||
}
|
||||
|
||||
return $result == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse SSH2-style string
|
||||
*
|
||||
* Returns either an array or a boolean if $data is malformed.
|
||||
*
|
||||
* Valid characters for $format are as follows:
|
||||
*
|
||||
* C = byte
|
||||
* b = boolean (true/false)
|
||||
* N = uint32
|
||||
* s = string
|
||||
* i = mpint
|
||||
* l = name-list
|
||||
*
|
||||
* uint64 is not supported.
|
||||
*
|
||||
* @param string $string
|
||||
* @param int $index
|
||||
* @access public
|
||||
* @return mixed
|
||||
*/
|
||||
public static function unpackSSH2($format, $data)
|
||||
{
|
||||
$result = [];
|
||||
for ($i = 0; $i < strlen($format); $i++) {
|
||||
switch ($format[$i]) {
|
||||
case 'C':
|
||||
case 'b':
|
||||
if (!strlen($data)) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case 'N':
|
||||
case 'i':
|
||||
case 's':
|
||||
case 'l':
|
||||
if (strlen($data) < 4) {
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
throw new \InvalidArgumentException('$format contains an invalid character');
|
||||
}
|
||||
switch ($format[$i]) {
|
||||
case 'C':
|
||||
$result[] = ord(self::shift($data));
|
||||
continue 2;
|
||||
case 'b':
|
||||
$result[] = ord(self::shift($data)) != 0;
|
||||
continue 2;
|
||||
case 'N':
|
||||
list(, $temp) = unpack('N', self::shift($data, 4));
|
||||
$result[] = $temp;
|
||||
continue 2;
|
||||
}
|
||||
list(, $length) = unpack('N', self::shift($data, 4));
|
||||
if (strlen($data) < $length) {
|
||||
return false;
|
||||
}
|
||||
$temp = self::shift($data, $length);
|
||||
switch ($format[$i]) {
|
||||
case 'i':
|
||||
$result[] = new BigInteger($temp, -256);
|
||||
break;
|
||||
case 's':
|
||||
$result[] = $temp;
|
||||
break;
|
||||
case 'l':
|
||||
$result[] = explode(',', $temp);
|
||||
}
|
||||
}
|
||||
|
||||
return $result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create SSH2-style string
|
||||
*
|
||||
* @param mixed $input..
|
||||
* @access public
|
||||
* @return mixed
|
||||
*/
|
||||
public static function packSSH2()
|
||||
{
|
||||
$elements = func_get_args();
|
||||
$format = $elements[0];
|
||||
array_shift($elements);
|
||||
if (strlen($format) != count($elements)) {
|
||||
throw new \InvalidArgumentException('There must be as many arguments as there are characters in the $format string');
|
||||
}
|
||||
$result = '';
|
||||
for ($i = 0; $i < strlen($format); $i++) {
|
||||
$element = $elements[$i];
|
||||
switch ($format[$i]) {
|
||||
case 'C':
|
||||
if (!is_int($element)) {
|
||||
throw new \InvalidArgumentException('Bytes must be represented as an integer between 0 and 255, inclusive.');
|
||||
}
|
||||
$result.= pack('C', $element);
|
||||
break;
|
||||
case 'b':
|
||||
if (!is_bool($element)) {
|
||||
throw new \InvalidArgumentException('A boolean parameter was expected.');
|
||||
}
|
||||
$result.= $element ? "\1" : "\0";
|
||||
break;
|
||||
case 'N':
|
||||
if (!is_int($element)) {
|
||||
throw new \InvalidArgumentException('An integer was expected.');
|
||||
}
|
||||
$result.= pack('N', $element);
|
||||
break;
|
||||
case 's':
|
||||
if (!is_string($element)) {
|
||||
throw new \InvalidArgumentException('A string was expected.');
|
||||
}
|
||||
$result.= pack('Na*', strlen($element), $element);
|
||||
break;
|
||||
case 'i':
|
||||
if (!$element instanceof BigInteger) {
|
||||
throw new \InvalidArgumentException('A phpseclib\Math\BigInteger object was expected.');
|
||||
}
|
||||
$element = $element->toBytes(true);
|
||||
$result.= pack('Na*', strlen($element), $element);
|
||||
break;
|
||||
case 'l':
|
||||
if (!is_array($element)) {
|
||||
throw new \InvalidArgumentException('An array was expected.');
|
||||
}
|
||||
$element = implode(',', $element);
|
||||
$result.= pack('Na*', strlen($element), $element);
|
||||
break;
|
||||
default:
|
||||
throw new \InvalidArgumentException('$format contains an invalid character');
|
||||
}
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
|
660
phpseclib/Crypt/Common/AsymmetricKey.php
Normal file
660
phpseclib/Crypt/Common/AsymmetricKey.php
Normal file
@ -0,0 +1,660 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Base Class for all asymmetric key ciphers
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package AsymmetricKey
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Crypt\Hash;
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
|
||||
/**
|
||||
* Base Class for all stream cipher classes
|
||||
*
|
||||
* @package AsymmetricKey
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
*/
|
||||
abstract class AsymmetricKey
|
||||
{
|
||||
/**
|
||||
* Precomputed Zero
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
protected static $zero;
|
||||
|
||||
/**
|
||||
* Precomputed One
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
protected static $one;
|
||||
|
||||
/**
|
||||
* Engine
|
||||
*
|
||||
* This is only used for key generation. Valid values are RSA::ENGINE_INTERNAL and RSA::ENGINE_OPENSSL
|
||||
*
|
||||
* @var int
|
||||
* @access private
|
||||
*/
|
||||
protected static $engine = NULL;
|
||||
|
||||
/**
|
||||
* OpenSSL configuration file name.
|
||||
*
|
||||
* Set to null to use system configuration file.
|
||||
*
|
||||
* @see self::createKey()
|
||||
* @var mixed
|
||||
* @access public
|
||||
*/
|
||||
protected static $configFile;
|
||||
|
||||
/**
|
||||
* Supported plugins (lower case)
|
||||
*
|
||||
* @see self::initialize_static_variables()
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
private static $plugins = [];
|
||||
|
||||
/**
|
||||
* Supported plugins (original case)
|
||||
*
|
||||
* @see self::initialize_static_variables()
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
private static $origPlugins = [];
|
||||
|
||||
/**
|
||||
* Supported signature formats (lower case)
|
||||
*
|
||||
* @see self::initialize_static_variables()
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
private static $signatureFormats = [];
|
||||
|
||||
/**
|
||||
* Supported signature formats (original case)
|
||||
*
|
||||
* @see self::initialize_static_variables()
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
private static $signatureFileFormats = [];
|
||||
|
||||
/**
|
||||
* Password
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
protected $password = false;
|
||||
|
||||
/**
|
||||
* Loaded File Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
protected $format = false;
|
||||
|
||||
/**
|
||||
* Private Key Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
protected $privateKeyFormat = 'PKCS8';
|
||||
|
||||
/**
|
||||
* Public Key Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
protected $publicKeyFormat = 'PKCS8';
|
||||
|
||||
/**
|
||||
* Hash function
|
||||
*
|
||||
* @var \phpseclib\Crypt\Hash
|
||||
* @access private
|
||||
*/
|
||||
protected $hash;
|
||||
|
||||
/**
|
||||
* HMAC function
|
||||
*
|
||||
* @var \phpseclib\Crypt\Hash
|
||||
* @access private
|
||||
*/
|
||||
private $hmac;
|
||||
|
||||
/**#@+
|
||||
* @access private
|
||||
* @see self::__construct()
|
||||
*/
|
||||
/**
|
||||
* To use the pure-PHP implementation
|
||||
*/
|
||||
const ENGINE_INTERNAL = 1;
|
||||
/**
|
||||
* To use the OpenSSL library
|
||||
*
|
||||
* (if enabled; otherwise, the internal implementation will be used)
|
||||
*/
|
||||
const ENGINE_OPENSSL = 2;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* The constructor
|
||||
*
|
||||
* @access public
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
$this->hash = new Hash('sha256');
|
||||
$this->hmac = new Hash('sha256');
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests engine validity
|
||||
*
|
||||
* @access public
|
||||
* @param int $val
|
||||
*/
|
||||
public static function isValidEngine($val)
|
||||
{
|
||||
switch ($val) {
|
||||
case self::ENGINE_OPENSSL:
|
||||
return extension_loaded('openssl') && file_exists(self::$configFile);
|
||||
case self::ENGINE_INTERNAL:
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the engine
|
||||
*
|
||||
* Only used in RSA::createKey. Valid values are RSA::ENGINE_OPENSSL and RSA::ENGINE_INTERNAL
|
||||
*
|
||||
* @access public
|
||||
* @param int $val
|
||||
*/
|
||||
public static function setPreferredEngine($val)
|
||||
{
|
||||
static::$engine = null;
|
||||
$candidateEngines = [
|
||||
$val,
|
||||
self::ENGINE_OPENSSL
|
||||
];
|
||||
foreach ($candidateEngines as $engine) {
|
||||
if (static::isValidEngine($engine)) {
|
||||
static::$engine = $engine;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!isset(static::$engine)) {
|
||||
static::$engine = self::ENGINE_INTERNAL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the engine
|
||||
*
|
||||
* @access public
|
||||
* @return int
|
||||
*/
|
||||
public static function getEngine()
|
||||
{
|
||||
return self::$engine;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize static variables
|
||||
*
|
||||
* @access private
|
||||
*/
|
||||
protected static function initialize_static_variables()
|
||||
{
|
||||
if (!isset(self::$zero)) {
|
||||
self::$zero= new BigInteger(0);
|
||||
self::$one = new BigInteger(1);
|
||||
self::$configFile = __DIR__ . '/../openssl.cnf';
|
||||
}
|
||||
|
||||
self::loadPlugins('Keys');
|
||||
if (static::ALGORITHM != 'RSA') {
|
||||
self::loadPlugins('Signature');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Load Plugins
|
||||
*
|
||||
* @params $format
|
||||
* @access private
|
||||
*/
|
||||
private static function loadPlugins($format)
|
||||
{
|
||||
if (!isset(self::$plugins[static::ALGORITHM][$format])) {
|
||||
self::$plugins[static::ALGORITHM][$format] = [];
|
||||
foreach (glob(__DIR__ . '/../' . static::ALGORITHM . '/' . $format . '/*.php') as $file) {
|
||||
$name = pathinfo($file, PATHINFO_FILENAME);
|
||||
$type = 'phpseclib\Crypt\\' . static::ALGORITHM . '\\' . $format . '\\' . $name;
|
||||
self::$plugins[static::ALGORITHM][$format][strtolower($name)] = $type;
|
||||
self::$origPlugins[static::ALGORITHM][$format][] = $name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate Plugin
|
||||
*
|
||||
* @access private
|
||||
* @param string $format
|
||||
* @param string $type
|
||||
* @param string $method optional
|
||||
* @return mixed
|
||||
*/
|
||||
protected static function validatePlugin($format, $type, $method = NULL)
|
||||
{
|
||||
$type = strtolower($type);
|
||||
if (!isset(self::$plugins[static::ALGORITHM][$format][$type])) {
|
||||
return false;
|
||||
}
|
||||
$type = self::$plugins[static::ALGORITHM][$format][$type];
|
||||
if (isset($method) && !method_exists($type, $method)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return $type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the key
|
||||
*
|
||||
* @access private
|
||||
* @param string $key
|
||||
* @param string $type
|
||||
* @return array
|
||||
*/
|
||||
protected function load($key, $type)
|
||||
{
|
||||
$components = false;
|
||||
if ($type === false) {
|
||||
foreach (self::$plugins[static::ALGORITHM]['Keys'] as $format) {
|
||||
try {
|
||||
$components = $format::load($key, $this->password);
|
||||
} catch (\Exception $e) {
|
||||
$components = false;
|
||||
}
|
||||
if ($components !== false) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$format = strtolower($type);
|
||||
if (isset(self::$plugins[static::ALGORITHM]['Keys'][$format])) {
|
||||
$format = self::$plugins[static::ALGORITHM]['Keys'][$format];
|
||||
$components = $format::load($key, $this->password);
|
||||
}
|
||||
}
|
||||
|
||||
if ($components === false) {
|
||||
$this->format = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
$this->format = $format;
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load the public key
|
||||
*
|
||||
* @access private
|
||||
* @param string $key
|
||||
* @param string $type
|
||||
* @return array
|
||||
*/
|
||||
protected function setPublicKey($key, $type)
|
||||
{
|
||||
$components = false;
|
||||
if ($type === false) {
|
||||
foreach (self::$plugins[static::ALGORITHM]['Keys'] as $format) {
|
||||
if (!method_exists($format, 'savePublicKey')) {
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
$components = $format::load($key, $this->password);
|
||||
} catch (\Exception $e) {
|
||||
$components = false;
|
||||
}
|
||||
if ($components !== false) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$format = strtolower($type);
|
||||
if (isset(self::$plugins[static::ALGORITHM]['Keys'][$format])) {
|
||||
$format = self::$plugins[static::ALGORITHM]['Keys'][$format];
|
||||
$components = $format::load($key, $this->password);
|
||||
}
|
||||
}
|
||||
|
||||
if ($components === false) {
|
||||
$this->format = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
$this->format = $format;
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a list of supported formats.
|
||||
*
|
||||
* @access public
|
||||
* @return array
|
||||
*/
|
||||
public static function getSupportedKeyFormats()
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
return self::$plugins[static::ALGORITHM]['Keys'];
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a fileformat plugin
|
||||
*
|
||||
* The plugin needs to either already be loaded or be auto-loadable.
|
||||
* Loading a plugin whose shortname overwrite an existing shortname will overwrite the old plugin.
|
||||
*
|
||||
* @see self::load()
|
||||
* @param string $fullname
|
||||
* @access public
|
||||
* @return bool
|
||||
*/
|
||||
public static function addFileFormat($fullname)
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
if (class_exists($fullname)) {
|
||||
$meta = new \ReflectionClass($path);
|
||||
$shortname = $meta->getShortName();
|
||||
self::$plugins[static::ALGORITHM]['Keys'][strtolower($shortname)] = $fullname;
|
||||
self::$origPlugins[static::ALGORITHM]['Keys'][] = $shortname;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the public key's fingerprint
|
||||
*
|
||||
* The public key's fingerprint is returned, which is equivalent to running `ssh-keygen -lf rsa.pub`. If there is
|
||||
* no public key currently loaded, false is returned.
|
||||
* Example output (md5): "c1:b1:30:29:d7:b8:de:6c:97:77:10:d7:46:41:63:87" (as specified by RFC 4716)
|
||||
*
|
||||
* @access public
|
||||
* @param string $algorithm The hashing algorithm to be used. Valid options are 'md5' and 'sha256'. False is returned
|
||||
* for invalid values.
|
||||
* @return mixed
|
||||
*/
|
||||
public function getPublicKeyFingerprint($algorithm = 'md5')
|
||||
{
|
||||
$type = self::validatePlugin('Keys', 'OpenSSH', 'getBinaryOutput');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$status = $type::getBinaryOutput();
|
||||
$type::setBinaryOutput(true);
|
||||
|
||||
$key = $this->getPublicKey('OpenSSH');
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$type::setBinaryOutput($status);
|
||||
|
||||
switch ($algorithm) {
|
||||
case 'sha256':
|
||||
$hash = new Hash('sha256');
|
||||
$base = Base64::encode($hash->hash($key));
|
||||
return substr($base, 0, strlen($base) - 1);
|
||||
case 'md5':
|
||||
return substr(chunk_split(md5($key), 2, ':'), 0, -1);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* __toString() magic method
|
||||
*
|
||||
* @access public
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
try {
|
||||
$key = $this->getPrivateKey($this->privateKeyFormat);
|
||||
if (is_string($key)) {
|
||||
return $key;
|
||||
}
|
||||
$key = $this->getPublicKey($this->publicKeyFormat);
|
||||
return is_string($key) ? $key : '';
|
||||
} catch (\Exception $e) {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* __clone() magic method
|
||||
*
|
||||
* @access public
|
||||
* @return static
|
||||
*/
|
||||
public function __clone()
|
||||
{
|
||||
$key = new static();
|
||||
$key->load($this);
|
||||
return $key;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines the private key format
|
||||
*
|
||||
* @see self::__toString()
|
||||
* @access public
|
||||
* @param string $format
|
||||
*/
|
||||
public function setPrivateKeyFormat($format)
|
||||
{
|
||||
$this->privateKeyFormat = $format;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines the public key format
|
||||
*
|
||||
* @see self::__toString()
|
||||
* @access public
|
||||
* @param string $format
|
||||
*/
|
||||
public function setPublicKeyFormat($format)
|
||||
{
|
||||
$this->publicKeyFormat = $format;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the format of the loaded key.
|
||||
*
|
||||
* If the key that was loaded wasn't in a valid or if the key was auto-generated
|
||||
* with RSA::createKey() then this will return false.
|
||||
*
|
||||
* @see self::load()
|
||||
* @access public
|
||||
* @return mixed
|
||||
*/
|
||||
public function getLoadedFormat()
|
||||
{
|
||||
if ($this->format === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$meta = new \ReflectionClass($this->format);
|
||||
return $meta->getShortName();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the password
|
||||
*
|
||||
* Private keys can be encrypted with a password. To unset the password, pass in the empty string or false.
|
||||
* Or rather, pass in $password such that empty($password) && !is_string($password) is true.
|
||||
*
|
||||
* @see self::createKey()
|
||||
* @see self::load()
|
||||
* @access public
|
||||
* @param string $password
|
||||
*/
|
||||
public function setPassword($password = false)
|
||||
{
|
||||
$this->password = $password;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines which hashing function should be used
|
||||
*
|
||||
* @access public
|
||||
* @param string $hash
|
||||
*/
|
||||
public function setHash($hash)
|
||||
{
|
||||
$this->hash = new Hash($hash);
|
||||
$this->hmac = new Hash($hash);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute the pseudorandom k for signature generation,
|
||||
* using the process specified for deterministic DSA.
|
||||
*
|
||||
* @access public
|
||||
* @param string $h1
|
||||
* @return string
|
||||
*/
|
||||
protected function computek($h1)
|
||||
{
|
||||
$v = str_repeat("\1", strlen($h1));
|
||||
|
||||
$k = str_repeat("\0", strlen($h1));
|
||||
|
||||
$x = $this->int2octets($this->x);
|
||||
$h1 = $this->bits2octets($h1);
|
||||
|
||||
$this->hmac->setKey($k);
|
||||
$k = $this->hmac->hash($v . "\0" . $x . $h1);
|
||||
$this->hmac->setKey($k);
|
||||
$v = $this->hmac->hash($v);
|
||||
$k = $this->hmac->hash($v . "\1" . $x . $h1);
|
||||
$this->hmac->setKey($k);
|
||||
$v = $this->hmac->hash($v);
|
||||
|
||||
$qlen = $this->q->getLengthInBytes();
|
||||
|
||||
while (true) {
|
||||
$t = '';
|
||||
while (strlen($t) < $qlen) {
|
||||
$v = $this->hmac->hash($v);
|
||||
$t = $t . $v;
|
||||
}
|
||||
$k = $this->bits2int($t);
|
||||
|
||||
if (!$k->equals(self::$zero) && $k->compare($this->q) < 0) {
|
||||
break;
|
||||
}
|
||||
$k = $this->hmac->hash($v . "\0");
|
||||
$this->hmac->setKey($k);
|
||||
$v = $this->hmac->hash($v);
|
||||
}
|
||||
|
||||
return $k;
|
||||
}
|
||||
|
||||
/**
|
||||
* Integer to Octet String
|
||||
*
|
||||
* @access private
|
||||
* @param \phpseclib\Math\BigInteger $v
|
||||
* @return string
|
||||
*/
|
||||
private function int2octets($v)
|
||||
{
|
||||
$out = $v->toBytes();
|
||||
$rolen = $this->q->getLengthInBytes();
|
||||
if (strlen($out) < $rolen) {
|
||||
return str_pad($out, $rolen, "\0", STR_PAD_LEFT);
|
||||
} else if (strlen($out) > $rolen) {
|
||||
return substr($out, -$rolen);
|
||||
} else {
|
||||
return $out;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Bit String to Integer
|
||||
*
|
||||
* @access private
|
||||
* @param string $in
|
||||
* @return \phpseclib\Math\BigInteger
|
||||
*/
|
||||
protected function bits2int($in)
|
||||
{
|
||||
$v = new BigInteger($in, 256);
|
||||
$vlen = strlen($in) << 3;
|
||||
$qlen = $this->q->getLength();
|
||||
if ($vlen > $qlen) {
|
||||
return $v->bitwise_rightShift($vlen - $qlen);
|
||||
}
|
||||
return $v;
|
||||
}
|
||||
|
||||
/**
|
||||
* Bit String to Octet String
|
||||
*
|
||||
* @access private
|
||||
* @param string $in
|
||||
* @return string
|
||||
*/
|
||||
private function bits2octets($in)
|
||||
{
|
||||
$z1 = $this->bits2int($in);
|
||||
$z2 = $z1->subtract($this->q);
|
||||
return $z2->compare(self::$zero) < 0 ?
|
||||
$this->int2octets($z1) :
|
||||
$this->int2octets($z2);
|
||||
}
|
||||
}
|
139
phpseclib/Crypt/Common/Keys/OpenSSH.php
Normal file
139
phpseclib/Crypt/Common/Keys/OpenSSH.php
Normal file
@ -0,0 +1,139 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSH Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Place in $HOME/.ssh/authorized_keys
|
||||
*
|
||||
* @category Crypt
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted RSA Key Handler
|
||||
*
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSH
|
||||
{
|
||||
/**
|
||||
* Default comment
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
protected static $comment = 'phpseclib-generated-key';
|
||||
|
||||
/**
|
||||
* Binary key flag
|
||||
*
|
||||
* @var bool
|
||||
* @access private
|
||||
*/
|
||||
protected static $binary = false;
|
||||
|
||||
/**
|
||||
* Sets the default comment
|
||||
*
|
||||
* @access public
|
||||
* @param string $comment
|
||||
*/
|
||||
public static function setComment($comment)
|
||||
{
|
||||
self::$comment = str_replace(["\r", "\n"], '', $comment);
|
||||
}
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* $type can be either ssh-dss or ssh-rsa
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $type
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $type)
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$parts = explode(' ', $key, 3);
|
||||
|
||||
if (!isset($parts[1])) {
|
||||
$key = Base64::decode($parts[0]);
|
||||
$comment = isset($parts[1]) ? $parts[1] : false;
|
||||
} else {
|
||||
if ($parts[0] != $type) {
|
||||
return false;
|
||||
}
|
||||
$key = Base64::decode($parts[1]);
|
||||
$comment = isset($parts[2]) ? $parts[2] : false;
|
||||
}
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (substr($key, 0, 11) != "\0\0\0\7$type") {
|
||||
return false;
|
||||
}
|
||||
Strings::shift($key, 11);
|
||||
if (strlen($key) <= 4) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return $key;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the comment for the key
|
||||
*
|
||||
* @access public
|
||||
* @return mixed
|
||||
*/
|
||||
public static function getComment($key)
|
||||
{
|
||||
$parts = explode(' ', $key, 3);
|
||||
|
||||
return isset($parts[2]) ? $parts[2] : false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Toggle between binary and printable keys
|
||||
*
|
||||
* Printable keys are what are generated by default. These are the ones that go in
|
||||
* $HOME/.ssh/authorized_key.
|
||||
*
|
||||
* @access public
|
||||
* @param bool $enabled
|
||||
*/
|
||||
public static function setBinaryOutput($enabled)
|
||||
{
|
||||
self::$binary = $enabled;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current binary output value
|
||||
*
|
||||
* @access public
|
||||
* @return bool
|
||||
*/
|
||||
public static function getBinaryOutput()
|
||||
{
|
||||
return (bool) self::$binary;
|
||||
}
|
||||
}
|
@ -13,7 +13,7 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common;
|
||||
namespace phpseclib\Crypt\Common\Keys;
|
||||
|
||||
/**
|
||||
* PKCS1 Formatted Key Handler
|
@ -13,7 +13,7 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common;
|
||||
namespace phpseclib\Crypt\Common\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
@ -106,7 +106,7 @@ abstract class PKCS1 extends PKCS
|
||||
/**
|
||||
* Generate a symmetric key for PKCS#1 keys
|
||||
*
|
||||
* @access public
|
||||
* @access private
|
||||
* @param string $password
|
||||
* @param string $iv
|
||||
* @param int $length
|
@ -25,7 +25,7 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common;
|
||||
namespace phpseclib\Crypt\Common\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Crypt\DES;
|
||||
@ -264,6 +264,10 @@ abstract class PKCS8 extends PKCS
|
||||
*/
|
||||
private static function initialize_static_variables()
|
||||
{
|
||||
if (!static::$childOIDsLoaded) {
|
||||
ASN1::loadOIDs([static::OID_VALUE => static::OID_NAME]);
|
||||
static::$childOIDsLoaded = true;
|
||||
}
|
||||
if (!self::$oidsLoaded) {
|
||||
// from https://tools.ietf.org/html/rfc2898
|
||||
ASN1::loadOIDs([
|
||||
@ -307,6 +311,7 @@ abstract class PKCS8 extends PKCS
|
||||
'2.16.840.1.101.3.4.1.22'=> 'aes192-CBC-PAD',
|
||||
'2.16.840.1.101.3.4.1.42'=> 'aes256-CBC-PAD'
|
||||
]);
|
||||
self::$oidsLoaded = true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -453,7 +458,9 @@ abstract class PKCS8 extends PKCS
|
||||
|
||||
$private = ASN1::asn1map($decoded[0], Maps\PrivateKeyInfo::MAP);
|
||||
if (is_array($private)) {
|
||||
return $private + $meta;
|
||||
return $private['privateKeyAlgorithm']['algorithm'] == static::OID_NAME ?
|
||||
$private + $meta :
|
||||
false;
|
||||
}
|
||||
|
||||
// EncryptedPrivateKeyInfo and PublicKeyInfo have largely identical "signatures". the only difference
|
||||
@ -462,7 +469,7 @@ abstract class PKCS8 extends PKCS
|
||||
// bit strings wanting a non-zero amount of bits trimmed are not supported
|
||||
$public = ASN1::asn1map($decoded[0], Maps\PublicKeyInfo::MAP);
|
||||
if (is_array($public)) {
|
||||
if ($public['publicKey'][0] != "\0") {
|
||||
if ($public['publicKey'][0] != "\0" || $public['publicKeyAlgorithm']['algorithm'] != static::OID_NAME) {
|
||||
return false;
|
||||
}
|
||||
$public['publicKey'] = substr($public['publicKey'], 1);
|
||||
@ -476,19 +483,22 @@ abstract class PKCS8 extends PKCS
|
||||
* Wrap a private key appropriately
|
||||
*
|
||||
* @access public
|
||||
* @param string $algorithm
|
||||
* @param string $key
|
||||
* @param string $attr
|
||||
* @param mixed $params
|
||||
* @param string $password
|
||||
* @return string
|
||||
*/
|
||||
protected static function wrapPrivateKey($key, $algorithm, $attr, $password)
|
||||
protected static function wrapPrivateKey($key, $attr, $params, $password)
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
$key = [
|
||||
'version' => 'v1',
|
||||
'privateKeyAlgorithm' => ['algorithm' => $algorithm], // parameters are not currently supported
|
||||
'privateKeyAlgorithm' => [
|
||||
'algorithm' => static::OID_NAME,
|
||||
'parameters' => $params
|
||||
],
|
||||
'privateKey' => $key
|
||||
];
|
||||
if (!empty($attr)) {
|
||||
@ -575,16 +585,17 @@ abstract class PKCS8 extends PKCS
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param mixed $params
|
||||
* @return string
|
||||
*/
|
||||
protected static function wrapPublicKey($key, $algorithm)
|
||||
protected static function wrapPublicKey($key, $params)
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
$key = [
|
||||
'publicKeyAlgorithm' => [
|
||||
'algorithm' => $algorithm,
|
||||
'parameters' => null // parameters are not currently supported
|
||||
'algorithm' => static::OID_NAME,
|
||||
'parameters' => $params
|
||||
],
|
||||
'publicKey' => "\0" . $key
|
||||
];
|
230
phpseclib/Crypt/Common/Keys/PuTTY.php
Normal file
230
phpseclib/Crypt/Common/Keys/PuTTY.php
Normal file
@ -0,0 +1,230 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PuTTY Formatted Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
use phpseclib\Crypt\AES;
|
||||
use phpseclib\Crypt\Hash;
|
||||
use phpseclib\Crypt\Random;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* PuTTY Formatted Key Handler
|
||||
*
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PuTTY
|
||||
{
|
||||
/**
|
||||
* Default comment
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private static $comment = 'phpseclib-generated-key';
|
||||
|
||||
/**
|
||||
* Sets the default comment
|
||||
*
|
||||
* @access public
|
||||
* @param string $comment
|
||||
*/
|
||||
public static function setComment($comment)
|
||||
{
|
||||
self::$comment = str_replace(["\r", "\n"], '', $comment);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a symmetric key for PuTTY keys
|
||||
*
|
||||
* @access public
|
||||
* @param string $password
|
||||
* @param int $length
|
||||
* @return string
|
||||
*/
|
||||
private static function generateSymmetricKey($password, $length)
|
||||
{
|
||||
$symkey = '';
|
||||
$sequence = 0;
|
||||
while (strlen($symkey) < $length) {
|
||||
$temp = pack('Na*', $sequence++, $password);
|
||||
$symkey.= Hex::decode(sha1($temp));
|
||||
}
|
||||
return substr($symkey, 0, $length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $publicHandler
|
||||
* @param string $type
|
||||
* @param string $password
|
||||
* @return array
|
||||
*/
|
||||
protected static function load($key, $password)
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (strpos($key, 'BEGIN SSH2 PUBLIC KEY')) {
|
||||
$data = preg_split('#[\r\n]+#', $key);
|
||||
$data = array_splice($data, 2, -1);
|
||||
$data = implode('', $data);
|
||||
|
||||
$components = call_user_func([static::PUBLIC_HANDLER, 'load'], $data);
|
||||
if ($components === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!preg_match('#Comment: "(.+)"#', $key, $matches)) {
|
||||
return false;
|
||||
}
|
||||
$components['comment'] = str_replace(['\\\\', '\"'], ['\\', '"'], $matches[1]);
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
$components = [];
|
||||
|
||||
$key = preg_split('#\r\n|\r|\n#', trim($key));
|
||||
$type = trim(preg_replace('#PuTTY-User-Key-File-2: (.+)#', '$1', $key[0]));
|
||||
if ($type != static::TYPE) {
|
||||
return false;
|
||||
}
|
||||
$encryption = trim(preg_replace('#Encryption: (.+)#', '$1', $key[1]));
|
||||
$components['comment'] = trim(preg_replace('#Comment: (.+)#', '$1', $key[2]));
|
||||
|
||||
$publicLength = trim(preg_replace('#Public-Lines: (\d+)#', '$1', $key[3]));
|
||||
$public = Base64::decode(implode('', array_map('trim', array_slice($key, 4, $publicLength))));
|
||||
|
||||
$source = Strings::packSSH2('ssss', static::TYPE, $encryption, $components['comment'], $public);
|
||||
|
||||
extract(unpack('Nlength', Strings::shift($public, 4)));
|
||||
if (Strings::shift($public, $length) != static::TYPE) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$components['public'] = $public;
|
||||
|
||||
$privateLength = trim(preg_replace('#Private-Lines: (\d+)#', '$1', $key[$publicLength + 4]));
|
||||
$private = Base64::decode(implode('', array_map('trim', array_slice($key, $publicLength + 5, $privateLength))));
|
||||
|
||||
switch ($encryption) {
|
||||
case 'aes256-cbc':
|
||||
$symkey = self::generateSymmetricKey($password, 32);
|
||||
$crypto = new AES(AES::MODE_CBC);
|
||||
}
|
||||
|
||||
$hashkey = 'putty-private-key-file-mac-key';
|
||||
|
||||
if ($encryption != 'none') {
|
||||
$hashkey.= $password;
|
||||
$crypto->setKey($symkey);
|
||||
$crypto->setIV(str_repeat("\0", $crypto->getBlockLength() >> 3));
|
||||
$crypto->disablePadding();
|
||||
$private = $crypto->decrypt($private);
|
||||
}
|
||||
|
||||
$source.= Strings::packSSH2('s', $private);
|
||||
|
||||
$hash = new Hash('sha1');
|
||||
$hash->setKey(sha1($hashkey, true));
|
||||
$hmac = trim(preg_replace('#Private-MAC: (.+)#', '$1', $key[$publicLength + $privateLength + 5]));
|
||||
$hmac = Hex::decode($hmac);
|
||||
|
||||
if (!Strings::equals($hash->hash($source), $hmac)) {
|
||||
throw new \UnexpectedValueException('MAC validation error');
|
||||
}
|
||||
|
||||
$components['private'] = $private;
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap a private key appropriately
|
||||
*
|
||||
* @access private
|
||||
* @param string $public
|
||||
* @param string $private
|
||||
* @param string $password
|
||||
* @return string
|
||||
*/
|
||||
protected static function wrapPrivateKey($public, $private, $password)
|
||||
{
|
||||
$key = "PuTTY-User-Key-File-2: " . static::TYPE . "\r\nEncryption: ";
|
||||
$encryption = (!empty($password) || is_string($password)) ? 'aes256-cbc' : 'none';
|
||||
$key.= $encryption;
|
||||
$key.= "\r\nComment: " . self::$comment . "\r\n";
|
||||
|
||||
$public = Strings::packSSH2('s', static::TYPE) . $public;
|
||||
|
||||
$source = Strings::packSSH2('ssss', static::TYPE, $encryption, self::$comment, $public);
|
||||
|
||||
$public = Base64::encode($public);
|
||||
$key.= "Public-Lines: " . ((strlen($public) + 63) >> 6) . "\r\n";
|
||||
$key.= chunk_split($public, 64);
|
||||
|
||||
if (empty($password) && !is_string($password)) {
|
||||
$source.= Strings::packSSH2('s', $private);
|
||||
$hashkey = 'putty-private-key-file-mac-key';
|
||||
} else {
|
||||
$private.= Random::string(16 - (strlen($private) & 15));
|
||||
$source.= Strings::packSSH2('s', $private);
|
||||
$crypto = new AES(AES::MODE_CBC);
|
||||
|
||||
$crypto->setKey(self::generateSymmetricKey($password, 32));
|
||||
$crypto->setIV(str_repeat("\0", $crypto->getBlockLength() >> 3));
|
||||
$crypto->disablePadding();
|
||||
$private = $crypto->encrypt($private);
|
||||
$hashkey = 'putty-private-key-file-mac-key' . $password;
|
||||
}
|
||||
|
||||
$private = Base64::encode($private);
|
||||
$key.= 'Private-Lines: ' . ((strlen($private) + 63) >> 6) . "\r\n";
|
||||
$key.= chunk_split($private, 64);
|
||||
$hash = new Hash('sha1');
|
||||
$hash->setKey(sha1($hashkey, true));
|
||||
$key.= 'Private-MAC: ' . Hex::encode($hash->hash($source)) . "\r\n";
|
||||
|
||||
return $key;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrap a public key appropriately
|
||||
*
|
||||
* This is basically the format described in RFC 4716 (https://tools.ietf.org/html/rfc4716)
|
||||
*
|
||||
* @access private
|
||||
* @param string $key
|
||||
* @return string
|
||||
*/
|
||||
protected static function wrapPublicKey($key)
|
||||
{
|
||||
$key = pack('Na*a*', strlen(static::TYPE), static::TYPE, $key);
|
||||
$key = "---- BEGIN SSH2 PUBLIC KEY ----\r\n" .
|
||||
'Comment: "' . str_replace(['\\', '"'], ['\\\\', '\"'], self::$comment) . "\"\r\n" .
|
||||
chunk_split(Base64::encode($key), 64) .
|
||||
'---- END SSH2 PUBLIC KEY ----';
|
||||
return $key;
|
||||
}
|
||||
}
|
67
phpseclib/Crypt/Common/Signature/Raw.php
Normal file
67
phpseclib/Crypt/Common/Signature/Raw.php
Normal file
@ -0,0 +1,67 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Raw Signature Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Handles signatures as arrays
|
||||
*
|
||||
* @category Crypt
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\Common\Signature;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* Raw Signature Handler
|
||||
*
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Raw
|
||||
{
|
||||
/**
|
||||
* Loads a signature
|
||||
*
|
||||
* @access public
|
||||
* @param array $key
|
||||
* @return array
|
||||
*/
|
||||
public static function load($sig)
|
||||
{
|
||||
switch (true) {
|
||||
case !is_array($sig):
|
||||
case !isset($sig['r']) || !isset($sig['s']):
|
||||
case !$sig['r'] instanceof BigInteger:
|
||||
case !$sig['s'] instanceof BigInteger:
|
||||
return false;
|
||||
}
|
||||
|
||||
return [
|
||||
'r' => $key['r'],
|
||||
's' => $key['s']
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a signature in the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $r
|
||||
* @param \phpseclib\Math\BigInteger $s
|
||||
* @return string
|
||||
*/
|
||||
public static function save(BigInteger $r, BigInteger $s)
|
||||
{
|
||||
return compact('r', 's');
|
||||
}
|
||||
}
|
500
phpseclib/Crypt/DSA.php
Normal file
500
phpseclib/Crypt/DSA.php
Normal file
@ -0,0 +1,500 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Pure-PHP FIPS 186-4 compliant implementation of DSA.
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Here's an example of how to create signatures and verify signatures with this library:
|
||||
* <code>
|
||||
* <?php
|
||||
* include 'vendor/autoload.php';
|
||||
*
|
||||
* extract(\phpseclib\Crypt\DSA::createKey());
|
||||
*
|
||||
* $plaintext = 'terrafrost';
|
||||
*
|
||||
* $signature = $privatekey->sign($plaintext, 'ASN1');
|
||||
*
|
||||
* echo $publickey->verify($plaintext, $signature) ? 'verified' : 'unverified';
|
||||
* ?>
|
||||
* </code>
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\File\ASN1;
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Crypt\Common\AsymmetricKey;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* Pure-PHP FIPS 186-4 compliant implementation of DSA.
|
||||
*
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
class DSA extends AsymmetricKey
|
||||
{
|
||||
/**
|
||||
* Algorithm Name
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const ALGORITHM = 'DSA';
|
||||
|
||||
/**
|
||||
* DSA Prime P
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
private $p;
|
||||
|
||||
/**
|
||||
* DSA Group Order q
|
||||
*
|
||||
* Prime divisor of p-1
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
protected $q;
|
||||
|
||||
/**
|
||||
* DSA Group Generator G
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
private $g;
|
||||
|
||||
/**
|
||||
* DSA secret exponent x
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
protected $x;
|
||||
|
||||
/**
|
||||
* DSA public key value y
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
private $y;
|
||||
|
||||
/**
|
||||
* Parameters Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private $parametersFormat = 'PKCS1';
|
||||
|
||||
/**
|
||||
* Create DSA parameters
|
||||
*
|
||||
* @access public
|
||||
* @param int $L
|
||||
* @param int $N
|
||||
* @return \phpseclib\Crypt\DSA
|
||||
*/
|
||||
static function createParameters($L = 2048, $N = 224)
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
switch (true) {
|
||||
case $N == 160:
|
||||
/*
|
||||
in FIPS 186-1 and 186-2 N was fixed at 160 whereas K had an upper bound of 1024.
|
||||
RFC 4253 (SSH Transport Layer Protocol) references FIPS 186-2 and as such most
|
||||
SSH DSA implementations only support keys with an N of 160.
|
||||
puttygen let's you set the size of L (but not the size of N) and uses 2048 as the
|
||||
default L value. that's not really compliant with any of the FIPS standards, however,
|
||||
for the purposes of maintaining compatibility with puttygen, we'll support it
|
||||
*/
|
||||
//case ($L >= 512 || $L <= 1024) && (($L & 0x3F) == 0) && $N == 160:
|
||||
// FIPS 186-3 changed this as follows:
|
||||
//case $L == 1024 && $N == 160:
|
||||
case $L == 2048 && $N == 224:
|
||||
case $L == 2048 && $N == 256:
|
||||
case $L == 3072 && $N == 256:
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
$two = new BigInteger(2);
|
||||
|
||||
$q = BigInteger::randomPrime($N);
|
||||
$divisor = $q->multiply($two);
|
||||
|
||||
do {
|
||||
$x = BigInteger::random($L);
|
||||
list(, $c) = $x->divide($divisor);
|
||||
$p = $x->subtract($c->subtract(self::$one));
|
||||
} while ($p->getLength() != $L || !$p->isPrime());
|
||||
|
||||
$p_1 = $p->subtract(self::$one);
|
||||
list($e) = $p_1->divide($q);
|
||||
|
||||
// quoting http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf#page=50 ,
|
||||
// "h could be obtained from a random number generator or from a counter that
|
||||
// changes after each use". PuTTY (sshdssg.c) starts h off at 1 and increments
|
||||
// it on each loop. wikipedia says "commonly h = 2 is used" so we'll just do that
|
||||
$h = clone $two;
|
||||
while (true) {
|
||||
$g = $h->powMod($e, $p);
|
||||
if (!$g->equals(self::$one)) {
|
||||
break;
|
||||
}
|
||||
$h = $h->add(self::$one);
|
||||
}
|
||||
|
||||
$dsa = new DSA();
|
||||
$dsa->p = $p;
|
||||
$dsa->q = $q;
|
||||
$dsa->g = $g;
|
||||
|
||||
return $dsa;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create public / private key pair.
|
||||
*
|
||||
* This method is a bit polymorphic. It can take a DSA object (eg. pre-loaded with parameters),
|
||||
* L / N as two distinct parameters or no parameters (at which point L and N will be generated
|
||||
* with this method)
|
||||
*
|
||||
* Returns an array with the following two elements:
|
||||
* - 'privatekey': The private key.
|
||||
* - 'publickey': The public key.
|
||||
*
|
||||
* @access public
|
||||
* @return \phpseclib\Crypt\DSA
|
||||
*/
|
||||
static function createKey()
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
$args = func_get_args();
|
||||
if (count($args) == 2 && is_int($args[0]) && is_int($args[1])) {
|
||||
$private = self::createParameters($args[0], $args[1]);
|
||||
} else if (count($args) == 1 && $args[0] instanceof DSA) {
|
||||
$private = clone $args[0];
|
||||
} else if (!count($args)) {
|
||||
$private = self::createParameters();
|
||||
} else {
|
||||
throw new \InvalidArgumentException('Valid parameters are either two integers (L and N), a single DSA object or no parameters at all.');
|
||||
}
|
||||
|
||||
$private->x = BigInteger::randomRange(self::$one, $private->q->subtract(self::$one));
|
||||
$private->y = $private->g->powMod($private->x, $private->p);
|
||||
|
||||
$public = clone $private;
|
||||
unset($public->x);
|
||||
|
||||
return ['privatekey' => $private, 'publickey' => $public];
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a public or private key
|
||||
*
|
||||
* Returns true on success and false on failure (ie. an incorrect password was provided or the key was malformed)
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param int $type optional
|
||||
*/
|
||||
public function load($key, $type = false)
|
||||
{
|
||||
if ($key instanceof DSA) {
|
||||
$this->privateKeyFormat = $key->privateKeyFormat;
|
||||
$this->publicKeyFormat = $key->publicKeyFormat;
|
||||
$this->format = $key->format;
|
||||
$this->p = $key->p;
|
||||
$this->q = $key->q;
|
||||
$this->g = $key->g;
|
||||
$this->x = $key->x;
|
||||
$this->y = $key->y;
|
||||
$this->parametersFormat = $key->parametersFormat;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
$components = parent::load($key, $type);
|
||||
if ($components === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isset($components['p'])) {
|
||||
switch (true) {
|
||||
case isset($this->p) && !$this->p->equals($components['p']):
|
||||
case isset($this->q) && !$this->q->equals($components['q']):
|
||||
case isset($this->g) && !$this->g->equals($components['g']):
|
||||
$this->x = $this->y = null;
|
||||
}
|
||||
|
||||
$this->p = $components['p'];
|
||||
$this->q = $components['q'];
|
||||
$this->g = $components['g'];
|
||||
}
|
||||
|
||||
if (isset($components['x'])) {
|
||||
$this->x = $components['x'];
|
||||
}
|
||||
|
||||
if (isset($components['y'])) {
|
||||
$this->y = $components['y'];
|
||||
}
|
||||
//} else if (isset($components['x'])) {
|
||||
// $this->y = $this->g->powMod($this->x, $this->p);
|
||||
//}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the key size
|
||||
*
|
||||
* More specifically, this L (the length of DSA Prime P) and N (the length of DSA Group Order q)
|
||||
*
|
||||
* @access public
|
||||
* @return array
|
||||
*/
|
||||
public function getLength()
|
||||
{
|
||||
return isset($this->p) ?
|
||||
['L' => $this->p->getLength(), 'N' => $this->q->getLength()] :
|
||||
['L' => 0, 'N' => 0];
|
||||
}
|
||||
|
||||
/**
|
||||
* __toString() magic method
|
||||
*
|
||||
* @access public
|
||||
* @return string
|
||||
*/
|
||||
public function __toString()
|
||||
{
|
||||
$key = parent::__toString();
|
||||
if (!empty($key)) {
|
||||
return $key;
|
||||
}
|
||||
|
||||
try {
|
||||
$key = $this->getParameters($this->parametersFormat);
|
||||
return is_string($key) ? $key : '';
|
||||
} catch (\Exception $e) {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the private key
|
||||
*
|
||||
* PKCS1 DSA private keys contain x and y. PKCS8 DSA private keys just contain x
|
||||
* but y can be derived from x.
|
||||
*
|
||||
* @see self::getPublicKey()
|
||||
* @access public
|
||||
* @param string $type optional
|
||||
* @return mixed
|
||||
*/
|
||||
public function getPrivateKey($type = 'PKCS8')
|
||||
{
|
||||
$type = self::validatePlugin('Keys', $type, 'savePrivateKey');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isset($this->x)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isset($this->y)) {
|
||||
$this->y = $this->g->powMod($this->x, $this->p);
|
||||
}
|
||||
|
||||
return $type::savePrivateKey($this->p, $this->q, $this->g, $this->y, $this->x, $this->password);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the public key
|
||||
*
|
||||
* If you do "openssl rsa -in private.rsa -pubout -outform PEM" you get a PKCS8 formatted key
|
||||
* that contains a publicKeyAlgorithm AlgorithmIdentifier and a publicKey BIT STRING.
|
||||
* An AlgorithmIdentifier contains an OID and a parameters field. With RSA public keys this
|
||||
* parameters field is NULL. With DSA PKCS8 public keys it is not - it contains the p, q and g
|
||||
* variables. The publicKey BIT STRING contains, simply, the y variable. This can be verified
|
||||
* by getting a DSA PKCS8 public key:
|
||||
*
|
||||
* "openssl dsa -in private.dsa -pubout -outform PEM"
|
||||
*
|
||||
* ie. just swap out rsa with dsa in the rsa command above.
|
||||
*
|
||||
* A PKCS1 public key corresponds to the publicKey portion of the PKCS8 key. In the case of RSA
|
||||
* the publicKey portion /is/ the key. In the case of DSA it is not. You cannot verify a signature
|
||||
* without the parameters and the PKCS1 DSA public key format does not include the parameters.
|
||||
*
|
||||
* @see self::getPrivateKey()
|
||||
* @access public
|
||||
* @param string $type optional
|
||||
* @return mixed
|
||||
*/
|
||||
public function getPublicKey($type = 'PKCS8')
|
||||
{
|
||||
$type = self::validatePlugin('Keys', $type, 'savePublicKey');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isset($this->y)) {
|
||||
if (!isset($this->x) || !isset($this->p)) {
|
||||
return false;
|
||||
}
|
||||
$this->y = $this->g->powMod($this->x, $this->p);
|
||||
}
|
||||
|
||||
return $type::savePublicKey($this->p, $this->q, $this->g, $this->y);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the parameters
|
||||
*
|
||||
* A public / private key is only returned if the currently loaded "key" contains an x or y
|
||||
* value.
|
||||
*
|
||||
* @see self::getPublicKey()
|
||||
* @see self::getPrivateKey()
|
||||
* @access public
|
||||
* @param string $type optional
|
||||
* @return mixed
|
||||
*/
|
||||
public function getParameters($type = 'PKCS1')
|
||||
{
|
||||
$type = self::validatePlugin('Keys', $type, 'saveParameters');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isset($this->p) || !isset($this->q) || !isset($this->g)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return $type::saveParameters($this->p, $this->q, $this->g);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a signature
|
||||
*
|
||||
* @see self::verify()
|
||||
* @access public
|
||||
* @param string $message
|
||||
* @param string $format optional
|
||||
* @return mixed
|
||||
*/
|
||||
function sign($message, $format = 'Raw')
|
||||
{
|
||||
$format = self::validatePlugin('Signature', $format);
|
||||
if ($format === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (empty($this->x) || empty($this->p)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
$k = BigInteger::randomRange(self::$one, $this->q->subtract(self::$one));
|
||||
$r = $this->g->powMod($k, $this->p);
|
||||
list(, $r) = $r->divide($this->q);
|
||||
if ($r->equals(self::$zero)) {
|
||||
continue;
|
||||
}
|
||||
$kinv = $k->modInverse($this->q);
|
||||
$h = $this->hash->hash($message);
|
||||
$h = $this->bits2int($h);
|
||||
$temp = $h->add($this->x->multiply($r));
|
||||
$temp = $kinv->multiply($temp);
|
||||
list(, $s) = $temp->divide($this->q);
|
||||
if (!$s->equals(self::$zero)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// the following is an RFC6979 compliant implementation of deterministic DSA
|
||||
// it's unused because it's mainly intended for use when a good CSPRNG isn't
|
||||
// available. if phpseclib's CSPRNG isn't good then even key generation is
|
||||
// suspect
|
||||
/*
|
||||
$h1 = $this->hash->hash($message);
|
||||
$k = $this->computek($h1);
|
||||
$r = $this->g->powMod($k, $this->p);
|
||||
list(, $r) = $r->divide($this->q);
|
||||
$kinv = $k->modInverse($this->q);
|
||||
$h1 = $this->bits2int($h1);
|
||||
$temp = $h1->add($this->x->multiply($r));
|
||||
$temp = $kinv->multiply($temp);
|
||||
list(, $s) = $temp->divide($this->q);
|
||||
*/
|
||||
|
||||
return $format::save($r, $s);
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify a signature
|
||||
*
|
||||
* @see self::verify()
|
||||
* @access public
|
||||
* @param string $message
|
||||
* @param string $format optional
|
||||
* @return mixed
|
||||
*/
|
||||
function verify($message, $signature, $format = 'Raw')
|
||||
{
|
||||
$format = self::validatePlugin('Signature', $format);
|
||||
if ($format === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$params = $format::load($signature);
|
||||
if ($params === false || count($params) != 2) {
|
||||
return false;
|
||||
}
|
||||
extract($params);
|
||||
|
||||
if (empty($this->y) || empty($this->p)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$q_1 = $this->q->subtract(self::$one);
|
||||
if (!$r->between(self::$one, $q_1) || !$s->between(self::$one, $q_1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$w = $s->modInverse($this->q);
|
||||
$h = $this->hash->hash($message);
|
||||
$h = $this->bits2int($h);
|
||||
list(, $u1) = $h->multiply($w)->divide($this->q);
|
||||
list(, $u2) = $r->multiply($w)->divide($this->q);
|
||||
$v1 = $this->g->powMod($u1, $this->p);
|
||||
$v2 = $this->y->powMod($u2, $this->p);
|
||||
list(, $v) = $v1->multiply($v2)->divide($this->p);
|
||||
list(, $v) = $v->divide($this->q);
|
||||
|
||||
return Strings::equals($v->toBytes(), $r->toBytes());
|
||||
}
|
||||
}
|
92
phpseclib/Crypt/DSA/Keys/OpenSSH.php
Normal file
92
phpseclib/Crypt/DSA/Keys/OpenSSH.php
Normal file
@ -0,0 +1,92 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted DSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Place in $HOME/.ssh/authorized_keys
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
use phpseclib\Crypt\Common\Keys\OpenSSH as Progenitor;
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted DSA Key Handler
|
||||
*
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSH extends Progenitor
|
||||
{
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
$key = parent::load($key, 'ssh-dss');
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$result = Strings::unpackSSH2('iiii', $key);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
list($p, $q, $g, $y) = $result;
|
||||
|
||||
$comment = parent::getComment($key);
|
||||
|
||||
return compact('p', 'q', 'g', 'y', 'comment');
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y)
|
||||
{
|
||||
if ($q->getLength() != 160) {
|
||||
throw new \InvalidArgumentException('SSH only supports keys with an N (length of Group Order q) of 160');
|
||||
}
|
||||
|
||||
// from <http://tools.ietf.org/html/rfc4253#page-15>:
|
||||
// string "ssh-dss"
|
||||
// mpint p
|
||||
// mpint q
|
||||
// mpint g
|
||||
// mpint y
|
||||
$DSAPublicKey = Strings::packSSH2('siiii', 'ssh-dss', $p, $q, $g, $y);
|
||||
|
||||
if (self::$binary) {
|
||||
return $DSAPublicKey;
|
||||
}
|
||||
|
||||
$DSAPublicKey = 'ssh-dss ' . Base64::encode($DSAPublicKey) . ' ' . self::$comment;
|
||||
|
||||
return $DSAPublicKey;
|
||||
}
|
||||
}
|
149
phpseclib/Crypt/DSA/Keys/PKCS1.php
Normal file
149
phpseclib/Crypt/DSA/Keys/PKCS1.php
Normal file
@ -0,0 +1,149 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PKCS#1 Formatted DSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Used by File/X509.php
|
||||
*
|
||||
* Processes keys with the following headers:
|
||||
*
|
||||
* -----BEGIN DSA PRIVATE KEY-----
|
||||
* -----BEGIN DSA PUBLIC KEY-----
|
||||
* -----BEGIN DSA PARAMETERS-----
|
||||
*
|
||||
* Analogous to ssh-keygen's pem format (as specified by -m)
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Crypt\Common\Keys\PKCS1 as Progenitor;
|
||||
use phpseclib\File\ASN1;
|
||||
use phpseclib\File\ASN1\Maps;
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
|
||||
/**
|
||||
* PKCS#1 Formatted RSA Key Handler
|
||||
*
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PKCS1 extends Progenitor
|
||||
{
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$key = parent::load($key, $password);
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$decoded = ASN1::decodeBER($key);
|
||||
if (empty($decoded)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$key = ASN1::asn1map($decoded[0], Maps\DSAParams::MAP);
|
||||
if (is_array($key)) {
|
||||
return $key;
|
||||
}
|
||||
|
||||
$key = ASN1::asn1map($decoded[0], Maps\DSAPrivateKey::MAP);
|
||||
if (is_array($key)) {
|
||||
return $key;
|
||||
}
|
||||
|
||||
$key = ASN1::asn1map($decoded[0], Maps\DSAPublicKey::MAP);
|
||||
return is_array($key) ? $key : false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert DSA parameters to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @return string
|
||||
*/
|
||||
public static function saveParameters(BigInteger $p, BigInteger $q, BigInteger $g)
|
||||
{
|
||||
$key = [
|
||||
'p' => $p,
|
||||
'q' => $q,
|
||||
'g' => $g
|
||||
];
|
||||
|
||||
$key = ASN1::encodeDER($key, Maps\DSAParams::MAP);
|
||||
|
||||
return "-----BEGIN DSA PARAMETERS-----\r\n" .
|
||||
chunk_split(Base64::encode($key), 64) .
|
||||
"-----END DSA PARAMETERS-----\r\n";
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a private key to the appropriate format.
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $x
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @param string $password optional
|
||||
* @return string
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y, BigInteger $x, $password = '')
|
||||
{
|
||||
$key = [
|
||||
'version' => 0,
|
||||
'p' => $p,
|
||||
'q' => $q,
|
||||
'g' => $g,
|
||||
'y' => $y,
|
||||
'x' => $x
|
||||
];
|
||||
|
||||
$key = ASN1::encodeDER($key, Maps\DSAPrivateKey::MAP);
|
||||
|
||||
return self::wrapPrivateKey($key, 'DSA', $password);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y)
|
||||
{
|
||||
$key = ASN1::encodeDER($y, Maps\DSAPublicKey::MAP);
|
||||
|
||||
return self::wrapPublicKey($key, 'DSA');
|
||||
}
|
||||
}
|
169
phpseclib/Crypt/DSA/Keys/PKCS8.php
Normal file
169
phpseclib/Crypt/DSA/Keys/PKCS8.php
Normal file
@ -0,0 +1,169 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PKCS#8 Formatted DSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Processes keys with the following headers:
|
||||
*
|
||||
* -----BEGIN ENCRYPTED PRIVATE KEY-----
|
||||
* -----BEGIN PRIVATE KEY-----
|
||||
* -----BEGIN PUBLIC KEY-----
|
||||
*
|
||||
* Analogous to ssh-keygen's pkcs8 format (as specified by -m). Although PKCS8
|
||||
* is specific to private keys it's basically creating a DER-encoded wrapper
|
||||
* for keys. This just extends that same concept to public keys (much like ssh-keygen)
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Crypt\Common\Keys\PKCS8 as Progenitor;
|
||||
use phpseclib\File\ASN1;
|
||||
use phpseclib\File\ASN1\Maps;
|
||||
|
||||
/**
|
||||
* PKCS#8 Formatted DSA Key Handler
|
||||
*
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PKCS8 extends Progenitor
|
||||
{
|
||||
/**
|
||||
* OID Name
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const OID_NAME = 'id-dsa';
|
||||
|
||||
/**
|
||||
* OID Value
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const OID_VALUE = '1.2.840.10040.4.1';
|
||||
|
||||
/**
|
||||
* Child OIDs loaded
|
||||
*
|
||||
* @var bool
|
||||
* @access private
|
||||
*/
|
||||
protected static $childOIDsLoaded = false;
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$isPublic = strpos($key, 'PUBLIC') !== false;
|
||||
|
||||
$key = parent::load($key, $password);
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$type = isset($key['privateKey']) ? 'privateKey' : 'publicKey';
|
||||
|
||||
switch (true) {
|
||||
case !$isPublic && $type == 'publicKey':
|
||||
case $isPublic && $type == 'privateKey':
|
||||
return false;
|
||||
}
|
||||
|
||||
$decoded = ASN1::decodeBER($key[$type . 'Algorithm']['parameters']->element);
|
||||
if (empty($decoded)) {
|
||||
return false;
|
||||
}
|
||||
$components = ASN1::asn1map($decoded[0], Maps\DSAParams::MAP);
|
||||
if (!is_array($components)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$decoded = ASN1::decodeBER($key[$type]);
|
||||
if (empty($decoded)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$var = $type == 'privateKey' ? 'x' : 'y';
|
||||
$components[$var] = ASN1::asn1map($decoded[0], Maps\DSAPublicKey::MAP);
|
||||
if (!$components[$var] instanceof BigInteger) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (isset($key['meta'])) {
|
||||
$components['meta'] = $key['meta'];
|
||||
}
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a private key to the appropriate format.
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $x
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @param string $password optional
|
||||
* @return string
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y, BigInteger $x, $password = '')
|
||||
{
|
||||
$params = [
|
||||
'p' => $p,
|
||||
'q' => $q,
|
||||
'g' => $g
|
||||
];
|
||||
$params = ASN1::encodeDER($params, Maps\DSAParams::MAP);
|
||||
$params = new ASN1\Element($params);
|
||||
$key = ASN1::encodeDER($x, Maps\DSAPublicKey::MAP);
|
||||
return self::wrapPrivateKey($key, [], $params, $password);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y)
|
||||
{
|
||||
$params = [
|
||||
'p' => $p,
|
||||
'q' => $q,
|
||||
'g' => $g
|
||||
];
|
||||
$params = ASN1::encodeDER($params, Maps\DSAParams::MAP);
|
||||
$params = new ASN1\Element($params);
|
||||
$key = ASN1::encodeDER($y, Maps\DSAPublicKey::MAP);
|
||||
return self::wrapPublicKey($key, $params);
|
||||
}
|
||||
}
|
129
phpseclib/Crypt/DSA/Keys/PuTTY.php
Normal file
129
phpseclib/Crypt/DSA/Keys/PuTTY.php
Normal file
@ -0,0 +1,129 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PuTTY Formatted DSA Key Handler
|
||||
*
|
||||
* puttygen does not generate DSA keys with an N of anything other than 160, however,
|
||||
* it can still load them and convert them. PuTTY will load them, too, but SSH servers
|
||||
* won't accept them. Since PuTTY formatted keys are primarily used with SSH this makes
|
||||
* keys with N > 160 kinda useless, hence this handlers not supporting such keys.
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
use phpseclib\Crypt\Common\Keys\PuTTY as Progenitor;
|
||||
|
||||
/**
|
||||
* PuTTY Formatted DSA Key Handler
|
||||
*
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PuTTY extends Progenitor
|
||||
{
|
||||
/**
|
||||
* Public Handler
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const PUBLIC_HANDLER = 'phpseclib\Crypt\DSA\Keys\OpenSSH';
|
||||
|
||||
/**
|
||||
* Algorithm Identifier
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const TYPE = 'ssh-dss';
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
$components = parent::load($key, $password);
|
||||
if ($components === false || !isset($components['private'])) {
|
||||
return $components;
|
||||
}
|
||||
extract($components);
|
||||
unset($components['public'], $components['private']);
|
||||
|
||||
$result = Strings::unpackSSH2('iiii', $public);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
list($p, $q, $g, $y) = $result;
|
||||
|
||||
$result = Strings::unpackSSH2('i', $private);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
list($x) = $result;
|
||||
|
||||
return compact('p', 'q', 'g', 'y', 'x', 'comment');
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a private key to the appropriate format.
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @param \phpseclib\Math\BigInteger $x
|
||||
* @param array $primes
|
||||
* @param array $exponents
|
||||
* @param array $coefficients
|
||||
* @param string $password optional
|
||||
* @return string
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y, BigInteger $x, $password = '')
|
||||
{
|
||||
if ($q->getLength() != 160) {
|
||||
throw new \InvalidArgumentException('SSH only supports keys with an N (length of Group Order q) of 160');
|
||||
}
|
||||
|
||||
$public = Strings::packSSH2('iiii', $p, $q, $g, $y);
|
||||
$private = Strings::packSSH2('i', $x);
|
||||
|
||||
return self::wrapPrivateKey($public, $private, $password);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y)
|
||||
{
|
||||
if ($q->getLength() != 160) {
|
||||
throw new \InvalidArgumentException('SSH only supports keys with an N (length of Group Order q) of 160');
|
||||
}
|
||||
|
||||
return self::wrapPublicKey(Strings::packSSH2('iiii', $p, $q, $g, $y));
|
||||
}
|
||||
}
|
95
phpseclib/Crypt/DSA/Keys/Raw.php
Normal file
95
phpseclib/Crypt/DSA/Keys/Raw.php
Normal file
@ -0,0 +1,95 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Raw DSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Reads and creates arrays as DSA keys
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
||||
/**
|
||||
* Raw DSA Key Handler
|
||||
*
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Raw
|
||||
{
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param array $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_array($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (true) {
|
||||
case !isset($key['p']) || !isset($key['q']) || !isset($key['g']):
|
||||
case !$key['p'] instanceof BigInteger:
|
||||
case !$key['q'] instanceof BigInteger:
|
||||
case !$key['g'] instanceof BigInteger:
|
||||
case !isset($key['x']) && !isset($key['y']):
|
||||
case isset($key['x']) && !$key['x'] instanceof BigInteger:
|
||||
case isset($key['y']) && !$key['y'] instanceof BigInteger:
|
||||
return false;
|
||||
}
|
||||
|
||||
$options = ['p' => 1, 'q' => 1, 'g' => 1, 'x' => 1, 'y' => 1];
|
||||
|
||||
return array_intersect_key($key, $options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a private key to the appropriate format.
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @param \phpseclib\Math\BigInteger $x
|
||||
* @param array $primes
|
||||
* @param array $exponents
|
||||
* @param array $coefficients
|
||||
* @param string $password optional
|
||||
* @return string
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y, BigInteger $x, $password = '')
|
||||
{
|
||||
return compact('p', 'q', 'g', 'y', 'x');
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y)
|
||||
{
|
||||
return compact('p', 'q', 'g', 'y');
|
||||
}
|
||||
}
|
129
phpseclib/Crypt/DSA/Keys/XML.php
Normal file
129
phpseclib/Crypt/DSA/Keys/XML.php
Normal file
@ -0,0 +1,129 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* XML Formatted DSA Key Handler
|
||||
*
|
||||
* While XKMS defines a private key format for RSA it does not do so for DSA. Quoting that standard:
|
||||
*
|
||||
* "[XKMS] does not specify private key parameters for the DSA signature algorithm since the algorithm only
|
||||
* supports signature modes and so the application of server generated keys and key recovery is of limited
|
||||
* value"
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
||||
/**
|
||||
* XML Formatted DSA Key Handler
|
||||
*
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class XML
|
||||
{
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$use_errors = libxml_use_internal_errors(true);
|
||||
|
||||
$dom = new \DOMDocument();
|
||||
if (!$dom->loadXML('<xml>' . $key . '</xml>')) {
|
||||
return false;
|
||||
}
|
||||
$xpath = new \DOMXPath($dom);
|
||||
$keys = ['p', 'q', 'g', 'y', 'j', 'seed', 'pgencounter'];
|
||||
foreach ($keys as $key) {
|
||||
// $dom->getElementsByTagName($key) is case-sensitive
|
||||
$temp = $xpath->query("//*[translate(local-name(), 'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='$key']");
|
||||
if (!$temp->length) {
|
||||
continue;
|
||||
}
|
||||
$value = new BigInteger(Base64::decode($temp->item(0)->nodeValue), 256);
|
||||
switch ($key) {
|
||||
case 'p': // a prime modulus meeting the [DSS] requirements
|
||||
// Parameters P, Q, and G can be public and common to a group of users. They might be known
|
||||
// from application context. As such, they are optional but P and Q must either both appear
|
||||
// or both be absent
|
||||
$components['p'] = $value;
|
||||
break;
|
||||
case 'q': // an integer in the range 2**159 < Q < 2**160 which is a prime divisor of P-1
|
||||
$components['q'] = $value;
|
||||
break;
|
||||
case 'g': // an integer with certain properties with respect to P and Q
|
||||
$components['g'] = $value;
|
||||
break;
|
||||
case 'y': // G**X mod P (where X is part of the private key and not made public)
|
||||
$components['y'] = $value;
|
||||
// the remaining options do not do anything
|
||||
case 'j': // (P - 1) / Q
|
||||
// Parameter J is available for inclusion solely for efficiency as it is calculatable from
|
||||
// P and Q
|
||||
case 'seed': // a DSA prime generation seed
|
||||
// Parameters seed and pgenCounter are used in the DSA prime number generation algorithm
|
||||
// specified in [DSS]. As such, they are optional but must either both be present or both
|
||||
// be absent
|
||||
case 'pgencounter': // a DSA prime generation counter
|
||||
}
|
||||
}
|
||||
|
||||
libxml_use_internal_errors($use_errors);
|
||||
|
||||
if (!isset($components['y'])) {
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (true) {
|
||||
case !isset($components['p']):
|
||||
case !isset($components['q']):
|
||||
case !isset($components['g']):
|
||||
return ['y' => $components['y']];
|
||||
}
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* See https://www.w3.org/TR/xmldsig-core/#sec-DSAKeyValue
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $p
|
||||
* @param \phpseclib\Math\BigInteger $q
|
||||
* @param \phpseclib\Math\BigInteger $g
|
||||
* @param \phpseclib\Math\BigInteger $y
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $p, BigInteger $q, BigInteger $g, BigInteger $y)
|
||||
{
|
||||
return "<DSAKeyValue>\r\n" .
|
||||
' <P>' . Base64::encode($p->toBytes()) . "</P>\r\n" .
|
||||
' <Q>' . Base64::encode($q->toBytes()) . "</Q>\r\n" .
|
||||
' <G>' . Base64::encode($g->toBytes()) . "</G>\r\n" .
|
||||
' <Y>' . Base64::encode($y->toBytes()) . "</Y>\r\n" .
|
||||
'</DSAKeyValue>';
|
||||
}
|
||||
}
|
68
phpseclib/Crypt/DSA/Signature/PKCS.php
Normal file
68
phpseclib/Crypt/DSA/Signature/PKCS.php
Normal file
@ -0,0 +1,68 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PKCS Signature Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Handles signatures in the format described in
|
||||
* https://tools.ietf.org/html/rfc3279#section-2.2.2
|
||||
*
|
||||
* @category Crypt
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Signature;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\File\ASN1;
|
||||
use phpseclib\File\ASN1\Maps;
|
||||
|
||||
/**
|
||||
* PKCS Signature Handler
|
||||
*
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PKCS
|
||||
{
|
||||
/**
|
||||
* Loads a signature
|
||||
*
|
||||
* @access public
|
||||
* @param array $key
|
||||
* @return array
|
||||
*/
|
||||
public static function load($sig)
|
||||
{
|
||||
if (!is_string($sig)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$decoded = ASN1::decodeBER($sig);
|
||||
if (empty($decoded)) {
|
||||
return false;
|
||||
}
|
||||
$components = ASN1::asn1map($decoded[0], Maps\DssSigValue::MAP);
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a signature in the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $r
|
||||
* @param \phpseclib\Math\BigInteger $s
|
||||
* @return string
|
||||
*/
|
||||
public static function save(BigInteger $r, BigInteger $s)
|
||||
{
|
||||
return ASN1::encodeDER(compact('r', 's'), Maps\DssSigValue::MAP);
|
||||
}
|
||||
}
|
29
phpseclib/Crypt/DSA/Signature/Raw.php
Normal file
29
phpseclib/Crypt/DSA/Signature/Raw.php
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Raw DSA Signature Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Signature;
|
||||
|
||||
use phpseclib\Crypt\Common\Signature\Raw as Progenitor;
|
||||
|
||||
/**
|
||||
* Raw DSA Signature Handler
|
||||
*
|
||||
* @package DSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class Raw extends Progenitor
|
||||
{
|
||||
}
|
75
phpseclib/Crypt/DSA/Signature/SSH2.php
Normal file
75
phpseclib/Crypt/DSA/Signature/SSH2.php
Normal file
@ -0,0 +1,75 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* SSH2 Signature Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Handles signatures in the format used by SSH2
|
||||
*
|
||||
* @category Crypt
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\DSA\Signature;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* SSH2 Signature Handler
|
||||
*
|
||||
* @package Common
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class SSH2
|
||||
{
|
||||
/**
|
||||
* Loads a signature
|
||||
*
|
||||
* @access public
|
||||
* @param array $key
|
||||
* @return array
|
||||
*/
|
||||
public static function load($sig)
|
||||
{
|
||||
if (!is_string($sig)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$result = Strings::unpackSSH2('ss', $sig);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
list($type, $blob) = $result;
|
||||
if ($type != 'ssh-dss' || strlen($blob) != 40) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return [
|
||||
'r' => new BigInteger(substr($blob, 0, 20), 256),
|
||||
's' => new BigInteger(substr($blob, 20), 256)
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a signature in the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $r
|
||||
* @param \phpseclib\Math\BigInteger $s
|
||||
* @return string
|
||||
*/
|
||||
public static function save(BigInteger $r, BigInteger $s)
|
||||
{
|
||||
if ($r->getLength() != 160 || $s->getLength != 160) {
|
||||
return false;
|
||||
}
|
||||
return Strings::pack('ss', $r, $s);
|
||||
}
|
||||
}
|
@ -50,6 +50,8 @@ use phpseclib\File\ASN1;
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
use phpseclib\File\ASN1\Maps\DigestInfo;
|
||||
use phpseclib\Crypt\Common\AsymmetricKey;
|
||||
use phpseclib\Exception\UnsupportedAlgorithmException;
|
||||
|
||||
/**
|
||||
* Pure-PHP PKCS#1 compliant implementation of RSA.
|
||||
@ -58,8 +60,16 @@ use phpseclib\File\ASN1\Maps\DigestInfo;
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
class RSA
|
||||
class RSA extends AsymmetricKey
|
||||
{
|
||||
/**
|
||||
* Algorithm Name
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const ALGORITHM = 'RSA';
|
||||
|
||||
/**#@+
|
||||
* @access public
|
||||
* @see self::encrypt()
|
||||
@ -119,54 +129,6 @@ class RSA
|
||||
const PADDING_RELAXED_PKCS1 = 5;
|
||||
/**#@-*/
|
||||
|
||||
/**#@+
|
||||
* @access private
|
||||
* @see self::__construct()
|
||||
*/
|
||||
/**
|
||||
* To use the pure-PHP implementation
|
||||
*/
|
||||
const ENGINE_INTERNAL = 1;
|
||||
/**
|
||||
* To use the OpenSSL library
|
||||
*
|
||||
* (if enabled; otherwise, the internal implementation will be used)
|
||||
*/
|
||||
const ENGINE_OPENSSL = 2;
|
||||
/**#@-*/
|
||||
|
||||
/**
|
||||
* Precomputed Zero
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
private static $zero;
|
||||
|
||||
/**
|
||||
* Precomputed One
|
||||
*
|
||||
* @var \phpseclib\Math\BigInteger
|
||||
* @access private
|
||||
*/
|
||||
private static $one;
|
||||
|
||||
/**
|
||||
* Private Key Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private $privateKeyFormat = 'PKCS8';
|
||||
|
||||
/**
|
||||
* Public Key Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private $publicKeyFormat = 'PKCS8';
|
||||
|
||||
/**
|
||||
* Modulus (ie. n)
|
||||
*
|
||||
@ -223,14 +185,6 @@ class RSA
|
||||
*/
|
||||
private $hashName;
|
||||
|
||||
/**
|
||||
* Hash function
|
||||
*
|
||||
* @var \phpseclib\Crypt\Hash
|
||||
* @access private
|
||||
*/
|
||||
private $hash;
|
||||
|
||||
/**
|
||||
* Length of hash function output
|
||||
*
|
||||
@ -271,51 +225,6 @@ class RSA
|
||||
*/
|
||||
private $publicExponent = false;
|
||||
|
||||
/**
|
||||
* Password
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private $password = false;
|
||||
|
||||
/**
|
||||
* Loaded File Format
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private $format = false;
|
||||
|
||||
/**
|
||||
* OpenSSL configuration file name.
|
||||
*
|
||||
* Set to null to use system configuration file.
|
||||
*
|
||||
* @see self::createKey()
|
||||
* @var mixed
|
||||
* @access public
|
||||
*/
|
||||
private static $configFile;
|
||||
|
||||
/**
|
||||
* Supported file formats (lower case)
|
||||
*
|
||||
* @see self::initialize_static_variables()
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
private static $fileFormats = false;
|
||||
|
||||
/**
|
||||
* Supported file formats (original case)
|
||||
*
|
||||
* @see self::initialize_static_variables()
|
||||
* @var array
|
||||
* @access private
|
||||
*/
|
||||
private static $origFileFormats = false;
|
||||
|
||||
/**
|
||||
* Public exponent
|
||||
*
|
||||
@ -340,40 +249,6 @@ class RSA
|
||||
*/
|
||||
private static $smallestPrime = 4096;
|
||||
|
||||
/**
|
||||
* Engine
|
||||
*
|
||||
* This is only used for key generation. Valid values are RSA::ENGINE_INTERNAL and RSA::ENGINE_OPENSSL
|
||||
*
|
||||
* @var int
|
||||
* @access private
|
||||
*/
|
||||
private static $engine = NULL;
|
||||
|
||||
/**
|
||||
* Initialize static variables
|
||||
*
|
||||
* @access private
|
||||
*/
|
||||
private static function initialize_static_variables()
|
||||
{
|
||||
if (!isset(self::$zero)) {
|
||||
self::$zero= new BigInteger(0);
|
||||
self::$one = new BigInteger(1);
|
||||
self::$configFile = __DIR__ . '/../openssl.cnf';
|
||||
|
||||
if (self::$fileFormats === false) {
|
||||
self::$fileFormats = [];
|
||||
foreach (glob(__DIR__ . '/RSA/*.php') as $file) {
|
||||
$name = pathinfo($file, PATHINFO_FILENAME);
|
||||
$type = 'phpseclib\Crypt\RSA\\' . $name;
|
||||
self::$fileFormats[strtolower($name)] = $type;
|
||||
self::$origFileFormats[] = $name;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The constructor
|
||||
*
|
||||
@ -386,9 +261,9 @@ class RSA
|
||||
*/
|
||||
public function __construct()
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
parent::__construct();
|
||||
|
||||
$this->hash = new Hash('sha256');
|
||||
//$this->hash = new Hash('sha256');
|
||||
$this->hLen = $this->hash->getLengthInBytes();
|
||||
$this->hashName = 'sha256';
|
||||
$this->mgfHash = new Hash('sha256');
|
||||
@ -421,73 +296,15 @@ class RSA
|
||||
self::$smallestPrime = $val;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests engine validity
|
||||
*
|
||||
* @access public
|
||||
* @param int $val
|
||||
*/
|
||||
public static function isValidEngine($val)
|
||||
{
|
||||
switch ($val) {
|
||||
case self::ENGINE_OPENSSL:
|
||||
return extension_loaded('openssl') && file_exists(self::$configFile);
|
||||
case self::ENGINE_INTERNAL:
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the engine
|
||||
*
|
||||
* Only used in RSA::createKey. Valid values are RSA::ENGINE_OPENSSL and RSA::ENGINE_INTERNAL
|
||||
*
|
||||
* @access public
|
||||
* @param int $val
|
||||
*/
|
||||
public static function setPreferredEngine($val)
|
||||
{
|
||||
self::$engine = null;
|
||||
$candidateEngines = [
|
||||
$val,
|
||||
self::ENGINE_OPENSSL
|
||||
];
|
||||
foreach ($candidateEngines as $engine) {
|
||||
if (self::isValidEngine($engine)) {
|
||||
self::$engine = $engine;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!isset(self::$engine)) {
|
||||
self::$engine = self::ENGINE_INTERNAL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the engine
|
||||
*
|
||||
* @access public
|
||||
* @return int
|
||||
*/
|
||||
public static function getEngine($val)
|
||||
{
|
||||
return self::$engine;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create public / private key pair
|
||||
*
|
||||
* Returns an array with the following three elements:
|
||||
* Returns an array with the following two elements:
|
||||
* - 'privatekey': The private key.
|
||||
* - 'publickey': The public key.
|
||||
* - 'partialkey': A partially computed key (if the execution time exceeded $timeout).
|
||||
* Will need to be passed back to \phpseclib\Crypt\RSA::createKey() as the third parameter for further processing.
|
||||
*
|
||||
* @access public
|
||||
* @param int $bits
|
||||
* @param int $timeout
|
||||
* @param array $p
|
||||
*/
|
||||
public static function createKey($bits = 2048)
|
||||
@ -513,16 +330,13 @@ class RSA
|
||||
$publickeyarr = openssl_pkey_get_details($rsa);
|
||||
$publickey = new RSA();
|
||||
$publickey->load($publickeyarr['key']);
|
||||
$publickey->setPublicKey();
|
||||
|
||||
// clear the buffer of error strings stemming from a minimalistic openssl.cnf
|
||||
while (openssl_error_string() !== false) {
|
||||
}
|
||||
|
||||
return [
|
||||
'privatekey' => $privatekey,
|
||||
'publickey' => $publickey,
|
||||
'partialkey' => false
|
||||
];
|
||||
return compact('privatekey', 'publickey');
|
||||
}
|
||||
|
||||
static $e;
|
||||
@ -614,47 +428,9 @@ class RSA
|
||||
$publickey->modulus = $n;
|
||||
$publickey->k = $bits >> 3;
|
||||
$publickey->exponent = $e;
|
||||
$publickey->publicExponent = $e;
|
||||
|
||||
return [
|
||||
'privatekey' => $privatekey,
|
||||
'publickey' => $publickey
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a fileformat plugin
|
||||
*
|
||||
* The plugin needs to either already be loaded or be auto-loadable.
|
||||
* Loading a plugin whose shortname overwrite an existing shortname will overwrite the old plugin.
|
||||
*
|
||||
* @see self::load()
|
||||
* @param string $fullname
|
||||
* @access public
|
||||
* @return bool
|
||||
*/
|
||||
public static function addFileFormat($fullname)
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
if (class_exists($fullname)) {
|
||||
$meta = new \ReflectionClass($path);
|
||||
$shortname = $meta->getShortName();
|
||||
self::$fileFormats[strtolower($shortname)] = $fullname;
|
||||
self::$origFileFormats[] = $shortname;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a list of supported formats.
|
||||
*
|
||||
* @access public
|
||||
* @return array
|
||||
*/
|
||||
public static function getSupportedFormats()
|
||||
{
|
||||
self::initialize_static_variables();
|
||||
|
||||
return self::$origFileFormats;
|
||||
return compact('privatekey', 'publickey');
|
||||
}
|
||||
|
||||
/**
|
||||
@ -671,6 +447,7 @@ class RSA
|
||||
if ($key instanceof RSA) {
|
||||
$this->privateKeyFormat = $key->privateKeyFormat;
|
||||
$this->publicKeyFormat = $key->publicKeyFormat;
|
||||
$this->format = $key->format;
|
||||
$this->k = $key->k;
|
||||
$this->hLen = $key->hLen;
|
||||
$this->sLen = $key->sLen;
|
||||
@ -711,33 +488,11 @@ class RSA
|
||||
return true;
|
||||
}
|
||||
|
||||
$components = false;
|
||||
if ($type === false) {
|
||||
foreach (self::$fileFormats as $format) {
|
||||
try {
|
||||
$components = $format::load($key, $this->password);
|
||||
} catch (\Exception $e) {
|
||||
$components = false;
|
||||
}
|
||||
if ($components !== false) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$format = strtolower($type);
|
||||
if (isset(self::$fileFormats[$format])) {
|
||||
$format = self::$fileFormats[$format];
|
||||
$components = $format::load($key, $this->password);
|
||||
}
|
||||
}
|
||||
|
||||
$components = parent::load($key, $type);
|
||||
if ($components === false) {
|
||||
$this->format = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
$this->format = $format;
|
||||
|
||||
$this->modulus = $components['modulus'];
|
||||
$this->k = $this->modulus->getLengthInBytes();
|
||||
$this->exponent = isset($components['privateExponent']) ? $components['privateExponent'] : $components['publicExponent'];
|
||||
@ -760,26 +515,6 @@ class RSA
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the format of the loaded key.
|
||||
*
|
||||
* If the key that was loaded wasn't in a valid or if the key was auto-generated
|
||||
* with RSA::createKey() then this will return false.
|
||||
*
|
||||
* @see self::load()
|
||||
* @access public
|
||||
* @return mixed
|
||||
*/
|
||||
public function getLoadedFormat()
|
||||
{
|
||||
if ($this->format === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$meta = new \ReflectionClass($this->format);
|
||||
return $meta->getShortName();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the private key
|
||||
*
|
||||
@ -790,14 +525,10 @@ class RSA
|
||||
* @param string $type optional
|
||||
* @return mixed
|
||||
*/
|
||||
public function getPrivateKey($type = 'PKCS1')
|
||||
public function getPrivateKey($type = 'PKCS8')
|
||||
{
|
||||
$type = strtolower($type);
|
||||
if (!isset(self::$fileFormats[$type])) {
|
||||
return false;
|
||||
}
|
||||
$type = self::$fileFormats[$type];
|
||||
if (!method_exists($type, 'savePrivateKey')) {
|
||||
$type = self::validatePlugin('Keys', $type, 'savePrivateKey');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -836,6 +567,35 @@ class RSA
|
||||
*/
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a minimalistic private key
|
||||
*
|
||||
* Returns the private key without the prime number constituants. Structurally identical to a public key that
|
||||
* hasn't been set as the public key
|
||||
*
|
||||
* @see self::getPrivateKey()
|
||||
* @access private
|
||||
* @param string $type optional
|
||||
* @return mixed
|
||||
*/
|
||||
protected function getPrivatePublicKey($type = 'PKCS8')
|
||||
{
|
||||
$type = self::validatePlugin('Keys', $type, 'savePublicKey');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (empty($this->modulus) || empty($this->exponent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$oldFormat = $this->publicKeyFormat;
|
||||
$this->publicKeyFormat = $type;
|
||||
$temp = $type::savePublicKey($this->modulus, $this->exponent);
|
||||
$this->publicKeyFormat = $oldFormat;
|
||||
return $temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the key size
|
||||
*
|
||||
@ -849,22 +609,6 @@ class RSA
|
||||
return !isset($this->modulus) ? 0 : $this->modulus->getLength();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the password
|
||||
*
|
||||
* Private keys can be encrypted with a password. To unset the password, pass in the empty string or false.
|
||||
* Or rather, pass in $password such that empty($password) && !is_string($password) is true.
|
||||
*
|
||||
* @see self::createKey()
|
||||
* @see self::load()
|
||||
* @access public
|
||||
* @param string $password
|
||||
*/
|
||||
public function setPassword($password = false)
|
||||
{
|
||||
$this->password = $password;
|
||||
}
|
||||
|
||||
/**
|
||||
* Defines the public key
|
||||
*
|
||||
@ -898,40 +642,11 @@ class RSA
|
||||
return true;
|
||||
}
|
||||
|
||||
$components = false;
|
||||
if ($type === false) {
|
||||
foreach (self::$fileFormats as $format) {
|
||||
if (!method_exists($format, 'savePublicKey')) {
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
$components = $format::load($key, $this->password);
|
||||
} catch (\Exception $e) {
|
||||
$components = false;
|
||||
}
|
||||
if ($components !== false) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$format = strtolower($type);
|
||||
if (isset(self::$fileFormats[$format])) {
|
||||
$format = self::$fileFormats[$format];
|
||||
try {
|
||||
$components = $format::load($key, $this->password);
|
||||
} catch (\Exception $e) {
|
||||
$components = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$components = parent::setPublicKey($key, $type);
|
||||
if ($components === false) {
|
||||
$this->format = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
$this->format = $format;
|
||||
|
||||
if (empty($this->modulus) || !$this->modulus->equals($components['modulus'])) {
|
||||
$this->modulus = $components['modulus'];
|
||||
$this->exponent = $this->publicExponent = $components['publicExponent'];
|
||||
@ -991,12 +706,8 @@ class RSA
|
||||
*/
|
||||
public function getPublicKey($type = 'PKCS8')
|
||||
{
|
||||
$type = strtolower($type);
|
||||
if (!isset(self::$fileFormats[$type])) {
|
||||
return false;
|
||||
}
|
||||
$type = self::$fileFormats[$type];
|
||||
if (!method_exists($type, 'savePublicKey')) {
|
||||
$type = self::validatePlugin('Keys', $type, 'savePublicKey');
|
||||
if ($type === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1007,75 +718,6 @@ class RSA
|
||||
return $type::savePublicKey($this->modulus, $this->publicExponent);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the public key's fingerprint
|
||||
*
|
||||
* The public key's fingerprint is returned, which is equivalent to running `ssh-keygen -lf rsa.pub`. If there is
|
||||
* no public key currently loaded, false is returned.
|
||||
* Example output (md5): "c1:b1:30:29:d7:b8:de:6c:97:77:10:d7:46:41:63:87" (as specified by RFC 4716)
|
||||
*
|
||||
* @access public
|
||||
* @param string $algorithm The hashing algorithm to be used. Valid options are 'md5' and 'sha256'. False is returned
|
||||
* for invalid values.
|
||||
* @return mixed
|
||||
*/
|
||||
public function getPublicKeyFingerprint($algorithm = 'md5')
|
||||
{
|
||||
if (empty($this->modulus) || empty($this->publicExponent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$modulus = $this->modulus->toBytes(true);
|
||||
$publicExponent = $this->publicExponent->toBytes(true);
|
||||
|
||||
$RSAPublicKey = pack('Na*Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($publicExponent), $publicExponent, strlen($modulus), $modulus);
|
||||
|
||||
switch ($algorithm) {
|
||||
case 'sha256':
|
||||
$hash = new Hash('sha256');
|
||||
$base = Base64::encode($hash->hash($RSAPublicKey));
|
||||
return substr($base, 0, strlen($base) - 1);
|
||||
case 'md5':
|
||||
return substr(chunk_split(md5($RSAPublicKey), 2, ':'), 0, -1);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a minimalistic private key
|
||||
*
|
||||
* Returns the private key without the prime number constituants. Structurally identical to a public key that
|
||||
* hasn't been set as the public key
|
||||
*
|
||||
* @see self::getPrivateKey()
|
||||
* @access private
|
||||
* @param string $type optional
|
||||
* @return mixed
|
||||
*/
|
||||
private function getPrivatePublicKey($type = 'PKCS8')
|
||||
{
|
||||
$type = strtolower($type);
|
||||
if (!isset(self::$fileFormats[$type])) {
|
||||
return false;
|
||||
}
|
||||
$type = self::$fileFormats[$type];
|
||||
if (!method_exists($type, 'savePublicKey')) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (empty($this->modulus) || empty($this->exponent)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$oldFormat = $this->publicKeyFormat;
|
||||
$this->publicKeyFormat = $type;
|
||||
$temp = $type::savePublicKey($this->modulus, $this->exponent);
|
||||
$this->publicKeyFormat = $oldFormat;
|
||||
return $temp;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* __toString() magic method
|
||||
*
|
||||
@ -1096,48 +738,11 @@ class RSA
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* __clone() magic method
|
||||
*
|
||||
* @access public
|
||||
* @return \phpseclib\Crypt\RSA
|
||||
*/
|
||||
public function __clone()
|
||||
{
|
||||
$key = new RSA();
|
||||
$key->load($this);
|
||||
return $key;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines the private key format
|
||||
*
|
||||
* @see self::__toString()
|
||||
* @access public
|
||||
* @param string $format
|
||||
*/
|
||||
public function setPrivateKeyFormat($format)
|
||||
{
|
||||
$this->privateKeyFormat = $format;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines the public key format
|
||||
*
|
||||
* @see self::__toString()
|
||||
* @access public
|
||||
* @param string $format
|
||||
*/
|
||||
public function setPublicKeyFormat($format)
|
||||
{
|
||||
$this->publicKeyFormat = $format;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines which hashing function should be used
|
||||
*
|
||||
* Used with signature production / verification and (if the encryption mode is self::PADDING_OAEP) encryption and
|
||||
* decryption. If $hash isn't supported, sha256 is used.
|
||||
* decryption.
|
||||
*
|
||||
* @access public
|
||||
* @param string $hash
|
||||
@ -1145,7 +750,7 @@ class RSA
|
||||
public function setHash($hash)
|
||||
{
|
||||
// \phpseclib\Crypt\Hash supports algorithms that PKCS#1 doesn't support. md5-96 and sha1-96, for example.
|
||||
switch ($hash) {
|
||||
switch (strtolower($hash)) {
|
||||
case 'md2':
|
||||
case 'md5':
|
||||
case 'sha1':
|
||||
@ -1159,8 +764,9 @@ class RSA
|
||||
$this->hashName = $hash;
|
||||
break;
|
||||
default:
|
||||
$this->hash = new Hash('sha256');
|
||||
$this->hashName = 'sha256';
|
||||
throw new UnsupportedAlgorithmException(
|
||||
'The only supported hash algorithms are: md2, md5, sha1, sha256, sha384, sha512, sha224, sha512/224, sha512/256'
|
||||
);
|
||||
}
|
||||
$this->hLen = $this->hash->getLengthInBytes();
|
||||
}
|
||||
@ -1352,34 +958,6 @@ class RSA
|
||||
return $x;
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs blinded RSA equality testing
|
||||
*
|
||||
* Protects against a particular type of timing attack described.
|
||||
*
|
||||
* See {@link http://codahale.com/a-lesson-in-timing-attacks/ A Lesson In Timing Attacks (or, Don't use MessageDigest.isEquals)}
|
||||
*
|
||||
* Thanks for the heads up singpolyma!
|
||||
*
|
||||
* @access private
|
||||
* @param string $x
|
||||
* @param string $y
|
||||
* @return bool
|
||||
*/
|
||||
private static function equals($x, $y)
|
||||
{
|
||||
if (strlen($x) != strlen($y)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$result = 0;
|
||||
for ($i = 0; $i < strlen($x); $i++) {
|
||||
$result |= ord($x[$i]) ^ ord($y[$i]);
|
||||
}
|
||||
|
||||
return $result == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* RSAEP
|
||||
*
|
||||
@ -1578,7 +1156,7 @@ class RSA
|
||||
$db = $maskedDB ^ $dbMask;
|
||||
$lHash2 = substr($db, 0, $this->hLen);
|
||||
$m = substr($db, $this->hLen);
|
||||
if (!self::equals($lHash, $lHash2)) {
|
||||
if (!Strings::equals($lHash, $lHash2)) {
|
||||
return false;
|
||||
}
|
||||
$m = ltrim($m, chr(0));
|
||||
@ -1796,7 +1374,7 @@ class RSA
|
||||
$salt = substr($db, $temp + 1); // should be $sLen long
|
||||
$m2 = "\0\0\0\0\0\0\0\0" . $mHash . $salt;
|
||||
$h2 = $this->hash->hash($m2);
|
||||
return self::equals($h, $h2);
|
||||
return Strings::equals($h, $h2);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1990,7 +1568,7 @@ class RSA
|
||||
}
|
||||
|
||||
// Compare
|
||||
return self::equals($em, $em2);
|
||||
return Strings::equals($em, $em2);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -2080,7 +1658,7 @@ class RSA
|
||||
$em = $hash->hash($m);
|
||||
$em2 = $decoded['digest'];
|
||||
|
||||
return self::equals($em, $em2);
|
||||
return Strings::equals($em, $em2);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -17,7 +17,7 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Math\BigInteger;
|
||||
@ -173,6 +173,10 @@ abstract class MSBLOB
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $n, BigInteger $e, BigInteger $d, $primes, $exponents, $coefficients, $password = '')
|
||||
{
|
||||
if (count($primes) != 2) {
|
||||
throw new \InvalidArgumentException('MSBLOB does not support multi-prime RSA keys');
|
||||
}
|
||||
|
||||
$n = strrev($n->toBytes());
|
||||
$e = str_pad(strrev($e->toBytes()), 4, "\0");
|
||||
$key = pack('aavV', chr(self::PRIVATEKEYBLOB), chr(2), 0, self::CALG_RSA_KEYX);
|
83
phpseclib/Crypt/RSA/Keys/OpenSSH.php
Normal file
83
phpseclib/Crypt/RSA/Keys/OpenSSH.php
Normal file
@ -0,0 +1,83 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted RSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Place in $HOME/.ssh/authorized_keys
|
||||
*
|
||||
* @category Crypt
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
use phpseclib\Crypt\Common\Keys\OpenSSH as Progenitor;
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted RSA Key Handler
|
||||
*
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSH extends Progenitor
|
||||
{
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
$key = parent::load($key, 'ssh-rsa');
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$result = Strings::unpackSSH2('ii', $key);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
list($publicExponent, $modulus) = $result;
|
||||
|
||||
return [
|
||||
'isPublicKey' => true,
|
||||
'modulus' => $modulus,
|
||||
'publicExponent' => $publicExponent,
|
||||
'comment' => parent::getComment($key)
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $n
|
||||
* @param \phpseclib\Math\BigInteger $e
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $n, BigInteger $e)
|
||||
{
|
||||
$RSAPublicKey = Strings::packSSH2('sii', 'ssh-rsa', $e, $n);
|
||||
|
||||
if (self::$binary) {
|
||||
return $RSAPublicKey;
|
||||
}
|
||||
|
||||
$RSAPublicKey = 'ssh-rsa ' . Base64::encode($RSAPublicKey) . ' ' . self::$comment;
|
||||
|
||||
return $RSAPublicKey;
|
||||
}
|
||||
}
|
@ -22,10 +22,10 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Crypt\Common\PKCS1 as Progenitor;
|
||||
use phpseclib\Crypt\Common\Keys\PKCS1 as Progenitor;
|
||||
use phpseclib\File\ASN1;
|
||||
use phpseclib\File\ASN1\Maps;
|
||||
|
@ -25,10 +25,10 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Crypt\Common\PKCS8 as Progenitor;
|
||||
use phpseclib\Crypt\Common\Keys\PKCS8 as Progenitor;
|
||||
use phpseclib\File\ASN1;
|
||||
|
||||
/**
|
||||
@ -40,6 +40,30 @@ use phpseclib\File\ASN1;
|
||||
*/
|
||||
abstract class PKCS8 extends Progenitor
|
||||
{
|
||||
/**
|
||||
* OID Name
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const OID_NAME = 'rsaEncryption';
|
||||
|
||||
/**
|
||||
* OID Value
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const OID_VALUE = '1.2.840.113549.1.1.1';
|
||||
|
||||
/**
|
||||
* Child OIDs loaded
|
||||
*
|
||||
* @var bool
|
||||
* @access private
|
||||
*/
|
||||
protected static $childOIDsLoaded = false;
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
@ -50,6 +74,10 @@ abstract class PKCS8 extends Progenitor
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$components = ['isPublicKey' => strpos($key, 'PUBLIC') !== false];
|
||||
|
||||
$key = parent::load($key, $password);
|
||||
@ -59,10 +87,6 @@ abstract class PKCS8 extends Progenitor
|
||||
|
||||
$type = isset($key['privateKey']) ? 'private' : 'public';
|
||||
|
||||
if ($key[$type . 'KeyAlgorithm']['algorithm'] != '1.2.840.113549.1.1.1') {
|
||||
return false;
|
||||
}
|
||||
|
||||
$result = $components + PKCS1::load($key[$type . 'Key']);
|
||||
|
||||
if (isset($key['meta'])) {
|
||||
@ -89,7 +113,7 @@ abstract class PKCS8 extends Progenitor
|
||||
{
|
||||
$key = PKCS1::savePrivateKey($n, $e, $d, $primes, $exponents, $coefficients);
|
||||
$key = ASN1::extractBER($key);
|
||||
return self::wrapPrivateKey($key, '1.2.840.113549.1.1.1', [], $password);
|
||||
return self::wrapPrivateKey($key, [], null, $password);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -104,6 +128,6 @@ abstract class PKCS8 extends Progenitor
|
||||
{
|
||||
$key = PKCS1::savePublicKey($n, $e);
|
||||
$key = ASN1::extractBER($key);
|
||||
return self::wrapPublicKey($key, '1.2.840.113549.1.1.1');
|
||||
return self::wrapPublicKey($key, null);
|
||||
}
|
||||
}
|
129
phpseclib/Crypt/RSA/Keys/PuTTY.php
Normal file
129
phpseclib/Crypt/RSA/Keys/PuTTY.php
Normal file
@ -0,0 +1,129 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PuTTY Formatted RSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
use phpseclib\Crypt\Common\Keys\PuTTY as Progenitor;
|
||||
|
||||
/**
|
||||
* PuTTY Formatted RSA Key Handler
|
||||
*
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PuTTY extends Progenitor
|
||||
{
|
||||
/**
|
||||
* Public Handler
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const PUBLIC_HANDLER = 'phpseclib\Crypt\RSA\Keys\OpenSSH';
|
||||
|
||||
/**
|
||||
* Algorithm Identifier
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
const TYPE = 'ssh-rsa';
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
static $one;
|
||||
if (!isset($one)) {
|
||||
$one = new BigInteger(1);
|
||||
}
|
||||
|
||||
$components = parent::load($key, $password);
|
||||
if ($components === false || !isset($components['private'])) {
|
||||
return $components;
|
||||
}
|
||||
extract($components);
|
||||
unset($components['public'], $components['private']);
|
||||
|
||||
$isPublicKey = false;
|
||||
|
||||
$result = Strings::unpackSSH2('ii', $public);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
list($publicExponent, $modulus) = $result;
|
||||
|
||||
$result = Strings::unpackSSH2('iiii', $private);
|
||||
if ($result === false) {
|
||||
return false;
|
||||
}
|
||||
$primes = $coefficients = [];
|
||||
list($privateExponent, $primes[1], $primes[2], $coefficients[2]) = $result;
|
||||
|
||||
$temp = $primes[1]->subtract($one);
|
||||
$exponents = [1 => $publicExponent->modInverse($temp)];
|
||||
$temp = $primes[2]->subtract($one);
|
||||
$exponents[] = $publicExponent->modInverse($temp);
|
||||
|
||||
return compact('publicExponent', 'modulus', 'privateExponent', 'primes', 'coefficients', 'exponents', 'comment', 'isPublicKey');
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a private key to the appropriate format.
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $n
|
||||
* @param \phpseclib\Math\BigInteger $e
|
||||
* @param \phpseclib\Math\BigInteger $d
|
||||
* @param array $primes
|
||||
* @param array $exponents
|
||||
* @param array $coefficients
|
||||
* @param string $password optional
|
||||
* @return string
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $n, BigInteger $e, BigInteger $d, $primes, $exponents, $coefficients, $password = '')
|
||||
{
|
||||
if (count($primes) != 2) {
|
||||
throw new \InvalidArgumentException('PuTTY does not support multi-prime RSA keys');
|
||||
}
|
||||
|
||||
$public = Strings::packSSH2('ii', $e, $n);
|
||||
$private = Strings::packSSH2('iiii', $d, $primes[1], $primes[2], $coefficients[2]);
|
||||
|
||||
return self::wrapPrivateKey($public, $private, $password);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $n
|
||||
* @param \phpseclib\Math\BigInteger $e
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $n, BigInteger $e)
|
||||
{
|
||||
return self::wrapPublicKey(Strings::packSSH2($e, $n));
|
||||
}
|
||||
}
|
@ -23,7 +23,7 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
@ -18,7 +18,7 @@
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
namespace phpseclib\Crypt\RSA\Keys;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Math\BigInteger;
|
||||
@ -116,7 +116,7 @@ abstract class XML
|
||||
public static function savePrivateKey(BigInteger $n, BigInteger $e, BigInteger $d, $primes, $exponents, $coefficients, $password = '')
|
||||
{
|
||||
if (count($primes) != 2) {
|
||||
return false;
|
||||
throw new \InvalidArgumentException('XML does not support multi-prime RSA keys');
|
||||
}
|
||||
return "<RSAKeyValue>\r\n" .
|
||||
' <Modulus>' . Base64::encode($n->toBytes()) . "</Modulus>\r\n" .
|
@ -1,126 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted RSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* Place in $HOME/.ssh/authorized_keys
|
||||
*
|
||||
* @category Crypt
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* OpenSSH Formatted RSA Key Handler
|
||||
*
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class OpenSSH
|
||||
{
|
||||
/**
|
||||
* Default comment
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private static $comment = 'phpseclib-generated-key';
|
||||
|
||||
/**
|
||||
* Sets the default comment
|
||||
*
|
||||
* @access public
|
||||
* @param string $comment
|
||||
*/
|
||||
public static function setComment($comment)
|
||||
{
|
||||
self::$comment = str_replace(["\r", "\n"], '', $comment);
|
||||
}
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$parts = explode(' ', $key, 3);
|
||||
|
||||
$key = isset($parts[1]) ? Base64::decode($parts[1]) : Base64::decode($parts[0]);
|
||||
if ($key === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$comment = isset($parts[2]) ? $parts[2] : false;
|
||||
|
||||
if (substr($key, 0, 11) != "\0\0\0\7ssh-rsa") {
|
||||
return false;
|
||||
}
|
||||
Strings::shift($key, 11);
|
||||
if (strlen($key) <= 4) {
|
||||
return false;
|
||||
}
|
||||
extract(unpack('Nlength', Strings::shift($key, 4)));
|
||||
if (strlen($key) <= $length) {
|
||||
return false;
|
||||
}
|
||||
$publicExponent = new BigInteger(Strings::shift($key, $length), -256);
|
||||
if (strlen($key) <= 4) {
|
||||
return false;
|
||||
}
|
||||
extract(unpack('Nlength', Strings::shift($key, 4)));
|
||||
if (strlen($key) != $length) {
|
||||
return false;
|
||||
}
|
||||
$modulus = new BigInteger(Strings::shift($key, $length), -256);
|
||||
|
||||
return [
|
||||
'isPublicKey' => true,
|
||||
'modulus' => $modulus,
|
||||
'publicExponent' => $publicExponent,
|
||||
'comment' => $comment
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $n
|
||||
* @param \phpseclib\Math\BigInteger $e
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $n, BigInteger $e)
|
||||
{
|
||||
$publicExponent = $e->toBytes(true);
|
||||
$modulus = $n->toBytes(true);
|
||||
|
||||
// from <http://tools.ietf.org/html/rfc4253#page-15>:
|
||||
// string "ssh-rsa"
|
||||
// mpint e
|
||||
// mpint n
|
||||
$RSAPublicKey = pack('Na*Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($publicExponent), $publicExponent, strlen($modulus), $modulus);
|
||||
$RSAPublicKey = 'ssh-rsa ' . Base64::encode($RSAPublicKey) . ' ' . self::$comment;
|
||||
|
||||
return $RSAPublicKey;
|
||||
}
|
||||
}
|
@ -1,295 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* PuTTY Formatted RSA Key Handler
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category Crypt
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\Crypt\RSA;
|
||||
|
||||
use ParagonIE\ConstantTime\Base64;
|
||||
use ParagonIE\ConstantTime\Hex;
|
||||
use phpseclib\Crypt\AES;
|
||||
use phpseclib\Crypt\Hash;
|
||||
use phpseclib\Math\BigInteger;
|
||||
use phpseclib\Common\Functions\Strings;
|
||||
|
||||
/**
|
||||
* PuTTY Formatted RSA Key Handler
|
||||
*
|
||||
* @package RSA
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class PuTTY
|
||||
{
|
||||
/**
|
||||
* Default comment
|
||||
*
|
||||
* @var string
|
||||
* @access private
|
||||
*/
|
||||
private static $comment = 'phpseclib-generated-key';
|
||||
|
||||
/**
|
||||
* Sets the default comment
|
||||
*
|
||||
* @access public
|
||||
* @param string $comment
|
||||
*/
|
||||
public static function setComment($comment)
|
||||
{
|
||||
self::$comment = str_replace(["\r", "\n"], '', $comment);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a symmetric key for PuTTY keys
|
||||
*
|
||||
* @access public
|
||||
* @param string $password
|
||||
* @param string $iv
|
||||
* @param int $length
|
||||
* @return string
|
||||
*/
|
||||
public static function generateSymmetricKey($password, $length)
|
||||
{
|
||||
$symkey = '';
|
||||
$sequence = 0;
|
||||
while (strlen($symkey) < $length) {
|
||||
$temp = pack('Na*', $sequence++, $password);
|
||||
$symkey.= Hex::decode(sha1($temp));
|
||||
}
|
||||
return substr($symkey, 0, $length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Break a public or private key down into its constituent components
|
||||
*
|
||||
* @access public
|
||||
* @param string $key
|
||||
* @param string $password optional
|
||||
* @return array
|
||||
*/
|
||||
public static function load($key, $password = '')
|
||||
{
|
||||
if (!is_string($key)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
static $one;
|
||||
if (!isset($one)) {
|
||||
$one = new BigInteger(1);
|
||||
}
|
||||
|
||||
if (strpos($key, 'BEGIN SSH2 PUBLIC KEY')) {
|
||||
$data = preg_split('#[\r\n]+#', $key);
|
||||
$data = array_splice($data, 2, -1);
|
||||
$data = implode('', $data);
|
||||
|
||||
$components = OpenSSH::load($data);
|
||||
if ($components === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!preg_match('#Comment: "(.+)"#', $key, $matches)) {
|
||||
return false;
|
||||
}
|
||||
$components['comment'] = str_replace(['\\\\', '\"'], ['\\', '"'], $matches[1]);
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
$components = ['isPublicKey' => false];
|
||||
$key = preg_split('#\r\n|\r|\n#', $key);
|
||||
$type = trim(preg_replace('#PuTTY-User-Key-File-2: (.+)#', '$1', $key[0]));
|
||||
if ($type != 'ssh-rsa') {
|
||||
return false;
|
||||
}
|
||||
$encryption = trim(preg_replace('#Encryption: (.+)#', '$1', $key[1]));
|
||||
$components['comment'] = trim(preg_replace('#Comment: (.+)#', '$1', $key[2]));
|
||||
|
||||
$publicLength = trim(preg_replace('#Public-Lines: (\d+)#', '$1', $key[3]));
|
||||
$public = Base64::decode(implode('', array_map('trim', array_slice($key, 4, $publicLength))));
|
||||
$public = substr($public, 11);
|
||||
extract(unpack('Nlength', Strings::shift($public, 4)));
|
||||
$components['publicExponent'] = new BigInteger(Strings::shift($public, $length), -256);
|
||||
extract(unpack('Nlength', Strings::shift($public, 4)));
|
||||
$components['modulus'] = new BigInteger(Strings::shift($public, $length), -256);
|
||||
|
||||
$privateLength = trim(preg_replace('#Private-Lines: (\d+)#', '$1', $key[$publicLength + 4]));
|
||||
$private = Base64::decode(implode('', array_map('trim', array_slice($key, $publicLength + 5, $privateLength))));
|
||||
|
||||
switch ($encryption) {
|
||||
case 'aes256-cbc':
|
||||
$symkey = static::generateSymmetricKey($password, 32);
|
||||
$crypto = new AES(AES::MODE_CBC);
|
||||
}
|
||||
|
||||
if ($encryption != 'none') {
|
||||
$crypto->setKey($symkey);
|
||||
$crypto->setIV(str_repeat("\0", $crypto->getBlockLength() >> 3));
|
||||
$crypto->disablePadding();
|
||||
$private = $crypto->decrypt($private);
|
||||
}
|
||||
|
||||
extract(unpack('Nlength', Strings::shift($private, 4)));
|
||||
if (strlen($private) < $length) {
|
||||
return false;
|
||||
}
|
||||
$components['privateExponent'] = new BigInteger(Strings::shift($private, $length), -256);
|
||||
extract(unpack('Nlength', Strings::shift($private, 4)));
|
||||
if (strlen($private) < $length) {
|
||||
return false;
|
||||
}
|
||||
$components['primes'] = [1 => new BigInteger(Strings::shift($private, $length), -256)];
|
||||
extract(unpack('Nlength', Strings::shift($private, 4)));
|
||||
if (strlen($private) < $length) {
|
||||
return false;
|
||||
}
|
||||
$components['primes'][] = new BigInteger(Strings::shift($private, $length), -256);
|
||||
|
||||
$temp = $components['primes'][1]->subtract($one);
|
||||
$components['exponents'] = [1 => $components['publicExponent']->modInverse($temp)];
|
||||
$temp = $components['primes'][2]->subtract($one);
|
||||
$components['exponents'][] = $components['publicExponent']->modInverse($temp);
|
||||
|
||||
extract(unpack('Nlength', Strings::shift($private, 4)));
|
||||
if (strlen($private) < $length) {
|
||||
return false;
|
||||
}
|
||||
$components['coefficients'] = [2 => new BigInteger(Strings::shift($private, $length), -256)];
|
||||
|
||||
return $components;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a private key to the appropriate format.
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $n
|
||||
* @param \phpseclib\Math\BigInteger $e
|
||||
* @param \phpseclib\Math\BigInteger $d
|
||||
* @param array $primes
|
||||
* @param array $exponents
|
||||
* @param array $coefficients
|
||||
* @param string $password optional
|
||||
* @return string
|
||||
*/
|
||||
public static function savePrivateKey(BigInteger $n, BigInteger $e, BigInteger $d, $primes, $exponents, $coefficients, $password = '')
|
||||
{
|
||||
if (count($primes) != 2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$raw = [
|
||||
'modulus' => $n->toBytes(true),
|
||||
'publicExponent' => $e->toBytes(true),
|
||||
'privateExponent' => $d->toBytes(true),
|
||||
'prime1' => $primes[1]->toBytes(true),
|
||||
'prime2' => $primes[2]->toBytes(true),
|
||||
'exponent1' => $exponents[1]->toBytes(true),
|
||||
'exponent2' => $exponents[2]->toBytes(true),
|
||||
'coefficient' => $coefficients[2]->toBytes(true)
|
||||
];
|
||||
|
||||
$key = "PuTTY-User-Key-File-2: ssh-rsa\r\nEncryption: ";
|
||||
$encryption = (!empty($password) || is_string($password)) ? 'aes256-cbc' : 'none';
|
||||
$key.= $encryption;
|
||||
$key.= "\r\nComment: " . self::$comment . "\r\n";
|
||||
$public = pack(
|
||||
'Na*Na*Na*',
|
||||
strlen('ssh-rsa'),
|
||||
'ssh-rsa',
|
||||
strlen($raw['publicExponent']),
|
||||
$raw['publicExponent'],
|
||||
strlen($raw['modulus']),
|
||||
$raw['modulus']
|
||||
);
|
||||
$source = pack(
|
||||
'Na*Na*Na*Na*',
|
||||
strlen('ssh-rsa'),
|
||||
'ssh-rsa',
|
||||
strlen($encryption),
|
||||
$encryption,
|
||||
strlen(self::$comment),
|
||||
self::$comment,
|
||||
strlen($public),
|
||||
$public
|
||||
);
|
||||
$public = Base64::encode($public);
|
||||
$key.= "Public-Lines: " . ((strlen($public) + 63) >> 6) . "\r\n";
|
||||
$key.= chunk_split($public, 64);
|
||||
$private = pack(
|
||||
'Na*Na*Na*Na*',
|
||||
strlen($raw['privateExponent']),
|
||||
$raw['privateExponent'],
|
||||
strlen($raw['prime1']),
|
||||
$raw['prime1'],
|
||||
strlen($raw['prime2']),
|
||||
$raw['prime2'],
|
||||
strlen($raw['coefficient']),
|
||||
$raw['coefficient']
|
||||
);
|
||||
if (empty($password) && !is_string($password)) {
|
||||
$source.= pack('Na*', strlen($private), $private);
|
||||
$hashkey = 'putty-private-key-file-mac-key';
|
||||
} else {
|
||||
$private.= Random::string(16 - (strlen($private) & 15));
|
||||
$source.= pack('Na*', strlen($private), $private);
|
||||
$crypto = new AES();
|
||||
|
||||
$crypto->setKey(static::generateSymmetricKey($password, 32));
|
||||
$crypto->setIV(str_repeat("\0", $crypto->getBlockLength() >> 3));
|
||||
$crypto->disablePadding();
|
||||
$private = $crypto->encrypt($private);
|
||||
$hashkey = 'putty-private-key-file-mac-key' . $password;
|
||||
}
|
||||
|
||||
$private = Base64::encode($private);
|
||||
$key.= 'Private-Lines: ' . ((strlen($private) + 63) >> 6) . "\r\n";
|
||||
$key.= chunk_split($private, 64);
|
||||
$hash = new Hash('sha1');
|
||||
$hash->setKey(sha1($hashkey, true));
|
||||
$key.= 'Private-MAC: ' . Hex::encode($hash->hash($source)) . "\r\n";
|
||||
|
||||
return $key;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a public key to the appropriate format
|
||||
*
|
||||
* @access public
|
||||
* @param \phpseclib\Math\BigInteger $n
|
||||
* @param \phpseclib\Math\BigInteger $e
|
||||
* @return string
|
||||
*/
|
||||
public static function savePublicKey(BigInteger $n, BigInteger $e)
|
||||
{
|
||||
$n = $n->toBytes(true);
|
||||
$e = $e->toBytes(true);
|
||||
|
||||
$key = pack(
|
||||
'Na*Na*Na*',
|
||||
strlen('ssh-rsa'),
|
||||
'ssh-rsa',
|
||||
strlen($e),
|
||||
$e,
|
||||
strlen($n),
|
||||
$n
|
||||
);
|
||||
$key = "---- BEGIN SSH2 PUBLIC KEY ----\r\n" .
|
||||
'Comment: "' . str_replace(['\\', '"'], ['\\\\', '\"'], self::$comment) . "\"\r\n" .
|
||||
chunk_split(Base64::encode($key), 64) .
|
||||
'---- END SSH2 PUBLIC KEY ----';
|
||||
|
||||
return $key;
|
||||
}
|
||||
}
|
@ -1151,7 +1151,7 @@ abstract class ASN1
|
||||
http://www.obj-sys.com/asn1tutorial/node14.html */
|
||||
|
||||
$pattern = $tag == self::TYPE_UTC_TIME ?
|
||||
'#(..)(..)(..)(..)(..)(..)(.*)#' :
|
||||
'#^(..)(..)(..)(..)(..)(..)?(.*)$#' :
|
||||
'#(....)(..)(..)(..)(..)(..).*([Z+-].*)$#';
|
||||
|
||||
preg_match($pattern, $content, $matches);
|
||||
@ -1176,7 +1176,7 @@ abstract class ASN1
|
||||
$timezone = 0;
|
||||
}
|
||||
|
||||
return @$mktime($hour, $minute, $second, $month, $day, $year) + $timezone;
|
||||
return @$mktime((int)$hour, (int)$minute, (int)$second, (int)$month, (int)$day, (int)$year) + $timezone;
|
||||
}
|
||||
|
||||
/**
|
||||
|
37
phpseclib/File/ASN1/Maps/DSAParams.php
Normal file
37
phpseclib/File/ASN1/Maps/DSAParams.php
Normal file
@ -0,0 +1,37 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* DSAParams
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category File
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\File\ASN1\Maps;
|
||||
|
||||
use phpseclib\File\ASN1;
|
||||
|
||||
/**
|
||||
* DSAParams
|
||||
*
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DSAParams
|
||||
{
|
||||
const MAP = [
|
||||
'type' => ASN1::TYPE_SEQUENCE,
|
||||
'children' => [
|
||||
'p' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'q' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'g' => ['type' => ASN1::TYPE_INTEGER]
|
||||
]
|
||||
];
|
||||
}
|
40
phpseclib/File/ASN1/Maps/DSAPrivateKey.php
Normal file
40
phpseclib/File/ASN1/Maps/DSAPrivateKey.php
Normal file
@ -0,0 +1,40 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* DSAPrivateKey
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category File
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\File\ASN1\Maps;
|
||||
|
||||
use phpseclib\File\ASN1;
|
||||
|
||||
/**
|
||||
* DSAPrivateKey
|
||||
*
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DSAPrivateKey
|
||||
{
|
||||
const MAP = [
|
||||
'type' => ASN1::TYPE_SEQUENCE,
|
||||
'children' => [
|
||||
'version' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'p' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'q' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'g' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'y' => ['type' => ASN1::TYPE_INTEGER],
|
||||
'x' => ['type' => ASN1::TYPE_INTEGER]
|
||||
]
|
||||
];
|
||||
}
|
30
phpseclib/File/ASN1/Maps/DSAPublicKey.php
Normal file
30
phpseclib/File/ASN1/Maps/DSAPublicKey.php
Normal file
@ -0,0 +1,30 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* DSAPublicKey
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category File
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\File\ASN1\Maps;
|
||||
|
||||
use phpseclib\File\ASN1;
|
||||
|
||||
/**
|
||||
* DSAPublicKey
|
||||
*
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DSAPublicKey
|
||||
{
|
||||
const MAP = ['type' => ASN1::TYPE_INTEGER];
|
||||
}
|
36
phpseclib/File/ASN1/Maps/DssSigValue.php
Normal file
36
phpseclib/File/ASN1/Maps/DssSigValue.php
Normal file
@ -0,0 +1,36 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* DssSigValue
|
||||
*
|
||||
* PHP version 5
|
||||
*
|
||||
* @category File
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2016 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
* @link http://phpseclib.sourceforge.net
|
||||
*/
|
||||
|
||||
namespace phpseclib\File\ASN1\Maps;
|
||||
|
||||
use phpseclib\File\ASN1;
|
||||
|
||||
/**
|
||||
* DssSigValue
|
||||
*
|
||||
* @package ASN1
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @access public
|
||||
*/
|
||||
abstract class DssSigValue
|
||||
{
|
||||
const MAP = [
|
||||
'type' => ASN1::TYPE_SEQUENCE,
|
||||
'children' => [
|
||||
'r' => ['type' => ASN1::TYPE_INTEGER],
|
||||
's' => ['type' => ASN1::TYPE_INTEGER]
|
||||
]
|
||||
];
|
||||
}
|
@ -26,7 +26,6 @@ use phpseclib\File\ASN1;
|
||||
*/
|
||||
abstract class RSAPublicKey
|
||||
{
|
||||
// version must be multi if otherPrimeInfos present
|
||||
const MAP = [
|
||||
'type' => ASN1::TYPE_SEQUENCE,
|
||||
'children' => [
|
||||
|
@ -1686,7 +1686,7 @@ class X509
|
||||
$value = array_pop($value); // Always strip data type.
|
||||
}
|
||||
} elseif (is_object($value) && $value instanceof Element) {
|
||||
$callback = create_function('$x', 'return "\x" . bin2hex($x[0]);');
|
||||
$callback = function($x) { return '\x' . bin2hex($x[0]); };
|
||||
$value = strtoupper(preg_replace_callback('#[^\x20-\x7E]#', $callback, $value->element));
|
||||
}
|
||||
$output.= $desc . '=' . $value;
|
||||
@ -2418,7 +2418,7 @@ class X509
|
||||
$altName = [];
|
||||
|
||||
if (isset($subject->domains) && count($subject->domains) > 1) {
|
||||
$altName = array_map(['X509', '_dnsName'], $subject->domains);
|
||||
$altName = array_map(['\phpseclib\File\X509', 'dnsName'], $subject->domains);
|
||||
}
|
||||
|
||||
if (isset($subject->ipAddresses) && count($subject->ipAddresses)) {
|
||||
|
@ -3867,4 +3867,17 @@ class BigInteger
|
||||
{
|
||||
return strlen($this->toBytes());
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests BigInteger to see if it is between two integers, inclusive
|
||||
*
|
||||
* @param \phpseclib\Math\BigInteger $min
|
||||
* @param \phpseclib\Math\BigInteger $max
|
||||
* @access public
|
||||
* @return boolean
|
||||
*/
|
||||
function between(BigInteger $min, BigInteger $max)
|
||||
{
|
||||
return $this->compare($min) >= 0 && $this->compare($max) <= 0;
|
||||
}
|
||||
}
|
||||
|
@ -1907,7 +1907,14 @@ class SFTP extends SSH2
|
||||
break;
|
||||
case is_resource($data):
|
||||
$mode = $mode & ~self::SOURCE_LOCAL_FILE;
|
||||
$fp = $data;
|
||||
$info = stream_get_meta_data($data);
|
||||
if ($info['wrapper_type'] == 'PHP' && $info['stream_type'] == 'Input') {
|
||||
$fp = fopen('php://memory', 'w+');
|
||||
stream_copy_to_stream($data, $fp);
|
||||
rewind($fp);
|
||||
} else {
|
||||
$fp = $data;
|
||||
}
|
||||
break;
|
||||
case $mode & self::SOURCE_LOCAL_FILE:
|
||||
if (!is_file($data)) {
|
||||
|
@ -3873,10 +3873,9 @@ class SSH2
|
||||
switch (NET_SSH2_LOGGING) {
|
||||
case self::LOG_SIMPLE:
|
||||
return $this->message_number_log;
|
||||
break;
|
||||
case self::LOG_COMPLEX:
|
||||
return $this->format_log($this->message_log, $this->message_number_log);
|
||||
break;
|
||||
$log = $this->_format_log($this->message_log, $this->message_number_log);
|
||||
return PHP_SAPI == 'cli' ? $log : '<pre>' . $log . '</pre>';
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
50
tests/Unit/Crypt/DSA/CreateKeyTest.php
Normal file
50
tests/Unit/Crypt/DSA/CreateKeyTest.php
Normal file
@ -0,0 +1,50 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use phpseclib\Crypt\DSA;
|
||||
|
||||
/**
|
||||
* @requires PHP 7.0
|
||||
*/
|
||||
class Unit_Crypt_DSA_CreateKeyTest extends PhpseclibTestCase
|
||||
{
|
||||
public function testCreateParameters()
|
||||
{
|
||||
$dsa = DSA::createParameters();
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $dsa);
|
||||
$this->assertRegexp('#BEGIN DSA PARAMETERS#', "$dsa");
|
||||
|
||||
$dsa = DSA::createParameters(100, 100);
|
||||
$this->assertFalse($dsa);
|
||||
|
||||
$dsa = DSA::createParameters(512, 160);
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $dsa);
|
||||
$this->assertRegexp('#BEGIN DSA PARAMETERS#', "$dsa");
|
||||
|
||||
return $dsa;
|
||||
}
|
||||
|
||||
/**
|
||||
* @depends testCreateParameters
|
||||
*/
|
||||
public function testCreateKey($params)
|
||||
{
|
||||
extract(DSA::createKey());
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $privatekey);
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $publickey);
|
||||
|
||||
extract(DSA::createKey($params));
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $privatekey);
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $publickey);
|
||||
|
||||
extract(DSA::createKey(512, 160));
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $privatekey);
|
||||
$this->assertInstanceOf('\phpseclib\Crypt\DSA', $publickey);
|
||||
}
|
||||
}
|
||||
|
233
tests/Unit/Crypt/DSA/LoadKeyTest.php
Normal file
233
tests/Unit/Crypt/DSA/LoadKeyTest.php
Normal file
@ -0,0 +1,233 @@
|
||||
<?php
|
||||
/**
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2013 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use phpseclib\Crypt\DSA;
|
||||
use phpseclib\Crypt\DSA\Keys\PKCS1;
|
||||
use phpseclib\Crypt\DSA\Keys\PKCS8;
|
||||
use phpseclib\Crypt\DSA\Keys\PuTTY;
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
||||
class Unit_Crypt_DSA_LoadKeyTest extends PhpseclibTestCase
|
||||
{
|
||||
public function testBadKey()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = 'zzzzzzzzzzzzzz';
|
||||
|
||||
$this->assertFalse($dsa->load($key));
|
||||
}
|
||||
public function testPuTTYKey()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = 'PuTTY-User-Key-File-2: ssh-dss
|
||||
Encryption: none
|
||||
Comment: dsa-key-20161223
|
||||
Public-Lines: 18
|
||||
AAAAB3NzaC1kc3MAAAEBAIsH1A8S7goEEneW6D/zJXh1zypZRlKlw7vNaJ7yXi9v
|
||||
qUkKnTSXK9lR4/nYy4SVTcVApY0sEU2RSDridLTy40ZeMPArH+sxR7lCSZ2AuNq9
|
||||
sQxu6VtYg1LKGekKYWC+r4TrZoTz2PUyrUd6sYBsYIX4ozbH2ITgYmYL9ONCrLbt
|
||||
4KsKO2EUE3xN3RHv8CkAp5BraCMw5z4vC43t0bcW63RN2mEvqWOqBFx5qe7uck4j
|
||||
pH7AvLyvwEye7t5KwJ8P1SMN72u4AWqyXqzLK3Ye0B7hQSFnbz0od4ps3EN+Irsu
|
||||
Kf20nkGgHKYJwenpIQwHz3xhBhtgiYCdQXb3ril1kd8AAAAVAJmhajsmmqwQqNkd
|
||||
k4JSJ/Y1SE11AAABADYHKKmAZ0OvCZ58m5CGPfuoX4h4nc5L0p3e0Sozcc9cJ5h3
|
||||
PvD18ggAf4cLoTpxETnXTFg+30shpKbr2WsE0Jrswe6V2bMaP7Hil6q3WWahLZx6
|
||||
9bEClnYCTlJkungzFjJmW+M7yd8xBHCBM6r83FKlLJjolJhHDL5DqX/uHP/9H0sl
|
||||
wncwALro1jTo3JU5oRdzMuLWf9P2MB7sEsoeWk2BOiil1BtKnItuObJgXUCCuaWB
|
||||
dPJyk4ZVMZZqr+vCnjocRrlQUwlMUG73Ze6KJKM1OgOKMt4PwaqD9oUaKq/gc+Eb
|
||||
UtCwVR6TEeIEkmazguvbAb6dSJ18TMZ07H6DJngAAAEAYE/7gKVb8P23zYzcfYOv
|
||||
3zG713/i/LAJ+dW3lQupyWkUnE8wDIht7DwKgcA/Vs73jG7SlqPjcMrNzBHjQE+y
|
||||
FVCP4xO+wDsh2wZ+KVppVkMljfGpp/0mQ0mQbrmTkaCNZc0ogXwtaI4r7Su2cCq0
|
||||
HMwrFJFFXXLaTZY49+lkrtP6q8WFOYJGK3WnrWvXyOe9Xnh2o8E1dQJ0RnshdOft
|
||||
j1KZ4JhOHnGKoz8+sKuchGVhs5VaMbJUur3cC8INaeKvtrEpwW/Ety5iy1iPyps9
|
||||
S9PlwN0KyVFGWdP2B4Gyj85IXCm3r+JNVoV5tVX9IUBTXnUor7YfWNncwWn56Lc+
|
||||
RQ==
|
||||
Private-Lines: 1
|
||||
AAAAFFMy7BG9rPXwzqZzIY/lqsHEILNf
|
||||
Private-MAC: 62b92ddd8b341b9414d640c24ba6ae929a78e039
|
||||
';
|
||||
|
||||
$dsa->setPrivateKeyFormat('PuTTY');
|
||||
$dsa->setPublicKeyFormat('PuTTY');
|
||||
|
||||
$this->assertTrue($dsa->load($key));
|
||||
$this->assertInternalType('string', "$dsa");
|
||||
$this->assertSame("$dsa", $dsa->getPrivateKey('PuTTY'));
|
||||
$this->assertInternalType('string', $dsa->getPublicKey('PuTTY'));
|
||||
$this->assertInternalType('string', $dsa->getParameters());
|
||||
|
||||
$dsa->setPassword('password');
|
||||
$this->assertGreaterThan(0, strlen("$dsa"));
|
||||
}
|
||||
|
||||
public function testPKCS1Key()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = '-----BEGIN DSA PRIVATE KEY-----
|
||||
MIIDPQIBAAKCAQEAiwfUDxLuCgQSd5boP/MleHXPKllGUqXDu81onvJeL2+pSQqd
|
||||
NJcr2VHj+djLhJVNxUCljSwRTZFIOuJ0tPLjRl4w8Csf6zFHuUJJnYC42r2xDG7p
|
||||
W1iDUsoZ6QphYL6vhOtmhPPY9TKtR3qxgGxghfijNsfYhOBiZgv040Kstu3gqwo7
|
||||
YRQTfE3dEe/wKQCnkGtoIzDnPi8Lje3RtxbrdE3aYS+pY6oEXHmp7u5yTiOkfsC8
|
||||
vK/ATJ7u3krAnw/VIw3va7gBarJerMsrdh7QHuFBIWdvPSh3imzcQ34iuy4p/bSe
|
||||
QaAcpgnB6ekhDAfPfGEGG2CJgJ1BdveuKXWR3wIVAJmhajsmmqwQqNkdk4JSJ/Y1
|
||||
SE11AoIBADYHKKmAZ0OvCZ58m5CGPfuoX4h4nc5L0p3e0Sozcc9cJ5h3PvD18ggA
|
||||
f4cLoTpxETnXTFg+30shpKbr2WsE0Jrswe6V2bMaP7Hil6q3WWahLZx69bEClnYC
|
||||
TlJkungzFjJmW+M7yd8xBHCBM6r83FKlLJjolJhHDL5DqX/uHP/9H0slwncwALro
|
||||
1jTo3JU5oRdzMuLWf9P2MB7sEsoeWk2BOiil1BtKnItuObJgXUCCuaWBdPJyk4ZV
|
||||
MZZqr+vCnjocRrlQUwlMUG73Ze6KJKM1OgOKMt4PwaqD9oUaKq/gc+EbUtCwVR6T
|
||||
EeIEkmazguvbAb6dSJ18TMZ07H6DJngCggEAYE/7gKVb8P23zYzcfYOv3zG713/i
|
||||
/LAJ+dW3lQupyWkUnE8wDIht7DwKgcA/Vs73jG7SlqPjcMrNzBHjQE+yFVCP4xO+
|
||||
wDsh2wZ+KVppVkMljfGpp/0mQ0mQbrmTkaCNZc0ogXwtaI4r7Su2cCq0HMwrFJFF
|
||||
XXLaTZY49+lkrtP6q8WFOYJGK3WnrWvXyOe9Xnh2o8E1dQJ0RnshdOftj1KZ4JhO
|
||||
HnGKoz8+sKuchGVhs5VaMbJUur3cC8INaeKvtrEpwW/Ety5iy1iPyps9S9PlwN0K
|
||||
yVFGWdP2B4Gyj85IXCm3r+JNVoV5tVX9IUBTXnUor7YfWNncwWn56Lc+RQIUUzLs
|
||||
Eb2s9fDOpnMhj+WqwcQgs18=
|
||||
-----END DSA PRIVATE KEY-----';
|
||||
|
||||
$dsa->setPrivateKeyFormat('PKCS1');
|
||||
$dsa->setPublicKeyFormat('PKCS1');
|
||||
|
||||
$this->assertTrue($dsa->load($key));
|
||||
$this->assertInternalType('string', "$dsa");
|
||||
$this->assertSame("$dsa", $dsa->getPrivateKey('PKCS1'));
|
||||
$this->assertInternalType('string', $dsa->getPublicKey('PKCS1'));
|
||||
$this->assertInternalType('string', $dsa->getParameters());
|
||||
}
|
||||
|
||||
public function testParameters()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = '-----BEGIN DSA PARAMETERS-----
|
||||
MIIBHgKBgQDandMycPZNOEwDXpIDSdFODWOQVO5tlnt38wK0X33TJh4wQdqOSiVF
|
||||
I+g+X8reP43ag3TEHu5bstrk6Znm7y1htTTvXQVTEwp6X3YHXbJG4Faul3g08Vud
|
||||
3gzV841wToVCMUinl0EOxMYP/CO9/Kvf66KACtqWITzJYBpwAeUKfwIVAM8e3xO8
|
||||
aityXVRiQRWeZtOI1yq9AoGAbmA+RzIZrtPx1mC5KzrpwgwgNHbbQBT83qeNKjEh
|
||||
N+S6A47iI5OVvpxd/ZwjdXoYo7D6RxR+3LNcT64DyYrBEZuzQzHeifaO6lBvDSNf
|
||||
L1cwyXx0KMaaampd34MzOIHbC44SHY+cE3aVVUsnmt6Ur1nQaVYVszl+AO6m8bPm
|
||||
4Vg=
|
||||
-----END DSA PARAMETERS-----';
|
||||
$key = str_replace(["\n", "\r"], '', $key);
|
||||
|
||||
$this->assertTrue($dsa->load($key));
|
||||
$this->assertSame($key, str_replace(["\n", "\r"], '', "$dsa"));
|
||||
$this->assertSame($key, str_replace(["\n", "\r"], '', $dsa->getParameters()));
|
||||
}
|
||||
|
||||
public function testPKCS8Public()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = '-----BEGIN PUBLIC KEY-----
|
||||
MIIBtjCCASsGByqGSM44BAEwggEeAoGBANqd0zJw9k04TANekgNJ0U4NY5BU7m2W
|
||||
e3fzArRffdMmHjBB2o5KJUUj6D5fyt4/jdqDdMQe7luy2uTpmebvLWG1NO9dBVMT
|
||||
CnpfdgddskbgVq6XeDTxW53eDNXzjXBOhUIxSKeXQQ7Exg/8I738q9/rooAK2pYh
|
||||
PMlgGnAB5Qp/AhUAzx7fE7xqK3JdVGJBFZ5m04jXKr0CgYBuYD5HMhmu0/HWYLkr
|
||||
OunCDCA0dttAFPzep40qMSE35LoDjuIjk5W+nF39nCN1ehijsPpHFH7cs1xPrgPJ
|
||||
isERm7NDMd6J9o7qUG8NI18vVzDJfHQoxppqal3fgzM4gdsLjhIdj5wTdpVVSyea
|
||||
3pSvWdBpVhWzOX4A7qbxs+bhWAOBhAACgYBTpSKcKoVKw+hglVClqvqQdNKGC4a+
|
||||
XC4lOh2221ZrTgy/sN92vT7cdBn4ydHoth6/bD236L/FYfiX4S4mOczPhrv/l/2u
|
||||
ZpmyOpXM/0opRMIRdmqVW4ardBFNokmlqngwcbaptfRnk9W2cQtx0lmKy6X/vnis
|
||||
3AElwP86TYgBhw==
|
||||
-----END PUBLIC KEY-----';
|
||||
|
||||
$this->assertTrue($dsa->load($key));
|
||||
$this->assertInternalType('string', "$dsa");
|
||||
}
|
||||
|
||||
public function testPKCS8Private()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = '-----BEGIN PRIVATE KEY-----
|
||||
MIIBSgIBADCCASsGByqGSM44BAEwggEeAoGBANqd0zJw9k04TANekgNJ0U4NY5BU
|
||||
7m2We3fzArRffdMmHjBB2o5KJUUj6D5fyt4/jdqDdMQe7luy2uTpmebvLWG1NO9d
|
||||
BVMTCnpfdgddskbgVq6XeDTxW53eDNXzjXBOhUIxSKeXQQ7Exg/8I738q9/rooAK
|
||||
2pYhPMlgGnAB5Qp/AhUAzx7fE7xqK3JdVGJBFZ5m04jXKr0CgYBuYD5HMhmu0/HW
|
||||
YLkrOunCDCA0dttAFPzep40qMSE35LoDjuIjk5W+nF39nCN1ehijsPpHFH7cs1xP
|
||||
rgPJisERm7NDMd6J9o7qUG8NI18vVzDJfHQoxppqal3fgzM4gdsLjhIdj5wTdpVV
|
||||
Syea3pSvWdBpVhWzOX4A7qbxs+bhWAQWAhQiF7sFfCtZ7oOgCb2aJ9ySC9sTug==
|
||||
-----END PRIVATE KEY-----';
|
||||
|
||||
$this->assertTrue($dsa->load($key));
|
||||
$this->assertInternalType('string', "$dsa");
|
||||
$this->assertSame("$dsa", $dsa->getPrivateKey());
|
||||
$this->assertInternalType('string', $dsa->getPublicKey());
|
||||
$this->assertInternalType('string', $dsa->getParameters());
|
||||
}
|
||||
|
||||
/**
|
||||
* @expectedException \UnexpectedValueException
|
||||
*/
|
||||
public function testPuTTYBadMAC()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = 'PuTTY-User-Key-File-2: ssh-dss
|
||||
Encryption: none
|
||||
Comment: dsa-key-20161223
|
||||
Public-Lines: 18
|
||||
AAAAB3NzaC1kc3MAAAEBAIsH1A8S7goEEneW6D/zJXh1zypZRlKlw7vNaJ7yXi9v
|
||||
qUkKnTSXK9lR4/nYy4SVTcVApY0sEU2RSDridLTy40ZeMPArH+sxR7lCSZ2AuNq9
|
||||
sQxu6VtYg1LKGekKYWC+r4TrZoTz2PUyrUd6sYBsYIX4ozbH2ITgYmYL9ONCrLbt
|
||||
4KsKO2EUE3xN3RHv8CkAp5BraCMw5z4vC43t0bcW63RN2mEvqWOqBFx5qe7uck4j
|
||||
pH7AvLyvwEye7t5KwJ8P1SMN72u4AWqyXqzLK3Ye0B7hQSFnbz0od4ps3EN+Irsu
|
||||
Kf20nkGgHKYJwenpIQwHz3xhBhtgiYCdQXb3ril1kd8AAAAVAJmhajsmmqwQqNkd
|
||||
k4JSJ/Y1SE11AAABADYHKKmAZ0OvCZ58m5CGPfuoX4h4nc5L0p3e0Sozcc9cJ5h3
|
||||
PvD18ggAf4cLoTpxETnXTFg+30shpKbr2WsE0Jrswe6V2bMaP7Hil6q3WWahLZx6
|
||||
9bEClnYCTlJkungzFjJmW+M7yd8xBHCBM6r83FKlLJjolJhHDL5DqX/uHP/9H0sl
|
||||
wncwALro1jTo3JU5oRdzMuLWf9P2MB7sEsoeWk2BOiil1BtKnItuObJgXUCCuaWB
|
||||
dPJyk4ZVMZZqr+vCnjocRrlQUwlMUG73Ze6KJKM1OgOKMt4PwaqD9oUaKq/gc+Eb
|
||||
UtCwVR6TEeIEkmazguvbAb6dSJ18TMZ07H6DJngAAAEAYE/7gKVb8P23zYzcfYOv
|
||||
3zG713/i/LAJ+dW3lQupyWkUnE8wDIht7DwKgcA/Vs73jG7SlqPjcMrNzBHjQE+y
|
||||
FVCP4xO+wDsh2wZ+KVppVkMljfGpp/0mQ0mQbrmTkaCNZc0ogXwtaI4r7Su2cCq0
|
||||
HMwrFJFFXXLaTZY49+lkrtP6q8WFOYJGK3WnrWvXyOe9Xnh2o8E1dQJ0RnshdOft
|
||||
j1KZ4JhOHnGKoz8+sKuchGVhs5VaMbJUur3cC8INaeKvtrEpwW/Ety5iy1iPyps9
|
||||
S9PlwN0KyVFGWdP2B4Gyj85IXCm3r+JNVoV5tVX9IUBTXnUor7YfWNncwWn56Lc+
|
||||
RQ==
|
||||
Private-Lines: 1
|
||||
AAAAFFMy7BG9rPXwzqZzIY/lqsHEILNf
|
||||
Private-MAC: aaaaaadd8b341b9414d640c24ba6ae929a78e039
|
||||
';
|
||||
|
||||
$this->assertFalse($dsa->load($key));
|
||||
$dsa->load($key, 'PuTTY');
|
||||
}
|
||||
|
||||
public function testXML()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
|
||||
$key = '-----BEGIN PUBLIC KEY-----
|
||||
MIIBtjCCASsGByqGSM44BAEwggEeAoGBANqd0zJw9k04TANekgNJ0U4NY5BU7m2W
|
||||
e3fzArRffdMmHjBB2o5KJUUj6D5fyt4/jdqDdMQe7luy2uTpmebvLWG1NO9dBVMT
|
||||
CnpfdgddskbgVq6XeDTxW53eDNXzjXBOhUIxSKeXQQ7Exg/8I738q9/rooAK2pYh
|
||||
PMlgGnAB5Qp/AhUAzx7fE7xqK3JdVGJBFZ5m04jXKr0CgYBuYD5HMhmu0/HWYLkr
|
||||
OunCDCA0dttAFPzep40qMSE35LoDjuIjk5W+nF39nCN1ehijsPpHFH7cs1xPrgPJ
|
||||
isERm7NDMd6J9o7qUG8NI18vVzDJfHQoxppqal3fgzM4gdsLjhIdj5wTdpVVSyea
|
||||
3pSvWdBpVhWzOX4A7qbxs+bhWAOBhAACgYBTpSKcKoVKw+hglVClqvqQdNKGC4a+
|
||||
XC4lOh2221ZrTgy/sN92vT7cdBn4ydHoth6/bD236L/FYfiX4S4mOczPhrv/l/2u
|
||||
ZpmyOpXM/0opRMIRdmqVW4ardBFNokmlqngwcbaptfRnk9W2cQtx0lmKy6X/vnis
|
||||
3AElwP86TYgBhw==
|
||||
-----END PUBLIC KEY-----';
|
||||
|
||||
$dsa->load($key);
|
||||
$xml = $dsa->getPublicKey('XML');
|
||||
$this->assertContains('DSAKeyValue', $xml);
|
||||
|
||||
$dsa = new DSA();
|
||||
$dsa->load($xml);
|
||||
$pkcs8 = $dsa->getPublicKey('PKCS8');
|
||||
|
||||
$this->assertSame(
|
||||
strtolower(preg_replace('#\s#', '', $pkcs8)),
|
||||
strtolower(preg_replace('#\s#', '', $key))
|
||||
);
|
||||
}
|
||||
}
|
115
tests/Unit/Crypt/DSA/SignatureTest.php
Normal file
115
tests/Unit/Crypt/DSA/SignatureTest.php
Normal file
@ -0,0 +1,115 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @author Jim Wigginton <terrafrost@php.net>
|
||||
* @copyright 2015 Jim Wigginton
|
||||
* @license http://www.opensource.org/licenses/mit-license.html MIT License
|
||||
*/
|
||||
|
||||
use phpseclib\Crypt\DSA;
|
||||
|
||||
class Unit_Crypt_DSA_SignatureTest extends PhpseclibTestCase
|
||||
{
|
||||
public function testPKCSSignature()
|
||||
{
|
||||
$message = 'hello, world!';
|
||||
|
||||
$dsa = new DSA();
|
||||
|
||||
$dsa->load('-----BEGIN DSA PRIVATE KEY-----
|
||||
MIIBvAIBAAKBgQDsGAHAM16bsPlwl7jaec4QMynYa0YLiLiOZC4mvH4UW/tRJxTz
|
||||
aV7eH1EtnP9D9J78x/07wKYs8zJEWCXmuq0UluQfjA47+pb68b/ucQTNeZHboNN9
|
||||
5oEi+8BCSK0y8G3uf3Y89qHvqa9Si6rP374MinEMrbVFm+UpsGflFcd83wIVALtJ
|
||||
ANi+lYG7xMKQ/bE4+bS8gemNAoGBAORowvirD7AB9x2SpdiME41+O4jVR8rs6+GX
|
||||
Ml3Hif6Yt1kem0CeraX9SNoyBNAzjD5TVMGIdGlgRr6GNreHeXMGWlvdDkvCACER
|
||||
ZEEtMsKZicm+yl6kR8AGHTCA/PBltHfyrFQd4n9I//UDqI4RjqzvpCXGQcVEsSDY
|
||||
CCBGBQJRAoGBALnHTAZlpoLJZuSBVtnMuRM3cSX43IkE9w9FveDV1jX5mmfK7yBV
|
||||
pQFV8eVJfk91ERQ4Dn6ePLUv2dRIt4a0S0qHqadgzyoFyqkmmUi1kNLyixtRqh+m
|
||||
2gXx0t63HEpZDbEPppdpnlppZquVQh7TyrKSXW9MTzUkQjFI9UY7kZeKAhQXiJgI
|
||||
kBniZHdFBAZBTE14YJUBkw==
|
||||
-----END DSA PRIVATE KEY-----');
|
||||
$signature = $dsa->sign($message, 'PKCS');
|
||||
|
||||
$dsa->load('-----BEGIN PUBLIC KEY-----
|
||||
MIIBuDCCASwGByqGSM44BAEwggEfAoGBAOwYAcAzXpuw+XCXuNp5zhAzKdhrRguI
|
||||
uI5kLia8fhRb+1EnFPNpXt4fUS2c/0P0nvzH/TvApizzMkRYJea6rRSW5B+MDjv6
|
||||
lvrxv+5xBM15kdug033mgSL7wEJIrTLwbe5/djz2oe+pr1KLqs/fvgyKcQyttUWb
|
||||
5SmwZ+UVx3zfAhUAu0kA2L6VgbvEwpD9sTj5tLyB6Y0CgYEA5GjC+KsPsAH3HZKl
|
||||
2IwTjX47iNVHyuzr4ZcyXceJ/pi3WR6bQJ6tpf1I2jIE0DOMPlNUwYh0aWBGvoY2
|
||||
t4d5cwZaW90OS8IAIRFkQS0ywpmJyb7KXqRHwAYdMID88GW0d/KsVB3if0j/9QOo
|
||||
jhGOrO+kJcZBxUSxINgIIEYFAlEDgYUAAoGBALnHTAZlpoLJZuSBVtnMuRM3cSX4
|
||||
3IkE9w9FveDV1jX5mmfK7yBVpQFV8eVJfk91ERQ4Dn6ePLUv2dRIt4a0S0qHqadg
|
||||
zyoFyqkmmUi1kNLyixtRqh+m2gXx0t63HEpZDbEPppdpnlppZquVQh7TyrKSXW9M
|
||||
TzUkQjFI9UY7kZeK
|
||||
-----END PUBLIC KEY-----');
|
||||
|
||||
$this->assertTrue($dsa->verify($message, $signature, 'PKCS'));
|
||||
$this->assertFalse($dsa->verify('foozbar', $signature, 'PKCS'));
|
||||
|
||||
// openssl dgst -dss1 -sign dsa_priv.pem foo.txt > sigfile.bin
|
||||
$signature = '302c021456d7e7da10d1538a6cd45dcb2b0ce15c28bac03402147e973a4de1e92e8a87ed5218c797952a3f854df5';
|
||||
$signature = pack('H*', $signature);
|
||||
|
||||
$dsa->setHash('sha1');
|
||||
|
||||
$this->assertTrue($dsa->verify("foobar\n", $signature, 'PKCS'));
|
||||
$this->assertFalse($dsa->verify('foozbar', $signature, 'PKCS'));
|
||||
|
||||
// openssl dgst -sha256 -sign dsa_priv.pem foo.txt > sigfile.bin
|
||||
$signature = '302e021500b131ec2682c4c0be13e6558ba3d64929ebc0ac420215009946300a03561cef50c0a51d0cd0a2c835e798fc';
|
||||
$signature = pack('H*', $signature);
|
||||
|
||||
$dsa->setHash('sha256');
|
||||
|
||||
$this->assertTrue($dsa->verify('abcdefghijklmnopqrstuvwxyz', $signature, 'PKCS'));
|
||||
$this->assertFalse($dsa->verify('zzzz', $signature, 'PKCS'));
|
||||
}
|
||||
|
||||
public function testRandomSignature()
|
||||
{
|
||||
$message = 'hello, world!';
|
||||
|
||||
$dsa = new DSA();
|
||||
|
||||
$dsa->load('-----BEGIN DSA PRIVATE KEY-----
|
||||
MIIBvAIBAAKBgQDsGAHAM16bsPlwl7jaec4QMynYa0YLiLiOZC4mvH4UW/tRJxTz
|
||||
aV7eH1EtnP9D9J78x/07wKYs8zJEWCXmuq0UluQfjA47+pb68b/ucQTNeZHboNN9
|
||||
5oEi+8BCSK0y8G3uf3Y89qHvqa9Si6rP374MinEMrbVFm+UpsGflFcd83wIVALtJ
|
||||
ANi+lYG7xMKQ/bE4+bS8gemNAoGBAORowvirD7AB9x2SpdiME41+O4jVR8rs6+GX
|
||||
Ml3Hif6Yt1kem0CeraX9SNoyBNAzjD5TVMGIdGlgRr6GNreHeXMGWlvdDkvCACER
|
||||
ZEEtMsKZicm+yl6kR8AGHTCA/PBltHfyrFQd4n9I//UDqI4RjqzvpCXGQcVEsSDY
|
||||
CCBGBQJRAoGBALnHTAZlpoLJZuSBVtnMuRM3cSX43IkE9w9FveDV1jX5mmfK7yBV
|
||||
pQFV8eVJfk91ERQ4Dn6ePLUv2dRIt4a0S0qHqadgzyoFyqkmmUi1kNLyixtRqh+m
|
||||
2gXx0t63HEpZDbEPppdpnlppZquVQh7TyrKSXW9MTzUkQjFI9UY7kZeKAhQXiJgI
|
||||
kBniZHdFBAZBTE14YJUBkw==
|
||||
-----END DSA PRIVATE KEY-----');
|
||||
$signature1 = $dsa->sign($message, 'PKCS');
|
||||
$signature2 = $dsa->sign($message, 'PKCS');
|
||||
|
||||
// phpseclib's DSA implementation uses a CSPRNG to generate the k parameter.
|
||||
// used correctly this should result in different signatures every time.
|
||||
// RFC6979 describes a deterministic DSA scheme wherein two signatures for the same
|
||||
// plaintext would yield the same value so if that were to be switched to then this
|
||||
// unit test would need to be updated
|
||||
$this->assertNotEquals($signature1, $signature2);
|
||||
|
||||
$this->assertTrue($dsa->verify($message, $signature1, 'PKCS'));
|
||||
$this->assertTrue($dsa->verify($message, $signature2, 'PKCS'));
|
||||
}
|
||||
|
||||
public function testSSHSignature()
|
||||
{
|
||||
$dsa = new DSA();
|
||||
$dsa->setHash('sha1');
|
||||
$dsa->load('AAAAB3NzaC1kc3MAAACBAPyzZzm4oqmY12lxmHwNcfYDNyXr38M1lU6xy9I792U1YSKgX27nUW9eXdJ8Mrn63Le5rrBRfg2Niycx' .
|
||||
'JF2IwDpwCi7YpIv79uwT3RtA0chQDS4vx8qi8BWBzy7PZC9hmqY62+mgfj8ooga1sr+JpMh+8r4j3KjPM+wE37khkgkvAAAAFQDn' .
|
||||
'19pBng6TajI/vdg7GPnxsitCqQAAAIEA6Pl1Z/TVdkc+HpfkAvcg2Q+yNtnVq7+26RCbRDO3b9Ocr+tZA9u23qnO3KDYeygzaLnI' .
|
||||
'gpErp61Bj70iIUldhXy2LFGZFEC9XiKmt/tQxSDKiBbj3bS3wKfHrAlElgjhqxiRh+GixgSsmCj96eJFXcsxPjQU81HR+WJ0ALV1' .
|
||||
'UnMAAACABRdNuqqe1Y68es8TIflV71P0J7Ci2BbbqAXRwYYKc9/7DrygwaN2UIbMXyOLuojeZgQPPoM9nkzd6QZo8M9apawVKKwD' .
|
||||
'GAUj2of+F9WVRxhE0ohTQBzD/3HqT80pQsX+rYcxuSx1cCtdMp4oLrrfKO2J4EiWUkaoSB7SdCaj+vU=');
|
||||
$message = pack('H*', '8bfc69a222c12ddf6bc6bf33c9cadc106af04feb');
|
||||
$signature = pack('H*', '000000077373682d64737300000028a7a2e55dc43e5e6145aa94daa0552ea479d1139d6d6ba50650b489e24e976593e73f76557813d6bc');
|
||||
|
||||
$this->assertTrue($dsa->verify($message, $signature, 'SSH2'));
|
||||
}
|
||||
}
|
@ -7,7 +7,7 @@
|
||||
*/
|
||||
|
||||
use phpseclib\Crypt\RSA;
|
||||
use phpseclib\Crypt\RSA\PKCS1;
|
||||
use phpseclib\Crypt\RSA\Keys\PKCS1;
|
||||
|
||||
class Unit_Crypt_RSA_CreateKeyTest extends PhpseclibTestCase
|
||||
{
|
||||
|
@ -6,9 +6,9 @@
|
||||
*/
|
||||
|
||||
use phpseclib\Crypt\RSA;
|
||||
use phpseclib\Crypt\RSA\PKCS1;
|
||||
use phpseclib\Crypt\RSA\PKCS8;
|
||||
use phpseclib\Crypt\RSA\PuTTY;
|
||||
use phpseclib\Crypt\RSA\Keys\PKCS1;
|
||||
use phpseclib\Crypt\RSA\Keys\PKCS8;
|
||||
use phpseclib\Crypt\RSA\Keys\PuTTY;
|
||||
use phpseclib\Math\BigInteger;
|
||||
|
||||
class Unit_Crypt_RSA_LoadKeyTest extends PhpseclibTestCase
|
||||
|
@ -453,4 +453,64 @@ Mj93S
|
||||
|
||||
runkit_constant_remove('FILE_X509_IGNORE_TYPE');
|
||||
}
|
||||
|
||||
// fixed by #1104
|
||||
public function testMultipleDomainNames()
|
||||
{
|
||||
extract(RSA::createKey(512));
|
||||
|
||||
$subject = new X509();
|
||||
$subject->setDomain('example.com', 'example.net');
|
||||
|
||||
$subject->setPublicKey($publickey);
|
||||
|
||||
$issuer = new X509();
|
||||
$issuer->setPrivateKey($privatekey);
|
||||
$issuer->setDN($subject->getDN());
|
||||
|
||||
$x509 = new X509();
|
||||
$x509->sign($issuer, $subject);
|
||||
}
|
||||
|
||||
public function testUtcTimeWithoutSeconds()
|
||||
{
|
||||
$test = '-----BEGIN CERTIFICATE-----
|
||||
MIIGFDCCBPygAwIBAgIDKCHVMA0GCSqGSIb3DQEBBQUAMIHcMQswCQYDVQQGEwJVUzEQMA4GA1UE
|
||||
CBMHQXJpem9uYTETMBEGA1UEBxMKU2NvdHRzZGFsZTElMCMGA1UEChMcU3RhcmZpZWxkIFRlY2hu
|
||||
b2xvZ2llcywgSW5jLjE5MDcGA1UECxMwaHR0cDovL2NlcnRpZmljYXRlcy5zdGFyZmllbGR0ZWNo
|
||||
LmNvbS9yZXBvc2l0b3J5MTEwLwYDVQQDEyhTdGFyZmllbGQgU2VjdXJlIENlcnRpZmljYXRpb24g
|
||||
QXV0aG9yaXR5MREwDwYDVQQFEwgxMDY4ODQzNTAcFwsxNDAxMDcwMDAwWhcNMTYwNDAxMDcwMDAw
|
||||
WjCB6zETMBEGCysGAQQBgjc8AgEDEwJVUzEYMBYGCysGAQQBgjc8AgECEwdBcml6b25hMR0wGwYD
|
||||
VQQPExRQcml2YXRlIE9yZ2FuaXphdGlvbjEUMBIGA1UEBRMLUi0xNzI0NzQxLTYxCzAJBgNVBAYT
|
||||
AlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSQwIgYDVQQKExtTdGFy
|
||||
ZmllbGQgVGVjaG5vbG9naWVzLCBMTEMxKzApBgNVBAMTInZhbGlkLnNmaS5jYXRlc3Quc3RhcmZp
|
||||
ZWxkdGVjaC5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCt1LHQOza9tkKxwGL+
|
||||
/yKi/Fe5HM0sjvcM4ic1XVrvpewa4P/04IzGSjIGO3CXaSArxQMSzsTt2dcO9tSJ1Zk8c9NZXM8e
|
||||
Vqx92iTMEf9OQcubWpzWmrPc3TAFhbVnfEmCptsXEgtxbAIbntrNeDk/hBPdl4DYFYRdm3ZTk4JM
|
||||
If/quDZe5Oti53J0UsxWXSSoqKyPNdb671Q+OTQfSDj7kVF4+Ri3FIeAV16d2UnpBW1bgNqA5yIT
|
||||
RskHE4bX98HDNHUTHioHpgA+fXfejWkGB/0FQN4HbZcysYHhf1L5cWBtz9w5J00YmjM5fzWvTc3U
|
||||
UF9ou7m7JE4aqEbNOWb9AgMBAAGjggHOMIIByjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIF
|
||||
oDAdBgNVHSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwLQYDVR0RBCYwJIIidmFsaWQuc2ZpLmNh
|
||||
dGVzdC5zdGFyZmllbGR0ZWNoLmNvbTAdBgNVHQ4EFgQUcO+QEqZcHphPW9szww9ty+1AGmQwHwYD
|
||||
VR0jBBgwFoAUSUtSJ9EbvPKhIWpie1FCeorX1VYwOAYDVR0fBDEwLzAtoCugKYYnaHR0cDovL2Ny
|
||||
bC5zdGFyZmllbGR0ZWNoLmNvbS9zZnMzLTAuY3JsMIGNBggrBgEFBQcBAQSBgDB+MCoGCCsGAQUF
|
||||
BzABhh5odHRwOi8vb2NzcC5zdGFyZmllbGR0ZWNoLmNvbS8wUAYIKwYBBQUHMAKGRGh0dHA6Ly9j
|
||||
ZXJ0aWZpY2F0ZXMuc3RhcmZpZWxkdGVjaC5jb20vcmVwb3NpdG9yeS9zZl9pbnRlcm1lZGlhdGUu
|
||||
Y3J0MFIGA1UdIARLMEkwRwYLYIZIAYb9bgEHFwMwODA2BggrBgEFBQcCARYqaHR0cDovL2NlcnRz
|
||||
LnN0YXJmaWVsZHRlY2guY29tL3JlcG9zaXRvcnkvMA0GCSqGSIb3DQEBBQUAA4IBAQAViYkLUjQk
|
||||
xWRmZl4DutL0/9/wJSURcJ1qunLP+TImJFp0A9RE/MNKZOmQoAEoH6hMg7FL4etkvTcnruTdcx+3
|
||||
mvqYiECUiUEx6pkx3dmkYgZACEuk2nfyJ0MkV/zwzqmI8aV+kunpOQv93aePZbrBgaAzkE8jDlEx
|
||||
td7c4pE7JF40jxmvDwjZHwpyNDULreGtFBij7JcWJCfihM3uetqrao0kOoeih1PQyJXtz2RldhFY
|
||||
s6Jdk3ILYv+84t5UMO+aS9nVBXIcbgaGjIMZjHDgR/tE9FKFB66k8UTDzAwwEs38VV24zx6hlOzT
|
||||
F7xAUxmPUnNb2teatMf2Rmj0fs+d
|
||||
-----END CERTIFICATE-----
|
||||
';
|
||||
|
||||
$x509 = new X509();
|
||||
|
||||
$cert = $x509->loadX509($test);
|
||||
|
||||
$this->assertEquals($cert['tbsCertificate']['validity']['notBefore']['utcTime'], 'Tue, 07 Jan 2014 00:00:00 +0000');
|
||||
$this->assertEquals($cert['tbsCertificate']['validity']['notAfter']['utcTime'], 'Fri, 01 Apr 2016 07:00:00 +0000');
|
||||
}
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user