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.zigindex 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.zigindex 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.htmlindex 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.zigindex 9eebd9613..3cdd0a23a 100644--- a/src/browser/webapi/Crypto.zig+++ b/src/browser/webapi/Crypto.zig@@ -31,8 +31,10 @@ pub const init: Crypto = .{};// TypedArrayfn 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.zigindex 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.zigindex 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 jsinline 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.