Leichte Fehlerisolierung (LFI)

Willkommen im übergeordneten Repository für das Projekt Lightweight Fault Isolation (LFI).

Was ist LFI?

LFI ist ein System zum Sandboxing von nativem Code. Wie WebAssembly und Native Client isoliert LFI sandboxed Code prozessintern (d.h. im selben Adressraum wie eine Host-Anwendung). Derzeit unterstützen wir Arm64- und x86-64-Ziele und haben experimentelle RISC-V-Unterstützung.

LFI wurde von Grund auf entwickelt, um vorhandenen Code zu sandboxen, wie C/C++-Bibliotheken (einschließlich Assembler-Code) und Gerätetreiber.

LFI verfolgt die folgenden Ziele:

• Kompatibilität: LFI kann verwendet werden, um nahezu alle vorhandenen C/C++/Assembler-Code unverändert zu sandboxen, funktioniert mit vorhandenen Systemaufrufschnittstellen usw.
• Leistung: LFI zielt auf minimale Overhead im Vergleich zu nicht gesandboxtem Code.
• Sicherheit: Die LFI-Laufzeit und Compiler-Elemente sollen nach Möglichkeit einfach und überprüfbar sein.
• Benutzerfreundlichkeit: Die Werkzeuge sollen es so einfach wie möglich machen, Sandboxing in vorhandenen Code nachzurüsten.

Nicht-Ziele sind ein stabiles Binärformat und Plattformunabhängigkeit. Wir werden alle architekturspezifischen Hardwarefunktionen und Compilertechniken nutzen, die die Leistung verbessern.

LFI verursacht derzeit einen Overhead von etwa 7 % (Arm64) oder 8 % (x86-64) im Vergleich zu nativem Code beim Sandboxing von Lese- und Schreibzugriffen, und 1,5 % (Arm64) oder 6 % (x86-64) Overhead beim ausschließlichen Sandboxing von Schreibzugriffen (geomean auf SPEC 2017). LFI-Kontextwechsel (d.h. zwischen Sandbox und Host-Anwendung) benötigen nur 10er von Zyklen, und LFI kann Tausende von Sandboxes in einem einzigen Adressraum unterstützen: ~64K (Arm64) oder ~3K (x86-64), wobei jede Sandbox bis zu 4 GiB Speicher erhält.

Repositories

• lfi-runtime: die Laufzeitumgebung, die für das Laden von LFI-Programmen, die Bearbeitung von Host-Aufrufen und die Durchführung der Verifikation verantwortlich ist.
• lfi-verifier: der LFI-Verifizierer.
• lfi-rewriter: der LFI-Rewriter für GNU-Assembler und ein Post-Linker-Werkzeug zur Durchführung von binären Transformationen nach dem Linken (nur auf x86-64 notwendig).
• lfi-bind: ein Werkzeug zur Generierung von Trampolinen und Initialisierungsroutinen für die Ausführung von Bibliotheken innerhalb von LFI-Sandboxes.
• lfi-llvm-toolchain: Skripte zum Erstellen einer LLVM-basierten LFI-Compiler-Toolchain, zusammen mit einem Sysroot, das compiler-rt, musl, libc++ und mimalloc enthält.
• llvm-project: unser Entwicklungsfork des LLVM-Projekts.
• lfi-specification: die LaTeX-Quellen für das LFI-Spezifikationsdokument.
• lfi-bench: eine Sammlung von Bibliotheken und Benchmarks zur Leistungsbewertung von LFI.

Erste Schritte

Um mit LFI zu beginnen, benötigen Sie einen LFI-Compiler. Sie erhalten einen von https://github.com/lfi-project/lfi-llvm-toolchain. Vorgefertigte aarch64 und x86-64-Compiler werden in den Releases bereitgestellt: https://github.com/lfi-project/lfi/releases/latest. Laden Sie das Paket aarch64-lfi-clang.tar.gz oder x86_64-lfi-clang.tar.gz herunter, je nach Ihrer Architektur (oder aarch64-lfi-clang-host-x86_64.tar.gz, wenn Sie von x86-64 nach aarch64 cross-compilieren möchten).

Nach dem Öffnen des Archivs sollten Sie eine Verzeichnisstruktur wie diese sehen:

├── bin
│   ├── LLVM tools (clang, lld, ...)
├── include
├── lfi-bin
│   ├── lfi-postlink
│   ├── lfi-rewrite
│   ├── lfi-run
│   ├── lfi-verify
│   ├── ARCH-lfi-linux-musl-clang -> ../bin/clang
│   └── ARCH-lfi-linux-musl-clang++ -> ../bin/clang++
├── lfi-clang
│   ├── ARCH-lfi-linux-musl-clang -> ../bin/clang
│   └── ARCH-lfi-linux-musl-clang++ -> ../bin/clang++
├── lib
├── libexec
├── share
└── sysroot

Sie sollten das Verzeichnis lfi-bin zu Ihrem PATH hinzufügen. Wenn Sie die LFI-Werkzeuge bereits über eine separate Installation installiert haben, sollten Sie stattdessen nur lfi-clang zu Ihrem PATH hinzufügen.

Sobald Sie einen Compiler haben, sollten Sie ein einfaches C- oder C++-Programm erstellen können:

#include <stdio.h>
int main() {
    printf("Hello from LFI\n");
    return 0;
}

Kompilieren und ausführen mit lfi-run:

$ aarch64-lfi-linux-musl-clang hello.c -O2 -o hello -static-pie
$ lfi-run -v ./hello
Hello from LFI

Sie können das vorgefertigte lfi-run-Werkzeug aus dem vorgefertigten Archiv verwenden. Sie können die LFI-Laufzeit auch einfach aus dem Quellcode erstellen:

git clone https://github.com/lfi-project/lfi-runtime
cd lfi-runtime
meson setup build
cd build
ninja
./tools/lfi-run/lfi-run ...

Das lfi-run-Werkzeug ist hauptsächlich für Benchmarking und Tests gedacht. Es führt standardmäßig keine Verifikation durch (übergeben Sie -v zum Aktivieren) und erlaubt standardmäßig vollen Dateisystemzugriff. Siehe die Verwendung (lfi-run --help) für weitere Informationen.

Nächste Schritte

Nach dem Erstellen und Ausführen Ihres ersten LFI-Programms möchten Sie vielleicht mehrere weitere Richtungen verfolgen. Siehe die folgenden Anleitungen für einige Vorschläge:

• Einrichten von Benchmarking mit SPEC 2017 und lfi-bench: Anleitung.
• Verwenden von LFI zum Sandboxen von Bibliotheken: Anleitung.
• Mehr über die Funktionsweise von LFI erfahren: Anleitung.
• Verwenden von liblfi zum Erstellen einer benutzerdefinierten Laufzeit: Anleitung

Forschungs-Repository

Dieses Repository existierte früher unter zyedidia/lfi und enthielt die erste Implementierung von LFI. Diese Quellen finden Sie im Branch lfi-research.