Zurück zu den Updates
New releaseJul 27, 2026

Z-Jail v1.1.0

Eine leichtgewichtige, mehrschichtige Linux-Sandbox, die Namensräume, pivot_root, seccomp-bpf, Capability-Dropping und eine evidenzbasierte Bewertungsengine (Truthimatics Public Version) für sichere, nachvollziehbare Codeausführung kombiniert.

Teilen
Z-Jail

Z-Jail

Mehrschichtige Sandbox für die Ausführung nativen Codes unter Linux.
Sieben geordnete Isolationsschichten — keine externen Abhängigkeiten, ~81 KiB PIE-Binary.


┌──────────────────────────────────────────────────────┐
│                    Z-Jail                            │
├──────────────────────────────────────────────────────┤
│  rlimits           (CPU, AS, NOFILE, NPROC caps)     │
│  Namespaces       (mount, pid, net, ipc, uts)        │
│  pivot_root       (chroot on steroids)               │
│  NO_NEW_PRIVS     (no privilege escalation)          │
│  Capabilities     (drop all, lock securebits)        │
│  seccomp-BPF      (whitelist-v1: 24 syscalls)        │
│  Audit            (JSON logging + BLAKE2b hashing)   │
└──────────────────────────────────────────────────────┘

Inhaltsverzeichnis


Schnellstart

git clone https://github.com/Division-36/Z-Jail.git
cd Z-Jail
make
sudo ./z_jail --root=/path/to/rootfs --seccomp-enforce -- /bin/ls

Das --root-Verzeichnis sollte ein minimales Dateisystem mit dem Ziel-Binary und seinen Abhängigkeiten enthalten (für statische Binaries reicht das Binary allein aus).


Warum Z-Jail

Bestehende Sandboxing-Lösungen gehen Kompromisse ein:

Z-JailFirecrackergVisorbwrapnsjail
Externe Abhängigkeitenkeinelibc, seccompGo-Runtimelibclibc, protobuf
Binärgröße~81 KiB20+ MiB40+ MiB~70 KiB~1 MiB
VM-Isolationneinja (microVM)nein (Sandbox)neinnein
seccomp-Whitelistjaneinjaoptionalja
Content-Hashingjaneinneinneinnein
Audit-JSONjaneinjaneinteilweise
Build-Komplexitätein makekomplexkomplextrivialmoderat

Z-Jail füllt die Nische zwischen bwrap (minimal, standardmäßig kein seccomp) und nsjail (funktionsreich, schwere Abhängigkeiten). Es ist für CI-Pipelines, CTF-Jail-Challenges und leichtgewichtige Code-Evaluierung konzipiert, wo du Defence-in-Depth benötigst, ohne eine Container-Runtime einzubinden.


Architektur

Datenfluss

flowchart LR
    CLI[CLI args] --> P[parse_args]
    P --> C{clone namespaces}
    C -->|child| CR[child_run]
    C -->|parent| W[waitpid]
    CR --> RL[setrlimit]
    RL --> FD[close fds >= 3]
    FD --> DUMP[PR_SET_DUMPABLE=0]
    DUMP --> PV[pivot_root]
    PV --> NNP[PR_SET_NO_NEW_PRIVS]
    NNP --> CAP[drop capabilities]
    CAP --> SC[seccomp-BPF]
    SC --> SIG[signal parent]
    SIG --> EX[execve target]
    W --> A[audit JSON]
    A --> EXIT[exit]

Schichtreihenfolge

Jede Schicht ist so angeordnet, dass eine spätere Schicht nicht durch eine frühere rückgängig gemacht werden kann:

  1. setrlimit — CPU, Adressraum, Dateianzahl, Prozesse begrenzen, bevor irgendetwas anderes geschieht
  2. fd scrub — alle geerbten fds außer der Report-Pipe schließen
  3. PR_SET_DUMPABLE=0 — Core Dumps deaktiviert, /proc/self/mem abgeriegelt
  4. pivot_root — vom Host-Dateisystem lösen; altes Root lazy unmounted
  5. PR_SET_NO_NEW_PRIVS — kein setuid, keine capset-Eskalation nach diesem Punkt
  6. drop_caps — alle Capabilities auf null setzen, securebits sperren
  7. seccomp-BPF — Syscalls auf Whitelist beschränken
  8. signal parent — dem Parent mitteilen, dass die Sandbox bereit ist
  9. execve — Prozess durch die Ziel-Binary ersetzen
sequenceDiagram
    participant P as Parent
    participant C as Child
    P->>C: clone (NEWNS|NEWPID|NEWNET|NEWIPC|NEWUTS)
    Note over C: setrlimit(CPU, AS, NOFILE, NPROC)
    Note over C: close(all fds > 2)
    Note over C: PR_SET_DUMPABLE=0
    Note over C: pivot_root → chdir("/") → umount -l
    Note over C: PR_SET_NO_NEW_PRIVS
    Note over C: capset(all zero) + securebits
    Note over C: seccomp(SECCOMP_MODE_FILTER, whitelist)
    C->>P: write(pipe, ready=1)
    Note over C: execve(target)
    P->>P: waitpid
    P->>P: write audit JSON

Ebenen

Z-Jail wendet sieben geordnete Isolationsmechanismen im Kindprozess vor execve an, jeder so gewählt, dass ein späterer Schritt nicht durch erneutes Ausführen eines früheren rückgängig gemacht werden kann. Der Elternprozess erzeugt den Kindprozess mit clone() und fordert fünf Namespaces an (Mount, PID, Netzwerk, IPC, UTS), anschließend führt der Kindprozess die folgende Pipeline aus:

1. Ressourcenlimits

setrlimit begrenzt CPU-Zeit, Adressraum, offene Dateien und Prozessanzahl, bevor jeglicher vom Gast beeinflusster Code läuft, und beschränkt Fork-Bomben und Speichererschöpfung.

2. Bereinigung der Dateideskriptoren

Alle geerbten Deskriptoren außer der Report-Pipe zum Elternprozess werden geschlossen, wodurch verhindert wird, dass geleakte Handles execve überqueren.

3. Dumpbarkeit deaktiviert

PR_SET_DUMPABLE=0 deaktiviert Core Dumps und beschränkt den Zugriff auf /proc/self/mem.

4. pivot_root

Das Root des Mount-Namespace wird durch das übergebene Root-Verzeichnis ersetzt: Das Verzeichnis wird auf sich selbst bind-gemountet, pivot_root tauscht den Mount-Baum, der Prozess führt chdir zum neuen Root aus, und das alte Root wird lazy abgehängt und entfernt. Dies ist strikt stärker als chroot(2), da das vorherige Root ausgehängt und nicht bloß verborgen wird.

5. NO_NEW_PRIVS

PR_SET_NO_NEW_PRIVS verhindert jeden nachfolgenden Privilegiengewinn durch setuid- Binaries, Datei-Capabilities oder LSM-Übergänge. Unumkehrbar.

6. Capability-Drop

Benutzer- und Gruppen-IDs werden geändert, während CAP_SETUID noch gehalten wird, wonach capset alle Capability-Sets auf null setzt und die Securebits gesperrt werden, sodass Capabilities nicht wieder aktiviert werden können.

7. seccomp-BPF (Whitelist-v1)

Ein Whitelist-Filter wird installiert; nicht auf der Whitelist stehende Aufrufe werden beendet. Allow-List von 24 Syscalls:

Kategorien