Skip to content

Lightpanda: the headless browser designed for AI and automation

wpt: improve webcrypto WPT results

Karl Seguinb415cbe9444c
diff --git a/src/browser/js/Caller.zig b/src/browser/js/Caller.zig
index 6bc056b34..4e9deed75 100644
--- a/src/browser/js/Caller.zig
+++ b/src/browser/js/Caller.zig
@@ -605,10 +605,29 @@ fn handleError(comptime T: type, comptime F: type, local: *const Local, err: any
};
};
+ if (comptime returnsPromise(F) and @TypeOf(info) == FunctionCallbackInfo) {
+ // An operation that returns a promise must not throw. It rejects.
+ const resolver = js.PromiseResolver.init(&err_local);
+ resolver.rejectValue(.{ .local = &err_local, .handle = js_err }) catch |reject_err| {
+ log.err(.bug, "handleError reject", .{ .err = reject_err });
+ };
+ info.getReturnValue().set(resolver.promise().toValue());
+ return;
+ }
+
const js_exception = isolate.throwException(js_err);
info.getReturnValue().setValueHandle(js_exception);
}
+fn returnsPromise(comptime F: type) bool {
+ const R = @typeInfo(F).@"fn".return_type orelse return false;
+ const payload = switch (@typeInfo(R)) {
+ .error_union => |eu| eu.payload,
+ else => R,
+ };
+ return payload == js.Promise;
+}
+
// Convert a Zig error to a DOMException. If the error is unknown, return null.
fn domExceptionToJs(local: *const Local, err: anyerror) ?*const v8.Value {
const DOMException = @import("../webapi/DOMException.zig");
diff --git a/src/browser/js/PromiseResolver.zig b/src/browser/js/PromiseResolver.zig
index 287ddd221..d6e9fe571 100644
--- a/src/browser/js/PromiseResolver.zig
+++ b/src/browser/js/PromiseResolver.zig
@@ -108,13 +108,19 @@ pub fn rejectError(
fn _reject(self: PromiseResolver, value: anytype) !void {
const local = self.local;
const js_val = try local.zigValueToJs(value, .{});
+ try self.rejectValue(js_val);
+ local.runMicrotasks();
+}
+/// Rejects with an already-built JS value, without running a microtask
+/// checkpoint. For use while the calling script is still on the stack, where
+/// draining the queue would run unrelated reactions mid-script.
+pub fn rejectValue(self: PromiseResolver, value: js.Value) !void {
var out: v8.MaybeBool = undefined;
- v8.v8__Promise__Resolver__Reject(self.handle, local.handle, js_val.handle, &out);
+ v8.v8__Promise__Resolver__Reject(self.handle, self.local.handle, value.handle, &out);
if (!out.has_value or !out.value) {
return error.FailedToRejectPromise;
}
- local.runMicrotasks();
}
pub fn persist(self: PromiseResolver) !Global {
diff --git a/src/browser/js/bridge.zig b/src/browser/js/bridge.zig
index bd2088395..a49444ff2 100644
--- a/src/browser/js/bridge.zig
+++ b/src/browser/js/bridge.zig
@@ -962,6 +962,7 @@ pub const PageJsApis = flattenTypes(&.{
@import("../webapi/DocumentType.zig"),
@import("../webapi/ShadowRoot.zig"),
@import("../webapi/DOMException.zig"),
+ @import("../webapi/QuotaExceededError.zig"),
@import("../webapi/DOMImplementation.zig"),
@import("../webapi/DOMTreeWalker.zig"),
@import("../webapi/DOMNodeIterator.zig"),
@@ -1229,6 +1230,7 @@ const worker_common_apis = [_]type{
@import("../webapi/event/PromiseRejectionEvent.zig"),
@import("../webapi/event/CloseEvent.zig"),
@import("../webapi/DOMException.zig"),
+ @import("../webapi/QuotaExceededError.zig"),
@import("../webapi/DOMRectReadOnly.zig"),
@import("../webapi/DOMRect.zig"),
@import("../webapi/DOMMatrixReadOnly.zig"),
diff --git a/src/browser/webapi/Crypto.zig b/src/browser/webapi/Crypto.zig
index 714b89543..cdd0a9a26 100644
--- a/src/browser/webapi/Crypto.zig
+++ b/src/browser/webapi/Crypto.zig
@@ -20,6 +20,7 @@ const lp = @import("lightpanda");
const js = @import("../js/js.zig");
const SubtleCrypto = @import("SubtleCrypto.zig");
+const QuotaExceededError = @import("QuotaExceededError.zig");
const Crypto = @This();
_subtle: SubtleCrypto = .{},
@@ -28,11 +29,17 @@ pub const init: Crypto = .{};
// We take a js.Value, because we want to return the same instance, not a new
// TypedArray
-pub fn getRandomValues(_: *const Crypto, js_obj: js.Object) !js.Object {
+pub fn getRandomValues(_: *const Crypto, js_obj: js.Object, exec: *const js.Execution) !js.Object {
+ const value = js_obj.toValue();
+ if (value.isFloat16Array() or value.isFloat32Array() or value.isFloat64Array() or (value.isArrayBufferView() and !value.isTypedArray())) {
+ // only integer TypedArrays are supported
+ return error.TypeMismatch;
+ }
+
var into = try js_obj.toZig(RandomValues);
const buf = into.asBuffer();
if (buf.len > 65_536) {
- return error.QuotaExceeded;
+ return QuotaExceededError.throw(js_obj.local, exec);
}
lp.io.random(buf);
return js_obj;
diff --git a/src/browser/webapi/DOMException.zig b/src/browser/webapi/DOMException.zig
index ab18fa05c..8dd7850dd 100644
--- a/src/browser/webapi/DOMException.zig
+++ b/src/browser/webapi/DOMException.zig
@@ -50,6 +50,7 @@ pub fn fromError(err: anyerror) ?DOMException {
error.InvalidModification => .{ ._code = .invalid_modification_error },
error.NamespaceError => .{ ._code = .namespace_error },
error.InvalidAccess => .{ ._code = .invalid_access_error },
+ error.TypeMismatch => .{ ._code = .type_mismatch_error },
error.SecurityError => .{ ._code = .security_error },
error.NetworkError => .{ ._code = .network_error },
error.AbortError => .{ ._code = .abort_error },
@@ -97,6 +98,7 @@ pub fn getName(self: *const DOMException) []const u8 {
.invalid_modification_error => "InvalidModificationError",
.namespace_error => "NamespaceError",
.invalid_access_error => "InvalidAccessError",
+ .type_mismatch_error => "TypeMismatchError",
.security_error => "SecurityError",
.network_error => "NetworkError",
.abort_error => "AbortError",
@@ -133,6 +135,7 @@ pub fn getMessage(self: *const DOMException) []const u8 {
.invalid_modification_error => "The object can not be modified in this way",
.namespace_error => "The operation is not allowed by Namespaces in XML",
.invalid_access_error => "The object does not support the operation or argument",
+ .type_mismatch_error => "The type of an object was incompatible with the expected type of the parameter associated to the object",
.security_error => "The operation is insecure",
.network_error => "A network error occurred",
.abort_error => "The operation was aborted",
@@ -178,6 +181,7 @@ const Code = enum(u8) {
invalid_modification_error = 13,
namespace_error = 14,
invalid_access_error = 15,
+ type_mismatch_error = 17,
security_error = 18,
network_error = 19,
abort_error = 20,
@@ -216,6 +220,7 @@ const Code = enum(u8) {
.{ "InvalidModificationError", .invalid_modification_error },
.{ "NamespaceError", .namespace_error },
.{ "InvalidAccessError", .invalid_access_error },
+ .{ "TypeMismatchError", .type_mismatch_error },
.{ "SecurityError", .security_error },
.{ "NetworkError", .network_error },
.{ "AbortError", .abort_error },
diff --git a/src/browser/webapi/QuotaExceededError.zig b/src/browser/webapi/QuotaExceededError.zig
new file mode 100644
index 000000000..2b44fb212
--- /dev/null
+++ b/src/browser/webapi/QuotaExceededError.zig
@@ -0,0 +1,88 @@
+// Copyright (C) 2023-2026 Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <[email protected]>
+// Pierre Tachoire <[email protected]>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// 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 js = @import("../js/js.zig");
+
+const DOMException = @import("DOMException.zig");
+
+const Execution = js.Execution;
+
+const QuotaExceededError = @This();
+
+pub const Proto = DOMException;
+
+_proto: *DOMException,
+_quota: ?f64 = null,
+_requested: ?f64 = null,
+
+const Options = struct {
+ quota: ?f64 = null,
+ requested: ?f64 = null,
+};
+
+pub fn init(message_: ?[]const u8, options_: ?Options, exec: *const Execution) !*QuotaExceededError {
+ const opts = options_ orelse Options{};
+ if (opts.quota) |quota| {
+ if (quota < 0) {
+ return error.RangeError;
+ }
+ }
+ if (opts.requested) |requested| {
+ if (requested < 0) {
+ return error.RangeError;
+ }
+ }
+ if (opts.quota != null and opts.requested != null and opts.requested.? < opts.quota.?) {
+ return error.RangeError;
+ }
+
+ const message = if (message_) |m| try exec.dupeString(m) else null;
+ return exec._factory.chained(.{
+ DOMException.init(message, "QuotaExceededError"),
+ QuotaExceededError{ ._proto = undefined, ._quota = opts.quota, ._requested = opts.requested },
+ });
+}
+
+pub fn throw(local: *const js.Local, exec: *const Execution) error{ TryCatchRethrow, OutOfMemory } {
+ const self = init(null, null, exec) catch return error.OutOfMemory;
+ const js_val = local.zigValueToJs(self, .{}) catch return error.OutOfMemory;
+ _ = local.isolate.throwException(js_val.handle);
+ return error.TryCatchRethrow;
+}
+
+pub fn getQuota(self: *const QuotaExceededError) ?f64 {
+ return self._quota;
+}
+
+pub fn getRequested(self: *const QuotaExceededError) ?f64 {
+ return self._requested;
+}
+
+pub const JsApi = struct {
+ pub const bridge = js.Bridge(QuotaExceededError);
+
+ pub const Meta = struct {
+ pub const name = "QuotaExceededError";
+ pub const prototype_chain = bridge.prototypeChain();
+ pub var class_id: bridge.ClassId = undefined;
+ };
+
+ pub const constructor = bridge.constructor(QuotaExceededError.init, .{});
+ pub const quota = bridge.accessor(QuotaExceededError.getQuota, null, .{});
+ pub const requested = bridge.accessor(QuotaExceededError.getRequested, null, .{});
+};
diff --git a/src/browser/webapi/SubtleCrypto.zig b/src/browser/webapi/SubtleCrypto.zig
index 8743aed04..f6b030a9e 100644
--- a/src/browser/webapi/SubtleCrypto.zig
+++ b/src/browser/webapi/SubtleCrypto.zig
@@ -524,10 +524,10 @@ pub fn verify(
/// or an object (`{name: "SHA-256"}`). The object variant must come first — a
/// `[]const u8` coerces *any* JS value to a string, so it has to be the fallback.
const DigestInput = union(enum) {
- obj: struct { name: []const u8 },
+ obj: struct { name: ?[]const u8 = null },
str: []const u8,
- fn name(self: DigestInput) []const u8 {
+ fn name(self: DigestInput) ?[]const u8 {
return switch (self) {
.obj => |o| o.name,
.str => |s| s,
@@ -539,7 +539,9 @@ const DigestInput = union(enum) {
pub fn digest(_: *const SubtleCrypto, algo: DigestInput, data: js.TypedArray(u8), exec: *const Execution) !js.Promise {
const local = exec.js.local.?;
- const algo_name = algo.name();
+ const algo_name = algo.name() orelse {
+ return local.rejectPromise(.{ .type_error = "required member name is undefined" });
+ };
if (algo_name.len > 10) {
return local.rejectPromise(.{ .dom_exception = .{ .err = error.NotSupported } });
}
diff --git a/src/browser/webapi/crypto/HMAC.zig b/src/browser/webapi/crypto/HMAC.zig
index 475b6553b..19f6d51c6 100644
--- a/src/browser/webapi/crypto/HMAC.zig
+++ b/src/browser/webapi/crypto/HMAC.zig
@@ -37,6 +37,11 @@ pub fn init(
exec: *const Execution,
) !js.Promise {
const local = exec.js.local.?;
+ // The union probe match to get here is pretty simple, so we can end up here
+ // for an unknown/invalid algo.
+ if (!std.ascii.eqlIgnoreCase(params.name, "HMAC")) {
+ return local.rejectPromise(.{ .dom_exception = .{ .err = error.NotSupported } });
+ }
const hash_name = switch (params.hash) {
.string => |str| str,
.object => |obj| obj.name,
diff --git a/src/browser/webapi/crypto/algorithm.zig b/src/browser/webapi/crypto/algorithm.zig
index aa96c0e53..8eb9404ef 100644
--- a/src/browser/webapi/crypto/algorithm.zig
+++ b/src/browser/webapi/crypto/algorithm.zig
@@ -26,12 +26,13 @@ const CryptoKey = @import("../CryptoKey.zig");
pub const Init = union(enum) {
/// For RSASSA-PKCS1-v1_5, RSA-PSS, or RSA-OAEP: pass an RsaHashedKeyGenParams object.
rsa_hashed_key_gen: RsaHashedKeyGen,
+ /// Must be before `hmac_key_gen`, since we need to ignore this param even
+ /// if it has a 'hash' property, and if it's after, we'll match that instead.
+ ec_key_gen: EcKeyGen,
/// For HMAC: pass an HmacKeyGenParams object.
hmac_key_gen: HmacKeyGen,
/// For AES variants: pass an AesKeyGenParams object.
aes_key_gen: AesKeyGen,
- /// For ECDSA / ECDH: pass an EcKeyGenParams object.
- ec_key_gen: EcKeyGen,
/// don't use []const u8 here, we don't want non-strings coerced. Let those
/// fall to the invalid case