welcome back to dyb-tech

2024-05-18 02:28:01 +02:00
parent 9513cdba09
commit 9f30bc98c7
6149 changed files with 668407 additions and 0 deletions
@@ -0,0 +1,117 @@
+<?php
+
+namespace Lexik\Bundle\JWTAuthenticationBundle\Services\KeyLoader;
+
+/**
+ * Abstract class for key loaders.
+ *
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ *
+ * @internal
+ */
+abstract class AbstractKeyLoader implements KeyLoaderInterface
+{
+    private $signingKey;
+    private $publicKey;
+    private $passphrase;
+    private $additionalPublicKeys;
+
+    public function __construct(?string $signingKey = null, ?string $publicKey = null, ?string $passphrase = null, array $additionalPublicKeys = [])
+    {
+        $this->signingKey = $signingKey;
+        $this->publicKey = $publicKey;
+        $this->passphrase = $passphrase;
+        $this->additionalPublicKeys = $additionalPublicKeys;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getPassphrase()
+    {
+        return $this->passphrase;
+    }
+
+    public function getSigningKey()
+    {
+        return $this->signingKey && is_file($this->signingKey) ? $this->readKey(self::TYPE_PRIVATE) : $this->signingKey;
+    }
+
+    public function getPublicKey()
+    {
+        return $this->publicKey && is_file($this->publicKey) ? $this->readKey(self::TYPE_PUBLIC) : $this->publicKey;
+    }
+
+    public function getAdditionalPublicKeys(): array
+    {
+        $contents = [];
+
+        foreach ($this->additionalPublicKeys as $key) {
+            if (!$key || !is_file($key) || !is_readable($key)) {
+                throw new \RuntimeException(sprintf('Additional public key "%s" does not exist or is not readable. Did you correctly set the "lexik_jwt_authentication.additional_public_keys" configuration key?', $key));
+            }
+
+            $rawKey = $key;
+
+            if (is_file($key)) {
+                $rawKey = @file_get_contents($key);
+
+                if (false === $rawKey) {
+                    // Try invalidating the realpath cache
+                    clearstatcache(true, $key);
+                    $rawKey = file_get_contents($key);
+                }
+            }
+            $contents[] = $rawKey;
+        }
+
+        return $contents;
+    }
+
+    /**
+     * @param string $type One of "public" or "private"
+     *
+     * @return string The path of the key, an empty string if not a valid path
+     *
+     * @throws \InvalidArgumentException If the given type is not valid
+     * @throws \InvalidArgumentException If the given type is not valid
+     */
+    protected function getKeyPath($type)
+    {
+        if (!in_array($type, [self::TYPE_PUBLIC, self::TYPE_PRIVATE])) {
+            throw new \InvalidArgumentException(sprintf('The key type must be "public" or "private", "%s" given.', $type));
+        }
+
+        $path = self::TYPE_PUBLIC === $type ? $this->publicKey : $this->signingKey;
+
+        if (!is_file($path) || !is_readable($path)) {
+            throw new \RuntimeException(sprintf('%s key is not a file or is not readable.', ucfirst($type)));
+        }
+
+        return $path;
+    }
+
+    private function readKey($type)
+    {
+        $isPublic = self::TYPE_PUBLIC === $type;
+        $key = $isPublic ? $this->publicKey : $this->signingKey;
+
+        if (!$key || !is_file($key) || !is_readable($key)) {
+            if ($isPublic) {
+                return null;
+            }
+
+            throw new \RuntimeException(sprintf('Signature key "%s" does not exist or is not readable. Did you correctly set the "lexik_jwt_authentication.signature_key" configuration key?', $key));
+        }
+
+        $rawKey = @file_get_contents($key);
+
+        if (false === $rawKey) {
+            // Try invalidating the realpath cache
+            clearstatcache(true, $key);
+            $rawKey = file_get_contents($key);
+        }
+
+        return $rawKey;
+    }
+}
@@ -0,0 +1,16 @@
+<?php
+
+namespace Lexik\Bundle\JWTAuthenticationBundle\Services\KeyLoader;
+
+/**
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ */
+interface KeyDumperInterface
+{
+    /**
+     * Dumps a key to be shared between parties.
+     *
+     * @return resource|string
+     */
+    public function dumpKey();
+}
@@ -0,0 +1,33 @@
+<?php
+
+namespace Lexik\Bundle\JWTAuthenticationBundle\Services\KeyLoader;
+
+/**
+ * Interface for classes that are able to load crypto keys.
+ *
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ *
+ * @method string|null getPublicKey()
+ * @method string|null getSigningKey()
+ * @method array getAdditionalPublicKeys()
+ */
+interface KeyLoaderInterface
+{
+    public const TYPE_PUBLIC = 'public';
+
+    public const TYPE_PRIVATE = 'private';
+
+    /**
+     * Loads a key from a given type (public or private).
+     *
+     * @param resource|string|null $type
+     *
+     * @return resource|string|null
+     */
+    public function loadKey($type);
+
+    /**
+     * @return string|null
+     */
+    public function getPassphrase();
+}
@@ -0,0 +1,67 @@
+<?php
+
+namespace Lexik\Bundle\JWTAuthenticationBundle\Services\KeyLoader;
+
+@trigger_error(sprintf('The "%s\OpenSSLKeyLoader" class is deprecated since version 2.5 and will be removed in 3.0. Use "%s" instead.', __NAMESPACE__, RawKeyLoader::class), E_USER_DEPRECATED);
+
+/**
+ * Load crypto keys for the OpenSSL crypto engine.
+ *
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ *
+ * @deprecated since version 2.5, to be removed in 3.0. Use RawKeyLoader instead
+ */
+class OpenSSLKeyLoader extends AbstractKeyLoader implements KeyDumperInterface
+{
+    /**
+     * {@inheritdoc}
+     *
+     * @throws \RuntimeException If the key cannot be read
+     * @throws \RuntimeException Either the key or the passphrase is not valid
+     */
+    public function loadKey($type)
+    {
+        if (!in_array($type, [self::TYPE_PUBLIC, self::TYPE_PRIVATE])) {
+            throw new \InvalidArgumentException(sprintf('The key type must be "public" or "private", "%s" given.', $type));
+        }
+
+        $keyPath = $this->getKeyPath($type);
+        $rawKey = @file_get_contents($keyPath);
+
+        if (false === $rawKey) {
+            // Try invalidating the realpath cache
+            clearstatcache(true, $keyPath);
+            $rawKey = file_get_contents($keyPath);
+        }
+
+        $key = call_user_func_array("openssl_pkey_get_$type", self::TYPE_PRIVATE == $type ? [$rawKey, $this->getPassphrase()] : [$rawKey]);
+
+        if (!$key) {
+            $sslError = '';
+            while ($msg = trim(openssl_error_string(), " \n\r\t\0\x0B\"")) {
+                if ('error:' === substr($msg, 0, 6)) {
+                    $msg = substr($msg, 6);
+                }
+                $sslError .= "\n $msg";
+            }
+
+            throw new \RuntimeException(sprintf('Failed to load %s key: %s', $type, $sslError));
+        }
+
+        return $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function dumpKey()
+    {
+        $key = openssl_pkey_get_details($this->loadKey('public'));
+
+        if (!isset($key['key'])) {
+            return;
+        }
+
+        return $key['key'];
+    }
+}
@@ -0,0 +1,52 @@
+<?php
+
+namespace Lexik\Bundle\JWTAuthenticationBundle\Services\KeyLoader;
+
+/**
+ * Reads crypto keys.
+ *
+ * @author Robin Chalas <robin.chalas@gmail.com>
+ */
+class RawKeyLoader extends AbstractKeyLoader implements KeyDumperInterface
+{
+    /**
+     * @param string $type
+     *
+     * @return string
+     *
+     * @throws \RuntimeException If the key cannot be read
+     */
+    public function loadKey($type)
+    {
+        if (!in_array($type, [self::TYPE_PUBLIC, self::TYPE_PRIVATE])) {
+            throw new \InvalidArgumentException(sprintf('The key type must be "public" or "private", "%s" given.', $type));
+        }
+
+        if (self::TYPE_PUBLIC === $type) {
+            return $this->dumpKey();
+        }
+
+        return $this->getSigningKey();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function dumpKey()
+    {
+        if ($publicKey = $this->getPublicKey()) {
+            return $publicKey;
+        }
+
+        $signingKey = $this->getSigningKey();
+
+        // no public key provided, compute it from signing key
+        try {
+            $publicKey = openssl_pkey_get_details(openssl_pkey_get_private($signingKey, $this->getPassphrase()))['key'];
+        } catch (\Throwable $e) {
+            throw new \RuntimeException('Secret key either does not exist, is not readable or is invalid. Did you correctly set the "lexik_jwt_authentication.secret_key" config option?');
+        }
+
+        return $publicKey;
+    }
+}