OAuth2OLD\ClientAuthentication\Guard

Complexity

Total Complexity

15

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
C	authenticate()	0	35	12
A	getClient()	0	3	1
A	getError()	0	3	1
A	__construct()	0	6	1

<?php
/**
 * Created by PhpStorm.
 * User: Alexandre
 * Date: 07/01/2018
 * Time: 14:19
 */

namespace OAuth2OLD\ClientAuthentication;


use OAuth2OLD\ClientAuthentication\Authenticators\ClientAuthenticatorInterface;
use OAuth2OLD\Config;
use OAuth2OLD\Exceptions\OAuthException;
use OAuth2OLD\Roles\ClientInterface;
use OAuth2OLD\Server;
use Psr\Http\Message\ServerRequestInterface;

class Guard
{
    private $client;
    private $error;
    /**
     * @var Server
     */
    private $server;
    private $enforceTLS;

    /**
     * Guard constructor.
     * @param Server $server
     * @throws \Exception
     */
    public function __construct(Server $server)
    {
        $this->client = null;
        $this->error = null;
        $this->server = $server;
        $this->enforceTLS = $server->getConfigurationRepository()->getConfig(Config::ENFORCE_TLS);
    }

    /**
     * @param ServerRequestInterface $request
     * @return bool
     * @throws OAuthException
     * @throws \Exception
     * @implementation if you use other authenticators, override this method to decide
     * what authenticator the guard should use for current client
     */
    public function authenticate(ServerRequestInterface $request): bool
    {
        $clientAuthenticatorSupported = null;
        /**
         * @var ClientAuthenticatorInterface $clientAuthenticator
         */
        foreach ($this->server->getClientAuthenticatorRepository()->getClientAuthenticators() as $clientAuthenticator) {
            if ($clientAuthenticator->support($request)) {
                if ($clientAuthenticatorSupported) {
                    throw new OAuthException('invalid_client', 'Multiple authentication methods used',
                        'https://tools.ietf.org/html/rfc6749#section-5.2');
                }
                $clientAuthenticatorSupported = $clientAuthenticator;
            }
        }

        if (!$clientAuthenticatorSupported) {
            return false;
        }

        try {
            $this->client = $clientAuthenticatorSupported->authenticate($request);
        } catch (\Exception $e) {
            throw new OAuthException('invalid_client', $e->getMessage(),
                'https://tools.ietf.org/html/rfc6749#section-5.2');
        }

        if (($this->enforceTLS === true && !$this->server->isSecure()) ||
            (is_null($this->enforceTLS) && $clientAuthenticatorSupported->isPasswordAuthentication() &&
                !$this->server->isSecure() && $this->client->isTLSSupported())) {
            throw new OAuthException('access_denied', 'Require the use of TLS',
                'https://tools.ietf.org/html/rfc6749#section-3.1.2.1');
        }

        return true;
    }

    /**
     * @return null|ClientInterface
     */
    public function getClient(): ?ClientInterface
    {
        return $this->client;
    }

    /**
     * @return null|string
     */
    public function getError(): ?string
    {
        return $this->error;
    }
}