tmp

Author: devgianlu

Libraries/LibWeb/CMakeLists.txt

@@ -84,12 +84,14 @@ set(SOURCES
     ContentSecurityPolicy/Violation.cpp
     CookieStore/CookieChangeEvent.cpp
     CookieStore/CookieStore.cpp
+    CredentialManagement/AuthenticatorResponse.cpp
     CredentialManagement/Credential.cpp
     CredentialManagement/CredentialsContainer.cpp
     CredentialManagement/FederatedCredential.cpp
     CredentialManagement/FederatedCredentialOperations.cpp
     CredentialManagement/PasswordCredential.cpp
     CredentialManagement/PasswordCredentialOperations.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 <altomanigianluca@gmail.com>
+ *
+ * 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 <altomanigianluca@gmail.com>
+ *
+ * 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

@@ -68,22 +68,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,7 +4,9 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/Bindings/Intrinsics.h>
+#include <LibWeb/CredentialManagement/CredentialsContainer.h>
 #include <LibWeb/CredentialManagement/FederatedCredential.h>
 #include <LibWeb/CredentialManagement/FederatedCredentialOperations.h>
 
@@ -25,6 +27,25 @@ FederatedCredential::~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;
+
+    // 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 = create_federated_credential(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();
+}
+
 FederatedCredential::FederatedCredential(JS::Realm& realm, FederatedCredentialInit const& init, URL::Origin origin)
     : Credential(realm, init.id)
     , CredentialUserData(init.name.value_or(String {}), init.icon_url.value_or(String {}))

Libraries/LibWeb/CredentialManagement/FederatedCredential.h

@@ -30,6 +30,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

Libraries/LibWeb/CredentialManagement/PasswordCredential.cpp

@@ -4,8 +4,12 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibWeb/Bindings/ExceptionOrUtils.h>
+#include <LibWeb/CredentialManagement/CredentialsContainer.h>
 #include <LibWeb/CredentialManagement/PasswordCredential.h>
 #include <LibWeb/CredentialManagement/PasswordCredentialOperations.h>
+#include <LibWeb/HTML/AutocompleteElement.h>
+#include <LibWeb/XHR/FormData.h>
 
 namespace Web::CredentialManagement {
 
@@ -51,4 +55,31 @@ void PasswordCredential::initialize(JS::Realm& realm)
     Base::initialize(realm);
 }
 
+// https://w3c.github.io/webappsec-credential-management/#create-passwordcredential
+JS::ThrowCompletionOr<Variant<Empty, GC::Ref<Credential>, GC::Ref<CreateCredentialAlgorithm>>> PasswordCredentialInterface::create(JS::Realm& realm, URL::Origin const& origin, CredentialCreationOptions const& options, bool) const
+{
+    // 1. Assert: options["password"] exists, and sameOriginWithAncestors is unused.
+    VERIFY(options.password.has_value());
+
+    auto maybe_result = options.password->visit(
+        // 2. If options["password"] is an HTMLFormElement, return the result of executing Create a PasswordCredential
+        //    from an HTMLFormElement given options["password"] and origin. Rethrow any exceptions.
+        [&](GC::Root<HTML::HTMLFormElement> const& form) {
+            return create_password_credential(realm, *form, origin);
+        },
+        // 3. If options["password"] is a PasswordCredentialData, return the result of executing
+        //     Create a PasswordCredential from PasswordCredentialData given options["password"]. Rethrow any exceptions.
+        [&](PasswordCredentialData const& data) {
+            return create_password_credential(realm, data, origin);
+        },
+        // 4. Throw a TypeError exception.
+        [&](auto) {
+            return realm.vm().throw_completion<JS::TypeError>("options.password must be an HTMLFormElement or a PasswordCredentialData"sv);
+        });
+    if (maybe_result.is_error())
+        return Bindings::exception_to_throw_completion(realm.vm(), maybe_result.release_error());
+
+    return maybe_result.release_value();
+}
+
 }