Fuzzable

Framework pour l'automatisation de la découverte de cibles Fuzzable avec analyse statique

Introduction

Les chercheurs en vulnérabilités qui effectuent des évaluations de sécurité sur des logiciels utilisent souvent les capacités du fuzzing guidé par couverture via des outils puissants comme AFL++ et libFuzzer. C'est important car cela automatise le processus de chasse aux bugs et révèle rapidement des conditions exploitables dans les cibles. Cependant, lorsqu'ils rencontrent des bases de code volumineuses et complexes ou des binaires fermés, les chercheurs doivent consacrer laborieusement du temps à auditer manuellement et à rétro-ingénierer pour identifier les fonctions où l'exploration basée sur le fuzzing peut être utile.

Fuzzable est un framework qui s'intègre à la fois avec le code source C/C++ et les binaires pour aider les chercheurs en vulnérabilités à identifier les fonctions cibles viables pour le fuzzing. Cela se fait en appliquant plusieurs heuristiques basées sur l'analyse statique pour identifier les comportements risqués dans le logiciel et les fonctions qui les exécutent. Les chercheurs peuvent ensuite utiliser le framework pour générer des modèles de harnais de base, qui peuvent ensuite être utilisés pour chasser les vulnérabilités, ou pour être intégrés dans un pipeline de fuzzing continu, comme le projet oss-fuzz de Google.

En plus de fonctionner comme un outil autonome, Fuzzable est également intégré comme plugin pour le désassembleur Binary Ninja, avec le support d'autres backends de désassemblage en développement.

Consultez l'article de blog original détaillant l'outil, qui met en évidence les spécifications techniques des heuristiques d'analyse statique et comment cet outil a vu le jour. Cet outil est également présenté au Black Hat Arsenal USA 2022.

Fonctionnalités

• Prend en charge l'analyse de binaires (avec Angr et Binary Ninja) et d'artefacts de code source (avec tree-sitter).
• Exécute l'analyse statique à la fois en tant qu'outil CLI autonome ou plugin Binary Ninja.
• Génération de harnais pour démarrer rapidement la création de campagnes de fuzzing.

Installation

Certaines cibles binaires peuvent nécessiter un certain assainissement (par exemple, la correspondance de signatures, ou l'identification de fonctions à partir de l'inlining), et donc fuzzable utilise principalement Binary Ninja comme backend de désassemblage en raison de sa capacité à résoudre efficacement ces problèmes. Par conséquent, il peut être utilisé à la fois comme outil autonome et comme plugin.

Étant donné que Binary Ninja n'est pas accessible à tous et qu'il peut y avoir une demande pour l'utiliser dans le cadre d'évaluations de sécurité et éventuellement le déployer dans le cloud, un backend de fallback angr est également supporté. J'envisage d'intégrer d'autres désassembleurs à l'avenir (priorité : Ghidra).

Ligne de commande (Autonome)

Si vous avez Binary Ninja Commercial, assurez-vous d'installer l'API pour une utilisation autonome sans interface graphique :

$ python3 /Applications/Binary\ Ninja.app/Contents/Resources/scripts/install_api.py

Installez avec pip :

$ pip install fuzzable

Construction manuelle/développement

Nous utilisons poetry pour la gestion des dépendances et la construction. Pour effectuer une construction manuelle, clonez le dépôt avec les modules tiers :

$ git clone --recursive https://github.com/ex0dus-0x/fuzzable

Pour installer manuellement :

$ cd fuzzable/

# without poetry
$ pip install .

# with poetry
$ poetry install

# with poetry for a development virtualenv
$ poetry shell

Vous pouvez maintenant analyser des binaires et/ou du code source avec l'outil !

# analyzing a single shared object library binary
$ fuzzable analyze examples/binaries/libbasic.so

# analyzing a single C source file
$ fuzzable analyze examples/source/libbasic.c

# analyzing a workspace with multiple C/C++ files and headers
$ fuzzable analyze examples/source/source_bundle/

Plugin Binary Ninja

fuzzable peut être facilement installé via la place de marché des plugins Binary Ninja en allant dans Binary Ninja > Manage Plugins et en le recherchant. Voici un exemple du plugin fuzzable en cours d'exécution, identifiant avec précision les cibles pour le fuzzing et une évaluation ultérieure des vulnérabilités :

Utilisation

fuzzable est livré avec diverses options pour vous aider à mieux ajuster votre analyse. D'autres seront supportées dans les plans futurs et toute demande de fonctionnalité.

Heuristiques d'analyse statique

Pour déterminer la fuzzabilité, fuzzable utilise plusieurs heuristiques pour déterminer quelles cibles sont les plus viables pour l'analyse dynamique. Ces heuristiques sont toutes pondérées différemment à l'aide de la bibliothèque scikit-criteria, qui utilise l'analyse de décision multicritère pour déterminer les meilleurs candidats. Ces métriques et leurs poids peuvent être vus ici :

Comme mentionné, consultez l'article de blog technique pour un aperçu plus approfondi de pourquoi et comment ces métriques sont utilisées.

De nombreuses métriques ont été largement inspirées par les travaux originaux de Vincenzo Iozzo sur le fuzzing à 0 connaissance.

Chaque cible que vous souhaitez analyser est diverse, et fuzzable ne pourra pas prendre en compte tous les comportements de cas limites dans la cible du programme. Ainsi, il peut être important lors de l'analyse d'ajuster ces poids de manière appropriée pour voir si différents résultats ont plus de sens pour votre cas d'utilisation. Pour ajuster ces poids dans la CLI, spécifiez simplement l'argument --score-weights :

$ fuzzable analyze <TARGET> --score-weights=0.2,0.2,0.2,0.2,0.2

Filtrage d'analyse

Par défaut, fuzzable filtrera les fonctions cibles selon les critères suivants :

• Appels de niveau supérieur - fonctions qui ne sont appelées par aucun autre appel dans la cible. Ce sont des points d'entrée idéaux qui ont potentiellement une très haute couverture.
• Appels statiques - (source uniquement) fonctions qui sont static et ne sont pas exposées via les en-têtes.
• Importations - (binaire uniquement) autres dépendances de bibliothèque utilisées par les implémentations de la cible.

Pour voir les appels qui ont été filtrés par fuzzable, définissez le drapeau --list_ignored :

$ fuzzable analyze --list-ignored <TARGET>

Dans Binary Ninja, vous pouvez activer ce paramètre dans Settings > Fuzzable > List Ignored Calls.

Dans le cas où fuzzable filtre faussement des appels importants qui devraient être analysés, il est recommandé d'utiliser les arguments --include-* pour les inclure lors de l'exécution :

# include ALL non top-level calls that were filtered out
$ fuzzable analyze --include-nontop <TARGET>

# include specific symbols that were filtered out
$ fuzzable analyze --include-sym <SYM> <TARGET>

Dans Binary Ninja, cela est supporté via Settings > Fuzzable > Include non-top level calls et Symbols to Exclude.

Génération de harnais

Maintenant que vous avez trouvé vos candidats idéaux pour le fuzzing, fuzzable vous aidera également à générer des harnais de fuzzing (presque) prêts à être instrumentés et compilés pour une utilisation avec un fuzzer basé sur fichier (ex: AFL++, Honggfuzz) ou un fuzzer en mémoire (libFuzzer). Pour ce faire dans la CLI :

# generate harness from a candidate
$ fuzzable create-harness target --symbol-name=some_unsafe_call

# make minimal and necessary modifications to the harness
$ vim target_some_unsafe_call_harness.cpp

# example compilation for AFL-QEMU, which is specified in the comments of the generated harness
$ clang target_some_unsafe_call_harness.cpp -no-pie -o target_some_unsafe_call_harness -ldl

# create your base seeds, ideally should be more well-formed for input
$ mkdir in/
$ echo "seed" >> in/seed

# start black box fuzzing
$ afl-fuzz -Q -m none -i in/ -o out/ -- ./target_some_unsafe_call_harness

Si cette cible est une base de code source, le modèle source générique sera utilisé.

Si la cible est un binaire, le modèle boîte noire générique sera utilisé, qui peut idéalement être utilisé avec un mode d'émulation de fuzzing comme AFL-QEMU. Une copie du binaire sera également créée en tant qu'objet partagé si le symbole n'est pas exporté directement pour être dlopené à l'aide de LIEF.

Pour le moment, cette fonctionnalité est assez rudimentaire, car elle crée simplement un harnais C++ autonome rempli avec les paramètres appropriés, et ne générera pas automatiquement le code nécessaire pour les comportements d'exécution (par exemple, instanciation et libération de structures). Cependant, les modèles créés pour fuzzable devraient vous permettre de démarrer rapidement. Voici quelques fonctionnalités ambitieuses que j'aimerais mettre en œuvre à l'avenir :

• Synthèse complète de harnais - les harnais fonctionneront directement sans aucune modification manuelle nécessaire.
• Synthèse à partir de tests unitaires potentiels utilisant le framework DeepState (Source uniquement).
• Déploiement immédiat vers une flotte de fuzzing continu gérée.

Exportation de rapports

fuzzable prend en charge la génération de rapports dans divers formats. Les formats actuellement supportés sont JSON, CSV et Markdown. Cela peut être utile si vous utilisez cela dans le cadre d'une automatisation où vous souhaitez ingérer la sortie dans un format sérialisable.

Dans la CLI, passez simplement l'argument --export avec un nom de fichier avec l'extension appropriée :

$ fuzzable analyze --export=report.json <TARGET>

Dans Binary Ninja, allez dans Plugins > Fuzzable > Export Fuzzability Report > ... et sélectionnez le format que vous souhaitez exporter et le chemin où l'écrire.

Contribution

Cet outil sera continuellement développé, et toute aide de mainteneurs externes est appréciée !

• Créez une issue pour les demandes de fonctionnalités ou les bogues que vous avez rencontrés.
• Soumettez une pull request pour les correctifs et améliorations que vous souhaiteriez voir contribués à cet outil.

Licence

Fuzzable est sous licence MIT License.