Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: crypto rejects shared buffers

orezraey5d608f9904ba
diff --git a/src/browser/js/Local.zig b/src/browser/js/Local.zig
index ec2efc07a..fdd129b8e 100644
--- a/src/browser/js/Local.zig
+++ b/src/browser/js/Local.zig
@@ -801,11 +801,8 @@ fn jsValueToStruct(self: *const Local, comptime T: type, js_val: js.Value) !?T {
if (v8.v8__Value__IsSharedArrayBuffer(js_val.handle)) {
return error.TypeError;
}
- if (js_val.isArrayBufferView()) {
- const view: *const v8.ArrayBufferView = @ptrCast(js_val.handle);
- if (js.arrayBufferIsShared(v8.v8__ArrayBufferView__Buffer(view).?)) {
- return error.TypeError;
- }
+ if (js_val.isArrayBufferView() and !js_val.isBufferSource()) {
+ return error.TypeError;
}
const bytes = (try jsValueToArrayBufferSlice(u8, true, js_val)) orelse return null;
return .{ .bytes = bytes };
diff --git a/src/browser/js/Value.zig b/src/browser/js/Value.zig
index a2ab7fa6f..134c6a196 100644
--- a/src/browser/js/Value.zig
+++ b/src/browser/js/Value.zig
@@ -153,6 +153,20 @@ pub fn isArrayBuffer(self: Value) bool {
return v8.v8__Value__IsArrayBuffer(self.handle);
}
+/// Whether this converts to a WebIDL BufferSource: an ArrayBuffer, or a view
+/// onto one. Without [AllowShared], a SharedArrayBuffer, or a view onto one,
+/// doesn't.
+pub fn isBufferSource(self: Value) bool {
+ if (self.isArrayBuffer()) {
+ return true;
+ }
+ if (!self.isArrayBufferView()) {
+ return false;
+ }
+ const view: *const v8.ArrayBufferView = @ptrCast(self.handle);
+ return !js.arrayBufferIsShared(v8.v8__ArrayBufferView__Buffer(view).?);
+}
+
pub fn taggedOpaque(self: Value) ?TaggedOpaque {
// caller must ensure self.isObject()
return TaggedOpaque.fromObject(@ptrCast(self.handle));
diff --git a/src/browser/tests/crypto.html b/src/browser/tests/crypto.html
index 6171892d1..18f4c6dde 100644
--- a/src/browser/tests/crypto.html
+++ b/src/browser/tests/crypto.html
@@ -2992,3 +2992,95 @@
}, results);
});
</script>
+
+<script id=shared-buffers type=module>
+ const state = await testing.async();
+ const subtle = crypto.subtle;
+ const outcome = async (fn) => {
+ try {
+ const r = await fn();
+ return r instanceof ArrayBuffer ? `bytes:${r.byteLength}` : r instanceof CryptoKey ? "key" : typeof r;
+ } catch (err) {
+ return err.name;
+ }
+ };
+ // None of SubtleCrypto's BufferSource arguments or members is
+ // [AllowShared]: a SharedArrayBuffer, or a view onto one, is a TypeError.
+ const sab = new SharedArrayBuffer(16);
+ const view = new Uint8Array(sab);
+ const data = new Uint8Array(16);
+ const gcm = await subtle.generateKey({ name: "AES-GCM", length: 128 }, false, ["encrypt", "decrypt"]);
+ const kw = await subtle.generateKey({ name: "AES-KW", length: 128 }, false, ["wrapKey", "unwrapKey"]);
+ const hmac = await subtle.generateKey({ name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
+ const hkdf = await subtle.importKey("raw", data, "HKDF", false, ["deriveBits"]);
+ const pbkdf2 = await subtle.importKey("raw", data, "PBKDF2", false, ["deriveBits"]);
+ const iv = new Uint8Array(12);
+ const results = {};
+ for (const [kind, buffer] of [["sab", sab], ["view", view], ["dataView", new DataView(sab)]]) {
+ results[`digest ${kind}`] = await outcome(() => subtle.digest("SHA-256", buffer));
+ results[`encrypt data ${kind}`] = await outcome(() => subtle.encrypt({ name: "AES-GCM", iv }, gcm, buffer));
+ results[`encrypt iv ${kind}`] = await outcome(() => subtle.encrypt({ name: "AES-GCM", iv: buffer }, gcm, data));
+ results[`encrypt aad ${kind}`] = await outcome(() => subtle.encrypt({ name: "AES-GCM", iv, additionalData: buffer }, gcm, data));
+ results[`decrypt data ${kind}`] = await outcome(() => subtle.decrypt({ name: "AES-GCM", iv }, gcm, buffer));
+ results[`sign data ${kind}`] = await outcome(() => subtle.sign("HMAC", hmac, buffer));
+ results[`verify signature ${kind}`] = await outcome(() => subtle.verify("HMAC", hmac, buffer, data));
+ results[`import ${kind}`] = await outcome(() => subtle.importKey("raw", buffer, "AES-GCM", false, ["encrypt"]));
+ results[`unwrap ${kind}`] = await outcome(() => subtle.unwrapKey("raw", buffer, kw, "AES-KW", "AES-GCM", false, ["encrypt"]));
+ results[`hkdf salt ${kind}`] = await outcome(() => subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt: buffer, info: data }, hkdf, 128));
+ results[`pbkdf2 salt ${kind}`] = await outcome(() => subtle.deriveBits({ name: "PBKDF2", hash: "SHA-256", salt: buffer, iterations: 1 }, pbkdf2, 128));
+ }
+ // The same calls with a non-shared buffer.
+ results["digest plain"] = await outcome(() => subtle.digest("SHA-256", data.buffer));
+ results["encrypt plain"] = await outcome(() => subtle.encrypt({ name: "AES-GCM", iv, additionalData: data }, gcm, data));
+ results["import plain"] = await outcome(() => subtle.importKey("raw", data, "AES-GCM", false, ["encrypt"]));
+ // Any view of a non-shared buffer is a BufferSource, whatever its element type.
+ results["digest Uint32Array"] = await outcome(() => subtle.digest("SHA-256", new Uint32Array([1, 2])));
+ results["digest Float64Array"] = await outcome(() => subtle.digest("SHA-256", new Float64Array([1])));
+ results["encrypt Uint16Array"] = await outcome(() => subtle.encrypt({ name: "AES-GCM", iv: new Uint16Array(6) }, gcm, new Uint16Array(8)));
+ results["import Uint16Array"] = await outcome(() => subtle.importKey("raw", new Uint16Array(8), "AES-GCM", false, ["encrypt"]));
+ results["import DataView"] = await outcome(() => subtle.importKey("raw", new DataView(new ArrayBuffer(16)), "AES-GCM", false, ["encrypt"]));
+ results["sign Int32Array"] = await outcome(() => subtle.sign("HMAC", hmac, new Int32Array(3)));
+ // RSA's publicExponent is a BigInteger: a Uint8Array, no other view or buffer.
+ const rsa = (publicExponent) => outcome(() => subtle.generateKey({ name: "RSASSA-PKCS1-v1_5", hash: "SHA-256", modulusLength: 1024, publicExponent }, false, ["sign"]));
+ results["publicExponent Uint8Array"] = await rsa(new Uint8Array([1, 0, 1]));
+ results["publicExponent Uint16Array"] = await rsa(new Uint16Array([1, 1]));
+ results["publicExponent DataView"] = await rsa(new DataView(new Uint8Array([1, 0, 1]).buffer));
+ results["publicExponent ArrayBuffer"] = await rsa(new Uint8Array([1, 0, 1]).buffer);
+ results["publicExponent shared"] = await rsa(new Uint8Array(new SharedArrayBuffer(3)));
+ // A shared keyData is a TypeError of its conversion, before the algorithm.
+ results["import view, unknown algorithm"] = await outcome(() => subtle.importKey("raw", view, "NOPE", false, ["encrypt"]));
+ // getRandomValues' ArrayBufferView isn't [AllowShared] either.
+ const random = (array) => { try { return crypto.getRandomValues(array) === array; } catch (err) { return err.name; } };
+ results["getRandomValues view"] = random(view);
+ results["getRandomValues plain"] = random(new Uint8Array(4));
+
+ const expected = {};
+ for (const kind of ["sab", "view", "dataView"]) {
+ for (const name of ["digest", "encrypt data", "encrypt iv", "encrypt aad", "decrypt data", "sign data",
+ "verify signature", "import", "unwrap", "hkdf salt", "pbkdf2 salt"]) {
+ expected[`${name} ${kind}`] = "TypeError";
+ }
+ }
+ expected["digest plain"] = "bytes:32";
+ expected["encrypt plain"] = "bytes:32";
+ expected["import plain"] = "key";
+ expected["digest Uint32Array"] = "bytes:32";
+ expected["digest Float64Array"] = "bytes:32";
+ expected["encrypt Uint16Array"] = "bytes:32";
+ expected["import Uint16Array"] = "key";
+ expected["import DataView"] = "key";
+ expected["sign Int32Array"] = "bytes:32";
+ expected["publicExponent Uint8Array"] = "object";
+ expected["publicExponent Uint16Array"] = "TypeError";
+ expected["publicExponent DataView"] = "TypeError";
+ expected["publicExponent ArrayBuffer"] = "TypeError";
+ expected["publicExponent shared"] = "TypeError";
+ expected["import view, unknown algorithm"] = "TypeError";
+ expected["getRandomValues view"] = "TypeError";
+ expected["getRandomValues plain"] = true;
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(expected, results);
+ });
+</script>
diff --git a/src/browser/webapi/Crypto.zig b/src/browser/webapi/Crypto.zig
index 9eebd9613..3cdd0a23a 100644
--- a/src/browser/webapi/Crypto.zig
+++ b/src/browser/webapi/Crypto.zig
@@ -31,8 +31,10 @@ pub const init: Crypto = .{};
// TypedArray
fn getRandomValues(_: *const Crypto, js_obj: js.Object, exec: *const js.Execution) !js.Object {
const value = js_obj.toValue();
- if (value.isArrayBufferView() == false) {
- // AllowSharedBufferSource would also take an ArrayBuffer
+ // An ArrayBufferView, not [AllowShared]: a view onto a SharedArrayBuffer
+ // is a TypeError too. (AllowSharedBufferSource below would also take an
+ // ArrayBuffer, or a shared buffer.)
+ if (value.isArrayBufferView() == false or value.isBufferSource() == false) {
return error.InvalidArgument;
}
if (value.isFloat16Array() or value.isFloat32Array() or value.isFloat64Array() or value.isTypedArray() == false) {
diff --git a/src/browser/webapi/SubtleCrypto.zig b/src/browser/webapi/SubtleCrypto.zig
index 17430fae0..6cad24989 100644
--- a/src/browser/webapi/SubtleCrypto.zig
+++ b/src/browser/webapi/SubtleCrypto.zig
@@ -124,7 +124,12 @@ pub fn importKey(
try checkFormat(format, local);
// keyData converts first (a JWK's members are read then), but a buffer's
// bytes are only read after the algorithm is normalized (bufferBytes).
- var key_data = local.jsValueToZig(algorithm.KeyData, key_data_value) catch |err| {
+ // Any ArrayBuffer or view is the BufferSource (a Uint16Array too, which
+ // KeyData's Uint8Array wouldn't take); any other object a JsonWebKey.
+ var key_data: algorithm.KeyData = if (key_data_value.isArrayBuffer() or key_data_value.isArrayBufferView()) blk: {
+ try checkBufferSource(key_data_value, local);
+ break :blk .{ .bytes = .{ .values = &.{} } };
+ } else local.jsValueToZig(algorithm.KeyData, key_data_value) catch |err| {
return algorithm.conversionError(err, local, "keyData is neither a BufferSource nor a JsonWebKey");
};
const algo = try algorithm.Import.fromJs(algo_value, local);
@@ -642,17 +647,20 @@ fn checkFormat(format: []const u8, local: *const js.Local) !void {
/// normalizing runs the page's getters, which can transfer the buffer, and
/// its bytes must then read as the now-empty buffer rather than through a
/// pointer into a moved backing store.
+///
+/// None of SubtleCrypto's BufferSource arguments is [AllowShared]: a
+/// SharedArrayBuffer, or a view onto one, is a TypeError.
fn checkBufferSource(value: js.Value, local: *const js.Local) !void {
- if (!value.isArrayBuffer() and !value.isArrayBufferView()) {
+ if (!value.isBufferSource()) {
return local.typeError("expected an ArrayBuffer or ArrayBufferView");
}
}
fn bufferBytes(value: js.Value, local: *const js.Local) ![]const u8 {
- const buffer = local.jsValueToZig(js.TypedArray(u8), value) catch |err| {
+ const buffer = local.jsValueToZig(js.BufferSource, value) catch |err| {
return algorithm.conversionError(err, local, "expected an ArrayBuffer or ArrayBufferView");
};
- return buffer.values;
+ return buffer.bytes;
}
/// What `cryptBytes` is for, which decides the direction and the usage the key
@@ -813,7 +821,7 @@ const DigestInput = union(enum) {
};
/// Generates a digest of the given data, using the specified hash function.
-pub fn digest(_: *const SubtleCrypto, algo: DigestInput, data: js.TypedArray(u8), exec: *const Execution) !js.Promise {
+pub fn digest(_: *const SubtleCrypto, algo: DigestInput, data: js.BufferSource, exec: *const Execution) !js.Promise {
const local = exec.js.local.?;
const algo_name = algo.name() orelse {
@@ -826,7 +834,7 @@ pub fn digest(_: *const SubtleCrypto, algo: DigestInput, data: js.TypedArray(u8)
const normalized = try std.ascii.allocUpperString(exec.local_arena, algo_name);
const digest_type = crypto.findDigest(normalized) catch return error.NotSupported;
- const bytes = data.values;
+ const bytes = data.bytes;
var out: [crypto.EVP_MAX_MD_SIZE]u8 = undefined;
var out_size: c_uint = 0;
const result = crypto.EVP_Digest(bytes.ptr, bytes.len, &out, &out_size, digest_type, null);
diff --git a/src/browser/webapi/crypto/algorithm.zig b/src/browser/webapi/crypto/algorithm.zig
index d611b39d0..a49e0ca68 100644
--- a/src/browser/webapi/crypto/algorithm.zig
+++ b/src/browser/webapi/crypto/algorithm.zig
@@ -101,7 +101,7 @@ pub const Init = union(enum) {
/// Some organizations are now recommending that it should be 4096.
modulusLength: js.EnforceRange(u32),
name: []const u8,
- publicExponent: js.TypedArray(u8),
+ publicExponent: BigInteger,
};
/// https://developer.mozilla.org/en-US/docs/Web/API/AesKeyGenParams
@@ -359,7 +359,7 @@ fn convert(comptime T: type, value: js.Value, name: []const u8, local: *const js
};
if (member) |m| {
if (comptime isBufferSource(FieldType)) {
- if (!m.isArrayBuffer() and !m.isArrayBufferView()) {
+ if (!m.isBufferSource() or (FieldType == BigInteger and !m.isUint8Array())) {
return local.typeError("algorithm has a missing or invalid member");
}
buffers[i] = m;
@@ -380,10 +380,10 @@ fn convert(comptime T: type, value: js.Value, name: []const u8, local: *const js
inline for (info.field_names, info.field_types, 0..) |field_name, FieldType, i| {
if (comptime isBufferSource(FieldType)) {
if (buffers[i]) |m| {
- const view = local.jsValueToZig(js.TypedArray(u8), m) catch |err| {
+ const buffer = local.jsValueToZig(js.BufferSource, m) catch |err| {
return conversionError(err, local, "algorithm has a missing or invalid member");
};
- @field(out, field_name) = .{ .values = try local.call_arena.dupe(u8, view.values) };
+ @field(out, field_name) = .{ .values = try local.call_arena.dupe(u8, buffer.bytes) };
}
}
}
@@ -392,9 +392,15 @@ fn convert(comptime T: type, value: js.Value, name: []const u8, local: *const js
/// Whether a params member is a BufferSource, copied by `convert`.
fn isBufferSource(comptime FieldType: type) bool {
- return FieldType == js.TypedArray(u8) or FieldType == ?js.TypedArray(u8);
+ return FieldType == js.TypedArray(u8) or FieldType == ?js.TypedArray(u8) or FieldType == BigInteger;
}
+/// A WebIDL BigInteger (RsaHashedKeyGenParams.publicExponent): a Uint8Array,
+/// not another view or a buffer. Read as a BufferSource member is.
+pub const BigInteger = struct {
+ values: []const u8,
+};
+
/// Key material handed to `importKey()`: either a BufferSource (raw/spki/pkcs8)
/// or a JSON Web Key object (jwk). `bytes` is probed first — a JWK is a plain
/// object and won't coerce to a TypedArray.