F AILLES A PPLICATIVES – I NTRODUCTION & E XPLOITATION –

1. FAILLES APPLICATIVES – INTRODUCTION & EXPLOITATION – Projet “TutoratRéseau/ Sécurité” INSA de Lyon – 2011

2. – INTRODUCTION –

3. – INTRODUCTION – • Qu’estcequ’une “faille applicative” ? • « faiblesse dans un système informatique permettant à un attaquant de porter atteinte à l'intégrité de ce système, c'est-à-dire à son fonctionnement normal, à la confidentialité et l'intégrité des données qu'il contient » • Dans notre cas : • exploitation de programmes codés en C / C++ • Quels types d’exploitation : • Fuited’informations • Contournement de protections • Détournement du flux d’exécution • …

4. – CONTEXTE D’ATTAQUE – • Architecture INTEL x86 32 bits • « littleendian » • Premières démonstrations sous Linux • Dernière démonstration sous Windows XP • Programmes C / C++ • Démonstration, « Proof Of Concept »

5. – CONTEXTE D’ATTAQUE – • 2 types d’attaques : • « remote » • « local » • Attaque en local : • Contexte : l’attaquant possède un compte sur la machine cible (ex : session SSH) • Cible : exploitation de binaires « setuid » • But : « privilege escalation »

6. – RAPPELS & PRE-REQUIS –

7. – RAPPELS & PRE-REQUIS –Segmentation de la mémoire code du programme adresses basses .Text .Data données statiques et globales initialisées .Bss données statiques et globales non-initialisées .Heap données allouées dynamiquement .Stack Variables locales, contexte de fonction adresses hautes

8. – RAPPELS & PRE-REQUIS –Quelques notions d’assembleur • Les registres : • De calcul : EAX, EBX, ECX, EDX • De pile : EBP, ESP • D’instruction : EIP • Quelques instructions : • PUSH reg, POP reg • CALL / RET • MOV dest, src

9. – RAPPELS & PRE-REQUIS –Appel de fonction : gestion de la pile adresses basses Sens de la pile ESP Contexte d’exécution de main() EBP adresses hautes

10. – RAPPELS & PRE-REQUIS –Appel de fonction : gestion de la pile 1 adresses basses 2, 3 4 Contexte d’exécution de fonction() 5 6 SEBP • Empilement des arguments • Sauvegarde d’EIP (SEIP) sur la pile • EIP ← adresse de la fonction à appeler • Sauvegarde d’EBP (SEBP) • EBP « remonte » au niveau d’ESP • Création d’espace pour le contexte de la fonction SEIP Argument 1 … Argument N ESP Contexte d’exécution de main() EBP adresses hautes

11. – RAPPELS & PRE-REQUIS –Appel de fonction : gestion de la pile adresses basses 1 Contexte d’exécution de fonction() 2 3 SEBP • Suppression du contexte de la fonction • Restauration d’EBP (depuis SEBP) • RET = POP EIP = Restauration d’EIP (depuis SEIP) SEIP Argument 1 … Argument N ESP Contexte d’exécution de main() EBP adresses hautes

12. – RAPPELS & PRE-REQUIS –Outils pour l’exploitation • Un désassembleur / débuggeur : • UNIX : GDB – GNU Debugger • Windows : OllyDBG, WinDBG, IDA • Un peu de shell  • Des « shellcodes » • Suite d’instruction assembleur précompilées • Permet de lancer un shell (d’où le nom…) • On détournera le flux d’exécution grâce à ça

13. – EXPLOITATION N°1 –Buffer Overflow

14. – EXPLOITATION N°1 –Buffer Overflow – Introduction • « buffer » ? • Zone de mémoire (ex : tableau d’éléments, structure de donnée, zone allouée avec malloc, …) • « overflow » ? • dépassement • Lors d’une copie, que se passe-t-il si la taille des données est supérieure à la taille du buffer qui est censé les recevoir ?

15. – EXPLOITATION N°1 –Buffer Overflow – Explications • La faille : copie de données utilisateur sans vérification de la taille • Exploitation la plus courante : • « stack overflow » • Injection d’un shellcode sur la pile et calcul de son adresse • Dépassement de capacité d’une variable sur la pile • Écrasement de SEIP par l’adresse du shellcode ⇒ Le programme saute à l’adresse du   shellcode lors du « RET » et l’exécute !

16. – EXPLOITATION N°1 –Buffer Overflow – Explications adresses basses adresses basses ESP ESP Contexte d’exécution actuel AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA EBP EBP SEBP AAAAAAAA SEIP @SHELLCODE SHELLCODE : \x90\x90\x90\x90\xEB\x1A\x31\xC0 … adresses hautes adresses hautes

18. – EXPLOITATION N°2 –Integer Overflow

19. – EXPLOITATION N°2 –Integer Overflow – Introduction • Opération mathématique qui produit une valeur numérique supérieure au maximum stockable • Limites :

20. – EXPLOITATION N°2 –Integer Overflow – Introduction • Exemple : avec un char 127 + 1 -128

21. – EXPLOITATION N°2 –Integer Overflow – Introduction • Exemple : avec un unsignedint 1 073 741 824 * 4 1 = 4 294 967 296 = 0

22. – EXPLOITATION N°2 –Integer Overflow – Explications • La faille : erreur de typage, non vérification des conditions limites, … • Diverses exploitations selon les cas : • Contournement de vérification sur la taille • Tentative d’allocation d’une zone mémoire de taille nulle • …

24. – EXPLOITATION N°3 –Format String Attack

25. – EXPLOITATION N°3 –Format String – Introduction • Fonctions à arguments variables • <type> fonction( <type> argument1, … ); • Un 1er argument obligatoire • Utilisation des macros va_start, va_arg et va_end pour récupérer les arguments suivants • Exemple : la famille « printf » • printf( "chaîne de format", argument1, …, argumentN ) • Affichage d’une chaine formatée

26. – EXPLOITATIONN°3 –Format String – Introduction • Que se passe-t-il si on ne donne pas le bon nombre d’arguments à printf() ? • printf( "%x" ); ? ⇒ utilisation des valeurs de la pile ou « seraient » normalement empilés les arguments ⇒ résultat : bffffbd4 adresses basses ESP Contexte d’exécution de printf() EBP SEBP SEIP %x Contexte d’exécution de la fonction appelante adresses hautes

27. – EXPLOITATIONN°3 –Format String – Explication • La faille : utilisation d’une entrée utilisateur dans une chaine de format • l’utilisateur pour fournir lui-même un formatage pour manipuler la mémoire • Exemple : • printf( argv[1] ); • Bonne utilisation : • printf( "%s", argv[1] ); Si argv[1] contient des « %... » ils seront interprété comme chaîne de format Peu importe ce que contient argv[1], ce sera uniquement affiché comme une chaine de caractères

28. – EXPLOITATIONN°3 –Format String – Explication • Formats utiles pour l’exploitation : • %x : affichage hexadécimal d’une valeur fournieprintf( "%x", 1234 )→ affiche « 4d2 », conversion hexadécimale de 1234 ⇒ Lectures arbitraires en mémoire • %hn : écriture du nombre d’octet traité par printf à l’adresse fournie (sur 2 octets)printf( "%x%hn", 1234, 0x12345678 )→ affiche « 4d2 » (donc 3 caractères) → écrit la valeur « 0x0003 » à l’adresse 0x12345678 ⇒ Écritures arbitraires en mémoire

29. – EXPLOITATIONN°3 –Format String – Explication • 2 problèmes→ 2 solutions  • Problème : Comment spécifier l’adresse où écrire, puisque les valeurs utilisées seront celles qui suivent sur la pile ? ⇒ Solution : « Direct Parameter Access » printf( "%3$x", 1, 2, 3 ) affiche « 3 » ⇒ Nos données aussi sont sur la pile : en donnant un numéro d’argument suffisamment lointain on peut retomber sur une valeur que l’on contrôle, comme si on contrôlait le Nième paramètre de printf.

30. – EXPLOITATIONN°3 –Format String – Explication • 2 problèmes→ 2 solutions  • Problème :Comment écrire une valeur précise, puisque c’est le nombre d’octets traité par printf qui est écrit ? ⇒ Solution : Taille minimum printf( "%010x", 1234 ) affiche 00000004d2 ⇒ A partir de la valeur voulue, on peut spécifier une taille minimum pour ajuster le nombre d’octets traités par printf sur cette valeur

31. – EXPLOITATIONN°3 –Format String – Explication • Une exploitation parmi d’autres : • Injection d’un shellcode sur la pile et calcul de son adresse • Recherche d’un pointeur de fonction utilisée après l’appel à printf • Écrasement du pointeur de fonction par l’adresse du shellcode en 2 étapes : • Adresse = 4 octets, or %hn = écriture de 2 octets • Ajustement et écriture de la 1ère moitié • Ajustement et écriture de la 2ème moitié ⇒ Lors de l’appel de la fonction écrasée, le programme saute à l’adresse dushellcode et l’exécute, croyant se trouver dans la fonction légitime !

32. – EXPLOITATIONN°3 –Format String – Explication • Chaine type pour l’exploitation : <addr1> <addr2> %<num1>x %<param1>$hn %<num2>x %<param2>$hn • <addr1>: adresse des 2 premiers octets du pointeur de fonction • <addr2>: adresse des 2 derniers octets du pointeur de fonction • <num1> : nombre pour l’ajustement de la valeur écrite, sur la 1ère moitié de l’adresse du shellcode • <param1> : numéro d’accès direct au paramètre pour <addr1> • <num2>: nombre pour l’ajustement de la valeur écrite, sur la 2ème moitié de l’adresse du shellcode • <param2> : numéro d’accès direct à <addr2> (généralement <param1>+1)

33. – EXPLOITATIONN°3 –Format String – Explication • Où trouver notre pointeur de fonction ?⇒ Dans la GOT – Global Offset Table PRINTF : push ebp movebp,esp push ebx call 0xb7e9828f addebx,0x10db3b … MALLOC : push ebp movebp,esp push ebx call 0xb7ff9d0b addebx,0x68eb … EXIT : push ebp movebp,esp push edi push esi push ebx … appel de fonction printf → 0xb7ecb4b0 malloc → 0xb7ff8700 exit → 0xb7eb0a30 GOT … SHELLCODE : \x90\x90\x90\x90\xEB\x1A\x31\xC0 … exit → @SHELLCODE

35. – EXPLOITATION N°3 –“In The Wild”

36. – EXPLOITATION N°3 –“In The Wild” – Introduction • Les programmes précédents sont faits pour être corrompus • Qu’en est-t-il de « vrais programmes » ? • Une multitude de programmes vulnérables utilisés tous les jours • IE, Firefox, Adobe Reader, libc, Exim4, …

37. – EXPLOITATION N°3 –“In The Wild” – Introduction • Une cible pour la démonstration ? • Les logiciels en IF :

38. – EXPLOITATION N°3 –“In The Wild” – Adobe Acrobat Reader • Quelques informations sur le format PDF • Une collection d’objets • Un dictionnaire des références aux objets • Peut être compressé, chiffré • Médias embarqués : • images, vidéos, flash, pièces jointes, … • Le coté obscur : • JavaScript : implémentation parfois douteuse • OpenAction / AutomaticAction / Handlers

39. – EXPLOITATION N°3 –“In The Wild” – Adobe Acrobat Reader • La cible : Adobe Acrobat Reader … v. 9.0.0  • La faille : mauvaise implémentation de la méthode JavaScript getIcon()→ StackOverflow • L’exploitation : Ouverture d’un PDF malveillant

40. – EXPLOITATION N°3 –“In The Wild” – Adobe Acrobat Reader • Le PDF : • Presque vide • Un script JavaScript • Appel du script à l’ouverture • Appel de la fonction getIcon() PDF OpenAction JavaScript • Shellcode • Heap Spray • getIcon()

41. – EXPLOITATION N°3 –“In The Wild” – Adobe Acrobat Reader • La technique du « HeapSpraying » • Choix d’un adresse de retour sur le tas • Allocation de nombreux blocs contenant : • Un « NOP Sled » • Un shellcode • Saut à l’adresse choisie sur le tas NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE NOP + SHELLCODE Heap Adresse choisie 0x0c0c0c0c

43. – CONCLUSION –

44. – CONCLUSION – • Facile de prendre le contrôle d’un programme à partir d’une erreur de codage • Exploitations de plus en plus compliquées, mais de plus en plus fréquentes : • Exploitations qui ciblent le français moyen • Lecteurs PDF → ☠ PDF malveillant • Navigateurs → ☠ Page Web malveillant • Clients Mail → ☠ Email malveillant • …

45. – CONCLUSION – • Sécurisation / Protection : • Impossible à éradiquer : le processeur ne différencie pas « code » et « données » • Moyens de protections alternatifs qui rendent l’exploitation plus compliquée : • ASLR – Address Space Layout Randomization • Bit NX – Page mémoire « Non eXecutable » • DEP, SafeSEH, Kernel patches, … • La meilleure des protection reste encore de coder proprement  ⇒ impossible…

46. – QUESTIONS? –

47. – LE MOT DE LA FIN – • Intéressé par la sécurité ? • La « Nuit Du Hack » 201118 juin à Paris entrée : 30 €

48. – LE MOT DE LA FIN – • Programme : • Conférences • Ateliers • Challenge !  • Exemple d’épreuves : • Failles web : injection SQL et xpath, XSS, includes, … • Wargame : overflow, format string, race conditions … • Reverse : crackmeandroid, nintendo DS, ARM, … • CTF : attaque défense en équipe !

49. – LE MOT DE LA FIN – http://www.nuitduhack.com/