Skip to content

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.html
index 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 the
diff --git a/src/browser/webapi/CryptoKey.zig b/src/browser/webapi/CryptoKey.zig
index 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.zig
index 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.zig
index 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.zig
index 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;
- }
};