ESSS
1.0.0
ESSS é uma ferramenta de análise estática para detectar verificações de erros ausentes e incorretas em casas de código C e C ++. A ferramenta deduz automaticamente as especificações de erro para funções, sem precisar de conhecimento priori e, em seguida, encontra locais de código onde as verificações de erro estão ausentes ou inconsistentes com essas especificações.
Este repositório contém o código -fonte ESSS, bem como os scripts e dados para executar a ferramenta e o EESI nos benchmarks usados no papel.
A VM de avaliação de artefatos já contém a ferramenta ESSS e a Chapa de Ferramentas LLVM pré-criada. A versão LLVM usada é 14.0.6. A razão pela qual realizamos a construção em vez de uma versão fornecida por distro é garantir a reprodutibilidade dos resultados exatos sem ter patches potencialmente que interferem em distro.
A ferramenta é suportada em qualquer distribuição recente do Linux. Confirmamos que funciona com certeza no Ubuntu 22.04. Não são necessários requisitos especiais de hardware para executar ESSs, embora recomendemos pelo menos 8 Gib of Ram. Embora a ferramenta possa funcionar com menos, pode levar até 2 Gib of Ram para a maior referência, deixando menos memória para outros processos.
Se você deseja criar manualmente a ferramenta ESSS e/ou a cadeia de ferramentas LLVM, siga estas instruções.
As seguintes dependências são necessárias para construir a ferramenta ESSS:
$ cd /home/evaluation/ESSS/llvm
$ mkdir llvm-project
$ cd llvm-project
$ wget https://github.com/llvm/llvm-project/releases/download/llvmorg-14.0.6/clang-14.0.6.src.tar.xz
$ wget https://github.com/llvm/llvm-project/releases/download/llvmorg-14.0.6/llvm-14.0.6.src.tar.xz
$ tar xf llvm-14.0.6.src.tar.xz
$ tar xf clang-14.0.6.src.tar.xz
$ mv clang-14.0.6.src clang
$ mv llvm-14.0.6.src llvm
$ cd ..
$ ./build-llvm.sh$ cd /home/evaluation/ESSS/analyzer
$ make Isso construirá a ferramenta do analisador e colocará o binário no diretório /home/evaluation/ESSS/analyzer/build/lib .
Ao aplicar a ferramenta em seus próprios benchmarks, você precisará gerar os arquivos Bitcode primeiro. Para fazer isso, você deve usar o WLLVM. Siga as instruções de instalação na página WLLVM ReadMe.
Além disso, também contamos com Musl para inferir especificações da LIBC. Embora não seja estritamente necessário para que a ferramenta funcione, isso aumentará a precisão das especificações inferidas. A versão usada no artigo era Musl 1.2.3, mas qualquer versão deve funcionar. Estas são as etapas para transformar Musl em um arquivo de código de bits:
cd musl
mkdir prefix
export CC=wllvm
./configure --prefix= " $( realpath prefix ) "
make -j4
make install
extract-bc prefix/lib/libc.soPara compilar um programa para uso com nossa ferramenta, você deve seguir as instruções de construção do programa referido, mas use o wlper Wrapper como compilador. Isso resultará em arquivos bitcode que podem ser analisados por nossa ferramenta. Idealmente, você passa todos os arquivos de código de bits separadamente para a nossa ferramenta, pois fornecer ao programa inteiro de uma só vez (que é o que acontece por padrão pelo Extract-BC) será mais lento para processar do que os arquivos separados.
A ferramenta pode ser executada diretamente executando ./kanalyzer dentro /home/evaluation/ESSS/analyzer/build/lib . Os argumentos são os caminhos para os arquivos Bitcode. A saída é gravada para stdout. A ferramenta também contém alguns argumentos opcionais que podem ser listados usando a opção --help .
Para executar a ferramenta para inferir especificações e detectar bugs em um programa, você pode usar o seguinte comando:
./kanalyzer /path/to/mysl/libc.so.bc /path/to/bitcode1.bc /path/to/bitcode2.bc ...A saída será gravada no stdout, isso inclui as especificações inferidas e os bugs.
A ferramenta suporta opções de configuração que podem ser definidas usando argumentos da linha de comando.
As opções de configuração mais importantes são:
--missing-ct : o limite para verificações ausentes. Apenas relatórios com uma pontuação que é pelo menos esse valor será relatada. O valor padrão é 0,725.--incorrect-ct : o limite para especificações incorretas. Apenas relatórios com uma pontuação que é pelo menos esse valor será relatada. O valor padrão é 0,725.Outras opções úteis incluem:
--refine-vsa : Isso permite fazer a interseção entre o conjunto de valor de erro e os possíveis valores de retorno constante da função para aumentar a precisão das especificações de erro. Padrões para True.--st : ANÁLISE DE ANÁLISE DA ANÁLISE DA ANÁLISE DE [0, 1]. Quanto maior, mais confiante de que a associação deve ser. Padrões para 0,925.--interval-ct : limiar de confiança entre [0, 1]. Quanto mais alto, mais semelhantes os intervalos de erro devem ser.-c <number> : define o número de threads como <number> . Não é bem testado para valores diferentes de 1.Existem algumas opções de depuração também:
--print-random-non-void-function-samples <number> : Quantos nomes de funções não void aleatórias para imprimir, úteis para as funções de amostragem para calcular um recall. Padrões para 0.--ssc : imprime o erro detectado verifica separadamente. Padrões para false. Fornecemos um exemplo mínimo no diretório de example . Existe algum código de brinquedo simples no example/example.c que você pode executar através do analisador usando o script example/build_and_run.sh . Ao correr, você deve obter a seguinte saída:
Function error return intervals (3, pre-libc-pruning 3):
Function: func {return index 0}
[0, 0]
Function: generate_error {return index 0}
[-2147483648, -1] U [1, 2147483647]
Function: malloc {return index 0}
[0, 0]
O repositório está estruturado da seguinte forma. Os arquivos adaptados de Crix são marcados como tal.
? ESSS
│ ├── ? analyzer [the ESSS tool source code]
│ │ │ ├── ? Makefile [adapted from Crix]
│ │ │ └── ? src
│ │ │ │ ├── ? ...
│ │ │ │ └── ? src
│ │ │ │ │ ├── ? Analyzer.{cc, h} [Entry point of the application, adapted from Crix]
│ │ │ │ │ ├── ? CallGraph.{cc, h} [MLTA component from Crix]
│ │ │ │ │ ├── ? ClOptForward.h [Forward declarations of command line options]
│ │ │ │ │ ├── ? Common.{cc, h} [Common utility functions, adapted from Crix]
│ │ │ │ │ ├── ? DataFlowAnalysis.{cc, h} [Dataflow analysis helpers]
│ │ │ │ │ ├── ? DebugHelpers.{cc, h} [Debugging helpers]
│ │ │ │ │ ├── ? EHBlockDetector.{cc, h} [Specification inference component]
│ │ │ │ │ ├── ? ErrorCheckViolationFinder.{cc, h} [Bug detection component]
│ │ │ │ │ ├── ? FunctionErrorReturnIntervals.{cc, h} [Data structure file]
│ │ │ │ │ ├── ? FunctionVSA.{cc, h} [Value set analysis of return values component]
│ │ │ │ │ ├── ? Helpers.{cc, h} [Common utility functions]
│ │ │ │ │ ├── ? Interval.{cc, h} [Interval data structure]
│ │ │ │ │ ├── ? Lazy.h [Lazy execution utility class]
│ │ │ │ │ ├── ? MLTA.{cc, h} [MLTA component from Crix]
│ │ │ │ │ └── ? PathSpan.h [Data structure to store (parts of) paths]
│ └── ? evaluation [Scripts and data to run the tool on the benchmarks]
│ │ ├── ? benchmark-instructions [Instructions to compile each benchmark into bitcode files]
│ │ ├── ? ...
│ │ ├── ? eesi-<program>-output [Our EESI output for <program>]
│ │ ├── ? eesi-<program>-precision [Random sample from EESI's output for <program> for precision calculation]
│ │ ├── ? run-eesi-<program>.sh [Runs EESI for <program> (e.g. openssl)]
│ │ ├── ? my-<program>-output [Our ESSS output for <program>]
│ │ ├── ? run-my-<program>.sh [Runs ESSS for <program> (e.g. openssl)]
│ │ ├── ? <program>-bugs [Bug categorisations for <program> (e.g. openssl)]
│ │ ├── ? <program>-recall-sample [Random sample from error-returning functions in <program> for recall calculation]
│ │ ├── ? <program>-precision-ground-truth [Ground truth for precision evaluation for ESSS]
│ │ ├── ? <program>-random-functions-for-precision-my-tool [Random sample from ESSS's output for <program> for precision calculation]
│ │ ├── ? compute_my_stats.py [Computes stats for ESSS for a program]
│ │ └── ? compute_eesi_stats.py [Computes stats for EESI for a program]
Em particular, a inferência de especificação é implementada em ehblockdetector.cc e a detecção de bugs no ErrorCheckViolationFinder.cc.
As instruções para a execução de cada referência são fornecidas no diretório evaluation/benchmark-instructions . Para executar um dos benchmarks, execute o script correspondente no diretório evaluation (conforme descrito na visão geral da estrutura do repositório acima).
compute_my_stats.py : Este script calcula a ferramenta de precisão, recall e F1 da ferramenta ESSS para uma determinada referência.compute_eesi_stats.py : Este script calcula a precisão, recall e pontuação F1 da ferramenta EESI para uma determinada referência.run-eesi-<program>.sh : Este script executa a ferramenta EESI na referência especificada.run-my-<program>.sh : Este script executa a ferramenta ESSS na referência especificada. Para facilitar a avaliação, fornecemos cada referência um script de execução para executar a ferramenta. Estes podem ser encontrados em /home/evaluation/ESSS/evaluation :
run-my-openssl.shrun-my-openssh.shrun-my-php.shrun-my-zlib.shrun-my-libpng.shrun-my-freetype.shrun-my-libwebp.sh O artefato de avaliação é fornecido como uma imagem VM VirtualBox no Zenodo. Para construir a imagem da VM, começamos a partir de uma instalação do Ubuntu 22.04 LTS (x86-64). Em seguida, podemos usar o script fornecido no vm/build-vm.sh para instalar e configurar tudo o que é necessário para a avaliação.
Esta ferramenta é baseada na ferramenta CRIX da Universidade de Minnesota. Em particular, reutilizamos o componente MLTA do CRIX. OSS é distribuído sob a mesma licença.
Link para a página de publicação do USENIX em papel: https://www.usenix.org/conference/usenixsecurity24/presentation/dossche
Link para a publicação final pdf: https://www.usenix.org/system/files/usenixsecurity24-dsche.pdf
Link para o artefato final Apêndice PDF (Disponível, Funcional e Reproduzido): https://www.usenix.org/system/files/usenixsecurity24-appendix-dsche.pdf
@inproceedings {dossche2024inferenceoferrorspecifications,
author = {Niels Dossche and Bart Coppens},
title = {Inference of Error Specifications and Bug Detection Using Structural Similarities},
booktitle = {33rd USENIX Security Symposium (USENIX Security 24)},
year = {2024},
isbn = {978-1-939133-44-1},
address = {Philadelphia, PA},
pages = {1885--1902},
url = {https://www.usenix.org/conference/usenixsecurity24/presentation/dossche},
publisher = {USENIX Association},
month = aug
}
