tmp

Author: devgianlu

Libraries/LibWeb/CMakeLists.txt

@@ -36,10 +36,12 @@ set(SOURCES
     Clipboard/ClipboardItem.cpp
     Compression/CompressionStream.cpp
     Compression/DecompressionStream.cpp
+    CredentialManagement/AuthenticatorResponse.cpp
     CredentialManagement/Credential.cpp
     CredentialManagement/CredentialsContainer.cpp
     CredentialManagement/FederatedCredential.cpp
     CredentialManagement/PasswordCredential.cpp
+    CredentialManagement/PublicKeyCredential.cpp
     Crypto/Crypto.cpp
     Crypto/CryptoAlgorithms.cpp
     Crypto/CryptoBindings.cpp

Libraries/LibWeb/CredentialManagement/AuthenticatorResponse.cpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025, Altomani Gianluca <[email protected]>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibJS/Runtime/ArrayBuffer.h>
+#include <LibWeb/Bindings/Intrinsics.h>
+#include <LibWeb/CredentialManagement/AuthenticatorResponse.h>
+
+namespace Web::CredentialManagement {
+
+GC_DEFINE_ALLOCATOR(AuthenticatorResponse);
+
+AuthenticatorResponse::~AuthenticatorResponse() { }
+
+GC::Ref<JS::ArrayBuffer> AuthenticatorResponse::client_data_json() const
+{
+    return MUST(JS::ArrayBuffer::create(realm(), static_cast<size_t>(0)));
+}
+
+AuthenticatorResponse::AuthenticatorResponse(JS::Realm& realm)
+    : PlatformObject(realm)
+{
+}
+
+void AuthenticatorResponse::initialize(JS::Realm& realm)
+{
+    Base::initialize(realm);
+    WEB_SET_PROTOTYPE_FOR_INTERFACE(AuthenticatorResponse);
+}
+}

Libraries/LibWeb/CredentialManagement/AuthenticatorResponse.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2025, Altomani Gianluca <[email protected]>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <LibJS/Forward.h>
+#include <LibWeb/Bindings/AuthenticatorResponsePrototype.h>
+#include <LibWeb/Bindings/PlatformObject.h>
+#include <LibWeb/WebIDL/Promise.h>
+
+namespace Web::CredentialManagement {
+
+class AuthenticatorResponse : public Bindings::PlatformObject {
+    WEB_PLATFORM_OBJECT(AuthenticatorResponse, Bindings::PlatformObject);
+    GC_DECLARE_ALLOCATOR(AuthenticatorResponse);
+
+public:
+    [[nodiscard]] static GC::Ref<AuthenticatorResponse> create(JS::Realm&);
+
+    virtual ~AuthenticatorResponse() override;
+
+    GC::Ref<JS::ArrayBuffer> client_data_json() const;
+
+protected:
+    explicit AuthenticatorResponse(JS::Realm&);
+    virtual void initialize(JS::Realm&) override;
+};
+
+}

Libraries/LibWeb/CredentialManagement/AuthenticatorResponse.idl

@@ -0,0 +1,4 @@
+[SecureContext, Exposed=Window]
+interface AuthenticatorResponse {
+    [SameObject] readonly attribute ArrayBuffer clientDataJSON;
+};

Libraries/LibWeb/CredentialManagement/CredentialsContainer.cpp

@@ -65,22 +65,22 @@ static Vector<CredentialInterface const*> relevant_credential_interface_objects(
     // NOTE: We cannot iterate like the spec says.
     //      1. Let credentialInterfaceObject be the Appropriate Interface Object (on settings’ global object) whose Options Member Identifier is optionKey.
     //      2. Assert: credentialInterfaceObject’s [[type]] slot equals the Credential Type whose Options Member Identifier is optionKey.
+    //         NOTE: This is not necessary in our implementation.
     //      3. Append credentialInterfaceObject to relevant interface objects.
 
 #define APPEND_CREDENTIAL_INTERFACE_OBJECT(key, type_)                            \
     if (options.key.has_value()) {                                                \
         auto credential_interface_object = type_##Interface::the();               \
-        VERIFY(credential_interface_object->options_member_identifier() == #key); \
         interfaces.append(credential_interface_object);                           \
     }
 
     // https://w3c.github.io/webappsec-credential-management/#credential-type-registry-appropriate-interface-object
     APPEND_CREDENTIAL_INTERFACE_OBJECT(password, PasswordCredential);
     APPEND_CREDENTIAL_INTERFACE_OBJECT(federated, FederatedCredential);
+    APPEND_CREDENTIAL_INTERFACE_OBJECT(public_key, PublicKeyCredential);
     // TODO: digital
     // TODO: identity
     // TODO: otp
-    // TODO: publicKey
 
 #undef APPEND_CREDENTIAL_INTERFACE_OBJECT
 

Libraries/LibWeb/CredentialManagement/CredentialsContainer.h

@@ -13,6 +13,7 @@
 #include <LibWeb/CredentialManagement/Credential.h>
 #include <LibWeb/CredentialManagement/FederatedCredential.h>
 #include <LibWeb/CredentialManagement/PasswordCredential.h>
+#include <LibWeb/CredentialManagement/PublicKeyCredential.h>
 #include <LibWeb/DOM/AbortSignal.h>
 
 namespace Web::CredentialManagement {
@@ -42,6 +43,7 @@ struct CredentialRequestOptions {
 
     Optional<bool> password;
     Optional<FederatedCredentialRequestOptions> federated;
+    Optional<PublicKeyCredentialRequestOptions> public_key;
 };
 
 struct CredentialCreationOptions {
@@ -50,6 +52,7 @@ struct CredentialCreationOptions {
 
     Optional<PasswordCredentialInit> password;
     Optional<FederatedCredentialInit> federated;
+    Optional<PublicKeyCredentialCreationOptions> public_key;
 };
 
 }

Libraries/LibWeb/CredentialManagement/CredentialsContainer.idl

@@ -1,6 +1,7 @@
 #import <CredentialManagement/Credential.idl>
 #import <CredentialManagement/FederatedCredential.idl>
 #import <CredentialManagement/PasswordCredential.idl>
+#import <CredentialManagement/PublicKeyCredential.idl>
 
 [Exposed=Window, SecureContext]
 interface CredentialsContainer {

Libraries/LibWeb/CredentialManagement/FederatedCredential.cpp

@@ -4,6 +4,9 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include "CredentialsContainer.h"
+
+#include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/CredentialManagement/FederatedCredential.h>
 
@@ -16,10 +19,45 @@ GC::Ref<FederatedCredential> FederatedCredential::create(JS::Realm& realm)
     return realm.create<FederatedCredential>(realm);
 }
 
-// https://www.w3.org/TR/credential-management-1/#dom-federatedcredential-federatedcredential
-WebIDL::ExceptionOr<GC::Ref<FederatedCredential>> FederatedCredential::construct_impl(JS::Realm& realm, FederatedCredentialInit const&)
+// https://w3c.github.io/webappsec-credential-management/#abstract-opdef-create-a-federatedcredential-from-federatedcredentialinit
+WebIDL::ExceptionOr<GC::Ref<FederatedCredential>> FederatedCredential::create_from_federated_credential_init(JS::Realm& realm, FederatedCredentialInit const& init)
+{
+    // 1. Let c be a new FederatedCredential object.
+    auto c = realm.create<FederatedCredential>(realm);
+
+    // 2. If any of the following are the empty string, throw a TypeError exception:
+    //      - init.id's value
+    //      - init.provider's value
+    if (init.id.is_empty() || init.provider.is_empty())
+        return realm.vm().throw_completion<JS::TypeError>("id and provider must not be empty"sv);
+
+    // 3. Set c’s properties as follows:
+    //      id -> init.id's value
+    c->m_id = init.id;
+    //      provider -> init.provider's value
+    c->m_provider = init.provider;
+    //      iconURL -> init.iconURL's value
+    c->m_icon_url = init.icon_url.value_or({});
+    //      name -> init.name's value
+    c->m_name = init.name.value_or({});
+    //      [[origin]] -> init.origin's value.
+    c->m_origin = init.origin;
+
+    // 4. Return c.
+    return c;
+}
+
+// https://w3c.github.io/webappsec-credential-management/#dom-federatedcredential-federatedcredential
+WebIDL::ExceptionOr<GC::Ref<FederatedCredential>> FederatedCredential::construct_impl(JS::Realm& realm, FederatedCredentialInit const& init)
 {
-    return realm.vm().throw_completion<JS::InternalError>(JS::ErrorType::NotImplemented, "construct"sv);
+    // 1. Let r be the result of executing Create a FederatedCredential from FederatedCredentialInit on data.
+    //    If that threw an exception, rethrow that exception.
+    auto r = create_from_federated_credential_init(realm, init);
+    if (r.is_error())
+        return r.exception();
+
+    // 2. Return r.
+    return r.value();
 }
 
 FederatedCredential::~FederatedCredential()
@@ -37,4 +75,23 @@ void FederatedCredential::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(FederatedCredential);
 }
 
+// // https://w3c.github.io/webappsec-credential-management/#create-federatedcredential
+JS::ThrowCompletionOr<Variant<Empty, GC::Ref<Credential>, GC::Ref<CreateCredentialAlgorithm>>> FederatedCredentialInterface::create(JS::Realm& realm, URL::Origin const& origin, CredentialCreationOptions const& options, bool) const
+{
+    // 1. Assert: options["federated"] exists, and sameOriginWithAncestors is unused.
+    VERIFY(options.federated.has_value());
+
+    // 2. Set options["federated"]'s origin member’s value to origin’s value.
+    auto new_options = options;
+    new_options.federated->origin = origin.serialize();
+
+    // 3. Return the result of executing Create a FederatedCredential from FederatedCredentialInit given options["federated"].
+    // If that threw an exception, then rethrow that exception.
+    auto maybe_result = FederatedCredential::create_from_federated_credential_init(realm, *new_options.federated);
+    if (maybe_result.is_error())
+        return Bindings::exception_to_throw_completion(realm.vm(), maybe_result.release_error());
+
+    return maybe_result.release_value();
+}
+
 }

Libraries/LibWeb/CredentialManagement/FederatedCredential.h

@@ -29,6 +29,9 @@ class FederatedCredentialInterface final : public CredentialInterface {
         //       therefore conditional mediation is not supported.
         return false;
     }
+
+    // https://w3c.github.io/webappsec-credential-management/#create-federatedcredential
+    virtual JS::ThrowCompletionOr<Variant<Empty, GC::Ref<Credential>, GC::Ref<CreateCredentialAlgorithm>>> create(JS::Realm&, URL::Origin const&, CredentialCreationOptions const&, bool) const override;
 };
 
 class FederatedCredential final : public Credential {
@@ -50,10 +53,14 @@ class FederatedCredential final : public Credential {
         return FederatedCredentialInterface::the();
     }
 
+    // https://w3c.github.io/webappsec-credential-management/#abstract-opdef-create-a-federatedcredential-from-federatedcredentialinit
+    static WebIDL::ExceptionOr<GC::Ref<FederatedCredential>> create_from_federated_credential_init(JS::Realm&, FederatedCredentialInit const&);
+
 private:
     explicit FederatedCredential(JS::Realm&);
     virtual void initialize(JS::Realm&) override;
 
+    String m_origin;
     String m_provider;
     Optional<String> m_protocol;
 };