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

PDF

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/