Lightpanda: the headless browser designed for AI and automation
webapi: sign/verify check the algorithm for every key type
orezraey798fe06b47bc
diff --git a/src/browser/tests/crypto.html b/src/browser/tests/crypto.htmlindex d021f20e7..9c9b14e6a 100644--- a/src/browser/tests/crypto.html+++ b/src/browser/tests/crypto.html@@ -994,6 +994,74 @@});</script>+<script id=sign-verify-names type=module>+ const state = await testing.async();+ const subtle = crypto.subtle;+ const errorName = async (fn) => {+ try {+ await fn();+ return null;+ } catch (err) {+ return err.name;+ }+ };+ const hex = (buf) => Array.from(new Uint8Array(buf), (b) => b.toString(16).padStart(2, "0")).join("");+ const data = new TextEncoder().encode("names");+ const hmac = await subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, true, ["sign", "verify"]);+ const signOnly = await subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, true, ["sign"]);+ const verifyOnly = await subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, true, ["verify"]);+ const aes = await subtle.generateKey({ name: "AES-GCM", length: 128 }, true, ["encrypt"]);+ const ecdsa = await subtle.generateKey({ name: "ECDSA", namedCurve: "P-256" }, true, ["sign", "verify"]);+ const ecdh = await subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);+ const x25519 = await subtle.generateKey({ name: "X25519" }, true, ["deriveBits"]);+ const ecdsaAlgo = { name: "ECDSA", hash: "SHA-256" };++ const mac = await subtle.sign("HMAC", hmac, data);+ const results = {+ // Algorithm names match case-insensitively, for HMAC as for RSA.+ lowerSign: hex(await subtle.sign("hmac", hmac, data)),+ mixedVerify: await subtle.verify({ name: "hMaC" }, hmac, mac, data),+ // A name that isn't a signing algorithm is NotSupportedError, whatever the key.+ prefixSign: await errorName(() => subtle.sign("HMACX", hmac, data)),+ prefixVerify: await errorName(() => subtle.verify("HMAC-SHA256", hmac, mac, data)),+ unknownOnEcdsa: await errorName(() => subtle.sign("foo", ecdsa.privateKey, data)),+ ecdhName: await errorName(() => subtle.sign("ECDH", ecdh.privateKey, data)),+ x25519Name: await errorName(() => subtle.sign("X25519", x25519.privateKey, data)),+ aesName: await errorName(() => subtle.sign("AES-GCM", aes, data)),+ // A signing algorithm other than the key's, or a key without the usage,+ // is InvalidAccessError.+ hmacOnAes: await errorName(() => subtle.sign("HMAC", aes, data)),+ hmacOnEcdsa: await errorName(() => subtle.sign("HMAC", ecdsa.privateKey, data)),+ ecdsaOnHmac: await errorName(() => subtle.verify(ecdsaAlgo, hmac, mac, data)),+ noSign: await errorName(() => subtle.sign("HMAC", verifyOnly, data)),+ noVerify: await errorName(() => subtle.verify("HMAC", signOnly, mac, data)),+ ecdsaPublicSign: await errorName(() => subtle.sign(ecdsaAlgo, ecdsa.publicKey, data)),+ // ECDSA signing isn't implemented yet.+ ecdsaSign: await errorName(() => subtle.sign(ecdsaAlgo, ecdsa.privateKey, data)),+ ecdsaVerify: await errorName(() => subtle.verify(ecdsaAlgo, ecdsa.publicKey, new Uint8Array(64), data)),+ };++ state.resolve();+ await state.done(() => {+ testing.expectEqual(hex(mac), results.lowerSign);+ testing.expectEqual(true, results.mixedVerify);+ testing.expectEqual("NotSupportedError", results.prefixSign);+ testing.expectEqual("NotSupportedError", results.prefixVerify);+ testing.expectEqual("NotSupportedError", results.unknownOnEcdsa);+ testing.expectEqual("NotSupportedError", results.ecdhName);+ testing.expectEqual("NotSupportedError", results.x25519Name);+ testing.expectEqual("NotSupportedError", results.aesName);+ testing.expectEqual("InvalidAccessError", results.hmacOnAes);+ testing.expectEqual("InvalidAccessError", results.hmacOnEcdsa);+ testing.expectEqual("InvalidAccessError", results.ecdsaOnHmac);+ testing.expectEqual("InvalidAccessError", results.noSign);+ testing.expectEqual("InvalidAccessError", results.noVerify);+ testing.expectEqual("InvalidAccessError", results.ecdsaPublicSign);+ testing.expectEqual("NotSupportedError", results.ecdsaSign);+ testing.expectEqual("NotSupportedError", results.ecdsaVerify);+ });+</script>+<script>// helper: runs generateKey and captures the rejection's error name (or null// if it unexpectedly resolved). Returns { algo, expected, actual } so thediff --git a/src/browser/webapi/CryptoKey.zig b/src/browser/webapi/CryptoKey.zigindex 343f62b02..a031acf8a 100644--- a/src/browser/webapi/CryptoKey.zig+++ b/src/browser/webapi/CryptoKey.zig@@ -137,14 +137,6 @@ pub fn acquireRef(self: *CryptoKey) void {self._rc.acquire();}-pub fn canSign(self: *const CryptoKey) bool {- return self._usages & Usages.sign != 0;-}--pub fn canVerify(self: *const CryptoKey) bool {- return self._usages & Usages.verify != 0;-}-pub fn canDeriveBits(self: *const CryptoKey) bool {return self._usages & Usages.deriveBits != 0;}diff --git a/src/browser/webapi/SubtleCrypto.zig b/src/browser/webapi/SubtleCrypto.zigindex b75295070..e6dbd7897 100644--- a/src/browser/webapi/SubtleCrypto.zig+++ b/src/browser/webapi/SubtleCrypto.zig@@ -652,18 +652,17 @@ pub fn sign(exec: *const Execution,) !js.Promise {const local = exec.js.local.?;- switch (key._type) {- // Call sign for HMAC.- .hmac => return HMAC.sign(algo, key, data, exec),- .rsa => {- try checkSigningKey(algo, key, CryptoKey.Usages.sign);- return local.resolvePromise(js.ArrayBuffer{ .values = try RSA.sign(key, data, exec) });- },+ try checkSigningKey(algo, key, CryptoKey.Usages.sign);+ const signature = switch (key._type) {+ .hmac => try HMAC.sign(key, data, exec),+ .rsa => try RSA.sign(key, data, exec),+ // A signing algorithm with no sign here yet (ECDSA).else => {log.debug(.not_implemented, "SubtleCrypto.sign", .{ .key_type = key._type });- return error.InvalidAccessError;+ return error.NotSupported;},- }+ };+ return local.resolvePromise(js.ArrayBuffer{ .values = signature });}/// Verify a digital signature.@@ -676,24 +675,23 @@ pub fn verify(exec: *const Execution,) !js.Promise {const local = exec.js.local.?;- switch (key._type) {- .hmac => {- if (!algo.isHMAC()) {- return error.InvalidAccessError;- }- return HMAC.verify(key, signature, data, exec);- },- .rsa => {- try checkSigningKey(algo, key, CryptoKey.Usages.verify);- return local.resolvePromise(try RSA.verify(key, signature, data));+ try checkSigningKey(algo, key, CryptoKey.Usages.verify);+ const valid = switch (key._type) {+ .hmac => try HMAC.verify(key, signature, data),+ .rsa => try RSA.verify(key, signature, data),+ // A signing algorithm with no verify here yet (ECDSA).+ else => {+ log.debug(.not_implemented, "SubtleCrypto.verify", .{ .key_type = key._type });+ return error.NotSupported;},- else => return error.InvalidAccessError,- }+ };+ return local.resolvePromise(valid);}/// The checks sign/verify make before the algorithm's own, in the spec's/// order: an algorithm that signs (else NotSupported), the key's own algorithm,-/// and the sign or verify usage (else InvalidAccessError).+/// and the sign or verify usage (else InvalidAccessError). The names match+/// case-insensitively, as algorithm normalization does.fn checkSigningKey(algo: algorithm.Sign, key: *const CryptoKey, usage: u8) !void {const name = algo.algoName();const signing = [_][]const u8{ "HMAC", "RSASSA-PKCS1-v1_5", "RSA-PSS", "ECDSA", "Ed25519", "Ed448" };diff --git a/src/browser/webapi/crypto/HMAC.zig b/src/browser/webapi/crypto/HMAC.zigindex dd0a25dbc..afd24d6c7 100644--- a/src/browser/webapi/crypto/HMAC.zig+++ b/src/browser/webapi/crypto/HMAC.zig@@ -159,77 +159,37 @@ pub fn import(return local.resolvePromise(crypto_key);}-pub fn sign(- algo: algorithm.Sign,- crypto_key: *const CryptoKey,- data: []const u8,- exec: *const Execution,-) !js.Promise {- var resolver = exec.js.local.?.createPromiseResolver();-- if (!algo.isHMAC() or !crypto_key.canSign()) {- resolver.rejectError("HMAC.sign", .{ .dom_exception = .{ .err = error.InvalidAccessError } });- return resolver.promise();- }-+/// The MAC of `data` with the key. SubtleCrypto.sign checked the algorithm+/// and the sign usage.+pub fn sign(crypto_key: *const CryptoKey, data: []const u8, exec: *const Execution) ![]const u8 {const buffer = try exec.local_arena.alloc(u8, crypto.EVP_MD_size(crypto_key.getDigest()));- var out_len: u32 = 0;- // Try to sign.- _ = crypto.HMAC(- crypto_key.getDigest(),- @ptrCast(crypto_key._key.ptr),- crypto_key._key.len,- data.ptr,- data.len,- buffer.ptr,- &out_len,- ) orelse {- // Failure.- resolver.rejectError("HMAC.sign", .{ .dom_exception = .{ .err = error.InvalidAccessError } });- return resolver.promise();- };-- // Success.- resolver.resolve("HMAC.sign", js.ArrayBuffer{ .values = buffer[0..out_len] });- return resolver.promise();+ return compute(crypto_key, data, buffer);}-pub fn verify(- crypto_key: *const CryptoKey,- signature: []const u8,- data: []const u8,- exec: *const Execution,-) !js.Promise {- var resolver = exec.js.local.?.createPromiseResolver();-- if (!crypto_key.canVerify()) {- resolver.rejectError("HMAC.verify", .{ .dom_exception = .{ .err = error.InvalidAccessError } });- return resolver.promise();+/// Whether `signature` is the MAC of `data` with the key. SubtleCrypto.verify+/// checked the algorithm and the verify usage.+pub fn verify(crypto_key: *const CryptoKey, signature: []const u8, data: []const u8) !bool {+ var buffer: [crypto.EVP_MAX_MD_SIZE]u8 = undefined;+ const mac = try compute(crypto_key, data, &buffer);+ // Check that lengths match; CRYPTO_memcmp can't cover this.+ if (signature.len != mac.len) {+ return false;}+ // CRYPTO_memcmp compare in constant time so prohibits time-based attacks.+ return crypto.CRYPTO_memcmp(mac.ptr, signature.ptr, signature.len) == 0;+}- var buffer: [crypto.EVP_MAX_MD_BLOCK_SIZE]u8 = undefined;- var out_len: u32 = 0;- // Try to sign.- const signed = crypto.HMAC(+/// The MAC of `data`, written to `out` (at least the digest's size).+fn compute(crypto_key: *const CryptoKey, data: []const u8, out: []u8) ![]const u8 {+ var out_len: c_uint = 0;+ _ = crypto.HMAC(crypto_key.getDigest(),@ptrCast(crypto_key._key.ptr),crypto_key._key.len,data.ptr,data.len,- &buffer,+ out.ptr,&out_len,- ) orelse {- resolver.resolve("HMAC.verify", false);- return resolver.promise();- };- // Check that lengths match; CRYPTO_memcmp can't cover this.- if (@as(u32, @intCast(signature.len)) != out_len) {- resolver.resolve("HMAC.verify", false);- return resolver.promise();- }-- // CRYPTO_memcmp compare in constant time so prohibits time-based attacks.- const res = crypto.CRYPTO_memcmp(signed, @ptrCast(signature.ptr), signature.len);- resolver.resolve("HMAC.verify", res == 0);- return resolver.promise();+ ) orelse return error.OperationError;+ return out[0..out_len];}diff --git a/src/browser/webapi/crypto/algorithm.zig b/src/browser/webapi/crypto/algorithm.zigindex b6dfe7025..d1f9f644b 100644--- a/src/browser/webapi/crypto/algorithm.zig+++ b/src/browser/webapi/crypto/algorithm.zig@@ -232,12 +232,4 @@ pub const Sign = union(enum) {.object => |object| object.name,};}-- pub fn isHMAC(self: Sign) bool {- const name = self.algoName();-- if (name.len < 4) return false;- const hmac: u32 = @bitCast([4]u8{ 'H', 'M', 'A', 'C' });- return @as(u32, @bitCast(name[0..4].*)) == hmac;- }};