Lightpanda: the headless browser designed for AI and automation
webapi: CryptoKey is serializable
orezraeyc8ae92c6431a
diff --git a/src/browser/js/Value.zig b/src/browser/js/Value.zigindex 0f4c0300c..c8f5cbdb1 100644--- a/src/browser/js/Value.zig+++ b/src/browser/js/Value.zig@@ -529,6 +529,7 @@ const cloneable_types = .{@import("../webapi/webcodecs/encoded_chunk.zig").EncodedVideoChunk,@import("../webapi/webcodecs/AudioData.zig"),@import("../webapi/webcodecs/VideoFrame.zig"),+ @import("../webapi/CryptoKey.zig"),};comptime {diff --git a/src/browser/tests/crypto-worker.js b/src/browser/tests/crypto-worker.jsindex 90d948d0d..0784aab99 100644--- a/src/browser/tests/crypto-worker.js+++ b/src/browser/tests/crypto-worker.js@@ -72,6 +72,22 @@ self.onmessage = async function(e) {return;}+ if (cmd.kind === 'posted-keys') {+ const es256 = { name: 'ECDSA', hash: 'SHA-256' };+ const signature = await crypto.subtle.sign(es256, cmd.privateKey, cmd.data);+ const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign', 'verify']);+ const theirs = await crypto.subtle.sign(es256, pair.privateKey, cmd.data);+ postMessage({+ ok: true,+ type: cmd.privateKey.type,+ extractable: cmd.privateKey.extractable,+ signature,+ publicKey: pair.publicKey,+ theirs,+ });+ return;+ }+if (cmd.kind === 'generateKey-rejection') {let err_name = null;try {diff --git a/src/browser/tests/crypto.html b/src/browser/tests/crypto.htmlindex fc438dc45..6ff6091b9 100644--- a/src/browser/tests/crypto.html+++ b/src/browser/tests/crypto.html@@ -2767,11 +2767,11 @@// Helper for worker-based crypto tests. Spawns a worker, waits for it to// signal readiness, then sends `kind` and forwards the worker's reply to// `state.resolve`. Avoids racing worker startup, which matters on slow CI.- window.runCryptoInWorker = function(kind, state) {+ window.runCryptoInWorker = function(kind, state, extra = {}) {const worker = new Worker('./crypto-worker.js');worker.onmessage = (e) => {if (e.data && e.data.ready) {- worker.postMessage({ kind });+ worker.postMessage({ kind, ...extra });return;}state.resolve(e.data);@@ -3169,3 +3169,110 @@testing.expectEqual(expected, results);});</script>++<script id=crypto-key-serialization type=module>+ const state = await testing.async();+ const subtle = crypto.subtle;+ const hex = (buffer) => Array.from(new Uint8Array(buffer), (b) => b.toString(16).padStart(2, "0")).join("");+ const exported = async (key, format) => format === "jwk"+ ? JSON.stringify(await subtle.exportKey("jwk", key))+ : hex(await subtle.exportKey(format, key));+ const data = new Uint8Array([1, 2, 3]);+ const results = {};++ // A clone keeps every slot of the key and its material.+ const same = async (label, key, format) => {+ const clone = structuredClone(key);+ results[label] = clone !== key && clone instanceof CryptoKey+ && clone.type === key.type && clone.extractable === key.extractable+ && JSON.stringify(clone.algorithm) === JSON.stringify(key.algorithm)+ && clone.usages.join() === key.usages.join()+ && (await exported(clone, format)) === (await exported(key, format));+ };+ await same("aes-gcm", await subtle.generateKey({ name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]), "raw");+ await same("aes-kw", await subtle.generateKey({ name: "AES-KW", length: 128 }, true, ["wrapKey"]), "raw");+ // A length that doesn't fill the last byte is kept (Chrome 152 clones this+ // key as null).+ await same("hmac", await subtle.generateKey({ name: "HMAC", hash: "SHA-384", length: 100 }, true, ["sign"]), "jwk");+ const ec = await subtle.generateKey({ name: "ECDSA", namedCurve: "P-384" }, true, ["sign", "verify"]);+ await same("ecdsa public", ec.publicKey, "spki");+ await same("ecdsa private", ec.privateKey, "pkcs8");+ const ecdh = await subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);+ await same("ecdh public", ecdh.publicKey, "raw");+ await same("ecdh private", ecdh.privateKey, "jwk");+ const rsa = await subtle.generateKey({ name: "RSA-PSS", hash: "SHA-256", modulusLength: 1024, publicExponent: new Uint8Array([1, 0, 1]) }, true, ["sign", "verify"]);+ await same("rsa public", rsa.publicKey, "jwk");+ await same("rsa private", rsa.privateKey, "pkcs8");+ const ed = await subtle.generateKey("Ed25519", true, ["sign", "verify"]);+ await same("ed25519 public", ed.publicKey, "raw");+ await same("ed25519 private", ed.privateKey, "pkcs8");+ const x = await subtle.generateKey("X25519", true, ["deriveBits"]);+ await same("x25519 public", x.publicKey, "raw");+ await same("x25519 private", x.privateKey, "pkcs8");++ // A non-extractable key clones too, and the clone works like it.+ const hmac = await subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);+ const hmacClone = structuredClone(hmac);+ results["locked hmac"] = hmacClone.extractable === false+ && hex(await subtle.sign("HMAC", hmacClone, data)) === hex(await subtle.sign("HMAC", hmac, data));+ const signer = await subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, false, ["sign", "verify"]);+ const { privateKey, publicKey } = structuredClone({ privateKey: signer.privateKey, publicKey: signer.publicKey });+ const es256 = { name: "ECDSA", hash: "SHA-256" };+ results["locked ecdsa"] = await subtle.verify(es256, signer.publicKey, await subtle.sign(es256, privateKey, data), data)+ && await subtle.verify(es256, publicKey, await subtle.sign(es256, signer.privateKey, data), data);+ results["locked export"] = await subtle.exportKey("pkcs8", privateKey).then(() => "exported", (e) => e.name);+ const hkdf = await subtle.importKey("raw", new Uint8Array(16), "HKDF", false, ["deriveBits"]);+ const derive = (key) => subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt: data, info: data }, key, 128);+ results["hkdf"] = hex(await derive(structuredClone(hkdf))) === hex(await derive(hkdf));+ // One key reached twice clones to one object.+ const twice = structuredClone([hmac, hmac]);+ results["one clone"] = twice[0] === twice[1];++ state.resolve();+ await state.done(() => {+ testing.expectEqual({+ "aes-gcm": true,+ "aes-kw": true,+ "hmac": true,+ "ecdsa public": true,+ "ecdsa private": true,+ "ecdh public": true,+ "ecdh private": true,+ "rsa public": true,+ "rsa private": true,+ "ed25519 public": true,+ "ed25519 private": true,+ "x25519 public": true,+ "x25519 private": true,+ "locked hmac": true,+ "locked ecdsa": true,+ "locked export": "InvalidAccessError",+ "hkdf": true,+ "one clone": true,+ }, results);+ });+</script>++<script id=worker-posted-keys type=module>+ {+ // A non-extractable key posted to a worker signs there, and the worker+ // posts back a key of its own.+ const state = await testing.async();+ const subtle = crypto.subtle;+ const es256 = { name: 'ECDSA', hash: 'SHA-256' };+ const data = new Uint8Array([7, 8, 9]);+ const pair = await subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign', 'verify']);+ runCryptoInWorker('posted-keys', state, { privateKey: pair.privateKey, data });+ const got = await state.promise;+ const signedThere = got.ok && await subtle.verify(es256, pair.publicKey, got.signature, data);+ const keyFromThere = got.ok && got.publicKey instanceof CryptoKey+ && await subtle.verify(es256, got.publicKey, got.theirs, data);+ await state.done((got) => {+ testing.expectTrue(got.ok);+ testing.expectEqual('private', got.type);+ testing.expectEqual(false, got.extractable);+ testing.expectEqual(true, signedThere);+ testing.expectEqual(true, keyFromThere);+ });+ }+</script>diff --git a/src/browser/tests/indexeddb.html b/src/browser/tests/indexeddb.htmlindex 105597832..764fd2d39 100644--- a/src/browser/tests/indexeddb.html+++ b/src/browser/tests/indexeddb.html@@ -1542,4 +1542,42 @@});}</script>++<!-- A CryptoKey is serializable: a DPoP client keeps its non-extractable key+ pair in IndexedDB and signs with it after reading it back. -->+<script id="crypto_key_pair" type=module>+{+ const state = await testing.async();+ const subtle = crypto.subtle;+ const es256 = { name: "ECDSA", hash: "SHA-256" };+ const data = new Uint8Array([4, 5, 6]);+ const pair = await subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, false, ["sign", "verify"]);+ const req = indexedDB.open("keys-db", 1);+ req.onupgradeneeded = (e) => e.target.result.createObjectStore("keys");+ req.onsuccess = (e) => {+ const store = e.target.result.transaction("keys", "readwrite").objectStore("keys");+ store.put(pair, "dpop");+ const getReq = store.get("dpop");+ getReq.onsuccess = async () => {+ const stored = getReq.result;+ state.resolve({+ privateType: stored.privateKey.type,+ privateExtractable: stored.privateKey.extractable,+ curve: stored.publicKey.algorithm.namedCurve,+ signedByCopy: await subtle.verify(es256, pair.publicKey, await subtle.sign(es256, stored.privateKey, data), data),+ verifiedByCopy: await subtle.verify(es256, stored.publicKey, await subtle.sign(es256, pair.privateKey, data), data),+ });+ };+ };+ await state.done((got) => {+ testing.expectEqual({+ privateType: "private",+ privateExtractable: false,+ curve: "P-256",+ signedByCopy: true,+ verifiedByCopy: true,+ }, got);+ });+}+</script></body>diff --git a/src/browser/webapi/CryptoKey.zig b/src/browser/webapi/CryptoKey.zigindex b0491e6a3..fe3e5c7ef 100644--- a/src/browser/webapi/CryptoKey.zig+++ b/src/browser/webapi/CryptoKey.zig@@ -16,11 +16,13 @@// You should have received a copy of the GNU Affero General Public License// along with this program. If not, see <https://www.gnu.org/licenses/>.+const std = @import("std");const lp = @import("lightpanda");const crypto = @import("../../sys/libcrypto.zig");const js = @import("../js/js.zig");const Page = @import("../Page.zig");+const common = @import("crypto/common.zig");const Execution = js.Execution;@@ -131,6 +133,108 @@ pub fn deinit(self: *CryptoKey, _: *Page) void {self._arena.release();}+/// A CryptoKey is serializable (structuredClone, postMessage, IndexedDB):+/// its internal slots are written out, and its material as bytes: a secret+/// key's, or an EVP_PKEY's SPKI (public) or PKCS#8 (private) DER. An HMAC+/// key's digest is found again from its hash.+pub fn structuredSerialize(self: *const CryptoKey, writer: *js.StructuredWriter) !void {+ writer.writeUint32(@backingInt(self._type));+ writer.writeUint32(@backingInt(self._kind));+ writer.writeUint32(@intFromBool(self._extractable));+ writer.writeUint32(self._usages);+ writer.writeBytes(self._key);++ const algorithm = self._algorithm;+ writer.writeBytes(algorithm.name);+ writeOptional(writer, algorithm.hash);+ writeOptional(writer, algorithm.named_curve);+ writeOptional(writer, algorithm.modulus_length);+ writeOptional(writer, algorithm.length);+ writeOptional(writer, algorithm.public_exponent);++ switch (self._vary) {+ .pkey => |pkey| {+ const der = common.pkeyDer(pkey, self._kind == .public, writer.local.call_arena) catch return error.DataClone;+ writer.writeBytes(der);+ },+ .none, .digest => writer.writeBytes(""),+ }+}++pub fn structuredDeserialize(reader: *js.StructuredReader, page: *Page) !*CryptoKey {+ const key_type = std.enums.fromInt(Type, try reader.readUint32()) orelse return error.DataClone;+ const kind = std.enums.fromInt(Kind, try reader.readUint32()) orelse return error.DataClone;+ const extractable = try reader.readUint32() != 0;+ const usages: u8 = std.math.cast(u8, try reader.readUint32()) orelse return error.DataClone;++ const arena = try page.getArena(.tiny, "CryptoKey");+ errdefer arena.release();++ const key = try arena.dupe(u8, try reader.readBytes());+ var algorithm: Algorithm = .{ .name = try arena.dupe(u8, try reader.readBytes()) };+ algorithm.hash = try readOptionalBytes(reader, arena);+ algorithm.named_curve = try readOptionalBytes(reader, arena);+ algorithm.modulus_length = try readOptionalUint32(reader);+ algorithm.length = try readOptionalUint32(reader);+ algorithm.public_exponent = try readOptionalBytes(reader, arena);++ const der = try reader.readBytes();+ const vary: @FieldType(CryptoKey, "_vary") = switch (key_type) {+ .rsa, .ec, .ed25519, .x25519 => .{+ .pkey = common.parseDer(if (kind == .public) "spki" else "pkcs8", der) catch return error.DataClone,+ },+ .hmac => .{+ .digest = crypto.findDigest(algorithm.hash orelse return error.DataClone) catch return error.DataClone,+ },+ .aes, .derive => .none,+ };+ errdefer switch (vary) {+ .pkey => |pkey| crypto.EVP_PKEY_free(pkey),+ .none, .digest => {},+ };++ const self = try arena.create(CryptoKey);+ self.* = .{+ ._arena = arena,+ ._type = key_type,+ ._kind = kind,+ ._extractable = extractable,+ ._usages = usages,+ ._key = key,+ ._algorithm = algorithm,+ ._vary = vary,+ };+ return self;+}++/// An optional member: a flag, then the value if there's one.+fn writeOptional(writer: *js.StructuredWriter, value: anytype) void {+ const v = value orelse {+ writer.writeUint32(0);+ return;+ };+ writer.writeUint32(1);+ if (@TypeOf(v) == u32) {+ writer.writeUint32(v);+ } else {+ writer.writeBytes(v);+ }+}++fn readOptionalBytes(reader: *js.StructuredReader, arena: *lp.Arena) !?[]const u8 {+ if (try reader.readUint32() == 0) {+ return null;+ }+ return try arena.dupe(u8, try reader.readBytes());+}++fn readOptionalUint32(reader: *js.StructuredReader) !?u32 {+ if (try reader.readUint32() == 0) {+ return null;+ }+ return try reader.readUint32();+}+pub fn releaseRef(self: *CryptoKey, page: *Page) void {self._rc.release(self, page);}diff --git a/src/browser/webapi/crypto/common.zig b/src/browser/webapi/crypto/common.zigindex 234f5517e..85cff4d79 100644--- a/src/browser/webapi/crypto/common.zig+++ b/src/browser/webapi/crypto/common.zig@@ -222,15 +222,20 @@ pub fn parseDer(format: []const u8, der: []const u8) error{ DataError, NotSuppor/// `pkcs8` for a private one. Asking for the other half's format is/// InvalidAccessError.pub fn exportDer(format: []const u8, key: *const CryptoKey, exec: *const Execution) ![]const u8 {- const pkey = key.getKeyObject();+ const public = std.mem.eql(u8, format, "spki");+ if (key._kind != (if (public) CryptoKey.Kind.public else CryptoKey.Kind.private)) {+ return error.InvalidAccessError;+ }+ return pkeyDer(key.getKeyObject(), public, exec.local_arena);+}+/// `pkey` as DER, in `allocator`: its SPKI if `public`, otherwise its PKCS#8.+pub fn pkeyDer(pkey: *crypto.EVP_PKEY, public: bool, allocator: std.mem.Allocator) ![]const u8 {var out: [*c]u8 = null;const len = blk: {- if (std.mem.eql(u8, format, "spki")) {- if (key._kind != .public) return error.InvalidAccessError;+ if (public) {break :blk crypto.i2d_PUBKEY(pkey, &out);}- if (key._kind != .private) return error.InvalidAccessError;const info = crypto.EVP_PKEY2PKCS8(pkey) orelse return error.OperationError;defer crypto.PKCS8_PRIV_KEY_INFO_free(info);break :blk crypto.i2d_PKCS8_PRIV_KEY_INFO(info, &out);@@ -238,5 +243,5 @@ pub fn exportDer(format: []const u8, key: *const CryptoKey, exec: *const Executidefer crypto.OPENSSL_free(out);if (len <= 0) return error.OperationError;- return exec.local_arena.dupe(u8, out[0..@intCast(len)]);+ return allocator.dupe(u8, out[0..@intCast(len)]);}