buninu-browser 0.0.2

package/lib/renderer/script-rewrite.js

@@ -0,0 +1,232 @@
+/**
+ * Rewrites a classic script so its top-level declarations become properties
+ * of the global object, as they are in a browser.
+ *
+ * SES evaluates code with a strict-mode direct eval, which gives every script
+ * its own variable scope: `var x` in one <script> would be invisible to the
+ * next. Together with SES's `sloppyGlobalsMode` (assignments to undeclared
+ * names set global properties) this rewrite restores the sharing:
+ *
+ *   var a = 1, b;        ->  a = 1;            (+ prologue declares a and b)
+ *   for (var i = 0; …)   ->  for (i = 0; …)
+ *   function f() {}      ->  f = function f() {};   (hoisted to the prologue)
+ *   let/const/class x    ->  global properties (an approximation: browsers
+ *                            keep them in a shared lexical scope instead)
+ *
+ * Declarations inside functions are untouched. Strict-mode-only restrictions
+ * (`with`, legacy octal literals, `arguments.callee`) cannot be lifted.
+ */
+import { Parser } from "../../vendor/acorn/dist/acorn.mjs";
+
+const FUNCTION_TYPES = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+
+/**
+ * @param {string} source classic script text
+ * @returns {{ code: string, globals: string[], rewritten: boolean }}
+ */
+export function rewriteClassicScript(source) {
+  let program;
+  try {
+    program = Parser.parse(source, {
+      ecmaVersion: "latest",
+      sourceType: "script",
+      allowHashBang: true,
+      allowReturnOutsideFunction: false,
+    });
+  } catch {
+    // Let the engine report the syntax error with its own message.
+    return { code: source, globals: [], rewritten: false };
+  }
+
+  const edits = [];
+  const globals = new Set();
+  const hoisted = [];
+
+  const declare = (pattern) => {
+    for (const name of boundNames(pattern)) globals.add(name);
+  };
+
+  /** Turns `var a = 1, {b} = c` into `a = 1, ({b} = c)`, or removes it. */
+  const declarationAsExpression = (declaration) => declaration.declarations
+    .filter((declarator) => declarator.init)
+    .map((declarator) => {
+      const target = source.slice(declarator.id.start, declarator.id.end);
+      const value = source.slice(declarator.init.start, declarator.init.end);
+      return declarator.id.type === "Identifier" ? `${target} = ${value}` : `(${target} = ${value})`;
+    })
+    .join(", ");
+
+  // The walk never enters function or class bodies, so every `var` it sees is
+  // function-scope-free and belongs to the global object. let/const/class
+  // and function declarations are lifted only when they sit directly in the
+  // program body; inside blocks they keep their block scope.
+  const visit = (node, parent) => {
+    if (!node || typeof node.type !== "string") return;
+    const programChild = parent?.type === "Program";
+    if (FUNCTION_TYPES.has(node.type)) {
+      if (node.type === "FunctionDeclaration" && programChild) {
+        globals.add(node.id.name);
+        hoisted.push(`${node.id.name} = ${source.slice(node.start, node.end)};`);
+        edits.push({ start: node.start, end: node.end, text: "" });
+      }
+      return;
+    }
+    if (node.type === "ClassBody" || node.type === "StaticBlock") return;
+    if (node.type === "VariableDeclaration" && (node.kind === "var" || programChild)) {
+      for (const declarator of node.declarations) declare(declarator.id);
+      edits.push({ start: node.start, end: node.end, text: variableReplacement(node) });
+      return;
+    }
+    if (node.type === "ClassDeclaration" && programChild) {
+      globals.add(node.id.name);
+      edits.push({ start: node.start, end: node.end, text: `${node.id.name} = ${source.slice(node.start, node.end)};` });
+      return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      for (const child of Array.isArray(value) ? value : [value]) {
+        if (child && typeof child === "object") visit(child, node);
+      }
+    }
+  };
+
+  /**
+   * The statement a `var` becomes depends on where it sits: a plain
+   * statement, the init of a for loop, or the left side of for-in/of.
+   */
+  const variableReplacement = (node) => {
+    const parent = parentOf.get(node);
+    if (parent && (parent.type === "ForInStatement" || parent.type === "ForOfStatement") && parent.left === node) {
+      return source.slice(node.declarations[0].id.start, node.declarations[0].id.end);
+    }
+    const expression = declarationAsExpression(node);
+    if (parent && parent.type === "ForStatement" && parent.init === node) return expression;
+    return expression ? `${expression};` : ";";
+  };
+
+  const parentOf = new Map();
+  (function link(node) {
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      const children = Array.isArray(value) ? value : [value];
+      for (const child of children) {
+        if (child && typeof child.type === "string") {
+          parentOf.set(child, node);
+          link(child);
+        }
+      }
+    }
+  })(program);
+
+  visit(program, null);
+  if (!edits.length) return { code: source, globals: [], rewritten: false };
+
+  edits.sort((left, right) => right.start - left.start);
+  let body = source;
+  for (const edit of edits) body = body.slice(0, edit.start) + edit.text + body.slice(edit.end);
+  // Hoisting: names exist (as undefined) before any statement runs, and
+  // function declarations are assigned first. Existing globals are kept.
+  const prologue = [...globals]
+    .map((name) => `if (!(${JSON.stringify(name)} in globalThis)) globalThis[${JSON.stringify(name)}] = undefined;`)
+    .join(" ");
+  return { code: `${prologue} ${hoisted.join(" ")}\n${body}`, globals: [...globals], rewritten: true };
+}
+
+/** Names bound by a declaration pattern (identifiers, destructuring, defaults, rest). */
+export function boundNames(pattern) {
+  if (!pattern) return [];
+  switch (pattern.type) {
+    case "Identifier": return [pattern.name];
+    case "ObjectPattern": return pattern.properties.flatMap((property) =>
+      boundNames(property.type === "RestElement" ? property.argument : property.value));
+    case "ArrayPattern": return pattern.elements.flatMap((element) => boundNames(element));
+    case "AssignmentPattern": return boundNames(pattern.left);
+    case "RestElement": return boundNames(pattern.argument);
+    default: return [];
+  }
+}
+
+/** The global the constructor-read rewrite calls (see rewriteConstructorReads). */
+export const CONSTRUCTOR_HELPER = "$buninu$constructor";
+
+/**
+ * Routes reads of `.constructor` through CONSTRUCTOR_HELPER:
+ *
+ *   Object.getPrototypeOf(async function () {}).constructor
+ *     ->  $buninu$constructor(Object.getPrototypeOf(async function () {}))
+ *
+ * SES replaces the Function, AsyncFunction, GeneratorFunction and
+ * AsyncGeneratorFunction constructors reachable through prototypes with inert
+ * ones that throw, and they are frozen afterwards; the helper hands out
+ * working per-document versions instead. Only plain reads change: assignment
+ * targets, `delete` and optional chains keep their form; a call passes the
+ * object along to stay its receiver. The edits only insert text, so nested
+ * reads compose.
+ *
+ * Parsing costs about as much as the engine's own parse, so only sources
+ * with the usual idiom are rewritten: `.constructor` right after a closing
+ * parenthesis — `(async () => {}).constructor`,
+ * `Object.getPrototypeOf(function* () {}).constructor` — in code that
+ * mentions async, generators or Function. On GitHub that is one script in a
+ * hundred.
+ *
+ * @param {string} source
+ * @param {"script" | "module"} sourceType
+ * @returns {{ code: string, rewritten: boolean }}
+ */
+export function rewriteConstructorReads(source, sourceType = "script") {
+  if (!/\)\s*\.\s*constructor\b|\)\s*\[\s*["'`]constructor["'`]\s*\]/.test(source)
+    || !/\basync\b|function\s*\*|\bFunction\b/.test(source)) {
+    return { code: source, rewritten: false };
+  }
+  let program;
+  try {
+    program = Parser.parse(source, { ecmaVersion: "latest", sourceType, allowHashBang: true });
+  } catch {
+    return { code: source, rewritten: false };
+  }
+  const inserts = [];
+  const visit = (node, parent, key) => {
+    if (!node || typeof node.type !== "string") return;
+    if (node.type === "MemberExpression" && !node.optional && isConstructorKey(node)
+      && node.object.type !== "Super" && !isWrite(parent, key)) {
+      // $buninu$constructor( <object> ) and drop ".constructor" / ["constructor"],
+      // which may follow the object's closing parenthesis. A call passes true
+      // so the helper keeps the object as the receiver.
+      const call = parent?.type === "CallExpression" && key === "callee";
+      const accessor = source.lastIndexOf(node.computed ? "[" : ".", node.property.start);
+      inserts.push({ at: node.object.start, text: `${CONSTRUCTOR_HELPER}(`, end: null });
+      inserts.push({ at: node.object.end, text: call ? ", true)" : ")", end: null });
+      inserts.push({ at: accessor, text: "", end: node.end });
+    }
+    if (node.type === "ChainExpression") return;
+    for (const [name, value] of Object.entries(node)) {
+      if (name === "type" || name === "start" || name === "end") continue;
+      for (const child of Array.isArray(value) ? value : [value]) {
+        if (child && typeof child === "object") visit(child, node, name);
+      }
+    }
+  };
+  visit(program, null, null);
+  if (!inserts.length) return { code: source, rewritten: false };
+  // Apply from the end; at one position the removal goes first so the
+  // insertion lands before what follows it.
+  inserts.sort((left, right) => right.at - left.at || (left.end === null) - (right.end === null));
+  let code = source;
+  for (const { at, text, end } of inserts) code = code.slice(0, at) + text + code.slice(end ?? at);
+  return { code, rewritten: true };
+}
+
+function isConstructorKey(node) {
+  return node.computed
+    ? node.property.type === "Literal" && node.property.value === "constructor"
+    : node.property.type === "Identifier" && node.property.name === "constructor";
+}
+
+function isWrite(parent, key) {
+  if (!parent) return false;
+  if ((parent.type === "AssignmentExpression" || parent.type === "AssignmentPattern") && key === "left") return true;
+  if (parent.type === "UpdateExpression") return true;
+  if (parent.type === "UnaryExpression" && parent.operator === "delete") return true;
+  return (parent.type === "ForInStatement" || parent.type === "ForOfStatement") && key === "left";
+}

package/lib/renderer/seccomp.js

@@ -0,0 +1,215 @@
+/**
+ * seccomp-bpf sandbox for the renderer process.
+ *
+ * The policy is an allowlist modelled on Chromium's renderer baseline
+ * (sandbox/linux/seccomp-bpf-helpers/baseline_policy.cc): anything not listed
+ * fails with EPERM; clone() may only create threads; clone3() reports ENOSYS
+ * so libc falls back to the inspectable clone(); signals may only target this
+ * process. Syscall numbers come from Chromium's
+ * sandbox/linux/system_headers/{x86_64,arm64}_linux_syscalls.h.
+ *
+ * The filter is installed with SECCOMP_FILTER_FLAG_TSYNC because Bun is
+ * multi-threaded from startup. Everything the renderer needs from the file
+ * system must be loaded before installation: open() is not allowed after it.
+ *
+ * Installing requires bun:ffi (libc's syscall()); AGENTS.md permits dlopen of
+ * libc when no other mechanism exists, which is the case for seccomp.
+ */
+import { dlopen, ptr } from "bun:ffi";
+import { SYSCALL_NUMBERS } from "./syscall-numbers.js";
+
+/**
+ * Syscalls the renderer may use after startup. The base sets are Chromium's
+ * unconditional baseline (IsBaselinePolicyAllowed in baseline_policy.cc); the
+ * rest are syscalls Chromium allows with argument checks, allowed here
+ * without them for now, plus what a strace of the renderer workload (load,
+ * resize, raster, scroll, hints, hit testing) showed Bun/JSC need.
+ * clone, clone3, kill, tgkill and prctl are handled separately with argument
+ * checks.
+ */
+export const ALLOWED_SYSCALLS = Object.freeze([
+  // Address space (Chromium: IsAllowedAddressSpaceAccess, mmap/mprotect/madvise restricted).
+  "brk", "mmap", "munmap", "mprotect", "mremap", "madvise", "mlock", "munlock", "mseal", "mincore",
+  // Scheduling (IsAllowedBasicScheduler; own-thread affinity queries).
+  "nanosleep", "pause", "sched_yield", "sched_getaffinity", "sched_getparam", "sched_getscheduler", "getpriority",
+  // Event loop (IsAllowedEpoll, IsEventFd). epoll_pwait2 is Bun's event loop wait.
+  "epoll_create", "epoll_create1", "epoll_ctl", "epoll_pwait", "epoll_pwait2", "epoll_wait", "eventfd", "eventfd2",
+  // I/O on already-open descriptors (IsAllowedGeneralIo, IsAllowedFileSystemAccessViaFd).
+  "read", "readv", "pread64", "write", "writev", "lseek", "poll", "ppoll", "select", "pselect6",
+  "recvfrom", "recvmsg", "recvmmsg", "sendto", "sendmsg", "fstat", "ftruncate",
+  // Descriptor operations (IsAllowedOperationOnFd); fcntl is argument-restricted in Chromium.
+  "close", "dup", "dup2", "dup3", "fcntl", "shutdown",
+  // Futexes and time (IsAllowedFutex; clock_* are clock-id restricted in Chromium).
+  "futex", "clock_gettime", "clock_getres", "clock_nanosleep", "gettimeofday", "time",
+  // Signals (IsAllowedSignalHandling). rt_sigsuspend: JSC suspends threads for GC.
+  "rt_sigaction", "rt_sigprocmask", "rt_sigreturn", "rt_sigtimedwait", "rt_sigsuspend", "sigaltstack",
+  // Identity (IsGetSimpleId).
+  "getpid", "getppid", "gettid", "getuid", "geteuid", "getgid", "getegid", "getgroups",
+  "getresuid", "getresgid", "getsid", "capget",
+  // Thread and process lifetime (IsAllowedProcessStartOrDeath; no fork/exec).
+  "exit", "exit_group", "wait4", "waitid", "restart_syscall", "rseq",
+  // Misc allowed by Chromium's baseline.
+  "uname", "getrandom",
+]);
+
+// prctl options a renderer may use: thread names (JSC, Bun) and Android's
+// anonymous-mapping names. Everything else, e.g. PR_SET_DUMPABLE, is refused.
+const PRCTL_ALLOWED = Object.freeze([15 /* PR_SET_NAME */, 16 /* PR_GET_NAME */, 0x53564d41 /* PR_SET_VMA */]);
+
+const AUDIT_ARCH = Object.freeze({ x64: 0xc000003e, arm64: 0xc00000b7 });
+const X32_SYSCALL_BIT = 0x40000000;
+const CLONE_THREAD = 0x00010000;
+const RET_KILL_PROCESS = 0x80000000;
+const RET_ALLOW = 0x7fff0000;
+const retErrno = (errno) => 0x00050000 | (errno & 0xffff);
+const EPERM = 1;
+const ENOSYS = 38;
+const SECCOMP_SET_MODE_FILTER = 1;
+const SECCOMP_FILTER_FLAG_TSYNC = 1;
+const PR_SET_NO_NEW_PRIVS = 38;
+
+// struct seccomp_data offsets.
+const DATA_NR = 0;
+const DATA_ARCH = 4;
+const DATA_ARG0_LOW = 16;
+
+// BPF opcodes.
+const LD_W_ABS = 0x20;
+const JEQ_K = 0x15;
+const JGE_K = 0x35;
+const JSET_K = 0x45;
+const RET_K = 0x06;
+
+/**
+ * Builds the filter program for an architecture as [code, jt, jf, k] tuples.
+ * @param {"x64" | "arm64"} arch
+ * @param {number} pid the process allowed as a signal target
+ * @param {readonly string[]} allowed syscall names
+ */
+export function buildFilter(arch, pid, allowed = ALLOWED_SYSCALLS) {
+  const numbers = SYSCALL_NUMBERS[arch];
+  if (!numbers) throw new Error(`no seccomp syscall table for ${arch}`);
+  const nr = (name) => {
+    const value = numbers[name];
+    if (value == null) throw new Error(`unknown ${arch} syscall ${name}`);
+    return value;
+  };
+  const program = [
+    [LD_W_ABS, 0, 0, DATA_ARCH],
+    [JEQ_K, 1, 0, AUDIT_ARCH[arch]],
+    [RET_K, 0, 0, RET_KILL_PROCESS],
+    [LD_W_ABS, 0, 0, DATA_NR],
+  ];
+  if (arch === "x64") {
+    // The x32 ABI reuses x86-64 numbers with bit 30 set; never allow it.
+    program.push([JGE_K, 0, 1, X32_SYSCALL_BIT], [RET_K, 0, 0, retErrno(EPERM)]);
+  }
+  // clone(): threads only (CLONE_THREAD), never new processes or namespaces.
+  program.push(
+    [JEQ_K, 0, 4, nr("clone")],
+    [LD_W_ABS, 0, 0, DATA_ARG0_LOW],
+    [JSET_K, 1, 0, CLONE_THREAD],
+    [RET_K, 0, 0, retErrno(EPERM)],
+    [RET_K, 0, 0, RET_ALLOW],
+    [LD_W_ABS, 0, 0, DATA_NR],
+  );
+  program.push([JEQ_K, 0, 1, nr("clone3")], [RET_K, 0, 0, retErrno(ENOSYS)]);
+  // kill(pid, ...) and tgkill(tgid, ...): only this process.
+  for (const name of ["kill", "tgkill"]) {
+    program.push(
+      [JEQ_K, 0, 4, nr(name)],
+      [LD_W_ABS, 0, 0, DATA_ARG0_LOW],
+      [JEQ_K, 1, 0, pid],
+      [RET_K, 0, 0, retErrno(EPERM)],
+      [RET_K, 0, 0, RET_ALLOW],
+      [LD_W_ABS, 0, 0, DATA_NR],
+    );
+  }
+  // prctl(option, ...): only the options in PRCTL_ALLOWED.
+  program.push(
+    [JEQ_K, 0, 3 + PRCTL_ALLOWED.length, nr("prctl")],
+    [LD_W_ABS, 0, 0, DATA_ARG0_LOW],
+    ...PRCTL_ALLOWED.map((option, index) => [JEQ_K, PRCTL_ALLOWED.length - index, 0, option]),
+    [RET_K, 0, 0, retErrno(EPERM)],
+    [RET_K, 0, 0, RET_ALLOW],
+    [LD_W_ABS, 0, 0, DATA_NR],
+  );
+  for (const name of new Set(allowed)) {
+    if (["clone", "clone3", "kill", "tgkill", "prctl"].includes(name)) continue;
+    // Some syscalls exist on only one architecture (e.g. x86-64 open, poll).
+    if (numbers[name] == null) continue;
+    program.push([JEQ_K, 0, 1, numbers[name]], [RET_K, 0, 0, RET_ALLOW]);
+  }
+  program.push([RET_K, 0, 0, retErrno(EPERM)]);
+  return program;
+}
+
+/** Serialises a filter program into struct sock_filter[] bytes. */
+export function encodeFilter(program) {
+  const bytes = new DataView(new ArrayBuffer(program.length * 8));
+  program.forEach(([code, jt, jf, k], index) => {
+    bytes.setUint16(index * 8, code, true);
+    bytes.setUint8(index * 8 + 2, jt);
+    bytes.setUint8(index * 8 + 3, jf);
+    bytes.setUint32(index * 8 + 4, k >>> 0, true);
+  });
+  return bytes.buffer;
+}
+
+const LIBC_CANDIDATES = Object.freeze([
+  "libc.so.6",
+  "libc.so",
+  "/lib/ld-musl-x86_64.so.1",
+  "/lib/ld-musl-aarch64.so.1",
+]);
+
+function openLibc() {
+  for (const path of LIBC_CANDIDATES) {
+    try {
+      return dlopen(path, {
+        syscall: { args: ["i64", "i64", "i64", "i64", "i64", "i64"], returns: "i64" },
+      });
+    } catch {
+      // Try the next libc name (glibc, bionic, musl).
+    }
+  }
+  return null;
+}
+
+/**
+ * Installs the renderer filter on every thread of this process.
+ * Never throws: returns { installed: false, reason } when the platform cannot
+ * provide the sandbox, so callers can report and continue.
+ */
+export function installSeccomp({ arch = process.arch, pid = process.pid, allowed = ALLOWED_SYSCALLS } = {}) {
+  if (process.platform !== "linux" && process.platform !== "android") {
+    return { installed: false, reason: `seccomp is Linux-only (${process.platform})` };
+  }
+  if (!SYSCALL_NUMBERS[arch]) return { installed: false, reason: `unsupported architecture ${arch}` };
+  const libc = openLibc();
+  if (!libc) return { installed: false, reason: "libc not found for bun:ffi" };
+  try {
+    const numbers = SYSCALL_NUMBERS[arch];
+    const program = buildFilter(arch, pid, allowed);
+    const filter = encodeFilter(program);
+    // struct sock_fprog { unsigned short len; struct sock_filter *filter; }
+    const fprog = new DataView(new ArrayBuffer(16));
+    fprog.setUint16(0, program.length, true);
+    fprog.setBigUint64(8, BigInt(ptr(filter)), true);
+    const call = libc.symbols.syscall;
+    // no_new_privs lets an unprivileged process install a filter; TSYNC
+    // copies it to every other thread.
+    if (Number(call(numbers.prctl, PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) !== 0) {
+      return { installed: false, reason: "prctl(PR_SET_NO_NEW_PRIVS) failed" };
+    }
+    const result = Number(call(numbers.seccomp, SECCOMP_SET_MODE_FILTER, SECCOMP_FILTER_FLAG_TSYNC, ptr(fprog.buffer), 0, 0));
+    if (result !== 0) {
+      return { installed: false, reason: result > 0 ? `thread ${result} could not be synchronised` : "seccomp() failed" };
+    }
+    return { installed: true, instructions: program.length };
+  } catch (error) {
+    return { installed: false, reason: String(error?.message ?? error) };
+  } finally {
+    libc.close();
+  }
+}

package/lib/renderer/syscall-numbers.js

@@ -0,0 +1,139 @@
+/**
+ * Linux syscall numbers by architecture, generated from Chromium's
+ * sandbox/linux/system_headers/x86_64_linux_syscalls.h (Copyright 2012 The
+ * Chromium Authors) and arm64_linux_syscalls.h (Copyright 2014 The Chromium
+ * Authors), chromium/src@2e7327eeeab051c4837bc03a17cbeae763449bcd.
+ * BSD-3-Clause; see LICENSES/chromium.txt. Keys match `process.arch`.
+ */
+export const SYSCALL_NUMBERS = Object.freeze({
+  x64: Object.freeze({
+    read: 0, write: 1, open: 2, close: 3, stat: 4, fstat: 5, lstat: 6, poll: 7, lseek: 8, mmap: 9,
+    mprotect: 10, munmap: 11, brk: 12, rt_sigaction: 13, rt_sigprocmask: 14, rt_sigreturn: 15,
+    ioctl: 16, pread64: 17, pwrite64: 18, readv: 19, writev: 20, access: 21, pipe: 22, select: 23,
+    sched_yield: 24, mremap: 25, msync: 26, mincore: 27, madvise: 28, shmget: 29, shmat: 30,
+    shmctl: 31, dup: 32, dup2: 33, pause: 34, nanosleep: 35, getitimer: 36, alarm: 37,
+    setitimer: 38, getpid: 39, sendfile: 40, socket: 41, connect: 42, accept: 43, sendto: 44,
+    recvfrom: 45, sendmsg: 46, recvmsg: 47, shutdown: 48, bind: 49, listen: 50, getsockname: 51,
+    getpeername: 52, socketpair: 53, setsockopt: 54, getsockopt: 55, clone: 56, fork: 57, vfork: 58,
+    execve: 59, exit: 60, wait4: 61, kill: 62, uname: 63, semget: 64, semop: 65, semctl: 66,
+    shmdt: 67, msgget: 68, msgsnd: 69, msgrcv: 70, msgctl: 71, fcntl: 72, flock: 73, fsync: 74,
+    fdatasync: 75, truncate: 76, ftruncate: 77, getdents: 78, getcwd: 79, chdir: 80, fchdir: 81,
+    rename: 82, mkdir: 83, rmdir: 84, creat: 85, link: 86, unlink: 87, symlink: 88, readlink: 89,
+    chmod: 90, fchmod: 91, chown: 92, fchown: 93, lchown: 94, umask: 95, gettimeofday: 96,
+    getrlimit: 97, getrusage: 98, sysinfo: 99, times: 100, ptrace: 101, getuid: 102, syslog: 103,
+    getgid: 104, setuid: 105, setgid: 106, geteuid: 107, getegid: 108, setpgid: 109, getppid: 110,
+    getpgrp: 111, setsid: 112, setreuid: 113, setregid: 114, getgroups: 115, setgroups: 116,
+    setresuid: 117, getresuid: 118, setresgid: 119, getresgid: 120, getpgid: 121, setfsuid: 122,
+    setfsgid: 123, getsid: 124, capget: 125, capset: 126, rt_sigpending: 127, rt_sigtimedwait: 128,
+    rt_sigqueueinfo: 129, rt_sigsuspend: 130, sigaltstack: 131, utime: 132, mknod: 133, uselib: 134,
+    personality: 135, ustat: 136, statfs: 137, fstatfs: 138, sysfs: 139, getpriority: 140,
+    setpriority: 141, sched_setparam: 142, sched_getparam: 143, sched_setscheduler: 144,
+    sched_getscheduler: 145, sched_get_priority_max: 146, sched_get_priority_min: 147,
+    sched_rr_get_interval: 148, mlock: 149, munlock: 150, mlockall: 151, munlockall: 152,
+    vhangup: 153, modify_ldt: 154, pivot_root: 155, _sysctl: 156, prctl: 157, arch_prctl: 158,
+    adjtimex: 159, setrlimit: 160, chroot: 161, sync: 162, acct: 163, settimeofday: 164, mount: 165,
+    umount2: 166, swapon: 167, swapoff: 168, reboot: 169, sethostname: 170, setdomainname: 171,
+    iopl: 172, ioperm: 173, create_module: 174, init_module: 175, delete_module: 176,
+    get_kernel_syms: 177, query_module: 178, quotactl: 179, nfsservctl: 180, getpmsg: 181,
+    putpmsg: 182, afs_syscall: 183, tuxcall: 184, security: 185, gettid: 186, readahead: 187,
+    setxattr: 188, lsetxattr: 189, fsetxattr: 190, getxattr: 191, lgetxattr: 192, fgetxattr: 193,
+    listxattr: 194, llistxattr: 195, flistxattr: 196, removexattr: 197, lremovexattr: 198,
+    fremovexattr: 199, tkill: 200, time: 201, futex: 202, sched_setaffinity: 203,
+    sched_getaffinity: 204, set_thread_area: 205, io_setup: 206, io_destroy: 207, io_getevents: 208,
+    io_submit: 209, io_cancel: 210, get_thread_area: 211, lookup_dcookie: 212, epoll_create: 213,
+    epoll_ctl_old: 214, epoll_wait_old: 215, remap_file_pages: 216, getdents64: 217,
+    set_tid_address: 218, restart_syscall: 219, semtimedop: 220, fadvise64: 221, timer_create: 222,
+    timer_settime: 223, timer_gettime: 224, timer_getoverrun: 225, timer_delete: 226,
+    clock_settime: 227, clock_gettime: 228, clock_getres: 229, clock_nanosleep: 230,
+    exit_group: 231, epoll_wait: 232, epoll_ctl: 233, tgkill: 234, utimes: 235, vserver: 236,
+    mbind: 237, set_mempolicy: 238, get_mempolicy: 239, mq_open: 240, mq_unlink: 241,
+    mq_timedsend: 242, mq_timedreceive: 243, mq_notify: 244, mq_getsetattr: 245, kexec_load: 246,
+    waitid: 247, add_key: 248, request_key: 249, keyctl: 250, ioprio_set: 251, ioprio_get: 252,
+    inotify_init: 253, inotify_add_watch: 254, inotify_rm_watch: 255, migrate_pages: 256,
+    openat: 257, mkdirat: 258, mknodat: 259, fchownat: 260, futimesat: 261, newfstatat: 262,
+    unlinkat: 263, renameat: 264, linkat: 265, symlinkat: 266, readlinkat: 267, fchmodat: 268,
+    faccessat: 269, pselect6: 270, ppoll: 271, unshare: 272, set_robust_list: 273,
+    get_robust_list: 274, splice: 275, tee: 276, sync_file_range: 277, vmsplice: 278,
+    move_pages: 279, utimensat: 280, epoll_pwait: 281, signalfd: 282, timerfd_create: 283,
+    eventfd: 284, fallocate: 285, timerfd_settime: 286, timerfd_gettime: 287, accept4: 288,
+    signalfd4: 289, eventfd2: 290, epoll_create1: 291, dup3: 292, pipe2: 293, inotify_init1: 294,
+    preadv: 295, pwritev: 296, rt_tgsigqueueinfo: 297, perf_event_open: 298, recvmmsg: 299,
+    fanotify_init: 300, fanotify_mark: 301, prlimit64: 302, name_to_handle_at: 303,
+    open_by_handle_at: 304, clock_adjtime: 305, syncfs: 306, sendmmsg: 307, setns: 308, getcpu: 309,
+    process_vm_readv: 310, process_vm_writev: 311, kcmp: 312, finit_module: 313, sched_setattr: 314,
+    sched_getattr: 315, renameat2: 316, seccomp: 317, getrandom: 318, memfd_create: 319,
+    kexec_file_load: 320, bpf: 321, execveat: 322, userfaultfd: 323, membarrier: 324, mlock2: 325,
+    copy_file_range: 326, preadv2: 327, pwritev2: 328, pkey_mprotect: 329, pkey_alloc: 330,
+    pkey_free: 331, statx: 332, io_pgetevents: 333, rseq: 334, uretprobe: 335, uprobe: 336,
+    pidfd_send_signal: 424, io_uring_setup: 425, io_uring_enter: 426, io_uring_register: 427,
+    open_tree: 428, move_mount: 429, fsopen: 430, fsconfig: 431, fsmount: 432, fspick: 433,
+    pidfd_open: 434, clone3: 435, close_range: 436, openat2: 437, pidfd_getfd: 438, faccessat2: 439,
+    process_madvise: 440, epoll_pwait2: 441, mount_setattr: 442, landlock_create_ruleset: 444,
+    landlock_add_rule: 445, landlock_restrict_self: 446, memfd_secret: 447, process_mrelease: 448,
+    futex_waitv: 449, set_mempolicy_home_node: 450, cachestat: 451, fchmodat2: 452,
+    map_shadow_stack: 453, futex_wake: 454, futex_wait: 455, futex_requeue: 456, statmount: 457,
+    listmount: 458, lsm_get_self_attr: 459, lsm_set_self_attr: 460, lsm_list_modules: 461,
+    mseal: 462,
+  }),
+  arm64: Object.freeze({
+    io_setup: 0, io_destroy: 1, io_submit: 2, io_cancel: 3, io_getevents: 4, setxattr: 5,
+    lsetxattr: 6, fsetxattr: 7, getxattr: 8, lgetxattr: 9, fgetxattr: 10, listxattr: 11,
+    llistxattr: 12, flistxattr: 13, removexattr: 14, lremovexattr: 15, fremovexattr: 16, getcwd: 17,
+    lookup_dcookie: 18, eventfd2: 19, epoll_create1: 20, epoll_ctl: 21, epoll_pwait: 22, dup: 23,
+    dup3: 24, fcntl: 25, inotify_init1: 26, inotify_add_watch: 27, inotify_rm_watch: 28, ioctl: 29,
+    ioprio_set: 30, ioprio_get: 31, flock: 32, mknodat: 33, mkdirat: 34, unlinkat: 35,
+    symlinkat: 36, linkat: 37, renameat: 38, umount2: 39, mount: 40, pivot_root: 41, nfsservctl: 42,
+    statfs: 43, fstatfs: 44, truncate: 45, ftruncate: 46, fallocate: 47, faccessat: 48, chdir: 49,
+    fchdir: 50, chroot: 51, fchmod: 52, fchmodat: 53, fchownat: 54, fchown: 55, openat: 56,
+    close: 57, vhangup: 58, pipe2: 59, quotactl: 60, getdents64: 61, lseek: 62, read: 63, write: 64,
+    readv: 65, writev: 66, pread64: 67, pwrite64: 68, preadv: 69, pwritev: 70, sendfile: 71,
+    pselect6: 72, ppoll: 73, signalfd4: 74, vmsplice: 75, splice: 76, tee: 77, readlinkat: 78,
+    newfstatat: 79, fstat: 80, sync: 81, fsync: 82, fdatasync: 83, sync_file_range: 84,
+    timerfd_create: 85, timerfd_settime: 86, timerfd_gettime: 87, utimensat: 88, acct: 89,
+    capget: 90, capset: 91, personality: 92, exit: 93, exit_group: 94, waitid: 95,
+    set_tid_address: 96, unshare: 97, futex: 98, set_robust_list: 99, get_robust_list: 100,
+    nanosleep: 101, getitimer: 102, setitimer: 103, kexec_load: 104, init_module: 105,
+    delete_module: 106, timer_create: 107, timer_gettime: 108, timer_getoverrun: 109,
+    timer_settime: 110, timer_delete: 111, clock_settime: 112, clock_gettime: 113,
+    clock_getres: 114, clock_nanosleep: 115, syslog: 116, ptrace: 117, sched_setparam: 118,
+    sched_setscheduler: 119, sched_getscheduler: 120, sched_getparam: 121, sched_setaffinity: 122,
+    sched_getaffinity: 123, sched_yield: 124, sched_get_priority_max: 125,
+    sched_get_priority_min: 126, sched_rr_get_interval: 127, restart_syscall: 128, kill: 129,
+    tkill: 130, tgkill: 131, sigaltstack: 132, rt_sigsuspend: 133, rt_sigaction: 134,
+    rt_sigprocmask: 135, rt_sigpending: 136, rt_sigtimedwait: 137, rt_sigqueueinfo: 138,
+    rt_sigreturn: 139, setpriority: 140, getpriority: 141, reboot: 142, setregid: 143, setgid: 144,
+    setreuid: 145, setuid: 146, setresuid: 147, getresuid: 148, setresgid: 149, getresgid: 150,
+    setfsuid: 151, setfsgid: 152, times: 153, setpgid: 154, getpgid: 155, getsid: 156, setsid: 157,
+    getgroups: 158, setgroups: 159, uname: 160, sethostname: 161, setdomainname: 162,
+    getrlimit: 163, setrlimit: 164, getrusage: 165, umask: 166, prctl: 167, getcpu: 168,
+    gettimeofday: 169, settimeofday: 170, adjtimex: 171, getpid: 172, getppid: 173, getuid: 174,
+    geteuid: 175, getgid: 176, getegid: 177, gettid: 178, sysinfo: 179, mq_open: 180,
+    mq_unlink: 181, mq_timedsend: 182, mq_timedreceive: 183, mq_notify: 184, mq_getsetattr: 185,
+    msgget: 186, msgctl: 187, msgrcv: 188, msgsnd: 189, semget: 190, semctl: 191, semtimedop: 192,
+    semop: 193, shmget: 194, shmctl: 195, shmat: 196, shmdt: 197, socket: 198, socketpair: 199,
+    bind: 200, listen: 201, accept: 202, connect: 203, getsockname: 204, getpeername: 205,
+    sendto: 206, recvfrom: 207, setsockopt: 208, getsockopt: 209, shutdown: 210, sendmsg: 211,
+    recvmsg: 212, readahead: 213, brk: 214, munmap: 215, mremap: 216, add_key: 217,
+    request_key: 218, keyctl: 219, clone: 220, execve: 221, mmap: 222, fadvise64: 223, swapon: 224,
+    swapoff: 225, mprotect: 226, msync: 227, mlock: 228, munlock: 229, mlockall: 230,
+    munlockall: 231, mincore: 232, madvise: 233, remap_file_pages: 234, mbind: 235,
+    get_mempolicy: 236, set_mempolicy: 237, migrate_pages: 238, move_pages: 239,
+    rt_tgsigqueueinfo: 240, perf_event_open: 241, accept4: 242, recvmmsg: 243, wait4: 260,
+    prlimit64: 261, fanotify_init: 262, fanotify_mark: 263, name_to_handle_at: 264,
+    open_by_handle_at: 265, clock_adjtime: 266, syncfs: 267, setns: 268, sendmmsg: 269,
+    process_vm_readv: 270, process_vm_writev: 271, kcmp: 272, finit_module: 273, sched_setattr: 274,
+    sched_getattr: 275, renameat2: 276, seccomp: 277, getrandom: 278, memfd_create: 279, bpf: 280,
+    execveat: 281, userfaultfd: 282, membarrier: 283, mlock2: 284, copy_file_range: 285,
+    preadv2: 286, pwritev2: 287, pkey_mprotect: 288, pkey_alloc: 289, pkey_free: 290, statx: 291,
+    io_pgetevents: 292, rseq: 293, kexec_file_load: 294, pidfd_send_signal: 424,
+    io_uring_setup: 425, io_uring_enter: 426, io_uring_register: 427, open_tree: 428,
+    move_mount: 429, fsopen: 430, fsconfig: 431, fsmount: 432, fspick: 433, pidfd_open: 434,
+    clone3: 435, close_range: 436, openat2: 437, pidfd_getfd: 438, faccessat2: 439,
+    process_madvise: 440, epoll_pwait2: 441, mount_setattr: 442, quotactl_path: 443,
+    landlock_create_ruleset: 444, landlock_add_rule: 445, landlock_restrict_self: 446,
+    memfd_secret: 447, process_mrelease: 448, futex_waitv: 449, set_mempolicy_home_node: 450,
+    cachestat: 451, fchmodat2: 452, map_shadow_stack: 453, futex_wake: 454, futex_wait: 455,
+    futex_requeue: 456, statmount: 457, listmount: 458, lsm_get_self_attr: 459,
+    lsm_set_self_attr: 460, lsm_list_modules: 461, mseal: 462,
+  }),
+});