Fuzz avec libFuzzer

Le fuzzing, qui consiste simplement à fournir des données potentiellement non valides, inattendues ou aléatoires en entrée d'un programme, est un moyen extrêmement efficace de détecter les bugs dans de grands systèmes logiciels. Il constitue une partie importante du cycle de vie du développement logiciel.

Le système de compilation d'Android est compatible avec le fuzzing grâce à l'inclusion de libFuzzer à partir du projet d'infrastructure de compilateur LLVM. LibFuzzer est associé à la bibliothèque en cours de test et gère toute la sélection, la mutation et la création de rapports sur les plantages des entrées qui se produisent lors d'une session de fuzzing. Les outils de nettoyage de LLVM permettent de détecter la corruption de la mémoire et de mesurer la couverture du code.

Cet article présente libFuzzer sur Android et explique comment effectuer une compilation instrumentée. Il comprend également des instructions pour écrire, exécuter et personnaliser des fuzzers.

Configuration et compilation

Pour vous assurer qu'une image fonctionnelle s'exécute sur un appareil, vous pouvez télécharger une image d'usine et flasher l'appareil. Vous pouvez également télécharger le code source AOSP et suivre l'exemple de configuration et de compilation ci-dessous.

Exemple de configuration

Cet exemple suppose que l'appareil cible est un Pixel (taimen) et qu'il est déjà préparé pour le débogage USB (aosp_taimen-userdebug). Vous pouvez télécharger d'autres binaires Pixel à partir de Driver Binaries. 

mkdir ~/bin
export PATH=~/bin:$PATH
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo
repo init -u https://android.googlesource.com/platform/manifest -b main
repo sync -c -j8
wget https://dl.google.com/dl/android/aosp/google_devices-taimen-qq1a.191205.008-f4537f93.tgz
tar xvf google_devices-taimen-qq1a.191205.008-f4537f93.tgz
./extract-google_devices-taimen.sh
wget https://dl.google.com/dl/android/aosp/qcom-taimen-qq1a.191205.008-760afa6e.tgz
tar xvf qcom-taimen-qq1a.191205.008-760afa6e.tgz
./extract-qcom-taimen.sh
. build/envsetup.sh
lunch aosp_taimen-userdebug

Créer un exemple

La première étape de l'exécution de cibles de fuzz consiste à obtenir une nouvelle image système. Nous vous recommandons d'utiliser au moins la dernière version de développement d'Android.

  1. Effectuez le build initial en exécutant la commande suivante: 
    m
  2. Pour pouvoir flasher votre appareil, démarrez-le en mode Fastboot à l'aide de la combinaison de touches appropriée.
  3. Déverrouillez le bootloader et flashez la nouvelle image compilée à l'aide des commandes suivantes. 
    fastboot oem unlock
fastboot flashall

L'appareil cible devrait maintenant être prêt pour le fuzzing libFuzzer.

Écrire un fuzzer

Pour illustrer l'écriture d'un fuzzeur de bout en bout à l'aide de libFuzzer dans Android, utilisez le code vulnérable suivant comme cas de test. Cela permet de tester le générateur de fuzz, de s'assurer que tout fonctionne correctement et d'illustrer à quoi ressemblent les données de plantage.

Voici la fonction de test. 

#include <stdint.h>
#include <stddef.h>
bool FuzzMe(const char *data, size_t dataSize) {
    return dataSize >= 3  &&
           data[0] == 'F' &&
           data[1] == 'U' &&
           data[2] == 'Z' &&
           data[3] == 'Z';  // ← Out of bounds access
}

Pour compiler et exécuter ce fuzzeur de test:

  1. Une cible de fuzzing se compose de deux fichiers: un fichier de compilation et le code source de la cible de fuzzing. Créez vos fichiers à côté de la bibliothèque que vous fuzzez. Donnez au générateur de fuzz un nom qui décrit son fonctionnement.
  2. Écrivez une cible de fuzzing à l'aide de libFuzzer. La cible de fuzzing est une fonction qui prend un blob de données d'une taille spécifiée et le transmet à la fonction à fuzzer. Voici un fuzzer de base pour la fonction de test vulnérable: 
    #include <stddef.h>
#include <stdint.h>

extern "C" int LLVMFuzzerTestOneInput(const char *data, size_t size) {
  // ...
  // Use the data to call the library you are fuzzing.
  // ...
  return FuzzMe(data, size);
}
  3. Demandez au système de compilation d'Android de créer le binaire du fuzzeur. Pour créer le fuzzer, ajoutez ce code au fichier Android.bp: 
    cc_fuzz {
  name: "fuzz_me_fuzzer",
  srcs: [
    "fuzz_me_fuzzer.cpp",
  ],
  // If the fuzzer has a dependent library, uncomment the following section and
  // include it.
  // static_libs: [
  //   "libfoo", // Dependent library
  // ],
  //
  // The advanced features below allow you to package your corpus and
  // dictionary files during building. You can find more information about
  // these features at:
  //  - Corpus: https://llvm.org/docs/LibFuzzer.html#corpus
  //  - Dictionaries: https://llvm.org/docs/LibFuzzer.html#dictionaries
  // These features are not required for fuzzing, but are highly recommended
  // to gain extra coverage.
  // To include a corpus folder, uncomment the following line.
  // corpus: ["corpus/*"],
  // To include a dictionary, uncomment the following line.
  // dictionary: "fuzz_me_fuzzer.dict",
}
  4. Pour exécuter le fuzzer sur la cible (appareil): 
    SANITIZE_TARGET=hwaddress m fuzz_me_fuzzer
  5. Pour exécuter le fuzzeur sur l'hôte: 
    SANITIZE_HOST=address m fuzz_me_fuzzer

Pour plus de commodité, définissez des variables de shell contenant le chemin d'accès à votre cible de fuzzing et le nom du binaire (à partir du fichier de compilation que vous avez écrit précédemment).

export FUZZER_NAME=your_fuzz_target

Une fois ces étapes effectuées, vous devriez avoir un fuzzer créé. L'emplacement par défaut du fuzzer (pour cet exemple de build Pixel) est le suivant:

  • $ANDROID_PRODUCT_OUT/data/fuzz/$TARGET_ARCH/$FUZZER_NAME/$FUZZER_NAME pour l'appareil.
  • $ANDROID_HOST_OUT/fuzz/$TARGET_ARCH/$FUZZER_NAME/$FUZZER_NAME pour l'hôte.

    • Exécuter votre fuzzer sur l'hôte

  • Ajoutez les éléments suivants à votre fichier de compilation Android.bp: 
    host_supported: true,
     Notez que cette opération ne peut être appliquée que si la bibliothèque que vous souhaitez fuzzer est compatible avec l'hôte.
  • Exécutez le fuzzeur sur l'hôte en exécutant simplement le binaire du fuzzeur compilé: 
    $ANDROID_HOST_OUT/fuzz/x86_64/$FUZZER_NAME/$FUZZER_NAME

    • Exécuter votre fuzzer sur l'appareil

    Nous souhaitons le copier sur votre appareil à l'aide de adb.

    1. Pour importer ces fichiers dans un répertoire de l'appareil, exécutez les commandes suivantes: 
      adb root
adb sync data
    2. Exécutez le test fuzzer sur l'appareil à l'aide de la commande suivante: 
      adb shell /data/fuzz/$(get_build_var TARGET_ARCH)/$FUZZER_NAME/$FUZZER_NAME \
  /data/fuzz/$(get_build_var TARGET_ARCH)/$FUZZER_NAME/corpus

    Vous obtiendrez un résultat semblable à l'exemple ci-dessous. 

    INFO: Seed: 913963180
INFO: Loaded 2 modules   (16039 inline 8-bit counters): 16033 [0x7041769b88, 0x704176da29), 6 [0x60e00f4df0, 0x60e00f4df6),
INFO: Loaded 2 PC tables (16039 PCs): 16033 [0x704176da30,0x70417ac440), 6 [0x60e00f4df8,0x60e00f4e58),
INFO: -max_len is not provided; libFuzzer will not generate inputs larger than 4096 bytes
INFO: A corpus is not provided, starting from an empty corpus
#2	INITED cov: 5 ft: 5 corp: 1/1b exec/s: 0 rss: 24Mb
#10	NEW    cov: 6 ft: 6 corp: 2/4b lim: 4 exec/s: 0 rss: 24Mb L: 3/3 MS: 3 CopyPart-ChangeByte-InsertByte-
#712	NEW    cov: 7 ft: 7 corp: 3/9b lim: 8 exec/s: 0 rss: 24Mb L: 5/5 MS: 2 InsertByte-InsertByte-
#744	REDUCE cov: 7 ft: 7 corp: 3/7b lim: 8 exec/s: 0 rss: 25Mb L: 3/3 MS: 2 ShuffleBytes-EraseBytes-
#990	REDUCE cov: 8 ft: 8 corp: 4/10b lim: 8 exec/s: 0 rss: 25Mb L: 3/3 MS: 1 ChangeByte-
==18631==ERROR: HWAddressSanitizer: tag-mismatch on address 0x0041e00b4183 at pc 0x0060e00c5144
READ of size 1 at 0x0041e00b4183 tags: f8/03 (ptr/mem) in thread T0
    #0 0x60e00c5140  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0xf140)
    #1 0x60e00ca130  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x14130)
    #2 0x60e00c9b8c  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x13b8c)
    #3 0x60e00cb188  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15188)
    #4 0x60e00cbdec  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15dec)
    #5 0x60e00d8fbc  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x22fbc)
    #6 0x60e00f0a98  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x3aa98)
    #7 0x7041b75d34  (/data/fuzz/arm64/lib/libc.so+0xa9d34)

[0x0041e00b4180,0x0041e00b41a0) is a small allocated heap chunk; size: 32 offset: 3
0x0041e00b4183 is located 0 bytes to the right of 3-byte region [0x0041e00b4180,0x0041e00b4183)
allocated here:
    #0 0x70418392bc  (/data/fuzz/arm64/lib/libclang_rt.hwasan-aarch64-android.so+0x212bc)
    #1 0x60e00ca040  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x14040)
    #2 0x60e00c9b8c  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x13b8c)
    #3 0x60e00cb188  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15188)
    #4 0x60e00cbdec  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x15dec)
    #5 0x60e00d8fbc  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x22fbc)
    #6 0x60e00f0a98  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x3aa98)
    #7 0x7041b75d34  (/data/fuzz/arm64/lib/libc.so+0xa9d34)
    #8 0x60e00c504c  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0xf04c)
    #9 0x70431aa9c4  (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0x519c4)

Thread: T1 0x006700006000 stack: [0x007040c55000,0x007040d4ecc0) sz: 1023168 tls: [0x000000000000,0x000000000000)
Thread: T0 0x006700002000 stack: [0x007fe51f3000,0x007fe59f3000) sz: 8388608 tls: [0x000000000000,0x000000000000)
Memory tags around the buggy address (one tag corresponds to 16 bytes):
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   08  00  cf  08  dc  08  cd  08  b9  08  1a  1a  0b  00  04  3f
=> 27  00  08  00  bd  bd  2d  07 [03] 73  66  66  27  27  20  f6 <=
   5b  5b  87  87  03  00  01  00  4f  04  24  24  03  39  2c  2c
   05  00  04  00  be  be  85  85  04  00  4a  4a  05  05  5f  5f
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
   00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
Tags for short granules around the buggy address (one tag corresponds to 16 bytes):
   04  ..  ..  cf  ..  dc  ..  cd  ..  b9  ..  ..  3f  ..  57  ..
=> ..  ..  21  ..  ..  ..  ..  2d [f8] ..  ..  ..  ..  ..  ..  .. <=
   ..  ..  ..  ..  9c  ..  e2  ..  ..  4f  ..  ..  99  ..  ..  ..
See https://clang.llvm.org/docs/HardwareAssistedAddressSanitizerDesign.html#short-granules for a description of short granule tags
Registers where the failure occurred (pc 0x0060e00c5144):
    x0  f8000041e00b4183  x1  000000000000005a  x2  0000000000000006  x3  000000704176d9c0
    x4  00000060e00f4df6  x5  0000000000000004  x6  0000000000000046  x7  000000000000005a
    x8  00000060e00f4df0  x9  0000006800000000  x10 0000000000000001  x11 00000060e0126a00
    x12 0000000000000001  x13 0000000000000231  x14 0000000000000000  x15 000e81434c909ede
    x16 0000007041838b14  x17 0000000000000003  x18 0000007042b80000  x19 f8000041e00b4180
    x20 0000006800000000  x21 000000000000005a  x22 24000056e00b4000  x23 00000060e00f5200
    x24 00000060e0128c88  x25 00000060e0128c20  x26 00000060e0128000  x27 00000060e0128000
    x28 0000007fe59f16e0  x29 0000007fe59f1400  x30 00000060e00c5144
SUMMARY: HWAddressSanitizer: tag-mismatch (/data/fuzz/arm64/example_fuzzer/example_fuzzer+0xf140)
MS: 1 ChangeByte-; base unit: e09f9c158989c56012ccd88111b82f778a816eae
0x46,0x55,0x5a,
FUZ
artifact_prefix='./'; Test unit written to ./crash-0eb8e4ed029b774d80f2b66408203801cb982a60
Base64: RlVa

    Dans l'exemple de sortie, le plantage a été causé par fuzz_me_fuzzer.cpp à la ligne 10:

          data[3] == 'Z';  // :(

    Il s'agit d'une lecture hors limites simple si data a une longueur de trois.

    Une fois que vous avez exécuté votre fuzzeur, la sortie entraîne souvent un plantage, et l'entrée incriminée est enregistrée dans le corpus et reçoit un ID. Dans l'exemple de sortie, il s'agit de crash-0eb8e4ed029b774d80f2b66408203801cb982a60.

    Pour récupérer des informations sur les plantages lors d'un fuzzing sur l'appareil, exécutez cette commande en spécifiant votre ID de plantage:

    adb pull /data/fuzz/arm64/fuzz_me_fuzzer/corpus/CRASH_ID
     Notez que pour enregistrer les cas de test dans le bon répertoire, vous pouvez utiliser le dossier "corpus" (comme dans l'exemple ci-dessus) ou l'argument "artifact_prefix" (par exemple, "-artifact_prefix=/data/fuzz/where/my/crashes/go").

    Lors du fuzzing sur l'hôte, les informations sur les plantages apparaissent dans le dossier des plantages du dossier local où le fuzzeur est exécuté.

    Générer une couverture de ligne

    La couverture des lignes est très utile pour les développeurs, car ils peuvent identifier les zones du code qui ne sont pas couvertes et mettre à jour leurs fuzzers en conséquence pour cibler ces zones lors de futures exécutions de fuzzing.

    1. Pour générer des rapports de couverture du fuzzeur, procédez comme suit : 
      CLANG_COVERAGE=true NATIVE_COVERAGE_PATHS='*' make ${FUZZER_NAME}

    2. Après avoir transféré le fuzzeur et ses dépendances sur l'appareil, exécutez la cible de fuzzing avec LLVM_PROFILE_FILE comme suit: 
      DEVICE_TRACE_PATH=/data/fuzz/$(get_build_var TARGET_ARCH)/${FUZZER_NAME}/data.profraw
adb shell LLVM_PROFILE_FILE=${DEVICE_TRACE_PATH} /data/fuzz/$(get_build_var TARGET_ARCH)/${FUZZER_NAME}/${FUZZER_NAME} -runs=1000

    3. Pour générer le rapport de couverture, commencez par extraire le fichier profraw de l'appareil, puis générez le rapport HTML dans un dossier appelé "coverage-html", comme indiqué ci-dessous: 
      adb pull ${DEVICE_TRACE_PATH} data.profraw
llvm-profdata merge --sparse data.profraw --output data.profdata
llvm-cov show --format=html --instr-profile=data.profdata \
  symbols/data/fuzz/$(get_build_var TARGET_ARCH)/${FUZZER_NAME}/${FUZZER_NAME} \
  --output-dir=coverage-html --path-equivalence=/proc/self/cwd/,$ANDROID_BUILD_TOP

    Pour en savoir plus sur libFuzzer, consultez la documentation en amont.