Aislamiento Ligero de Fallos (LFI)

Bienvenido al repositorio de nivel superior del proyecto de Aislamiento Ligero de Fallos (LFI).

¿Qué es LFI?

LFI es un sistema para aislar (sandboxing) código nativo. Al igual que WebAssembly y Native Client, LFI aísla el código en proceso (es decir, en el mismo espacio de direcciones que una aplicación anfitriona). Actualmente, soportamos objetivos Arm64 y x86-64, y tenemos soporte experimental para RISC-V.

LFI está diseñado desde cero para aislar código existente, como bibliotecas C/C++ (incluyendo código ensamblador) y controladores de dispositivos.

LFI persigue los siguientes objetivos:

• Compatibilidad: LFI se puede utilizar para aislar casi todo el código C/C++/ensamblador existente sin modificaciones, funciona con interfaces de llamadas al sistema existentes, etc.
• Rendimiento: LFI busca una sobrecarga mínima en comparación con el código no aislado.
• Seguridad: Los elementos del runtime y del compilador de LFI buscan ser simples y verificables cuando sea posible.
• Usabilidad: Las herramientas deben facilitar al máximo la incorporación del aislamiento en código existente.

Los no objetivos incluyen un formato binario estable e independencia de plataforma. Usaremos cualquier característica de hardware específica de la arquitectura y técnicas de compilador que podamos para mejorar el rendimiento.

Actualmente, LFI impone alrededor de un 7% (Arm64) u 8% (x86-64) de sobrecarga en comparación con el código nativo al aislar lecturas y escrituras, y un 1.5% (Arm64) o 6% (x86-64) de sobrecarga al aislar solo escrituras (media geométrica en SPEC 2017). Los cambios de contexto de LFI (es decir, entre el sandbox y la aplicación anfitriona) toman solo decenas de ciclos, y LFI puede soportar miles de sandboxes en un único espacio de direcciones: ~64K (Arm64) o ~3K (x86-64), con cada sandbox recibiendo hasta 4 GiB de memoria.

Repositorios

• lfi-runtime: el runtime responsable de cargar programas LFI, manejar llamadas al anfitrión y ejecutar la verificación.
• lfi-verifier: el verificador de LFI.
• lfi-rewriter: el reescritor de LFI para ensamblador GNU, y una herramienta post-enlazador para realizar transformaciones binarias después del enlace (solo necesario en x86-64).
• lfi-bind: una herramienta para generar trampolines y rutinas de inicialización para ejecutar bibliotecas dentro de sandboxes LFI.
• lfi-llvm-toolchain: scripts para construir una cadena de herramientas de compilación LFI basada en LLVM, junto con un sysroot que incluye compiler-rt, musl, libc++ y mimalloc.
• llvm-project: nuestro fork de desarrollo del proyecto LLVM.
• lfi-specification: las fuentes LaTeX del documento de especificación de LFI.
• lfi-bench: una colección de bibliotecas y benchmarks para realizar evaluaciones de rendimiento de LFI.

Primeros Pasos

Para comenzar con LFI, necesitarás un compilador LFI. Puedes obtener uno desde https://github.com/lfi-project/lfi-llvm-toolchain. Los compiladores precompilados para aarch64 y x86-64 están alojados en los lanzamientos: https://github.com/lfi-project/lfi/releases/latest. Descarga el paquete aarch64-lfi-clang.tar.gz o x86_64-lfi-clang.tar.gz, según tu arquitectura (o aarch64-lfi-clang-host-x86_64.tar.gz si deseas compilar de forma cruzada para aarch64 desde x86-64).

Después de abrir el archivo, deberías ver una estructura de directorios como esta:

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

Querrás añadir el directorio lfi-bin a tu PATH. Si ya tienes las herramientas LFI instaladas mediante una instalación separada, considera añadir solo lfi-clang a tu PATH.

Una vez que tengas un compilador, deberías poder compilar un programa simple en C o C++:

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

Compila y ejecuta usando lfi-run:

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

Puedes usar la herramienta lfi-run precompilada del archivo precompilado. También puedes construir fácilmente el runtime de LFI desde las fuentes:

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

La herramienta lfi-run está pensada principalmente para benchmarking y pruebas. No ejecuta verificación por defecto (pasa -v para habilitarla), y permite acceso completo al sistema de archivos por defecto. Consulta el uso (lfi-run --help) para más información.

Próximos Pasos

Después de compilar y ejecutar tu primer programa LFI, es posible que desees explorar varias direcciones adicionales. Consulta las siguientes guías para algunas sugerencias:

• Configuración de benchmarking con SPEC 2017 y lfi-bench: guía.
• Uso de LFI para aislar bibliotecas: guía.
• Aprender más sobre cómo funciona LFI: guía.
• Uso de liblfi para crear un runtime personalizado: guía

Repositorio de Investigación

Este repositorio solía existir en zyedidia/lfi y contenía la implementación inicial de LFI. Esas fuentes se pueden encontrar en la rama lfi-research.