LibWeb: Create policy containers from responses and then run CSP init

This allows us to parse the Content-Security-Policy header and
Referrer-Policy header from navigation responses and actually allow
them to start having an effect.

Libraries/LibWeb/HTML/Navigable.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <LibWeb/CSS/SystemColor.h>
+#include <LibWeb/ContentSecurityPolicy/PolicyList.h>
 #include <LibWeb/Crypto/Crypto.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/DOM/DocumentLoading.h>
@@ -992,8 +993,11 @@ static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation
             entry->document_state()->set_resource(Empty {});
         }
 
-        // FIXME 9. Set responsePolicyContainer to the result of creating a policy container from a fetch response given response and request's reserved client.
-        // FIXME 10. Set finalSandboxFlags to the union of targetSnapshotParams's sandboxing flags and responsePolicyContainer's CSP list's CSP-derived sandboxing flags.
+        // 9. Set responsePolicyContainer to the result of creating a policy container from a fetch response given response and request's reserved client.
+        response_policy_container = create_a_policy_container_from_a_fetch_response(realm, *response_holder->response(), request->reserved_client());
+
+        // 10. Set finalSandboxFlags to the union of targetSnapshotParams's sandboxing flags and responsePolicyContainer's CSP list's CSP-derived sandboxing flags.
+        final_sandbox_flags = target_snapshot_params.sandboxing_flags | response_policy_container->csp_list->csp_derived_sandboxing_flags();
 
         // 11. Set responseOrigin to the result of determining the origin given response's URL, finalSandboxFlags, and entry's document state's initiator origin.
         response_origin = determine_the_origin(response_holder->response()->url(), final_sandbox_flags, entry->document_state()->initiator_origin());

Libraries/LibWeb/HTML/PolicyContainers.cpp

@@ -9,6 +9,7 @@
 #include <LibURL/URL.h>
 #include <LibWeb/ContentSecurityPolicy/Policy.h>
 #include <LibWeb/ContentSecurityPolicy/PolicyList.h>
+#include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
 #include <LibWeb/Fetch/Infrastructure/URL.h>
 #include <LibWeb/HTML/PolicyContainers.h>
 #include <LibWeb/HTML/SerializedPolicyContainer.h>
@@ -34,6 +35,29 @@ bool url_requires_storing_the_policy_container_in_history(URL::URL const& url)
     return Fetch::Infrastructure::is_local_url(url);
 }
 
+// https://html.spec.whatwg.org/multipage/browsers.html#creating-a-policy-container-from-a-fetch-response
+GC::Ref<PolicyContainer> create_a_policy_container_from_a_fetch_response(JS::Realm& realm, GC::Ref<Fetch::Infrastructure::Response const> response, GC::Ptr<Environment>)
+{
+    // FIXME: 1. If response's URL's scheme is "blob", then return a clone of response's URL's blob URL entry's
+    //           environment's policy container.
+
+    // 2. Let result be a new policy container.
+    GC::Ref<PolicyContainer> result = realm.create<PolicyContainer>(realm);
+
+    // 3. Set result's CSP list to the result of parsing a response's Content Security Policies given response.
+    result->csp_list = ContentSecurityPolicy::Policy::parse_a_responses_content_security_policies(realm, response);
+
+    // FIXME: 4. If environment is non-null, then set result's embedder policy to the result of obtaining an embedder
+    //           policy given response and environment. Otherwise, set it to "unsafe-none".
+
+    // FIXME: 5. Set result's referrer policy to the result of parsing the `Referrer-Policy` header given response.
+    //           [REFERRERPOLICY]
+    //        Doing this currently makes Fetch fail the policy != ReferrerPolicy::EmptyString verification.
+
+    // 6. Return result.
+    return result;
+}
+
 GC::Ref<PolicyContainer> create_a_policy_container_from_serialized_policy_container(JS::Realm& realm, SerializedPolicyContainer const& serialized_policy_container)
 {
     GC::Ref<PolicyContainer> result = realm.create<PolicyContainer>(realm);

Libraries/LibWeb/HTML/PolicyContainers.h

@@ -50,6 +50,9 @@ private:
 // https://html.spec.whatwg.org/multipage/browsers.html#requires-storing-the-policy-container-in-history
 [[nodiscard]] bool url_requires_storing_the_policy_container_in_history(URL::URL const& url);
 
+// https://html.spec.whatwg.org/multipage/browsers.html#creating-a-policy-container-from-a-fetch-response
+[[nodiscard]] GC::Ref<PolicyContainer> create_a_policy_container_from_a_fetch_response(JS::Realm&, GC::Ref<Fetch::Infrastructure::Response const> response, GC::Ptr<Environment> environment);
+
 [[nodiscard]] GC::Ref<PolicyContainer> create_a_policy_container_from_serialized_policy_container(JS::Realm&, SerializedPolicyContainer const&);
 
 }

Libraries/LibWeb/HTML/WorkerGlobalScope.cpp

@@ -9,6 +9,10 @@
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WorkerGlobalScopePrototype.h>
 #include <LibWeb/CSS/FontFaceSet.h>
+#include <LibWeb/ContentSecurityPolicy/Directives/Directive.h>
+#include <LibWeb/ContentSecurityPolicy/Policy.h>
+#include <LibWeb/ContentSecurityPolicy/PolicyList.h>
+#include <LibWeb/Fetch/Infrastructure/URL.h>
 #include <LibWeb/HTML/EventHandler.h>
 #include <LibWeb/HTML/EventNames.h>
 #include <LibWeb/HTML/MessageEvent.h>
@@ -176,4 +180,45 @@ GC::Ref<PolicyContainer> WorkerGlobalScope::policy_container() const
     return *m_policy_container;
 }
 
+// https://html.spec.whatwg.org/multipage/browsers.html#initialize-worker-policy-container
+void WorkerGlobalScope::initialize_policy_container(GC::Ref<Fetch::Infrastructure::Response const> response, GC::Ref<EnvironmentSettingsObject> environment)
+{
+    auto& realm = this->realm();
+
+    // 1. If workerGlobalScope's url is local but its scheme is not "blob":
+    if (m_url.has_value() && Fetch::Infrastructure::is_local_url(m_url.value()) && m_url->scheme() != "blob"sv) {
+        // FIXME: 1. Assert: workerGlobalScope's owner set's size is 1.
+        // FIXME: 2. Set workerGlobalScope's policy container to a clone of workerGlobalScope's owner set[0]'s relevant settings object's policy container.
+        dbgln("FIXME: WorkerGlobalScope::initialize_policy_container: Clone owner's policy container for local, non-blob URL.");
+        return;
+    }
+
+    // 2. Otherwise, set workerGlobalScope's policy container to the result of creating a policy container from a fetch
+    //    response given response and environment.
+    m_policy_container = create_a_policy_container_from_a_fetch_response(realm, response, environment);
+}
+
+// https://w3c.github.io/webappsec-csp/#run-global-object-csp-initialization
+ContentSecurityPolicy::Directives::Directive::Result WorkerGlobalScope::run_csp_initialization() const
+{
+    // 1. Let result be "Allowed".
+    auto result = ContentSecurityPolicy::Directives::Directive::Result::Allowed;
+
+    // 2. For each policy of global’s CSP list:
+    for (auto policy : policy_container()->csp_list->policies()) {
+        // 1. For each directive of policy:
+        for (auto directive : policy->directives()) {
+            // 1. Execute directive’s initialization algorithm on global. If its returned value is "Blocked", then set
+            //    result to "Blocked".
+            auto directive_result = directive->initialization(GC::Ref { *this }, policy);
+            if (directive_result == ContentSecurityPolicy::Directives::Directive::Result::Blocked) {
+                result = ContentSecurityPolicy::Directives::Directive::Result::Blocked;
+            }
+        }
+    }
+
+    // 3. Return result.
+    return result;
+}
+
 }

Libraries/LibWeb/HTML/WorkerGlobalScope.h

@@ -97,6 +97,9 @@ public:
 
     bool is_closing() const { return m_closing; }
 
+    void initialize_policy_container(GC::Ref<Fetch::Infrastructure::Response const> response, GC::Ref<EnvironmentSettingsObject> environment);
+    [[nodiscard]] ContentSecurityPolicy::Directives::Directive::Result run_csp_initialization() const;
+
 protected:
     explicit WorkerGlobalScope(JS::Realm&, GC::Ref<Web::Page>);