Aller au contenu
La Lettre IT
Retour aux synthèses
3 min de lecture
Développement & outils

Techniques pour améliorer le fuzzing avec AFL++

En bref

  • Un guide pratique de fuzzing avec AFL++, l'outil standard du fuzzing C/C++ sur Linux.
  • Les techniques clés : configurer les sanitizers (ASan, UBSan), utiliser le mode persistant pour accélérer les tests d'un ordre de magnitude, inclure directement les fichiers sources plutôt que les headers.
  • L'article note que malgré son efficacité prouvée, le fuzzing reste peu utilisé et découvre régulièrement des bugs dans des logiciels déjà en production.

Ce que dit la source

Le fuzzing mécanique détecte des défauts là où ils existent réellement, mais reste largement sous-exploité. L'auteur, qui a fuzé ~1 000 projets en six ans, affirme que presque tout logiciel complexe acceptant des entrées non maîtrisées contient au moins un bug trouvable par fuzzing, et propose une liste de techniques pour en améliorer l'efficacité avec AFL++.

  • Configurer les sanitizers Address Sanitizer (ASan) et Undefined Behavior Sanitizer (UBSan) dès la compilation, avec des options strictes (abort_on_error=1, halt_on_error=1) et activation de detect_stack_use_after_return pour une détection plus sensible des défauts
  • Le mode persistant (afl-gcc-fast, afl-clang-fast) est typiquement dix fois plus rapide que le fuzzing standard, malgré des pièges à connaître, et vaut l'effort d'un petit code d'entrée (quelques dizaines de lignes)
  • Inclure directement les fichiers source (.c, .cpp) dans le template de fuzzing plutôt que de gérer des headers : élimine la plupart de la configuration de build, donne accès aux fonctions statiques et variables statiques (possibilité de les réinitialiser entre tests), et permet de tester directement des interfaces internes non publiques
  • Le remplissage complet des allocations mémoire en ASan (max_malloc_fill_size) aide à détecter des bugs subtils qui restent cachés avec le comportement par défaut (4 Kio seulement)
  • Pour C++, ajouter -D_GLIBCXX_DEBUG lors du fuzzing avec libstdc++ pour attraper les accès hors limites que ASan ne voit pas au sein de la capacité d'un conteneur

Dans les commentaires

Débat partagé, centré sur la valeur pratique prouvée de l'outil. Plusieurs commentateurs confirment que le fuzzing avec AFL++ trouve régulièrement des bugs réels même dans du code écrit par des ingénieurs seniors, et que le mode persistant apporte des gains énormes de vitesse.

  • L'un des commentateurs signale que la documentation du mode persistant est mauvaise, ce qui crée une friction d'adoption malgré les gains de performance (x160 dans son cas avec hivex)
  • Une question posée porte sur la détermination de la réalité d'un crash trouvé versus un faux positif, question à laquelle le fil ne répond pas de façon substantielle

Notre lecture

Article pratique adressé à des développeurs C/C++ Linux sérieux sur leurs tests. Les techniques sont éprouvées (l'auteur a le terrain pour les valider), incrémentales et peu coûteuses à mettre en place. Le message principal, que le fuzzing est délaissé malgré son ROI évident, reste vrai et justifie la lecture. Une ressource à consulter si votre équipe accepte des entrées complexes non triviales ; mieux vaut commencer par la documentation officielle d'AFL++, puis utiliser ce guide comme complément de configuration plus agressif. Pas une révélation, mais une consolidation d'une bonne pratique largement inactuelle.

Le brief, dans votre boîte mail

Recevez chaque jour la sélection et l'analyse La Lettre IT, sans avoir à repasser sur le site.