Viel neues

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/AsymmetricKey.php

@@ -0,0 +1,532 @@
+<?php
+
+/**
+ * Base Class for all asymmetric key ciphers
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common;
+
+use phpseclib3\Crypt\Hash;
+use phpseclib3\Exception\NoKeyLoadedException;
+use phpseclib3\Exception\UnsupportedFormatException;
+use phpseclib3\Math\BigInteger;
+
+/**
+ * Base Class for all asymmetric cipher classes
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class AsymmetricKey
+{
+    /**
+     * Precomputed Zero
+     *
+     * @var BigInteger
+     */
+    protected static $zero;
+
+    /**
+     * Precomputed One
+     *
+     * @var BigInteger
+     */
+    protected static $one;
+
+    /**
+     * Format of the loaded key
+     *
+     * @var string
+     */
+    protected $format;
+
+    /**
+     * Hash function
+     *
+     * @var Hash
+     */
+    protected $hash;
+
+    /**
+     * HMAC function
+     *
+     * @var Hash
+     */
+    private $hmac;
+
+    /**
+     * Supported plugins (lower case)
+     *
+     * @see self::initialize_static_variables()
+     * @var array
+     */
+    private static $plugins = [];
+
+    /**
+     * Invisible plugins
+     *
+     * @see self::initialize_static_variables()
+     * @var array
+     */
+    private static $invisiblePlugins = [];
+
+    /**
+     * Available Engines
+     *
+     * @var boolean[]
+     */
+    protected static $engines = [];
+
+    /**
+     * Key Comment
+     *
+     * @var null|string
+     */
+    private $comment;
+
+    abstract public function toString(string $type, array $options = []): array|string;
+
+    /**
+     * The constructor
+     */
+    protected function __construct()
+    {
+        self::initialize_static_variables();
+
+        $this->hash = new Hash('sha256');
+        $this->hmac = new Hash('sha256');
+    }
+
+    /**
+     * Initialize static variables
+     */
+    protected static function initialize_static_variables(): void
+    {
+        if (!isset(self::$zero)) {
+            self::$zero = new BigInteger(0);
+            self::$one = new BigInteger(1);
+        }
+
+        self::loadPlugins('Keys');
+        if (static::ALGORITHM != 'RSA' && static::ALGORITHM != 'DH') {
+            self::loadPlugins('Signature');
+        }
+    }
+
+    /**
+     * Load the key
+     *
+     * @param string|array $key
+     * @return PublicKey|PrivateKey
+     */
+    public static function load($key, ?string $password = null): AsymmetricKey
+    {
+        self::initialize_static_variables();
+
+        $class = new \ReflectionClass(static::class);
+        if ($class->isFinal()) {
+            throw new \RuntimeException('load() should not be called from final classes (' . static::class . ')');
+        }
+
+        $components = false;
+        foreach (self::$plugins[static::ALGORITHM]['Keys'] as $format) {
+            if (isset(self::$invisiblePlugins[static::ALGORITHM]) && in_array($format, self::$invisiblePlugins[static::ALGORITHM])) {
+                continue;
+            }
+            try {
+                $components = $format::load($key, $password);
+            } catch (\Exception $e) {
+                $components = false;
+            }
+            if ($components !== false) {
+                break;
+            }
+        }
+
+        if ($components === false) {
+            throw new NoKeyLoadedException('Unable to read key');
+        }
+
+        $components['format'] = $format;
+        $components['secret'] ??= '';
+        $comment = $components['comment'] ?? null;
+        $new = static::onLoad($components);
+        $new->format = $format;
+        $new->comment = $comment;
+        return $new instanceof PrivateKey ?
+            $new->withPassword($password) :
+            $new;
+    }
+
+    /**
+     * Loads a private key
+     *
+     * @param string|array $key
+     * @param string $password optional
+     */
+    public static function loadPrivateKey($key, string $password = ''): PrivateKey
+    {
+        $key = self::load($key, $password);
+        if (!$key instanceof PrivateKey) {
+            throw new NoKeyLoadedException('The key that was loaded was not a private key');
+        }
+        return $key;
+    }
+
+    /**
+     * Loads a public key
+     *
+     * @param string|array $key
+     */
+    public static function loadPublicKey($key): PublicKey
+    {
+        $key = self::load($key);
+        if (!$key instanceof PublicKey) {
+            throw new NoKeyLoadedException('The key that was loaded was not a public key');
+        }
+        return $key;
+    }
+
+    /**
+     * Loads parameters
+     *
+     * @param string|array $key
+     */
+    public static function loadParameters($key): AsymmetricKey
+    {
+        $key = self::load($key);
+        if (!$key instanceof PrivateKey && !$key instanceof PublicKey) {
+            throw new NoKeyLoadedException('The key that was loaded was not a parameter');
+        }
+        return $key;
+    }
+
+    /**
+     * Load the key, assuming a specific format
+     *
+     * @return static
+     */
+    public static function loadFormat(string $type, string $key, ?string $password = null): AsymmetricKey
+    {
+        self::initialize_static_variables();
+
+        $components = false;
+        $format = strtolower($type);
+        if (isset(self::$plugins[static::ALGORITHM]['Keys'][$format])) {
+            $format = self::$plugins[static::ALGORITHM]['Keys'][$format];
+            $components = $format::load($key, $password);
+        }
+
+        if ($components === false) {
+            throw new NoKeyLoadedException('Unable to read key');
+        }
+
+        $components['format'] = $format;
+        $components['secret'] ??= '';
+
+        $new = static::onLoad($components);
+        $new->format = $format;
+        return $new instanceof PrivateKey ?
+            $new->withPassword($password) :
+            $new;
+    }
+
+    /**
+     * Loads a private key
+     */
+    public static function loadPrivateKeyFormat(string $type, string $key, ?string $password = null): PrivateKey
+    {
+        $key = self::loadFormat($type, $key, $password);
+        if (!$key instanceof PrivateKey) {
+            throw new NoKeyLoadedException('The key that was loaded was not a private key');
+        }
+        return $key;
+    }
+
+    /**
+     * Loads a public key
+     */
+    public static function loadPublicKeyFormat(string $type, string $key): PublicKey
+    {
+        $key = self::loadFormat($type, $key);
+        if (!$key instanceof PublicKey) {
+            throw new NoKeyLoadedException('The key that was loaded was not a public key');
+        }
+        return $key;
+    }
+
+    /**
+     * Loads parameters
+     *
+     * @param string|array $key
+     */
+    public static function loadParametersFormat(string $type, $key): AsymmetricKey
+    {
+        $key = self::loadFormat($type, $key);
+        if (!$key instanceof PrivateKey && !$key instanceof PublicKey) {
+            throw new NoKeyLoadedException('The key that was loaded was not a parameter');
+        }
+        return $key;
+    }
+
+    /**
+     * Validate Plugin
+     *
+     * @param string|null $method optional
+     */
+    protected static function validatePlugin(string $format, string $type, ?string $method = null)
+    {
+        $type = strtolower($type);
+        if (!isset(self::$plugins[static::ALGORITHM][$format][$type])) {
+            throw new UnsupportedFormatException("$type is not a supported format");
+        }
+        $type = self::$plugins[static::ALGORITHM][$format][$type];
+        if (isset($method) && !method_exists($type, $method)) {
+            throw new UnsupportedFormatException("$type does not implement $method");
+        }
+
+        return $type;
+    }
+
+    /**
+     * Load Plugins
+     */
+    private static function loadPlugins(string $format): void
+    {
+        if (!isset(self::$plugins[static::ALGORITHM][$format])) {
+            self::$plugins[static::ALGORITHM][$format] = [];
+            foreach (new \DirectoryIterator(__DIR__ . '/../' . static::ALGORITHM . '/Formats/' . $format . '/') as $file) {
+                if ($file->getExtension() != 'php') {
+                    continue;
+                }
+                $name = $file->getBasename('.php');
+                if ($name[0] == '.') {
+                    continue;
+                }
+                $type = 'phpseclib3\Crypt\\' . static::ALGORITHM . '\\Formats\\' . $format . '\\' . $name;
+                $reflect = new \ReflectionClass($type);
+                if ($reflect->isTrait()) {
+                    continue;
+                }
+                self::$plugins[static::ALGORITHM][$format][strtolower($name)] = $type;
+                if ($reflect->hasConstant('IS_INVISIBLE')) {
+                    self::$invisiblePlugins[static::ALGORITHM][] = $type;
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns a list of supported formats.
+     */
+    public static function getSupportedKeyFormats(): array
+    {
+        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()
+     */
+    public static function addFileFormat(string $fullname): void
+    {
+        self::initialize_static_variables();
+
+        if (class_exists($fullname)) {
+            $meta = new \ReflectionClass($fullname);
+            $shortname = $meta->getShortName();
+            self::$plugins[static::ALGORITHM]['Keys'][strtolower($shortname)] = $fullname;
+            if ($meta->hasConstant('IS_INVISIBLE')) {
+                self::$invisiblePlugins[static::ALGORITHM][] = strtolower($shortname);
+            }
+        }
+    }
+
+    /**
+     * 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 throw an exception.
+     *
+     * @see self::load()
+     */
+    public function getLoadedFormat(): string
+    {
+        if (empty($this->format)) {
+            throw new NoKeyLoadedException('This key was created with createKey - it was not loaded with load. Therefore there is no "loaded format"');
+        }
+
+        $meta = new \ReflectionClass($this->format);
+        return $meta->getShortName();
+    }
+
+    /**
+     * Returns the key's comment
+     *
+     * Not all key formats support comments. If you want to set a comment use toString()
+     */
+    public function getComment(): ?string
+    {
+        return $this->comment;
+    }
+
+    /**
+     * Tests engine validity
+     */
+    public static function useBestEngine(): array
+    {
+        static::$engines = [
+            'PHP' => true,
+            'OpenSSL' => extension_loaded('openssl'),
+            // this test can be satisfied by either of the following:
+            // http://php.net/manual/en/book.sodium.php
+            // https://github.com/paragonie/sodium_compat
+            'libsodium' => function_exists('sodium_crypto_sign_keypair'),
+        ];
+
+        return static::$engines;
+    }
+
+    /**
+     * Flag to use internal engine only (useful for unit testing)
+     */
+    public static function useInternalEngine(): void
+    {
+        static::$engines = [
+            'PHP' => true,
+            'OpenSSL' => false,
+            'libsodium' => false,
+        ];
+    }
+
+    /**
+     * __toString() magic method
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->toString('PKCS8');
+    }
+
+    /**
+     * Determines which hashing function should be used
+     */
+    public function withHash(string $hash): AsymmetricKey
+    {
+        $new = clone $this;
+
+        $new->hash = new Hash($hash);
+        $new->hmac = new Hash($hash);
+
+        return $new;
+    }
+
+    /**
+     * Returns the hash algorithm currently being used
+     */
+    public function getHash(): Hash
+    {
+        return clone $this->hash;
+    }
+
+    /**
+     * Compute the pseudorandom k for signature generation,
+     * using the process specified for deterministic DSA.
+     *
+     * @return string
+     */
+    protected function computek(string $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
+     */
+    private function int2octets(BigInteger $v): string
+    {
+        $out = $v->toBytes();
+        $rolen = $this->q->getLengthInBytes();
+        if (strlen($out) < $rolen) {
+            return str_pad($out, $rolen, "\0", STR_PAD_LEFT);
+        } elseif (strlen($out) > $rolen) {
+            return substr($out, -$rolen);
+        } else {
+            return $out;
+        }
+    }
+
+    /**
+     * Bit String to Integer
+     */
+    protected function bits2int(string $in): BigInteger
+    {
+        $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
+     */
+    private function bits2octets(string $in): string
+    {
+        $z1 = $this->bits2int($in);
+        $z2 = $z1->subtract($this->q);
+        return $z2->compare(self::$zero) < 0 ?
+            $this->int2octets($z1) :
+            $this->int2octets($z2);
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/BlockCipher.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * Base Class for all block ciphers
+ *
+ * PHP version 5
+ *
+ * @author    Jim Wigginton <terrafrost@php.net>
+ * @author    Hans-Juergen Petrich <petrich@tronic-media.com>
+ * @copyright 2007 Jim Wigginton
+ * @license   http://www.opensource.org/licenses/mit-license.html  MIT License
+ * @link      http://phpseclib.sourceforge.net
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common;
+
+/**
+ * Base Class for all block cipher classes
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class BlockCipher extends SymmetricKey
+{
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Keys/JWK.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * JSON Web Key (RFC7517) Handler
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Keys;
+
+use phpseclib3\Common\Functions\Strings;
+
+/**
+ * JSON Web Key Formatted Key Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class JWK
+{
+    /**
+     * Break a public or private key down into its constituent components
+     *
+     * @param string|array $key
+     */
+    protected static function loadHelper($key): \stdClass
+    {
+        if (!Strings::is_stringable($key)) {
+            throw new \UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        $key = preg_replace('#\s#', '', $key); // remove whitespace
+
+        $key = json_decode($key, null, 512, JSON_THROW_ON_ERROR);
+
+        if (isset($key->kty)) {
+            return $key;
+        }
+
+        if (count($key->keys) != 1) {
+            throw new \RuntimeException('Although the JWK key format supports multiple keys phpseclib does not');
+        }
+
+        return $key->keys[0];
+    }
+
+    /**
+     * Wrap a key appropriately
+     */
+    protected static function wrapKey(array $key, array $options): string
+    {
+        return json_encode(['keys' => [$key + $options]]);
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Keys/OpenSSH.php

@@ -0,0 +1,217 @@
+<?php
+
+/**
+ * OpenSSH Key Handler
+ *
+ * PHP version 5
+ *
+ * Place in $HOME/.ssh/authorized_keys
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Keys;
+
+use phpseclib3\Common\Functions\Strings;
+use phpseclib3\Crypt\AES;
+use phpseclib3\Crypt\Random;
+use phpseclib3\Exception\BadDecryptionException;
+use phpseclib3\Exception\RuntimeException;
+use phpseclib3\Exception\UnexpectedValueException;
+
+/**
+ * OpenSSH Formatted RSA Key Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class OpenSSH
+{
+    /**
+     * Default comment
+     *
+     * @var string
+     */
+    protected static $comment = 'phpseclib-generated-key';
+
+    /**
+     * Binary key flag
+     *
+     * @var bool
+     */
+    protected static $binary = false;
+
+    /**
+     * Sets the default comment
+     */
+    public static function setComment(string $comment): void
+    {
+        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
+     *
+     * @param string|array $key
+     */
+    public static function load($key, ?string $password = null): array
+    {
+        if (!Strings::is_stringable($key)) {
+            throw new UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        // key format is described here:
+        // https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.key?annotate=HEAD
+
+        if (str_contains($key, 'BEGIN OPENSSH PRIVATE KEY')) {
+            $key = preg_replace('#(?:^-.*?-[\r\n]*$)|\s#ms', '', $key);
+            $key = Strings::base64_decode($key);
+            $magic = Strings::shift($key, 15);
+            if ($magic != "openssh-key-v1\0") {
+                throw new RuntimeException('Expected openssh-key-v1');
+            }
+            [$ciphername, $kdfname, $kdfoptions, $numKeys] = Strings::unpackSSH2('sssN', $key);
+            if ($numKeys != 1) {
+                // if we wanted to support multiple keys we could update PublicKeyLoader to preview what the # of keys
+                // would be; it'd then call Common\Keys\OpenSSH.php::load() and get the paddedKey. it'd then pass
+                // that to the appropriate key loading parser $numKey times or something
+                throw new RuntimeException('Although the OpenSSH private key format supports multiple keys phpseclib does not');
+            }
+
+            switch ($ciphername) {
+                case 'none':
+                    break;
+                case 'aes256-ctr':
+                    if ($kdfname != 'bcrypt') {
+                        throw new RuntimeException('Only the bcrypt kdf is supported (' . $kdfname . ' encountered)');
+                    }
+                    [$salt, $rounds] = Strings::unpackSSH2('sN', $kdfoptions);
+                    $crypto = new AES('ctr');
+                    //$crypto->setKeyLength(256);
+                    //$crypto->disablePadding();
+                    $crypto->setPassword($password, 'bcrypt', $salt, $rounds, 32);
+                    break;
+                default:
+                    throw new RuntimeException('The only supported ciphers are: none, aes256-ctr (' . $ciphername . ' is being used)');
+            }
+
+            [$publicKey, $paddedKey] = Strings::unpackSSH2('ss', $key);
+            [$type] = Strings::unpackSSH2('s', $publicKey);
+            if (isset($crypto)) {
+                $paddedKey = $crypto->decrypt($paddedKey);
+            }
+            [$checkint1, $checkint2] = Strings::unpackSSH2('NN', $paddedKey);
+            // any leftover bytes in $paddedKey are for padding? but they should be sequential bytes. eg. 1, 2, 3, etc.
+            if ($checkint1 != $checkint2) {
+                if (isset($crypto)) {
+                    throw new BadDecryptionException('Unable to decrypt key - please verify the password you are using');
+                }
+                throw new RuntimeException("The two checkints do not match ($checkint1 vs. $checkint2)");
+            }
+            self::checkType($type);
+
+            return compact('type', 'publicKey', 'paddedKey');
+        }
+
+        $parts = explode(' ', $key, 3);
+
+        if (!isset($parts[1])) {
+            $key = base64_decode($parts[0]);
+            $comment = false;
+        } else {
+            $asciiType = $parts[0];
+            self::checkType($parts[0]);
+            $key = base64_decode($parts[1]);
+            $comment = $parts[2] ?? false;
+        }
+        if ($key === false) {
+            throw new UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        [$type] = Strings::unpackSSH2('s', $key);
+        self::checkType($type);
+        if (isset($asciiType) && $asciiType != $type) {
+            throw new RuntimeException('Two different types of keys are claimed: ' . $asciiType . ' and ' . $type);
+        }
+        if (strlen($key) <= 4) {
+            throw new UnexpectedValueException('Key appears to be malformed');
+        }
+
+        $publicKey = $key;
+
+        return compact('type', 'publicKey', 'comment');
+    }
+
+    /**
+     * 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.
+     */
+    public static function setBinaryOutput(bool $enabled): void
+    {
+        self::$binary = $enabled;
+    }
+
+    /**
+     * Checks to see if the type is valid
+     */
+    private static function checkType(string $candidate): void
+    {
+        if (!in_array($candidate, static::$types)) {
+            throw new RuntimeException("The key type ($candidate) is not equal to: " . implode(',', static::$types));
+        }
+    }
+
+    /**
+     * Wrap a private key appropriately
+     *
+     * @param string|false $password
+     */
+    protected static function wrapPrivateKey(string $publicKey, string $privateKey, $password, array $options): string
+    {
+        [, $checkint] = unpack('N', Random::string(4));
+
+        $comment = $options['comment'] ?? self::$comment;
+        $paddedKey = Strings::packSSH2('NN', $checkint, $checkint) .
+                     $privateKey .
+                     Strings::packSSH2('s', $comment);
+
+        $usesEncryption = !empty($password) && is_string($password);
+
+        /*
+           from http://tools.ietf.org/html/rfc4253#section-6 :
+
+           Note that the length of the concatenation of 'packet_length',
+           'padding_length', 'payload', and 'random padding' MUST be a multiple
+           of the cipher block size or 8, whichever is larger.
+         */
+        $blockSize = $usesEncryption ? 16 : 8;
+        $paddingLength = (($blockSize - 1) * strlen($paddedKey)) % $blockSize;
+        for ($i = 1; $i <= $paddingLength; $i++) {
+            $paddedKey .= chr($i);
+        }
+        if (!$usesEncryption) {
+            $key = Strings::packSSH2('sssNss', 'none', 'none', '', 1, $publicKey, $paddedKey);
+        } else {
+            $rounds = $options['rounds'] ?? 16;
+            $salt = Random::string(16);
+            $kdfoptions = Strings::packSSH2('sN', $salt, $rounds);
+            $crypto = new AES('ctr');
+            $crypto->setPassword($password, 'bcrypt', $salt, $rounds, 32);
+            $paddedKey = $crypto->encrypt($paddedKey);
+            $key = Strings::packSSH2('sssNss', 'aes256-ctr', 'bcrypt', $kdfoptions, 1, $publicKey, $paddedKey);
+        }
+        $key = "openssh-key-v1\0$key";
+
+        return "-----BEGIN OPENSSH PRIVATE KEY-----\n" .
+               chunk_split(Strings::base64_encode($key), 70, "\n") .
+               "-----END OPENSSH PRIVATE KEY-----\n";
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Keys/PKCS.php

@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * PKCS Formatted Key Handler
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Keys;
+
+/**
+ * PKCS1 Formatted Key Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class PKCS
+{
+    /**
+     * Auto-detect the format
+     */
+    public const MODE_ANY = 0;
+    /**
+     * Require base64-encoded PEM's be supplied
+     */
+    public const MODE_PEM = 1;
+    /**
+     * Require raw DER's be supplied
+     */
+    public const MODE_DER = 2;
+    /**#@-*/
+
+    /**
+     * Is the key a base-64 encoded PEM, DER or should it be auto-detected?
+     *
+     * @var int
+     */
+    protected static $format = self::MODE_ANY;
+
+    /**
+     * Require base64-encoded PEM's be supplied
+     */
+    public static function requirePEM(): void
+    {
+        self::$format = self::MODE_PEM;
+    }
+
+    /**
+     * Require raw DER's be supplied
+     */
+    public static function requireDER(): void
+    {
+        self::$format = self::MODE_DER;
+    }
+
+    /**
+     * Accept any format and auto detect the format
+     *
+     * This is the default setting
+     */
+    public static function requireAny(): void
+    {
+        self::$format = self::MODE_ANY;
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Keys/PKCS1.php

@@ -0,0 +1,195 @@
+<?php
+
+/**
+ * PKCS1 Formatted Key Handler
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Keys;
+
+use phpseclib3\Common\Functions\Strings;
+use phpseclib3\Crypt\AES;
+use phpseclib3\Crypt\DES;
+use phpseclib3\Crypt\Random;
+use phpseclib3\Crypt\TripleDES;
+use phpseclib3\Exception\UnexpectedValueException;
+use phpseclib3\Exception\UnsupportedAlgorithmException;
+use phpseclib3\File\ASN1;
+
+/**
+ * PKCS1 Formatted Key Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class PKCS1 extends PKCS
+{
+    /**
+     * Default encryption algorithm
+     *
+     * @var string
+     */
+    private static $defaultEncryptionAlgorithm = 'AES-128-CBC';
+
+    /**
+     * Sets the default encryption algorithm
+     */
+    public static function setEncryptionAlgorithm(string $algo): void
+    {
+        self::$defaultEncryptionAlgorithm = $algo;
+    }
+
+    /**
+     * Returns the mode constant corresponding to the mode string
+     *
+     * @return int
+     * @throws UnexpectedValueException if the block cipher mode is unsupported
+     */
+    private static function getEncryptionMode(string $mode)
+    {
+        switch ($mode) {
+            case 'CBC':
+            case 'ECB':
+            case 'CFB':
+            case 'OFB':
+            case 'CTR':
+                return $mode;
+        }
+        throw new UnexpectedValueException('Unsupported block cipher mode of operation');
+    }
+
+    /**
+     * Returns a cipher object corresponding to a string
+     *
+     * @return AES|DES|TripleDES
+     * @throws UnexpectedValueException if the encryption algorithm is unsupported
+     */
+    private static function getEncryptionObject(string $algo)
+    {
+        $modes = '(CBC|ECB|CFB|OFB|CTR)';
+        switch (true) {
+            case preg_match("#^AES-(128|192|256)-$modes$#", $algo, $matches):
+                $cipher = new AES(self::getEncryptionMode($matches[2]));
+                $cipher->setKeyLength((int) $matches[1]);
+                return $cipher;
+            case preg_match("#^DES-EDE3-$modes$#", $algo, $matches):
+                return new TripleDES(self::getEncryptionMode($matches[1]));
+            case preg_match("#^DES-$modes$#", $algo, $matches):
+                return new DES(self::getEncryptionMode($matches[1]));
+            default:
+                throw new UnsupportedAlgorithmException($algo . ' is not a supported algorithm');
+        }
+    }
+
+    /**
+     * Generate a symmetric key for PKCS#1 keys
+     */
+    private static function generateSymmetricKey(string $password, string $iv, int $length): string
+    {
+        $symkey = '';
+        $iv = substr($iv, 0, 8);
+        while (strlen($symkey) < $length) {
+            $symkey .= md5($symkey . $password . $iv, true);
+        }
+        return substr($symkey, 0, $length);
+    }
+
+    /**
+     * Break a public or private key down into its constituent components
+     *
+     * @param string|array $key
+     * @return array|string
+     */
+    protected static function load($key, ?string $password = null)
+    {
+        if (!Strings::is_stringable($key)) {
+            throw new UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        /* Although PKCS#1 proposes a format that public and private keys can use, encrypting them is
+           "outside the scope" of PKCS#1.  PKCS#1 then refers you to PKCS#12 and PKCS#15 if you're wanting to
+           protect private keys, however, that's not what OpenSSL* does.  OpenSSL protects private keys by adding
+           two new "fields" to the key - DEK-Info and Proc-Type.  These fields are discussed here:
+
+           http://tools.ietf.org/html/rfc1421#section-4.6.1.1
+           http://tools.ietf.org/html/rfc1421#section-4.6.1.3
+
+           DES-EDE3-CBC as an algorithm, however, is not discussed anywhere, near as I can tell.
+           DES-CBC and DES-EDE are discussed in RFC1423, however, DES-EDE3-CBC isn't, nor is its key derivation
+           function.  As is, the definitive authority on this encoding scheme isn't the IETF but rather OpenSSL's
+           own implementation.  ie. the implementation *is* the standard and any bugs that may exist in that
+           implementation are part of the standard, as well.
+
+           * OpenSSL is the de facto standard.  It's utilized by OpenSSH and other projects */
+        if (preg_match('#DEK-Info: (.+),(.+)#', $key, $matches)) {
+            $iv = Strings::hex2bin(trim($matches[2]));
+            // remove the Proc-Type / DEK-Info sections as they're no longer needed
+            $key = preg_replace('#^(?:Proc-Type|DEK-Info): .*#m', '', $key);
+            $ciphertext = ASN1::extractBER($key);
+            if ($ciphertext === false) {
+                $ciphertext = $key;
+            }
+            $crypto = self::getEncryptionObject($matches[1]);
+            $crypto->setKey(self::generateSymmetricKey($password, $iv, $crypto->getKeyLength() >> 3));
+            $crypto->setIV($iv);
+            $key = $crypto->decrypt($ciphertext);
+        } else {
+            if (self::$format != self::MODE_DER) {
+                $decoded = ASN1::extractBER($key);
+                if ($decoded !== false) {
+                    $key = $decoded;
+                } elseif (self::$format == self::MODE_PEM) {
+                    throw new UnexpectedValueException('Expected base64-encoded PEM format but was unable to decode base64 text');
+                }
+            }
+        }
+
+        return $key;
+    }
+
+    /**
+     * Wrap a private key appropriately
+     *
+     * @param string|false $password
+     * @param array $options optional
+     */
+    protected static function wrapPrivateKey(string $key, string $type, $password, array $options = []): string
+    {
+        if (empty($password) || !is_string($password)) {
+            return "-----BEGIN $type PRIVATE KEY-----\r\n" .
+                   chunk_split(Strings::base64_encode($key), 64) .
+                   "-----END $type PRIVATE KEY-----";
+        }
+
+        $encryptionAlgorithm = $options['encryptionAlgorithm'] ?? self::$defaultEncryptionAlgorithm;
+
+        $cipher = self::getEncryptionObject($encryptionAlgorithm);
+        $iv = Random::string($cipher->getBlockLength() >> 3);
+        $cipher->setKey(self::generateSymmetricKey($password, $iv, $cipher->getKeyLength() >> 3));
+        $cipher->setIV($iv);
+        $iv = strtoupper(Strings::bin2hex($iv));
+        return "-----BEGIN $type PRIVATE KEY-----\r\n" .
+               "Proc-Type: 4,ENCRYPTED\r\n" .
+               "DEK-Info: " . $encryptionAlgorithm . ",$iv\r\n" .
+               "\r\n" .
+               chunk_split(Strings::base64_encode($cipher->encrypt($key)), 64) .
+               "-----END $type PRIVATE KEY-----";
+    }
+
+    /**
+     * Wrap a public key appropriately
+     */
+    protected static function wrapPublicKey(string $key, string $type): string
+    {
+        return "-----BEGIN $type PUBLIC KEY-----\r\n" .
+               chunk_split(Strings::base64_encode($key), 64) .
+               "-----END $type PUBLIC KEY-----";
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Keys/PKCS8.php

@@ -0,0 +1,697 @@
+<?php
+
+/**
+ * PKCS#8 Formatted Key Handler
+ *
+ * PHP version 5
+ *
+ * Used by PHP's openssl_public_encrypt() and openssl's rsautl (when -pubin is set)
+ *
+ * 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)
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Keys;
+
+use phpseclib3\Common\Functions\Strings;
+use phpseclib3\Crypt\AES;
+use phpseclib3\Crypt\Common\SymmetricKey;
+use phpseclib3\Crypt\DES;
+use phpseclib3\Crypt\Random;
+use phpseclib3\Crypt\RC2;
+use phpseclib3\Crypt\RC4;
+use phpseclib3\Crypt\TripleDES;
+use phpseclib3\Exception\InsufficientSetupException;
+use phpseclib3\Exception\RuntimeException;
+use phpseclib3\Exception\UnexpectedValueException;
+use phpseclib3\Exception\UnsupportedAlgorithmException;
+use phpseclib3\File\ASN1;
+use phpseclib3\File\ASN1\Maps;
+
+/**
+ * PKCS#8 Formatted Key Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class PKCS8 extends PKCS
+{
+    /**
+     * Default encryption algorithm
+     *
+     * @var string
+     */
+    private static $defaultEncryptionAlgorithm = 'id-PBES2';
+
+    /**
+     * Default encryption scheme
+     *
+     * Only used when defaultEncryptionAlgorithm is id-PBES2
+     *
+     * @var string
+     */
+    private static $defaultEncryptionScheme = 'aes128-CBC-PAD';
+
+    /**
+     * Default PRF
+     *
+     * Only used when defaultEncryptionAlgorithm is id-PBES2
+     *
+     * @var string
+     */
+    private static $defaultPRF = 'id-hmacWithSHA256';
+
+    /**
+     * Default Iteration Count
+     *
+     * @var int
+     */
+    private static $defaultIterationCount = 2048;
+
+    /**
+     * OIDs loaded
+     *
+     * @var bool
+     */
+    private static $oidsLoaded = false;
+
+    /**
+     * Sets the default encryption algorithm
+     */
+    public static function setEncryptionAlgorithm(string $algo): void
+    {
+        self::$defaultEncryptionAlgorithm = $algo;
+    }
+
+    /**
+     * Sets the default encryption algorithm for PBES2
+     */
+    public static function setEncryptionScheme(string $algo): void
+    {
+        self::$defaultEncryptionScheme = $algo;
+    }
+
+    /**
+     * Sets the iteration count
+     */
+    public static function setIterationCount(int $count): void
+    {
+        self::$defaultIterationCount = $count;
+    }
+
+    /**
+     * Sets the PRF for PBES2
+     */
+    public static function setPRF(string $algo): void
+    {
+        self::$defaultPRF = $algo;
+    }
+
+    /**
+     * Returns a SymmetricKey object based on a PBES1 $algo
+     *
+     * @return SymmetricKey
+     */
+    private static function getPBES1EncryptionObject(string $algo)
+    {
+        $algo = preg_match('#^pbeWith(?:MD2|MD5|SHA1|SHA)And(.*?)-CBC$#', $algo, $matches) ?
+            $matches[1] :
+            substr($algo, 13); // strlen('pbeWithSHAAnd') == 13
+
+        switch ($algo) {
+            case 'DES':
+                $cipher = new DES('cbc');
+                break;
+            case 'RC2':
+                $cipher = new RC2('cbc');
+                $cipher->setKeyLength(64);
+                break;
+            case '3-KeyTripleDES':
+                $cipher = new TripleDES('cbc');
+                break;
+            case '2-KeyTripleDES':
+                $cipher = new TripleDES('cbc');
+                $cipher->setKeyLength(128);
+                break;
+            case '128BitRC2':
+                $cipher = new RC2('cbc');
+                $cipher->setKeyLength(128);
+                break;
+            case '40BitRC2':
+                $cipher = new RC2('cbc');
+                $cipher->setKeyLength(40);
+                break;
+            case '128BitRC4':
+                $cipher = new RC4();
+                $cipher->setKeyLength(128);
+                break;
+            case '40BitRC4':
+                $cipher = new RC4();
+                $cipher->setKeyLength(40);
+                break;
+            default:
+                throw new UnsupportedAlgorithmException("$algo is not a supported algorithm");
+        }
+
+        return $cipher;
+    }
+
+    /**
+     * Returns a hash based on a PBES1 $algo
+     */
+    private static function getPBES1Hash(string $algo): string
+    {
+        if (preg_match('#^pbeWith(MD2|MD5|SHA1|SHA)And.*?-CBC$#', $algo, $matches)) {
+            return $matches[1] == 'SHA' ? 'sha1' : $matches[1];
+        }
+
+        return 'sha1';
+    }
+
+    /**
+     * Returns a KDF baesd on a PBES1 $algo
+     */
+    private static function getPBES1KDF(string $algo): string
+    {
+        switch ($algo) {
+            case 'pbeWithMD2AndDES-CBC':
+            case 'pbeWithMD2AndRC2-CBC':
+            case 'pbeWithMD5AndDES-CBC':
+            case 'pbeWithMD5AndRC2-CBC':
+            case 'pbeWithSHA1AndDES-CBC':
+            case 'pbeWithSHA1AndRC2-CBC':
+                return 'pbkdf1';
+        }
+
+        return 'pkcs12';
+    }
+
+    /**
+     * Returns a SymmetricKey object baesd on a PBES2 $algo
+     */
+    private static function getPBES2EncryptionObject(string $algo): SymmetricKey
+    {
+        switch ($algo) {
+            case 'desCBC':
+                $cipher = new DES('cbc');
+                break;
+            case 'des-EDE3-CBC':
+                $cipher = new TripleDES('cbc');
+                break;
+            case 'rc2CBC':
+                $cipher = new RC2('cbc');
+                // in theory this can be changed
+                $cipher->setKeyLength(128);
+                break;
+            case 'rc5-CBC-PAD':
+                throw new UnsupportedAlgorithmException('rc5-CBC-PAD is not supported for PBES2 PKCS#8 keys');
+            case 'aes128-CBC-PAD':
+            case 'aes192-CBC-PAD':
+            case 'aes256-CBC-PAD':
+                $cipher = new AES('cbc');
+                $cipher->setKeyLength((int) substr($algo, 3, 3));
+                break;
+            default:
+                throw new UnsupportedAlgorithmException("$algo is not supported");
+        }
+
+        return $cipher;
+    }
+
+    /**
+     * Initialize static variables
+     */
+    private static function initialize_static_variables(): void
+    {
+        if (!isset(static::$childOIDsLoaded)) {
+            throw new InsufficientSetupException('This class should not be called directly');
+        }
+
+        if (!static::$childOIDsLoaded) {
+            ASN1::loadOIDs(is_array(static::OID_NAME) ?
+                array_combine(static::OID_NAME, static::OID_VALUE) :
+                [static::OID_NAME => static::OID_VALUE]);
+            static::$childOIDsLoaded = true;
+        }
+        if (!self::$oidsLoaded) {
+            // from https://tools.ietf.org/html/rfc2898
+            ASN1::loadOIDs([
+               // PBES1 encryption schemes
+               'pbeWithMD2AndDES-CBC' => '1.2.840.113549.1.5.1',
+               'pbeWithMD2AndRC2-CBC' => '1.2.840.113549.1.5.4',
+               'pbeWithMD5AndDES-CBC' => '1.2.840.113549.1.5.3',
+               'pbeWithMD5AndRC2-CBC' => '1.2.840.113549.1.5.6',
+               'pbeWithSHA1AndDES-CBC' => '1.2.840.113549.1.5.10',
+               'pbeWithSHA1AndRC2-CBC' => '1.2.840.113549.1.5.11',
+
+               // from PKCS#12:
+               // https://tools.ietf.org/html/rfc7292
+               'pbeWithSHAAnd128BitRC4' => '1.2.840.113549.1.12.1.1',
+               'pbeWithSHAAnd40BitRC4' => '1.2.840.113549.1.12.1.2',
+               'pbeWithSHAAnd3-KeyTripleDES-CBC' => '1.2.840.113549.1.12.1.3',
+               'pbeWithSHAAnd2-KeyTripleDES-CBC' => '1.2.840.113549.1.12.1.4',
+               'pbeWithSHAAnd128BitRC2-CBC' => '1.2.840.113549.1.12.1.5',
+               'pbeWithSHAAnd40BitRC2-CBC' => '1.2.840.113549.1.12.1.6',
+
+               'id-PBKDF2' => '1.2.840.113549.1.5.12',
+               'id-PBES2' => '1.2.840.113549.1.5.13',
+               'id-PBMAC1' => '1.2.840.113549.1.5.14',
+
+               // from PKCS#5 v2.1:
+               // http://www.rsa.com/rsalabs/pkcs/files/h11302-wp-pkcs5v2-1-password-based-cryptography-standard.pdf
+               'id-hmacWithSHA1' => '1.2.840.113549.2.7',
+               'id-hmacWithSHA224' => '1.2.840.113549.2.8',
+               'id-hmacWithSHA256' => '1.2.840.113549.2.9',
+               'id-hmacWithSHA384' => '1.2.840.113549.2.10',
+               'id-hmacWithSHA512' => '1.2.840.113549.2.11',
+               'id-hmacWithSHA512-224' => '1.2.840.113549.2.12',
+               'id-hmacWithSHA512-256' => '1.2.840.113549.2.13',
+
+               'desCBC'       => '1.3.14.3.2.7',
+               'des-EDE3-CBC' => '1.2.840.113549.3.7',
+               'rc2CBC' => '1.2.840.113549.3.2',
+               'rc5-CBC-PAD' => '1.2.840.113549.3.9',
+
+               'aes128-CBC-PAD' => '2.16.840.1.101.3.4.1.2',
+               'aes192-CBC-PAD' => '2.16.840.1.101.3.4.1.22',
+               'aes256-CBC-PAD' => '2.16.840.1.101.3.4.1.42',
+            ]);
+            self::$oidsLoaded = true;
+        }
+    }
+
+    /**
+     * Break a public or private key down into its constituent components
+     *
+     * @param string|array $key
+     */
+    protected static function load($key, ?string $password = null): array
+    {
+        if (!Strings::is_stringable($key)) {
+            throw new UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        $isPublic = str_contains($key, 'PUBLIC');
+        $isPrivate = str_contains($key, 'PRIVATE');
+
+        $decoded = self::preParse($key);
+
+        $meta = [];
+
+        $decrypted = ASN1::asn1map($decoded[0], Maps\EncryptedPrivateKeyInfo::MAP);
+        if ($password !== null && strlen($password) && is_array($decrypted)) {
+            $algorithm = $decrypted['encryptionAlgorithm']['algorithm'];
+            switch ($algorithm) {
+                // PBES1
+                case 'pbeWithMD2AndDES-CBC':
+                case 'pbeWithMD2AndRC2-CBC':
+                case 'pbeWithMD5AndDES-CBC':
+                case 'pbeWithMD5AndRC2-CBC':
+                case 'pbeWithSHA1AndDES-CBC':
+                case 'pbeWithSHA1AndRC2-CBC':
+                case 'pbeWithSHAAnd3-KeyTripleDES-CBC':
+                case 'pbeWithSHAAnd2-KeyTripleDES-CBC':
+                case 'pbeWithSHAAnd128BitRC2-CBC':
+                case 'pbeWithSHAAnd40BitRC2-CBC':
+                case 'pbeWithSHAAnd128BitRC4':
+                case 'pbeWithSHAAnd40BitRC4':
+                    $cipher = self::getPBES1EncryptionObject($algorithm);
+                    $hash = self::getPBES1Hash($algorithm);
+                    $kdf = self::getPBES1KDF($algorithm);
+
+                    $meta['meta']['algorithm'] = $algorithm;
+
+                    $temp = ASN1::decodeBER($decrypted['encryptionAlgorithm']['parameters']);
+                    if (!$temp) {
+                        throw new RuntimeException('Unable to decode BER');
+                    }
+                    extract(ASN1::asn1map($temp[0], Maps\PBEParameter::MAP));
+                    $iterationCount = (int) $iterationCount->toString();
+                    $cipher->setPassword($password, $kdf, $hash, $salt, $iterationCount);
+                    $key = $cipher->decrypt($decrypted['encryptedData']);
+                    $decoded = ASN1::decodeBER($key);
+                    if (!$decoded) {
+                        throw new RuntimeException('Unable to decode BER 2');
+                    }
+
+                    break;
+                case 'id-PBES2':
+                    $meta['meta']['algorithm'] = $algorithm;
+
+                    $temp = ASN1::decodeBER($decrypted['encryptionAlgorithm']['parameters']);
+                    if (!$temp) {
+                        throw new RuntimeException('Unable to decode BER');
+                    }
+                    $temp = ASN1::asn1map($temp[0], Maps\PBES2params::MAP);
+                    extract($temp);
+
+                    $cipher = self::getPBES2EncryptionObject($encryptionScheme['algorithm']);
+                    $meta['meta']['cipher'] = $encryptionScheme['algorithm'];
+
+                    $temp = ASN1::decodeBER($decrypted['encryptionAlgorithm']['parameters']);
+                    if (!$temp) {
+                        throw new RuntimeException('Unable to decode BER');
+                    }
+                    $temp = ASN1::asn1map($temp[0], Maps\PBES2params::MAP);
+                    extract($temp);
+
+                    if (!$cipher instanceof RC2) {
+                        $cipher->setIV($encryptionScheme['parameters']['octetString']);
+                    } else {
+                        $temp = ASN1::decodeBER($encryptionScheme['parameters']);
+                        if (!$temp) {
+                            throw new RuntimeException('Unable to decode BER');
+                        }
+                        extract(ASN1::asn1map($temp[0], Maps\RC2CBCParameter::MAP));
+                        $effectiveKeyLength = (int) $rc2ParametersVersion->toString();
+                        switch ($effectiveKeyLength) {
+                            case 160:
+                                $effectiveKeyLength = 40;
+                                break;
+                            case 120:
+                                $effectiveKeyLength = 64;
+                                break;
+                            case 58:
+                                $effectiveKeyLength = 128;
+                                break;
+                            //default: // should be >= 256
+                        }
+                        $cipher->setIV($iv);
+                        $cipher->setKeyLength($effectiveKeyLength);
+                    }
+
+                    $meta['meta']['keyDerivationFunc'] = $keyDerivationFunc['algorithm'];
+                    switch ($keyDerivationFunc['algorithm']) {
+                        case 'id-PBKDF2':
+                            $temp = ASN1::decodeBER($keyDerivationFunc['parameters']);
+                            if (!$temp) {
+                                throw new RuntimeException('Unable to decode BER');
+                            }
+                            $prf = ['algorithm' => 'id-hmacWithSHA1'];
+                            $params = ASN1::asn1map($temp[0], Maps\PBKDF2params::MAP);
+                            extract($params);
+                            $meta['meta']['prf'] = $prf['algorithm'];
+                            $hash = str_replace('-', '/', substr($prf['algorithm'], 11));
+                            $params = [
+                                $password,
+                                'pbkdf2',
+                                $hash,
+                                $salt,
+                                (int) $iterationCount->toString(),
+                            ];
+                            if (isset($keyLength)) {
+                                $params[] = (int) $keyLength->toString();
+                            }
+                            $cipher->setPassword(...$params);
+                            $key = $cipher->decrypt($decrypted['encryptedData']);
+                            $decoded = ASN1::decodeBER($key);
+                            if (!$decoded) {
+                                throw new RuntimeException('Unable to decode BER 3');
+                            }
+                            break;
+                        default:
+                            throw new UnsupportedAlgorithmException('Only PBKDF2 is supported for PBES2 PKCS#8 keys');
+                    }
+                    break;
+                case 'id-PBMAC1':
+                    //$temp = ASN1::decodeBER($decrypted['encryptionAlgorithm']['parameters']);
+                    //$value = ASN1::asn1map($temp[0], Maps\PBMAC1params::MAP);
+                    // since i can't find any implementation that does PBMAC1 it is unsupported
+                    throw new UnsupportedAlgorithmException('Only PBES1 and PBES2 PKCS#8 keys are supported.');
+                // at this point we'll assume that the key conforms to PublicKeyInfo
+            }
+        }
+
+        $private = ASN1::asn1map($decoded[0], Maps\OneAsymmetricKey::MAP);
+        if (is_array($private)) {
+            if ($isPublic) {
+                throw new UnexpectedValueException('Human readable string claims public key but DER encoded string claims private key');
+            }
+
+            if (isset($private['privateKeyAlgorithm']['parameters']) && !$private['privateKeyAlgorithm']['parameters'] instanceof ASN1\Element && isset($decoded[0]['content'][1]['content'][1])) {
+                $temp = $decoded[0]['content'][1]['content'][1];
+                $private['privateKeyAlgorithm']['parameters'] = new ASN1\Element(substr($key, $temp['start'], $temp['length']));
+            }
+            if (is_array(static::OID_NAME)) {
+                if (!in_array($private['privateKeyAlgorithm']['algorithm'], static::OID_NAME)) {
+                    throw new UnsupportedAlgorithmException($private['privateKeyAlgorithm']['algorithm'] . ' is not a supported key type');
+                }
+            } else {
+                if ($private['privateKeyAlgorithm']['algorithm'] != static::OID_NAME) {
+                    throw new UnsupportedAlgorithmException('Only ' . static::OID_NAME . ' keys are supported; this is a ' . $private['privateKeyAlgorithm']['algorithm'] . ' key');
+                }
+            }
+            if (isset($private['publicKey'])) {
+                if ($private['publicKey'][0] != "\0") {
+                    throw new UnexpectedValueException('The first byte of the public key should be null - not ' . bin2hex($private['publicKey'][0]));
+                }
+                $private['publicKey'] = substr($private['publicKey'], 1);
+            }
+            return $private + $meta;
+        }
+
+        // EncryptedPrivateKeyInfo and PublicKeyInfo have largely identical "signatures". the only difference
+        // is that the former has an octet string and the later has a bit string. the first byte of a bit
+        // string represents the number of bits in the last byte that are to be ignored but, currently,
+        // 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 ($isPrivate) {
+                throw new UnexpectedValueException('Human readable string claims private key but DER encoded string claims public key');
+            }
+
+            if ($public['publicKey'][0] != "\0") {
+                throw new UnexpectedValueException('The first byte of the public key should be null - not ' . bin2hex($public['publicKey'][0]));
+            }
+            if (is_array(static::OID_NAME)) {
+                if (!in_array($public['publicKeyAlgorithm']['algorithm'], static::OID_NAME)) {
+                    throw new UnsupportedAlgorithmException($public['publicKeyAlgorithm']['algorithm'] . ' is not a supported key type');
+                }
+            } else {
+                if ($public['publicKeyAlgorithm']['algorithm'] != static::OID_NAME) {
+                    throw new UnsupportedAlgorithmException('Only ' . static::OID_NAME . ' keys are supported; this is a ' . $public['publicKeyAlgorithm']['algorithm'] . ' key');
+                }
+            }
+            if (isset($public['publicKeyAlgorithm']['parameters']) && !$public['publicKeyAlgorithm']['parameters'] instanceof ASN1\Element && isset($decoded[0]['content'][0]['content'][1])) {
+                $temp = $decoded[0]['content'][0]['content'][1];
+                $public['publicKeyAlgorithm']['parameters'] = new ASN1\Element(substr($key, $temp['start'], $temp['length']));
+            }
+            $public['publicKey'] = substr($public['publicKey'], 1);
+            return $public;
+        }
+
+        throw new RuntimeException('Unable to parse using either OneAsymmetricKey or PublicKeyInfo ASN1 maps');
+    }
+
+    /**
+     * Wrap a private key appropriately
+     *
+     * @param array|string $attr
+     * @param string|false $password
+     * @param string|null $oid optional
+     * @param string $publicKey optional
+     * @param array $options optional
+     */
+    protected static function wrapPrivateKey(string $key, $attr, $params, $password, ?string $oid = null, string $publicKey = '', array $options = []): string
+    {
+        self::initialize_static_variables();
+
+        $key = [
+            'version' => 'v1',
+            'privateKeyAlgorithm' => [
+                'algorithm' => is_string(static::OID_NAME) ? static::OID_NAME : $oid,
+             ],
+            'privateKey' => $key,
+        ];
+        if ($oid != 'id-Ed25519' && $oid != 'id-Ed448') {
+            $key['privateKeyAlgorithm']['parameters'] = $params;
+        }
+        if (!empty($attr)) {
+            $key['attributes'] = $attr;
+        }
+        if (!empty($publicKey)) {
+            $key['version'] = 'v2';
+            $key['publicKey'] = $publicKey;
+        }
+        $key = ASN1::encodeDER($key, Maps\OneAsymmetricKey::MAP);
+        if (!empty($password) && is_string($password)) {
+            $salt = Random::string(8);
+
+            $iterationCount = $options['iterationCount'] ?? self::$defaultIterationCount;
+            $encryptionAlgorithm = $options['encryptionAlgorithm'] ?? self::$defaultEncryptionAlgorithm;
+            $encryptionScheme = $options['encryptionScheme'] ?? self::$defaultEncryptionScheme;
+            $prf = $options['PRF'] ?? self::$defaultPRF;
+
+            if ($encryptionAlgorithm == 'id-PBES2') {
+                $crypto = self::getPBES2EncryptionObject($encryptionScheme);
+                $hash = str_replace('-', '/', substr($prf, 11));
+                $kdf = 'pbkdf2';
+                $iv = Random::string($crypto->getBlockLength() >> 3);
+
+                $PBKDF2params = [
+                    'salt' => $salt,
+                    'iterationCount' => $iterationCount,
+                    'prf' => ['algorithm' => $prf, 'parameters' => null],
+                ];
+                $PBKDF2params = ASN1::encodeDER($PBKDF2params, Maps\PBKDF2params::MAP);
+
+                if (!$crypto instanceof RC2) {
+                    $params = ['octetString' => $iv];
+                } else {
+                    $params = [
+                        'rc2ParametersVersion' => 58,
+                        'iv' => $iv,
+                    ];
+                    $params = ASN1::encodeDER($params, Maps\RC2CBCParameter::MAP);
+                    $params = new ASN1\Element($params);
+                }
+
+                $params = [
+                    'keyDerivationFunc' => [
+                        'algorithm' => 'id-PBKDF2',
+                        'parameters' => new ASN1\Element($PBKDF2params),
+                    ],
+                    'encryptionScheme' => [
+                        'algorithm' => $encryptionScheme,
+                        'parameters' => $params,
+                    ],
+                ];
+                $params = ASN1::encodeDER($params, Maps\PBES2params::MAP);
+
+                $crypto->setIV($iv);
+            } else {
+                $crypto = self::getPBES1EncryptionObject($encryptionAlgorithm);
+                $hash = self::getPBES1Hash($encryptionAlgorithm);
+                $kdf = self::getPBES1KDF($encryptionAlgorithm);
+
+                $params = [
+                    'salt' => $salt,
+                    'iterationCount' => $iterationCount,
+                ];
+                $params = ASN1::encodeDER($params, Maps\PBEParameter::MAP);
+            }
+            $crypto->setPassword($password, $kdf, $hash, $salt, $iterationCount);
+            $key = $crypto->encrypt($key);
+
+            $key = [
+                'encryptionAlgorithm' => [
+                    'algorithm' => $encryptionAlgorithm,
+                    'parameters' => new ASN1\Element($params),
+                ],
+                'encryptedData' => $key,
+            ];
+
+            $key = ASN1::encodeDER($key, Maps\EncryptedPrivateKeyInfo::MAP);
+
+            return "-----BEGIN ENCRYPTED PRIVATE KEY-----\r\n" .
+                   chunk_split(Strings::base64_encode($key), 64) .
+                   "-----END ENCRYPTED PRIVATE KEY-----";
+        }
+
+        return "-----BEGIN PRIVATE KEY-----\r\n" .
+               chunk_split(Strings::base64_encode($key), 64) .
+               "-----END PRIVATE KEY-----";
+    }
+
+    /**
+     * Wrap a public key appropriately
+     */
+    protected static function wrapPublicKey(string $key, $params, ?string $oid = null): string
+    {
+        self::initialize_static_variables();
+
+        $key = [
+            'publicKeyAlgorithm' => [
+                'algorithm' => is_string(static::OID_NAME) ? static::OID_NAME : $oid,
+            ],
+            'publicKey' => "\0" . $key,
+        ];
+
+        if ($oid != 'id-Ed25519' && $oid != 'id-Ed448') {
+            $key['publicKeyAlgorithm']['parameters'] = $params;
+        }
+
+        $key = ASN1::encodeDER($key, Maps\PublicKeyInfo::MAP);
+
+        return "-----BEGIN PUBLIC KEY-----\r\n" .
+               chunk_split(Strings::base64_encode($key), 64) .
+               "-----END PUBLIC KEY-----";
+    }
+
+    /**
+     * Perform some preliminary parsing of the key
+     *
+     * @param string|array $key
+     */
+    private static function preParse(&$key): array
+    {
+        self::initialize_static_variables();
+
+        if (self::$format != self::MODE_DER) {
+            $decoded = ASN1::extractBER($key);
+            if ($decoded !== false) {
+                $key = $decoded;
+            } elseif (self::$format == self::MODE_PEM) {
+                throw new UnexpectedValueException('Expected base64-encoded PEM format but was unable to decode base64 text');
+            }
+        }
+
+        $decoded = ASN1::decodeBER($key);
+        if (!$decoded) {
+            throw new RuntimeException('Unable to decode BER');
+        }
+
+        return $decoded;
+    }
+
+    /**
+     * Returns the encryption parameters used by the key
+     */
+    public static function extractEncryptionAlgorithm(string $key): array
+    {
+        if (!Strings::is_stringable($key)) {
+            throw new UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        $decoded = self::preParse($key);
+
+        $r = ASN1::asn1map($decoded[0], Maps\EncryptedPrivateKeyInfo::MAP);
+        if (!is_array($r)) {
+            throw new RuntimeException('Unable to parse using EncryptedPrivateKeyInfo map');
+        }
+
+        if ($r['encryptionAlgorithm']['algorithm'] == 'id-PBES2') {
+            $decoded = ASN1::decodeBER($r['encryptionAlgorithm']['parameters']->element);
+            if (!$decoded) {
+                throw new RuntimeException('Unable to decode BER');
+            }
+            $r['encryptionAlgorithm']['parameters'] = ASN1::asn1map($decoded[0], Maps\PBES2params::MAP);
+
+            $kdf = &$r['encryptionAlgorithm']['parameters']['keyDerivationFunc'];
+            switch ($kdf['algorithm']) {
+                case 'id-PBKDF2':
+                    $decoded = ASN1::decodeBER($kdf['parameters']->element);
+                    if (!$decoded) {
+                        throw new RuntimeException('Unable to decode BER');
+                    }
+                    $kdf['parameters'] = ASN1::asn1map($decoded[0], Maps\PBKDF2params::MAP);
+            }
+        }
+
+        return $r['encryptionAlgorithm'];
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Keys/PuTTY.php

@@ -0,0 +1,353 @@
+<?php
+
+/**
+ * PuTTY Formatted Key Handler
+ *
+ * See PuTTY's SSHPUBK.C and https://tartarus.org/~simon/putty-snapshots/htmldoc/AppendixC.html
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Keys;
+
+use phpseclib3\Common\Functions\Strings;
+use phpseclib3\Crypt\AES;
+use phpseclib3\Crypt\Hash;
+use phpseclib3\Crypt\Random;
+use phpseclib3\Exception\RuntimeException;
+use phpseclib3\Exception\UnexpectedValueException;
+use phpseclib3\Exception\UnsupportedAlgorithmException;
+
+/**
+ * PuTTY Formatted Key Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class PuTTY
+{
+    /**
+     * Default comment
+     *
+     * @var string
+     */
+    private static $comment = 'phpseclib-generated-key';
+
+    /**
+     * Default version
+     *
+     * @var int
+     */
+    private static $version = 2;
+
+    /**
+     * Sets the default comment
+     */
+    public static function setComment(string $comment): void
+    {
+        self::$comment = str_replace(["\r", "\n"], '', $comment);
+    }
+
+    /**
+     * Sets the default version
+     */
+    public static function setVersion(int $version): void
+    {
+        if ($version != 2 && $version != 3) {
+            throw new RuntimeException('Only supported versions are 2 and 3');
+        }
+        self::$version = $version;
+    }
+
+    /**
+     * Generate a symmetric key for PuTTY v2 keys
+     */
+    private static function generateV2Key(string $password, int $length): string
+    {
+        $symkey = '';
+        $sequence = 0;
+        while (strlen($symkey) < $length) {
+            $temp = pack('Na*', $sequence++, $password);
+            $symkey .= Strings::hex2bin(sha1($temp));
+        }
+        return substr($symkey, 0, $length);
+    }
+
+    /**
+     * Generate a symmetric key for PuTTY v3 keys
+     */
+    private static function generateV3Key(string $password, string $flavour, int $memory, int $passes, string $salt): array
+    {
+        if (!function_exists('sodium_crypto_pwhash')) {
+            throw new RuntimeException('sodium_crypto_pwhash needs to exist for Argon2 password hasing');
+        }
+
+        switch ($flavour) {
+            case 'Argon2i':
+                $flavour = SODIUM_CRYPTO_PWHASH_ALG_ARGON2I13;
+                break;
+            case 'Argon2id':
+                $flavour = SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13;
+                break;
+            default:
+                throw new UnsupportedAlgorithmException('Only Argon2i and Argon2id are supported');
+        }
+
+        $length = 80; // keylen + ivlen + mac_keylen
+        $temp = sodium_crypto_pwhash($length, $password, $salt, $passes, $memory << 10, $flavour);
+
+        $symkey = substr($temp, 0, 32);
+        $symiv = substr($temp, 32, 16);
+        $hashkey = substr($temp, -32);
+
+        return compact('symkey', 'symiv', 'hashkey');
+    }
+
+    /**
+     * Break a public or private key down into its constituent components
+     *
+     * @param array|string $key
+     * @param string|false $password
+     * @return array|false
+     */
+    public static function load($key, $password)
+    {
+        if (!Strings::is_stringable($key)) {
+            throw new UnexpectedValueException('Key should be a string - not a ' . gettype($key));
+        }
+
+        if (str_contains($key, 'BEGIN SSH2 PUBLIC KEY')) {
+            $lines = preg_split('#[\r\n]+#', $key);
+            switch (true) {
+                case $lines[0] != '---- BEGIN SSH2 PUBLIC KEY ----':
+                    throw new UnexpectedValueException('Key doesn\'t start with ---- BEGIN SSH2 PUBLIC KEY ----');
+                case $lines[count($lines) - 1] != '---- END SSH2 PUBLIC KEY ----':
+                    throw new UnexpectedValueException('Key doesn\'t end with ---- END SSH2 PUBLIC KEY ----');
+            }
+            $lines = array_splice($lines, 1, -1);
+            $lines = array_map(fn ($line) => rtrim($line, "\r\n"), $lines);
+            $data = $current = '';
+            $values = [];
+            $in_value = false;
+            foreach ($lines as $line) {
+                switch (true) {
+                    case preg_match('#^(.*?): (.*)#', $line, $match):
+                        $in_value = $line[-1] == '\\';
+                        $current = strtolower($match[1]);
+                        $values[$current] = $in_value ? substr($match[2], 0, -1) : $match[2];
+                        break;
+                    case $in_value:
+                        $in_value = $line[-1] == '\\';
+                        $values[$current] .= $in_value ? substr($line, 0, -1) : $line;
+                        break;
+                    default:
+                        $data .= $line;
+                }
+            }
+
+            $components = call_user_func([static::PUBLIC_HANDLER, 'load'], $data);
+            if ($components === false) {
+                throw new UnexpectedValueException('Unable to decode public key');
+            }
+            $components += $values;
+            $components['comment'] = str_replace(['\\\\', '\"'], ['\\', '"'], $values['comment']);
+
+            return $components;
+        }
+
+        $components = [];
+
+        $key = preg_split('#\r\n|\r|\n#', trim($key));
+        if (Strings::shift($key[0], strlen('PuTTY-User-Key-File-')) != 'PuTTY-User-Key-File-') {
+            return false;
+        }
+        $version = (int) Strings::shift($key[0], 3); // should be either "2: " or "3: 0" prior to int casting
+        if ($version != 2 && $version != 3) {
+            throw new RuntimeException('Only v2 and v3 PuTTY private keys are supported');
+        }
+        $components['type'] = $type = rtrim($key[0]);
+        if (!in_array($type, static::$types)) {
+            $error = count(static::$types) == 1 ?
+                'Only ' . static::$types[0] . ' keys are supported. ' :
+                '';
+            throw new UnsupportedAlgorithmException($error . 'This is an unsupported ' . $type . ' key');
+        }
+        $encryption = trim(preg_replace('#Encryption: (.+)#', '$1', $key[1]));
+        $components['comment'] = trim(preg_replace('#Comment: (.+)#', '$1', $key[2]));
+
+        $publicLength = (int) trim(preg_replace('#Public-Lines: (\d+)#', '$1', $key[3]));
+        $public = Strings::base64_decode(implode('', array_map('trim', array_slice($key, 4, $publicLength))));
+
+        $source = Strings::packSSH2('ssss', $type, $encryption, $components['comment'], $public);
+
+        extract(unpack('Nlength', Strings::shift($public, 4)));
+        $newtype = Strings::shift($public, $length);
+        if ($newtype != $type) {
+            throw new RuntimeException('The binary type does not match the human readable type field');
+        }
+
+        $components['public'] = $public;
+
+        switch ($version) {
+            case 3:
+                $hashkey = '';
+                break;
+            case 2:
+                $hashkey = 'putty-private-key-file-mac-key';
+        }
+
+        $offset = $publicLength + 4;
+        switch ($encryption) {
+            case 'aes256-cbc':
+                $crypto = new AES('cbc');
+                switch ($version) {
+                    case 3:
+                        $flavour = trim(preg_replace('#Key-Derivation: (.*)#', '$1', $key[$offset++]));
+                        $memory = trim(preg_replace('#Argon2-Memory: (\d+)#', '$1', $key[$offset++]));
+                        $passes = trim(preg_replace('#Argon2-Passes: (\d+)#', '$1', $key[$offset++]));
+                        $parallelism = trim(preg_replace('#Argon2-Parallelism: (\d+)#', '$1', $key[$offset++]));
+                        $salt = Strings::hex2bin(trim(preg_replace('#Argon2-Salt: ([0-9a-f]+)#', '$1', $key[$offset++])));
+
+                        extract(self::generateV3Key($password, $flavour, (int)$memory, (int)$passes, $salt));
+
+                        break;
+                    case 2:
+                        $symkey = self::generateV2Key($password, 32);
+                        $symiv = str_repeat("\0", $crypto->getBlockLength() >> 3);
+                        $hashkey .= $password;
+                }
+        }
+
+        switch ($version) {
+            case 3:
+                $hash = new Hash('sha256');
+                $hash->setKey($hashkey);
+                break;
+            case 2:
+                $hash = new Hash('sha1');
+                $hash->setKey(sha1($hashkey, true));
+        }
+
+        $privateLength = (int) trim(preg_replace('#Private-Lines: (\d+)#', '$1', $key[$offset++]));
+        $private = Strings::base64_decode(implode('', array_map('trim', array_slice($key, $offset, $privateLength))));
+
+        if ($encryption != 'none') {
+            $crypto->setKey($symkey);
+            $crypto->setIV($symiv);
+            $crypto->disablePadding();
+            $private = $crypto->decrypt($private);
+        }
+
+        $source .= Strings::packSSH2('s', $private);
+
+        $hmac = trim(preg_replace('#Private-MAC: (.+)#', '$1', $key[$offset + $privateLength]));
+        $hmac = Strings::hex2bin($hmac);
+
+        if (!hash_equals($hash->hash($source), $hmac)) {
+            throw new UnexpectedValueException('MAC validation error');
+        }
+
+        $components['private'] = $private;
+
+        return $components;
+    }
+
+    /**
+     * Wrap a private key appropriately
+     *
+     * @param string|false $password
+     * @param array $options optional
+     */
+    protected static function wrapPrivateKey(string $public, string $private, string $type, $password, array $options = []): string
+    {
+        $encryption = (!empty($password) || is_string($password)) ? 'aes256-cbc' : 'none';
+        $comment = $options['comment'] ?? self::$comment;
+        $version = $options['version'] ?? self::$version;
+
+        $key = "PuTTY-User-Key-File-$version: $type\r\n";
+        $key .= "Encryption: $encryption\r\n";
+        $key .= "Comment: $comment\r\n";
+
+        $public = Strings::packSSH2('s', $type) . $public;
+
+        $source = Strings::packSSH2('ssss', $type, $encryption, $comment, $public);
+
+        $public = Strings::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);
+            switch ($version) {
+                case 3:
+                    $hash = new Hash('sha256');
+                    $hash->setKey('');
+                    break;
+                case 2:
+                    $hash = new Hash('sha1');
+                    $hash->setKey(sha1('putty-private-key-file-mac-key', true));
+            }
+        } else {
+            $private .= Random::string(16 - (strlen($private) & 15));
+            $source .= Strings::packSSH2('s', $private);
+            $crypto = new AES('cbc');
+
+            switch ($version) {
+                case 3:
+                    $salt = Random::string(16);
+                    $key .= "Key-Derivation: Argon2id\r\n";
+                    $key .= "Argon2-Memory: 8192\r\n";
+                    $key .= "Argon2-Passes: 13\r\n";
+                    $key .= "Argon2-Parallelism: 1\r\n";
+                    $key .= "Argon2-Salt: " . Strings::bin2hex($salt) . "\r\n";
+                    extract(self::generateV3Key($password, 'Argon2id', 8192, 13, $salt));
+
+                    $hash = new Hash('sha256');
+                    $hash->setKey($hashkey);
+
+                    break;
+                case 2:
+                    $symkey = self::generateV2Key($password, 32);
+                    $symiv = str_repeat("\0", $crypto->getBlockLength() >> 3);
+                    $hashkey = 'putty-private-key-file-mac-key' . $password;
+
+                    $hash = new Hash('sha1');
+                    $hash->setKey(sha1($hashkey, true));
+            }
+
+            $crypto->setKey($symkey);
+            $crypto->setIV($symiv);
+            $crypto->disablePadding();
+            $private = $crypto->encrypt($private);
+            $mac = $hash->hash($source);
+        }
+
+        $private = Strings::base64_encode($private);
+        $key .= 'Private-Lines: ' . ((strlen($private) + 63) >> 6) . "\r\n";
+        $key .= chunk_split($private, 64);
+        $key .= 'Private-MAC: ' . Strings::bin2hex($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)
+     */
+    protected static function wrapPublicKey(string $key, string $type): string
+    {
+        $key = pack('Na*a*', strlen($type), $type, $key);
+        $key = "---- BEGIN SSH2 PUBLIC KEY ----\r\n" .
+               'Comment: "' . str_replace(['\\', '"'], ['\\\\', '\"'], self::$comment) . "\"\r\n" .
+               chunk_split(Strings::base64_encode($key), 64) .
+               '---- END SSH2 PUBLIC KEY ----';
+        return $key;
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Formats/Signature/Raw.php

@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * Raw Signature Handler
+ *
+ * PHP version 5
+ *
+ * Handles signatures as arrays
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Formats\Signature;
+
+use phpseclib3\Math\BigInteger;
+
+/**
+ * Raw Signature Handler
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class Raw
+{
+    /**
+     * Loads a signature
+     *
+     * @return array|bool
+     */
+    public static function load(array $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' => $sig['r'],
+            's' => $sig['s'],
+        ];
+    }
+
+    /**
+     * Returns a signature in the appropriate format
+     */
+    public static function save(BigInteger $r, BigInteger $s): string
+    {
+        return compact('r', 's');
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/PrivateKey.php

@@ -0,0 +1,32 @@
+<?php
+
+/**
+ * PrivateKey interface
+ *
+ * @author    Jim Wigginton <terrafrost@php.net>
+ * @copyright 2009 Jim Wigginton
+ * @license   http://www.opensource.org/licenses/mit-license.html  MIT License
+ * @link      http://phpseclib.sourceforge.net
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common;
+
+/**
+ * PrivateKey interface
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+interface PrivateKey
+{
+    public function sign($message);
+    //public function decrypt($ciphertext);
+    public function getPublicKey();
+    public function toString(string $type, array $options = []): string;
+
+    /**
+     * @return static
+     */
+    public function withPassword(?string $password = null): PrivateKey;
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/PublicKey.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * PublicKey interface
+ *
+ * @author    Jim Wigginton <terrafrost@php.net>
+ * @copyright 2009 Jim Wigginton
+ * @license   http://www.opensource.org/licenses/mit-license.html  MIT License
+ * @link      http://phpseclib.sourceforge.net
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common;
+
+/**
+ * PublicKey interface
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+interface PublicKey
+{
+    public function verify($message, $signature);
+    //public function encrypt($plaintext);
+    public function toString(string $type, array $options = []): string;
+    public function getFingerprint($algorithm);
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/StreamCipher.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * Base Class for all stream ciphers
+ *
+ * PHP version 5
+ *
+ * @author    Jim Wigginton <terrafrost@php.net>
+ * @author    Hans-Juergen Petrich <petrich@tronic-media.com>
+ * @copyright 2007 Jim Wigginton
+ * @license   http://www.opensource.org/licenses/mit-license.html  MIT License
+ * @link      http://phpseclib.sourceforge.net
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common;
+
+/**
+ * Base Class for all stream cipher classes
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+abstract class StreamCipher extends SymmetricKey
+{
+    /**
+     * Block Length of the cipher
+     *
+     * Stream ciphers do not have a block size
+     *
+     * @see \phpseclib3\Crypt\Common\SymmetricKey::block_size
+     * @var int
+     */
+    protected $block_size = 0;
+
+    /**
+     * Default Constructor.
+     *
+     * @see \phpseclib3\Crypt\Common\SymmetricKey::__construct()
+     * @return StreamCipher
+     */
+    public function __construct()
+    {
+        parent::__construct('stream');
+    }
+
+    /**
+     * Stream ciphers not use an IV
+     */
+    public function usesIV(): bool
+    {
+        return false;
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Traits/Fingerprint.php

@@ -0,0 +1,58 @@
+<?php
+
+/**
+ * Fingerprint Trait for Public Keys
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Traits;
+
+use phpseclib3\Crypt\Hash;
+
+/**
+ * Fingerprint Trait for Private Keys
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+trait Fingerprint
+{
+    /**
+     * 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)
+     *
+     * @param string $algorithm The hashing algorithm to be used. Valid options are 'md5' and 'sha256'. False is returned
+     * for invalid values.
+     */
+    public function getFingerprint($algorithm = 'md5')
+    {
+        $type = self::validatePlugin('Keys', 'OpenSSH', 'savePublicKey');
+        if ($type === false) {
+            return false;
+        }
+        $key = $this->toString('OpenSSH', ['binary' => true]);
+        if ($key === false) {
+            return false;
+        }
+        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;
+        }
+    }
+}

qa-tool/htdocs/oidc/phpseclib/Crypt/Common/Traits/PasswordProtected.php

@@ -0,0 +1,47 @@
+<?php
+
+/**
+ * Password Protected Trait for Private Keys
+ *
+ * PHP version 5
+ *
+ * @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
+ */
+
+declare(strict_types=1);
+
+namespace phpseclib3\Crypt\Common\Traits;
+
+/**
+ * Password Protected Trait for Private Keys
+ *
+ * @author  Jim Wigginton <terrafrost@php.net>
+ */
+trait PasswordProtected
+{
+    /**
+     * @var string|null
+     */
+    private $password = null;
+
+    /**
+     * 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()
+     *
+     * @return static
+     */
+    public function withPassword(?string $password = null): self
+    {
+        $new = clone $this;
+        $new->password = $password;
+        return $new;
+    }
+}