Isolation Légère des Fautes (LFI)

Bienvenue dans le dépôt principal du projet d'Isolation Légère des Fautes (LFI).

Qu'est-ce que LFI ?

LFI est un système pour isoler du code natif. Comme WebAssembly et Native Client, LFI isole le code mis en bac à sable dans le même processus (c'est-à-dire dans le même espace d'adressage qu'une application hôte). Actuellement, nous supportons les cibles Arm64 et x86-64, et avons un support expérimental pour RISC-V.

LFI est conçu dès le départ pour mettre en bac à sable du code existant, comme les bibliothèques C/C++ (y compris le code assembleur) et les pilotes de périphériques.

LFI vise les objectifs suivants :

• Compatibilité : LFI peut être utilisé pour isoler la quasi-totalité du code C/C++/assembleur existant sans modification, fonctionne avec les interfaces d'appels système existantes, etc.
• Performances : LFI vise une surcharge minimale par rapport au code non isolé.
• Sécurité : Les éléments du runtime et du compilateur LFI visent à être simples et vérifiables lorsque possible.
• Utilisabilité : Les outils doivent rendre aussi simple que possible l'ajout d'isolation dans du code existant.

Les non-objectifs incluent un format binaire stable et l'indépendance de plateforme. Nous utiliserons toutes les fonctionnalités matérielles et techniques de compilation spécifiques à l'architecture pour améliorer les performances.

Actuellement, LFI impose environ 7 % (Arm64) ou 8 % (x86-64) de surcharge par rapport au code natif lors de l'isolation des lectures et écritures, et 1,5 % (Arm64) ou 6 % (x86-64) lors de l'isolation des seules écritures (moyenne géométrique sur SPEC 2017). Les changements de contexte LFI (c'est-à-dire entre le bac à sable et l'application hôte) ne prennent que quelques dizaines de cycles, et LFI peut supporter des milliers de bacs à sable dans un seul espace d'adressage : ~64K (Arm64) ou ~3K (x86-64), chaque bac à sable pouvant disposer jusqu'à 4 Go de mémoire.

Dépôts

• lfi-runtime: le runtime responsable du chargement des programmes LFI, de la gestion des appels hôtes et de l'exécution de la vérification.
• lfi-verifier: le vérificateur LFI.
• lfi-rewriter: le réécriveur LFI pour l'assembleur GNU, et un outil de post-édition pour effectuer des transformations binaires après l'édition de liens (nécessaire uniquement sur x86-64).
• lfi-bind: un outil pour générer des trampolines et des routines d'initialisation pour exécuter des bibliothèques dans des bacs à sable LFI.
• lfi-llvm-toolchain: des scripts pour construire une chaîne d'outils de compilation LFI basée sur LLVM, avec un sysroot incluant compiler-rt, musl, libc++ et mimalloc.
• llvm-project: notre fork de développement du projet LLVM.
• lfi-specification: les sources LaTeX du document de spécification LFI.
• lfi-bench: une collection de bibliothèques et de benchmarks pour l'évaluation des performances de LFI.

Pour Commencer

Pour commencer avec LFI, vous aurez besoin d'un compilateur LFI. Vous pouvez en obtenir un sur https://github.com/lfi-project/lfi-llvm-toolchain. Des compilateurs préconstruits pour aarch64 et x86-64 sont hébergés dans les releases : https://github.com/lfi-project/lfi/releases/latest. Téléchargez le bundle aarch64-lfi-clang.tar.gz ou x86_64-lfi-clang.tar.gz, selon votre architecture (ou aarch64-lfi-clang-host-x86_64.tar.gz si vous voulez faire de la compilation croisée vers aarch64 depuis x86-64).

Après avoir extrait l'archive, vous devriez voir une structure de répertoires comme celle-ci :

├── 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

Vous voudrez ajouter le répertoire lfi-bin à votre PATH. Si vous avez déjà les outils LFI installés via une installation séparée, envisagez d'ajouter uniquement lfi-clang à votre PATH à la place.

Une fois que vous avez un compilateur, vous devriez pouvoir construire un simple programme C ou C++ :

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

Compilez et exécutez en utilisant lfi-run :

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

Vous pouvez utiliser l'outil lfi-run préconstruit depuis l'archive préconstruite. Vous pouvez aussi facilement construire le runtime LFI à partir des sources :

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

L'outil lfi-run est principalement destiné aux benchmarks et aux tests. Il n'exécute pas la vérification par défaut (passez -v pour activer), et il permet un accès complet au système de fichiers par défaut. Voir l'utilisation (lfi-run --help) pour plus d'informations.

Prochaines Étapes

Après avoir construit et exécuté votre premier programme LFI, vous voudrez peut-être poursuivre plusieurs directions supplémentaires. Consultez les guides suivants pour quelques suggestions :

• Mise en place de benchmarks avec SPEC 2017 et lfi-bench : guide.
• Utiliser LFI pour isoler des bibliothèques : guide.
• En apprendre plus sur le fonctionnement de LFI : guide.
• Utiliser liblfi pour créer un runtime personnalisé : guide

Dépôt de Recherche

Ce dépôt existait auparavant à zyedidia/lfi et contenait l'implémentation initiale de LFI. Ces sources peuvent être trouvées sur la branche lfi-research.