failles applicatives
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
.Stack adresses 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 arguments
2. Sauvegarde d’EIP (SEIP) sur la pile
3. EIP ← adresse de la fonction à appeler
4. Sauvegarde d’EBP (SEBP)
5. EBP « remonte » au niveau d’ESP
6. Création d’espace pour le contexte de la fonction
2, 3
5
4
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 fonction
2. Restauration d’EBP (depuis SEBP)
3. RET = POP EIP = Restauration d’EIP (depuis SEIP)
2
1
3 Contexte
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
AAAAAAAA
AAAAAAAA
AAAAAAAA
AAAAAAAA
AAAAAAAA
AAAAAAAA
@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 0 1
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
appelante
adresses 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 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, 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 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
– 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 ebp
mov ebp,esp
push ebx
call 0xb7ff9d0b
add ebx,0x68eb
…
EXIT :
push ebp
mov ebp,esp
push edi
push esi
push ebx
…
PRINTF :
push ebp
mov ebp,esp
push ebx
call 0xb7e9828f
add ebx,0x10db3b
…
SHELLCODE :
\x90\x90\x90\x90
\xEB\x1A\x31\xC0
…
printf → 0xb7ecb4b0
malloc → 0xb7ff8700
exit → 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
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
NO
P +
SH
ELLC
OD
E
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 malicieux
Navigateurs → ☠ Page Web malicieuse
Clients Mail → ☠ Email malicieux
…
– 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 » 2011 18 juin à Paris
entré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/