ESSS
1.0.0
ESSS est un outil d'analyse statique pour détecter les vérifications d'erreur manquantes et incorrectes dans les bases de code C et C ++. L'outil déduit automatiquement les spécifications d'erreur pour les fonctions, sans avoir besoin de connaissances a priori, puis il trouve des emplacements de code où les vérifications d'erreur sont manquantes ou incompatibles avec ces spécifications.
Ce référentiel contient le code source ESSS, ainsi que les scripts et les données pour exécuter l'outil et EESI sur les repères utilisés dans le document.
La machine virtuelle d'évaluation des artefacts contient déjà l'outil ESSS et la chaîne d'outils LLVM pré-construite. La version LLVM utilisée est 14.0.6. La raison pour laquelle nous effectuons la construction nous-mêmes plutôt qu'une version fournie est d'assurer la reproductibilité des résultats exacts sans avoir des correctifs spécifiques à la distribution potentiellement interférant.
L'outil est pris en charge sur toute distribution Linux récente. Nous avons confirmé que cela fonctionne à coup sûr sur Ubuntu 22.04. Aucune exigence matérielle spéciale n'est nécessaire pour exécuter les ESS, bien que nous recommandons au moins 8 GIB de RAM. Même si l'outil peut fonctionner avec moins, cela peut prendre jusqu'à 2 gib de RAM pour la plus grande référence, laissant moins de mémoire pour d'autres processus.
Si vous souhaitez créer manuellement l'outil ESSS et / ou la chaîne d'outils LLVM, suivez ces instructions.
Les dépendances suivantes sont nécessaires pour construire l'outil 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 Cela construira l'outil d'analyseur et placera le binaire dans le répertoire /home/evaluation/ESSS/analyzer/build/lib .
Lorsque vous appliquez l'outil à vos propres repères, vous devrez d'abord générer les fichiers bitcodes. Pour ce faire, vous devez utiliser WLLVM. Suivez les instructions d'installation sur la page WLLVM Readme.
De plus, nous comptons également sur MUSL pour déduire les spécifications de LIBC. Bien qu'il ne soit pas strictement nécessaire pour que l'outil fonctionne, cela augmentera la précision des spécifications inférées. La version utilisée dans le journal était MUSL 1.2.3, mais toute version devrait fonctionner. Ce sont les étapes pour construire MUSL dans un fichier de code binaire:
cd musl
mkdir prefix
export CC=wllvm
./configure --prefix= " $( realpath prefix ) "
make -j4
make install
extract-bc prefix/lib/libc.soPour compiler un programme à utiliser avec notre outil, vous devez suivre les instructions de construction dudit programme, mais utilisez l'emballage WLLVM comme compilateur. Cela se traduira par des fichiers bitcodes qui peuvent être analysés par notre outil. Idéalement, vous transmettez tous les fichiers bitcodes séparément à notre outil, car donner à l'ensemble le programme (ce qui se passe par défaut par extrait-BC) sera plus lent à traiter que les fichiers séparés.
L'outil peut être exécuté directement en exécutant ./kanalyzer à l'intérieur /home/evaluation/ESSS/analyzer/build/lib . Les arguments sont les chemins des fichiers bitcodes. La sortie est écrite sur stdout. L'outil contient également des arguments facultatifs qui peuvent être répertoriés à l'aide de l'option --help .
Pour exécuter l'outil pour déduire les spécifications et détecter les bogues dans un programme, vous pouvez utiliser la commande suivante:
./kanalyzer /path/to/mysl/libc.so.bc /path/to/bitcode1.bc /path/to/bitcode2.bc ...La sortie sera écrite sur STDOUT, cela inclut les spécifications inférées et les bogues.
L'outil prend en charge les options de configuration qui peuvent être définies à l'aide d'arguments de ligne de commande.
Les options de configuration les plus importantes sont:
--missing-ct : Le seuil pour les chèques manquants. Seuls les rapports avec un score qui est au moins cette valeur sera signalée. La valeur par défaut est de 0,725.--incorrect-ct : Le seuil de spécifications incorrectes. Seuls les rapports avec un score qui est au moins cette valeur sera signalée. La valeur par défaut est de 0,725.Les autres options utiles incluent:
--refine-vsa : Cela permet de prendre l'intersection entre la valeur d'erreur définie et les valeurs de retour constantes possibles de la fonction pour augmenter la précision des spécifications d'erreur. Par défaut est vrai.--st : Analyse de l'association Confiance entre [0, 1]. Plus l'association doit être confiante. Par défaut à 0,925.--interval-ct : Seuil de confiance entre [0, 1]. Plus les intervalles d'erreur devraient être similaires.-c <number> : Définit le nombre de threads sur <number> . Non testé soigneusement pour des valeurs autres que 1.Il existe également quelques options de débogage:
--print-random-non-void-function-samples <number> : combien de noms de fonctions aléatoires non-nul à imprimer, utile pour que les fonctions d'échantillonnage de calculer un rappel. Par défaut est 0.--ssc : imprime l'erreur détectée vérifie séparément. Par défaut est faux. Nous fournissons un exemple minimal dans l' example de répertoire. Il existe un code de jouet simple dans example/example.c que vous pouvez exécuter l'analyseur à l'aide du script example/build_and_run.sh . Lors de l'exécution, vous devez obtenir la sortie suivante:
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]
Le référentiel est structuré comme suit. Les fichiers adaptés de Crix sont marqués comme tels.
? 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]
En particulier, l'inférence de spécification est implémentée dans ehblockdetector.cc et la détection de bogue dans ErrorCheckviolationfinder.cc.
Les instructions pour exécuter chaque référence sont fournies dans le répertoire evaluation/benchmark-instructions . Pour exécuter l'un des repères, exécutez le script correspondant dans le répertoire evaluation (comme décrit dans la vue d'ensemble de la structure du référentiel ci-dessus).
compute_my_stats.py : Ce script calcule le score de précision, de rappel et de F1 de l'outil ESSS pour une référence donnée.compute_eesi_stats.py : Ce script calcule le score de précision, de rappel et de F1 de l'outil EESI pour une référence donnée.run-eesi-<program>.sh : Ce script exécute l'outil EESI sur le référence donné.run-my-<program>.sh : Ce script exécute l'outil ESSS sur le benchmark donné. Pour faciliter l'évaluation, nous avons fourni à chaque benchmark un script d'exécution pour exécuter l'outil. Ceux-ci peuvent être trouvés dans /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 L'artefact d'évaluation est fourni en tant qu'image VM VirtualBox sur Zenodo. Pour construire l'image VM, nous avons commencé à partir d'une installation Ubuntu 22.04 LTS (x86-64). Nous pouvons ensuite utiliser le script fourni dans vm/build-vm.sh pour installer et configurer tout ce qui est nécessaire pour l'évaluation.
Cet outil est basé sur l'outil Crix de l'Université du Minnesota. En particulier, nous réutilisons la composante MLTA de Crix. ESSS est distribué sous la même licence.
Lien vers la page Publication du papier Usenix: https://www.usenix.org/conference/usenixsecurity24/presentation/dossche
Lien vers la publication finale PDF: https://www.usenix.org/system/files/usenixsecurity24-dossche.pdf
Lien vers l'artefact final PDF PDF (badges fonctionnels, fonctionnels et reproduits): https://www.usenix.org/system/files/usenixsecurity24-appendix-dossche.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
}
