Skip to content

Lightpanda: the headless browser designed for AI and automation

js: a string longer than V8 accepts throws RangeError instead of aborting

Lucien Coffe21fbd47f4bc5
diff --git a/src/browser/js/Caller.zig b/src/browser/js/Caller.zig
index 1e7f27e52..9dc1f5a18 100644
--- a/src/browser/js/Caller.zig
+++ b/src/browser/js/Caller.zig
@@ -615,6 +615,7 @@ fn handleError(comptime T: type, comptime F: type, local: *const Local, err: any
error.InvalidArgument => isolate.createTypeError("invalid argument"),
error.TypeError => isolate.createTypeError(message),
error.RangeError => isolate.createRangeError(""),
+ error.InvalidStringLength => isolate.createRangeError("Invalid string length"),
error.OutOfMemory => isolate.createError("out of memory"),
error.IllegalConstructor => isolate.createError("Illegal Constructor"),
error.TryCatchRethrow, error.JsException => unreachable, // early exited a few lines up
diff --git a/src/browser/js/Context.zig b/src/browser/js/Context.zig
index 1e64fb9d3..a2deaf16a 100644
--- a/src/browser/js/Context.zig
+++ b/src/browser/js/Context.zig
@@ -501,7 +501,7 @@ fn compileModule(local: *const js.Local, src: []const u8, name: []const u8) !js.
var source_handle: v8.ScriptCompilerSource = undefined;
v8.v8__ScriptCompiler__Source__CONSTRUCT2(
- local.isolate.initStringHandle(src),
+ try local.isolate.newString(src),
&origin_handle,
null, // cached data
&source_handle,
diff --git a/src/browser/js/Isolate.zig b/src/browser/js/Isolate.zig
index 6324429c5..94a67f374 100644
--- a/src/browser/js/Isolate.zig
+++ b/src/browser/js/Isolate.zig
@@ -16,6 +16,7 @@
// 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 std = @import("std");
const js = @import("js.zig");
const v8 = js.v8;
@@ -71,12 +72,23 @@ pub fn throwException(self: Isolate, value: *const v8.Value) *const v8.Value {
return v8.v8__Isolate__ThrowException(self.handle, value).?;
}
+// For short strings (names, keys, messages). Page or network data goes
+// through newString.
pub fn initStringHandle(self: Isolate, str: []const u8) *const v8.String {
- return v8.v8__String__NewFromUtf8(self.handle, str.ptr, v8.kNormal, @as(c_int, @intCast(str.len))).?;
+ return self.newString(str) catch unreachable;
}
-pub fn initOneByteStringHandle(self: Isolate, bytes: []const u8) *const v8.String {
- return v8.v8__String__NewFromOneByte(self.handle, bytes.ptr, v8.kNormal, @as(c_int, @intCast(bytes.len))).?;
+// Past v8::String::kMaxLength (just under 512 MiB on 64-bit) V8 returns an
+// empty handle; callers turn the error into "RangeError: Invalid string
+// length", as V8 throws for its own over-long strings.
+pub fn newString(self: Isolate, str: []const u8) error{InvalidStringLength}!*const v8.String {
+ const len = std.math.cast(c_int, str.len) orelse return error.InvalidStringLength;
+ return v8.v8__String__NewFromUtf8(self.handle, str.ptr, v8.kNormal, len) orelse error.InvalidStringLength;
+}
+
+pub fn newOneByteString(self: Isolate, bytes: []const u8) error{InvalidStringLength}!*const v8.String {
+ const len = std.math.cast(c_int, bytes.len) orelse return error.InvalidStringLength;
+ return v8.v8__String__NewFromOneByte(self.handle, bytes.ptr, v8.kNormal, len) orelse error.InvalidStringLength;
}
pub fn createError(self: Isolate, msg: []const u8) *const v8.Value {
diff --git a/src/browser/js/Local.zig b/src/browser/js/Local.zig
index ec2efc07a..0dfc30ea6 100644
--- a/src/browser/js/Local.zig
+++ b/src/browser/js/Local.zig
@@ -150,7 +150,7 @@ pub fn compileFunction(
) !js.Function {
// TODO: Make configurable.
const script_name = self.isolate.initStringHandle("anonymous");
- const script_source = if (@TypeOf(src) == js.String) src.handle else self.isolate.initStringHandle(src);
+ const script_source = if (@TypeOf(src) == js.String) src.handle else try self.isolate.newString(src);
var parameter_list: [parameter_names.len]*const v8.String = undefined;
inline for (0..parameter_names.len) |i| {
@@ -205,7 +205,7 @@ const CompileResult = struct {
// compiled and serialized script (see Script.Unbound.createCodeCache)
pub fn compileWithCache(self: *const Local, src: []const u8, name: ?[]const u8, cached_data: ?[]const u8) !CompileResult {
const script_name = self.isolate.initStringHandle(name orelse "anonymous");
- const script_source = self.isolate.initStringHandle(src);
+ const script_source = try self.isolate.newString(src);
// Create ScriptOrigin
var origin: v8.ScriptOrigin = undefined;
@@ -355,7 +355,7 @@ pub fn zigValueToJs(self: *const Local, value: anytype, comptime opts: CallOpts)
// Check if it's a "simple" type. This is extracted so that it can be
// reused by other parts of the code. "simple" types only require an
// isolate to create (specifically, they don't our templates array)
- if (js.simpleZigValueToJs(isolate, value, false, opts.null_as_undefined)) |js_value_handle| {
+ if (try js.simpleZigValueToJs(isolate, value, false, opts.null_as_undefined)) |js_value_handle| {
return .{ .local = self, .handle = js_value_handle };
}
@@ -1573,7 +1573,7 @@ pub fn createPromiseResolver(self: *const Local) js.PromiseResolver {
// == Misc ==
pub fn parseJSON(self: *const Local, json: []const u8) !js.Value {
- const string_handle = self.isolate.initStringHandle(json);
+ const string_handle = try self.isolate.newString(json);
const value_handle = v8.v8__JSON__Parse(self.handle, string_handle) orelse return error.JsException;
return .{
.local = self,
diff --git a/src/browser/js/PromiseResolver.zig b/src/browser/js/PromiseResolver.zig
index d6e9fe571..44edeabb0 100644
--- a/src/browser/js/PromiseResolver.zig
+++ b/src/browser/js/PromiseResolver.zig
@@ -46,6 +46,11 @@ pub fn promise(self: PromiseResolver) js.Promise {
pub fn resolve(self: PromiseResolver, comptime source: []const u8, value: anytype) void {
self._resolve(value) catch |err| {
+ // A string too long for V8 (e.g. text() on a huge body): reject the
+ // way a synchronous call throws, rather than leaving it pending.
+ if (@as(anyerror, err) == error.InvalidStringLength) {
+ return self.rejectError(source, .{ .range_error = "Invalid string length" });
+ }
log.err(.bug, "resolve", .{ .source = source, .err = err, .persistent = false });
};
}
diff --git a/src/browser/js/Snapshot.zig b/src/browser/js/Snapshot.zig
index 0c06d78a1..da1aa19a6 100644
--- a/src/browser/js/Snapshot.zig
+++ b/src/browser/js/Snapshot.zig
@@ -915,10 +915,11 @@ fn attachClass(comptime JsApi: type, comptime flatten: bool, isolate: *v8.Isolat
v8.v8__Template__Set(@ptrCast(prototype), js_name, @ptrCast(function_template), v8.DontEnum);
},
bridge.Property => {
+ // Comptime-known property values: never an over-long string.
const js_value = switch (value.value) {
.null => js.simpleZigValueToJs(.{ .handle = isolate }, null, true, false),
inline .bool, .int, .float, .string => |v| js.simpleZigValueToJs(.{ .handle = isolate }, v, true, false),
- };
+ } catch unreachable;
const js_name = v8.v8__String__NewFromUtf8(isolate, name.ptr, v8.kNormal, @intCast(name.len));
{
diff --git a/src/browser/js/js.zig b/src/browser/js/js.zig
index 72b9b195c..426b3749b 100644
--- a/src/browser/js/js.zig
+++ b/src/browser/js/js.zig
@@ -363,7 +363,8 @@ pub const Exception = struct {
// These are simple types that we can convert to JS with only an isolate. This
// is separated from the Caller's zigValueToJs to make it available when we
// don't have a caller (i.e., when setting static attributes on types)
-pub fn simpleZigValueToJs(isolate: Isolate, value: anytype, comptime fail: bool, comptime null_as_undefined: bool) if (fail) *const v8.Value else ?*const v8.Value {
+// Fails only for a string longer than V8 accepts (see Isolate.newString).
+pub fn simpleZigValueToJs(isolate: Isolate, value: anytype, comptime fail: bool, comptime null_as_undefined: bool) error{InvalidStringLength}!(if (fail) *const v8.Value else ?*const v8.Value) {
switch (@typeInfo(@TypeOf(value))) {
.void => return isolate.initUndefined(),
.null => if (comptime null_as_undefined) return isolate.initUndefined() else return isolate.initNull(),
@@ -390,12 +391,12 @@ pub fn simpleZigValueToJs(isolate: Isolate, value: anytype, comptime fail: bool,
.float, .comptime_float => return @ptrCast(isolate.initNumber(value).handle),
.pointer => |ptr| {
if (ptr.size == .slice and ptr.child == u8) {
- return @ptrCast(isolate.initStringHandle(value));
+ return @ptrCast(try isolate.newString(value));
}
if (ptr.size == .one) {
const one_info = @typeInfo(ptr.child);
if (one_info == .array and one_info.array.child == u8) {
- return @ptrCast(isolate.initStringHandle(value));
+ return @ptrCast(try isolate.newString(value));
}
}
},
@@ -411,8 +412,8 @@ pub fn simpleZigValueToJs(isolate: Isolate, value: anytype, comptime fail: bool,
},
.@"struct" => {
switch (@TypeOf(value)) {
- string.String => return isolate.initStringHandle(value.str()),
- String.OneByte => return @ptrCast(isolate.initOneByteStringHandle(value.bytes)),
+ string.String => return @ptrCast(try isolate.newString(value.str())),
+ String.OneByte => return @ptrCast(try isolate.newOneByteString(value.bytes)),
ArrayBuffer => {
const values = value.values;
const len = values.len;
@@ -569,10 +570,10 @@ test "js: ArrayBuffers crossing Zig don't keep a reference to their backing stor
_ = created.slice();
try testing.expectEqual(1, backingStoreRefs(created.handle));
- const typed = simpleZigValueToJs(local.isolate, TypedArray(u8){ .values = "abc" }, true, false);
+ const typed = try simpleZigValueToJs(local.isolate, TypedArray(u8){ .values = "abc" }, true, false);
try testing.expectEqual(1, backingStoreRefs(typed));
- const buffer = simpleZigValueToJs(local.isolate, ArrayBuffer{ .values = "abc" }, true, false);
+ const buffer = try simpleZigValueToJs(local.isolate, ArrayBuffer{ .values = "abc" }, true, false);
try testing.expectEqual(1, backingStoreRefs(buffer));
const from_js = try local.exec("new Uint8Array(8)", null);
@@ -581,6 +582,53 @@ test "js: ArrayBuffers crossing Zig don't keep a reference to their backing stor
try testing.expectEqual(1, backingStoreRefs(from_js.handle));
}
+// A slice claiming `len` bytes over a 1-byte buffer. Only valid for code that
+// rejects it on its length before reading any byte: V8 compares the length
+// against String::kMaxLength before touching the data, and lengths that don't
+// fit a c_int never reach V8.
+fn overlongString(len: usize) []const u8 {
+ const byte: *const [1]u8 = "a";
+ const base: [*]const u8 = byte;
+ return base[0..len];
+}
+
+test "js: a string longer than V8 accepts fails with RangeError instead of crashing" {
+ const frame = try testing.createFrame();
+ defer testing.test_session.closeAllPages();
+
+ var ls: Local.Scope = undefined;
+ frame.js.localScope(&ls);
+ defer ls.deinit();
+ const local = &ls.local;
+
+ const State = struct {
+ len: usize,
+
+ fn text(self: *@This()) []const u8 {
+ return overlongString(self.len);
+ }
+ };
+ const driver = try local.exec("(function(text) { try { text(); } catch (e) { return String(e); } })", null);
+ const driver_fn = Function{ .local = local, .handle = @ptrCast(driver.handle) };
+
+ // Just above v8::String::kMaxLength on 64-bit builds, then past c_int.
+ for ([_]usize{ 1 << 29, 1 << 31 }) |len| {
+ const str = overlongString(len);
+ try testing.expectError(error.InvalidStringLength, local.zigValueToJs(str, .{}));
+ try testing.expectError(error.InvalidStringLength, local.zigValueToJs(String.OneByte{ .bytes = str }, .{}));
+ try testing.expectError(error.InvalidStringLength, local.parseJSON(str));
+ try testing.expectError(error.InvalidStringLength, local.compile(str, null));
+
+ var state = State{ .len = len };
+ const res = try driver_fn.call([]const u8, .{local.newCallback(State.text, &state)});
+ try testing.expectEqual("RangeError: Invalid string length", res);
+
+ const promise = try local.resolvePromise(str);
+ try testing.expectEqual(.rejected, promise.state());
+ try testing.expectEqual("RangeError: Invalid string length", try promise.result().toStringSmart());
+ }
+}
+
// References held on an ArrayBuffer's (or a view's) backing store, not
// counting the one taken here to ask.
fn backingStoreRefs(handle: *const v8.Value) i64 {
diff --git a/src/browser/webapi/compression/zlib.zig b/src/browser/webapi/compression/zlib.zig
index db42530a3..4045c2d95 100644
--- a/src/browser/webapi/compression/zlib.zig
+++ b/src/browser/webapi/compression/zlib.zig
@@ -100,7 +100,7 @@ pub fn Deflate(comptime mode: enum(u1) { compress, decompress }) type {
return error.StreamError;
}
- const FeedError = error{ StreamNotReadable, OutOfMemory, CreateObjectFailure, HasJunkData, InvalidData };
+ const FeedError = error{ StreamNotReadable, OutOfMemory, CreateObjectFailure, InvalidStringLength, HasJunkData, InvalidData };
fn feed(
self: *Deflate(mode),
diff --git a/src/server/bidi/execute.zig b/src/server/bidi/execute.zig
index a52ee5ae5..d81553f64 100644
--- a/src/server/bidi/execute.zig
+++ b/src/server/bidi/execute.zig
@@ -340,6 +340,7 @@ const CloneError = error{
MethodNotFound,
DeadFunctionHandle,
InvalidArgument,
+ InvalidStringLength,
};
fn cloneErrorMessage(err: anyerror) []const u8 {