buninu-browser 0.0.2

package/test/script-rewrite.test.js

@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test";
+import { rewriteConstructorReads } from "../lib/renderer/script-rewrite.js";
+
+const rewrite = (source, type) => rewriteConstructorReads(source, type).code;
+
+test("constructor reads go through the helper; writes, delete and optional chains do not", () => {
+  expect(rewrite("var A = Object.getPrototypeOf(async function () {}).constructor;"))
+    .toBe("var A = $buninu$constructor(Object.getPrototypeOf(async function () {}));");
+  // Parentheses around the object stay; nested reads compose.
+  expect(rewrite("x = (async () => {}).constructor.constructor;"))
+    .toBe("x = $buninu$constructor(($buninu$constructor(async () => {})));");
+  // Once a source has the idiom, every read in it goes through the helper.
+  const trigger = " (async () => {}).constructor;";
+  expect(rewrite(`y = a . constructor ['constructor'];${trigger}`))
+    .toBe("y = $buninu$constructor($buninu$constructor(a) ) ; ($buninu$constructor(async () => {}));");
+  // Calls keep the receiver (the helper's second argument).
+  expect(rewrite(`b.constructor(1); new c.constructor();${trigger}`))
+    .toBe("$buninu$constructor(b, true)(1); new $buninu$constructor(c)(); ($buninu$constructor(async () => {}));");
+  const untouched = "a.constructor = 1; a.constructor++; delete a.constructor; for (a.constructor of []); c?.constructor; "
+    + "class K extends B { constructor() { super(); super.constructor } } ({ constructor: 1 });";
+  expect(rewrite(untouched + trigger)).toBe(`${untouched} ($buninu$constructor(async () => {}));`);
+});
+
+test("sources that cannot reach Function constructors are not parsed; bad syntax is left to the engine", () => {
+  expect(rewriteConstructorReads("x.constructor.name")).toEqual({ code: "x.constructor.name", rewritten: false });
+  // this.constructor is common and harmless; alone it does not trigger a parse.
+  expect(rewriteConstructorReads("async function f() { return this.constructor }").rewritten).toBe(false);
+  expect(rewriteConstructorReads("(async () => {}).constructor(")).toEqual({ code: "(async () => {}).constructor(", rewritten: false });
+  expect(rewrite("export const A = (async () => {}).constructor;", "module"))
+    .toBe("export const A = ($buninu$constructor(async () => {}));");
+});

package/test/scroll-viewport.test.js

@@ -0,0 +1,25 @@
+import { expect, test } from "bun:test";
+import { ScrollViewport } from "../lib/layout/scroll-viewport.js";
+
+test("scroll viewport clamps offsets to content bounds", () => {
+  const viewport = new ScrollViewport(320, 200);
+  viewport.setContentSize(500, 900);
+
+  expect(viewport.scrollBy(20, 100)).toBeTrue();
+  expect({ x: viewport.x, y: viewport.y }).toEqual({ x: 20, y: 100 });
+  viewport.scrollBy(1_000, 1_000);
+  expect({ x: viewport.x, y: viewport.y }).toEqual({ x: 180, y: 700 });
+  viewport.scrollBy(-1_000, -1_000);
+  expect({ x: viewport.x, y: viewport.y }).toEqual({ x: 0, y: 0 });
+});
+
+test("resize and content changes keep the current offset valid", () => {
+  const viewport = new ScrollViewport(100, 100);
+  viewport.setContentSize(100, 500);
+  viewport.scrollTo(0, 400);
+  viewport.resize(100, 300);
+  expect(viewport.y).toBe(200);
+  viewport.setContentSize(100, 50);
+  expect(viewport.y).toBe(0);
+});
+

package/test/seccomp.test.js

@@ -0,0 +1,71 @@
+import { expect, test } from "bun:test";
+import { ALLOWED_SYSCALLS, buildFilter, encodeFilter } from "../lib/renderer/seccomp.js";
+import { SYSCALL_NUMBERS } from "../lib/renderer/syscall-numbers.js";
+
+const RET = 0x06;
+const RET_ALLOW = 0x7fff0000;
+const RET_EPERM = 0x00050001;
+const RET_ENOSYS = 0x00050026;
+
+test("builds an allowlist program that checks the architecture first and denies by default", () => {
+  for (const arch of ["x64", "arm64"]) {
+    const program = buildFilter(arch, 1234);
+    expect(program[0]).toEqual([0x20, 0, 0, 4]);
+    expect(program[1][3]).toBe(arch === "x64" ? 0xc000003e : 0xc00000b7);
+    expect(program.at(-1)).toEqual([RET, 0, 0, RET_EPERM]);
+    // Every allowed syscall number is followed by RET_ALLOW.
+    const allowed = new Set();
+    program.forEach(([code, , , k], index) => {
+      if (code === 0x15 && program[index + 1]?.[0] === RET && program[index + 1][3] === RET_ALLOW) allowed.add(k);
+    });
+    expect(allowed.has(SYSCALL_NUMBERS[arch].read)).toBeTrue();
+    for (const denied of ["openat", "socket", "execve", "ptrace", "bpf", "io_uring_setup", "unshare", "mount"]) {
+      expect(`${arch} ${denied} ${allowed.has(SYSCALL_NUMBERS[arch][denied])}`).toBe(`${arch} ${denied} false`);
+    }
+    // clone3 reports ENOSYS so libc falls back to the inspectable clone().
+    const clone3 = program.findIndex(([code, , , k]) => code === 0x15 && k === SYSCALL_NUMBERS[arch].clone3);
+    expect(program[clone3 + 1]).toEqual([RET, 0, 0, RET_ENOSYS]);
+    // Signals are only allowed towards this process id.
+    expect(program.some(([code, , , k]) => code === 0x15 && k === 1234)).toBeTrue();
+    expect(encodeFilter(program).byteLength).toBe(program.length * 8);
+  }
+});
+
+test("skips syscalls an architecture lacks and rejects unknown architectures", () => {
+  // x86-64-only names such as open/poll are simply absent from the arm64 program.
+  const program = buildFilter("arm64", 1, ["open", "read"]);
+  expect(program.filter(([code, , , k]) => code === 0x15 && k === SYSCALL_NUMBERS.arm64.read)).toHaveLength(1);
+  expect(() => buildFilter("sparc", 1)).toThrow("no seccomp syscall table");
+});
+
+test("the policy lists no syscall that opens files, sockets or processes", () => {
+  const forbidden = ["open", "openat", "openat2", "creat", "socket", "connect", "execve", "execveat",
+    "fork", "vfork", "ptrace", "process_vm_readv", "process_vm_writev", "bpf", "io_uring_setup",
+    "userfaultfd", "perf_event_open", "keyctl", "unshare", "setns", "mount", "memfd_create"];
+  expect(ALLOWED_SYSCALLS.filter((name) => forbidden.includes(name))).toEqual([]);
+});
+
+const supported = ["linux", "android"].includes(process.platform) && ["x64", "arm64"].includes(process.arch);
+
+test.skipIf(!supported)("an installed filter keeps the runtime working and blocks escapes", async () => {
+  const child = Bun.spawn({
+    cmd: [process.execPath, new URL("./fixtures/seccomp-child.js", import.meta.url).pathname],
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const output = await new Response(child.stdout).text();
+  await child.exited;
+  const results = JSON.parse(output.trim().split("\n").at(-1));
+  // On a supported platform the sandbox must really be installed; a silent
+  // fallback would make every assertion below vacuous.
+  expect(results.status).toMatchObject({ installed: true });
+  expect(results.compute.ok).toBeTrue();
+  expect(results.allocate).toEqual({ ok: true, value: 64 * 1024 * 1024 });
+  expect(results.timer).toEqual({ ok: true, value: "fired" });
+  expect(results.date).toEqual({ ok: true, value: "1970-01-01T00:00:00.000Z" });
+  expect(results.worker).toEqual({ ok: true, value: 42 });
+  expect(results.readFile.ok).toBeFalse();
+  expect(results.network.ok).toBeFalse();
+  expect(results.spawn.ok).toBeFalse();
+  expect(results.killParent.ok).toBeFalse();
+});

package/test/site-isolation.test.js

@@ -0,0 +1,74 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { createBrowser } from "../lib/headless-shell.js";
+
+let server;
+let browser;
+beforeAll(async () => {
+  server = Bun.serve({
+    port: 0,
+    fetch(request) {
+      const { pathname } = new URL(request.url);
+      if (pathname === "/bounce") {
+        return new Response(null, { status: 302, headers: { location: `http://localhost:${server.port}/landed` } });
+      }
+      return new Response(`<title>${pathname.slice(1)}</title><p>${pathname}</p>`, {
+        headers: { "content-type": "text/html" },
+      });
+    },
+  });
+  browser = await createBrowser({ spareRenderer: true });
+});
+afterAll(() => {
+  browser?.close();
+  server?.stop(true);
+});
+
+async function exited(pid, timeout = 5000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return true;
+    }
+    await Bun.sleep(20);
+  }
+  return false;
+}
+
+const loopback = (path) => `http://127.0.0.1:${server.port}${path}`;
+const local = (path) => `http://localhost:${server.port}${path}`;
+
+test("keeps one renderer per origin and swaps on cross-origin navigation", async () => {
+  const { context } = browser;
+  await context.navigate(loopback("/one"));
+  const first = browser.rendererPid;
+  expect(await context.title()).toBe("one");
+
+  await context.navigate(loopback("/two"));
+  expect(browser.rendererPid).toBe(first);
+
+  await context.navigate(local("/three"));
+  const second = browser.rendererPid;
+  expect(second).not.toBe(first);
+  expect(await context.title()).toBe("three");
+  // The old origin's process is gone (it is signalled; exiting takes a moment).
+  expect(await exited(first)).toBeTrue();
+
+  // History back to the first origin gets a fresh process, not the old one.
+  await context.goBack();
+  expect(await context.title()).toBe("two");
+  expect(browser.rendererPid).not.toBe(second);
+  expect(browser.rendererPid).not.toBe(first);
+}, 60_000);
+
+test("picks the renderer by the final URL after redirects and replays the viewport", async () => {
+  const { context } = browser;
+  await context.navigate(loopback("/start"));
+  await context.resize(320, 240, 1);
+  const before = browser.rendererPid;
+  await context.navigate(loopback("/bounce"));
+  expect(browser.rendererPid).not.toBe(before);
+  expect(await context.title()).toBe("landed");
+  expect(await context.evaluate("innerWidth")).toBe(320);
+}, 60_000);

package/test/svg.test.js

@@ -0,0 +1,61 @@
+import { expect, test } from "bun:test";
+import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
+import { layoutText } from "../lib/layout/text-layout.js";
+import { buildDisplayList } from "../lib/paint/display-list.js";
+import { RenderTreeBuilder } from "../lib/render-tree/index.js";
+import { extractSvg, parseTransform } from "../lib/render-tree/svg.js";
+import { StyleEngine } from "../lib/style/computed-style.js";
+
+test("extracts shapes with inherited paint, currentColor and transforms", () => {
+  const { document, window } = parseHTMLDocument(`<svg viewBox="0 0 16 16" width="16" height="16" fill="currentColor">
+    <path d="M0 0h4v4z"/>
+    <g fill="#f00" stroke="blue" stroke-width="2" opacity="0.5" transform="translate(2 3)">
+      <rect x="1" y="1" width="4" height="2" rx="1"/><circle cx="8" cy="8" r="3" fill="none"/>
+      <line x1="0" y1="0" x2="4" y2="4"/><polygon points="0,0 4,0 2,3" fill-rule="evenodd"/>
+    </g>
+    <defs><path d="M9 9h1"/></defs><title>ignored</title>
+  </svg>`);
+  const svg = extractSvg(document.querySelector("svg"), "rgba(1, 2, 3, 1)");
+  expect(svg.viewBox).toEqual([0, 0, 16, 16]);
+  expect(svg.width).toBe(16);
+  expect(svg.shapes.map((shape) => [shape.fill, shape.stroke])).toEqual([
+    ["rgba(1, 2, 3, 1)", null],
+    ["rgba(255, 0, 0, 1)", "rgba(0, 0, 255, 1)"],
+    [null, "rgba(0, 0, 255, 1)"],
+    [null, "rgba(0, 0, 255, 1)"],
+    ["rgba(255, 0, 0, 1)", "rgba(0, 0, 255, 1)"],
+  ]);
+  const [, rect, circle, , polygon] = svg.shapes;
+  expect(rect.d).toStartWith("M2 1");
+  expect(rect).toMatchObject({ strokeWidth: 2, fillOpacity: 0.5, strokeOpacity: 0.5, matrix: [1, 0, 0, 1, 2, 3] });
+  expect(circle.d).toBe("M5 8a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z");
+  expect(polygon).toMatchObject({ d: "M0 0L4 0L2 3Z", fillRule: "evenodd" });
+  window.happyDOM.abort();
+});
+
+test("parses transform lists into one matrix", () => {
+  expect(parseTransform("translate(10 20) scale(2)")).toEqual([2, 0, 0, 2, 10, 20]);
+  const [a, b, c, d] = parseTransform("rotate(90)");
+  expect([a, b, c, d].map((value) => Math.round(value))).toEqual([0, 1, -1, 0]);
+});
+
+test("inline SVG is a replaced box with margins and vertical-align in the line", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0"><p style="margin:0">
+    <svg viewBox="0 0 16 16" width="16" height="16" style="margin-right:8px;vertical-align:text-bottom"><path d="M0 0h16v16z"/></svg>Readme</p></body>`);
+  const styles = new StyleEngine().compute(document);
+  const tree = new RenderTreeBuilder().build(document, styles);
+  const layout = layoutText(tree, {
+    x: 0, y: 0, width: 300, measureText: (text) => text.length * 10, fontMetrics: () => ({ ascent: 16, height: 20 }),
+  });
+  const runs = layout.fragments.flatMap((fragment) => fragment.runs);
+  const icon = runs.find((run) => run.type === "image");
+  const text = runs.find((run) => run.text?.includes("Readme"));
+  expect(icon).toMatchObject({ x: 0, width: 16, height: 16 });
+  // margin-right separates the icon from the text.
+  expect(text.x).toBeGreaterThanOrEqual(24);
+  // text-bottom: the icon's bottom sits on the text's bottom (baseline 16 + descent 4).
+  expect(icon.y + icon.height).toBe(20);
+  const items = buildDisplayList(layout, tree).items;
+  expect(items.find((item) => item.op === "drawSvg")).toMatchObject({ rect: { x: 0, width: 16, height: 16 } });
+  window.happyDOM.abort();
+});