FAILLES APPLICATIVES – INTRODUCTION & EXPLOITATION –

Présentation au sujet: "FAILLES APPLICATIVES – INTRODUCTION & EXPLOITATION –"— Transcription de la présentation:

1 FAILLES APPLICATIVES – INTRODUCTION & EXPLOITATION –
Projet “Tutorat Réseau / Sécurité” INSA de Lyon – 2011 Lucas Bouillot Gaétan Bouquet Arnaud Kleinpeter Xavier Paquin

2 – INTRODUCTION –

3 – INTRODUCTION – Qu’est ce qu’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 : Fuite d’informations Contournement de protections Détournement du flux d’exécution …

4 – CONTEXTE D’ATTAQUE – Architecture INTEL x86 32 bits
« little endian » 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 : Attaque en local :
« 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
adresses basses .Text code du programme .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 ESP Contexte d’exécution de fonction() 2 3 EBP 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 Contexte d’exécution de main() 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
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 AAAAAAAA AAAAAAAA AAAAAAAA AAAAAAAA AAAAAAAA AAAAAAAA EBP EBP SEBP AAAAAAAA SEIP @SHELLCODE SHELLCODE : \x90\x90\x90\x90 \xEB\x1A\x31\xC0 … adresses hautes adresses hautes

17

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 : Type Taille Signé Non signé char 8 bits [ -128 ; 127 ] [ 0 ; 255 ] short 16 bits [ ; ] [ 0 ; ] int 32 bits [ ; ] [ 0 ; ] …

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

21 – EXPLOITATION N°2 – Integer Overflow – Introduction
Exemple : avec un unsigned int 1 1 4 * 1 = = 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 …

23

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 – EXPLOITATION N°3 – Format String – Introduction
adresses basses 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 ESP Contexte d’exécution de printf() EBP SEBP SEIP %x Contexte d’exécution de la fonction appelante adresses hautes

27 – EXPLOITATION N°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 – EXPLOITATION N°3 – Format String – Explication
Formats utiles pour l’exploitation : %x : affichage hexadécimal d’une valeur fournie printf( "%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, 0x ) → affiche « 4d2 » (donc 3 caractères) → écrit la valeur « 0x0003 » à l’adresse 0x ⇒ Écritures arbitraires en mémoire

29 – EXPLOITATION N°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 – EXPLOITATION N°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 d2 ⇒ 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 – EXPLOITATION N°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 du shellcode et l’exécute, croyant se trouver dans la fonction légitime !

32 – EXPLOITATION N°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 – EXPLOITATION N°3 – Format String – Explication
Où trouver notre pointeur de fonction ? ⇒ Dans la GOT – Global Offset Table PRINTF : push ebp mov ebp,esp push ebx call 0xb7e9828f add ebx,0x10db3b … MALLOC : push ebp mov ebp,esp push ebx call 0xb7ff9d0b add ebx,0x68eb … EXIT : push ebp mov ebp,esp push edi push esi push ebx … appel de fonction GOT printf → 0xb7ecb4b0 malloc → 0xb7ff8700 exit → 0xb7eb0a30 … SHELLCODE : \x90\x90\x90\x90 \xEB\x1A\x31\xC0 … exit

34

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 : Logiciel Dernière version Vulnérabilité connue ? IE v v 9 beta Pas assez de place ici… ;) Firefox v3.6.10 v (v 4 beta 10) Use After Free Notepad++ v5.8.1 v 5.8.6 DLL Hijacking Acrobat Reader v9.3.4 v 10.0 Buffer overflow Filezilla v v (v beta) Passwords en clair …

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  La faille : mauvaise implémentation de la méthode JavaScript getIcon() → Stack Overflow 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 « Heap Spraying » 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

42

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 → ☠ 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 » juin à Paris entrée : 30 €

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

49 – LE MOT DE LA FIN –