tmp

Author: devgianlu

Libraries/LibCrypto/PK/EC.h

@@ -36,6 +36,8 @@ class ECPublicKey {
     {
     }
 
+    UnsignedBigInteger const& x() const { return m_x; }
+    UnsignedBigInteger const& y() const { return m_y; }
     size_t scalar_size() const { return m_scalar_size; }
 
     ErrorOr<ByteBuffer> x_bytes() const

Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp

@@ -8141,6 +8141,7 @@ WebIDL::ExceptionOr<GC::Ref<JS::Object>> HMAC::export_key(Bindings::KeyFormat fo
     // 2. Let bits be the raw bits of the key represented by [[handle]] internal slot of key.
     // 3. Let data be an octet string containing bits.
     auto data = key->handle().get<ByteBuffer>();
+    dbgln("DATA {}", data.bytes());
 
     // 4. If format is "raw":
     GC::Ptr<JS::Object> result;

Libraries/LibWeb/Crypto/CryptoBindings.cpp

@@ -85,7 +85,7 @@ JS::ThrowCompletionOr<JsonWebKey> JsonWebKey::parse(JS::Realm& realm, ReadonlyBy
 
 #undef JWK_PARSE_STRING_PROPERTY
 
-JS::ThrowCompletionOr<GC::Ref<JS::Object>> JsonWebKey::to_object(JS::Realm& realm)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> JsonWebKey::to_object(JS::Realm& realm) const
 {
     auto& vm = realm.vm();
     auto object = JS::Object::create(realm, realm.intrinsics().object_prototype());

Libraries/LibWeb/Crypto/CryptoBindings.h

@@ -43,7 +43,7 @@ struct JsonWebKey {
     Optional<Vector<RsaOtherPrimesInfo>> oth;
     Optional<String> k;
 
-    JS::ThrowCompletionOr<GC::Ref<JS::Object>> to_object(JS::Realm&);
+    JS::ThrowCompletionOr<GC::Ref<JS::Object>> to_object(JS::Realm&) const;
 
     static JS::ThrowCompletionOr<JsonWebKey> parse(JS::Realm& realm, ReadonlyBytes data);
 };

Libraries/LibWeb/Crypto/CryptoKey.cpp

@@ -134,6 +134,7 @@ JS_DEFINE_NATIVE_FUNCTION(CryptoKeyPair::private_key_getter)
     return TRY(Bindings::throw_dom_exception_if_needed(vm, [&] { return impl->private_key(); }));
 }
 
+// https://w3c.github.io/webcrypto/#cryptokey-interface-serializable
 WebIDL::ExceptionOr<void> CryptoKey::serialization_steps(HTML::SerializationRecord& serialized, bool for_storage, HTML::SerializationMemory& memory)
 {
     auto& vm = this->vm();
@@ -144,19 +145,58 @@ WebIDL::ExceptionOr<void> CryptoKey::serialization_steps(HTML::SerializationReco
     // 2. Set serialized.[[Extractable]] to the [[extractable]] internal slot of value.
     HTML::serialize_primitive_type(serialized, m_extractable);
 
+    dbgln("PRE SERIALIZE ALGORITHM");
     // 3. Set serialized.[[Algorithm]] to the sub-serialization of the [[algorithm]] internal slot of value.
     auto serialized_algorithm = TRY(HTML::structured_serialize_internal(vm, m_algorithm, for_storage, memory));
     serialized.extend(move(serialized_algorithm));
+    dbgln("POST SERIALIZE ALGORITHM");
 
     // 4. Set serialized.[[Usages]] to the sub-serialization of the [[usages]] internal slot of value.
     auto serialized_usages = TRY(HTML::structured_serialize_internal(vm, m_usages, for_storage, memory));
     serialized.extend(move(serialized_usages));
 
-    // FIXME: 5. Set serialized.[[Handle]] to the [[handle]] internal slot of value.
+    // 5. Set serialized.[[Handle]] to the [[handle]] internal slot of value.
+    TRY(m_key_data.visit(
+        [&](ByteBuffer const& data) -> WebIDL::ExceptionOr<void> {
+            TRY(HTML::serialize_string(vm, serialized, "bytes"_string));
+            TRY(HTML::serialize_bytes(vm, serialized, data));
+            return {};
+        },
+        [&](Bindings::JsonWebKey const& jwk) -> WebIDL::ExceptionOr<void> {
+            TRY(HTML::serialize_string(vm, serialized, "jwk"_string));
+            auto serialized_jwk = TRY(HTML::structured_serialize_internal(vm, TRY(jwk.to_object(realm())), for_storage, memory));
+            serialized.extend(move(serialized_jwk));
+            return {};
+        },
+        [&](::Crypto::PK::RSAPublicKey const& public_key) -> WebIDL::ExceptionOr<void> {
+            TRY(HTML::serialize_string(vm, serialized, "rsa-pub"_string));
+            auto bytes = TRY_OR_THROW_OOM(vm, public_key.export_as_der());
+            TRY(HTML::serialize_bytes(vm, serialized, bytes));
+            return {};
+        },
+        [&](::Crypto::PK::RSAPrivateKey const& private_key) -> WebIDL::ExceptionOr<void> {
+            TRY(HTML::serialize_string(vm, serialized, "rsa-priv"_string));
+            auto bytes = TRY_OR_THROW_OOM(vm, private_key.export_as_der());
+            TRY(HTML::serialize_bytes(vm, serialized, bytes));
+            return {};
+        },
+        [&](::Crypto::PK::ECPublicKey const& public_key) -> WebIDL::ExceptionOr<void> {
+            TRY(HTML::serialize_string(vm, serialized, "ec-pub"_string));
+            auto bytes = TRY_OR_THROW_OOM(vm, public_key.to_uncompressed());
+            TRY(HTML::serialize_bytes(vm, serialized, bytes));
+            return {};
+        },
+        [&](::Crypto::PK::ECPrivateKey const& private_key) -> WebIDL::ExceptionOr<void> {
+            TRY(HTML::serialize_string(vm, serialized, "ec-priv"_string));
+            auto bytes = TRY_OR_THROW_OOM(vm, private_key.export_as_der());
+            TRY(HTML::serialize_bytes(vm, serialized, bytes));
+            return {};
+        }));
 
     return {};
 }
 
+// https://w3c.github.io/webcrypto/#cryptokey-interface-serializable
 WebIDL::ExceptionOr<void> CryptoKey::deserialization_steps(ReadonlySpan<u32> const& serialized, size_t& position, HTML::DeserializationMemory& memory)
 {
     auto& vm = this->vm();
@@ -169,18 +209,44 @@ WebIDL::ExceptionOr<void> CryptoKey::deserialization_steps(ReadonlySpan<u32> con
     m_extractable = HTML::deserialize_primitive_type<bool>(serialized, position);
 
     // 3. Initialize the [[algorithm]] internal slot of value to the sub-deserialization of serialized.[[Algorithm]].
+    dbgln("PRE DESERIALIZE ALGORITHM");
     auto deserialized_record = TRY(HTML::structured_deserialize_internal(vm, serialized, realm, memory, position));
     if (deserialized_record.value.has_value())
         m_algorithm = deserialized_record.value.release_value().as_object();
     position = deserialized_record.position;
+    dbgln("POST DESERIALIZE ALGORITHM: {}", m_algorithm);
 
     // 4. Initialize the [[usages]] internal slot of value to the sub-deserialization of serialized.[[Usages]].
     deserialized_record = TRY(HTML::structured_deserialize_internal(vm, serialized, realm, memory, position));
     if (deserialized_record.value.has_value())
         m_usages = deserialized_record.value.release_value().as_object();
     position = deserialized_record.position;
 
-    // FIXME: 5. Initialize the [[handle]] internal slot of value to serialized.[[Handle]].
+    // 5. Initialize the [[handle]] internal slot of value to serialized.[[Handle]].
+    auto deserialized_key_data_type = TRY(HTML::deserialize_string(vm, serialized, position));
+    if (deserialized_key_data_type == "bytes") {
+        m_key_data = TRY(HTML::deserialize_bytes(vm, serialized, position));
+    } else if (deserialized_key_data_type == "jwk") {
+        VERIFY_NOT_REACHED();
+    } else if (deserialized_key_data_type == "rsa-pub") {
+        auto bytes = TRY(HTML::deserialize_bytes(vm, serialized, position));
+        auto key_pair = MUST(::Crypto::PK::RSA::parse_rsa_key(bytes, false, {}));
+        m_key_data = key_pair.public_key;
+    } else if (deserialized_key_data_type == "rsa-priv") {
+        auto bytes = TRY(HTML::deserialize_bytes(vm, serialized, position));
+        auto key_pair = MUST(::Crypto::PK::RSA::parse_rsa_key(bytes, true, {}));
+        m_key_data = key_pair.private_key;
+    } else if (deserialized_key_data_type == "ec-pub") {
+        auto bytes = TRY(HTML::deserialize_bytes(vm, serialized, position));
+        auto key_pair = MUST(::Crypto::PK::EC::parse_ec_key(bytes, false, {}));
+        m_key_data = key_pair.public_key;
+    } else if (deserialized_key_data_type == "ec-priv") {
+        auto bytes = TRY(HTML::deserialize_bytes(vm, serialized, position));
+        auto key_pair = MUST(::Crypto::PK::EC::parse_ec_key(bytes, true, {}));
+        m_key_data = key_pair.private_key;
+    } else {
+        VERIFY_NOT_REACHED();
+    }
 
     return {};
 }

Libraries/LibWeb/Crypto/SubtleCrypto.cpp

@@ -448,6 +448,7 @@ GC::Ref<WebIDL::Promise> SubtleCrypto::export_key(Bindings::KeyFormat format, GC
         // 5. If the name member of the [[algorithm]] internal slot of key does not identify a registered algorithm that supports the export key operation,
         //    then throw a NotSupportedError.
         // Note: Handled by the base AlgorithmMethods implementation
+        dbgln("EXPORT: {}", key->algorithm()->class_name());
         auto& algorithm = as<KeyAlgorithm>(*key->algorithm());
         // FIXME: Stash the AlgorithmMethods on the KeyAlgorithm
         auto normalized_algorithm_or_error = normalize_an_algorithm(realm, algorithm.name(), "exportKey"_string);

Libraries/LibWeb/HTML/StructuredSerialize.cpp

@@ -320,6 +320,7 @@ class Serializer {
 
         // 19. Otherwise, if value is a platform object that is a serializable object:
         else if (value.is_object() && is<Bindings::Serializable>(value.as_object())) {
+            dbgln("SERIALIZE {}", value.as_object().class_name());
             auto& serializable = dynamic_cast<Bindings::Serializable&>(value.as_object());
 
             // FIXME: 1. If value has a [[Detached]] internal slot whose value is true, then throw a "DataCloneError" DOMException.
@@ -349,6 +350,8 @@ class Serializer {
 
         // 24. Otherwise:
         else {
+dbgln("OTHERWISE {}",value.as_object().class_name() );
+
             // 1. Set serialized to { [[Type]]: "Object", [[Properties]]: a new empty List }.
             serialize_enum(m_serialized, ValueTag::Object);
 
@@ -530,6 +533,11 @@ WebIDL::ExceptionOr<void> serialize_reg_exp_object(JS::VM& vm, SerializationReco
     return {};
 }
 
+WebIDL::ExceptionOr<void> serialize_unsigned_big_integer(JS::VM& vm, Vector<u32>& vector, ::Crypto::UnsignedBigInteger const& bigint)
+{
+    return serialize_string(vm, vector, TRY_OR_THROW_OOM(vm, bigint.to_base(10)));
+}
+
 WebIDL::ExceptionOr<void> serialize_bytes(JS::VM& vm, Vector<u32>& vector, ReadonlyBytes bytes)
 {
     // Append size of the buffer to the serialized structure.
@@ -716,6 +724,7 @@ class Deserializer {
     WebIDL::ExceptionOr<JS::Value> deserialize()
     {
         auto tag = deserialize_primitive_type<ValueTag>(m_serialized, m_position);
+        dbgln("DESERIALIZE TAG: {}", static_cast<u32>(tag));
 
         // 2. If memory[serialized] exists, then return memory[serialized].
         if (tag == ValueTag::ObjectReference) {

Libraries/LibWeb/HTML/StructuredSerialize.h

@@ -16,6 +16,7 @@
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/StructuredSerializeTypes.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
+#include <LibCrypto/BigInt/UnsignedBigInteger.h>
 
 // Structured serialize is an entirely different format from IPC because:
 // - It contains representation of type information
@@ -91,6 +92,7 @@ void serialize_enum(SerializationRecord& serialized, T value)
     serialize_primitive_type<UnderlyingType<T>>(serialized, to_underlying(value));
 }
 
+WebIDL::ExceptionOr<void> serialize_unsigned_big_integer(JS::VM& vm, Vector<u32>& vector, ::Crypto::UnsignedBigInteger const& bigint);
 WebIDL::ExceptionOr<void> serialize_bytes(JS::VM& vm, Vector<u32>& vector, ReadonlyBytes bytes);
 WebIDL::ExceptionOr<void> serialize_string(JS::VM& vm, Vector<u32>& vector, StringView);
 WebIDL::ExceptionOr<void> serialize_string(JS::VM& vm, Vector<u32>& vector, String const& string);

Tests/LibWeb/Text/expected/Crypto/CryptoKey-serialize.txt

@@ -0,0 +1,6 @@
+AES-GCM kty: true
+AES-GCM key_ops: false
+AES-GCM alg: false
+AES-GCM ext: true
+AES-GCM k: false
+Caught error while running async test: OperationError: unclear key size

Tests/LibWeb/Text/input/Crypto/CryptoKey-serialize.html

@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<script src="../include.js"></script>
+<script>
+  async function prepareDatabase() {
+    const req = window.indexedDB.open("TestDatabase");
+
+    return new Promise((resolve, reject) => {
+      req.onerror = () => {
+        reject(req.error);
+      };
+      req.onupgradeneeded = () => {
+        req.result.createObjectStore("TestObjectStore");
+      };
+      req.onsuccess = () => {
+        resolve(req.result);
+      };
+    })
+  }
+
+  async function awaitRequest(request) {
+    return new Promise((resolve, reject) => {
+      request.onerror = () => {
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+    });
+  }
+
+  asyncTest(async (done) => {
+    for (const [algo, usages] of [
+      [{name: "AES-GCM", length: 256}, ["encrypt", "decrypt"]],
+      [{name: "AES-CBC", length: 256}, ["encrypt", "decrypt"]],
+      [{name: "AES-KW", length: 256}, ["wrapKey", "unwrapKey"]],
+      [{name: "HMAC", hash: {name: "SHA-256"}}, ["sign", "verify"]],
+      [{name: "RSASSA-PKCS1-v1_5", hash: {name: "SHA-256"}}, ["sign", "verify"]],
+      [{name: "ECDSA", namedCurve: "P-256"}, ["sign", "verify"]],
+      [{name: "Ed25519"}, ["sign", "verify"]],
+    ]) {
+      const originalKey = await crypto.subtle.generateKey(algo, true, usages);
+
+      const db = await prepareDatabase()
+
+      const tx = db.transaction("TestObjectStore", "readwrite");
+      const store = tx.objectStore("TestObjectStore");
+      await awaitRequest(store.put(originalKey, "testKey"));
+
+      const serializedKey = await awaitRequest(store.get("testKey"));
+
+      const originalKeyJwk = await crypto.subtle.exportKey("jwk", originalKey);
+
+      try {
+        const serializedKeyJwk = await crypto.subtle.exportKey("jwk", serializedKey);
+
+        for (const key of Object.keys(originalKeyJwk)) {
+          println(`${algo.name} ${key}: ${originalKeyJwk[key] === serializedKeyJwk[key]}`);
+        }
+      } catch (e) {
+        println(`${algo.name}: ${e}`);
+      }
+    }
+
+    done();
+  });
+</script>