Skip to content

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.zig
index 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.js
index 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.html
index 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.html
index 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.zig
index 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.zig
index 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 Executi
defer 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)]);
}