Skip to content

Lightpanda: the headless browser designed for AI and automation

Fix UAF on ScrollTask

Karl Seguin40c18f614299
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 33d391c56..7e30b45d8 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -1432,15 +1432,18 @@ fn frameDataCallback(transfer: *HttpClient.Transfer, data: []const u8) !void {
}
// Record the response's MIME essence so the resulting document
- // reports it (document.contentType); text/html stays the default.
+ // reports it (document.contentType). text/html keeps the default, so an
+ // HTML response (parsed from the header, or sniffed when there's no
+ // header) never needs an override; inside this branch the essence can
+ // no longer be text/html.
self._pending_content_type = null;
- if (transfer.contentType()) |ct| {
- const end = std.mem.indexOfScalar(u8, ct, ';') orelse ct.len;
- const essence = std.mem.trim(u8, ct[0..end], " \t");
- if (essence.len > 0 and !std.ascii.eqlIgnoreCase(essence, "text/html")) {
- const lower = try self.arena.dupe(u8, essence);
- _ = std.ascii.lowerString(lower, essence);
- self._pending_content_type = lower;
+ if (mime.content_type != .text_html) {
+ if (transfer.contentType()) |ct| {
+ const end = std.mem.indexOfScalarPos(u8, ct, 0, ';') orelse ct.len;
+ const essence = std.mem.trim(u8, ct[0..end], " \t");
+ if (essence.len > 0) {
+ self._pending_content_type = try std.ascii.allocLowerString(self.arena, essence);
+ }
}
}
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 11d59f77f..118c4491b 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1715,58 +1715,90 @@ fn scheduleScrollEvents(self: *Element, frame: *Frame) !void {
}
gop.value_ptr.state = .scroll;
- const task = try frame.arena.create(ScrollEventTask);
- task.* = .{ .frame = frame, .element = self };
+ const task = try frame._factory.create(ScrollEventTask{ .frame = frame, .element = self });
try frame.js.scheduler.add(task, ScrollEventTask.dispatchScroll, 10, .{ .low_priority = true });
- try frame.js.scheduler.add(task, ScrollEventTask.dispatchScrollEnd, 20, .{ .low_priority = true });
+ try frame.js.scheduler.add(task, ScrollEventTask.dispatchScrollEnd, 20, .{ .low_priority = true, .finalizer = ScrollEventTask.cancelled });
}
const ScrollEventTask = struct {
frame: *Frame,
element: *Element,
- fn eventTarget(self: *ScrollEventTask) *@import("EventTarget.zig") {
- if (self.frame.document.getDocumentElement() == self.element) {
- return self.frame.document.asEventTarget();
- }
- return self.element.asEventTarget();
+ fn cancelled(ctx: *anyopaque) void {
+ const self: *ScrollEventTask = @ptrCast(@alignCast(ctx));
+ self.deinit();
}
- // Scroll events fired at an element don't bubble; only document-level
- // scrolls (the scrolling element, dispatched at the document) do.
- fn bubbles(self: *ScrollEventTask) bool {
- return self.frame.document.getDocumentElement() == self.element;
+ fn deinit(self: *ScrollEventTask) void {
+ self.frame._factory.destroy(self);
}
- fn dispatchScroll(ptr: *anyopaque) anyerror!?u32 {
- const self: *ScrollEventTask = @ptrCast(@alignCast(ptr));
+ fn dispatchScroll(ctx: *anyopaque) anyerror!?u32 {
+ const self: *ScrollEventTask = @ptrCast(@alignCast(ctx));
const f = self.frame;
const pos = f._element_scroll_positions.getPtr(self.element) orelse return null;
if (pos.state != .scroll) {
return null;
}
+
const Event = @import("Event.zig");
const event = try Event.initTrusted(comptime .wrap("scroll"), .{ .bubbles = self.bubbles() }, f._page);
try f._event_manager.dispatch(self.eventTarget(), event);
- pos.state = .end;
+
+ // can't use gop on _element_scroll_positions above, since the JS callback
+ // can mutate _element_scroll_positions and invalidate any pointers
+ if (f._element_scroll_positions.getPtr(self.element)) |p| {
+ p.state = .end;
+ }
return null;
}
- fn dispatchScrollEnd(ptr: *anyopaque) anyerror!?u32 {
- const self: *ScrollEventTask = @ptrCast(@alignCast(ptr));
+ fn dispatchScrollEnd(ctx: *anyopaque) anyerror!?u32 {
+ const self: *ScrollEventTask = @ptrCast(@alignCast(ctx));
+
const f = self.frame;
- const pos = f._element_scroll_positions.getPtr(self.element) orelse return null;
+ const pos = f._element_scroll_positions.getPtr(self.element) orelse {
+ self.deinit();
+ return null;
+ };
+
switch (pos.state) {
+ // The scroll event is still pending; retry in 10ms. Must not destroy
+ // the task here — the entry is re-scheduled and runs again.
.scroll => return 10,
.end => {},
- .done => return null,
+ .done => {
+ self.deinit();
+ return null;
+ },
}
+
+ defer self.deinit();
const Event = @import("Event.zig");
const event = try Event.initTrusted(comptime .wrap("scrollend"), .{ .bubbles = self.bubbles() }, f._page);
try f._event_manager.dispatch(self.eventTarget(), event);
- pos.state = .done;
+
+ // can't use gop on _element_scroll_positions above, since the JS callback
+ // can mutate _element_scroll_positions and invalidate any pointers
+ if (f._element_scroll_positions.getPtr(self.element)) |p| {
+ p.state = .done;
+ }
+
return null;
}
+
+ fn eventTarget(self: *ScrollEventTask) *EventTarget {
+ if (self.frame.document.getDocumentElement() == self.element) {
+ return self.frame.document.asEventTarget();
+ }
+ return self.element.asEventTarget();
+ }
+
+ // Scroll events fired at an element don't bubble; only document-level
+ // scrolls (the scrolling element, dispatched at the document) do.
+ fn bubbles(self: *ScrollEventTask) bool {
+ return self.frame.document.getDocumentElement() == self.element;
+ }
};
pub fn format(self: *Element, writer: *std.Io.Writer) !void {