Devo sempre sovrascrivere EIP per arrivare a scrivere sullo stack in un buffer overflow?

Non è sempre necessario sovrascrivere l'indirizzo di ritorno per sfruttare un overflow del buffer basato sullo stack (inoltre un grande diagramma del layout dello stack). Con un overflow del buffer basato sullo stack è possibile corrompere altre variabili dichiarate nell'ambito locale della funzione che possono produrre risultati interessanti.

Ad esempio, diciamo che esiste una funzione di autenticazione:

//I like to think of the return address as sitting on top of every function.
//void * ret;
boolean login(char * password){
  boolean is_logged_in=False;
  char buf[5];
  strcpy(buf,password);
  if(strmp(buf, MASTER_PASSWORD)==0){
     is_Logged_int=True;
  }
  return is_logged_in;
}

Il layout dello stack è tale che is_logged_in è sopra il buf. Il frame dello stack, che contiene l'indirizzo di ritorno è da qualche parte sopra is_logged_in . L'indirizzo di ritorno diventerà EIP solo quando la funzione ritorna. Ma non è necessario che l'attaccante corrompa il frame dello stack in modo che l'attacker possa trarre vantaggio da questo overflow del buffer. Semplicemente sovrascrivendo il valore di is_logged_in con un valore uguale a True consentirà all'autore dell'attacco di autenticarsi senza conoscere il valore di MASTER_PASSWORD .

In questa vulnerabilità di overflow del buffer, l'uso di: ASLR, NX Zone e Stack Canarie non impedisce lo sfruttamento. In effetti è anche probabile che lo stesso esatto exploit funzioni indipendentemente dalla piattaforma (windows / linux / arm / x86 ...).

(Disclaimer: Penso di aver letto su questo metodo di sfruttamento in "Hacking: The Art of Exploitation")

È il contrario: si riversa un buffer di stack in modo che si riesca a sovrascrivere il campo con il quale verrà caricato EIP quando la funzione ritorna.

Nelle solite architetture, lo stack cresce verso il basso, in modo che l'"indirizzo di ritorno" inserito nello stack quando la funzione è stata chiamata giace qualche byte dopo le variabili locali. Sovrapponendo un buffer locale, si arriva a sovrascrivere ciò che si trova dopo nella RAM, cioè l'indirizzo di ritorno. Quando la funzione ritorna, il corrispondente ret opcode carica l'indirizzo di ritorno in EIP, il che significa che l'esecuzione salta a quell'indirizzo.