Isolamento Leve de Falhas (LFI)

Bem-vindo ao repositório principal do projeto Isolamento Leve de Falhas (LFI).

O que é LFI?

LFI é um sistema para isolar (sandbox) código nativo. Como WebAssembly e Native Client, o LFI isola código isolado em processo (isto é, no mesmo espaço de endereçamento de uma aplicação anfitriã). Atualmente, suportamos alvos Arm64 e x86-64, e temos suporte experimental para RISC-V.

LFI foi projetado desde o início para isolar código existente, como bibliotecas C/C++ (incluindo código assembly) e drivers de dispositivo.

LFI tem os seguintes objetivos:

• Compatibilidade: LFI pode ser usado para isolar quase todo o código C/C++/assembly existente sem modificações, funciona com interfaces de chamada de sistema existentes, etc.
• Desempenho: LFI busca um overhead mínimo em comparação com código não isolado.
• Segurança: Os elementos do runtime e do compilador LFI visam ser simples e verificáveis quando possível.
• Usabilidade: As ferramentas devem tornar o mais fácil possível a adaptação de isolamento em código existente.

Não são objetivos incluir um formato binário estável e independência de plataforma. Usaremos quaisquer recursos de hardware específicos de arquitetura e técnicas de compilador que pudermos para melhorar o desempenho.

Atualmente, o LFI impõe um overhead de cerca de 7% (Arm64) ou 8% (x86-64) em comparação com código nativo ao isolar leituras e escritas, e 1,5% (Arm64) ou 6% (x86-64) ao isolar apenas escritas (geomédia no SPEC 2017). As trocas de contexto do LFI (ou seja, entre sandbox e aplicação anfitriã) levam apenas dezenas de ciclos, e o LFI pode suportar milhares de sandboxes em um único espaço de endereçamento: ~64K (Arm64) ou ~3K (x86-64), com cada sandbox recebendo até 4GiB de memória.

Repositórios

• lfi-runtime: o runtime responsável por carregar programas LFI, lidar com chamadas do anfitrião e executar verificação.
• lfi-verifier: o verificador LFI.
• lfi-rewriter: o reescritor LFI para assembly GNU, e uma ferramenta pós-link para realizar transformações binárias após a ligação (necessário apenas em x86-64).
• lfi-bind: uma ferramenta para gerar trampolins e rotinas de inicialização para executar bibliotecas dentro de sandboxes LFI.
• lfi-llvm-toolchain: scripts para construir uma toolchain de compilador LFI baseada em LLVM, juntamente com um sysroot incluindo compiler-rt, musl, libc++ e mimalloc.
• llvm-project: nosso fork de desenvolvimento do projeto LLVM.
• lfi-specification: os fontes LaTeX para o documento de especificação LFI.
• lfi-bench: uma coleção de bibliotecas e benchmarks para realizar avaliação de desempenho do LFI.

Primeiros Passos

Para começar com o LFI, você precisará de um compilador LFI. Você pode obter um em https://github.com/lfi-project/lfi-llvm-toolchain. Compiladores pré-construídos para aarch64 e x86-64 estão hospedados nos lançamentos: https://github.com/lfi-project/lfi/releases/latest. Baixe o pacote aarch64-lfi-clang.tar.gz ou x86_64-lfi-clang.tar.gz, dependendo da sua arquitetura (ou aarch64-lfi-clang-host-x86_64.tar.gz se você quiser compilar cruzadamente para aarch64 a partir de x86-64).

Após abrir o arquivo, você deve ver uma estrutura de diretórios 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

Você vai querer adicionar o diretório lfi-bin ao seu PATH. Se você já tem as ferramentas LFI instaladas por meio de uma instalação separada, considere adicionar apenas lfi-clang ao seu PATH em vez disso.

Após ter um compilador, você deve conseguir compilar um programa simples em C ou C++:

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

Compile e execute usando lfi-run:

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

Você pode usar a ferramenta lfi-run pré-construída do arquivo pré-construído. Você também pode facilmente compilar o runtime LFI a partir do código fonte:

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

A ferramenta lfi-run é principalmente destinada a benchmarks e testes. Ela não executa verificação por padrão (passe -v para ativar), e permite acesso completo ao sistema de arquivos por padrão. Consulte o uso (lfi-run --help) para mais informações.

Próximos Passos

Após compilar e executar seu primeiro programa LFI, você pode querer explorar várias direções adicionais. Consulte os seguintes guias para algumas sugestões:

• Configurando benchmarks com SPEC 2017 e lfi-bench: guia.
• Usando LFI para isolar bibliotecas: guia.
• Aprendendo mais sobre como o LFI funciona: guia.
• Usando liblfi para criar um runtime personalizado: guia

Repositório de Pesquisa

Este repositório costumava existir em zyedidia/lfi e continha a implementação inicial do LFI. Esses fontes podem ser encontrados no branch lfi-research.