f ailles a pplicatives – i ntroduction & e xploitation – projet tutorat réseau / sécurité...
TRANSCRIPT
FAILLES APPLICATIVES – INTRODUCTION & EXPLOITATION –
Projet “Tutorat Réseau / Sécurité”
INSA de Lyon – 2011
Lucas Bouillot Gaétan Bouquet
Arnaud Kleinpeter Xavier Paquin
– INTRODUCTION –
– 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 …
– 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 »
– 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 »
– RAPPELS & PRE-REQUIS –
– RAPPELS & PRE-REQUIS –Segmentation de la mémoire
code du programme.Text
.Heap
.Data
.Bss
.Stackadresses
hautes
adresses basses
données statiques et globales initialisées
données statiques et globales non-initialisées
données allouées dynamiquement
Variables locales, contexte de fonction
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
– RAPPELS & PRE-REQUIS –Quelques notions d’assembleur
– RAPPELS & PRE-REQUIS –Appel de fonction : gestion de la pile
adresses hautes
adresses basses
Sens de la pile
ESP
EBP
Contexte d’exécution de main()
– RAPPELS & PRE-REQUIS –Appel de fonction : gestion de la pile
Contexte d’exécution
de fonction()
SEIP
SEBP
Contexte d’exécution de main()
1. Empilement des arguments2. Sauvegarde d’EIP (SEIP) sur la pile3. EIP ← adresse de la fonction à appeler4. Sauvegarde d’EBP (SEBP)5. EBP « remonte » au niveau d’ESP6. Création d’espace pour le contexte de la
fonction
2, 3
54
adresses hautes
adresses basses
Argument 1…
Argument N
1
6
ESP
EBP
– RAPPELS & PRE-REQUIS –Appel de fonction : gestion de la pile
1. Suppression du contexte de la fonction2. Restauration d’EBP (depuis SEBP)3. RET = POP EIP = Restauration d’EIP
(depuis SEIP)
21
3Contexte
d’exécution de
fonction()
SEIP
SEBP
Contexte d’exécution de main()
adresses hautes
adresses basses
Argument 1…
Argument N
ESP
EBP
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
– RAPPELS & PRE-REQUIS –Outils pour l’exploitation
– EXPLOITATION N°1 –Buffer Overflow
« 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 ?
– EXPLOITATION N°1 –Buffer Overflow – Introduction
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 !
– EXPLOITATION N°1 –Buffer Overflow – Explications
– EXPLOITATION N°1 –Buffer Overflow – Explications
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@SHELLCODE
AAAAAAAA
SHELLCODE :
\x90\x90\x90\x90\xEB\x1A\x31\xC0 …
adresses hautes
adresses basses
ESP
EBP
Contexte d’exécution
actuel
SEIP
SEBP
adresses hautes
adresses basses
ESP
EBP
– EXPLOITATION N°2 –Integer Overflow
Opération mathématique qui produit une valeur numérique supérieure au maximum stockable
Limites :
– EXPLOITATION N°2 –Integer Overflow – Introduction
Type Taille Signé Non signé
char 8 bits [ -128 ; 127 ] [ 0 ; 255 ]
short 16 bits [ -32768 ; 32767 ] [ 0 ; 65535 ]
int 32 bits [ -2 147 483 648 ; 2 147 483 647 ] [ 0 ; 4 294 967 295 ]
…
Exemple : avec un char
– EXPLOITATION N°2 –Integer Overflow – Introduction
0 1 1 1 1 1 1 1 127
0 0 0 0 0 0 0 1 1 +
1 0 0 0 0 0 0 0 -128
Exemple : avec un unsigned int
– EXPLOITATION N°2 –Integer Overflow – Introduction
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
4 *
= 4 294 967 296= 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 01
1 073 741 824
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 …
– EXPLOITATION N°2 –Integer Overflow – Explications
– EXPLOITATION N°3 –Format String Attack
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
– EXPLOITATION N°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
– EXPLOITATION N°3 –Format String – Introduction
Contexte d’exécution de printf()
SEIP
SEBP
Contexte d’exécution
de la fonction
appelanteadresses
hautes
adresses basses
ESP
EBP
%x
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] );
– EXPLOITATION N°3 –Format String – Explication
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
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
– EXPLOITATION N°3 –Format String – Explication
2 problèmes → 2 solutions
1. 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.
– EXPLOITATION N°3 –Format String – Explication
2 problèmes → 2 solutions
2. Problème : Comment écrire une valeur précise, puisque c’est le nombre d’octets traité par printf qui est écrit ?
⇒ Solution : Taille minimumprintf( "%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
– 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 !
– EXPLOITATION N°3 –Format String – Explication
Chaine type pour l’exploitation :
– EXPLOITATION N°3 –Format String – Explication
• <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)
<addr1><addr2>%<num1>x%<param1>$hn%<num2>x%<param2>$hn
Où trouver notre pointeur de fonction ?⇒ Dans la GOT – Global Offset Table
– EXPLOITATION N°3 –Format String – Explication
MALLOC :
push ebpmov ebp,esppush ebxcall 0xb7ff9d0badd ebx,0x68eb…
EXIT :
push ebpmov ebp,esppush edipush esipush ebx…
PRINTF :push ebpmov ebp,esppush ebxcall 0xb7e9828fadd ebx,0x10db3b…
SHELLCODE :
\x90\x90\x90\x90\xEB\x1A\x31\xC0 …
printf → 0xb7ecb4b0malloc →
0xb7ff8700exit → 0xb7eb0a30
…
GOT
appel de fonction
exit → @SHELLCODE
– EXPLOITATION N°3 –“In The Wild”
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, …
– EXPLOITATION N°3 –“In The Wild” – Introduction
Une cible pour la démonstration ?
Les logiciels en IF :
– EXPLOITATION N°3 –“In The Wild” – Introduction
Logiciel Dernière version Vulnérabilité connue ?
IE v8.0.6001.18999 v 9 beta Pas assez de place ici… ;)
Firefox v3.6.10 v 3.6.13 (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 v3.3.4.1 v 3.3.5.1 (v 3.4.0 beta) Passwords en clair
…
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
– 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() → Stack Overflow
L’exploitation :Ouverture d’un PDF malveillant
– 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()
– EXPLOITATION N°3 –“In The Wild” – Adobe Acrobat Reader
JavaScript
OpenAction
• Shellcode• Heap Spray• getIcon()
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
– EXPLOITATION N°3 –“In The Wild” – Adobe Acrobat Reader
Heap
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
NO
P +
SH
ELL
CO
DE
Adresse choisie
0x0c0c0c0c
– CONCLUSION –
– 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 …
– 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…
– QUESTIONS ? –
– LE MOT DE LA FIN – Intéressé par la sécurité ?
La « Nuit Du Hack » 201118 juin à Parisentrée : 30 €
– 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 : crackme android, nintendo DS, ARM, … CTF : attaque défense en équipe !
– LE MOT DE LA FIN –
http://www.nuitduhack.com/