Implement AIA fetching, for sites with broken cert chains

.github/actions/setup/action.yml

@@ -64,7 +64,7 @@ runs:
         python3 -m pip install --upgrade pip
 
         if ${{ inputs.type == 'build' }} ; then
-          pip3 install pyyaml requests six
+          pip3 install pyyaml requests six cryptography
         else
           pip3 install pyright ruff
         fi

AK/Debug.h.in

@@ -218,6 +218,10 @@
 #    cmakedefine01 SPAM_DEBUG
 #endif
 
+#ifndef STRUCTURED_SERIALIZE_DEBUG
+#    cmakedefine01 STRUCTURED_SERIALIZE_DEBUG
+#endif
+
 #ifndef SYNTAX_HIGHLIGHTING_DEBUG
 #    cmakedefine01 SYNTAX_HIGHLIGHTING_DEBUG
 #endif

AK/JsonObjectSerializer.h

@@ -72,16 +72,46 @@ class JsonObjectSerializer {
         return {};
     }
 
+    ErrorOr<void> add(StringView key, Utf16View const& value)
+    {
+        TRY(begin_item(key));
+        if constexpr (IsLegacyBuilder<Builder>) {
+            TRY(m_builder.try_append('"'));
+            TRY(m_builder.try_append_escaped_for_json(value));
+            TRY(m_builder.try_append('"'));
+        } else {
+            TRY(m_builder.append('"'));
+            TRY(m_builder.append_escaped_for_json(value));
+            TRY(m_builder.append('"'));
+        }
+        return {};
+    }
+
+    ErrorOr<void> add(Utf16View const& key, Utf16View const& value)
+    {
+        TRY(begin_item(key));
+        if constexpr (IsLegacyBuilder<Builder>) {
+            TRY(m_builder.try_append('"'));
+            TRY(m_builder.try_append_escaped_for_json(value));
+            TRY(m_builder.try_append('"'));
+        } else {
+            TRY(m_builder.append('"'));
+            TRY(m_builder.append_escaped_for_json(value));
+            TRY(m_builder.append('"'));
+        }
+        return {};
+    }
+
     ErrorOr<void> add(StringView key, char const* value)
     {
         TRY(begin_item(key));
         if constexpr (IsLegacyBuilder<Builder>) {
             TRY(m_builder.try_append('"'));
-            TRY(m_builder.try_append_escaped_for_json({ value, __builtin_strlen(value) }));
+            TRY(m_builder.try_append_escaped_for_json(StringView { value, __builtin_strlen(value) }));
             TRY(m_builder.try_append('"'));
         } else {
             TRY(m_builder.append('"'));
-            TRY(m_builder.append_escaped_for_json({ value, __builtin_strlen(value) }));
+            TRY(m_builder.append_escaped_for_json(StringView { value, __builtin_strlen(value) }));
             TRY(m_builder.append('"'));
         }
         return {};
@@ -183,12 +213,24 @@ class JsonObjectSerializer {
         return JsonArraySerializer<Builder>::try_create(m_builder);
     }
 
+    ErrorOr<JsonArraySerializer<Builder>> add_array(Utf16View const& key)
+    {
+        TRY(begin_item(key));
+        return JsonArraySerializer<Builder>::try_create(m_builder);
+    }
+
     ErrorOr<JsonObjectSerializer<Builder>> add_object(StringView key)
     {
         TRY(begin_item(key));
         return JsonObjectSerializer::try_create(m_builder);
     }
 
+    ErrorOr<JsonObjectSerializer<Builder>> add_object(Utf16View const& key)
+    {
+        TRY(begin_item(key));
+        return JsonObjectSerializer::try_create(m_builder);
+    }
+
     ErrorOr<void> finish()
     {
         VERIFY(!m_finished);
@@ -229,6 +271,29 @@ class JsonObjectSerializer {
         return {};
     }
 
+    ErrorOr<void> begin_item(Utf16View const& key)
+    {
+        VERIFY(!m_finished);
+        if (!m_empty) {
+            if constexpr (IsLegacyBuilder<Builder>)
+                TRY(m_builder.try_append(','));
+            else
+                TRY(m_builder.append(','));
+        }
+        m_empty = false;
+
+        if constexpr (IsLegacyBuilder<Builder>) {
+            TRY(m_builder.try_append('"'));
+            TRY(m_builder.try_append_escaped_for_json(key));
+            TRY(m_builder.try_append("\":"sv));
+        } else {
+            TRY(m_builder.append('"'));
+            TRY(m_builder.append_escaped_for_json(key));
+            TRY(m_builder.append("\":"sv));
+        }
+        return {};
+    }
+
     Builder& m_builder;
     bool m_empty { true };
     bool m_finished { false };

AK/LEB128.h

@@ -95,7 +95,52 @@ class [[gnu::packed]] LEB128 {
         return LEB128<ValueType> { result };
     }
 
+    ErrorOr<void> write_to_stream(Stream& stream) const
+    {
+        ErrorOr<void> result;
+        for_each_leb128_byte(m_value, [&](u8 byte) {
+            if (!result.is_error())
+                result = stream.write_value(byte);
+        });
+        return result;
+    }
+
+    template<typename Buffer>
+    static void append_to(Buffer& output, ValueType value)
+    {
+        for_each_leb128_byte(value, [&output](u8 byte) { output.append(byte); });
+    }
+
 private:
+    template<typename Callback>
+    static void for_each_leb128_byte(ValueType value, Callback&& callback)
+    requires(Unsigned<ValueType>)
+    {
+        do {
+            u8 byte = value & 0x7F;
+            value >>= 7;
+            if (value != 0)
+                byte |= 0x80; // More bytes follow.
+            callback(byte);
+        } while (value != 0);
+    }
+
+    template<typename Callback>
+    static void for_each_leb128_byte(ValueType value, Callback&& callback)
+    requires(Signed<ValueType>)
+    {
+        while (true) {
+            u8 byte = value & 0x7F;
+            value >>= 7; // Arithmetic shift; preserves the sign.
+            bool const sign_bit_set = (byte & 0x40) != 0;
+            if ((value == 0 && !sign_bit_set) || (value == -1 && sign_bit_set)) {
+                callback(byte);
+                return;
+            }
+            callback(static_cast<u8>(byte | 0x80));
+        }
+    }
+
     ValueType m_value { 0 };
 };
 

AK/MemoryStream.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <AK/Checked.h>
 #include <AK/Error.h>
 #include <AK/OwnPtr.h>
 #include <AK/Stream.h>
@@ -74,8 +75,13 @@ class FixedMemoryStream : public SeekableStream {
                 return Error::from_string_literal("Tried to obtain a non-const span from a read-only FixedMemoryStream");
         }
 
+        Checked<size_t> byte_count = sizeof(T);
+        byte_count *= count;
+        if (byte_count.has_overflow() || byte_count.value() > remaining())
+            return Error::from_string_literal("Read of out-of-bounds span from FixedMemoryStream");
+
         Span<T> span { reinterpret_cast<T*>(m_bytes.offset_pointer(m_offset)), count };
-        TRY(discard(sizeof(T) * count));
+        TRY(discard(byte_count.value()));
         return span;
     }
 

AK/Utf16FlyString.cpp

@@ -58,6 +58,13 @@ Utf16FlyString Utf16FlyString::from_utf8(StringView string)
     return Utf16String::from_utf8(string);
 }
 
+Utf16FlyString Utf16FlyString::from_ascii_without_validation(StringView string)
+{
+    if (auto result = create_fly_string_from_cache(string); result.has_value())
+        return result.release_value();
+    return Utf16String::from_ascii_without_validation(string.bytes());
+}
+
 Utf16FlyString Utf16FlyString::from_utf8_without_validation(StringView string)
 {
     if (auto result = create_fly_string_from_cache(string); result.has_value())

AK/Utf16FlyString.h

@@ -24,6 +24,7 @@ class [[nodiscard]] Utf16FlyString {
     static Utf16FlyString from_utf8(String const& string) { return from_utf8_without_validation(string); }
     static Utf16FlyString from_utf8(FlyString const& string) { return from_utf8_without_validation(string); }
     static Utf16FlyString from_fly_string(FlyString const& string) { return from_utf8_without_validation(string); }
+    static Utf16FlyString from_ascii_without_validation(StringView);
     static Utf16FlyString from_utf8_without_validation(StringView);
     static Utf16FlyString from_utf8_but_should_be_ported_to_utf16(StringView string) { return from_utf8_without_validation(string); }
 

AK/Utf16StringBuilder.cpp

@@ -343,6 +343,74 @@ void Utf16StringBuilder::append_repeated(Utf16View const& view, size_t count)
         append(view);
 }
 
+void Utf16StringBuilder::append_escaped_for_json(Utf16View const& string)
+{
+    MUST(try_append_escaped_for_json(string));
+}
+
+void Utf16StringBuilder::append_escaped_for_json(StringView string)
+{
+    MUST(try_append_escaped_for_json(string));
+}
+
+ErrorOr<void> Utf16StringBuilder::try_append(char code_unit)
+{
+    append_ascii(code_unit);
+    return {};
+}
+
+ErrorOr<void> Utf16StringBuilder::try_append(StringView string)
+{
+    if (string.is_ascii()) {
+        append_ascii(string);
+        return {};
+    }
+
+    auto utf16_string = TRY(Utf16String::try_from_utf8(string));
+    append(utf16_string.utf16_view());
+    return {};
+}
+
+ErrorOr<void> Utf16StringBuilder::try_append(Utf16View const& view)
+{
+    append(view);
+    return {};
+}
+
+ErrorOr<void> Utf16StringBuilder::try_append_escaped_for_json(StringView string)
+{
+    return try_append_escaped_for_json(Utf16View { string });
+}
+
+ErrorOr<void> Utf16StringBuilder::try_append_escaped_for_json(Utf16View const& string)
+{
+    for (auto code_point : string) {
+        switch (code_point) {
+        case '\b':
+            append_ascii("\\b"sv);
+            break;
+        case '\n':
+            append_ascii("\\n"sv);
+            break;
+        case '\t':
+            append_ascii("\\t"sv);
+            break;
+        case '"':
+            append_ascii("\\\""sv);
+            break;
+        case '\\':
+            append_ascii("\\\\"sv);
+            break;
+        default:
+            if (code_point <= 0x1f)
+                TRY(try_appendff("\\u{:04x}", code_point));
+            else
+                append_code_point(code_point);
+        }
+    }
+    return {};
+}
+
 Utf16String Utf16StringBuilder::to_string()
 {
     return Utf16String::from_string_builder({}, *this);

AK/Utf16StringBuilder.h

@@ -85,6 +85,14 @@ class Utf16StringBuilder {
     void append_code_point(u32);
     void append_repeated_ascii(char, size_t);
     void append_repeated(Utf16View const&, size_t);
+    void append_escaped_for_json(StringView);
+    void append_escaped_for_json(Utf16View const&);
+
+    ErrorOr<void> try_append(char);
+    ErrorOr<void> try_append(StringView);
+    ErrorOr<void> try_append(Utf16View const&);
+    ErrorOr<void> try_append_escaped_for_json(StringView);
+    ErrorOr<void> try_append_escaped_for_json(Utf16View const&);
 
     template<typename... Parameters>
     ErrorOr<void> try_appendff(CheckedFormatString<Parameters...>&& fmtstr, Parameters const&... parameters)

Documentation/BuildInstructionsLadybird.md

@@ -2,7 +2,10 @@
 
 ## Build Prerequisites
 
-Qt6 development packages, nasm, additional build tools, and a C++23 capable compiler are required.
+Qt6.9+ development packages, nasm, additional build tools, and a C++23 capable compiler are required.
+
+> [!NOTE]
+> Some distributions still package a Qt6 older than 6.9; for example, Debian 13 (trixie) ships Qt 6.8 — so configuring against it fails. If your Qt6 is older than 6.9, install a newer one from a newer distribution release, or directly from the [Qt online installer](https://www.qt.io/download-open-source), and then point the build to it using `CMAKE_PREFIX_PATH`.
 
 A Rust toolchain is also required. You can install it via [rustup](https://rustup.rs/).
 
@@ -25,7 +28,7 @@ sudo apt install autoconf autoconf-archive automake build-essential ccache cmake
 - Recommendation: Install `CMake 3.30` or newer from [Kitware's apt repository](https://apt.kitware.com/):
 
 > [!NOTE]
-> This repository is Ubuntu-only
+> Kitware’s apt repository is Ubuntu-only.
 
 ```bash
 # Add Kitware GPG signing key