├── LICENSE
├── README.md
├── RELEASES.md
├── SECURITY.md
├── composer.json
├── link
├── package.json
└── src
    ├── stimulus
        ├── .github
        │   ├── CONTRIBUTING.md
        │   ├── FUNDING.yml
        │   ├── PULL_REQUEST_TEMPLATE.md
        │   ├── close-pull-request.yml
        │   └── stale.yml
        ├── LICENSE
        ├── assets
        │   ├── dist
        │   │   ├── controller.d.ts
        │   │   └── controller.js
        │   ├── jest.config.js
        │   ├── package.json
        │   └── src
        │   │   └── controller.ts
        ├── composer.json
        ├── doc
        │   └── index.rst
        └── src
        │   └── WebauthnStimulusBundle.php
    ├── symfony
        ├── LICENSE
        ├── composer.json
        └── src
        │   ├── Controller
        │       ├── AllowedOriginsController.php
        │       ├── AssertionControllerFactory.php
        │       ├── AssertionRequestController.php
        │       ├── AssertionResponseController.php
        │       ├── AttestationControllerFactory.php
        │       ├── AttestationRequestController.php
        │       ├── AttestationResponseController.php
        │       ├── DummyController.php
        │       └── DummyControllerFactory.php
        │   ├── CredentialOptionsBuilder
        │       ├── ProfileBasedCreationOptionsBuilder.php
        │       ├── ProfileBasedRequestOptionsBuilder.php
        │       ├── PublicKeyCredentialCreationOptionsBuilder.php
        │       └── PublicKeyCredentialRequestOptionsBuilder.php
        │   ├── DataCollector
        │       └── WebauthnCollector.php
        │   ├── DependencyInjection
        │       ├── Compiler
        │       │   ├── AttestationStatementSupportCompilerPass.php
        │       │   ├── CeremonyStepManagerFactoryCompilerPass.php
        │       │   ├── CoseAlgorithmCompilerPass.php
        │       │   ├── CounterCheckerSetterCompilerPass.php
        │       │   ├── DynamicRouteCompilerPass.php
        │       │   ├── EventDispatcherSetterCompilerPass.php
        │       │   ├── ExtensionOutputCheckerCompilerPass.php
        │       │   └── LoggerSetterCompilerPass.php
        │       ├── Configuration.php
        │       ├── Factory
        │       │   └── Security
        │       │   │   ├── WebauthnFactory.php
        │       │   │   └── WebauthnServicesFactory.php
        │       └── WebauthnExtension.php
        │   ├── Doctrine
        │       └── Type
        │       │   ├── AAGUIDDataType.php
        │       │   ├── AttestedCredentialDataType.php
        │       │   ├── Base64BinaryDataType.php
        │       │   ├── PublicKeyCredentialDescriptorType.php
        │       │   ├── SerializerTrait.php
        │       │   └── TrustPathDataType.php
        │   ├── Dto
        │       ├── PublicKeyCredentialCreationOptionsRequest.php
        │       ├── ServerPublicKeyCredentialCreationOptionsRequest.php
        │       └── ServerPublicKeyCredentialRequestOptionsRequest.php
        │   ├── Event
        │       ├── PublicKeyCredentialCreationOptionsCreatedEvent.php
        │       └── PublicKeyCredentialRequestOptionsCreatedEvent.php
        │   ├── Exception
        │       ├── HttpNotImplementedException.php
        │       ├── MissingFeatureException.php
        │       └── MissingUserEntityException.php
        │   ├── Repository
        │       ├── CanGenerateUserEntity.php
        │       ├── CanRegisterUserEntity.php
        │       ├── CanSaveCredentialSource.php
        │       ├── DoctrineCredentialSourceRepository.php
        │       ├── DummyPublicKeyCredentialSourceRepository.php
        │       ├── DummyPublicKeyCredentialUserEntityRepository.php
        │       ├── PublicKeyCredentialSourceRepositoryInterface.php
        │       └── PublicKeyCredentialUserEntityRepositoryInterface.php
        │   ├── Resources
        │       ├── config
        │       │   ├── cose.php
        │       │   ├── dev_services.php
        │       │   ├── doctrine-mapping
        │       │   │   ├── PublicKeyCredentialEntity.orm.xml
        │       │   │   ├── PublicKeyCredentialSource.orm.xml
        │       │   │   └── PublicKeyCredentialUserEntity.orm.xml
        │       │   ├── metadata_statement_supports.php
        │       │   ├── routing.php
        │       │   ├── security.php
        │       │   └── services.php
        │       └── views
        │       │   └── data_collector
        │       │       ├── tab
        │       │           ├── attestation.html.twig
        │       │           └── request.html.twig
        │       │       └── template.html.twig
        │   ├── Routing
        │       └── Loader.php
        │   ├── Security
        │       ├── Authentication
        │       │   ├── Exception
        │       │   │   ├── WebauthnAuthenticationEvent.php
        │       │   │   └── WebauthnAuthenticationEvents.php
        │       │   ├── Token
        │       │   │   └── WebauthnToken.php
        │       │   ├── WebauthnAuthenticator.php
        │       │   ├── WebauthnBadge.php
        │       │   ├── WebauthnBadgeListener.php
        │       │   └── WebauthnPassport.php
        │       ├── Authorization
        │       │   └── Voter
        │       │   │   ├── IsUserPresentVoter.php
        │       │   │   └── IsUserVerifiedVoter.php
        │       ├── Guesser
        │       │   ├── CurrentUserEntityGuesser.php
        │       │   ├── RequestBodyUserEntityGuesser.php
        │       │   └── UserEntityGuesser.php
        │       ├── Handler
        │       │   ├── CreationOptionsHandler.php
        │       │   ├── DefaultCreationOptionsHandler.php
        │       │   ├── DefaultFailureHandler.php
        │       │   ├── DefaultRequestOptionsHandler.php
        │       │   ├── DefaultSuccessHandler.php
        │       │   ├── FailureHandler.php
        │       │   ├── RequestOptionsHandler.php
        │       │   └── SuccessHandler.php
        │       ├── Http
        │       │   └── Authenticator
        │       │   │   ├── Passport
        │       │   │       └── Credentials
        │       │   │       │   └── WebauthnCredentials.php
        │       │   │   └── WebauthnAuthenticator.php
        │       ├── Storage
        │       │   ├── CacheStorage.php
        │       │   ├── Item.php
        │       │   ├── OptionsStorage.php
        │       │   └── SessionStorage.php
        │       └── WebauthnFirewallConfig.php
        │   ├── Service
        │       ├── DefaultFailureHandler.php
        │       ├── DefaultSuccessHandler.php
        │       ├── PublicKeyCredentialCreationOptionsFactory.php
        │       └── PublicKeyCredentialRequestOptionsFactory.php
        │   └── WebauthnBundle.php
    └── webauthn
        ├── LICENSE
        ├── composer.json
        └── src
            ├── AttestationStatement
                ├── AndroidKeyAttestationStatementSupport.php
                ├── AppleAttestationStatementSupport.php
                ├── AttestationObject.php
                ├── AttestationObjectLoader.php
                ├── AttestationStatement.php
                ├── AttestationStatementSupport.php
                ├── AttestationStatementSupportManager.php
                ├── FidoU2FAttestationStatementSupport.php
                ├── NoneAttestationStatementSupport.php
                ├── PackedAttestationStatementSupport.php
                └── TPMAttestationStatementSupport.php
            ├── AttestedCredentialData.php
            ├── AuthenticationExtensions
                ├── AppIdExcludeInputExtension.php
                ├── AppIdInputExtension.php
                ├── AuthenticationExtension.php
                ├── AuthenticationExtensionLoader.php
                ├── AuthenticationExtensions.php
                ├── CredentialPropertiesInputExtension.php
                ├── ExtensionOutputChecker.php
                ├── ExtensionOutputCheckerHandler.php
                ├── ExtensionOutputError.php
                ├── LargeBlobInputExtension.php
                ├── PseudoRandomFunctionInputExtension.php
                ├── PseudoRandomFunctionInputExtensionBuilder.php
                └── UvmInputExtension.php
            ├── AuthenticatorAssertionResponse.php
            ├── AuthenticatorAssertionResponseValidator.php
            ├── AuthenticatorAttestationResponse.php
            ├── AuthenticatorAttestationResponseValidator.php
            ├── AuthenticatorData.php
            ├── AuthenticatorDataLoader.php
            ├── AuthenticatorResponse.php
            ├── AuthenticatorSelectionCriteria.php
            ├── CeremonyStep
                ├── CeremonyStep.php
                ├── CeremonyStepManager.php
                ├── CeremonyStepManagerFactory.php
                ├── CheckAlgorithm.php
                ├── CheckAllowedCredentialList.php
                ├── CheckAllowedOrigins.php
                ├── CheckAttestationFormatIsKnownAndValid.php
                ├── CheckBackupBitsAreConsistent.php
                ├── CheckChallenge.php
                ├── CheckClientDataCollectorType.php
                ├── CheckCounter.php
                ├── CheckCredentialId.php
                ├── CheckExtensions.php
                ├── CheckHasAttestedCredentialData.php
                ├── CheckMetadataStatement.php
                ├── CheckOrigin.php
                ├── CheckRelyingPartyIdIdHash.php
                ├── CheckSignature.php
                ├── CheckTopOrigin.php
                ├── CheckUserHandle.php
                ├── CheckUserVerification.php
                ├── CheckUserWasPresent.php
                ├── HostTopOriginValidator.php
                └── TopOriginValidator.php
            ├── ClientDataCollector
                ├── ClientDataCollector.php
                ├── ClientDataCollectorManager.php
                └── WebauthnAuthenticationCollector.php
            ├── CollectedClientData.php
            ├── Counter
                ├── CounterChecker.php
                └── ThrowExceptionIfInvalid.php
            ├── Credential.php
            ├── Denormalizer
                ├── AttestationObjectDenormalizer.php
                ├── AttestationStatementDenormalizer.php
                ├── AttestedCredentialDataNormalizer.php
                ├── AuthenticationExtensionNormalizer.php
                ├── AuthenticationExtensionsDenormalizer.php
                ├── AuthenticatorAssertionResponseDenormalizer.php
                ├── AuthenticatorAttestationResponseDenormalizer.php
                ├── AuthenticatorDataDenormalizer.php
                ├── AuthenticatorResponseDenormalizer.php
                ├── CollectedClientDataDenormalizer.php
                ├── ExtensionDescriptorDenormalizer.php
                ├── PublicKeyCredentialDenormalizer.php
                ├── PublicKeyCredentialDescriptorNormalizer.php
                ├── PublicKeyCredentialOptionsDenormalizer.php
                ├── PublicKeyCredentialParametersDenormalizer.php
                ├── PublicKeyCredentialSourceDenormalizer.php
                ├── PublicKeyCredentialUserEntityDenormalizer.php
                ├── TrustPathDenormalizer.php
                ├── VerificationMethodANDCombinationsDenormalizer.php
                └── WebauthnSerializerFactory.php
            ├── Event
                ├── AttestationObjectLoaded.php
                ├── AttestationStatementLoaded.php
                ├── AuthenticatorAssertionResponseValidationFailedEvent.php
                ├── AuthenticatorAssertionResponseValidationSucceededEvent.php
                ├── AuthenticatorAttestationResponseValidationFailedEvent.php
                ├── AuthenticatorAttestationResponseValidationSucceededEvent.php
                ├── BeforeCertificateChainValidation.php
                ├── CanDispatchEvents.php
                ├── CertificateChainValidationFailed.php
                ├── CertificateChainValidationSucceeded.php
                ├── MetadataStatementFound.php
                ├── NullEventDispatcher.php
                └── WebauthnEvent.php
            ├── Exception
                ├── AttestationStatementException.php
                ├── AttestationStatementLoadingException.php
                ├── AttestationStatementVerificationException.php
                ├── AuthenticationExtensionException.php
                ├── AuthenticatorResponseVerificationException.php
                ├── CertificateChainException.php
                ├── CertificateException.php
                ├── CertificateRevocationListException.php
                ├── CounterException.php
                ├── ExpiredCertificateException.php
                ├── InvalidAttestationStatementException.php
                ├── InvalidCertificateException.php
                ├── InvalidDataException.php
                ├── InvalidTrustPathException.php
                ├── InvalidUserHandleException.php
                ├── MetadataServiceException.php
                ├── MetadataStatementException.php
                ├── MetadataStatementLoadingException.php
                ├── MissingMetadataStatementException.php
                ├── RevokedCertificateException.php
                ├── UnsupportedFeatureException.php
                └── WebauthnException.php
            ├── FakeCredentialGenerator.php
            ├── MetadataService
                ├── CanLogData.php
                ├── CertificateChain
                │   ├── CertificateChainValidator.php
                │   ├── CertificateToolbox.php
                │   └── PhpCertificateChainValidator.php
                ├── MetadataStatementRepository.php
                ├── Psr18HttpClient.php
                ├── Service
                │   ├── ChainedMetadataServices.php
                │   ├── DistantResourceMetadataService.php
                │   ├── FidoAllianceCompliantMetadataService.php
                │   ├── FolderResourceMetadataService.php
                │   ├── InMemoryMetadataService.php
                │   ├── JsonMetadataService.php
                │   ├── LocalResourceMetadataService.php
                │   ├── MetadataBLOBPayload.php
                │   ├── MetadataBLOBPayloadEntry.php
                │   └── MetadataService.php
                ├── Statement
                │   ├── AbstractDescriptor.php
                │   ├── AlternativeDescriptions.php
                │   ├── AuthenticatorGetInfo.php
                │   ├── AuthenticatorStatus.php
                │   ├── BiometricAccuracyDescriptor.php
                │   ├── BiometricStatusReport.php
                │   ├── CodeAccuracyDescriptor.php
                │   ├── DisplayPNGCharacteristicsDescriptor.php
                │   ├── ExtensionDescriptor.php
                │   ├── MetadataStatement.php
                │   ├── PatternAccuracyDescriptor.php
                │   ├── RgbPaletteEntry.php
                │   ├── RogueListEntry.php
                │   ├── StatusReport.php
                │   ├── VerificationMethodANDCombinations.php
                │   ├── VerificationMethodDescriptor.php
                │   └── Version.php
                └── StatusReportRepository.php
            ├── PublicKeyCredential.php
            ├── PublicKeyCredentialCreationOptions.php
            ├── PublicKeyCredentialDescriptor.php
            ├── PublicKeyCredentialEntity.php
            ├── PublicKeyCredentialOptions.php
            ├── PublicKeyCredentialParameters.php
            ├── PublicKeyCredentialRequestOptions.php
            ├── PublicKeyCredentialRpEntity.php
            ├── PublicKeyCredentialSource.php
            ├── PublicKeyCredentialUserEntity.php
            ├── SimpleFakeCredentialGenerator.php
            ├── StringStream.php
            ├── TrustPath
                ├── CertificateTrustPath.php
                ├── EmptyTrustPath.php
                └── TrustPath.php
            ├── U2FPublicKey.php
            └── Util
                ├── Base64.php
                └── CoseSignatureFixer.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2018-2022 Spomky-Labs
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/RELEASES.md:
--------------------------------------------------------------------------------
 1 | # Versioning and Release
 2 | 
 3 | This document describes the versioning and release process of the Webauthn Framework.
 4 | This document is a living document, contents will be updated according to each release.
 5 | 
 6 | ## Releases
 7 | 
 8 | Webauthn Framework releases will be versioned using dotted triples, similar to [Semantic Version](http://semver.org/).
 9 | For this specific document, we will refer to the respective components of this triple as `<major>.<minor>.<patch>`.
10 | The version number may have additional information, such as "-rc1,-rc2,-rc3" to mark release candidate builds for earlier access.
11 | Such releases will be considered as "pre-releases".
12 | 
13 | ## Minor Release Support Matrix
14 | 
15 | | Version | Supported          |
16 | |---------| ------------------ |
17 | | 5.0.x   | :white_check_mark: |
18 | | 4.8.x   | :white_check_mark: |
19 | | 4.7.x   | :white_check_mark: |
20 | | <4.7.x  | :x:                |
21 | 


--------------------------------------------------------------------------------
/src/stimulus/.github/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing
2 | 
3 | This repository is a sub repository of [the Webauthn Framework](https://github.com/web-auth/webauthn-framework) project
4 | and is READ ONLY.
5 | Please do not submit any Pull Requests here. It will be automatically closed.
6 | 


--------------------------------------------------------------------------------
/src/stimulus/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: Spomky
2 | patreon: FlorentMorselli
3 | 


--------------------------------------------------------------------------------
/src/stimulus/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | Please do not submit any Pull Requests here. It will be automatically closed.
2 | 
3 | You should submit it here: https://github.com/web-auth/webauthn-framework/pulls
4 | 


--------------------------------------------------------------------------------
/src/stimulus/.github/close-pull-request.yml:
--------------------------------------------------------------------------------
 1 | name: Close Pull Request
 2 | 
 3 | on:
 4 |   pull_request_target:
 5 |     types: [opened]
 6 | 
 7 | jobs:
 8 |   run:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |       - uses: superbrothers/close-pull-request@v3
12 |         with:
13 |           comment: |
14 |             Thanks for your Pull Request! We love contributions.
15 | 
16 |             However, you should instead open your PR on the main repository:
17 |             https://github.com/web-auth/webauthn-framework
18 | 
19 |             This repository is what we call a "subtree split": a read-only subset of that main repository.
20 |             We're looking forward to your PR there!
21 | 


--------------------------------------------------------------------------------
/src/stimulus/.github/stale.yml:
--------------------------------------------------------------------------------
1 | daysUntilStale: 1
2 | daysUntilClose: 1
3 | staleLabel: wontfix
4 | markComment: >
5 |   This issue has been automatically marked as stale because this repository
6 |   is a read-only repository and nobody will take care of it. Please submit it to the main repository.
7 |   Thank you for your contributions.
8 | closeComment: false
9 | 


--------------------------------------------------------------------------------
/src/stimulus/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2018-2022 Spomky-Labs
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/stimulus/assets/jest.config.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../../jest.config.js');
2 | 


--------------------------------------------------------------------------------
/src/stimulus/assets/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "@web-auth/webauthn-stimulus",
 3 |     "description": "Webauthn integration for Symfony",
 4 |     "license": "MIT",
 5 |     "version": "1.0.0",
 6 |     "main": "dist/controller.js",
 7 |     "types": "dist/controller.d.ts",
 8 |     "symfony": {
 9 |         "controllers": {
10 |             "webauthn": {
11 |                 "main": "dist/controller.js",
12 |                 "name": "web-auth/webauthn-stimulus",
13 |                 "webpackMode": "eager",
14 |                 "fetch": "eager",
15 |                 "enabled": true
16 |             }
17 |         },
18 |         "importmap": {
19 |             "@hotwired/stimulus": "^3.0.0",
20 |             "@simplewebauthn/browser": "^13.0.0"
21 |         }
22 |     },
23 |     "peerDependencies": {
24 |         "@hotwired/stimulus": "^3.0.0",
25 |         "@simplewebauthn/browser": "^13.0.0"
26 |     },
27 |     "devDependencies": {
28 |         "@hotwired/stimulus": "^3.0.0",
29 |         "@simplewebauthn/browser": "^13.0.0"
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/stimulus/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "web-auth/webauthn-stimulus",
 3 |     "type": "symfony-bundle",
 4 |     "description": "Webauthn integration for Symfony",
 5 |     "keywords": [
 6 |         "symfony",
 7 |         "symfony-ux",
 8 |         "FIDO",
 9 |         "FIDO2",
10 |         "webauthn"
11 |     ],
12 |     "homepage": "https://github.com/web-auth",
13 |     "authors": [
14 |         {
15 |             "name": "Florent Morselli",
16 |             "homepage": "https://github.com/Spomky"
17 |         },
18 |         {
19 |             "name": "All contributors",
20 |             "homepage": "https://github.com/web-auth/ux/contributors"
21 |         }
22 |     ],
23 |     "license": "MIT",
24 |     "autoload": {
25 |         "psr-4": {
26 |             "Webauthn\\Stimulus\\": "src/"
27 |         }
28 |     },
29 |     "conflict": {
30 |         "symfony/flex": "<1.13"
31 |     },
32 |     "extra": {
33 |         "thanks": {
34 |             "name": "web-auth/webauthn-framework",
35 |             "url": "https://github.com/web-auth/webauthn-framework"
36 |         }
37 |     },
38 |     "minimum-stability": "dev"
39 | }
40 | 


--------------------------------------------------------------------------------
/src/stimulus/src/WebauthnStimulusBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Stimulus;
 6 | 
 7 | use Symfony\Component\AssetMapper\AssetMapperInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
10 | use Symfony\Component\HttpKernel\Bundle\AbstractBundle;
11 | 
12 | final class WebauthnStimulusBundle extends AbstractBundle
13 | {
14 |     public function prependExtension(ContainerConfigurator $container, ContainerBuilder $builder): void
15 |     {
16 |         if (! $this->isAssetMapperAvailable($builder)) {
17 |             return;
18 |         }
19 | 
20 |         $builder->prependExtensionConfig('framework', [
21 |             'asset_mapper' => [
22 |                 'paths' => [
23 |                     __DIR__ . '/../assets/dist' => '@web-auth/webauthn-stimulus',
24 |                 ],
25 |             ],
26 |         ]);
27 |     }
28 | 
29 |     private function isAssetMapperAvailable(ContainerBuilder $container): bool
30 |     {
31 |         if (! interface_exists(AssetMapperInterface::class)) {
32 |             return false;
33 |         }
34 | 
35 |         // check that FrameworkBundle is installed
36 |         $bundlesMetadata = $container->getParameter('kernel.bundles_metadata');
37 |         if (! isset($bundlesMetadata['FrameworkBundle'])) {
38 |             return false;
39 |         }
40 | 
41 |         return is_file($bundlesMetadata['FrameworkBundle']['path'] . '/Resources/config/asset_mapper.php');
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/symfony/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018-2022 Spomky-Labs
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/symfony/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "web-auth/webauthn-symfony-bundle",
 3 |     "type": "symfony-bundle",
 4 |     "license": "MIT",
 5 |     "description": "FIDO2/Webauthn Security Bundle For Symfony",
 6 |     "keywords": [
 7 |         "FIDO",
 8 |         "FIDO2",
 9 |         "webauthn",
10 |         "symfony",
11 |         "symfony-bundle",
12 |         "bundle"
13 |     ],
14 |     "homepage": "https://github.com/web-auth",
15 |     "authors": [
16 |         {
17 |             "name": "Florent Morselli",
18 |             "homepage": "https://github.com/Spomky"
19 |         },
20 |         {
21 |             "name": "All contributors",
22 |             "homepage": "https://github.com/web-auth/webauthn-symfony-bundle/contributors"
23 |         }
24 |     ],
25 |     "require": {
26 |         "php": ">=8.2",
27 |         "psr/event-dispatcher": "^1.0",
28 |         "symfony/config": "^6.4|^7.0",
29 |         "symfony/dependency-injection": "^6.4|^7.0",
30 |         "symfony/framework-bundle": "^6.4|^7.0",
31 |         "symfony/http-client": "^6.4|^7.0",
32 |         "symfony/security-bundle": "^6.4|^7.0",
33 |         "symfony/security-core": "^6.4|^7.0",
34 |         "symfony/security-http": "^6.4|^7.0",
35 |         "symfony/serializer": "^6.4|^7.0",
36 |         "symfony/validator": "^6.4|^7.0",
37 |         "web-auth/webauthn-lib": "self.version"
38 |     },
39 |     "extra": {
40 |         "thanks": {
41 |             "name": "web-auth/webauthn-framework",
42 |             "url": "https://github.com/web-auth/webauthn-framework"
43 |         }
44 |     },
45 |     "autoload": {
46 |         "psr-4": {
47 |             "Webauthn\\Bundle\\": "src/"
48 |         }
49 |     },
50 |     "suggest": {
51 |         "symfony/security-bundle": "Symfony firewall using a JSON API (perfect for script applications)"
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/symfony/src/Controller/AllowedOriginsController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Controller;
 6 | 
 7 | use Symfony\Component\HttpFoundation\JsonResponse;
 8 | 
 9 | final readonly class AllowedOriginsController
10 | {
11 |     /**
12 |      * @param string[] $allowedOrigins
13 |      */
14 |     public function __construct(
15 |         private array $allowedOrigins
16 |     ) {
17 |     }
18 | 
19 |     public function __invoke(): JsonResponse
20 |     {
21 |         return new JsonResponse([
22 |             'origins' => $this->allowedOrigins,
23 |         ]);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/symfony/src/Controller/AssertionRequestController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Controller;
 6 | 
 7 | use Psr\Log\LoggerInterface;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Symfony\Component\Security\Core\Exception\AuthenticationException;
11 | use Symfony\Component\Security\Http\Authentication\AuthenticationFailureHandlerInterface;
12 | use Throwable;
13 | use Webauthn\Bundle\CredentialOptionsBuilder\PublicKeyCredentialRequestOptionsBuilder;
14 | use Webauthn\Bundle\Security\Handler\FailureHandler;
15 | use Webauthn\Bundle\Security\Handler\RequestOptionsHandler;
16 | use Webauthn\Bundle\Security\Storage\Item;
17 | use Webauthn\Bundle\Security\Storage\OptionsStorage;
18 | 
19 | final readonly class AssertionRequestController
20 | {
21 |     public function __construct(
22 |         private PublicKeyCredentialRequestOptionsBuilder $optionsBuilder,
23 |         private OptionsStorage $optionsStorage,
24 |         private RequestOptionsHandler $optionsHandler,
25 |         private FailureHandler|AuthenticationFailureHandlerInterface $failureHandler,
26 |         private LoggerInterface $logger,
27 |     ) {
28 |     }
29 | 
30 |     public function __invoke(Request $request): Response
31 |     {
32 |         try {
33 |             $userEntity = null;
34 |             $publicKeyCredentialRequestOptions = $this->optionsBuilder->getFromRequest($request, $userEntity);
35 |             $response = $this->optionsHandler->onRequestOptions($publicKeyCredentialRequestOptions, $userEntity);
36 |             $this->optionsStorage->store(Item::create($publicKeyCredentialRequestOptions, $userEntity));
37 | 
38 |             return $response;
39 |         } catch (Throwable $throwable) {
40 |             $this->logger->error('An error occurred during the assertion ceremony', [
41 |                 'exception' => $throwable,
42 |             ]);
43 |             if ($this->failureHandler instanceof AuthenticationFailureHandlerInterface) {
44 |                 return $this->failureHandler->onAuthenticationFailure(
45 |                     $request,
46 |                     new AuthenticationException($throwable->getMessage(), $throwable->getCode(), $throwable)
47 |                 );
48 |             }
49 | 
50 |             return $this->failureHandler->onFailure($request, $throwable);
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/symfony/src/Controller/DummyController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Controller;
 6 | 
 7 | use LogicException;
 8 | 
 9 | final class DummyController
10 | {
11 |     public function __invoke(): never
12 |     {
13 |         throw new LogicException('This method should never be called.');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/symfony/src/Controller/DummyControllerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Controller;
 6 | 
 7 | final class DummyControllerFactory
 8 | {
 9 |     public function create(): DummyController
10 |     {
11 |         return new DummyController();
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/symfony/src/CredentialOptionsBuilder/PublicKeyCredentialCreationOptionsBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\CredentialOptionsBuilder;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | use Webauthn\PublicKeyCredentialCreationOptions;
 9 | use Webauthn\PublicKeyCredentialUserEntity;
10 | 
11 | interface PublicKeyCredentialCreationOptionsBuilder
12 | {
13 |     public function getFromRequest(
14 |         Request $request,
15 |         PublicKeyCredentialUserEntity $userEntity,
16 |         /*bool $hideExistingExcludedCredentials = false*/
17 |     ): PublicKeyCredentialCreationOptions;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/symfony/src/CredentialOptionsBuilder/PublicKeyCredentialRequestOptionsBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\CredentialOptionsBuilder;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | use Webauthn\PublicKeyCredentialRequestOptions;
 9 | use Webauthn\PublicKeyCredentialUserEntity;
10 | 
11 | interface PublicKeyCredentialRequestOptionsBuilder
12 | {
13 |     public function getFromRequest(
14 |         Request $request,
15 |         ?PublicKeyCredentialUserEntity &$userEntity = null
16 |     ): PublicKeyCredentialRequestOptions;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/AttestationStatementSupportCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | use Webauthn\AttestationStatement\AttestationStatementSupportManager;
11 | 
12 | final readonly class AttestationStatementSupportCompilerPass implements CompilerPassInterface
13 | {
14 |     public const TAG = 'webauthn_attestation_statement_support';
15 | 
16 |     public function process(ContainerBuilder $container): void
17 |     {
18 |         if (! $container->hasDefinition(AttestationStatementSupportManager::class)) {
19 |             return;
20 |         }
21 | 
22 |         $definition = $container->getDefinition(AttestationStatementSupportManager::class);
23 |         $taggedServices = $container->findTaggedServiceIds(self::TAG);
24 |         foreach ($taggedServices as $id => $attributes) {
25 |             $definition->addMethodCall('add', [new Reference($id)]);
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/CoseAlgorithmCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | 
11 | final readonly class CoseAlgorithmCompilerPass implements CompilerPassInterface
12 | {
13 |     public const TAG = 'webauthn_cose_algorithm';
14 | 
15 |     public function process(ContainerBuilder $container): void
16 |     {
17 |         if (! $container->hasDefinition('webauthn.cose.algorithm.manager')) {
18 |             return;
19 |         }
20 | 
21 |         $definition = $container->getDefinition('webauthn.cose.algorithm.manager');
22 | 
23 |         $taggedServices = $container->findTaggedServiceIds(self::TAG);
24 |         foreach ($taggedServices as $id => $attributes) {
25 |             $definition->addMethodCall('add', [new Reference($id)]);
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/CounterCheckerSetterCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | use Webauthn\CeremonyStep\CeremonyStepManagerFactory;
11 | use Webauthn\Counter\CounterChecker;
12 | 
13 | final class CounterCheckerSetterCompilerPass implements CompilerPassInterface
14 | {
15 |     public function process(ContainerBuilder $container): void
16 |     {
17 |         if (
18 |             ! $container->hasAlias(CounterChecker::class)
19 |             || ! $container->hasDefinition(CeremonyStepManagerFactory::class)
20 |         ) {
21 |             return;
22 |         }
23 | 
24 |         $definition = $container->getDefinition(CeremonyStepManagerFactory::class);
25 |         $definition->addMethodCall('setCounterChecker', [new Reference(CounterChecker::class)]);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/DynamicRouteCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 9 | use Symfony\Component\DependencyInjection\ContainerBuilder;
10 | use Webauthn\Bundle\Routing\Loader;
11 | use function array_key_exists;
12 | use function sprintf;
13 | 
14 | final readonly class DynamicRouteCompilerPass implements CompilerPassInterface
15 | {
16 |     public const TAG = 'webauthn_controller';
17 | 
18 |     public function process(ContainerBuilder $container): void
19 |     {
20 |         if (! $container->hasDefinition(Loader::class)) {
21 |             return;
22 |         }
23 | 
24 |         $definition = $container->getDefinition(Loader::class);
25 | 
26 |         $taggedServices = $container->findTaggedServiceIds(self::TAG);
27 |         foreach ($taggedServices as $id => $tags) {
28 |             foreach ($tags as $attributes) {
29 |                 array_key_exists('path', $attributes) || throw new InvalidArgumentException(sprintf(
30 |                     'The path is missing for "%s"',
31 |                     $id
32 |                 ));
33 |                 array_key_exists('host', $attributes) || throw new InvalidArgumentException(sprintf(
34 |                     'The host is missing for "%s"',
35 |                     $id
36 |                 ));
37 |                 $definition->addMethodCall(
38 |                     'add',
39 |                     [$attributes['path'], $attributes['host'], $id, $attributes['method'] ?? 'POST']
40 |                 );
41 |             }
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/EventDispatcherSetterCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | 
11 | final readonly class EventDispatcherSetterCompilerPass implements CompilerPassInterface
12 | {
13 |     public const TAG = 'webauthn_can_dispatch_events';
14 | 
15 |     public function process(ContainerBuilder $container): void
16 |     {
17 |         if (! $container->hasAlias('webauthn.event_dispatcher')) {
18 |             return;
19 |         }
20 | 
21 |         $taggedServices = $container->findTaggedServiceIds(self::TAG);
22 |         foreach ($taggedServices as $id => $attributes) {
23 |             $service = $container->getDefinition($id);
24 |             $service->addMethodCall('setEventDispatcher', [new Reference('webauthn.event_dispatcher')]);
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/ExtensionOutputCheckerCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | use Webauthn\AuthenticationExtensions\ExtensionOutputCheckerHandler;
11 | 
12 | final readonly class ExtensionOutputCheckerCompilerPass implements CompilerPassInterface
13 | {
14 |     public const TAG = 'webauthn_extension_output_checker';
15 | 
16 |     public function process(ContainerBuilder $container): void
17 |     {
18 |         if (! $container->hasDefinition(ExtensionOutputCheckerHandler::class)) {
19 |             return;
20 |         }
21 | 
22 |         $definition = $container->getDefinition(ExtensionOutputCheckerHandler::class);
23 | 
24 |         $taggedServices = $container->findTaggedServiceIds(self::TAG);
25 |         foreach ($taggedServices as $id => $attributes) {
26 |             $definition->addMethodCall('add', [new Reference($id)]);
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/symfony/src/DependencyInjection/Compiler/LoggerSetterCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | 
11 | final readonly class LoggerSetterCompilerPass implements CompilerPassInterface
12 | {
13 |     public const TAG = 'webauthn_can_log_data';
14 | 
15 |     public function process(ContainerBuilder $container): void
16 |     {
17 |         if (! $container->hasAlias('webauthn.logger')) {
18 |             return;
19 |         }
20 | 
21 |         $taggedServices = $container->findTaggedServiceIds(self::TAG);
22 |         foreach ($taggedServices as $id => $attributes) {
23 |             $service = $container->getDefinition($id);
24 |             $service->addMethodCall('setLogger', [new Reference('webauthn.logger')]);
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/symfony/src/Doctrine/Type/AAGUIDDataType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Doctrine\Type;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Types\Type;
 9 | use Symfony\Component\Uid\Uuid;
10 | use function is_string;
11 | 
12 | final class AAGUIDDataType extends Type
13 | {
14 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
15 |     {
16 |         if (is_string($value)) {
17 |             return $value;
18 |         }
19 |         if ($value instanceof Uuid) {
20 |             return $value->__toString();
21 |         }
22 |         return null;
23 |     }
24 | 
25 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?Uuid
26 |     {
27 |         if ($value instanceof Uuid) {
28 |             return $value;
29 |         }
30 |         if (is_string($value)) {
31 |             return Uuid::fromString($value);
32 |         }
33 | 
34 |         return null;
35 |     }
36 | 
37 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
38 |     {
39 |         return $platform->getClobTypeDeclarationSQL($column);
40 |     }
41 | 
42 |     public function getName(): string
43 |     {
44 |         return 'aaguid';
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/symfony/src/Doctrine/Type/AttestedCredentialDataType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Doctrine\Type;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Types\JsonType;
 9 | use Webauthn\AttestedCredentialData;
10 | 
11 | final class AttestedCredentialDataType extends JsonType
12 | {
13 |     use SerializerTrait;
14 | 
15 |     public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string
16 |     {
17 |         if (! $value instanceof AttestedCredentialData) {
18 |             return $value;
19 |         }
20 | 
21 |         return $this->serialize($value);
22 |     }
23 | 
24 |     public function convertToPHPValue($value, AbstractPlatform $platform): ?AttestedCredentialData
25 |     {
26 |         if ($value === null || $value instanceof AttestedCredentialData) {
27 |             return $value;
28 |         }
29 | 
30 |         return $this->deserialize($value, AttestedCredentialData::class);
31 |     }
32 | 
33 |     public function getName(): string
34 |     {
35 |         return 'attested_credential_data';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/symfony/src/Doctrine/Type/Base64BinaryDataType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Doctrine\Type;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Types\Type;
 9 | use ParagonIE\ConstantTime\Base64;
10 | use function is_string;
11 | 
12 | final class Base64BinaryDataType extends Type
13 | {
14 |     public function convertToDatabaseValue(mixed $value, AbstractPlatform $platform): ?string
15 |     {
16 |         if (! is_string($value)) {
17 |             return null;
18 |         }
19 | 
20 |         return Base64::encode($value);
21 |     }
22 | 
23 |     public function convertToPHPValue(mixed $value, AbstractPlatform $platform): ?string
24 |     {
25 |         if (is_string($value)) {
26 |             return Base64::decode($value, true);
27 |         }
28 | 
29 |         return null;
30 |     }
31 | 
32 |     public function getSQLDeclaration(array $column, AbstractPlatform $platform): string
33 |     {
34 |         return $platform->getClobTypeDeclarationSQL($column);
35 |     }
36 | 
37 |     public function getName(): string
38 |     {
39 |         return 'base64';
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/symfony/src/Doctrine/Type/PublicKeyCredentialDescriptorType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Doctrine\Type;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Types\JsonType;
 9 | use Webauthn\PublicKeyCredentialDescriptor;
10 | 
11 | final class PublicKeyCredentialDescriptorType extends JsonType
12 | {
13 |     use SerializerTrait;
14 | 
15 |     public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string
16 |     {
17 |         if (! $value instanceof PublicKeyCredentialDescriptor) {
18 |             return $value;
19 |         }
20 | 
21 |         return $this->serialize($value);
22 |     }
23 | 
24 |     public function convertToPHPValue($value, AbstractPlatform $platform): ?PublicKeyCredentialDescriptor
25 |     {
26 |         if ($value === null || $value instanceof PublicKeyCredentialDescriptor) {
27 |             return $value;
28 |         }
29 | 
30 |         return $this->deserialize($value, PublicKeyCredentialDescriptor::class);
31 |     }
32 | 
33 |     public function getName(): string
34 |     {
35 |         return 'public_key_credential_descriptor';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/symfony/src/Doctrine/Type/SerializerTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Doctrine\Type;
 6 | 
 7 | use Symfony\Component\Serializer\Encoder\JsonEncode;
 8 | use Symfony\Component\Serializer\Encoder\JsonEncoder;
 9 | use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
10 | use Webauthn\AttestationStatement\AttestationStatementSupportManager;
11 | use Webauthn\Denormalizer\WebauthnSerializerFactory;
12 | use const JSON_THROW_ON_ERROR;
13 | 
14 | trait SerializerTrait
15 | {
16 |     protected function serialize(mixed $data): string
17 |     {
18 |         $serializer = (new WebauthnSerializerFactory(AttestationStatementSupportManager::create()))->create();
19 | 
20 |         return $serializer->serialize($data, JsonEncoder::FORMAT, [
21 |             AbstractObjectNormalizer::SKIP_NULL_VALUES => true,
22 |             JsonEncode::OPTIONS => JSON_THROW_ON_ERROR,
23 |         ]);
24 |     }
25 | 
26 |     protected function deserialize(string $data, string $class): mixed
27 |     {
28 |         $serializer = (new WebauthnSerializerFactory(AttestationStatementSupportManager::create()))->create();
29 | 
30 |         return $serializer->deserialize($data, $class, JsonEncoder::FORMAT);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/symfony/src/Doctrine/Type/TrustPathDataType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Doctrine\Type;
 6 | 
 7 | use Doctrine\DBAL\Platforms\AbstractPlatform;
 8 | use Doctrine\DBAL\Types\JsonType;
 9 | use Webauthn\TrustPath\TrustPath;
10 | 
11 | final class TrustPathDataType extends JsonType
12 | {
13 |     use SerializerTrait;
14 | 
15 |     public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string
16 |     {
17 |         if (! $value instanceof TrustPath) {
18 |             return $value;
19 |         }
20 | 
21 |         return $this->serialize($value);
22 |     }
23 | 
24 |     public function convertToPHPValue($value, AbstractPlatform $platform): ?TrustPath
25 |     {
26 |         if ($value === null || $value instanceof TrustPath) {
27 |             return $value;
28 |         }
29 | 
30 |         return $this->deserialize($value, TrustPath::class);
31 |     }
32 | 
33 |     public function getName(): string
34 |     {
35 |         return 'trust_path';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/symfony/src/Dto/PublicKeyCredentialCreationOptionsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Dto;
 6 | 
 7 | use Symfony\Component\Validator\Constraints\Choice;
 8 | use Symfony\Component\Validator\Constraints\NotBlank;
 9 | use Webauthn\AuthenticatorSelectionCriteria;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | 
12 | class PublicKeyCredentialCreationOptionsRequest
13 | {
14 |     #[NotBlank(allowNull: true)]
15 |     #[Choice(choices: [
16 |         PublicKeyCredentialCreationOptions::ATTESTATION_CONVEYANCE_PREFERENCE_NONE,
17 |         PublicKeyCredentialCreationOptions::ATTESTATION_CONVEYANCE_PREFERENCE_DIRECT,
18 |         PublicKeyCredentialCreationOptions::ATTESTATION_CONVEYANCE_PREFERENCE_INDIRECT,
19 |     ])]
20 |     public ?string $attestation = null;
21 | 
22 |     #[NotBlank(allowNull: true)]
23 |     #[Choice(choices: [
24 |         AuthenticatorSelectionCriteria::USER_VERIFICATION_REQUIREMENT_PREFERRED,
25 |         AuthenticatorSelectionCriteria::USER_VERIFICATION_REQUIREMENT_REQUIRED,
26 |         AuthenticatorSelectionCriteria::USER_VERIFICATION_REQUIREMENT_DISCOURAGED,
27 |     ])]
28 |     public ?string $userVerification = null;
29 | 
30 |     #[NotBlank(allowNull: true)]
31 |     #[Choice(choices: [
32 |         AuthenticatorSelectionCriteria::RESIDENT_KEY_REQUIREMENT_NO_PREFERENCE,
33 |         AuthenticatorSelectionCriteria::RESIDENT_KEY_REQUIREMENT_REQUIRED,
34 |         AuthenticatorSelectionCriteria::RESIDENT_KEY_REQUIREMENT_PREFERRED,
35 |         AuthenticatorSelectionCriteria::RESIDENT_KEY_REQUIREMENT_DISCOURAGED,
36 |     ])]
37 |     public ?string $residentKey = null;
38 | 
39 |     #[NotBlank(allowNull: true)]
40 |     #[Choice(choices: [
41 |         AuthenticatorSelectionCriteria::AUTHENTICATOR_ATTACHMENT_NO_PREFERENCE,
42 |         AuthenticatorSelectionCriteria::AUTHENTICATOR_ATTACHMENT_PLATFORM,
43 |         AuthenticatorSelectionCriteria::AUTHENTICATOR_ATTACHMENT_CROSS_PLATFORM,
44 |     ])]
45 |     public ?string $authenticatorAttachment = null;
46 | 
47 |     /**
48 |      * @var array<string, mixed>|null
49 |      */
50 |     public ?array $extensions = null;
51 | }
52 | 


--------------------------------------------------------------------------------
/src/symfony/src/Dto/ServerPublicKeyCredentialCreationOptionsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Dto;
 6 | 
 7 | use Symfony\Component\Validator\Constraints\NotBlank;
 8 | 
 9 | final class ServerPublicKeyCredentialCreationOptionsRequest extends PublicKeyCredentialCreationOptionsRequest
10 | {
11 |     #[NotBlank(allowNull: true)]
12 |     public ?string $username = null;
13 | 
14 |     #[NotBlank(allowNull: true)]
15 |     public ?string $displayName = null;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/symfony/src/Dto/ServerPublicKeyCredentialRequestOptionsRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Dto;
 6 | 
 7 | use Symfony\Component\Validator\Constraints\Choice;
 8 | use Symfony\Component\Validator\Constraints\NotBlank;
 9 | use Webauthn\PublicKeyCredentialRequestOptions;
10 | 
11 | final class ServerPublicKeyCredentialRequestOptionsRequest
12 | {
13 |     #[NotBlank(allowNull: true)]
14 |     public ?string $username = null;
15 | 
16 |     #[NotBlank(allowNull: true)]
17 |     #[Choice(choices: [
18 |         PublicKeyCredentialRequestOptions::USER_VERIFICATION_REQUIREMENT_PREFERRED,
19 |         PublicKeyCredentialRequestOptions::USER_VERIFICATION_REQUIREMENT_REQUIRED,
20 |         PublicKeyCredentialRequestOptions::USER_VERIFICATION_REQUIREMENT_DISCOURAGED,
21 |     ])]
22 |     public ?string $userVerification = null;
23 | 
24 |     /**
25 |      * @var array<string, mixed>|null
26 |      */
27 |     public ?array $extensions = null;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/symfony/src/Event/PublicKeyCredentialCreationOptionsCreatedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Event;
 6 | 
 7 | use Symfony\Contracts\EventDispatcher\Event;
 8 | use Webauthn\PublicKeyCredentialCreationOptions;
 9 | 
10 | class PublicKeyCredentialCreationOptionsCreatedEvent extends Event
11 | {
12 |     public function __construct(
13 |         public readonly PublicKeyCredentialCreationOptions $publicKeyCredentialCreationOptions
14 |     ) {
15 |     }
16 | 
17 |     public static function create(PublicKeyCredentialCreationOptions $publicKeyCredentialCreationOptions): self
18 |     {
19 |         return new self($publicKeyCredentialCreationOptions);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/symfony/src/Event/PublicKeyCredentialRequestOptionsCreatedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Event;
 6 | 
 7 | use Symfony\Contracts\EventDispatcher\Event;
 8 | use Webauthn\PublicKeyCredentialRequestOptions;
 9 | 
10 | class PublicKeyCredentialRequestOptionsCreatedEvent extends Event
11 | {
12 |     public function __construct(
13 |         public readonly PublicKeyCredentialRequestOptions $publicKeyCredentialRequestOptions
14 |     ) {
15 |     }
16 | 
17 |     public static function create(PublicKeyCredentialRequestOptions $publicKeyCredentialRequestOptions): self
18 |     {
19 |         return new self($publicKeyCredentialRequestOptions);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/symfony/src/Exception/HttpNotImplementedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Exception;
 6 | 
 7 | use Symfony\Component\HttpKernel\Exception\HttpException;
 8 | use Throwable;
 9 | 
10 | class HttpNotImplementedException extends HttpException
11 | {
12 |     /**
13 |      * @param array<string, mixed> $headers
14 |      */
15 |     public function __construct(string $message = '', ?Throwable $previous = null, int $code = 0, array $headers = [])
16 |     {
17 |         parent::__construct(501, $message, $previous, $headers, $code);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/symfony/src/Exception/MissingFeatureException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Exception;
 6 | 
 7 | use Throwable;
 8 | use Webauthn\Exception\WebauthnException;
 9 | 
10 | final class MissingFeatureException extends WebauthnException
11 | {
12 |     public static function create(string $message, ?Throwable $previous = null): self
13 |     {
14 |         return new self($message, $previous);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/symfony/src/Exception/MissingUserEntityException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Exception;
 6 | 
 7 | use Throwable;
 8 | use Webauthn\Exception\WebauthnException;
 9 | 
10 | final class MissingUserEntityException extends WebauthnException
11 | {
12 |     public static function create(string $message, ?Throwable $previous = null): self
13 |     {
14 |         return new self($message, $previous);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/CanGenerateUserEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use Webauthn\PublicKeyCredentialUserEntity;
 8 | 
 9 | interface CanGenerateUserEntity
10 | {
11 |     public function generateUserEntity(?string $username, ?string $displayName): PublicKeyCredentialUserEntity;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/CanRegisterUserEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use Webauthn\PublicKeyCredentialUserEntity;
 8 | 
 9 | interface CanRegisterUserEntity
10 | {
11 |     public function saveUserEntity(PublicKeyCredentialUserEntity $userEntity): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/CanSaveCredentialSource.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use Webauthn\PublicKeyCredentialSource;
 8 | 
 9 | interface CanSaveCredentialSource
10 | {
11 |     public function saveCredentialSource(PublicKeyCredentialSource $publicKeyCredentialSource): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/DummyPublicKeyCredentialSourceRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use LogicException;
 8 | use Psr\Log\LoggerInterface;
 9 | use Psr\Log\NullLogger;
10 | use Webauthn\MetadataService\CanLogData;
11 | use Webauthn\PublicKeyCredentialSource;
12 | use Webauthn\PublicKeyCredentialUserEntity;
13 | 
14 | /**
15 |  * This dummy Public Key Credential Source Repository is set to allow the bundle to be installed even if the real
16 |  * repository is not set in the configuration file. This class shall be replaced in favour of your own implementation.
17 |  */
18 | class DummyPublicKeyCredentialSourceRepository implements PublicKeyCredentialSourceRepositoryInterface, CanLogData
19 | {
20 |     public function __construct(
21 |         private LoggerInterface $logger = new NullLogger()
22 |     ) {
23 |     }
24 | 
25 |     public function setLogger(LoggerInterface $logger): void
26 |     {
27 |         $this->logger = $logger;
28 |     }
29 | 
30 |     public function findAllForUserEntity(PublicKeyCredentialUserEntity $publicKeyCredentialUserEntity): array
31 |     {
32 |         $this->throwException();
33 |     }
34 | 
35 |     public function findOneByCredentialId(string $publicKeyCredentialId): ?PublicKeyCredentialSource
36 |     {
37 |         $this->throwException();
38 |     }
39 | 
40 |     private function throwException(): never
41 |     {
42 |         $this->logger->critical(
43 |             'Please change the Public Key Credential Source Repository in the bundle configuration. See https://webauthn-doc.spomky-labs.com/the-webauthn-server/the-symfony-way#repositories-1'
44 |         );
45 |         throw new LogicException(
46 |             'You are using the DummyPublicKeyCredentialSourceRepository service. Please create your own repository'
47 |         );
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/DummyPublicKeyCredentialUserEntityRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use LogicException;
 8 | use Psr\Log\LoggerInterface;
 9 | use Psr\Log\NullLogger;
10 | use Webauthn\MetadataService\CanLogData;
11 | use Webauthn\PublicKeyCredentialUserEntity;
12 | 
13 | /**
14 |  * This dummy Public Key User Entity Repository is set to allow the bundle to be installed even if the real repository
15 |  * is not set in the configuration file. This class shall be replaced in favour of your own implementation.
16 |  */
17 | class DummyPublicKeyCredentialUserEntityRepository implements PublicKeyCredentialUserEntityRepositoryInterface, CanLogData
18 | {
19 |     public function __construct(
20 |         private LoggerInterface $logger = new NullLogger()
21 |     ) {
22 |     }
23 | 
24 |     public function setLogger(LoggerInterface $logger): void
25 |     {
26 |         $this->logger = $logger;
27 |     }
28 | 
29 |     public function findOneByUsername(string $username): ?PublicKeyCredentialUserEntity
30 |     {
31 |         $this->throwException();
32 |     }
33 | 
34 |     public function findOneByUserHandle(string $userHandle): ?PublicKeyCredentialUserEntity
35 |     {
36 |         $this->throwException();
37 |     }
38 | 
39 |     private function throwException(): never
40 |     {
41 |         $this->logger->critical(
42 |             'Please change the Public Key Credential User Entity Repository in the bundle configuration. See https://webauthn-doc.spomky-labs.com/the-webauthn-server/the-symfony-way#repositories-1'
43 |         );
44 |         throw new LogicException(
45 |             'You are using the DummyPublicKeyCredentialUserEntityRepository service. Please create your own repository'
46 |         );
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/PublicKeyCredentialSourceRepositoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use Webauthn\PublicKeyCredentialSource;
 8 | use Webauthn\PublicKeyCredentialUserEntity;
 9 | 
10 | interface PublicKeyCredentialSourceRepositoryInterface
11 | {
12 |     /**
13 |      * @return PublicKeyCredentialSource[]
14 |      */
15 |     public function findAllForUserEntity(PublicKeyCredentialUserEntity $publicKeyCredentialUserEntity): array;
16 | 
17 |     public function findOneByCredentialId(string $publicKeyCredentialId): ?PublicKeyCredentialSource;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/symfony/src/Repository/PublicKeyCredentialUserEntityRepositoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Repository;
 6 | 
 7 | use Webauthn\PublicKeyCredentialUserEntity;
 8 | 
 9 | interface PublicKeyCredentialUserEntityRepositoryInterface
10 | {
11 |     public function findOneByUsername(string $username): ?PublicKeyCredentialUserEntity;
12 | 
13 |     public function findOneByUserHandle(string $userHandle): ?PublicKeyCredentialUserEntity;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/symfony/src/Resources/config/dev_services.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\DataCollector;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
 8 | use function Symfony\Component\DependencyInjection\Loader\Configurator\service;
 9 | 
10 | return static function (ContainerConfigurator $container): void {
11 |     $service = $container->services()
12 |         ->defaults()
13 |         ->private()
14 |         ->autoconfigure()
15 |         ->autowire()
16 |     ;
17 | 
18 |     $service->set(WebauthnCollector::class)
19 |         ->args([service('serializer')])
20 |         ->tag('data_collector', [
21 |             'id' => 'webauthn_collector',
22 |             'template' => '@Webauthn/data_collector/template.html.twig',
23 |         ]);
24 | };
25 | 


--------------------------------------------------------------------------------
/src/symfony/src/Resources/config/doctrine-mapping/PublicKeyCredentialEntity.orm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <doctrine-mapping
 3 |     xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
 4 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |     xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping https://raw.github.com/doctrine/doctrine2/master/doctrine-mapping.xsd"
 6 | >
 7 |     <mapped-superclass name="Webauthn\PublicKeyCredentialEntity">
 8 |         <field name="name" unique="true"/>
 9 |         <field name="icon" nullable="true"/>
10 |     </mapped-superclass>
11 | </doctrine-mapping>
12 | 


--------------------------------------------------------------------------------
/src/symfony/src/Resources/config/doctrine-mapping/PublicKeyCredentialSource.orm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <doctrine-mapping
 3 |     xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
 4 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |     xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping https://raw.github.com/doctrine/doctrine2/master/doctrine-mapping.xsd"
 6 | >
 7 |     <mapped-superclass name="Webauthn\PublicKeyCredentialSource">
 8 |         <field name="publicKeyCredentialId" type="base64" unique="true" length="250"/>
 9 |         <field name="type"/>
10 |         <field name="transports" type="json"/>
11 |         <field name="attestationType"/>
12 |         <field name="trustPath" type="trust_path"/>
13 |         <field name="aaguid" type="aaguid" length="36"/>
14 |         <field name="credentialPublicKey" type="base64"/>
15 |         <field name="userHandle"/>
16 |         <field name="counter" type="integer"/>
17 |         <field name="otherUI" type="json" nullable="true"/>
18 |         <field name="backupEligible" type="boolean" nullable="true"/>
19 |         <field name="backupStatus" type="boolean" nullable="true"/>
20 |         <field name="uvInitialized" type="boolean" nullable="true"/>
21 |     </mapped-superclass>
22 | </doctrine-mapping>
23 | 


--------------------------------------------------------------------------------
/src/symfony/src/Resources/config/doctrine-mapping/PublicKeyCredentialUserEntity.orm.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <doctrine-mapping
 3 |     xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
 4 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 |     xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping https://raw.github.com/doctrine/doctrine2/master/doctrine-mapping.xsd"
 6 | >
 7 |     <mapped-superclass name="Webauthn\PublicKeyCredentialUserEntity">
 8 |         <field name="displayName"/>
 9 |     </mapped-superclass>
10 | </doctrine-mapping>
11 | 


--------------------------------------------------------------------------------
/src/symfony/src/Resources/config/metadata_statement_supports.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
 6 | use Webauthn\AttestationStatement\AndroidKeyAttestationStatementSupport;
 7 | use Webauthn\AttestationStatement\AppleAttestationStatementSupport;
 8 | use Webauthn\AttestationStatement\FidoU2FAttestationStatementSupport;
 9 | use Webauthn\AttestationStatement\PackedAttestationStatementSupport;
10 | use Webauthn\AttestationStatement\TPMAttestationStatementSupport;
11 | use Webauthn\MetadataService\CertificateChain\PhpCertificateChainValidator;
12 | use function Symfony\Component\DependencyInjection\Loader\Configurator\service;
13 | 
14 | return static function (ContainerConfigurator $container): void {
15 |     $service = $container->services()
16 |         ->defaults()
17 |         ->private()
18 |         ->autoconfigure();
19 | 
20 |     $service
21 |         ->set(AppleAttestationStatementSupport::class);
22 |     $service
23 |         ->set(TPMAttestationStatementSupport::class)
24 |         ->args([service('webauthn.clock')])
25 |     ;
26 |     $service
27 |         ->set(FidoU2FAttestationStatementSupport::class);
28 |     $service
29 |         ->set(AndroidKeyAttestationStatementSupport::class);
30 |     $service
31 |         ->set(PackedAttestationStatementSupport::class)
32 |         ->args([service('webauthn.cose.algorithm.manager')]);
33 | 
34 |     $service
35 |         ->set(PhpCertificateChainValidator::class)
36 |         ->args([service('webauthn.http_client'), service('webauthn.clock')]);
37 | };
38 | 


--------------------------------------------------------------------------------
/src/symfony/src/Resources/config/routing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
 6 | 
 7 | return static function (RoutingConfigurator $routes): void {
 8 |     $routes->import('.', 'webauthn');
 9 | };
10 | 


--------------------------------------------------------------------------------
/src/symfony/src/Routing/Loader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Routing;
 6 | 
 7 | use Symfony\Component\Config\Loader\Loader as SymfonyLoader;
 8 | use Symfony\Component\Routing\Route;
 9 | use Symfony\Component\Routing\RouteCollection;
10 | use function sprintf;
11 | 
12 | class Loader extends SymfonyLoader
13 | {
14 |     private readonly RouteCollection $routes;
15 | 
16 |     public function __construct()
17 |     {
18 |         parent::__construct();
19 |         $this->routes = new RouteCollection();
20 |     }
21 | 
22 |     public function add(string $pattern, ?string $host, string $name, string $method = 'POST'): void
23 |     {
24 |         $controllerId = sprintf('%s', $name);
25 |         $defaults = [
26 |             '_controller' => $controllerId,
27 |         ];
28 |         $route = new Route($pattern, $defaults, [], [], $host, [], [$method]);
29 |         $this->routes->add($name, $route);
30 |     }
31 | 
32 |     /**
33 |      * @noRector
34 |      */
35 |     public function load(mixed $resource, ?string $type = null): RouteCollection
36 |     {
37 |         return $this->routes;
38 |     }
39 | 
40 |     public function supports(mixed $resource, ?string $type = null): bool
41 |     {
42 |         return $type === 'webauthn';
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Authentication/Exception/WebauthnAuthenticationEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Authentication\Exception;
 6 | 
 7 | use Symfony\Component\Security\Core\Exception\BadCredentialsException;
 8 | 
 9 | final class WebauthnAuthenticationEvent extends BadCredentialsException
10 | {
11 |     private const MESSAGE_KEY = 'invalid';
12 | 
13 |     public function getMessageKey(): string
14 |     {
15 |         return self::MESSAGE_KEY;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Authentication/Exception/WebauthnAuthenticationEvents.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Authentication\Exception;
 6 | 
 7 | interface WebauthnAuthenticationEvents
 8 | {
 9 |     public const FAILURE = 'failure';
10 | 
11 |     public const SUCCESS = 'success';
12 | }
13 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Authentication/WebauthnAuthenticator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Authentication;
 6 | 
 7 | use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
 8 | use Symfony\Component\Security\Http\Authenticator\AbstractLoginFormAuthenticator;
 9 | use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
10 | use Webauthn\AuthenticatorAssertionResponse;
11 | use Webauthn\Bundle\Security\Authentication\Token\WebauthnToken;
12 | use function assert;
13 | 
14 | abstract class WebauthnAuthenticator extends AbstractLoginFormAuthenticator
15 | {
16 |     public function createToken(Passport $passport, string $firewallName): TokenInterface
17 |     {
18 |         assert($passport instanceof WebauthnPassport, 'Invalid passport');
19 |         $webauthnBadge = $passport->getBadge(WebauthnBadge::class);
20 |         assert($webauthnBadge instanceof WebauthnBadge, 'Invalid badge');
21 |         if ($webauthnBadge->getAuthenticatorResponse() instanceof AuthenticatorAssertionResponse) {
22 |             $authData = $webauthnBadge->getAuthenticatorResponse()
23 |                 ->authenticatorData;
24 |         } else {
25 |             $authData = $webauthnBadge->getAuthenticatorResponse()
26 |                 ->attestationObject
27 |                 ->authData;
28 |         }
29 | 
30 |         $token = new WebauthnToken(
31 |             $webauthnBadge->getPublicKeyCredentialUserEntity(),
32 |             $webauthnBadge->getPublicKeyCredentialOptions(),
33 |             $webauthnBadge->getPublicKeyCredentialSource()
34 |                 ->getPublicKeyCredentialDescriptor(),
35 |             $authData->isUserPresent(),
36 |             $authData->isUserVerified(),
37 |             $authData->getReservedForFutureUse1(),
38 |             $authData->getReservedForFutureUse2(),
39 |             $authData->signCount,
40 |             $authData->extensions,
41 |             $firewallName,
42 |             $webauthnBadge->getUser()
43 |                 ->getRoles(),
44 |             $authData->isBackupEligible(),
45 |             $authData->isBackedUp(),
46 |         );
47 |         $token->setUser($webauthnBadge->getUser());
48 | 
49 |         return $token;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Authentication/WebauthnPassport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Authentication;
 6 | 
 7 | use LogicException;
 8 | use Symfony\Component\Security\Core\User\UserInterface;
 9 | use Symfony\Component\Security\Http\Authenticator\Passport\Badge\BadgeInterface;
10 | use Symfony\Component\Security\Http\Authenticator\Passport\Badge\PreAuthenticatedUserBadge;
11 | use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
12 | 
13 | final class WebauthnPassport extends Passport
14 | {
15 |     /**
16 |      * @param BadgeInterface[] $badges
17 |      */
18 |     public function __construct(WebauthnBadge $webauthnBadge, array $badges = [])
19 |     {
20 |         $this->addBadge($webauthnBadge);
21 |         $this->addBadge(new PreAuthenticatedUserBadge());
22 |         foreach ($badges as $badge) {
23 |             $this->addBadge($badge);
24 |         }
25 |     }
26 | 
27 |     public function getUser(): UserInterface
28 |     {
29 |         $webauthnBadge = $this->getBadge(WebauthnBadge::class);
30 |         if ($webauthnBadge === null || ! $webauthnBadge instanceof WebauthnBadge) {
31 |             throw new LogicException('No WebauthnBadge found in the passport.');
32 |         }
33 | 
34 |         return $webauthnBadge->getUser();
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Authorization/Voter/IsUserPresentVoter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Authorization\Voter;
 6 | 
 7 | use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
 8 | use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
 9 | use Webauthn\Bundle\Security\Authentication\Token\WebauthnToken;
10 | 
11 | final readonly class IsUserPresentVoter implements VoterInterface
12 | {
13 |     public const IS_USER_PRESENT = 'IS_USER_PRESENT';
14 | 
15 |     public function vote(TokenInterface $token, mixed $subject, array $attributes): int
16 |     {
17 |         $result = VoterInterface::ACCESS_ABSTAIN;
18 |         if (! $token instanceof WebauthnToken) {
19 |             return $result;
20 |         }
21 | 
22 |         foreach ($attributes as $attribute) {
23 |             if ($attribute !== self::IS_USER_PRESENT) {
24 |                 continue;
25 |             }
26 | 
27 |             return $token->isUserPresent() ? VoterInterface::ACCESS_GRANTED : VoterInterface::ACCESS_DENIED;
28 |         }
29 | 
30 |         return $result;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Authorization/Voter/IsUserVerifiedVoter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Authorization\Voter;
 6 | 
 7 | use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
 8 | use Symfony\Component\Security\Core\Authorization\Voter\VoterInterface;
 9 | use Webauthn\Bundle\Security\Authentication\Token\WebauthnToken;
10 | 
11 | final readonly class IsUserVerifiedVoter implements VoterInterface
12 | {
13 |     public const IS_USER_VERIFIED = 'IS_USER_VERIFIED';
14 | 
15 |     public function vote(TokenInterface $token, mixed $subject, array $attributes): int
16 |     {
17 |         $result = VoterInterface::ACCESS_ABSTAIN;
18 |         if (! $token instanceof WebauthnToken) {
19 |             return $result;
20 |         }
21 | 
22 |         foreach ($attributes as $attribute) {
23 |             if ($attribute !== self::IS_USER_VERIFIED) {
24 |                 continue;
25 |             }
26 | 
27 |             return $token->isUserVerified() ? VoterInterface::ACCESS_GRANTED : VoterInterface::ACCESS_DENIED;
28 |         }
29 | 
30 |         return $result;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Guesser/CurrentUserEntityGuesser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Guesser;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
 9 | use Webauthn\Bundle\Exception\MissingUserEntityException;
10 | use Webauthn\Bundle\Repository\PublicKeyCredentialUserEntityRepositoryInterface;
11 | use Webauthn\PublicKeyCredentialUserEntity;
12 | 
13 | final readonly class CurrentUserEntityGuesser implements UserEntityGuesser
14 | {
15 |     public function __construct(
16 |         private TokenStorageInterface $tokenStorage,
17 |         private PublicKeyCredentialUserEntityRepositoryInterface $userEntityRepository
18 |     ) {
19 |     }
20 | 
21 |     public function findUserEntity(Request $request): PublicKeyCredentialUserEntity
22 |     {
23 |         $user = $this->tokenStorage->getToken()?->getUser();
24 |         $user !== null || throw MissingUserEntityException::create('Unable to find the user entity');
25 |         $userEntity = $this->userEntityRepository->findOneByUsername($user->getUserIdentifier());
26 |         $userEntity !== null || throw MissingUserEntityException::create('Unable to find the user entity');
27 | 
28 |         return $userEntity;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Guesser/UserEntityGuesser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Guesser;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | use Webauthn\PublicKeyCredentialUserEntity;
 9 | 
10 | interface UserEntityGuesser
11 | {
12 |     public function findUserEntity(Request $request): PublicKeyCredentialUserEntity;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/CreationOptionsHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Response;
 8 | use Webauthn\PublicKeyCredentialCreationOptions;
 9 | use Webauthn\PublicKeyCredentialUserEntity;
10 | 
11 | interface CreationOptionsHandler
12 | {
13 |     public function onCreationOptions(
14 |         PublicKeyCredentialCreationOptions $publicKeyCredentialCreationOptions,
15 |         PublicKeyCredentialUserEntity $userEntity
16 |     ): Response;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/DefaultCreationOptionsHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use RuntimeException;
 8 | use Symfony\Component\HttpFoundation\JsonResponse;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Symfony\Component\Serializer\Encoder\JsonEncoder;
11 | use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
12 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
13 | use Webauthn\PublicKeyCredentialCreationOptions;
14 | use Webauthn\PublicKeyCredentialUserEntity;
15 | use function is_array;
16 | 
17 | final readonly class DefaultCreationOptionsHandler implements CreationOptionsHandler
18 | {
19 |     public function __construct(
20 |         private NormalizerInterface $normalizer
21 |     ) {
22 |     }
23 | 
24 |     public function onCreationOptions(
25 |         PublicKeyCredentialCreationOptions $publicKeyCredentialCreationOptions,
26 |         PublicKeyCredentialUserEntity $userEntity
27 |     ): Response {
28 |         $data = $this->normalizer->normalize($publicKeyCredentialCreationOptions, JsonEncoder::FORMAT, [
29 |             AbstractObjectNormalizer::SKIP_NULL_VALUES => true,
30 |         ]);
31 |         is_array($data) || throw new RuntimeException('Unable to encode the response to JSON.');
32 |         $data['status'] = 'ok';
33 |         $data['errorMessage'] = '';
34 | 
35 |         return new JsonResponse($data);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/DefaultFailureHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use Symfony\Component\HttpFoundation\JsonResponse;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Symfony\Component\Security\Core\Exception\AuthenticationException;
11 | use Symfony\Component\Security\Http\Authentication\AuthenticationFailureHandlerInterface;
12 | use Throwable;
13 | 
14 | final class DefaultFailureHandler implements FailureHandler, AuthenticationFailureHandlerInterface
15 | {
16 |     public function onFailure(Request $request, ?Throwable $exception = null): Response
17 |     {
18 |         $data = [
19 |             'status' => 'error',
20 |             'errorMessage' => $exception === null ? 'Authentication failed' : $exception->getMessage(),
21 |         ];
22 | 
23 |         return new JsonResponse($data, Response::HTTP_UNAUTHORIZED);
24 |     }
25 | 
26 |     public function onAuthenticationFailure(Request $request, AuthenticationException $exception): Response
27 |     {
28 |         return $this->onFailure($request, $exception);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/DefaultRequestOptionsHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use RuntimeException;
 8 | use Symfony\Component\HttpFoundation\JsonResponse;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Symfony\Component\Serializer\Encoder\JsonEncoder;
11 | use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
12 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
13 | use Webauthn\PublicKeyCredentialRequestOptions;
14 | use Webauthn\PublicKeyCredentialUserEntity;
15 | use function is_array;
16 | 
17 | final readonly class DefaultRequestOptionsHandler implements RequestOptionsHandler
18 | {
19 |     public function __construct(
20 |         private NormalizerInterface $normalizer
21 |     ) {
22 |     }
23 | 
24 |     public function onRequestOptions(
25 |         PublicKeyCredentialRequestOptions $publicKeyCredentialRequestOptions,
26 |         ?PublicKeyCredentialUserEntity $userEntity
27 |     ): Response {
28 |         $data = $this->normalizer->normalize($publicKeyCredentialRequestOptions, JsonEncoder::FORMAT, [
29 |             AbstractObjectNormalizer::SKIP_NULL_VALUES => true,
30 |         ]);
31 |         is_array($data) || throw new RuntimeException('Unable to encode the response to JSON.');
32 |         $data['status'] = 'ok';
33 |         $data['errorMessage'] = '';
34 | 
35 |         return new JsonResponse($data);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/DefaultSuccessHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use Symfony\Component\HttpFoundation\JsonResponse;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
11 | use Symfony\Component\Security\Http\Authentication\AuthenticationSuccessHandlerInterface;
12 | 
13 | final class DefaultSuccessHandler implements SuccessHandler, AuthenticationSuccessHandlerInterface
14 | {
15 |     public function onSuccess(Request $request): Response
16 |     {
17 |         $data = [
18 |             'status' => 'ok',
19 |             'errorMessage' => '',
20 |         ];
21 |         $statusCode = $request->getMethod() === Request::METHOD_POST ? Response::HTTP_CREATED : Response::HTTP_OK;
22 | 
23 |         return new JsonResponse($data, $statusCode);
24 |     }
25 | 
26 |     public function onAuthenticationSuccess(Request $request, TokenInterface $token): Response
27 |     {
28 |         return $this->onSuccess($request);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/FailureHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | use Symfony\Component\HttpFoundation\Response;
 9 | use Throwable;
10 | 
11 | interface FailureHandler
12 | {
13 |     public function onFailure(Request $request, ?Throwable $exception = null): Response;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/RequestOptionsHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Response;
 8 | use Webauthn\PublicKeyCredentialRequestOptions;
 9 | use Webauthn\PublicKeyCredentialUserEntity;
10 | 
11 | interface RequestOptionsHandler
12 | {
13 |     public function onRequestOptions(
14 |         PublicKeyCredentialRequestOptions $publicKeyCredentialRequestOptions,
15 |         ?PublicKeyCredentialUserEntity $userEntity
16 |     ): Response;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Handler/SuccessHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Handler;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | use Symfony\Component\HttpFoundation\Response;
 9 | 
10 | interface SuccessHandler
11 | {
12 |     public function onSuccess(Request $request): Response;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Http/Authenticator/Passport/Credentials/WebauthnCredentials.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Http\Authenticator\Passport\Credentials;
 6 | 
 7 | use Symfony\Component\Security\Http\Authenticator\Passport\Credentials\CredentialsInterface;
 8 | use Webauthn\AuthenticatorResponse;
 9 | use Webauthn\PublicKeyCredentialOptions;
10 | use Webauthn\PublicKeyCredentialSource;
11 | use Webauthn\PublicKeyCredentialUserEntity;
12 | 
13 | class WebauthnCredentials implements CredentialsInterface
14 | {
15 |     public function __construct(
16 |         private readonly AuthenticatorResponse $authenticatorResponse,
17 |         private readonly PublicKeyCredentialOptions $publicKeyCredentialOptions,
18 |         private readonly PublicKeyCredentialUserEntity $publicKeyCredentialUserEntity,
19 |         private readonly PublicKeyCredentialSource $publicKeyCredentialSource,
20 |         private readonly string $firewallName,
21 |     ) {
22 |     }
23 | 
24 |     public function getAuthenticatorResponse(): AuthenticatorResponse
25 |     {
26 |         return $this->authenticatorResponse;
27 |     }
28 | 
29 |     public function getPublicKeyCredentialOptions(): PublicKeyCredentialOptions
30 |     {
31 |         return $this->publicKeyCredentialOptions;
32 |     }
33 | 
34 |     public function getPublicKeyCredentialUserEntity(): ?PublicKeyCredentialUserEntity
35 |     {
36 |         return $this->publicKeyCredentialUserEntity;
37 |     }
38 | 
39 |     public function getPublicKeyCredentialSource(): PublicKeyCredentialSource
40 |     {
41 |         return $this->publicKeyCredentialSource;
42 |     }
43 | 
44 |     public function getFirewallName(): string
45 |     {
46 |         return $this->firewallName;
47 |     }
48 | 
49 |     public function isResolved(): bool
50 |     {
51 |         return true;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Storage/CacheStorage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Storage;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
 9 | use function sprintf;
10 | 
11 | final readonly class CacheStorage implements OptionsStorage
12 | {
13 |     private const CACHE_PARAMETER = 'WEBAUTHN_PUBLIC_KEY_OPTIONS';
14 | 
15 |     public function __construct(
16 |         private CacheItemPoolInterface $cache
17 |     ) {
18 |     }
19 | 
20 |     public function store(Item $item): void
21 |     {
22 |         $key = sprintf(
23 |             '%s-%s',
24 |             self::CACHE_PARAMETER,
25 |             hash('xxh128', $item->getPublicKeyCredentialOptions()->challenge)
26 |         );
27 | 
28 |         $cacheItem = $this->cache->getItem($key);
29 |         $cacheItem->set($item);
30 |         $this->cache->save($cacheItem);
31 |     }
32 | 
33 |     public function get(string $challenge): Item
34 |     {
35 |         $key = sprintf('%s-%s', self::CACHE_PARAMETER, hash('xxh128', $challenge));
36 |         $cacheItem = $this->cache->getItem($key);
37 |         if (! $cacheItem->isHit()) {
38 |             throw new BadRequestHttpException('No public key credential options available.');
39 |         }
40 |         $item = $cacheItem->get();
41 |         $this->cache->deleteItem($key);
42 |         if (! $item instanceof Item) {
43 |             throw new BadRequestHttpException('No public key credential options available.');
44 |         }
45 | 
46 |         return $item;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Storage/Item.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Storage;
 6 | 
 7 | use Webauthn\PublicKeyCredentialOptions;
 8 | use Webauthn\PublicKeyCredentialUserEntity;
 9 | 
10 | final readonly class Item
11 | {
12 |     public function __construct(
13 |         private PublicKeyCredentialOptions $publicKeyCredentialOptions,
14 |         private ?PublicKeyCredentialUserEntity $publicKeyCredentialUserEntity
15 |     ) {
16 |     }
17 | 
18 |     public static function create(
19 |         PublicKeyCredentialOptions $publicKeyCredentialOptions,
20 |         ?PublicKeyCredentialUserEntity $publicKeyCredentialUserEntity
21 |     ): self {
22 |         return new self($publicKeyCredentialOptions, $publicKeyCredentialUserEntity);
23 |     }
24 | 
25 |     public function getPublicKeyCredentialOptions(): PublicKeyCredentialOptions
26 |     {
27 |         return $this->publicKeyCredentialOptions;
28 |     }
29 | 
30 |     public function getPublicKeyCredentialUserEntity(): ?PublicKeyCredentialUserEntity
31 |     {
32 |         return $this->publicKeyCredentialUserEntity;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/symfony/src/Security/Storage/OptionsStorage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Security\Storage;
 6 | 
 7 | interface OptionsStorage
 8 | {
 9 |     public function store(Item $item): void;
10 | 
11 |     public function get(string $challenge): Item;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/symfony/src/Service/DefaultFailureHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Service;
 6 | 
 7 | use Symfony\Component\HttpFoundation\JsonResponse;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Throwable;
11 | use Webauthn\Bundle\Security\Handler\FailureHandler;
12 | 
13 | final class DefaultFailureHandler implements FailureHandler
14 | {
15 |     public function onFailure(Request $request, ?Throwable $exception = null): Response
16 |     {
17 |         $data = [
18 |             'status' => 'error',
19 |             'errorMessage' => $exception === null ? 'An unexpected error occurred' : $exception->getMessage(),
20 |         ];
21 | 
22 |         return new JsonResponse($data, Response::HTTP_BAD_REQUEST);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/symfony/src/Service/DefaultSuccessHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Bundle\Service;
 6 | 
 7 | use Symfony\Component\HttpFoundation\JsonResponse;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Webauthn\Bundle\Security\Handler\SuccessHandler;
11 | 
12 | final class DefaultSuccessHandler implements SuccessHandler
13 | {
14 |     public function onSuccess(Request $request): Response
15 |     {
16 |         $data = [
17 |             'status' => 'ok',
18 |             'errorMessage' => '',
19 |         ];
20 | 
21 |         return new JsonResponse($data, JsonResponse::HTTP_CREATED);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/webauthn/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018-2022 Spomky-Labs
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/webauthn/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "web-auth/webauthn-lib",
 3 |     "type": "library",
 4 |     "license": "MIT",
 5 |     "description": "FIDO2/Webauthn Support For PHP",
 6 |     "keywords": [
 7 |         "FIDO",
 8 |         "FIDO2",
 9 |         "webauthn"
10 |     ],
11 |     "homepage": "https://github.com/web-auth",
12 |     "authors": [
13 |         {
14 |             "name": "Florent Morselli",
15 |             "homepage": "https://github.com/Spomky"
16 |         },
17 |         {
18 |             "name": "All contributors",
19 |             "homepage": "https://github.com/web-auth/webauthn-library/contributors"
20 |         }
21 |     ],
22 |     "require": {
23 |         "php": ">=8.2",
24 |         "ext-json": "*",
25 |         "ext-openssl": "*",
26 |         "paragonie/constant_time_encoding": "^2.6|^3.0",
27 |         "phpdocumentor/reflection-docblock": "^5.3",
28 |         "psr/clock": "^1.0",
29 |         "psr/event-dispatcher": "^1.0",
30 |         "psr/log": "^1.0|^2.0|^3.0",
31 |         "spomky-labs/cbor-php": "^3.0",
32 |         "symfony/clock": "^6.4|^7.0",
33 |         "symfony/uid": "^6.4|^7.0",
34 |         "spomky-labs/pki-framework": "^1.0",
35 |         "symfony/property-info": "^6.4|^7.0",
36 |         "symfony/property-access": "^6.4|^7.0",
37 |         "symfony/serializer": "^6.4|^7.0",
38 |         "symfony/deprecation-contracts": "^3.2",
39 |         "web-auth/cose-lib": "^4.2.3"
40 |     },
41 |     "autoload": {
42 |         "psr-4": {
43 |             "Webauthn\\": "src/"
44 |         }
45 |     },
46 |     "extra": {
47 |         "thanks": {
48 |             "name": "web-auth/webauthn-framework",
49 |             "url": "https://github.com/web-auth/webauthn-framework"
50 |         }
51 |     },
52 |     "suggest": {
53 |         "psr/log-implementation": "Recommended to receive logs from the library",
54 |         "symfony/event-dispatcher": "Recommended to use dispatched events",
55 |         "web-token/jwt-library": "Mandatory for fetching Metadata Statement from distant sources"
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AttestationStatement/AttestationObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AttestationStatement;
 6 | 
 7 | use Webauthn\AuthenticatorData;
 8 | use Webauthn\MetadataService\Statement\MetadataStatement;
 9 | 
10 | class AttestationObject
11 | {
12 |     public ?MetadataStatement $metadataStatement = null;
13 | 
14 |     public function __construct(
15 |         public readonly string $rawAttestationObject,
16 |         public AttestationStatement $attStmt,
17 |         public readonly AuthenticatorData $authData
18 |     ) {
19 |     }
20 | 
21 |     public static function create(
22 |         string $rawAttestationObject,
23 |         AttestationStatement $attStmt,
24 |         AuthenticatorData $authData
25 |     ): self {
26 |         return new self($rawAttestationObject, $attStmt, $authData);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AttestationStatement/AttestationStatementSupport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AttestationStatement;
 6 | 
 7 | use Webauthn\AuthenticatorData;
 8 | 
 9 | interface AttestationStatementSupport
10 | {
11 |     public function name(): string;
12 | 
13 |     /**
14 |      * @param array<string, mixed> $attestation
15 |      */
16 |     public function load(array $attestation): AttestationStatement;
17 | 
18 |     public function isValid(
19 |         string $clientDataJSONHash,
20 |         AttestationStatement $attestationStatement,
21 |         AuthenticatorData $authenticatorData
22 |     ): bool;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AttestationStatement/AttestationStatementSupportManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AttestationStatement;
 6 | 
 7 | use Webauthn\Exception\InvalidDataException;
 8 | use function array_key_exists;
 9 | use function sprintf;
10 | 
11 | class AttestationStatementSupportManager
12 | {
13 |     /**
14 |      * @param AttestationStatementSupport[] $attestationStatementSupports
15 |      */
16 |     public function __construct(
17 |         private array $attestationStatementSupports = []
18 |     ) {
19 |         $this->add(new NoneAttestationStatementSupport());
20 |         foreach ($attestationStatementSupports as $attestationStatementSupport) {
21 |             $this->add($attestationStatementSupport);
22 |         }
23 |     }
24 | 
25 |     /**
26 |      * @param AttestationStatementSupport[] $attestationStatementSupports
27 |      */
28 |     public static function create(array $attestationStatementSupports = []): self
29 |     {
30 |         return new self($attestationStatementSupports);
31 |     }
32 | 
33 |     public function add(AttestationStatementSupport $attestationStatementSupport): void
34 |     {
35 |         $this->attestationStatementSupports[$attestationStatementSupport->name()] = $attestationStatementSupport;
36 |     }
37 | 
38 |     public function has(string $name): bool
39 |     {
40 |         return array_key_exists($name, $this->attestationStatementSupports);
41 |     }
42 | 
43 |     public function get(string $name): AttestationStatementSupport
44 |     {
45 |         $this->has($name) || throw InvalidDataException::create($name, sprintf(
46 |             'The attestation statement format "%s" is not supported.',
47 |             $name
48 |         ));
49 | 
50 |         return $this->attestationStatementSupports[$name];
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AttestedCredentialData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use Symfony\Component\Uid\Uuid;
 8 | 
 9 | /**
10 |  * @see https://www.w3.org/TR/webauthn/#sec-attested-credential-data
11 |  */
12 | class AttestedCredentialData
13 | {
14 |     public function __construct(
15 |         public Uuid $aaguid,
16 |         public readonly string $credentialId,
17 |         public readonly ?string $credentialPublicKey
18 |     ) {
19 |     }
20 | 
21 |     public static function create(Uuid $aaguid, string $credentialId, ?string $credentialPublicKey = null): self
22 |     {
23 |         return new self($aaguid, $credentialId, $credentialPublicKey);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/AppIdExcludeInputExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | final class AppIdExcludeInputExtension extends AuthenticationExtension
 8 | {
 9 |     public static function enable(string $value): AuthenticationExtension
10 |     {
11 |         return self::create('appidExclude', $value);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/AppIdInputExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | final class AppIdInputExtension extends AuthenticationExtension
 8 | {
 9 |     public static function enable(): AuthenticationExtension
10 |     {
11 |         return self::create('appid', true);
12 |     }
13 | 
14 |     public static function disable(): AuthenticationExtension
15 |     {
16 |         return self::create('appid', false);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/AuthenticationExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | class AuthenticationExtension
 8 | {
 9 |     public function __construct(
10 |         public readonly string $name,
11 |         public readonly mixed $value
12 |     ) {
13 |     }
14 | 
15 |     public static function create(string $name, mixed $value): self
16 |     {
17 |         return new self($name, $value);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/AuthenticationExtensionLoader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | use CBOR\CBORObject;
 8 | use CBOR\MapObject;
 9 | use Webauthn\Exception\AuthenticationExtensionException;
10 | 
11 | abstract class AuthenticationExtensionLoader
12 | {
13 |     public static function load(CBORObject $object): AuthenticationExtensions
14 |     {
15 |         $object instanceof MapObject || throw AuthenticationExtensionException::create('Invalid extension object');
16 |         $data = $object->normalize();
17 |         return AuthenticationExtensions::create(
18 |             array_map(
19 |                 fn (mixed $value, string $key) => AuthenticationExtension::create($key, $value),
20 |                 $data,
21 |                 array_keys($data)
22 |             )
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/CredentialPropertiesInputExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | final class CredentialPropertiesInputExtension extends AuthenticationExtension
 8 | {
 9 |     public static function enable(): AuthenticationExtension
10 |     {
11 |         return self::create('credProps', true);
12 |     }
13 | 
14 |     public static function disable(): AuthenticationExtension
15 |     {
16 |         return self::create('credProps', false);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/ExtensionOutputChecker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | interface ExtensionOutputChecker
 8 | {
 9 |     public function check(AuthenticationExtensions $inputs, AuthenticationExtensions $outputs): void;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/ExtensionOutputCheckerHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | class ExtensionOutputCheckerHandler
 8 | {
 9 |     /**
10 |      * @var ExtensionOutputChecker[]
11 |      */
12 |     private array $checkers = [];
13 | 
14 |     public static function create(): self
15 |     {
16 |         return new self();
17 |     }
18 | 
19 |     public function add(ExtensionOutputChecker $checker): void
20 |     {
21 |         $this->checkers[] = $checker;
22 |     }
23 | 
24 |     public function check(AuthenticationExtensions $inputs, AuthenticationExtensions $outputs): void
25 |     {
26 |         foreach ($this->checkers as $checker) {
27 |             $checker->check($inputs, $outputs);
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/ExtensionOutputError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | use Exception;
 8 | use Throwable;
 9 | 
10 | class ExtensionOutputError extends Exception
11 | {
12 |     public function __construct(
13 |         public readonly AuthenticationExtension $authenticationExtension,
14 |         string $message = '',
15 |         int $code = 0,
16 |         ?Throwable $previous = null
17 |     ) {
18 |         parent::__construct($message, $code, $previous);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/LargeBlobInputExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | use function assert;
 8 | use function in_array;
 9 | 
10 | final class LargeBlobInputExtension extends AuthenticationExtension
11 | {
12 |     public const REQUIRED = 'required';
13 | 
14 |     public const PREFERRED = 'preferred';
15 | 
16 |     public static function support(string $support): AuthenticationExtension
17 |     {
18 |         assert(in_array($support, [self::REQUIRED, self::PREFERRED], true), 'Invalid support value.');
19 | 
20 |         return self::create('largeBlob', [
21 |             'support' => $support,
22 |         ]);
23 |     }
24 | 
25 |     public static function read(): AuthenticationExtension
26 |     {
27 |         return self::create('largeBlob', [
28 |             'read' => true,
29 |         ]);
30 |     }
31 | 
32 |     public static function write(string $value): AuthenticationExtension
33 |     {
34 |         return self::create('largeBlob', [
35 |             'write' => $value,
36 |         ]);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/PseudoRandomFunctionInputExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | final class PseudoRandomFunctionInputExtension extends AuthenticationExtension
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/PseudoRandomFunctionInputExtensionBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | use ParagonIE\ConstantTime\Base64UrlSafe;
 8 | use function array_key_exists;
 9 | 
10 | final class PseudoRandomFunctionInputExtensionBuilder
11 | {
12 |     /**
13 |      * @var array{eval?: array{first: string, second?: string}, evalByCredential?: array<string, array{first: string, second?: string}>
14 |      */
15 |     private array $values = [];
16 | 
17 |     private function __construct()
18 |     {
19 |     }
20 | 
21 |     public static function create(): self
22 |     {
23 |         return new self();
24 |     }
25 | 
26 |     public function withInputs(string $first, null|string $second = null): self
27 |     {
28 |         $eval = [
29 |             'first' => Base64UrlSafe::encodeUnpadded($first),
30 |         ];
31 |         if ($second !== null) {
32 |             $eval['second'] = Base64UrlSafe::encodeUnpadded($second);
33 |         }
34 |         $this->values['eval'] = $eval;
35 | 
36 |         return $this;
37 |     }
38 | 
39 |     public function withCredentialInputs(string $credentialId, string $first, null|string $second = null): self
40 |     {
41 |         $eval = [
42 |             'first' => Base64UrlSafe::encodeUnpadded($first),
43 |         ];
44 |         if ($second !== null) {
45 |             $eval['second'] = Base64UrlSafe::encodeUnpadded($second);
46 |         }
47 |         if (! array_key_exists('evalByCredential', $this->values)) {
48 |             $this->values['evalByCredential'] = [];
49 |         }
50 |         $this->values['evalByCredential'][$credentialId] = $eval;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function build(): PseudoRandomFunctionInputExtension
56 |     {
57 |         return new PseudoRandomFunctionInputExtension('prf', $this->values);
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticationExtensions/UvmInputExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\AuthenticationExtensions;
 6 | 
 7 | final class UvmInputExtension extends AuthenticationExtension
 8 | {
 9 |     public static function enable(): AuthenticationExtension
10 |     {
11 |         return self::create('uvm', true);
12 |     }
13 | 
14 |     public static function disable(): AuthenticationExtension
15 |     {
16 |         return self::create('uvm', false);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticatorAssertionResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use Webauthn\AttestationStatement\AttestationObject;
 8 | 
 9 | /**
10 |  * @see https://www.w3.org/TR/webauthn/#authenticatorassertionresponse
11 |  */
12 | class AuthenticatorAssertionResponse extends AuthenticatorResponse
13 | {
14 |     public function __construct(
15 |         CollectedClientData $clientDataJSON,
16 |         public readonly AuthenticatorData $authenticatorData,
17 |         public readonly string $signature,
18 |         public readonly ?string $userHandle,
19 |         public readonly null|AttestationObject $attestationObject = null,
20 |     ) {
21 |         parent::__construct($clientDataJSON);
22 |     }
23 | 
24 |     public static function create(
25 |         CollectedClientData $clientDataJSON,
26 |         AuthenticatorData $authenticatorData,
27 |         string $signature,
28 |         ?string $userHandle = null,
29 |         null|AttestationObject $attestationObject = null,
30 |     ): self {
31 |         return new self($clientDataJSON, $authenticatorData, $signature, $userHandle, $attestationObject);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticatorAttestationResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use Webauthn\AttestationStatement\AttestationObject;
 8 | 
 9 | /**
10 |  * @see https://www.w3.org/TR/webauthn/#authenticatorattestationresponse
11 |  */
12 | class AuthenticatorAttestationResponse extends AuthenticatorResponse
13 | {
14 |     /**
15 |      * @param string[] $transports
16 |      */
17 |     public function __construct(
18 |         CollectedClientData $clientDataJSON,
19 |         public readonly AttestationObject $attestationObject,
20 |         public readonly array $transports = []
21 |     ) {
22 |         parent::__construct($clientDataJSON);
23 |     }
24 | 
25 |     /**
26 |      * @param string[] $transports
27 |      */
28 |     public static function create(
29 |         CollectedClientData $clientDataJSON,
30 |         AttestationObject $attestationObject,
31 |         array $transports = []
32 |     ): self {
33 |         return new self($clientDataJSON, $attestationObject, $transports);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/webauthn/src/AuthenticatorResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | /**
 8 |  * @see https://www.w3.org/TR/webauthn/#authenticatorresponse
 9 |  */
10 | abstract class AuthenticatorResponse
11 | {
12 |     public function __construct(
13 |         public readonly CollectedClientData $clientDataJSON
14 |     ) {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CeremonyStep.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\PublicKeyCredentialCreationOptions;
10 | use Webauthn\PublicKeyCredentialRequestOptions;
11 | use Webauthn\PublicKeyCredentialSource;
12 | 
13 | interface CeremonyStep
14 | {
15 |     public function process(
16 |         PublicKeyCredentialSource $publicKeyCredentialSource,
17 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
18 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
19 |         ?string $userHandle,
20 |         string $host
21 |     ): void;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CeremonyStepManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\PublicKeyCredentialCreationOptions;
10 | use Webauthn\PublicKeyCredentialRequestOptions;
11 | use Webauthn\PublicKeyCredentialSource;
12 | 
13 | final readonly class CeremonyStepManager
14 | {
15 |     /**
16 |      * @param CeremonyStep[] $steps
17 |      */
18 |     public function __construct(
19 |         private array $steps
20 |     ) {
21 |     }
22 | 
23 |     public function process(
24 |         PublicKeyCredentialSource $publicKeyCredentialSource,
25 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
26 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
27 |         ?string $userHandle,
28 |         string $host
29 |     ): void {
30 |         foreach ($this->steps as $step) {
31 |             $step->process(
32 |                 $publicKeyCredentialSource,
33 |                 $authenticatorResponse,
34 |                 $publicKeyCredentialOptions,
35 |                 $userHandle,
36 |                 $host
37 |             );
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckAllowedCredentialList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | use function count;
14 | 
15 | final class CheckAllowedCredentialList implements CeremonyStep
16 | {
17 |     public function process(
18 |         PublicKeyCredentialSource $publicKeyCredentialSource,
19 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
20 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
21 |         ?string $userHandle,
22 |         string $host
23 |     ): void {
24 |         if (! $publicKeyCredentialOptions instanceof PublicKeyCredentialRequestOptions) {
25 |             return;
26 |         }
27 |         if (count($publicKeyCredentialOptions->allowCredentials) === 0) {
28 |             return;
29 |         }
30 | 
31 |         foreach ($publicKeyCredentialOptions->allowCredentials as $allowedCredential) {
32 |             if (hash_equals($allowedCredential->id, $publicKeyCredentialSource->publicKeyCredentialId)) {
33 |                 return;
34 |             }
35 |         }
36 |         throw AuthenticatorResponseVerificationException::create('The credential ID is not allowed.');
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckAttestationFormatIsKnownAndValid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AttestationStatement\AttestationStatementSupportManager;
 8 | use Webauthn\AuthenticatorAssertionResponse;
 9 | use Webauthn\AuthenticatorAttestationResponse;
10 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
11 | use Webauthn\PublicKeyCredentialCreationOptions;
12 | use Webauthn\PublicKeyCredentialRequestOptions;
13 | use Webauthn\PublicKeyCredentialSource;
14 | 
15 | final readonly class CheckAttestationFormatIsKnownAndValid implements CeremonyStep
16 | {
17 |     public function __construct(
18 |         private AttestationStatementSupportManager $attestationStatementSupportManager,
19 |     ) {
20 |     }
21 | 
22 |     public function process(
23 |         PublicKeyCredentialSource $publicKeyCredentialSource,
24 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
25 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
26 |         ?string $userHandle,
27 |         string $host
28 |     ): void {
29 |         $attestationObject = $authenticatorResponse->attestationObject;
30 |         if ($attestationObject === null) {
31 |             return;
32 |         }
33 | 
34 |         $fmt = $attestationObject->attStmt
35 |             ->fmt;
36 |         $this->attestationStatementSupportManager->has(
37 |             $fmt
38 |         ) || throw AuthenticatorResponseVerificationException::create('Unsupported attestation statement format.');
39 | 
40 |         $attestationStatementSupport = $this->attestationStatementSupportManager->get($fmt);
41 |         $clientDataJSONHash = hash('sha256', $authenticatorResponse->clientDataJSON ->rawData, true);
42 |         $attestationStatementSupport->isValid(
43 |             $clientDataJSONHash,
44 |             $attestationObject->attStmt,
45 |             $attestationObject->authData
46 |         ) || throw AuthenticatorResponseVerificationException::create('Invalid attestation statement.');
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckBackupBitsAreConsistent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final class CheckBackupBitsAreConsistent implements CeremonyStep
15 | {
16 |     public function process(
17 |         PublicKeyCredentialSource $publicKeyCredentialSource,
18 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
19 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
20 |         ?string $userHandle,
21 |         string $host
22 |     ): void {
23 |         $authData = $authenticatorResponse instanceof AuthenticatorAssertionResponse ? $authenticatorResponse->authenticatorData : $authenticatorResponse->attestationObject->authData;
24 |         if ($authData->isBackupEligible()) {
25 |             return;
26 |         }
27 |         $authData->isBackedUp() !== true || throw AuthenticatorResponseVerificationException::create(
28 |             'Backup up bit is set but the backup is not eligible.'
29 |         );
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckChallenge.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final class CheckChallenge implements CeremonyStep
15 | {
16 |     public function process(
17 |         PublicKeyCredentialSource $publicKeyCredentialSource,
18 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
19 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
20 |         ?string $userHandle,
21 |         string $host
22 |     ): void {
23 |         $publicKeyCredentialOptions->challenge !== '' || throw AuthenticatorResponseVerificationException::create(
24 |             'Invalid challenge.'
25 |         );
26 |         hash_equals(
27 |             $publicKeyCredentialOptions->challenge,
28 |             $authenticatorResponse->clientDataJSON->challenge
29 |         ) || throw AuthenticatorResponseVerificationException::create('Invalid challenge.');
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckClientDataCollectorType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\ClientDataCollector\ClientDataCollectorManager;
10 | use Webauthn\ClientDataCollector\WebauthnAuthenticationCollector;
11 | use Webauthn\PublicKeyCredentialCreationOptions;
12 | use Webauthn\PublicKeyCredentialRequestOptions;
13 | use Webauthn\PublicKeyCredentialSource;
14 | 
15 | final readonly class CheckClientDataCollectorType implements CeremonyStep
16 | {
17 |     private ClientDataCollectorManager $clientDataCollectorManager;
18 | 
19 |     public function __construct(
20 |         null|ClientDataCollectorManager $clientDataCollectorManager = null,
21 |     ) {
22 |         $this->clientDataCollectorManager = $clientDataCollectorManager ?? new ClientDataCollectorManager([
23 |             new WebauthnAuthenticationCollector(),
24 |         ]);
25 |     }
26 | 
27 |     public function process(
28 |         PublicKeyCredentialSource $publicKeyCredentialSource,
29 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
30 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
31 |         ?string $userHandle,
32 |         string $host
33 |     ): void {
34 |         $this->clientDataCollectorManager->collect(
35 |             $authenticatorResponse->clientDataJSON,
36 |             $publicKeyCredentialOptions,
37 |             $authenticatorResponse,
38 |             $host
39 |         );
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckCounter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Counter\CounterChecker;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final readonly class CheckCounter implements CeremonyStep
15 | {
16 |     public function __construct(
17 |         private CounterChecker $counterChecker
18 |     ) {
19 |     }
20 | 
21 |     public function process(
22 |         PublicKeyCredentialSource $publicKeyCredentialSource,
23 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
24 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
25 |         ?string $userHandle,
26 |         string $host
27 |     ): void {
28 |         $authData = $authenticatorResponse instanceof AuthenticatorAssertionResponse ? $authenticatorResponse->authenticatorData : $authenticatorResponse->attestationObject->authData;
29 |         $storedCounter = $publicKeyCredentialSource->counter;
30 |         $responseCounter = $authData->signCount;
31 |         if ($responseCounter !== 0 || $storedCounter !== 0) {
32 |             $this->counterChecker->check($publicKeyCredentialSource, $responseCounter);
33 |         }
34 |         $publicKeyCredentialSource->counter = $responseCounter;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckCredentialId.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | use function strlen;
14 | 
15 | class CheckCredentialId implements CeremonyStep
16 | {
17 |     public function process(
18 |         PublicKeyCredentialSource $publicKeyCredentialSource,
19 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
20 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
21 |         ?string $userHandle,
22 |         string $host
23 |     ): void {
24 |         $credentialId = $publicKeyCredentialSource->publicKeyCredentialId;
25 |         strlen($credentialId) <= 1023 || throw new AuthenticatorResponseVerificationException(
26 |             'Credential ID too long.'
27 |         );
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckExtensions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticationExtensions\ExtensionOutputCheckerHandler;
 8 | use Webauthn\AuthenticatorAssertionResponse;
 9 | use Webauthn\AuthenticatorAttestationResponse;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final readonly class CheckExtensions implements CeremonyStep
15 | {
16 |     public function __construct(
17 |         private ExtensionOutputCheckerHandler $extensionOutputCheckerHandler,
18 |     ) {
19 |     }
20 | 
21 |     public function process(
22 |         PublicKeyCredentialSource $publicKeyCredentialSource,
23 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
24 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
25 |         ?string $userHandle,
26 |         string $host
27 |     ): void {
28 |         $authData = $authenticatorResponse instanceof AuthenticatorAssertionResponse ? $authenticatorResponse->authenticatorData : $authenticatorResponse->attestationObject->authData;
29 |         $extensionsClientOutputs = $authData->extensions;
30 |         if ($extensionsClientOutputs !== null) {
31 |             $this->extensionOutputCheckerHandler->check(
32 |                 $publicKeyCredentialOptions->extensions,
33 |                 $extensionsClientOutputs
34 |             );
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckHasAttestedCredentialData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final class CheckHasAttestedCredentialData implements CeremonyStep
15 | {
16 |     public function process(
17 |         PublicKeyCredentialSource $publicKeyCredentialSource,
18 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
19 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
20 |         ?string $userHandle,
21 |         string $host
22 |     ): void {
23 |         $authData = $authenticatorResponse instanceof AuthenticatorAssertionResponse ? $authenticatorResponse->authenticatorData : $authenticatorResponse->attestationObject->authData;
24 |         $authData
25 |             ->hasAttestedCredentialData() || throw AuthenticatorResponseVerificationException::create(
26 |                 'There is no attested credential data.'
27 |             );
28 |         $authData->attestedCredentialData !== null || throw AuthenticatorResponseVerificationException::create(
29 |             'There is no attested credential data.'
30 |         );
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckTopOrigin.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | class CheckTopOrigin implements CeremonyStep
15 | {
16 |     public function __construct(
17 |         private readonly null|TopOriginValidator $topOriginValidator = null
18 |     ) {
19 |     }
20 | 
21 |     public function process(
22 |         PublicKeyCredentialSource $publicKeyCredentialSource,
23 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
24 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
25 |         ?string $userHandle,
26 |         string $host
27 |     ): void {
28 |         $topOrigin = $authenticatorResponse->clientDataJSON->topOrigin;
29 |         if ($topOrigin === null) {
30 |             return;
31 |         }
32 |         if ($authenticatorResponse->clientDataJSON->crossOrigin !== true) {
33 |             throw AuthenticatorResponseVerificationException::create('The response is not cross-origin.');
34 |         }
35 |         if ($this->topOriginValidator === null) {
36 |             (new HostTopOriginValidator($host))->validate($topOrigin);
37 |         } else {
38 |             $this->topOriginValidator->validate($topOrigin);
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckUserHandle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\InvalidUserHandleException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final class CheckUserHandle implements CeremonyStep
15 | {
16 |     public function process(
17 |         PublicKeyCredentialSource $publicKeyCredentialSource,
18 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
19 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
20 |         ?string $userHandle,
21 |         string $host
22 |     ): void {
23 |         if (! $authenticatorResponse instanceof AuthenticatorAssertionResponse) {
24 |             return;
25 |         }
26 |         $credentialUserHandle = $publicKeyCredentialSource->userHandle;
27 |         $responseUserHandle = $authenticatorResponse->userHandle;
28 |         if ($userHandle !== null) { //If the user was identified before the authentication ceremony was initiated,
29 |             $credentialUserHandle === $userHandle || throw InvalidUserHandleException::create();
30 |             if ($responseUserHandle !== null && $responseUserHandle !== '') {
31 |                 $credentialUserHandle === $responseUserHandle || throw InvalidUserHandleException::create();
32 |             }
33 |         } else {
34 |             ($responseUserHandle !== '' && $credentialUserHandle === $responseUserHandle) || throw InvalidUserHandleException::create();
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckUserVerification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\AuthenticatorSelectionCriteria;
10 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
11 | use Webauthn\PublicKeyCredentialCreationOptions;
12 | use Webauthn\PublicKeyCredentialRequestOptions;
13 | use Webauthn\PublicKeyCredentialSource;
14 | 
15 | final class CheckUserVerification implements CeremonyStep
16 | {
17 |     public function process(
18 |         PublicKeyCredentialSource $publicKeyCredentialSource,
19 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
20 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
21 |         ?string $userHandle,
22 |         string $host
23 |     ): void {
24 |         $userVerification = $publicKeyCredentialOptions instanceof PublicKeyCredentialRequestOptions ? $publicKeyCredentialOptions->userVerification : $publicKeyCredentialOptions->authenticatorSelection?->userVerification;
25 |         if ($userVerification !== AuthenticatorSelectionCriteria::USER_VERIFICATION_REQUIREMENT_REQUIRED) {
26 |             return;
27 |         }
28 |         $authData = $authenticatorResponse instanceof AuthenticatorAssertionResponse ? $authenticatorResponse->authenticatorData : $authenticatorResponse->attestationObject->authData;
29 |         $authData->isUserVerified() || throw AuthenticatorResponseVerificationException::create(
30 |             'User authentication required.'
31 |         );
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/CheckUserWasPresent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialCreationOptions;
11 | use Webauthn\PublicKeyCredentialRequestOptions;
12 | use Webauthn\PublicKeyCredentialSource;
13 | 
14 | final class CheckUserWasPresent implements CeremonyStep
15 | {
16 |     public function process(
17 |         PublicKeyCredentialSource $publicKeyCredentialSource,
18 |         AuthenticatorAssertionResponse|AuthenticatorAttestationResponse $authenticatorResponse,
19 |         PublicKeyCredentialRequestOptions|PublicKeyCredentialCreationOptions $publicKeyCredentialOptions,
20 |         ?string $userHandle,
21 |         string $host
22 |     ): void {
23 |         $authData = $authenticatorResponse instanceof AuthenticatorAssertionResponse ? $authenticatorResponse->authenticatorData : $authenticatorResponse->attestationObject->authData;
24 |         $authData->isUserPresent() || throw AuthenticatorResponseVerificationException::create('User was not present');
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/HostTopOriginValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
 8 | 
 9 | final readonly class HostTopOriginValidator implements TopOriginValidator
10 | {
11 |     public function __construct(
12 |         private string $host
13 |     ) {
14 |     }
15 | 
16 |     public function validate(string $topOrigin): void
17 |     {
18 |         $topOrigin === $this->host || throw AuthenticatorResponseVerificationException::create(
19 |             'The top origin does not correspond to the host.'
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/webauthn/src/CeremonyStep/TopOriginValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\CeremonyStep;
 6 | 
 7 | interface TopOriginValidator
 8 | {
 9 |     public function validate(string $topOrigin): void;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/webauthn/src/ClientDataCollector/ClientDataCollector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\ClientDataCollector;
 6 | 
 7 | use Webauthn\AuthenticatorResponse;
 8 | use Webauthn\CollectedClientData;
 9 | use Webauthn\PublicKeyCredentialOptions;
10 | 
11 | interface ClientDataCollector
12 | {
13 |     /**
14 |      * @return string[]
15 |      */
16 |     public function supportedTypes(): array;
17 | 
18 |     public function verifyCollectedClientData(
19 |         CollectedClientData $collectedClientData,
20 |         PublicKeyCredentialOptions $publicKeyCredentialOptions,
21 |         AuthenticatorResponse $authenticatorResponse,
22 |         string $host
23 |     ): void;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/webauthn/src/ClientDataCollector/ClientDataCollectorManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\ClientDataCollector;
 6 | 
 7 | use Webauthn\AuthenticatorResponse;
 8 | use Webauthn\CollectedClientData;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialOptions;
11 | use function in_array;
12 | 
13 | final readonly class ClientDataCollectorManager
14 | {
15 |     /**
16 |      * @param ClientDataCollector[] $clientDataCollectors
17 |      */
18 |     public function __construct(
19 |         private iterable $clientDataCollectors,
20 |     ) {
21 |     }
22 | 
23 |     public function collect(
24 |         CollectedClientData $collectedClientData,
25 |         PublicKeyCredentialOptions $publicKeyCredentialOptions,
26 |         AuthenticatorResponse $authenticatorResponse,
27 |         string $host
28 |     ): void {
29 |         foreach ($this->clientDataCollectors as $clientDataCollector) {
30 |             if (in_array($collectedClientData->type, $clientDataCollector->supportedTypes(), true)) {
31 |                 $clientDataCollector->verifyCollectedClientData(
32 |                     $collectedClientData,
33 |                     $publicKeyCredentialOptions,
34 |                     $authenticatorResponse,
35 |                     $host
36 |                 );
37 |                 return;
38 |             }
39 |         }
40 | 
41 |         throw AuthenticatorResponseVerificationException::create('No client data collector found.');
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/webauthn/src/ClientDataCollector/WebauthnAuthenticationCollector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\ClientDataCollector;
 6 | 
 7 | use Webauthn\AuthenticatorResponse;
 8 | use Webauthn\CollectedClientData;
 9 | use Webauthn\Exception\AuthenticatorResponseVerificationException;
10 | use Webauthn\PublicKeyCredentialOptions;
11 | use function in_array;
12 | use function sprintf;
13 | 
14 | final class WebauthnAuthenticationCollector implements ClientDataCollector
15 | {
16 |     public function supportedTypes(): array
17 |     {
18 |         return ['webauthn.get', 'webauthn.create'];
19 |     }
20 | 
21 |     public function verifyCollectedClientData(
22 |         CollectedClientData $collectedClientData,
23 |         PublicKeyCredentialOptions $publicKeyCredentialOptions,
24 |         AuthenticatorResponse $authenticatorResponse,
25 |         string $host
26 |     ): void {
27 |         in_array(
28 |             $collectedClientData->type,
29 |             $this->supportedTypes(),
30 |             true
31 |         ) || throw AuthenticatorResponseVerificationException::create(
32 |             sprintf('The client data type is not "%s" supported.', implode('", "', $this->supportedTypes()))
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Counter/CounterChecker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Counter;
 6 | 
 7 | use Webauthn\PublicKeyCredentialSource;
 8 | 
 9 | interface CounterChecker
10 | {
11 |     public function check(PublicKeyCredentialSource $publicKeyCredentialSource, int $currentCounter): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Counter/ThrowExceptionIfInvalid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Counter;
 6 | 
 7 | use Psr\Log\LoggerInterface;
 8 | use Psr\Log\NullLogger;
 9 | use Webauthn\Exception\CounterException;
10 | use Webauthn\MetadataService\CanLogData;
11 | use Webauthn\PublicKeyCredentialSource;
12 | 
13 | final class ThrowExceptionIfInvalid implements CounterChecker, CanLogData
14 | {
15 |     public function __construct(
16 |         private LoggerInterface $logger = new NullLogger()
17 |     ) {
18 |     }
19 | 
20 |     public function setLogger(LoggerInterface $logger): void
21 |     {
22 |         $this->logger = $logger;
23 |     }
24 | 
25 |     public function check(PublicKeyCredentialSource $publicKeyCredentialSource, int $currentCounter): void
26 |     {
27 |         try {
28 |             $currentCounter > $publicKeyCredentialSource->counter || throw CounterException::create(
29 |                 $currentCounter,
30 |                 $publicKeyCredentialSource->counter,
31 |                 'Invalid counter.'
32 |             );
33 |         } catch (CounterException $throwable) {
34 |             $this->logger->error('The counter is invalid', [
35 |                 'current' => $currentCounter,
36 |                 'new' => $publicKeyCredentialSource->counter,
37 |             ]);
38 |             throw $throwable;
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Credential.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | /**
 8 |  * @see https://w3c.github.io/webappsec-credential-management/#credential
 9 |  */
10 | abstract class Credential
11 | {
12 |     public function __construct(
13 |         public readonly string $type,
14 |         public readonly string $rawId,
15 |     ) {
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/AttestationStatementDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 8 | use Webauthn\AttestationStatement\AttestationStatement;
 9 | use Webauthn\AttestationStatement\AttestationStatementSupportManager;
10 | 
11 | final readonly class AttestationStatementDenormalizer implements DenormalizerInterface
12 | {
13 |     public function __construct(
14 |         private AttestationStatementSupportManager $attestationStatementSupportManager
15 |     ) {
16 |     }
17 | 
18 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
19 |     {
20 |         $attestationStatementSupport = $this->attestationStatementSupportManager->get($data['fmt']);
21 | 
22 |         return $attestationStatementSupport->load($data);
23 |     }
24 | 
25 |     public function supportsDenormalization(
26 |         mixed $data,
27 |         string $type,
28 |         ?string $format = null,
29 |         array $context = []
30 |     ): bool {
31 |         return $type === AttestationStatement::class;
32 |     }
33 | 
34 |     /**
35 |      * @return array<class-string, bool>
36 |      */
37 |     public function getSupportedTypes(?string $format): array
38 |     {
39 |         return [
40 |             AttestationStatement::class => true,
41 |         ];
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/AttestedCredentialDataNormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
 8 | use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
 9 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
10 | use Webauthn\AttestedCredentialData;
11 | use function assert;
12 | 
13 | final class AttestedCredentialDataNormalizer implements NormalizerInterface, NormalizerAwareInterface
14 | {
15 |     use NormalizerAwareTrait;
16 | 
17 |     /**
18 |      * @return array<string, mixed>
19 |      */
20 |     public function normalize(mixed $data, ?string $format = null, array $context = []): array
21 |     {
22 |         assert($data instanceof AttestedCredentialData);
23 |         $result = [
24 |             'aaguid' => $this->normalizer->normalize($data->aaguid, $format, $context),
25 |             'credentialId' => base64_encode($data->credentialId),
26 |         ];
27 |         if ($data->credentialPublicKey !== null) {
28 |             $result['credentialPublicKey'] = base64_encode($data->credentialPublicKey);
29 |         }
30 | 
31 |         return $result;
32 |     }
33 | 
34 |     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
35 |     {
36 |         return $data instanceof AttestedCredentialData;
37 |     }
38 | 
39 |     public function getSupportedTypes(?string $format): array
40 |     {
41 |         return [
42 |             AttestedCredentialData::class => true,
43 |         ];
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/AuthenticationExtensionNormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 8 | use Webauthn\AuthenticationExtensions\AuthenticationExtension;
 9 | use function assert;
10 | 
11 | final class AuthenticationExtensionNormalizer implements NormalizerInterface
12 | {
13 |     /**
14 |      * @return array<class-string, bool>
15 |      */
16 |     public function getSupportedTypes(?string $format): array
17 |     {
18 |         return [
19 |             AuthenticationExtension::class => true,
20 |         ];
21 |     }
22 | 
23 |     /**
24 |      * @return array<mixed>
25 |      */
26 |     public function normalize(mixed $object, ?string $format = null, array $context = []): array
27 |     {
28 |         assert($object instanceof AuthenticationExtension);
29 | 
30 |         return $object->value;
31 |     }
32 | 
33 |     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
34 |     {
35 |         return $data instanceof AuthenticationExtension;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/AuthenticatorAttestationResponseDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use ParagonIE\ConstantTime\Base64UrlSafe;
 8 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
 9 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
10 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
11 | use Webauthn\AttestationStatement\AttestationObject;
12 | use Webauthn\AuthenticatorAttestationResponse;
13 | use Webauthn\CollectedClientData;
14 | use Webauthn\Util\Base64;
15 | 
16 | final class AuthenticatorAttestationResponseDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
17 | {
18 |     use DenormalizerAwareTrait;
19 | 
20 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
21 |     {
22 |         $data['clientDataJSON'] = Base64UrlSafe::decodeNoPadding($data['clientDataJSON']);
23 |         $data['attestationObject'] = Base64::decode($data['attestationObject']);
24 | 
25 |         $clientDataJSON = $this->denormalizer->denormalize(
26 |             $data['clientDataJSON'],
27 |             CollectedClientData::class,
28 |             $format,
29 |             $context
30 |         );
31 |         $attestationObject = $this->denormalizer->denormalize(
32 |             $data['attestationObject'],
33 |             AttestationObject::class,
34 |             $format,
35 |             $context
36 |         );
37 | 
38 |         return AuthenticatorAttestationResponse::create(
39 |             $clientDataJSON,
40 |             $attestationObject,
41 |             $data['transports'] ?? [],
42 |         );
43 |     }
44 | 
45 |     public function supportsDenormalization(
46 |         mixed $data,
47 |         string $type,
48 |         ?string $format = null,
49 |         array $context = []
50 |     ): bool {
51 |         return $type === AuthenticatorAttestationResponse::class;
52 |     }
53 | 
54 |     /**
55 |      * @return array<class-string, bool>
56 |      */
57 |     public function getSupportedTypes(?string $format): array
58 |     {
59 |         return [
60 |             AuthenticatorAttestationResponse::class => true,
61 |         ];
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/AuthenticatorResponseDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
 8 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
 9 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
10 | use Webauthn\AuthenticatorAssertionResponse;
11 | use Webauthn\AuthenticatorAttestationResponse;
12 | use Webauthn\AuthenticatorResponse;
13 | use Webauthn\Exception\InvalidDataException;
14 | use function array_key_exists;
15 | 
16 | final class AuthenticatorResponseDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
17 | {
18 |     use DenormalizerAwareTrait;
19 | 
20 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
21 |     {
22 |         $realType = match (true) {
23 |             array_key_exists('attestationObject', $data) => AuthenticatorAttestationResponse::class,
24 |             array_key_exists('signature', $data) => AuthenticatorAssertionResponse::class,
25 |             default => throw InvalidDataException::create($data, 'Unable to create the response object'),
26 |         };
27 | 
28 |         return $this->denormalizer->denormalize($data, $realType, $format, $context);
29 |     }
30 | 
31 |     public function supportsDenormalization(
32 |         mixed $data,
33 |         string $type,
34 |         ?string $format = null,
35 |         array $context = []
36 |     ): bool {
37 |         return $type === AuthenticatorResponse::class;
38 |     }
39 | 
40 |     /**
41 |      * @return array<class-string, bool>
42 |      */
43 |     public function getSupportedTypes(?string $format): array
44 |     {
45 |         return [
46 |             AuthenticatorResponse::class => true,
47 |         ];
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/CollectedClientDataDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
 8 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
 9 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
10 | use Webauthn\CollectedClientData;
11 | use const JSON_THROW_ON_ERROR;
12 | 
13 | final class CollectedClientDataDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
14 | {
15 |     use DenormalizerAwareTrait;
16 | 
17 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
18 |     {
19 |         return CollectedClientData::create($data, json_decode($data, true, flags: JSON_THROW_ON_ERROR));
20 |     }
21 | 
22 |     public function supportsDenormalization(
23 |         mixed $data,
24 |         string $type,
25 |         ?string $format = null,
26 |         array $context = []
27 |     ): bool {
28 |         return $type === CollectedClientData::class;
29 |     }
30 | 
31 |     /**
32 |      * @return array<class-string, bool>
33 |      */
34 |     public function getSupportedTypes(?string $format): array
35 |     {
36 |         return [
37 |             CollectedClientData::class => true,
38 |         ];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/ExtensionDescriptorDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 8 | use Webauthn\MetadataService\Statement\ExtensionDescriptor;
 9 | use function array_key_exists;
10 | 
11 | final class ExtensionDescriptorDenormalizer implements DenormalizerInterface
12 | {
13 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
14 |     {
15 |         if (array_key_exists('fail_if_unknown', $data)) {
16 |             $data['failIfUnknown'] = $data['fail_if_unknown'];
17 |             unset($data['fail_if_unknown']);
18 |         }
19 | 
20 |         return ExtensionDescriptor::create(...$data);
21 |     }
22 | 
23 |     public function supportsDenormalization(
24 |         mixed $data,
25 |         string $type,
26 |         ?string $format = null,
27 |         array $context = []
28 |     ): bool {
29 |         return $type === ExtensionDescriptor::class;
30 |     }
31 | 
32 |     /**
33 |      * @return array<class-string, bool>
34 |      */
35 |     public function getSupportedTypes(?string $format): array
36 |     {
37 |         return [
38 |             ExtensionDescriptor::class => true,
39 |         ];
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/PublicKeyCredentialDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use ParagonIE\ConstantTime\Base64UrlSafe;
 8 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
 9 | use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
10 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
11 | use Webauthn\AuthenticatorResponse;
12 | use Webauthn\Exception\InvalidDataException;
13 | use Webauthn\PublicKeyCredential;
14 | use Webauthn\Util\Base64;
15 | use function array_key_exists;
16 | 
17 | final class PublicKeyCredentialDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
18 | {
19 |     use DenormalizerAwareTrait;
20 | 
21 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
22 |     {
23 |         if (! array_key_exists('id', $data)) {
24 |             return $data;
25 |         }
26 |         $id = Base64UrlSafe::decodeNoPadding($data['id']);
27 |         $rawId = Base64::decode($data['rawId']);
28 |         hash_equals($id, $rawId) || throw InvalidDataException::create($data, 'Invalid ID');
29 |         $data['rawId'] = $rawId;
30 | 
31 |         return PublicKeyCredential::create(
32 |             $data['type'],
33 |             $data['rawId'],
34 |             $this->denormalizer->denormalize($data['response'], AuthenticatorResponse::class, $format, $context),
35 |         );
36 |     }
37 | 
38 |     public function supportsDenormalization(
39 |         mixed $data,
40 |         string $type,
41 |         ?string $format = null,
42 |         array $context = []
43 |     ): bool {
44 |         return $type === PublicKeyCredential::class;
45 |     }
46 | 
47 |     /**
48 |      * @return array<class-string, bool>
49 |      */
50 |     public function getSupportedTypes(?string $format): array
51 |     {
52 |         return [
53 |             PublicKeyCredential::class => true,
54 |         ];
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/PublicKeyCredentialDescriptorNormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use ParagonIE\ConstantTime\Base64UrlSafe;
 8 | use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
 9 | use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
10 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
11 | use Webauthn\PublicKeyCredentialDescriptor;
12 | use function assert;
13 | use function count;
14 | 
15 | final class PublicKeyCredentialDescriptorNormalizer implements NormalizerInterface, NormalizerAwareInterface
16 | {
17 |     use NormalizerAwareTrait;
18 | 
19 |     /**
20 |      * @return array<string, mixed>
21 |      */
22 |     public function normalize(mixed $data, ?string $format = null, array $context = []): array
23 |     {
24 |         assert($data instanceof PublicKeyCredentialDescriptor);
25 |         $result = [
26 |             'type' => $data->type,
27 |             'id' => Base64UrlSafe::encodeUnpadded($data->id),
28 |         ];
29 |         if (count($data->transports) !== 0) {
30 |             $result['transports'] = $data->transports;
31 |         }
32 | 
33 |         return $result;
34 |     }
35 | 
36 |     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
37 |     {
38 |         return $data instanceof PublicKeyCredentialDescriptor;
39 |     }
40 | 
41 |     public function getSupportedTypes(?string $format): array
42 |     {
43 |         return [
44 |             PublicKeyCredentialDescriptor::class => true,
45 |         ];
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/PublicKeyCredentialParametersDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 8 | use Webauthn\Exception\InvalidDataException;
 9 | use Webauthn\PublicKeyCredentialParameters;
10 | use function array_key_exists;
11 | 
12 | final class PublicKeyCredentialParametersDenormalizer implements DenormalizerInterface
13 | {
14 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
15 |     {
16 |         if (! array_key_exists('type', $data) || ! array_key_exists('alg', $data)) {
17 |             throw new InvalidDataException($data, 'Missing type or alg');
18 |         }
19 | 
20 |         return PublicKeyCredentialParameters::create($data['type'], $data['alg']);
21 |     }
22 | 
23 |     public function supportsDenormalization(
24 |         mixed $data,
25 |         string $type,
26 |         ?string $format = null,
27 |         array $context = []
28 |     ): bool {
29 |         return $type === PublicKeyCredentialParameters::class;
30 |     }
31 | 
32 |     /**
33 |      * @return array<class-string, bool>
34 |      */
35 |     public function getSupportedTypes(?string $format): array
36 |     {
37 |         return [
38 |             PublicKeyCredentialParameters::class => true,
39 |         ];
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/PublicKeyCredentialUserEntityDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use ParagonIE\ConstantTime\Base64UrlSafe;
 8 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 9 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
10 | use Webauthn\PublicKeyCredentialUserEntity;
11 | use Webauthn\Util\Base64;
12 | use function array_key_exists;
13 | use function assert;
14 | 
15 | final class PublicKeyCredentialUserEntityDenormalizer implements DenormalizerInterface, NormalizerInterface
16 | {
17 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
18 |     {
19 |         if (! array_key_exists('id', $data)) {
20 |             return $data;
21 |         }
22 |         $data['id'] = Base64::decode($data['id']);
23 | 
24 |         return PublicKeyCredentialUserEntity::create($data['name'], $data['id'], $data['displayName']);
25 |     }
26 | 
27 |     public function supportsDenormalization(
28 |         mixed $data,
29 |         string $type,
30 |         ?string $format = null,
31 |         array $context = []
32 |     ): bool {
33 |         return $type === PublicKeyCredentialUserEntity::class;
34 |     }
35 | 
36 |     /**
37 |      * @return array<class-string, bool>
38 |      */
39 |     public function getSupportedTypes(?string $format): array
40 |     {
41 |         return [
42 |             PublicKeyCredentialUserEntity::class => true,
43 |         ];
44 |     }
45 | 
46 |     /**
47 |      * @return array<string, mixed>
48 |      */
49 |     public function normalize(mixed $object, ?string $format = null, array $context = []): array
50 |     {
51 |         assert($object instanceof PublicKeyCredentialUserEntity);
52 |         return [
53 |             'id' => Base64UrlSafe::encodeUnpadded($object->id),
54 |             'name' => $object->name,
55 |             'displayName' => $object->displayName,
56 |         ];
57 |     }
58 | 
59 |     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
60 |     {
61 |         return $data instanceof PublicKeyCredentialUserEntity;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/TrustPathDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 8 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 9 | use Webauthn\Exception\InvalidTrustPathException;
10 | use Webauthn\TrustPath\CertificateTrustPath;
11 | use Webauthn\TrustPath\EmptyTrustPath;
12 | use Webauthn\TrustPath\TrustPath;
13 | use function array_key_exists;
14 | use function assert;
15 | use function is_array;
16 | 
17 | final class TrustPathDenormalizer implements DenormalizerInterface, NormalizerInterface
18 | {
19 |     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
20 |     {
21 |         return match (true) {
22 |             array_key_exists('x5c', $data) && is_array($data['x5c']) => CertificateTrustPath::create($data['x5c']),
23 |             $data === [], isset($data['type']) && $data['type'] === EmptyTrustPath::class => EmptyTrustPath::create(),
24 |             default => throw new InvalidTrustPathException('Unsupported trust path type'),
25 |         };
26 |     }
27 | 
28 |     public function supportsDenormalization(
29 |         mixed $data,
30 |         string $type,
31 |         ?string $format = null,
32 |         array $context = []
33 |     ): bool {
34 |         return $type === TrustPath::class;
35 |     }
36 | 
37 |     /**
38 |      * @return array<class-string, bool>
39 |      */
40 |     public function getSupportedTypes(?string $format): array
41 |     {
42 |         return [
43 |             TrustPath::class => true,
44 |         ];
45 |     }
46 | 
47 |     /**
48 |      * @return array<string, mixed>
49 |      */
50 |     public function normalize(mixed $data, ?string $format = null, array $context = []): array
51 |     {
52 |         assert($data instanceof TrustPath);
53 |         return match (true) {
54 |             $data instanceof CertificateTrustPath => [
55 |                 'x5c' => $data->certificates,
56 |             ],
57 |             $data instanceof EmptyTrustPath => [],
58 |             default => throw new InvalidTrustPathException('Unsupported trust path type'),
59 |         };
60 |     }
61 | 
62 |     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
63 |     {
64 |         return $data instanceof TrustPath;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Denormalizer/VerificationMethodANDCombinationsDenormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Denormalizer;
 6 | 
 7 | use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
 8 | use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
 9 | use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
10 | use Webauthn\MetadataService\Statement\VerificationMethodANDCombinations;
11 | use Webauthn\MetadataService\Statement\VerificationMethodDescriptor;
12 | use function assert;
13 | 
14 | final class VerificationMethodANDCombinationsDenormalizer implements NormalizerInterface, NormalizerAwareInterface
15 | {
16 |     use NormalizerAwareTrait;
17 | 
18 |     /**
19 |      * @return array<class-string, bool>
20 |      */
21 |     public function getSupportedTypes(?string $format): array
22 |     {
23 |         return [
24 |             VerificationMethodANDCombinations::class => true,
25 |         ];
26 |     }
27 | 
28 |     /**
29 |      * @return array<VerificationMethodDescriptor>
30 |      */
31 |     public function normalize(mixed $data, ?string $format = null, array $context = []): array
32 |     {
33 |         assert($data instanceof VerificationMethodANDCombinations);
34 | 
35 |         return array_map(
36 |             fn ($verificationMethod) => $this->normalizer->normalize($verificationMethod, $format, $context),
37 |             $data->verificationMethods
38 |         );
39 |     }
40 | 
41 |     public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
42 |     {
43 |         return $data instanceof VerificationMethodANDCombinations;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/AttestationObjectLoaded.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Webauthn\AttestationStatement\AttestationObject;
 8 | 
 9 | class AttestationObjectLoaded implements WebauthnEvent
10 | {
11 |     public function __construct(
12 |         public readonly AttestationObject $attestationObject
13 |     ) {
14 |     }
15 | 
16 |     public static function create(AttestationObject $attestationObject): self
17 |     {
18 |         return new self($attestationObject);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/AttestationStatementLoaded.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Webauthn\AttestationStatement\AttestationStatement;
 8 | 
 9 | class AttestationStatementLoaded implements WebauthnEvent
10 | {
11 |     public function __construct(
12 |         public readonly AttestationStatement $attestationStatement
13 |     ) {
14 |     }
15 | 
16 |     public static function create(AttestationStatement $attestationStatement): self
17 |     {
18 |         return new self($attestationStatement);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/AuthenticatorAssertionResponseValidationFailedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Throwable;
 8 | use Webauthn\AuthenticatorAssertionResponse;
 9 | use Webauthn\PublicKeyCredentialRequestOptions;
10 | use Webauthn\PublicKeyCredentialSource;
11 | 
12 | readonly class AuthenticatorAssertionResponseValidationFailedEvent
13 | {
14 |     public function __construct(
15 |         public PublicKeyCredentialSource $credentialSource,
16 |         public AuthenticatorAssertionResponse $authenticatorAssertionResponse,
17 |         public PublicKeyCredentialRequestOptions $publicKeyCredentialRequestOptions,
18 |         public string $host,
19 |         public ?string $userHandle,
20 |         public Throwable $throwable
21 |     ) {
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/AuthenticatorAssertionResponseValidationSucceededEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Webauthn\AuthenticatorAssertionResponse;
 8 | use Webauthn\PublicKeyCredentialRequestOptions;
 9 | use Webauthn\PublicKeyCredentialSource;
10 | 
11 | class AuthenticatorAssertionResponseValidationSucceededEvent
12 | {
13 |     public function __construct(
14 |         public readonly AuthenticatorAssertionResponse $authenticatorAssertionResponse,
15 |         public readonly PublicKeyCredentialRequestOptions $publicKeyCredentialRequestOptions,
16 |         public readonly string $host,
17 |         public readonly ?string $userHandle,
18 |         public readonly PublicKeyCredentialSource $publicKeyCredentialSource
19 |     ) {
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/AuthenticatorAttestationResponseValidationFailedEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Throwable;
 8 | use Webauthn\AuthenticatorAttestationResponse;
 9 | use Webauthn\PublicKeyCredentialCreationOptions;
10 | 
11 | readonly class AuthenticatorAttestationResponseValidationFailedEvent
12 | {
13 |     public function __construct(
14 |         public AuthenticatorAttestationResponse $authenticatorAttestationResponse,
15 |         public PublicKeyCredentialCreationOptions $publicKeyCredentialCreationOptions,
16 |         public string $host,
17 |         public Throwable $throwable
18 |     ) {
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/AuthenticatorAttestationResponseValidationSucceededEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Webauthn\AuthenticatorAttestationResponse;
 8 | use Webauthn\PublicKeyCredentialCreationOptions;
 9 | use Webauthn\PublicKeyCredentialSource;
10 | 
11 | readonly class AuthenticatorAttestationResponseValidationSucceededEvent
12 | {
13 |     public function __construct(
14 |         public AuthenticatorAttestationResponse $authenticatorAttestationResponse,
15 |         public PublicKeyCredentialCreationOptions $publicKeyCredentialCreationOptions,
16 |         public string $host,
17 |         public PublicKeyCredentialSource $publicKeyCredentialSource
18 |     ) {
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/BeforeCertificateChainValidation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | final readonly class BeforeCertificateChainValidation implements WebauthnEvent
 8 | {
 9 |     /**
10 |      * @param string[] $untrustedCertificates
11 |      */
12 |     public function __construct(
13 |         public array $untrustedCertificates,
14 |         public string $trustedCertificate
15 |     ) {
16 |     }
17 | 
18 |     /**
19 |      * @param string[] $untrustedCertificates
20 |      */
21 |     public static function create(array $untrustedCertificates, string $trustedCertificate): self
22 |     {
23 |         return new self($untrustedCertificates, $trustedCertificate);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/CanDispatchEvents.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Psr\EventDispatcher\EventDispatcherInterface;
 8 | 
 9 | interface CanDispatchEvents
10 | {
11 |     public function setEventDispatcher(EventDispatcherInterface $eventDispatcher): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/CertificateChainValidationFailed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | final readonly class CertificateChainValidationFailed implements WebauthnEvent
 8 | {
 9 |     /**
10 |      * @param string[] $untrustedCertificates
11 |      */
12 |     public function __construct(
13 |         public array $untrustedCertificates,
14 |         public string $trustedCertificate
15 |     ) {
16 |     }
17 | 
18 |     /**
19 |      * @param string[] $untrustedCertificates
20 |      */
21 |     public static function create(array $untrustedCertificates, string $trustedCertificate): self
22 |     {
23 |         return new self($untrustedCertificates, $trustedCertificate);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/CertificateChainValidationSucceeded.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | final readonly class CertificateChainValidationSucceeded implements WebauthnEvent
 8 | {
 9 |     /**
10 |      * @param string[] $untrustedCertificates
11 |      */
12 |     public function __construct(
13 |         public array $untrustedCertificates,
14 |         public string $trustedCertificate
15 |     ) {
16 |     }
17 | 
18 |     /**
19 |      * @param string[] $untrustedCertificates
20 |      */
21 |     public static function create(array $untrustedCertificates, string $trustedCertificate): self
22 |     {
23 |         return new self($untrustedCertificates, $trustedCertificate);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/MetadataStatementFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Webauthn\MetadataService\Statement\MetadataStatement;
 8 | 
 9 | final readonly class MetadataStatementFound implements WebauthnEvent
10 | {
11 |     public function __construct(
12 |         public MetadataStatement $metadataStatement
13 |     ) {
14 |     }
15 | 
16 |     public static function create(MetadataStatement $metadataStatement): self
17 |     {
18 |         return new self($metadataStatement);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/NullEventDispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | use Psr\EventDispatcher\EventDispatcherInterface;
 8 | 
 9 | final class NullEventDispatcher implements EventDispatcherInterface
10 | {
11 |     public function dispatch(object $event): object
12 |     {
13 |         return $event;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Event/WebauthnEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Event;
 6 | 
 7 | interface WebauthnEvent
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/AttestationStatementException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | class AttestationStatementException extends WebauthnException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/AttestationStatementLoadingException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class AttestationStatementLoadingException extends AttestationStatementException
10 | {
11 |     /**
12 |      * @param array<string, mixed> $attestation
13 |      */
14 |     public function __construct(
15 |         public readonly array $attestation,
16 |         string $message,
17 |         ?Throwable $previous = null
18 |     ) {
19 |         parent::__construct($message, $previous);
20 |     }
21 | 
22 |     /**
23 |      * @param array<string, mixed> $attestation
24 |      */
25 |     public static function create(
26 |         array $attestation,
27 |         string $message = 'Invalid attestation object',
28 |         ?Throwable $previous = null
29 |     ): self {
30 |         return new self($attestation, $message, $previous);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/AttestationStatementVerificationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class AttestationStatementVerificationException extends AttestationStatementException
10 | {
11 |     public static function create(string $message = 'Invalid attestation object', ?Throwable $previous = null): self
12 |     {
13 |         return new self($message, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/AuthenticationExtensionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class AuthenticationExtensionException extends WebauthnException
10 | {
11 |     public static function create(string $message, ?Throwable $previous = null): self
12 |     {
13 |         return new self($message, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/AuthenticatorResponseVerificationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | class AuthenticatorResponseVerificationException extends WebauthnException
10 | {
11 |     public static function create(string $message, ?Throwable $previous = null): self
12 |     {
13 |         return new self($message, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/CertificateChainException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | class CertificateChainException extends MetadataServiceException
10 | {
11 |     /**
12 |      * @param array<string> $untrustedCertificates
13 |      * @param array<string> $trustedCertificates
14 |      */
15 |     public function __construct(
16 |         public readonly array $untrustedCertificates,
17 |         public readonly array $trustedCertificates,
18 |         string $message,
19 |         ?Throwable $previous = null
20 |     ) {
21 |         parent::__construct($message, $previous);
22 |     }
23 | 
24 |     /**
25 |      * @param array<string> $untrustedCertificates
26 |      * @param array<string> $trustedCertificates
27 |      */
28 |     public static function create(
29 |         array $untrustedCertificates,
30 |         array $trustedCertificates,
31 |         string $message = 'Unable to validate the certificate chain.',
32 |         ?Throwable $previous = null
33 |     ): self {
34 |         return new self($untrustedCertificates, $trustedCertificates, $message, $previous);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/CertificateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | class CertificateException extends MetadataServiceException
10 | {
11 |     public function __construct(
12 |         public readonly string $certificate,
13 |         string $message,
14 |         ?Throwable $previous = null
15 |     ) {
16 |         parent::__construct($message, $previous);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/CertificateRevocationListException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class CertificateRevocationListException extends MetadataServiceException
10 | {
11 |     public function __construct(
12 |         public readonly string $url,
13 |         string $message,
14 |         ?Throwable $previous = null
15 |     ) {
16 |         parent::__construct($message, $previous);
17 |     }
18 | 
19 |     public static function create(string $url, string $message = 'Invalid CRL.', ?Throwable $previous = null): self
20 |     {
21 |         return new self($url, $message, $previous);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/CounterException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class CounterException extends WebauthnException
10 | {
11 |     public function __construct(
12 |         public int $currentCounter,
13 |         public int $authenticatorCounter,
14 |         string $message,
15 |         ?Throwable $previous = null
16 |     ) {
17 |         parent::__construct($message, $previous);
18 |     }
19 | 
20 |     public static function create(
21 |         int $currentCounter,
22 |         int $authenticatorCounter,
23 |         string $message,
24 |         ?Throwable $previous = null
25 |     ): self {
26 |         return new self($currentCounter, $authenticatorCounter, $message, $previous);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/ExpiredCertificateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class ExpiredCertificateException extends CertificateException
10 | {
11 |     public static function create(
12 |         string $certificate,
13 |         string $message = 'Expired certificate',
14 |         ?Throwable $previous = null
15 |     ): self {
16 |         return new self($certificate, $message, $previous);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/InvalidAttestationStatementException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | use Webauthn\AttestationStatement\AttestationStatement;
 9 | 
10 | final class InvalidAttestationStatementException extends AttestationStatementException
11 | {
12 |     public function __construct(
13 |         public readonly AttestationStatement $attestationStatement,
14 |         string $message,
15 |         ?Throwable $previous = null
16 |     ) {
17 |         parent::__construct($message, $previous);
18 |     }
19 | 
20 |     public static function create(
21 |         AttestationStatement $attestationStatement,
22 |         string $message = 'Invalid attestation statement',
23 |         ?Throwable $previous = null
24 |     ): self {
25 |         return new self($attestationStatement, $message, $previous);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/InvalidCertificateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class InvalidCertificateException extends MetadataServiceException
10 | {
11 |     public function __construct(
12 |         public readonly string $certificate,
13 |         string $message,
14 |         ?Throwable $previous = null
15 |     ) {
16 |         parent::__construct($message, $previous);
17 |     }
18 | 
19 |     public static function create(string $certificate, string $message, ?Throwable $previous = null): self
20 |     {
21 |         return new self($certificate, $message, $previous);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/InvalidDataException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class InvalidDataException extends WebauthnException
10 | {
11 |     public function __construct(
12 |         public readonly mixed $data,
13 |         string $message,
14 |         ?Throwable $previous = null
15 |     ) {
16 |         parent::__construct($message, $previous);
17 |     }
18 | 
19 |     public static function create(mixed $data, string $message, ?Throwable $previous = null): self
20 |     {
21 |         return new self($data, $message, $previous);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/InvalidTrustPathException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class InvalidTrustPathException extends WebauthnException
10 | {
11 |     public static function create(string $message, ?Throwable $previous = null): self
12 |     {
13 |         return new self($message, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/InvalidUserHandleException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class InvalidUserHandleException extends AuthenticatorResponseVerificationException
10 | {
11 |     public static function create(string $message = 'Invalid user handle', ?Throwable $previous = null): self
12 |     {
13 |         return new self($message, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/MetadataServiceException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Exception;
 8 | use Throwable;
 9 | 
10 | class MetadataServiceException extends Exception
11 | {
12 |     public function __construct(string $message, ?Throwable $previous = null)
13 |     {
14 |         parent::__construct($message, 0, $previous);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/MetadataStatementException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | class MetadataStatementException extends MetadataServiceException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/MetadataStatementLoadingException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class MetadataStatementLoadingException extends MetadataStatementException
10 | {
11 |     public static function create(
12 |         string $message = 'Unable to load the metadata statement',
13 |         ?Throwable $previous = null
14 |     ): self {
15 |         return new self($message, $previous);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/MissingMetadataStatementException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class MissingMetadataStatementException extends MetadataStatementException
10 | {
11 |     public function __construct(
12 |         public readonly string $aaguid,
13 |         string $message,
14 |         ?Throwable $previous = null
15 |     ) {
16 |         parent::__construct($message, $previous);
17 |     }
18 | 
19 |     public static function create(
20 |         string $aaguid,
21 |         string $message = 'The Metadata Statement is missing',
22 |         ?Throwable $previous = null
23 |     ): self {
24 |         return new self($aaguid, $message, $previous);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/RevokedCertificateException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | final class RevokedCertificateException extends CertificateException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/UnsupportedFeatureException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Throwable;
 8 | 
 9 | final class UnsupportedFeatureException extends WebauthnException
10 | {
11 |     public static function create(string $message, ?Throwable $previous = null): self
12 |     {
13 |         return new self($message, $previous);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Exception/WebauthnException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Exception;
 6 | 
 7 | use Exception;
 8 | use Throwable;
 9 | 
10 | class WebauthnException extends Exception
11 | {
12 |     public function __construct(string $message, ?Throwable $previous = null)
13 |     {
14 |         parent::__construct($message, 0, $previous);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/webauthn/src/FakeCredentialGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use Symfony\Component\HttpFoundation\Request;
 8 | 
 9 | interface FakeCredentialGenerator
10 | {
11 |     /**
12 |      * @return PublicKeyCredentialDescriptor[]
13 |      */
14 |     public function generate(Request $request, string $username): array;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/CanLogData.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService;
 6 | 
 7 | use Psr\Log\LoggerInterface;
 8 | 
 9 | interface CanLogData
10 | {
11 |     public function setLogger(LoggerInterface $logger): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/CertificateChain/CertificateChainValidator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\CertificateChain;
 6 | 
 7 | interface CertificateChainValidator
 8 | {
 9 |     /**
10 |      * @param string[] $untrustedCertificates
11 |      * @param string[] $trustedCertificates
12 |      */
13 |     public function check(array $untrustedCertificates, array $trustedCertificates): void;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/CertificateChain/CertificateToolbox.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\CertificateChain;
 6 | 
 7 | use const PHP_EOL;
 8 | 
 9 | final readonly class CertificateToolbox
10 | {
11 |     private const PEM_HEADER = '-----BEGIN ';
12 | 
13 |     private const PEM_FOOTER = '-----END ';
14 | 
15 |     /**
16 |      * @param string[] $data
17 |      *
18 |      * @return string[]
19 |      */
20 |     public static function fixPEMStructures(array $data, string $type = 'CERTIFICATE'): array
21 |     {
22 |         return array_map(static fn ($d): string => self::fixPEMStructure($d, $type), $data);
23 |     }
24 | 
25 |     public static function fixPEMStructure(string $data, string $type = 'CERTIFICATE'): string
26 |     {
27 |         if (str_contains($data, self::PEM_HEADER)) {
28 |             return trim($data);
29 |         }
30 |         $pem = self::PEM_HEADER . $type . '-----' . PHP_EOL;
31 |         $pem .= chunk_split($data, 64, PHP_EOL);
32 | 
33 |         return $pem . (self::PEM_FOOTER . $type . '-----' . PHP_EOL);
34 |     }
35 | 
36 |     public static function convertDERToPEM(string $data, string $type = 'CERTIFICATE'): string
37 |     {
38 |         if (str_contains($data, self::PEM_HEADER)) {
39 |             return $data;
40 |         }
41 | 
42 |         return self::fixPEMStructure(base64_encode($data), $type);
43 |     }
44 | 
45 |     /**
46 |      * @param string[] $data
47 |      *
48 |      * @return string[]
49 |      */
50 |     public static function convertAllDERToPEM(array $data, string $type = 'CERTIFICATE'): array
51 |     {
52 |         return array_map(static fn ($d): string => self::convertDERToPEM($d, $type), $data);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/MetadataStatementRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService;
 6 | 
 7 | use Webauthn\MetadataService\Statement\MetadataStatement;
 8 | 
 9 | interface MetadataStatementRepository
10 | {
11 |     public function findOneByAAGUID(string $aaguid): ?MetadataStatement;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Service/ChainedMetadataServices.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Service;
 6 | 
 7 | use Webauthn\Exception\MissingMetadataStatementException;
 8 | use Webauthn\MetadataService\Statement\MetadataStatement;
 9 | 
10 | final class ChainedMetadataServices implements MetadataService
11 | {
12 |     /**
13 |      * @var MetadataService[]
14 |      */
15 |     private array $services = [];
16 | 
17 |     public function __construct(MetadataService ...$services)
18 |     {
19 |         foreach ($services as $service) {
20 |             $this->addServices($service);
21 |         }
22 |     }
23 | 
24 |     public static function create(MetadataService ...$services): self
25 |     {
26 |         return new self(...$services);
27 |     }
28 | 
29 |     public function addServices(MetadataService ...$services): self
30 |     {
31 |         foreach ($services as $service) {
32 |             $this->services[] = $service;
33 |         }
34 | 
35 |         return $this;
36 |     }
37 | 
38 |     public function list(): iterable
39 |     {
40 |         foreach ($this->services as $service) {
41 |             yield from $service->list();
42 |         }
43 |     }
44 | 
45 |     public function has(string $aaguid): bool
46 |     {
47 |         foreach ($this->services as $service) {
48 |             if ($service->has($aaguid)) {
49 |                 return true;
50 |             }
51 |         }
52 | 
53 |         return false;
54 |     }
55 | 
56 |     public function get(string $aaguid): MetadataStatement
57 |     {
58 |         foreach ($this->services as $service) {
59 |             if ($service->has($aaguid)) {
60 |                 return $service->get($aaguid);
61 |             }
62 |         }
63 | 
64 |         throw MissingMetadataStatementException::create($aaguid);
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Service/InMemoryMetadataService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Service;
 6 | 
 7 | use Psr\EventDispatcher\EventDispatcherInterface;
 8 | use Webauthn\Event\CanDispatchEvents;
 9 | use Webauthn\Event\MetadataStatementFound;
10 | use Webauthn\Event\NullEventDispatcher;
11 | use Webauthn\Exception\MissingMetadataStatementException;
12 | use Webauthn\MetadataService\Statement\MetadataStatement;
13 | use function array_key_exists;
14 | 
15 | final class InMemoryMetadataService implements MetadataService, CanDispatchEvents
16 | {
17 |     /**
18 |      * @var MetadataStatement[]
19 |      */
20 |     private array $statements = [];
21 | 
22 |     private EventDispatcherInterface $dispatcher;
23 | 
24 |     public function __construct(MetadataStatement ...$statements)
25 |     {
26 |         foreach ($statements as $statement) {
27 |             $this->addStatements($statement);
28 |         }
29 |         $this->dispatcher = new NullEventDispatcher();
30 |     }
31 | 
32 |     public function setEventDispatcher(EventDispatcherInterface $eventDispatcher): void
33 |     {
34 |         $this->dispatcher = $eventDispatcher;
35 |     }
36 | 
37 |     public static function create(MetadataStatement ...$statements): self
38 |     {
39 |         return new self(...$statements);
40 |     }
41 | 
42 |     public function addStatements(MetadataStatement ...$statements): self
43 |     {
44 |         foreach ($statements as $statement) {
45 |             $aaguid = $statement->aaguid;
46 |             if ($aaguid === null) {
47 |                 continue;
48 |             }
49 |             $this->statements[$aaguid] = $statement;
50 |         }
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     public function list(): iterable
56 |     {
57 |         yield from array_keys($this->statements);
58 |     }
59 | 
60 |     public function has(string $aaguid): bool
61 |     {
62 |         return array_key_exists($aaguid, $this->statements);
63 |     }
64 | 
65 |     public function get(string $aaguid): MetadataStatement
66 |     {
67 |         array_key_exists($aaguid, $this->statements) || throw MissingMetadataStatementException::create($aaguid);
68 |         $mds = $this->statements[$aaguid];
69 |         $this->dispatcher->dispatch(MetadataStatementFound::create($mds));
70 | 
71 |         return $mds;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Service/MetadataBLOBPayload.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Service;
 6 | 
 7 | class MetadataBLOBPayload
 8 | {
 9 |     /**
10 |      * @param MetadataBLOBPayloadEntry[] $entries
11 |      */
12 |     public function __construct(
13 |         public readonly int $no,
14 |         public readonly string $nextUpdate,
15 |         public readonly ?string $legalHeader = null,
16 |         public array $entries = [],
17 |     ) {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Service/MetadataService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Service;
 6 | 
 7 | use Webauthn\MetadataService\Statement\MetadataStatement;
 8 | 
 9 | interface MetadataService
10 | {
11 |     /**
12 |      * @return string[] The list of AAGUID supported by the service
13 |      */
14 |     public function list(): iterable;
15 | 
16 |     public function has(string $aaguid): bool;
17 | 
18 |     public function get(string $aaguid): MetadataStatement;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/AbstractDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | 
 9 | abstract class AbstractDescriptor
10 | {
11 |     public function __construct(
12 |         public readonly ?int $maxRetries = null,
13 |         public readonly ?int $blockSlowdown = null
14 |     ) {
15 |         $maxRetries >= 0 || throw MetadataStatementLoadingException::create(
16 |             'Invalid data. The value of "maxRetries" must be a positive integer'
17 |         );
18 |         $blockSlowdown >= 0 || throw MetadataStatementLoadingException::create(
19 |             'Invalid data. The value of "blockSlowdown" must be a positive integer'
20 |         );
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/AlternativeDescriptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | class AlternativeDescriptions
 8 | {
 9 |     /**
10 |      * @param array<string, string> $descriptions
11 |      */
12 |     public function __construct(
13 |         public array $descriptions = []
14 |     ) {
15 |     }
16 | 
17 |     /**
18 |      * @param array<string, string> $descriptions
19 |      */
20 |     public static function create(array $descriptions = []): self
21 |     {
22 |         return new self($descriptions);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/AuthenticatorGetInfo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | class AuthenticatorGetInfo
 8 | {
 9 |     /**
10 |      * @param array<array-key, mixed> $info
11 |      */
12 |     public function __construct(
13 |         public array $info = []
14 |     ) {
15 |     }
16 | 
17 |     /**
18 |      * @param array<array-key, mixed> $info
19 |      */
20 |     public static function create(array $info = []): self
21 |     {
22 |         return new self($info);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/AuthenticatorStatus.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | final class AuthenticatorStatus
 8 | {
 9 |     final public const NOT_FIDO_CERTIFIED = 'NOT_FIDO_CERTIFIED';
10 | 
11 |     final public const FIDO_CERTIFIED = 'FIDO_CERTIFIED';
12 | 
13 |     final public const USER_VERIFICATION_BYPASS = 'USER_VERIFICATION_BYPASS';
14 | 
15 |     final public const ATTESTATION_KEY_COMPROMISE = 'ATTESTATION_KEY_COMPROMISE';
16 | 
17 |     final public const USER_KEY_REMOTE_COMPROMISE = 'USER_KEY_REMOTE_COMPROMISE';
18 | 
19 |     final public const USER_KEY_PHYSICAL_COMPROMISE = 'USER_KEY_PHYSICAL_COMPROMISE';
20 | 
21 |     final public const UPDATE_AVAILABLE = 'UPDATE_AVAILABLE';
22 | 
23 |     final public const REVOKED = 'REVOKED';
24 | 
25 |     final public const SELF_ASSERTION_SUBMITTED = 'SELF_ASSERTION_SUBMITTED';
26 | 
27 |     final public const FIDO_CERTIFIED_L1 = 'FIDO_CERTIFIED_L1';
28 | 
29 |     final public const FIDO_CERTIFIED_L1plus = 'FIDO_CERTIFIED_L1plus';
30 | 
31 |     final public const FIDO_CERTIFIED_L2 = 'FIDO_CERTIFIED_L2';
32 | 
33 |     final public const FIDO_CERTIFIED_L2plus = 'FIDO_CERTIFIED_L2plus';
34 | 
35 |     final public const FIDO_CERTIFIED_L3 = 'FIDO_CERTIFIED_L3';
36 | 
37 |     final public const FIDO_CERTIFIED_L3plus = 'FIDO_CERTIFIED_L3plus';
38 | 
39 |     final public const FIDO_CERTIFIED_L4 = 'FIDO_CERTIFIED_L4';
40 | 
41 |     final public const FIDO_CERTIFIED_L5 = 'FIDO_CERTIFIED_L5';
42 | 
43 |     final public const STATUSES = [
44 |         self::NOT_FIDO_CERTIFIED,
45 |         self::FIDO_CERTIFIED,
46 |         self::USER_VERIFICATION_BYPASS,
47 |         self::ATTESTATION_KEY_COMPROMISE,
48 |         self::USER_KEY_REMOTE_COMPROMISE,
49 |         self::USER_KEY_PHYSICAL_COMPROMISE,
50 |         self::UPDATE_AVAILABLE,
51 |         self::REVOKED,
52 |         self::SELF_ASSERTION_SUBMITTED,
53 |         self::FIDO_CERTIFIED_L1,
54 |         self::FIDO_CERTIFIED_L1plus,
55 |         self::FIDO_CERTIFIED_L2,
56 |         self::FIDO_CERTIFIED_L2plus,
57 |         self::FIDO_CERTIFIED_L3,
58 |         self::FIDO_CERTIFIED_L3plus,
59 |         self::FIDO_CERTIFIED_L4,
60 |         self::FIDO_CERTIFIED_L5,
61 |     ];
62 | }
63 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/BiometricAccuracyDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | class BiometricAccuracyDescriptor extends AbstractDescriptor
 8 | {
 9 |     public function __construct(
10 |         public readonly ?float $selfAttestedFRR,
11 |         public readonly ?float $selfAttestedFAR,
12 |         public readonly ?float $maxTemplates,
13 |         ?int $maxRetries = null,
14 |         ?int $blockSlowdown = null
15 |     ) {
16 |         parent::__construct($maxRetries, $blockSlowdown);
17 |     }
18 | 
19 |     public static function create(
20 |         ?float $selfAttestedFRR,
21 |         ?float $selfAttestedFAR,
22 |         ?float $maxTemplates,
23 |         ?int $maxRetries = null,
24 |         ?int $blockSlowdown = null
25 |     ): self {
26 |         return new self($selfAttestedFRR, $selfAttestedFAR, $maxTemplates, $maxRetries, $blockSlowdown);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/BiometricStatusReport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | readonly class BiometricStatusReport
 8 | {
 9 |     private function __construct(
10 |         public ?int $certLevel,
11 |         public ?int $modality,
12 |         public ?string $effectiveDate,
13 |         public ?string $certificationDescriptor,
14 |         public ?string $certificateNumber,
15 |         public ?string $certificationPolicyVersion,
16 |         public ?string $certificationRequirementsVersion,
17 |     ) {
18 |     }
19 | 
20 |     public static function create(
21 |         ?int $certLevel,
22 |         ?int $modality,
23 |         ?string $effectiveDate,
24 |         ?string $certificationDescriptor,
25 |         ?string $certificateNumber,
26 |         ?string $certificationPolicyVersion,
27 |         ?string $certificationRequirementsVersion,
28 |     ): self {
29 |         return new self(
30 |             $certLevel,
31 |             $modality,
32 |             $effectiveDate,
33 |             $certificationDescriptor,
34 |             $certificateNumber,
35 |             $certificationPolicyVersion,
36 |             $certificationRequirementsVersion,
37 |         );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/CodeAccuracyDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | 
 9 | class CodeAccuracyDescriptor extends AbstractDescriptor
10 | {
11 |     public function __construct(
12 |         public readonly int $base,
13 |         public readonly int $minLength,
14 |         ?int $maxRetries = null,
15 |         ?int $blockSlowdown = null
16 |     ) {
17 |         $base >= 0 || throw MetadataStatementLoadingException::create(
18 |             'Invalid data. The value of "base" must be a positive integer'
19 |         );
20 |         $minLength >= 0 || throw MetadataStatementLoadingException::create(
21 |             'Invalid data. The value of "minLength" must be a positive integer'
22 |         );
23 |         parent::__construct($maxRetries, $blockSlowdown);
24 |     }
25 | 
26 |     public static function create(int $base, int $minLength, ?int $maxRetries = null, ?int $blockSlowdown = null): self
27 |     {
28 |         return new self($base, $minLength, $maxRetries, $blockSlowdown);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/DisplayPNGCharacteristicsDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | 
 9 | class DisplayPNGCharacteristicsDescriptor
10 | {
11 |     /**
12 |      * @param RgbPaletteEntry[] $plte
13 |      */
14 |     public function __construct(
15 |         public readonly int $width,
16 |         public readonly int $height,
17 |         public readonly int $bitDepth,
18 |         public readonly int $colorType,
19 |         public readonly int $compression,
20 |         public readonly int $filter,
21 |         public readonly int $interlace,
22 |         /** @readonly */
23 |         public array $plte = [],
24 |     ) {
25 |         $width >= 0 || throw MetadataStatementLoadingException::create('Invalid width');
26 |         $height >= 0 || throw MetadataStatementLoadingException::create('Invalid height');
27 |         ($bitDepth >= 0 && $bitDepth <= 254) || throw MetadataStatementLoadingException::create('Invalid bit depth');
28 |         ($colorType >= 0 && $colorType <= 254) || throw MetadataStatementLoadingException::create(
29 |             'Invalid color type'
30 |         );
31 |         ($compression >= 0 && $compression <= 254) || throw MetadataStatementLoadingException::create(
32 |             'Invalid compression'
33 |         );
34 |         ($filter >= 0 && $filter <= 254) || throw MetadataStatementLoadingException::create('Invalid filter');
35 |         ($interlace >= 0 && $interlace <= 254) || throw MetadataStatementLoadingException::create(
36 |             'Invalid interlace'
37 |         );
38 |     }
39 | 
40 |     /**
41 |      * @param RgbPaletteEntry[] $plte
42 |      */
43 |     public static function create(
44 |         int $width,
45 |         int $height,
46 |         int $bitDepth,
47 |         int $colorType,
48 |         int $compression,
49 |         int $filter,
50 |         int $interlace,
51 |         array $plte = []
52 |     ): self {
53 |         return new self($width, $height, $bitDepth, $colorType, $compression, $filter, $interlace, $plte);
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/ExtensionDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Symfony\Component\Serializer\Attribute\SerializedName;
 8 | use Webauthn\Exception\MetadataStatementLoadingException;
 9 | 
10 | readonly class ExtensionDescriptor
11 | {
12 |     public function __construct(
13 |         public string $id,
14 |         public ?int $tag,
15 |         public ?string $data,
16 |         #[SerializedName('fail_if_unknown')]
17 |         public bool $failIfUnknown
18 |     ) {
19 |         if ($tag !== null) {
20 |             $tag >= 0 || throw MetadataStatementLoadingException::create(
21 |                 'Invalid data. The parameter "tag" shall be a positive integer'
22 |             );
23 |         }
24 |     }
25 | 
26 |     public static function create(
27 |         string $id,
28 |         ?int $tag = null,
29 |         ?string $data = null,
30 |         bool $failIfUnknown = false
31 |     ): self {
32 |         return new self($id, $tag, $data, $failIfUnknown);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/PatternAccuracyDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | 
 9 | class PatternAccuracyDescriptor extends AbstractDescriptor
10 | {
11 |     public function __construct(
12 |         public readonly int $minComplexity,
13 |         ?int $maxRetries = null,
14 |         ?int $blockSlowdown = null
15 |     ) {
16 |         $minComplexity >= 0 || throw MetadataStatementLoadingException::create(
17 |             'Invalid data. The value of "minComplexity" must be a positive integer'
18 |         );
19 |         parent::__construct($maxRetries, $blockSlowdown);
20 |     }
21 | 
22 |     public static function create(int $minComplexity, ?int $maxRetries = null, ?int $blockSlowdown = null): self
23 |     {
24 |         return new self($minComplexity, $maxRetries, $blockSlowdown);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/RgbPaletteEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | 
 9 | readonly class RgbPaletteEntry
10 | {
11 |     public function __construct(
12 |         public int $r,
13 |         public int $g,
14 |         public int $b,
15 |     ) {
16 |         ($r >= 0 && $r <= 255) || throw MetadataStatementLoadingException::create('The key "r" is invalid');
17 |         ($g >= 0 && $g <= 255) || throw MetadataStatementLoadingException::create('The key "g" is invalid');
18 |         ($b >= 0 && $b <= 255) || throw MetadataStatementLoadingException::create('The key "b" is invalid');
19 |     }
20 | 
21 |     public static function create(int $r, int $g, int $b): self
22 |     {
23 |         return new self($r, $g, $b);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/RogueListEntry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | readonly class RogueListEntry
 8 | {
 9 |     public function __construct(
10 |         public string $sk,
11 |         public string $date
12 |     ) {
13 |     }
14 | 
15 |     public static function create(string $sk, string $date): self
16 |     {
17 |         return new self($sk, $date);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/StatusReport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | use function in_array;
 9 | 
10 | readonly class StatusReport
11 | {
12 |     /**
13 |      * @see AuthenticatorStatus
14 |      */
15 |     public function __construct(
16 |         public string $status,
17 |         public ?string $effectiveDate,
18 |         public ?string $certificate,
19 |         public ?string $url,
20 |         public ?string $certificationDescriptor,
21 |         public ?string $certificateNumber,
22 |         public ?string $certificationPolicyVersion,
23 |         public ?string $certificationRequirementsVersion
24 |     ) {
25 |         in_array($status, AuthenticatorStatus::STATUSES, true) || throw MetadataStatementLoadingException::create(
26 |             'The value of the key "status" is not acceptable'
27 |         );
28 |     }
29 | 
30 |     public static function create(
31 |         string $status,
32 |         ?string $effectiveDate,
33 |         ?string $certificate,
34 |         ?string $url,
35 |         ?string $certificationDescriptor,
36 |         ?string $certificateNumber,
37 |         ?string $certificationPolicyVersion,
38 |         ?string $certificationRequirementsVersion
39 |     ): self {
40 |         return new self(
41 |             $status,
42 |             $effectiveDate,
43 |             $certificate,
44 |             $url,
45 |             $certificationDescriptor,
46 |             $certificateNumber,
47 |             $certificationPolicyVersion,
48 |             $certificationRequirementsVersion
49 |         );
50 |     }
51 | 
52 |     public function isCompromised(): bool
53 |     {
54 |         return in_array($this->status, [
55 |             AuthenticatorStatus::ATTESTATION_KEY_COMPROMISE,
56 |             AuthenticatorStatus::USER_KEY_PHYSICAL_COMPROMISE,
57 |             AuthenticatorStatus::USER_KEY_REMOTE_COMPROMISE,
58 |             AuthenticatorStatus::USER_VERIFICATION_BYPASS,
59 |         ], true);
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/VerificationMethodANDCombinations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | class VerificationMethodANDCombinations
 8 | {
 9 |     /**
10 |      * @param VerificationMethodDescriptor[] $verificationMethods
11 |      */
12 |     public function __construct(
13 |         /** @readonly */
14 |         public array $verificationMethods = []
15 |     ) {
16 |     }
17 | 
18 |     /**
19 |      * @param VerificationMethodDescriptor[] $verificationMethods
20 |      */
21 |     public static function create(array $verificationMethods): self
22 |     {
23 |         return new self($verificationMethods);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/Statement/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService\Statement;
 6 | 
 7 | use Webauthn\Exception\MetadataStatementLoadingException;
 8 | 
 9 | readonly class Version
10 | {
11 |     public function __construct(
12 |         public ?int $major,
13 |         public ?int $minor
14 |     ) {
15 |         if ($major === null && $minor === null) {
16 |             throw MetadataStatementLoadingException::create('Invalid data. Must contain at least one item');
17 |         }
18 |         $major >= 0 || throw MetadataStatementLoadingException::create('Invalid argument "major"');
19 |         $minor >= 0 || throw MetadataStatementLoadingException::create('Invalid argument "minor"');
20 |     }
21 | 
22 |     public static function create(?int $major, ?int $minor): self
23 |     {
24 |         return new self($major, $minor);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/webauthn/src/MetadataService/StatusReportRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\MetadataService;
 6 | 
 7 | use Webauthn\MetadataService\Statement\StatusReport;
 8 | 
 9 | interface StatusReportRepository
10 | {
11 |     /**
12 |      * @return StatusReport[]
13 |      */
14 |     public function findStatusReportsByAAGUID(string $aaguid): array;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredential.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | /**
 8 |  * @see https://www.w3.org/TR/webauthn/#iface-pkcredential
 9 |  */
10 | class PublicKeyCredential extends Credential
11 | {
12 |     public function __construct(
13 |         string $type,
14 |         string $rawId,
15 |         public readonly AuthenticatorResponse $response
16 |     ) {
17 |         parent::__construct($type, $rawId);
18 |     }
19 | 
20 |     public static function create(string $type, string $rawId, AuthenticatorResponse $response): self
21 |     {
22 |         return new self($type, $rawId, $response);
23 |     }
24 | 
25 |     public function getPublicKeyCredentialDescriptor(): PublicKeyCredentialDescriptor
26 |     {
27 |         $transport = $this->response instanceof AuthenticatorAttestationResponse ? $this->response->transports : [];
28 | 
29 |         return PublicKeyCredentialDescriptor::create($this->type, $this->rawId, $transport);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredentialDescriptor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | class PublicKeyCredentialDescriptor
 8 | {
 9 |     final public const CREDENTIAL_TYPE_PUBLIC_KEY = 'public-key';
10 | 
11 |     final public const AUTHENTICATOR_TRANSPORT_USB = 'usb';
12 | 
13 |     final public const AUTHENTICATOR_TRANSPORT_NFC = 'nfc';
14 | 
15 |     final public const AUTHENTICATOR_TRANSPORT_BLE = 'ble';
16 | 
17 |     final public const AUTHENTICATOR_TRANSPORT_CABLE = 'cable';
18 | 
19 |     final public const AUTHENTICATOR_TRANSPORT_INTERNAL = 'internal';
20 | 
21 |     final public const AUTHENTICATOR_TRANSPORTS = [
22 |         self::AUTHENTICATOR_TRANSPORT_USB,
23 |         self::AUTHENTICATOR_TRANSPORT_NFC,
24 |         self::AUTHENTICATOR_TRANSPORT_BLE,
25 |         self::AUTHENTICATOR_TRANSPORT_CABLE,
26 |         self::AUTHENTICATOR_TRANSPORT_INTERNAL,
27 |     ];
28 | 
29 |     /**
30 |      * @param string[] $transports
31 |      */
32 |     public function __construct(
33 |         public readonly string $type,
34 |         public readonly string $id,
35 |         public readonly array $transports = []
36 |     ) {
37 |     }
38 | 
39 |     /**
40 |      * @param string[] $transports
41 |      */
42 |     public static function create(string $type, string $id, array $transports = []): self
43 |     {
44 |         return new self($type, $id, $transports);
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredentialEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | abstract class PublicKeyCredentialEntity
 8 | {
 9 |     /**
10 |      * @deprecated since 5.1.0 and will be removed in 6.0.0. This value is always null.
11 |      */
12 |     public ?string $icon = null;
13 | 
14 |     public function __construct(
15 |         public readonly string $name,
16 |         ?string $icon = null
17 |     ) {
18 |         if ($icon !== null) {
19 |             trigger_deprecation(
20 |                 'web-auth/webauthn-lib',
21 |                 '5.1.0',
22 |                 'The parameter "$icon" is deprecated since 5.1.0 and will be removed in 6.0.0. This value has no effect. Please set "null" instead.'
23 |             );
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredentialOptions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use InvalidArgumentException;
 8 | use Webauthn\AuthenticationExtensions\AuthenticationExtensions;
 9 | 
10 | abstract class PublicKeyCredentialOptions
11 | {
12 |     public AuthenticationExtensions $extensions;
13 | 
14 |     /**
15 |      * @param positive-int|null $timeout
16 |      * @param null|AuthenticationExtensions|array<array-key, AuthenticationExtensions> $extensions
17 |      * @protected
18 |      */
19 |     public function __construct(
20 |         public string $challenge,
21 |         public null|int $timeout = null,
22 |         null|array|AuthenticationExtensions $extensions = null,
23 |     ) {
24 |         ($this->timeout === null || $this->timeout > 0) || throw new InvalidArgumentException('Invalid timeout');
25 |         if ($extensions === null) {
26 |             $this->extensions = AuthenticationExtensions::create();
27 |         } elseif ($extensions instanceof AuthenticationExtensions) {
28 |             $this->extensions = $extensions;
29 |         } else {
30 |             $this->extensions = AuthenticationExtensions::create($extensions);
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredentialParameters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | readonly class PublicKeyCredentialParameters
 8 | {
 9 |     public function __construct(
10 |         public string $type,
11 |         public int $alg
12 |     ) {
13 |     }
14 | 
15 |     public static function create(string $type, int $alg): self
16 |     {
17 |         return new self($type, $alg);
18 |     }
19 | 
20 |     public static function createPk(int $alg): self
21 |     {
22 |         return self::create(PublicKeyCredentialDescriptor::CREDENTIAL_TYPE_PUBLIC_KEY, $alg);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredentialRpEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | class PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity
 8 | {
 9 |     public function __construct(
10 |         string $name,
11 |         public readonly ?string $id = null,
12 |         ?string $icon = null
13 |     ) {
14 |         parent::__construct($name, $icon);
15 |     }
16 | 
17 |     public static function create(string $name, ?string $id = null, ?string $icon = null): self
18 |     {
19 |         return new self($name, $id, $icon);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/webauthn/src/PublicKeyCredentialUserEntity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use Webauthn\Exception\InvalidDataException;
 8 | use function strlen;
 9 | 
10 | class PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity
11 | {
12 |     public readonly string $id;
13 | 
14 |     public function __construct(
15 |         string $name,
16 |         string $id,
17 |         public readonly string $displayName,
18 |         ?string $icon = null
19 |     ) {
20 |         parent::__construct($name, $icon);
21 |         strlen($id) <= 64 || throw InvalidDataException::create($id, 'User ID max length is 64 bytes');
22 |         $this->id = $id;
23 |     }
24 | 
25 |     public static function create(string $name, string $id, string $displayName, ?string $icon = null): self
26 |     {
27 |         return new self($name, $id, $displayName, $icon);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/webauthn/src/SimpleFakeCredentialGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use Psr\Cache\CacheItemPoolInterface;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use function count;
10 | use function is_int;
11 | 
12 | final readonly class SimpleFakeCredentialGenerator implements FakeCredentialGenerator
13 | {
14 |     public function __construct(
15 |         private null|CacheItemPoolInterface $cache = null
16 |     ) {
17 |     }
18 | 
19 |     /**
20 |      * @return PublicKeyCredentialDescriptor[]
21 |      */
22 |     public function generate(Request $request, string $username): array
23 |     {
24 |         if ($this->cache === null) {
25 |             return $this->generateCredentials($username);
26 |         }
27 | 
28 |         $cacheKey = 'fake_credentials_' . hash('xxh128', $username);
29 |         $cacheItem = $this->cache->getItem($cacheKey);
30 |         if ($cacheItem->isHit()) {
31 |             return $cacheItem->get();
32 |         }
33 | 
34 |         $credentials = $this->generateCredentials($username);
35 |         $cacheItem->set($credentials);
36 |         $this->cache->save($cacheItem);
37 | 
38 |         return $credentials;
39 |     }
40 | 
41 |     /**
42 |      * @return PublicKeyCredentialDescriptor[]
43 |      */
44 |     private function generateCredentials(string $username): array
45 |     {
46 |         $transports = [
47 |             PublicKeyCredentialDescriptor::AUTHENTICATOR_TRANSPORT_USB,
48 |             PublicKeyCredentialDescriptor::AUTHENTICATOR_TRANSPORT_NFC,
49 |             PublicKeyCredentialDescriptor::AUTHENTICATOR_TRANSPORT_BLE,
50 |         ];
51 |         $credentials = [];
52 |         for ($i = 0; $i < random_int(1, 3); $i++) {
53 |             $randomTransportKeys = array_rand($transports, random_int(1, count($transports)));
54 |             if (is_int($randomTransportKeys)) {
55 |                 $randomTransportKeys = [$randomTransportKeys];
56 |             }
57 |             $randomTransports = array_values(array_intersect_key($transports, array_flip($randomTransportKeys)));
58 |             $credentials[] = PublicKeyCredentialDescriptor::create(
59 |                 PublicKeyCredentialDescriptor::CREDENTIAL_TYPE_PUBLIC_KEY,
60 |                 hash('sha256', random_bytes(16) . $username),
61 |                 $randomTransports
62 |             );
63 |         }
64 | 
65 |         return $credentials;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/webauthn/src/StringStream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use CBOR\Stream;
 8 | use Webauthn\Exception\InvalidDataException;
 9 | use function assert;
10 | use function fclose;
11 | use function fopen;
12 | use function fread;
13 | use function fwrite;
14 | use function rewind;
15 | use function sprintf;
16 | use function strlen;
17 | 
18 | final class StringStream implements Stream
19 | {
20 |     /**
21 |      * @var resource
22 |      */
23 |     private $data;
24 | 
25 |     private readonly int $length;
26 | 
27 |     private int $totalRead = 0;
28 | 
29 |     public function __construct(string $data)
30 |     {
31 |         $this->length = strlen($data);
32 |         $resource = fopen('php://memory', 'rb+');
33 |         assert($resource !== false, 'The resource could not be opened.');
34 |         fwrite($resource, $data);
35 |         rewind($resource);
36 |         $this->data = $resource;
37 |     }
38 | 
39 |     public function read(int $length): string
40 |     {
41 |         if ($length <= 0) {
42 |             return '';
43 |         }
44 |         $read = fread($this->data, $length);
45 |         assert($read !== false, 'The data could not be read.');
46 |         $bytesRead = strlen($read);
47 |         strlen($read) === $length || throw InvalidDataException::create(null, sprintf(
48 |             'Out of range. Expected: %d, read: %d.',
49 |             $length,
50 |             $bytesRead
51 |         ));
52 |         $this->totalRead += $bytesRead;
53 | 
54 |         return $read;
55 |     }
56 | 
57 |     public function close(): void
58 |     {
59 |         fclose($this->data);
60 |     }
61 | 
62 |     public function isEOF(): bool
63 |     {
64 |         return $this->totalRead === $this->length;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/webauthn/src/TrustPath/CertificateTrustPath.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\TrustPath;
 6 | 
 7 | final readonly class CertificateTrustPath implements TrustPath
 8 | {
 9 |     /**
10 |      * @param string[] $certificates
11 |      */
12 |     public function __construct(
13 |         public array $certificates
14 |     ) {
15 |     }
16 | 
17 |     /**
18 |      * @param string[] $certificates
19 |      */
20 |     public static function create(array $certificates): self
21 |     {
22 |         return new self($certificates);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/webauthn/src/TrustPath/EmptyTrustPath.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\TrustPath;
 6 | 
 7 | final readonly class EmptyTrustPath implements TrustPath
 8 | {
 9 |     public static function create(): self
10 |     {
11 |         return new self();
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/webauthn/src/TrustPath/TrustPath.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\TrustPath;
 6 | 
 7 | interface TrustPath
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/webauthn/src/U2FPublicKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn;
 6 | 
 7 | use CBOR\ByteStringObject;
 8 | use CBOR\MapItem;
 9 | use CBOR\MapObject;
10 | use CBOR\NegativeIntegerObject;
11 | use CBOR\UnsignedIntegerObject;
12 | use Cose\Algorithms;
13 | use Cose\Key\Ec2Key;
14 | use function strlen;
15 | 
16 | /**
17 |  * @internal
18 |  */
19 | final readonly class U2FPublicKey
20 | {
21 |     private const U2F_KEY_PREFIX = "\x04";
22 | 
23 |     private const U2F_KEY_LENGTH = 65;
24 | 
25 |     private const U2F_KEY_PART_SIZE = 32;
26 | 
27 |     public static function isU2FKey(string $publicKey): bool
28 |     {
29 |         return $publicKey[0] === self::U2F_KEY_PREFIX && strlen($publicKey) === self::U2F_KEY_LENGTH;
30 |     }
31 | 
32 |     public static function convertToCoseKey(string $publicKey): string
33 |     {
34 |         return MapObject::create([
35 |             MapItem::create(
36 |                 UnsignedIntegerObject::create(Ec2Key::TYPE),
37 |                 UnsignedIntegerObject::create(Ec2Key::TYPE_EC2)
38 |             ),
39 |             MapItem::create(
40 |                 UnsignedIntegerObject::create(Ec2Key::ALG),
41 |                 NegativeIntegerObject::create(Algorithms::COSE_ALGORITHM_ES256)
42 |             ),
43 |             MapItem::create(
44 |                 NegativeIntegerObject::create(Ec2Key::DATA_CURVE),
45 |                 UnsignedIntegerObject::create(Ec2Key::CURVE_P256)
46 |             ),
47 |             MapItem::create(
48 |                 NegativeIntegerObject::create(Ec2Key::DATA_X),
49 |                 ByteStringObject::create(substr($publicKey, 1, self::U2F_KEY_PART_SIZE))
50 |             ),
51 |             MapItem::create(
52 |                 NegativeIntegerObject::create(Ec2Key::DATA_Y),
53 |                 ByteStringObject::create(substr($publicKey, 1 + self::U2F_KEY_PART_SIZE))
54 |             ),
55 |         ])->__toString();
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Util/Base64.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Util;
 6 | 
 7 | use ParagonIE\ConstantTime\Base64UrlSafe;
 8 | use Throwable;
 9 | use Webauthn\Exception\InvalidDataException;
10 | 
11 | abstract class Base64
12 | {
13 |     public static function decode(string $data): string
14 |     {
15 |         try {
16 |             return Base64UrlSafe::decode($data);
17 |         } catch (Throwable) {
18 |         }
19 | 
20 |         try {
21 |             return \ParagonIE\ConstantTime\Base64::decode($data);
22 |         } catch (Throwable $e) {
23 |             throw InvalidDataException::create($data, 'Invalid data submitted', $e);
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/webauthn/src/Util/CoseSignatureFixer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Webauthn\Util;
 6 | 
 7 | use Cose\Algorithm\Signature\ECDSA\ECSignature;
 8 | use Cose\Algorithm\Signature\ECDSA\ES256;
 9 | use Cose\Algorithm\Signature\ECDSA\ES256K;
10 | use Cose\Algorithm\Signature\ECDSA\ES384;
11 | use Cose\Algorithm\Signature\ECDSA\ES512;
12 | use Cose\Algorithm\Signature\Signature;
13 | use function strlen;
14 | 
15 | /**
16 |  * This class fixes the signature of the ECDSA based algorithms.
17 |  *
18 |  * @internal
19 |  *
20 |  * @see https://www.w3.org/TR/webauthn/#signature-attestation-types
21 |  */
22 | final readonly class CoseSignatureFixer
23 | {
24 |     private const ES256_SIGNATURE_LENGTH = 64;
25 | 
26 |     private const ES384_SIGNATURE_LENGTH = 96;
27 | 
28 |     private const ES512_SIGNATURE_LENGTH = 132;
29 | 
30 |     public static function fix(string $signature, Signature $algorithm): string
31 |     {
32 |         switch ($algorithm::identifier()) {
33 |             case ES256K::ID:
34 |             case ES256::ID:
35 |                 if (strlen($signature) === self::ES256_SIGNATURE_LENGTH) {
36 |                     return $signature;
37 |                 }
38 | 
39 |                 return ECSignature::fromAsn1(
40 |                     $signature,
41 |                     self::ES256_SIGNATURE_LENGTH
42 |                 ); //TODO: fix this hardcoded value by adding a dedicated method for the algorithms
43 |             case ES384::ID:
44 |                 if (strlen($signature) === self::ES384_SIGNATURE_LENGTH) {
45 |                     return $signature;
46 |                 }
47 | 
48 |                 return ECSignature::fromAsn1($signature, self::ES384_SIGNATURE_LENGTH);
49 |             case ES512::ID:
50 |                 if (strlen($signature) === self::ES512_SIGNATURE_LENGTH) {
51 |                     return $signature;
52 |                 }
53 | 
54 |                 return ECSignature::fromAsn1($signature, self::ES512_SIGNATURE_LENGTH);
55 |         }
56 | 
57 |         return $signature;
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------