feat: add webauthn signal api

Author: joostdebruijn

src/webauthn/src/Denormalizer/SignalAllAcceptedCredentialsDenormalizer.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Webauthn\Denormalizer;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Webauthn\PublicKeyCredentialDescriptor;
+use Webauthn\Signal\AllAcceptedCredentials;
+
+class SignalAllAcceptedCredentialsDenormalizer implements NormalizerInterface, NormalizerAwareInterface
+{
+    use NormalizerAwareTrait;
+
+    /**
+     * @return array<class-string, bool>
+     */
+    public function getSupportedTypes(?string $format): array
+    {
+        return [
+            AllAcceptedCredentials::class => true,
+        ];
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function normalize(mixed $data, ?string $format = null, array $context = []): array
+    {
+        assert($data instanceof AllAcceptedCredentials);
+
+        $normalized_rp = $this->normalizer->normalize(
+            $data->rp,
+            $format,
+            $context
+        );
+
+        $normalized_user = $this->normalizer->normalize(
+            $data->user,
+            $format,
+            $context
+        );
+
+        $normalized_credentials = array_map(function (PublicKeyCredentialDescriptor $credential) use ($format, $context) {
+            return $this->normalizer->normalize($credential, $format, $context);
+        }, $data->allAcceptedCredentials);
+
+        return [
+            'rpId' => $normalized_rp['id'],
+            'userId' => $normalized_user['id'],
+            'allAcceptedCredentialIds' => array_map(
+                fn (array $credential): string => $credential['id'],
+                $normalized_credentials
+            ),
+        ];
+    }
+
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
+    {
+        return $data instanceof AllAcceptedCredentials;
+    }
+}

src/webauthn/src/Denormalizer/SignalCurrentUserDetailsDenormalizer.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Webauthn\Denormalizer;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Webauthn\Signal\CurrentUserDetails;
+
+class SignalCurrentUserDetailsDenormalizer implements NormalizerInterface, NormalizerAwareInterface
+{
+    use NormalizerAwareTrait;
+
+    /**
+     * @return array<class-string, bool>
+     */
+    public function getSupportedTypes(?string $format): array
+    {
+        return [
+            CurrentUserDetails::class => true,
+        ];
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function normalize(mixed $data, ?string $format = null, array $context = []): array
+    {
+        assert($data instanceof CurrentUserDetails);
+
+        $normalized_rp = $this->normalizer->normalize(
+            $data->rp,
+            $format,
+            $context
+        );
+
+        $normalized_user = $this->normalizer->normalize(
+            $data->user,
+            $format,
+            $context
+        );
+
+        return [
+            'rpId' => $normalized_rp['id'],
+            'userId' => $normalized_user['id'],
+            'name' => $normalized_user['name'],
+            'displayName' => $normalized_user['displayName'],
+        ];
+    }
+
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
+    {
+        return $data instanceof CurrentUserDetails;
+    }
+}

src/webauthn/src/Denormalizer/SignalUnknownCredentialDenormalizer.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Webauthn\Denormalizer;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerAwareTrait;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Webauthn\Signal\UnknownCredential;
+
+class SignalUnknownCredentialDenormalizer implements NormalizerInterface, NormalizerAwareInterface
+{
+    use NormalizerAwareTrait;
+
+    /**
+     * @return array<class-string, bool>
+     */
+    public function getSupportedTypes(?string $format): array
+    {
+        return [
+            UnknownCredential::class => true,
+        ];
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function normalize(mixed $data, ?string $format = null, array $context = []): array
+    {
+        assert($data instanceof UnknownCredential);
+
+        $normalized_rp = $this->normalizer->normalize(
+            $data->rp,
+            $format,
+            $context
+        );
+
+        $normalized_credential = $this->normalizer->normalize(
+            $data->credential,
+            $format,
+            $context
+        );
+
+        return [
+            'rpId' => $normalized_rp['id'],
+            'credentialId' => $normalized_credential['id'],
+        ];
+    }
+
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
+    {
+        return $data instanceof UnknownCredential;
+    }
+}

src/webauthn/src/Denormalizer/WebauthnSerializerFactory.php

@@ -60,6 +60,9 @@ public function create(): SerializerInterface
             new PublicKeyCredentialOptionsDenormalizer(),
             new PublicKeyCredentialSourceDenormalizer(),
             new PublicKeyCredentialUserEntityDenormalizer(),
+            new SignalAllAcceptedCredentialsDenormalizer(),
+            new SignalCurrentUserDetailsDenormalizer(),
+            new SignalUnknownCredentialDenormalizer(),
             new TrustPathDenormalizer(),
             new UidNormalizer(),
             new ArrayDenormalizer(),

src/webauthn/src/Signal/AllAcceptedCredentials.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Webauthn\Signal;
+
+use Webauthn\PublicKeyCredentialDescriptor;
+use Webauthn\PublicKeyCredentialRpEntity;
+use Webauthn\PublicKeyCredentialUserEntity;
+
+readonly class AllAcceptedCredentials implements Signal
+{
+    /**
+     * @param PublicKeyCredentialDescriptor[] $allAcceptedCredentials 
+     */
+    public function __construct(
+        public PublicKeyCredentialRpEntity $rp,
+        public PublicKeyCredentialUserEntity $user,
+        public array $allAcceptedCredentials,
+    ) {}
+}

src/webauthn/src/Signal/CurrentUserDetails.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Webauthn\Signal;
+
+use Webauthn\PublicKeyCredentialRpEntity;
+use Webauthn\PublicKeyCredentialUserEntity;
+
+readonly class CurrentUserDetails implements Signal
+{
+    public function __construct(
+        public PublicKeyCredentialRpEntity $rp,
+        public PublicKeyCredentialUserEntity $user,
+    ) {}
+}

src/webauthn/src/Signal/Signal.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Webauthn\Signal;
+
+interface Signal
+{
+}

src/webauthn/src/Signal/UnknownCredential.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Webauthn\Signal;
+
+use Webauthn\PublicKeyCredentialDescriptor;
+use Webauthn\PublicKeyCredentialRpEntity;
+
+readonly class UnknownCredential implements Signal
+{
+    public function __construct(
+        public PublicKeyCredentialRpEntity $rp,
+        public PublicKeyCredentialDescriptor $credential,
+    ) {}
+}

tests/library/Unit/SerializerTest.php

@@ -10,9 +10,13 @@
 use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
 use Webauthn\AuthenticatorSelectionCriteria;
 use Webauthn\PublicKeyCredentialCreationOptions;
+use Webauthn\PublicKeyCredentialDescriptor;
 use Webauthn\PublicKeyCredentialParameters;
 use Webauthn\PublicKeyCredentialRpEntity;
 use Webauthn\PublicKeyCredentialUserEntity;
+use Webauthn\Signal\AllAcceptedCredentials;
+use Webauthn\Signal\CurrentUserDetails;
+use Webauthn\Signal\UnknownCredential;
 use Webauthn\Tests\AbstractTestCase;
 use Webauthn\TrustPath\CertificateTrustPath;
 use Webauthn\TrustPath\EmptyTrustPath;
@@ -134,4 +138,63 @@ public function theCredentialCanBeDeserialized(): void
             $json,
         );
     }
+
+    #[Test]
+    public function itSerializesSignalUnknownCredential(): void
+    {
+        $rp = new PublicKeyCredentialRpEntity('Example.com', 'rp.example.com');
+        $credential = new PublicKeyCredentialDescriptor(
+            PublicKeyCredentialDescriptor::CREDENTIAL_TYPE_PUBLIC_KEY,
+            'cred-123',
+            []
+        );
+        $signal = new UnknownCredential($rp, $credential);
+
+        $serializer = $this->getSerializer();
+        $json = $serializer->serialize($signal, 'json');
+        static::assertJsonStringEqualsJsonString(
+            '{"rpId":"rp.example.com","credentialId":"Y3JlZC0xMjM"}',
+            $json
+        );
+    }
+
+    #[Test]
+    public function itSerializesSignalAllAcceptedCredentials(): void
+    {
+        $rp = new PublicKeyCredentialRpEntity('Example.com', 'rp.example.com');
+        $user = new PublicKeyCredentialUserEntity('john.doe', 'user-1', 'John Doe');
+        $cred1 = new PublicKeyCredentialDescriptor(
+            PublicKeyCredentialDescriptor::CREDENTIAL_TYPE_PUBLIC_KEY,
+            'cred-1',
+            []
+        );
+        $cred2 = new PublicKeyCredentialDescriptor(
+            PublicKeyCredentialDescriptor::CREDENTIAL_TYPE_PUBLIC_KEY,
+            'cred-2',
+            []
+        );
+        $signal = new AllAcceptedCredentials($rp, $user, [$cred1, $cred2]);
+
+        $serializer = $this->getSerializer();
+        $json = $serializer->serialize($signal, 'json');
+        static::assertJsonStringEqualsJsonString(
+            '{"rpId":"rp.example.com","userId":"dXNlci0x","allAcceptedCredentialIds":["Y3JlZC0x","Y3JlZC0y"]}',
+            $json
+        );
+    }
+
+    #[Test]
+    public function itSerializesSignalCurrentUserDetails(): void
+    {
+        $rp = new PublicKeyCredentialRpEntity('Example.com', 'rp.example.com');
+        $user = new PublicKeyCredentialUserEntity('john.doe', 'user-1', 'John Doe');
+        $signal = new CurrentUserDetails($rp, $user);
+
+        $serializer = $this->getSerializer();
+        $json = $serializer->serialize($signal, 'json');
+        static::assertJsonStringEqualsJsonString(
+            '{"rpId":"rp.example.com","userId":"dXNlci0x","name":"john.doe","displayName":"John Doe"}',
+            $json
+        );
+    }
 }