AddressSanitizer (ASan)
AddressSanitizer (ASan) est un outil de détection d'erreurs mémoire largement adopté, utilisé intensivement lors des tests logiciels, en particulier le fuzzing. Il permet de détecter des bugs de corruption mémoire qui pourraient autrement passer inaperçus, tels que les dépassements de tampon, les erreurs use-after-free et autres violations de sécurité mémoire.
Aperçu
ASan est une pratique standard en fuzzing en raison de son efficacité à identifier les vulnérabilités mémoire. Il instrumente le code au moment de la compilation pour suivre les allocations et accès mémoire, détectant les opérations illégales à l'exécution.
Concepts clés
| Concept | Description |
|---|---|
| Instrumentation | ASan ajoute des vérifications à l'exécution sur les opérations mémoire pendant la compilation |
| Mémoire fantôme (Shadow Memory) | Mappe 20 To de mémoire virtuelle pour suivre l'état des allocations |
| Coût en performances | Ralentissement d'environ 2 à 4 fois par rapport au code non instrumenté |
| Périmètre de détection | Trouve les dépassements de tampon, use-after-free, double libération et fuites mémoire |
Quand appliquer
Appliquez cette technique lorsque :
- Vous fuzzez du code C/C++ à la recherche de vulnérabilités de sécurité mémoire
- Vous testez du code Rust avec des blocs
unsafe - Vous déboguez des plantages liés à une corruption mémoire
- Vous exécutez des tests unitaires où des erreurs mémoire sont suspectées
Ignorez cette technique lorsque :
- Vous exécutez du code en production (ASan peut réduire la sécurité)
- La plateforme est Windows ou macOS (prise en charge limitée d'ASan)
- Le surcoût en performance est inacceptable pour votre cas d'utilisation
- Vous fuzzez des langages purs et sécurisés sans FFI (par exemple, Go pur, Java pur)
Référence rapide
| Tâche | Commande/Modèle |
|---|---|
| Activer ASan (Clang/GCC) | -fsanitize=address |
| Activer la verbosité | ASAN_OPTIONS=verbosity=1 |
| Désactiver la détection de fuites | ASAN_OPTIONS=detect_leaks=0 |
| Forcer l'abandon sur erreur | ASAN_OPTIONS=abort_on_error=1 |
| Options multiples | ASAN_OPTIONS=verbosity=1:abort_on_error=1 |
Guide pas à pas
Étape 1 : Compiler avec ASan
Compilez et liez votre code avec l'option -fsanitize=address :
clang -fsanitize=address -g -o mon_programme mon_programme.c
L'option -g est recommandée pour obtenir de meilleures traces de pile lorsqu'ASan détecte des erreurs.
Étape 2 : Configurer les options ASan
Définissez la variable d'environnement ASAN_OPTIONS pour configurer le comportement d'ASan :
export ASAN_OPTIONS=verbosity=1:abort_on_error=1:detect_leaks=0
Étape 3 : Exécuter votre programme
Exécutez le binaire instrumenté par ASan. Lorsque des erreurs mémoire sont détectées, ASan imprime des rapports détaillés :
./mon_programme
Étape 4 : Ajuster les limites mémoire du fuzzer
ASan nécessite environ 20 To de mémoire virtuelle. Désactivez les restrictions mémoire du fuzzer :
- libFuzzer :
-rss_limit_mb=0 - AFL++ :
-m none
Modèles courants
Modèle : Intégration ASan de base
Cas d'utilisation : Configuration standard de fuzzing avec ASan
Avant :
clang -o cible_fuzz cible_fuzz.c
./cible_fuzz
Après :
clang -fsanitize=address -g -o cible_fuzz cible_fuzz.c
ASAN_OPTIONS=verbosity=1:abort_on_error=1 ./cible_fuzz
Modèle : ASan avec tests unitaires
Cas d'utilisation : Activer ASan pour une suite de tests unitaires
Avant :
gcc -o suite_tests suite_tests.c -lcheck
./suite_tests
Après :
gcc -fsanitize=address -g -o suite_tests suite_tests.c -lcheck
ASAN_OPTIONS=detect_leaks=1 ./suite_tests
Utilisation avancée
Astuces
| Astuce | Pourquoi cela aide |
|---|---|
Utiliser l'option -g | Fournit des traces de pile détaillées pour le débogage |
Définir verbosity=1 | Confirme qu'ASan est activé avant le démarrage du programme |
| Désactiver les fuites pendant le fuzzing | La détection de fuites ne provoque pas de plantages immédiats et encombre la sortie |
Activer abort_on_error=1 | Certains fuzzers nécessitent abort() au lieu de _exit() |
Comprendre les rapports ASan
Lorsqu'ASan détecte une erreur mémoire, il imprime un rapport détaillé comprenant :
- Type d'erreur : Dépassement de tampon, use-after-free, etc.
- Trace de pile : Où l'erreur s'est produite
- Traces d'allocation/libération : Où la mémoire a été allouée/libérée
- Carte mémoire : État de la mémoire fantôme autour de l'erreur
Exemple de rapport ASan :
==12345==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x60300000eff4 at pc 0x00000048e6a3
READ of size 4 at 0x60300000eff4 thread T0
#0 0x48e6a2 in main /path/to/file.c:42
Combiner les sanitizers
ASan peut être combiné avec d'autres sanitizers pour une détection complète :
clang -fsanitize=address,undefined -g -o cible_fuzz cible_fuzz.c
Considérations spécifiques à la plateforme
Linux : Prise en charge complète d'ASan avec les meilleures performances macOS : Prise en charge limitée, certaines fonctionnalités peuvent ne pas fonctionner Windows : Prise en charge expérimentale, déconseillée pour le fuzzing en production
Anti-patrons
| Anti-patron | Problème | Approche correcte |
|---|---|---|
| Utiliser ASan en production | Peut rendre les applications moins sécurisées | Utiliser ASan uniquement pour les tests |
| Ne pas désactiver les limites mémoire | Le fuzzer peut tuer le processus à cause des 20 To de mémoire virtuelle | Définir -rss_limit_mb=0 ou -m none |
| Ignorer les rapports de fuites | Les fuites mémoire indiquent des problèmes de gestion des ressources | Examiner les rapports de fuites à la fin de la campagne de fuzzing |
Conseils spécifiques aux outils
libFuzzer
Compilez avec le fuzzer et le sanitizer d'adresse :
clang++ -fsanitize=fuzzer,address -g harness.cc -o fuzz
Exécutez avec RSS illimité :
./fuzz -rss_limit_mb=0
Conseils d'intégration :
- Combinez toujours
-fsanitize=fuzzeravec-fsanitize=address - Utilisez
-gpour des traces de pile détaillées dans les rapports de plantage - Envisagez
ASAN_OPTIONS=abort_on_error=1pour une meilleure gestion des plantages
Voir : libFuzzer : AddressSanitizer
AFL++
Utilisez la variable d'environnement AFL_USE_ASAN :
AFL_USE_ASAN=1 afl-clang-fast++ -g harness.cc -o fuzz
Exécutez avec mémoire illimitée :
afl-fuzz -m none -i dossier_entree -o dossier_sortie ./fuzz
Conseils d'intégration :
AFL_USE_ASAN=1ajoute automatiquement les bons indicateurs de compilation- Utilisez
-m nonepour désactiver la limite mémoire d'AFL++ - Envisagez
AFL_MAP_SIZEpour les programmes avec de grandes cartes de couverture
Voir : AFL++ : AddressSanitizer
cargo-fuzz (Rust)
Utilisez l'option --sanitizer=address :
cargo fuzz run cible_fuzz --sanitizer=address
Ou configurez dans fuzz/Cargo.toml :
[profile.release]
opt-level = 3
debug = true
Conseils d'intégration :
- ASan est utile pour fuzzer du code Rust non sécurisé ou des interfaces FFI
- Le code Rust sécurisé peut ne pas en bénéficier autant (le compilateur empêche déjà de nombreuses erreurs)
- Concentrez-vous sur les blocs
unsafe, les pointeurs bruts et les liaisons de bibliothèques C
Voir : cargo-fuzz : AddressSanitizer
honggfuzz
Compilez avec ASan et liez avec honggfuzz :
honggfuzz -i dossier_entree -o dossier_sortie -- ./cible_fuzz_asan
Compilez la cible :
hfuzz-clang -fsanitize=address -g cible.c -o cible_fuzz_asan
Conseils d'intégration :
- honggfuzz fonctionne bien avec ASan par défaut
- Utilisez le mode piloté par rétroaction pour une meilleure couverture avec les sanitizers
- Surveillez l'utilisation mémoire, car ASan augmente l'empreinte mémoire
Dépannage
| Problème | Cause | Solution |
|---|---|---|
| Le fuzzer tue le processus immédiatement | Limite mémoire trop basse pour les 20 To de mémoire virtuelle d'ASan | Utilisez -rss_limit_mb=0 (libFuzzer) ou -m none (AFL++) |
| "ASan runtime not initialized" | Ordre de liaison incorrect ou runtime manquant | Assurez-vous que -fsanitize=address est utilisé à la fois en compilation et en liaison |
| Les rapports de fuites encombrent la sortie | LeakSanitizer activé par défaut | Définissez ASAN_OPTIONS=detect_leaks=0 |
| Mauvaise performance (>4x de ralentissement) | Mode débogage ou build non optimisé | Compilez avec -O2 ou -O3 en plus de -fsanitize=address |
| ASan ne détecte pas les bugs évidents | Binaire non instrumenté | Vérifiez avec ASAN_OPTIONS=verbosity=1 qu'ASan imprime les informations de démarrage |
| Faux positifs | Conflits d'intercepteurs | Consultez la FAQ ASan pour les problèmes connus avec des bibliothèques spécifiques |
Compétences associées
Outils utilisant cette technique
| Compétence | Comment cela s'applique |
|---|---|
| libfuzzer | Compilez avec -fsanitize=fuzzer,address pour un fuzzing intégré avec détection d'erreurs mémoire |
| aflpp | Utilisez la variable d'environnement AFL_USE_ASAN=1 lors de la compilation |
| cargo-fuzz | Utilisez l'option --sanitizer=address pour activer ASan pour les cibles de fuzzing Rust |
| honggfuzz | Compilez la cible avec -fsanitize=address pour un fuzzing instrumenté par ASan |
Techniques associées
| Compétence | Relation |
|---|---|
| undefined-behavior-sanitizer | Souvent utilisé ensemble avec ASan pour une détection complète des bugs (comportement indéfini + erreurs mémoire) |
| fuzz-harness-writing | Les harnais doivent être conçus pour gérer les plantages détectés par ASan et éviter les faux positifs |
| coverage-analysis | Le fuzzing guidé par la couverture aide à déclencher les chemins de code où ASan peut détecter des erreurs mémoire |
Ressources
Ressources externes clés
AddressSanitizer sur Google Sanitizers Wiki
La documentation officielle d'ASan couvre :
- Algorithme et détails d'implémentation
- Liste complète des types d'erreurs détectés
- Caractéristiques de performance et surcharge
- Comportement spécifique à la plateforme
- Limitations connues et incompatibilités
Indicateurs de configuration communs partagés par tous les sanitizers :
verbosity: Contrôle du niveau de sortie de diagnosticlog_path: Redirection de la sortie du sanitizer vers des fichierssymbolize: Activation/désactivation de la résolution des symboles dans les rapportsexternal_symbolizer_path: Utilisation d'un symboliseur personnalisé
Options de configuration spécifiques à ASan :
detect_leaks: Contrôle de la détection des fuites mémoireabort_on_error: Appel deabort()vs_exit()sur erreurdetect_stack_use_after_return: Détection des bugs use-after-return sur la pilecheck_initialization_order: Recherche des bugs d'ordre d'initialisation
Pièges courants et solutions :
- Problèmes d'ordre de liaison
- Conflits avec d'autres outils
- Problèmes spécifiques à la plateforme
- Conseils d'optimisation des performances
Documentation Clang AddressSanitizer
Conseils spécifiques à Clang :
- Indicateurs et options de compilation
- Interaction avec d'autres fonctionnalités de Clang
- Plateformes et architectures prises en charge
Documentation ASan spécifique à GCC :
- Indicateurs et comportement spécifiques à GCC
- Différences par rapport à l'implémentation Clang
- Prise en charge des plateformes dans GCC
AddressSanitizer : A Fast Address Sanity Checker (Article USENIX)
Article de recherche original avec des détails techniques :
- Algorithme de mémoire fantôme
- Exigences en mémoire virtuelle (historiquement 16 To, maintenant ~20 To)
- Références de performance
- Décisions de conception et compromis