Crate proot 

PRoot reimplemented in Rust.

The program runs a command inside a guest root filesystem without any privilege. Path-taking syscalls are routed through seccomp user notification and answered by a small pool of supervisor threads; only the syscalls that must change the tracee’s own state in place (execve, chdir, unix socket bind/connect) take a ptrace stop. Everything else runs untraced at native speed. Where ptrace is filtered out, those few syscalls are served through notifications too, with in-place rewrites (syscall::direct).

The binary behaves like bubblewrap when invoked through a name ending in bwrap, busybox style, so a symlink is enough to make it a drop-in.

Modules

abi 🔒

Syscall ABIs a tracee may use.

access 🔒

How the supervisor gets the right to reach its tracees.

cli 🔒

PRoot command-line front end (the subset proot-apps and users rely on).

config 🔒

Runtime configuration shared by both command-line front ends.

exec 🔒

execve handling at the ptrace stop.

fs 🔒

Guest filesystem view: the root, the bindings, and path translation.

guest_stub 🔒

The supervisor’s side of the guest-stub restricted mode.

launch 🔒

Starting the first tracee and wiring supervisor, listener and tracer.

procs 🔒

Per-process bookkeeping shared by every handler: the program a process runs, the identity it believes it has under -0 and, without ptrace, the working directory it believes it is in.

seccomp 🔒

Seccomp: the BPF filter the tracee installs, and the listener pool that answers user notifications.

state 🔒

Supervisor-wide shared state.

sys 🔒

Raw kernel ABI not covered (or not covered stably) by the libc crate: the seccomp user-notification structures and ioctls, plus small helpers.

syscall 🔒

Syscall routing: which numbers go where, and the handlers for each tier.

tracee 🔒

Access to a tracee: its memory and, at ptrace stops, its registers.

tracer 🔒

The ptrace event loop. Runs on the thread that forked the first tracee.

Macros

note

Logs to stderr when verbose is at least level.

Functions

main 🔒

Program entry point.