===================== :: Reversing Linux :: =====================

Transcription

1 ===================== :: Reversing Linux :: ===================== [+] SoMmAiRe - Introduction - Format ELF & PE - Outils Unix - Patcher un Binaire - Cracker une Structure Conditionnel - Outrepasser ptrace() - Exploiter un Stack Overflow - Hoocking avec LD_PRELOAD - Contourner le Stripping - Obfuscation de Code en C

2 [+] Introduction Depuis que les ordinateurs existent, il y a toujours eu des bugs dans la machine, des erreurs de programmation, ou des paramètres non pris en compte lors de la conception d'une application, conduisant un système à un endroit du Kernel qu'il n'était pas censé visiter... Mais dès lors, plusieurs techniques on vu le jour afin d'analyser ces dysfonctionnements, et les corriger. Ces techniques repose en réalité sur un seul grand principe d'analyse de binaire, nommé Reverse Engineering (Reversing). Dans ce tutorial, je ne vais me consacrer qu'à l'analyse de programme sous environnement de type Unix, et non sous Windows beaucoup plus connu. L'unique raison à cela est que le système et la structure même des fichiers exécutable sous Unix est grandement différente et beaucoup plus attrayante. Sous Windows, il porte le nom de PE (Portable Exécutable), tandis que sous Linux, il est nommé ELF (Extended & Linking Format), et c'est la raison même du prochain Chapitre. Qui plus est s'ajoute à cela le fait que la grande majorité des serveurs de la planète tourne sous ce système d'exploitation, et de fait la compréhension des serveurs planétaire se verra d'autant pus grande si l'on se lance dans l'analyse approfondie de ses binaires et de son mode de fonctionnement. Également, il est bon de savoir que la majorité des techniques de Hacking moderne sont basés sur le Reversing, car cette méthode d'analyse permet dans de nombreux cas de comprendre le fonctionnement poussé d'un programme, et par conséquent cela permet d'en découvrir des failles qu'il aurait été impossible de découvrir autrement. C'est donc un atout du côté sécurité, comme du côté programmatif, car il toujours nécessaire de comprendre le déroulement d'un programme bugué afin de le corriger correctement. [+] Format ELF & PE Chaque fichier exécutable sous Linux repose sur une structure nommé ELF. Cette structure, détaillé dans /usr/include/elf.h, permet au système d exécuter un binaire, et lui permet de connaître son fonctionnement exacte. Ainsi, lorsque l'on exécute un programme, le système va commencer par lire l'ensemble du fichier exécutable, analyser chaque table, mettre en mémoire chaque information à sa bonne place (SDR, Appel de fonction...), afin que ce dernier puisse fonctionner correctement. Ainsi, et vous pourrez l'observer par vous-même, chaque programme est composé en section, et chaque section possède un nom et une fonction propre. De fait.text contient l'ensemble du code à proprement parler,.rodata contient les SDR (String Data Reference)...

3 Sophocle~# cat trainer.c #include <stdio.h> int main(){ int i = 0; if(i > 15){ printf("\n\naccess GRANTED!!\n\n"); else{ printf("\n\naccess DENIED!!\n\n"); return 0; Sophocle~# gcc trainer.c Sophocle~# [+] Outils Unix Afin d'avoir la possibilité d'analyser un programme sous une forme compréhensible, il est nécessaire de posséder quelques outils préalable. Sous Windows ils sont très connu, mais peut-être moins sous Linux lorsque l'on ne s'y attarde pas. Ainsi, voici une courte liste détaillant le principe des principaux outils de Reversing sous Linux. - GCC : GNU C Compiler - GDB : GNU Debuguer. - Objdump : Un outil très utile pour l'analyse statique - Strace : Permet de tracer l exécution d'un programme - Hexedit : Un Éditeur Héxadécimale en mode Console. Comme vous avez sûrement pû le constater, ce ne sont là que les outils de bases indispensables, et d'autre outils ou paquetage d'outils comme elfsh peuvent s'avérer très intéressant, mais pour ce tutorial d'initiation au Reversing Linux, je pense que cela sera amplement suffisant. [+] Patcher un Binaire Pour cette toute première mise en œuvre, je vais m'attarder sur la modification manuel d'un programme afin de lui faire une chose qu'il n'était pas censé faire à son origine. Pour cela, il va nous falloir analyser l exécution du programme, comprendre son fonctionnement et éditer son code directement avec hexedit. Voici le code source C du programme de démonstration. Comme on peut le constater, obtenir un accès sur ce programme est un jeux d'enfant, il nous suffit pour cela de modifier la valeur de i, ou alors de modifier la comparaison, et c'est ce que nous allons faire ici. Commençons par executer le programme et observons. Sophocle~# a.out ACCESS DENIED!! Sophocle~# Intéressant, nous avons donc eu un accès refusé car la valeur de i est inférieur à 15. Modifions donc la comparaison et obtenons un accès. Essayons en premier lieu de désassembler le code via objdump et observons.

4 Sophocle~# objdump -d a.out a.out: file format elf32-i386 Disassembly of section.init: <_init>: : 55 [...] <main>: : 8d 4c lea 0x4(%esp),%ecx : 83 e4 f0 and $0xfffffff0,%esp b: ff 71 fc pushl -0x4(%ecx) e: 55 push %ebp f: 89 e5 mov %esp,%ebp : 51 push %ecx : 83 ec 14 sub $0x14,%esp : c7 45 f movl $0x0,-0x8(%ebp) c: 83 7d f8 0f cmpl $0xf,-0x8(%ebp) : 7e 12 jle <main+0x30> : 83 ec 0c sub $0xc,%esp : push $0x a: e8 1d ff ff ff call c f: 83 c4 10 add $0x10,%esp : eb 10 jmp <main+0x40> : 83 ec 0c sub $0xc,%esp : 68 9d push $0x804849d c: e8 0b ff ff ff call c : 83 c4 10 add $0x10,%esp : b mov $0x0,%eax : 8b 4d fc mov -0x4(%ebp),%ecx c: c9 leave d: 8d 61 fc lea -0x4(%ecx),%esp 80483a0: c3 ret 80483a1: 90 nop 80483a2: 90 nop 80483a3: 90 nop [...] J'ai volontairement supprimer une partie du code ASM afin de gagner en place, mais cela n'empêche en rien une analyse sur le tutorial étant donné que le code ASM de la fonction main est présente. Regardons du côté des comparaisons. On a donc un JLE (Saut Conditionnel) en 0x et juste au dessus, un CMPL (Comparaison de i avec 15). De manière logique, si on modifie la valeur 0xF (15 en Décimal) du CMPL, ou si l'on supprime le saut conditionnel, on obtiendra un accès. Activons nous à la tâche dans ce cas... Ouvrons le programme avec hexedit, et recherchons la chaine hexadécimale 837DF80F, qui correspond au code machine du if(i > 15) en C. Une fois trouvé, vérifions si 7E12 (JLE) suit ce bout de code, remplaçons le 7E12 par des NOP (No Operation), soit 9090, on sauvegarde (CTRL+X) et on rééxecute. Sophocle~# a.out ACCESS GRANTED!! Sophocle~# Et voila comment il est possible de Patcher un programme sans aucun code source.

5 [+] Cracker une Structure Conditionnel A présent que nous savons comment fonctionne la plupart des outils, et la manière de patcher un binaire, il va nous falloir apprendre à outrepasser une structure conditionnel un peu plus complexe, et cette fois sans toucher au code même du programme. Voici le programme de démonstration en C. Sophocle~# cat test.c #include <stdio.h> #include <string.h> int main(){ char Password[] = "Sophocle"; char Buffer[500+1]; printf("password : "); fgets(buffer, sizeof(buffer), stdin); if(strncmp(buffer, Password, strlen(password))==0){ printf("\naccess GRANTED!!\n"); else{ printf("\naccess DENIED!!\n"); return 0; Sophocle~# gcc test.c Sophocole~# Comme vous pouvez encore le constater, toujours rien de très compliqué. Cette fois-ci j'ai implémenter un très simple système d'authentification, et le but du jeux étant toujours d'obtenir un accès valide. Executons en premier lieu le programme afin d'observer son fonctionnement. Sophocle~# a.out Password : root ACCESS DENIED!! Sophocle~# Sortons à présent GDB (Débugueur) afin de tenter de bypasser cette authentification. Sophocle~# gdb GNU gdb 6.6 Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-slackware-linux". (gdb) Maintenant, chargeons le programme dans le Debugueur et désassemblons la

6 fonction main afin d'analyser son comportement. (gdb) file a.out Reading symbols from /root/a.out...done. Using host libthread_db library "/lib/libthread_db.so.1". (gdb) disass main Dump of assembler code for function main: 0x <main+0>: lea 0x4(%esp),%ecx 0x <main+4>: and $0xfffffff0,%esp 0x b <main+7>: pushl 0xfffffffc(%ecx) 0x e <main+10>: push %ebp 0x f <main+11>: mov %esp,%ebp 0x <main+13>: push %edi 0x <main+14>: push %esi 0x <main+15>: push %ecx 0x <main+16>: sub $0x20c,%esp 0x a <main+22>: lea 0xffffffeb(%ebp),%edi 0x d <main+25>: mov $0x80485e9,%esi 0x <main+30>: cld 0x <main+31>: mov $0x9,%ecx 0x <main+36>: rep movsb %ds:(%esi),%es:(%edi) 0x a <main+38>: sub $0xc,%esp 0x d <main+41>: push $0x80485b8 0x <main+46>: call 0x x <main+51>: add $0x10,%esp 0x a <main+54>: mov 0x ,%eax 0x f <main+59>: sub $0x4,%esp 0x <main+62>: push %eax 0x <main+63>: push $0x1f5 0x <main+68>: lea 0xfffffdf6(%ebp),%eax 0x e <main+74>: push %eax 0x f <main+75>: call 0x x <main+80>: add $0x10,%esp 0x <main+83>: lea 0xffffffeb(%ebp),%eax 0x a <main+86>: mov $0xffffffff,%ecx 0x f <main+91>: mov %eax,0xfffffdf0(%ebp) 0x <main+97>: mov $0x0,%al 0x <main+99>: cld 0x <main+100>: mov 0xfffffdf0(%ebp),%edi 0x e <main+106>: repnz scas %es:(%edi),%al 0x <main+108>: mov %ecx,%eax 0x <main+110>: not %eax 0x <main+112>: dec %eax 0x <main+113>: sub $0x4,%esp 0x <main+116>: push %eax 0x <main+117>: lea 0xffffffeb(%ebp),%eax 0x c <main+120>: push %eax 0x d <main+121>: lea 0xfffffdf6(%ebp),%eax 0x <main+127>: push %eax 0x <main+128>: call 0x x <main+133>: add $0x10,%esp 0x c <main+136>: test %eax,%eax 0x e <main+138>: jne 0x80484b2 <main+158> 0x080484a0 <main+140>: sub $0xc,%esp 0x080484a3 <main+143>: push $0x80485c4 0x080484a8 <main+148>: call 0x x080484ad <main+153>: add $0x10,%esp 0x080484b0 <main+156>: jmp 0x80484c2 <main+174> 0x080484b2 <main+158>: sub $0xc,%esp 0x080484b5 <main+161>: push $0x80485d7 0x080484ba <main+166>: call 0x

7 0x080484bf <main+171>: add 0x080484c2 <main+174>: mov 0x080484c7 <main+179>: lea 0x080484ca <main+182>: pop 0x080484cb <main+183>: pop 0x080484cc <main+184>: pop 0x080484cd <main+185>: pop 0x080484ce <main+186>: lea 0x080484d1 <main+189>: ret End of assembler dump. (gdb) $0x10,%esp $0x0,%eax 0xfffffff4(%ebp),%esp %ecx %esi %edi %ebp 0xfffffffc(%ecx),%esp D'après notre connaissance du programme au vu du résultat de son execution, nous sommes en droit d'en déduire qu'il doit effectuer une vérification du mot de passe entré afin de laisser ou non l'accès, et comme de par hasard, on observe une fonction strncmp() à l adresse 0x Suivit non loin dessous d'une comparaison JNE (0x0x804849e). Ainsi, commençons par posé un Point d'arrêt juste au dessus de ce JNE, juste après la comparaison du Mot de Passe saisie, et lançons le programme. (gdb) break *0x c Breakpoint 1 at 0x804849c (gdb) run Starting program: /root/a.out Password : Magicien Breakpoint 1, 0x c in main () (gdb) Ayant saisie "Magicien" comme Mot de Passe, le programme si l'on continue son execution va nous afficher "ACCESS DENIED!!". De manière logique il va donc nous falloir modifier le bon déroulement du programme afin de le faire sauter sur la partie du code qui nous intérésse, pour pouvoir afficher "ACCES GRANTED!!". Essayons de sauter sur la ligne juste après JNE (Jump if Not Equal). (gdb) jump *main+140 Continuing at 0x80484a0. ACCESS GRANTED!! Program exited normally. (gdb) Comme nous l'avions prédit, le programme nous a afficher le bon message, et ce, sans avoir eu à modifier une quelconque ligne de code du programme. [+] Outrepasser ptrace() En premier lieu, qu'est-ce que ptrace()? ptrace() est un vulgaire Syscall (Appel Système) sous Linux permettant de débuguer un processus (Modification de sa Mémoire, Modification de ses Registres...). IL s'agit d'un simple appel système donc, mais qui permet, si il est instauré dans un programme, d'agir en tant que système de détection d'analyse et peut

8 permettre à des programmes de protéger leur code contre toute attaque ou analyse dynamique. Voici donc le code source qui va être utilisé. Sophocle~# cat test.c #include <stdio.h> #include <sys/ptrace.h> int main(){ if(ptrace(ptrace_traceme, 0, 1, 0) < 0){ printf("\ndebuging Detected...\n"); else{ printf("\naccess GRANTED!!\n"); return 0; Sophocle~# Comme on peut le voir, le programme s exécutera normalement en temps normal, mais quittera soudainement si l'on tente de le debuguer. Essayons pour comprendre... Sophocle~# a.out ACCESS GRANTED!! Sophocle~# gdb a.out GNU gdb 6.6 Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-slackware-linux"... Using host libthread_db library "/lib/libthread_db.so.1". (gdb) run Starting program: /root/a.out Debuging Detected... Program exited normally. (gdb) Tout comme nous l'avions prédit. Il va donc falloir trouver un moyen de contourner cette restriction à l'analyse. Utilisons nos prérequis, et tentons une autre approche... Sophocle~# objdump -d a.out a.out: file format elf32-i386 Disassembly of section.init: c <_init>: c: 55 push %ebp d: 89 e5 mov %esp,%ebp f: 83 ec 08 sub $0x8,%esp : e8 8d call <call_gmon_start> [...] <main>: : 8d 4c lea 0x4(%esp),%ecx

9 : 83 e4 f0 and $0xfffffff0,%esp b: ff 71 fc pushl -0x4(%ecx) e: 55 push %ebp f: 89 e5 mov %esp,%ebp 80483a1: 51 push %ecx 80483a2: 83 ec 04 sub $0x4,%esp 80483a5: 6a 00 push $0x a7: 6a 01 push $0x a9: 6a 00 push $0x ab: 6a 00 push $0x ad: e8 02 ff ff ff call 80482b b2: 83 c4 10 add $0x10,%esp 80483b5: 85 c0 test %eax,%eax 80483b7: jns 80483cb <main+0x37> 80483b9: 83 ec 0c sub $0xc,%esp 80483bc: 68 c push $0x80484c c1: e8 0e ff ff ff call 80482d c6: 83 c4 10 add $0x10,%esp 80483c9: eb 10 jmp 80483db <main+0x47> 80483cb: 83 ec 0c sub $0xc,%esp 80483ce: 68 de push $0x80484de 80483d3: e8 fc fe ff ff call 80482d d8: 83 c4 10 add $0x10,%esp 80483db: b mov $0x0,%eax 80483e0: 8b 4d fc mov -0x4(%ebp),%ecx 80483e3: c9 leave 80483e4: 8d 61 fc lea -0x4(%ecx),%esp 80483e7: c3 ret 80483e8: 90 nop [...] Comme on peut le remarquer à l adresse 0x080483ad, il y a un appel à la fonction ptrace(), il va donc nous falloir supprimer ou contourner cet appel système afin de pouvoir lancer le programme normalement dans un Debugueur. Modifier le programme de tel sorte qu'il saute sur le bon message même si il est en cour d'analyse. Ouvrons-le avec hexedit, et modifions le JNS en JMP afin de le forcer à sauter. Pour ce faire, il suffit de modifier la valeur 7912 de ce JNS, en EB12. On referme, et on exécute avec GDB pour vérifier. Sophocle~# hexedit a.out Sophocle~# a.out ACCESS GRANTED!! Sophocle~# gdb a.out GNU gdb 6.6 Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-slackware-linux"... Using host libthread_db library "/lib/libthread_db.so.1". (gdb) run Starting program: /root/a.out ACCESS GRANTED!!

10 Program exited normally. (gdb)quit Tout fonctionne à merveille, le programme s exécute normalement même lorsque nous le lançons avec un Debugueur, on peut donc considérer ptrace comme ayant été outrepasser. [+] Exploiter un Stack Overflow Dorénavant, nous allons utiliser nos connaissances et notre savoir-faire afin de trouver et d'exploiter une faille de type Stack Overflow. Sommairement, il s'agit d'un débordement de mémoire se produisant dans la Stack (La Pile). Voici donc un programme vulnérable à cette faille pour la démonstration. Sophocle~# cat test.c #include <stdio.h> #include <string.h> void Fonction(){ printf("\nstack Overflow exploited!!\n"); void Auth(char * argv){ char Buffer[10]; strcpy(buffer, argv); int main(int argc, char * argv[]){ if(argc > 1){ printf("cherche la Faille!!\n"); Auth(argv[1]); else{ printf("usage : auth <password>\n"); return 0; Sophocle~# Dans ce programme, le fonctionnement est très simple, on rentre un mot de passe, et ce dernier insère notre mot de passe dans un buffer d'espace 10 octet (Un caractère = 1 octet). Le problème ici est simple, que se passe t'il si je rentre un mot de passe de plus de 10 caractères? Essayons pour voir. Sophocle~# a.out Usage : auth <password> Sophocle~# a.out Sophocle Cherche la Faille!! Sophocle~# a.out Cherche la Faille!! Segmentation fault Sophocle~# Comme nous pouvons le constater, il se produit un Overflow au bout de 10 caractères. En fait, en C le caractère final est toujours "\0", et spécifie une fin de chaine, et c'est pour cette raison que dans cet exemple la chaine maximum

11 accordé à l'utilisateur aura une longueur de 9, et non de 10. Bien, cherchons donc un moyen d'exploiter tout ceci. Ouvrons-le avec GDB, et lançons une analyse sur ce programme. Commençons par saisir un mot de passe de 25 caractères, et voyons ce qu'il se produit. Sophocle~# gdb a.out GNU gdb 6.6 Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-slackware-linux"... Using host libthread_db library "/lib/libthread_db.so.1". (gdb) run aaaaaaaaaaaaaaaaaaaaaaaaa Starting program: /root/a.out aaaaaaaaaaaaaaaaaaaaaaaaa Cherche la Faille!! Program received signal SIGSEGV, Segmentation fault. 0x in?? () Très intéressant, nous avons complètement réécrit EIP (Extended Instruction Pointer). EIP est en fait un registre sur les plateformes Intelx86, qui permet d'enregistrer l adresse de la prochaine instruction à exécuter, ici on réécrit cette adresse avec des 61, sachant que 0x61 est la valeur hexadécimale du caractère "a", on peut donc en déduire qu'il nous est possible via l'exploitation de cette vulnérabilité, de rediriger totalement le flux du programme pour lui faire faire des choses qu'il n'est pas censé faire en temps normal, comme exécuter un Shell par exemple. Pour cette vulgaire démonstration et explication, on va se contenter d exécuter la fonction Fonction(), vu plus haut dans le code source. Mais au préalable encore nous faut-il savoir combien de caractères il est nécessaire de rentrer pour réécrire complètement EIP. (gdb) run aaaaaaaaaaaaaaa The program being debugged has been started already. Start it from the beginning? (y or n) y Starting program: /root/a.out aaaaaaaaaaaaaaa Cherche la Faille!! Program received signal SIGSEGV, Segmentation fault. 0x in?? () (gdb) Après quelques recherches, on s aperçoit que 15 caractères permettent d'écrire sur le dernier octet de EIP. Donc, de manière tout à fait logique, 18 caractères vont nous permettre de réécrire complètement EIP. Maintenant on recherche l adresse de la fonction Fonction() via gdb. (gdb) disass Fonction Dump of assembler code for function Fonction: 0x <Fonction+0>: push %ebp 0x <Fonction+1>: mov %esp,%ebp 0x <Fonction+3>: sub $0x8,%esp 0x a <Fonction+6>: sub $0xc,%esp 0x d <Fonction+9>: push $0x

12 0x080483a2 <Fonction+14>: call 0x80482d4 0x080483a7 <Fonction+19>: add $0x10,%esp 0x080483aa <Fonction+22>: leave 0x080483ab <Fonction+23>: ret End of assembler dump. On voit que l adresse de début de la fonction se trouve en 0x , par conséquent, il nous suffit d'écrit 14 "a", et enfin nos 4 derniers octet qui vont remplir EIP par l adresse de la fonction : Fonction()!! Voyons cela plus en détails en testant notre principe. (gdb) run `python -c 'print "aaaaaaaaaaaaaa\x94\x83\x04\x08"'` Starting program: /root/a.out `python -c 'print "aaaaaaaaaaaaaa\x94\x83\x04\x08"'` Cherche la Faille!! Stack Overflow exploited!! Program received signal SIGSEGV, Segmentation fault. 0xbfc9a500 in?? () (gdb) Et voila un beau Stack Overflow mis à mal. Pour l'instant nous n'avons qu exécuter une fonction interne au programme qui n'était pas censé s exécuter en temps normal, mais en retrouvant l adresse du Buffer, il est à tout a fait possible d'injecter du code permettant l exécution d'un Shell sous les droits du Programmes. [+] Hoocking avec LD_PRELOAD LD_PRELOAD, un mot inconnu lorsque l'on a touché à Linux que de trop loin. C'est en vérité une vulgaire variable d'environnement, tout comme %SYSTEMROOT% ou %PROGRAMFILES% sous Windows. Cette variable permet de spécifier au système quelle bibliothèque partagée sera chargée avec un programme lors de son exécution. Une fois la valeur de cette variable définie, l'éditeur de liens se chargera de charger notre bibliothèque avant toute les autres. L'utilité de tout ça? Sachez avant tout que si l'on charge une bibliothèque de fonction en plus dans la mémoire d'un programme, et que si nous écrivons, par exemple, des fonctions portant exactement le même nom que des fonctions ayant été appelé par un programme, ce même programme que nous avons lancé juste après avoir définit LD_PRELOAD, ce sont nos fonctions à nous qui vont être exécute. Ce genre de pratique porte un nom : Le Hoocking. Autrement dit, créer une fonction maison portant le nom d'une fonction normalement inclus dans les librairies du système, et ordinairement appelé par un programme sur ce même système, et que nous préchargeons nos fonctions avant toutes les autres lors d'une exécution, ce sont nos fonctions qui auront "priorités" pour s exécuter. Pour commencer, voici un programme de démonstration qui va simplement afficher l'id utilisateur lors de son exécution. Sophocle~# cat getuid.c #include <stdio.h> #include <unistd.h>

13 int main(){ int i = getuid(); printf("(uid)=%i\n", i); return 0; Vérifions à présent afin de comprendre un peu mieux tout cela... Sophocle~# gcc getuid.c Sophocle~# a.out (uid)=0 Sophocle~# id uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy) Le programme "id" inclus dans le système nours permet de vérifier que notre programme fonctionne bien, étant donné que je suis bien "root" au moment ou j'écris ces lignes. Mais allons plus loin, je vais maintenant créer un nouvel utilisateur sur le système, me loguer sous cet utilisateur, et regarder l'uid qui m'as été attribué par le système. Après cela, nous allons commencer notre travail de contournement de fonction système. Sophocle~# adduser Magicien - User 'Magicien' contains illegal characters (uppercase); please choose another Login name for new user []: magicien User ID ('UID') [ defaults to next available ]: 951 Initial group [ users ]: Additional groups (comma separated) []: Home directory [ /home/magicien ] Shell [ /bin/bash ] Expiry date (YYYY-MM-DD) []: New account will be created as follows: Login name...: magicien UID...: 951 Initial group...: users Additional groups: [ None ] Home directory...: /home/magicien Shell...: /bin/bash Expiry date...: [ Never ] This is it... if you want to bail out, hit Control-C. Otherwise, press ENTER to go ahead and make the account.

14 Creating new account... Changing the user information for magicien Enter the new value, or press ENTER for the default Full Name []: Magicien Room Number []: Work Phone []: Home Phone []: Other []: Changing password for magicien Enter the new password (minimum of 5, maximum of 127 characters) Please use a combination of upper and lower case letters and numbers. New password: Bad password: too short. Warning: weak password (enter it again to use it anyway). New password: Re-enter new password: Password changed. Account setup complete. Sophocle~# su magicien Sophocle root $ id uid=951(magicien) gid=100(users) groups=100(users) Sophocle root $ A présent, nous allons écrire une librairie et définir LD_PRELOAD avec cette nouvelle librairie. Le but sera de faire afficher au programme "id" du système ainsi qu'à notre programme écrit plus haut, la valeur '0', qui je le rappel, est la valeur uid de root. Sophocle~# cat lib.c #include <stdio.h> int getuid(){ return 0; int geteuid(){ return 0; int getgid(){ return 0; Sophocle~# Sophocle~# gcc -shared lib.c -o falseid.so Une fois écrit et compilé, il ne nous reste plus qu'à charger notre nouvelle bibliothèque dans LD_PRELOAD, et de vérifier si tout à bien fonctionner comme nous le voulions. Au passage, je viens d'écrire 3 fonctions, observez bien cidessous le résultat de "id" et vous comprendrez je pense, également, il est à noter que nous avons réécrit une fonction existante, existante étant donné que nous l'avons utilisé plus haut pour notre programme getuid.

15 Sophocle~# su magicien Sophocle root $ pwd /root Sophocle root $ id uid=951(magicien) gid=100(users) groups=100(users) Sophocle root $ export LD_PRELOAD=/root/falseid.so Sophocle root $ id uid=0(root) gid=0(root) egid=100(users) groups=100(users) Sophocle root $ /root/a.out (id)=0 Sophocle root $ exit Comme nous avons pu le constater, notre détournement de fonction getuid() fonctionne à merveille. Pour cette exemple, je n'ai fait que mettre en avant le principe final, mais sachez que nous pouvons faire bien plus que déconcerter des fonctions d'affichage d'uid ou de gid en les reprogrammant indirectement. Nous pouvons par exemple, reprogrammer complètement une fonction pour lui faire afficher un Shell, copier le fichier /etc/shadow (/etc/passwd ne contient pas réellement les mot de passe), et bien plus encore. En y repensant, on aurait même pû reprogrammer ptrace() afin qu'il retourne toujours 0, ce qui aurait eu pour effet d'annuler l'action réel de la fonction dans l explication détaillé plus haut. Dans le Hacking et la Sécurité Informatique, il n'y a que l'imagination qui peut réellement stopper l'action de l'utilisateur. Pour finir, il est bon à savoir que pour remettre LD_PRELOAD par défaut (Vider son contenue), il suffit simplement de taper LD_PRELOAD="" dans le Shell après avoir effectuer les actions souhaitées. Sophocle root $ LD_PRELOAD="" Sophocle root $ id uid=951(magicien) gid=100(users) groups=100(users) Sophocle root $ [+] Contourner le Stripping Le stripping est une technique permettant de détruire la table des symboles sous Unix. Autrement dit, cela permet d'altérer la majeur partie des symboles d'un programme afin que l'on ne puisse plus y lire certaines portions de code directement, via GDB par exemple. L outil permettant d'effectuer un tel action sous Linux est strip. Voici un programme de démonstration. Sophocle~# kedit prog.c Sophocle~# gcc prog.c Sophocle~# objdump -d a.out a.out: file format elf32-i386 Disassembly of section.init: <_init>: : 55 push %ebp : 89 e5 mov %esp,%ebp : 83 ec 08 sub $0x8,%esp a: e call 80482d4 <call_gmon_start> f: e8 cc call <frame_dummy> : e8 c call

16 < do_global_ctors_aux> : c9 leave a: c3 ret Disassembly of section.plt: [...] <main>: : 8d 4c lea 0x4(%esp),%ecx : 83 e4 f0 and $0xfffffff0,%esp b: ff 71 fc pushl -0x4(%ecx) e: 55 push %ebp f: 89 e5 mov %esp,%ebp : 51 push %ecx : 83 ec 04 sub $0x4,%esp : 89 4d f8 mov %ecx,-0x8(%ebp) : 8b 45 f8 mov -0x8(%ebp),%eax b: cmpl $0x1,(%eax) [...] Comme nous pouvons le constater, tout est tout à fait normal. Maintenant nous allons stripper ce programme et observer les modifications éventuels. Sophocle~# strip a.out Sophocle~# objdump -d a.out a.out: file format elf32-i386 Disassembly of section.init: <.init>: : 55 push %ebp : 89 e5 mov %esp,%ebp : 83 ec 08 sub $0x8,%esp a: e [...] b0 <.text>: 80482b0: 31 ed xor %ebp,%ebp 80482b2: 5e pop %esi 80482b3: 89 e1 mov %esp,%ecx 80482b5: 83 e4 f0 and $0xfffffff0,%esp 80482b8: 50 push %eax 80482b9: 54 push %esp 80482ba: 52 push %edx 80482bb: 68 b push $0x80483b c0: 68 c push $0x80483c c5: 51 push %ecx 80482c6: 56 push %esi 80482c7: push $0x cc: e8 bb ff ff ff call c < libc_start_main@plt> 80482d1: f4 hlt 80482d2: 90 nop [...] Comme je l'avais stipulé au départ, plus aucun symbole n'est présent. Vous allez me dire, mais en quoi cela est-il bien gênant? Voyons cela de plus près, vous comprendrez mieux. Établissons une petite analyse succincte avec GDB.

17 Sophocle~# gdb a.out GNU gdb 6.6 Copyright (C) 2006 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions. There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i486-slackware-linux"... (no debugging symbols found) Using host libthread_db library "/lib/libthread_db.so.1". (gdb) disass main No symbol table is loaded. Use the "file" command. (gdb) Et oui, comme je vous l'avez dit. Plutôt ennuyeux lorsque l'on a un programme de plusieurs centaines de Kilo à analyser en profondeur. Il existe tout de même un outils capable de remettre en place la Table des Symboles, il se nomme Fenris. Mais voyons comment il est possible de se débrouiller sans Table des Symboles. Voici donc un morceau du code ASM de la section.text ( Code du Programme). Disassembly of section.text: b0 <.text>: 80482b0: 31 ed xor %ebp,%ebp 80482b2: 5e pop %esi 80482b3: 89 e1 mov %esp,%ecx 80482b5: 83 e4 f0 and $0xfffffff0,%esp 80482b8: 50 push %eax 80482b9: 54 push %esp 80482ba: 52 push %edx 80482bb: 68 b push $0x80483b c0: 68 c push $0x80483c c5: 51 push %ecx 80482c6: 56 push %esi 80482c7: push $0x cc: e8 bb ff ff ff call c < libc_start_main@plt> 80482d1: f4 hlt 80482d2: 90 nop 80482d3: 90 nop 80482d4: 55 push %ebp 80482d5: 89 e5 mov %esp,%ebp 80482d7: 53 push %ebx 80482d8: 83 ec 04 sub $0x4,%esp 80482db: e call 80482e0 <puts@plt+0x44> 80482e0: 5b pop %ebx 80482e1: 81 c3 a add $0x12a4,%ebx 80482e7: 8b 93 fc ff ff ff mov -0x4(%ebx),%edx 80482ed: 85 d2 test %edx,%edx 80482ef: je 80482f6 <puts@plt+0x5a> 80482f1: e8 86 ff ff ff call c < 80482f6: 58 pop %eax 80482f7: 5b pop %ebx 80482f8: c9 leave 80482f9: c3 ret 80482fa: 90 nop 80482fb: 90 nop 80482fc: 90 nop 80482fd: 90 nop 80482fe: 90 nop

18 80482ff: 90 nop : 55 push %ebp : 89 e5 mov %esp,%ebp : 83 ec 08 sub $0x8,%esp : 80 3d a cmpb $0x0,0x80495a d: 74 0c je b f: eb 1c jmp d : 83 c0 04 add $0x4,%eax : a3 a mov %eax,0x80495a : ff d2 call *%edx b: a1 a mov 0x80495a4,%eax : 8b 10 mov (%eax),%edx : 85 d2 test %edx,%edx : 75 eb jne : c6 05 a movb $0x1,0x80495a d: c9 leave e: c3 ret f: 90 nop : 55 push %ebp : 89 e5 mov %esp,%ebp : 83 ec 08 sub $0x8,%esp : a1 b mov 0x804 [...] On observe très facilement qu'à chaque fois des NOP apparaissent très clairement, cela est en fait la coupure entre chaque section. Cela nous permet déjà de connaitre le nombre de section, et donc de savoir combien de lignes il faudra analyser lorsque nous aurons trouvé main(). Une autre chose à savoir plutôt intéressante est qu'il est vraiment très très rare que nous puissions trouver des références de fonctions de type < ou encore < Dans une fonction aucune indication n'apparait, si un appel de fonction est présent il se fera comme d'habitude à savoir quelque chose du type autrement dit directement le nom de la fonction. [+] Obfuscation de Code en C L'obfuscation de Code est une technique permettant de rendre difficile la lecture direct d'un code source écrit en C, ou dans d'autres langages. Le but est de jouer avec les directives du préprocesseur, autrement dit avec les "balises" #define. Voici un exemple d'un code obfusquer. Sophocle~# cat obfusc.c #include <stdio.h> #define A int #define B main #define C printf #define D return #define Z "Bonjour Sophocle...\n" A B(){ C(Z); D 0; Sophocle~# gcc obfusc.c Sophocle~# a.out Bonjour Sophocle... Sophocle~#

19 Comme vous pouvez l'observer de vous-même, cela est vraiment un jeux d'enfant à mettre en œuvre, et l'utilité est nul d'un point de vue sécurité binaire du fait que le code du programme sera exécuté de la même manière, et sera structuré tout autant de cette même manière. Le but est surtout de rendre en partie illisible ou incompréhensible des programmes écrient dans des langages décompilation tel que Java. En effet, pour un programme de quelques lignes, cela est très rapide de réécrire le code manuellement, ou encore de le comprendre aisément, mais pour des programmes ayant quelques centaines de lignes de codes, cela devient légèrement plus ardu.