Skip to content

Lightpanda: the headless browser designed for AI and automation

crash: fix UAF in MutationObserver

Karl Seguine1c2ea6dcc2f
diff --git a/src/browser/frame/observers.zig b/src/browser/frame/observers.zig
index e8fd0526c..d80916bb8 100644
--- a/src/browser/frame/observers.zig
+++ b/src/browser/frame/observers.zig
@@ -113,7 +113,7 @@ pub fn unregisterIntersectionObserver(frame: *Frame, observer: *IntersectionObse
for (frame._intersection.observers.items, 0..) |obs, i| {
if (obs == observer) {
observer.releaseRef(frame.page);
- _ = frame._intersection.observers.swapRemove(i);
+ _ = frame._intersection.observers.orderedRemove(i);
return;
}
}
@@ -128,7 +128,7 @@ pub fn unregisterResizeObserver(frame: *Frame, observer: *ResizeObserver) void {
for (frame._resize.observers.items, 0..) |obs, i| {
if (obs == observer) {
observer.releaseRef(frame.page);
- _ = frame._resize.observers.swapRemove(i);
+ _ = frame._resize.observers.orderedRemove(i);
return;
}
}
@@ -282,14 +282,21 @@ pub fn deliverResizes(frame: *Frame) void {
return;
}
- // Iterate backwards so an observer disconnecting during its callback is safe.
- var i = frame._resize.observers.items.len;
- while (i > 0) {
- i -= 1;
- if (i >= frame._resize.observers.items.len) {
- continue;
- }
- const observer = frame._resize.observers.items[i];
+ // snapshot and acquireRef because a the callback for observer A could
+ // disconnect, which would then wipe our reference from under us.
+ const observers = frame.call_arena.dupe(*ResizeObserver, frame._resize.observers.items) catch |err| {
+ log.err(.frame, "deliverResizes.snapshot", .{ .err = err, .type = frame._type, .url = frame.url });
+ return;
+ };
+
+ for (observers) |observer| {
+ observer.acquireRef();
+ }
+ defer for (observers) |observer| {
+ observer.releaseRef(frame.page);
+ };
+
+ for (observers) |observer| {
observer.deliverEntries(frame) catch |err| {
log.debug(.frame, "frame.deliverResizes", .{ .err = err, .type = frame._type, .url = frame.url });
if (err == error.ExecutionTerminated) {
@@ -369,14 +376,20 @@ pub fn deliverIntersections(frame: *Frame) void {
return;
}
- // Iterate backwards so an observer disconnecting during its callback is safe.
- var i = frame._intersection.observers.items.len;
- while (i > 0) {
- i -= 1;
- if (i >= frame._intersection.observers.items.len) {
- continue;
- }
- const observer = frame._intersection.observers.items[i];
+ // snapshot and acquireRef because a the callback for observer A could
+ // disconnect, which would then wipe our reference from under us.
+ const observers = frame.call_arena.dupe(*IntersectionObserver, frame._intersection.observers.items) catch |err| {
+ log.err(.frame, "deliverIntersections.snapshot", .{ .err = err, .type = frame._type, .url = frame.url });
+ return;
+ };
+ for (observers) |observer| {
+ observer.acquireRef();
+ }
+ defer for (observers) |observer| {
+ observer.releaseRef(frame.page);
+ };
+
+ for (observers) |observer| {
observer.deliverEntries(frame) catch |err| {
log.debug(.frame, "frame.deliverIntersections", .{ .err = err, .type = frame._type, .url = frame.url });
if (err == error.ExecutionTerminated) {
@@ -442,6 +455,9 @@ pub fn deliverMutations(frame: *Frame) void {
// we started the delivery. So we need to snapshot this. Any observers which
// get records during this phase will only be processed on the next microtask tick.
var notify: std.ArrayList(*MutationObserver) = .empty;
+ defer for (notify.items) |observer| {
+ observer.releaseRef(frame.page);
+ };
var it: ?*std.DoublyLinkedList.Node = frame._mutation.observers.first;
while (it) |node| : (it = node.next) {
const observer: *MutationObserver = @fieldParentPtr("node", node);
@@ -452,6 +468,7 @@ pub fn deliverMutations(frame: *Frame) void {
log.err(.frame, "deliverMutations.notify", .{ .err = err, .type = frame._type, .url = frame.url });
break;
};
+ observer.acquireRef();
}
for (notify.items) |observer| {
diff --git a/src/browser/tests/intersection_observer/disconnect_during_delivery.html b/src/browser/tests/intersection_observer/disconnect_during_delivery.html
new file mode 100644
index 000000000..dcf5e3bb2
--- /dev/null
+++ b/src/browser/tests/intersection_observer/disconnect_during_delivery.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+<div id="target" style="width: 100px; height: 60px;">Target Element</div>
+
+<script id="disconnectEarlierObserver">
+ {
+ // b disconnects a while the delivery round is in progress. Each observer
+ // must still be called at most once, in registration order.
+ const target = document.getElementById('target');
+ const calls = [];
+ const a = new IntersectionObserver(() => calls.push('a'));
+ const b = new IntersectionObserver(() => { calls.push('b'); a.disconnect(); });
+ const c = new IntersectionObserver(() => calls.push('c'));
+ a.observe(target);
+ b.observe(target);
+ c.observe(target);
+
+ testing.onload(() => {
+ testing.expectEqual('a,b,c', calls.join(','));
+ b.disconnect();
+ c.disconnect();
+ });
+ }
+</script>
+
+<script id="disconnectLaterObserver">
+ {
+ const target = document.getElementById('target');
+ const calls = [];
+ let c = null;
+ const a = new IntersectionObserver(() => { calls.push('a'); c.disconnect(); });
+ const b = new IntersectionObserver(() => calls.push('b'));
+ c = new IntersectionObserver(() => calls.push('c'));
+ a.observe(target);
+ b.observe(target);
+ c.observe(target);
+
+ testing.onload(() => {
+ testing.expectEqual('a,b', calls.join(','));
+ a.disconnect();
+ b.disconnect();
+ });
+ }
+</script>
diff --git a/src/browser/tests/mutation_observer/disconnect_other_during_delivery.html b/src/browser/tests/mutation_observer/disconnect_other_during_delivery.html
new file mode 100644
index 000000000..e1cedb7e0
--- /dev/null
+++ b/src/browser/tests/mutation_observer/disconnect_other_during_delivery.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+
+<script id=disconnectAndCollectLaterObserver>
+ var calledB = false;
+ {
+ const target = document.createElement('div');
+ let b = null;
+
+ const a = new MutationObserver(() => {
+ b.disconnect();
+ b = null;
+ const keep = [];
+ for (let round = 0; round < 4; round++) {
+ const junk = [];
+ for (let i = 0; i < 300000; i++) junk.push({ i, s: 'x' + i });
+ keep.push(junk);
+ }
+ });
+ a.observe(target, { attributes: true });
+
+ b = new MutationObserver(() => { calledB = true; });
+ b.observe(target, { attributes: true });
+
+ for (let i = 0; i < 8; i++) target.setAttribute('x' + i, '1');
+ testing.expectEqual('1', target.getAttribute('x0'));
+ }
+</script>
+
+<script id=laterObserverNotCalled>
+ testing.expectEqual(false, calledB);
+</script>
diff --git a/src/browser/tests/performance_observer/callback_throws.html b/src/browser/tests/performance_observer/callback_throws.html
new file mode 100644
index 000000000..372e1a3c8
--- /dev/null
+++ b/src/browser/tests/performance_observer/callback_throws.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+
+<script id="throwingObserverDoesNotStopOthers" type=module>
+ const state = await testing.async();
+
+ let calledSecond = false;
+ const first = new PerformanceObserver(() => {
+ first.disconnect();
+ throw new Error('boom');
+ });
+ first.observe({ type: "mark" });
+
+ await new Promise((resolve) => {
+ const second = new PerformanceObserver(() => {
+ calledSecond = true;
+ second.disconnect();
+ resolve();
+ });
+ second.observe({ type: "mark" });
+ performance.mark("throwMark");
+ });
+
+ state.resolve();
+ await state.done(() => {
+ testing.expectEqual(true, calledSecond);
+ });
+</script>
diff --git a/src/browser/tests/resize_observer/disconnect_during_delivery.html b/src/browser/tests/resize_observer/disconnect_during_delivery.html
new file mode 100644
index 000000000..a654506bd
--- /dev/null
+++ b/src/browser/tests/resize_observer/disconnect_during_delivery.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<script src="../testing.js"></script>
+<div id="target" style="width: 100px; height: 60px;">Target Element</div>
+
+<script id="disconnectEarlierObserver">
+ {
+ // b disconnects a while the delivery round is in progress. Each observer
+ // must still be called at most once, in registration order.
+ const target = document.getElementById('target');
+ const calls = [];
+ const a = new ResizeObserver(() => calls.push('a'));
+ const b = new ResizeObserver(() => { calls.push('b'); a.disconnect(); });
+ const c = new ResizeObserver(() => calls.push('c'));
+ a.observe(target);
+ b.observe(target);
+ c.observe(target);
+
+ testing.onload(() => {
+ testing.expectEqual('a,b,c', calls.join(','));
+ b.disconnect();
+ c.disconnect();
+ });
+ }
+</script>
+
+<script id="disconnectLaterObserver">
+ {
+ const target = document.getElementById('target');
+ const calls = [];
+ let c = null;
+ const a = new ResizeObserver(() => { calls.push('a'); c.disconnect(); });
+ const b = new ResizeObserver(() => calls.push('b'));
+ c = new ResizeObserver(() => calls.push('c'));
+ a.observe(target);
+ b.observe(target);
+ c.observe(target);
+
+ testing.onload(() => {
+ testing.expectEqual('a,b', calls.join(','));
+ a.disconnect();
+ b.disconnect();
+ });
+ }
+</script>
diff --git a/src/browser/webapi/Performance.zig b/src/browser/webapi/Performance.zig
index cb0bea547..076b68316 100644
--- a/src/browser/webapi/Performance.zig
+++ b/src/browser/webapi/Performance.zig
@@ -679,7 +679,11 @@ pub fn scheduleDelivery(self: *Performance) !void {
while (i < perf._observers.items.len) : (i += 1) {
const observer = perf._observers.items[i];
if (observer.hasRecords()) {
- try observer.dispatch();
+ observer.dispatch() catch |err| {
+ if (err == error.ExecutionTerminated) {
+ return err;
+ }
+ };
}
}
return null;