Jackalope

Copyright 2020 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Qu'est-ce que Jackalope

Jackalope est un fuzzer personnalisable, distribué et guidé par la couverture, capable de fonctionner avec des binaires en boîte noire.

Pourquoi un autre fuzzer ?

Bien qu'il existe de nombreux bons fuzzers guidés par la couverture qui fonctionnent sur des cibles dont le code source est disponible, il en existe relativement peu qui fonctionnent sur des binaires en boîte noire, en particulier sur les systèmes d'exploitation Windows et macOS, et ceux qui existent sont principalement basés sur des bases de code qui ne sont pas très faciles à personnaliser. Les objectifs initiaux de Jackalope sont :

• Facile à personnaliser pour des cibles où les fuzzers génériques pourraient ne pas bien fonctionner. Cela peut inclure
  • Des mutateurs personnalisés
  • Des mécanismes de livraison d'échantillons personnalisés
  • Une instrumentation personnalisée, etc.
• Facile à paralléliser, à la fois sur une seule machine et sur plusieurs machines

Que fait-il ?

Jackalope peut être utilisé de manière autonome, mais il est plus puissant lorsqu'il est utilisé comme bibliothèque, où les utilisateurs peuvent brancher des composants personnalisés qui remplaceraient le comportement par défaut. Par défaut, Jackalope est livré avec :

• Une instrumentation binaire utilisant TinyInst
• Un ensemble simple de mutateurs génériques pour les formats binaires ainsi qu'un moteur de mutation basé sur une grammaire
• Une livraison d'échantillons via fichier ou via mémoire partagée

Jackalope peut être exécuté en parallèle

• Sur une seule machine : en passant le nombre de threads de fuzzing via le paramètre de ligne de commande -nthreads
• Sur plusieurs machines : en exécutant une instance en tant que serveur (option de ligne de commande -start_server) et en faisant connecter les fuzzers des machines de travail à ce serveur (option de ligne de commande -server). Le serveur collecte et distribue ensuite les échantillons, les crashes et la couverture entre les workers.

Que ne fait-il pas ?

Jackalope n'inclut actuellement pas de stratégies de mutation avancées. Il est livré avec un ensemble de mutateurs génériques, qui fonctionneront pour de nombreuses cibles, mais les utilisateurs sont encouragés à écrire des mutateurs et des stratégies de mutation personnalisés en fonction des cibles qu'ils souhaitent fuzzer.

Quelles plateformes sont prises en charge ?

Actuellement, le fuzzing de binaires en boîte noire est pris en charge sur les systèmes d'exploitation Windows, macOS, Linux et Android.

Sur Linux, Jackalope peut également fonctionner avec Sanitizer Coverage (le code source de la cible est requis). Ce mode est documenté dans un document séparé.

Compilation de Jackalope

Prérequis : Python 3

1. Ouvrez un terminal et configurez votre environnement de compilation si nécessaire. Sous Windows, au lieu d'ouvrir une invite de commande générique, vous voudrez ouvrir l'invite de commande Visual Studio pour la plateforme pour laquelle vous compilez, ou exécuter vcvars64.bat / vcvars32.bat.

2. Naviguez vers le répertoire contenant le code source.

3. Exécutez les commandes suivantes :

cd Jackalope
git clone --recurse-submodules [email protected]:googleprojectzero/TinyInst.git
(alternately: git clone --recurse-submodules https://github.com/googleprojectzero/TinyInst.git)
mkdir build
cd build
cmake <generator arguments> ..
cmake --build . --config Release

Les arguments du générateur dépendent de votre environnement. Sur macOS, vous voudrez utiliser -G Xcode, tandis que par exemple sous Windows avec Visual Studio 2019 et pour une compilation 64 bits, vous utiliseriez -G "Visual Studio 16 2019" -A x64. Sur Linux, aucun argument de générateur n'est requis. Lors de la compilation croisée pour Android, des arguments cmake supplémentaires sont nécessaires, ceux-ci sont les mêmes que ceux décrits dans les instructions de compilation de TinyInst pour Android. Si vous fuzzé Android sur une VM qui prend en charge la mémoire partagée via /dev/shm, -DANDROID_TARGET=VM active la livraison d'échantillons par mémoire partagée.

Pour compiler afin d'exécuter contre des binaires arm64e sur macOS, voir ici.

Vous obtenez l'erreur No CMAKE_C_COMPILER could be found sur macOS ? Essayez de mettre à jour cmake. Assurez-vous également que Xcode est installé et que vous l'avez exécuté au moins une fois (il installe certains composants lors de la première exécution).

Exécution de Jackalope

Utilisation :

./fuzzer <fuzzer arguments> <instrumentation and other components arguments> -- <target command line>

Les arguments de ligne de commande suivants sont pris en charge :

-in - Répertoire d'entrée (répertoire contenant l'ensemble d'échantillons initial). Si le répertoire d'entrée est "-", le fuzzer tente de restaurer la session précédente (identique à l'utilisation du flag -restore).

-out - Répertoire de sortie

-t - Délai d'attente de l'échantillon en ms

-t1 - Délai d'attente pour l'initialisation de la cible (par exemple avant d'atteindre la méthode cible si définie). Par défaut, le délai d'attente de l'échantillon.

-nthreads - Nombre de threads du fuzzer. Par défaut, 1.

-delivery <file|shmem> - Mécanisme de livraison d'échantillons à utiliser. Si file, chaque échantillon est produit sous forme de fichier et "@@" dans les arguments de la cible est remplacé par un chemin vers le fichier. Si shmem, le fuzzer crée une mémoire partagée à la place et remplace "@@" dans les arguments de la cible par le nom de la mémoire partagée. Il est de la responsabilité de la cible d'ouvrir la mémoire partagée et d'extraire l'échantillon dans ce cas. Par défaut, file.

-file_extension - Lors de l'utilisation de la livraison d'échantillons file, ajoute l'extension spécifiée au nom de fichier. Utile si la cible attend que les fichiers d'entrée aient une certaine extension.

-restore ou -resume - Restaure et reprend une session de fuzzing précédente. Le processus fuzzer et le processus serveur prennent en charge la restauration.

-server - Spécifie le serveur de couverture à utiliser.

-start_server - Exécute un processus serveur au lieu d'un processus de fuzzing.

-crash_retry - Nombre de fois pour essayer de reproduire un crash. Par défaut, 10. Les crashes qui ne se reproduisent pas dans ce nombre de tentatives ou qui ne se reproduisent pas lorsqu'ils sont exécutés sans instrumentation sont marqués comme instables.

-coverage_retry - Nombre de fois pour réessayer de reproduire une nouvelle couverture. La couverture qui ne peut pas être reproduite de manière fiable dans ce nombre de tentatives est considérée comme instable. Les échantillons qui ne contiennent qu'une couverture instable ne sont pas sauvegardés.

-clean_target_on_coverage - Redémarre la cible lors de la reproduction de la couverture. Par défaut, true.

-minimize_samples - Tente de minimiser les nouveaux échantillons avant de les sauvegarder dans le corpus. Par défaut, true.