ServerBuilder::setupExtensions() - Code Metrics - Inspection of "Add extension support (appid implemented)" - madwizard-org/webauthn-server - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 9eb68a...5271f3 )

by Thomas
created 2020-09-24 15:19 UTC
ServerBuilder::setupExtensions() A

↳ Parent: Project
Complexity

Conditions	3
Paths	1
Size

Total Lines	14
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	12
Importance

Changes
Metric	Value
cc	3
eloc	9
c	0
b	0
f	0
nc	1
nop	1
dl	0
loc	14
ccs	0
cts	0
cp	0
crap	12
rs	9.9666
<?php

namespace MadWizard\WebAuthn\Builder;

use Closure;
use GuzzleHttp\Client;
use MadWizard\WebAuthn\Attestation\AttestationType;
use MadWizard\WebAuthn\Attestation\Registry\AttestationFormatRegistry;
use MadWizard\WebAuthn\Attestation\Registry\AttestationFormatRegistryInterface;
use MadWizard\WebAuthn\Attestation\TrustAnchor\TrustPathValidator;
use MadWizard\WebAuthn\Attestation\TrustAnchor\TrustPathValidatorInterface;
use MadWizard\WebAuthn\Attestation\Verifier\AndroidKeyAttestationVerifier;
use MadWizard\WebAuthn\Attestation\Verifier\AndroidSafetyNetAttestationVerifier;
use MadWizard\WebAuthn\Attestation\Verifier\FidoU2fAttestationVerifier;
use MadWizard\WebAuthn\Attestation\Verifier\NoneAttestationVerifier;
use MadWizard\WebAuthn\Attestation\Verifier\PackedAttestationVerifier;
use MadWizard\WebAuthn\Attestation\Verifier\TpmAttestationVerifier;
use MadWizard\WebAuthn\Cache\CacheProviderInterface;
use MadWizard\WebAuthn\Cache\FileCacheProvider;
use MadWizard\WebAuthn\Config\RelyingParty;
use MadWizard\WebAuthn\Config\RelyingPartyInterface;
use MadWizard\WebAuthn\Credential\CredentialStoreInterface;
use MadWizard\WebAuthn\Exception\ConfigurationException;
use MadWizard\WebAuthn\Exception\UnsupportedException;
use MadWizard\WebAuthn\Extension\AppId\AppIdExtension;
use MadWizard\WebAuthn\Extension\ExtensionInterface;
use MadWizard\WebAuthn\Extension\ExtensionRegistry;
use MadWizard\WebAuthn\Extension\ExtensionRegistryInterface;
use MadWizard\WebAuthn\Metadata\MetadataResolver;
use MadWizard\WebAuthn\Metadata\MetadataResolverInterface;
use MadWizard\WebAuthn\Metadata\NullMetadataResolver;
use MadWizard\WebAuthn\Metadata\Provider\FileProvider;
use MadWizard\WebAuthn\Metadata\Provider\MetadataServiceProvider;
use MadWizard\WebAuthn\Metadata\Source\MetadataServiceSource;
use MadWizard\WebAuthn\Metadata\Source\MetadataSourceInterface;
use MadWizard\WebAuthn\Metadata\Source\StatementDirectorySource;
use MadWizard\WebAuthn\Pki\ChainValidator;
use MadWizard\WebAuthn\Pki\ChainValidatorInterface;
use MadWizard\WebAuthn\Policy\Policy;
use MadWizard\WebAuthn\Policy\PolicyInterface;
use MadWizard\WebAuthn\Policy\Trust\TrustDecisionManager;
use MadWizard\WebAuthn\Policy\Trust\TrustDecisionManagerInterface;
use MadWizard\WebAuthn\Policy\Trust\Voter\AllowEmptyMetadataVoter;
use MadWizard\WebAuthn\Policy\Trust\Voter\SupportedAttestationTypeVoter;
use MadWizard\WebAuthn\Policy\Trust\Voter\TrustAttestationTypeVoter;
use MadWizard\WebAuthn\Policy\Trust\Voter\TrustChainVoter;
use MadWizard\WebAuthn\Policy\Trust\Voter\UndesiredStatusReportVoter;
use MadWizard\WebAuthn\Remote\CachingClientFactory;
use MadWizard\WebAuthn\Remote\Downloader;
use MadWizard\WebAuthn\Remote\DownloaderInterface;
use MadWizard\WebAuthn\Server\ServerInterface;
use MadWizard\WebAuthn\Server\WebAuthnServer;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

final class ServerBuilder
{
    /**
     * @var RelyingParty|null
     */
    private $rp;

    /**
     * @var CredentialStoreInterface|null
     */
    private $store;

    /**
     * @var string|null;
     */
    private $cacheDir;

    /**
     * @var callable|PolicyCallbackInterface|null
     */
    private $policyCallback;

    /**
     * @var MetadataSourceInterface[]
     */
    private $metadataSources = [];

    /**
     * @var LoggerInterface|null
     */
    private $logger;

    /**
     * @var bool
     */
    private $allowNoneAttestation = true;

    /**
     * @var bool
     */
    private $allowSelfAttestation = true;

    /**
     * @var bool
     */
    private $trustWithoutMetadata = true;

    /**
     * @var bool
     */
    private $useMetadata = true;

    /**
     * @var bool
     */
    private $strictSupportedFormats = false;

    /**
     * @var string[]
     */
    private $enabledExtensions = [];

    /**
     * @var ExtensionInterface[]
     */
    private $customExtensions = [];

    private const SUPPORTED_EXTENSIONS = [
        'appid' => AppIdExtension::class,
    ];

    public function __construct()
    {
    }

    public function setRelyingParty(RelyingParty $rp): self
    {
        $this->rp = $rp;
        return $this;
    }

    public function setCredentialStore(CredentialStoreInterface $store): self
    {
        $this->store = $store;
        return $this;
    }

    public function setCacheDirectory(string $directory): self
    {
        $this->cacheDir = $directory;
        return $this;
    }

    public function useSystemTempCache(string $subDirectory = 'webauthn-server-cache'): self
    {
        $this->cacheDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . $subDirectory;
        return $this;
    }

    /**
     * @param callable|PolicyCallbackInterface $policyCallback
     *
     * @return $this
     */
    public function configurePolicy(callable $policyCallback): self
    {
        $this->policyCallback = $policyCallback;
        return $this;
    }

    /**
     * @return $this
     */
    public function allowNoneAttestation(bool $allow): self
    {
        $this->allowNoneAttestation = $allow;
        return $this;
    }

    /**
     * @return $this
     */
    public function strictSupportedFormats(bool $strict): self
    {
        $this->strictSupportedFormats = $strict;
        return $this;
    }

    /**
     * @return $this
     */
    public function useMetadata(bool $use): self
    {
        $this->useMetadata = $use;
        return $this;
    }

    /**
     * @return $this
     */
    public function allowSelfAttestation(bool $allow): self
    {
        $this->allowSelfAttestation = $allow;
        return $this;
    }

    /**
     * @return $this
     */
    public function trustWithoutMetadata(bool $trust): self
    {
        $this->trustWithoutMetadata = $trust;
        return $this;
    }

    /**
     * @return $this
     */
    public function enableExtensions(string ...$extensions): self
    {
        foreach ($extensions as $ext) {
            if (!isset(self::SUPPORTED_EXTENSIONS[$ext])) {
                throw new ConfigurationException(sprintf('Extension %s is not supported.', $ext));
            }
        }
        $this->enabledExtensions = array_merge($this->enabledExtensions, $extensions);
        return $this;
    }

    /**
     * @return $this
     */
    public function addCustomExtension(ExtensionInterface $extension): self
    {
        $this->customExtensions[] = $extension;
        return $this;
    }

    /**
     * @return $this
     */
    public function setLogger(LoggerInterface $logger): self
    {
        $this->logger = $logger;
        return $this;
    }

    private function assignLogger(LoggerAwareInterface $service): void
    {
        if ($this->logger !== null) {
            $service->setLogger($this->logger);
        }
    }

    public function build(): ServerInterface
    {
        $c = $this->setupContainer();

        return $c[ServerInterface::class];
    }

    private function setupContainer(): ServiceContainer
    {
        $c = new ServiceContainer();

        $this->setupConfiguredServices($c);
        $this->setupFormats($c);
        $this->setupTrustDecisionManager($c);
        $this->setupExtensions($c);

        $c[TrustPathValidatorInterface::class] = static function (ServiceContainer $c): TrustPathValidatorInterface {
            return new TrustPathValidator($c[ChainValidatorInterface::class]);
        };

        $c[ChainValidatorInterface::class] = static function (ServiceContainer $c): ChainValidatorInterface {
        $c[ChainValidatorInterface::class] = static function (/** @scrutinizer ignore-unused */ ServiceContainer $c): ChainValidatorInterface {
            // TODO
            //return new ChainValidator($c[CertificateStatusResolverInterface::class]);
            return new ChainValidator(null);
        };

        // TODO
//        $c[CertificateStatusResolverInterface::class] = static function (ServiceContainer $c) {
//            return new CertificateStatusResolver($c[DownloaderInterface::class], $c[CacheProviderInterface::class]);
//        };

        $c[PolicyInterface::class] = Closure::fromCallable([$this, 'createPolicy']);
        $c[MetadataResolverInterface::class] = Closure::fromCallable([$this, 'createMetadataResolver']);
        $c[ServerInterface::class] = Closure::fromCallable([$this, 'createServer']);

        return $c;
    }

    private function setupDownloader(ServiceContainer $c)
    {
        $this->setupCache($c);
        if (isset($c[DownloaderInterface::class])) {
            return;
        }
        $c[DownloaderInterface::class] = static function (ServiceContainer $c): DownloaderInterface {
            return new Downloader($c[Client::class]);
        };
        $c[Client::class] = static function (ServiceContainer $c): Client {
            $factory = new CachingClientFactory($c[CacheProviderInterface::class]);
            return $factory->createClient();
        };
    }

    private function setupCache(ServiceContainer $c)
    {
        if (isset($c[CacheProviderInterface::class])) {
            return;
        }

        $cacheDir = $this->cacheDir;
        if ($cacheDir === null) {
            throw new ConfigurationException('No cache directory configured. Use useCacheDirectory or useSystemTempCache.');
        }
        $c[CacheProviderInterface::class] = static function (ServiceContainer $c) use ($cacheDir): CacheProviderInterface {
        $c[CacheProviderInterface::class] = static function (/** @scrutinizer ignore-unused */ ServiceContainer $c) use ($cacheDir): CacheProviderInterface {
            return new FileCacheProvider($cacheDir);
        };
    }

    private function setupConfiguredServices(ServiceContainer $c): void
    {
        if ($this->rp === null) {
            throw new ConfigurationException('Relying party not configured. Use setRelyingParty.');
        }

        $c[RelyingPartyInterface::class] = function (): RelyingPartyInterface { return $this->rp; };


        if ($this->store === null) {
            throw new ConfigurationException('Credential store not configured. Use setCredentialStore.');
        }

        $c[CredentialStoreInterface::class] = function (): CredentialStoreInterface { return $this->store; };

        $c[LoggerInterface::class] = function (): LoggerInterface { return $this->logger ?? new NullLogger(); };
    }

    private function createPolicy(ServiceContainer $c): PolicyInterface
    private function createPolicy(/** @scrutinizer ignore-unused */ ServiceContainer $c): PolicyInterface
    {
        $policy = new Policy();

        if ($this->policyCallback !== null) {
            ($this->policyCallback)($policy);
        }

        return $policy;
    }

    private function createServer(ServiceContainer $c): ServerInterface
    {
        return new WebAuthnServer(
            $c[RelyingPartyInterface::class],
            $c[PolicyInterface::class],
            $c[CredentialStoreInterface::class],
            $c[AttestationFormatRegistryInterface::class],
            $c[MetadataResolverInterface::class],
            $c[TrustDecisionManagerInterface::class],
            $c[ExtensionRegistryInterface::class]);
    }

    public function addMetadataSource(MetadataSourceInterface $metadataSource): self
    {
        $this->metadataSources[] = $metadataSource;
        return $this;
    }

    private function createMetadataResolver(ServiceContainer $c): MetadataResolverInterface
    {
        if (count($this->metadataSources) === 0) {
            return new NullMetadataResolver();
        }
        return new MetadataResolver($this->createMetadataProviders($c));
    }

    private function setupTrustDecisionManager(ServiceContainer $c)
    {
        $c[TrustDecisionManagerInterface::class] = function (ServiceContainer $c): TrustDecisionManagerInterface {
            $tdm = new TrustDecisionManager();

            if ($this->allowNoneAttestation) {
                $tdm->addVoter(new TrustAttestationTypeVoter(AttestationType::NONE));
            }
            if ($this->allowSelfAttestation) {
                $tdm->addVoter(new TrustAttestationTypeVoter(AttestationType::SELF));
            }
            if ($this->trustWithoutMetadata) {
                $tdm->addVoter(new AllowEmptyMetadataVoter());
            }
            if ($this->useMetadata) {
                $tdm->addVoter(new SupportedAttestationTypeVoter());
                $tdm->addVoter(new UndesiredStatusReportVoter());
                $tdm->addVoter(new TrustChainVoter($c[TrustPathValidatorInterface::class]));
            }
            return $tdm;
        };
    }

    private function createMetadataProviders(ServiceContainer $c): array
    {
        $providers = [];
        foreach ($this->metadataSources as $source) {
            if ($source instanceof StatementDirectorySource) {
                $provider = new FileProvider($source);
            } elseif ($source instanceof MetadataServiceSource) {
                $this->setupDownloader($c);
                $provider = new MetadataServiceProvider($source, $c[DownloaderInterface::class], $c[CacheProviderInterface::class], $c[ChainValidatorInterface::class]);
            } else {
                throw new UnsupportedException(sprintf('No provider available for metadata source of type %s.', get_class($source)));
            }

            if ($provider instanceof LoggerAwareInterface) {
                $this->assignLogger($provider);
            }
            $providers[] = $provider;
        }
        return $providers;
    }

    private function setupFormats(ServiceContainer $c)
    {
        $c[PackedAttestationVerifier::class] = static function (): PackedAttestationVerifier {
            return new PackedAttestationVerifier();
        };
        $c[FidoU2fAttestationVerifier::class] = static function (): FidoU2fAttestationVerifier {
            return new FidoU2fAttestationVerifier();
        };
        $c[NoneAttestationVerifier::class] = static function (): NoneAttestationVerifier {
            return new NoneAttestationVerifier();
        };
        $c[TpmAttestationVerifier::class] = static function (): TpmAttestationVerifier {
            return new TpmAttestationVerifier();
        };
        $c[AndroidSafetyNetAttestationVerifier::class] = static function (): AndroidSafetyNetAttestationVerifier {
            return new AndroidSafetyNetAttestationVerifier();
        };
        $c[AndroidKeyAttestationVerifier::class] = static function (): AndroidKeyAttestationVerifier {
            return new AndroidKeyAttestationVerifier();
        };

        $c[AttestationFormatRegistryInterface::class] = function (ServiceContainer $c): AttestationFormatRegistryInterface {
            $registry = new AttestationFormatRegistry();

            $registry->strictSupportedFormats($this->strictSupportedFormats);

            $registry->addFormat($c[PackedAttestationVerifier::class]->getSupportedFormat());
            $registry->addFormat($c[FidoU2fAttestationVerifier::class]->getSupportedFormat());
            $registry->addFormat($c[NoneAttestationVerifier::class]->getSupportedFormat());
            $registry->addFormat($c[TpmAttestationVerifier::class]->getSupportedFormat());
            $registry->addFormat($c[AndroidSafetyNetAttestationVerifier::class]->getSupportedFormat());
            $registry->addFormat($c[AndroidKeyAttestationVerifier::class]->getSupportedFormat());

            return $registry;
        };
    }

    private function setupExtensions(ServiceContainer $c): void
    {
        $c[AppIdExtension::class] = static function (ServiceContainer $c): AppIdExtension {
        $c[AppIdExtension::class] = static function (/** @scrutinizer ignore-unused */ ServiceContainer $c): AppIdExtension {
            return new AppIdExtension();
        };
        $c[ExtensionRegistryInterface::class] = function (ServiceContainer $c): ExtensionRegistryInterface {
            $registry = new ExtensionRegistry();
            foreach (array_unique($this->enabledExtensions) as $ext) {
                $registry->addExtension($c[self::SUPPORTED_EXTENSIONS[$ext]]);
            }
            foreach ($this->customExtensions as $ext) {
                $registry->addExtension($ext);
            }
            return $registry;
        };
    }
}

madwizard-org / webauthn-server

Push — master ( 9eb68a...5271f3 )

ServerBuilder::setupExtensions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
