Come sovradimensionare lo stack senza spingere nuovi frame dello stack?

Question

Un modo ovvio per causare un overflow dello stack e ottenere Segmentation fault è quello di spingere in modo ricorsivo i frame dello stack uno sopra l'altro fino a quando non si gonfia. Mi chiedo se l'overflow dello stack potrebbe accadere senza nemmeno spingere nuovi frame dello stack.

La creazione di un array abbastanza grande potrebbe farlo anche dall'esperienza, ma con qualsiasi altro possibile scenario?

Answer 1

C99 utilizza un array ridimensionabile, che è possibile utilizzare e continuare a ridimensionarlo in uno più grande. Tuttavia questo array ridimensionabile è implementato usando alloca. Ecco un codice di esempio in UNIX ENV:

#include <stdio.h> 
#include <alloca.h> 
#include <stdlib.h> 
#include <stdbool.h> 

int 
main() 
{ 
    while (true) 
    { 
     void *p = alloca(32UL); 
     printf("new memory allocated at %p \n", p); 
    } 
    exit(EXIT_SUCCESS); 
} 

E il vostro output sarà simile a questa

new memory allocated at 0xbf800a60 
new memory allocated at 0xbf800a30 
new memory allocated at 0xbf800a00 
new memory allocated at 0xbf8009d0 
new memory allocated at 0xbf8009a0 
[1] 3977 segmentation fault ./a.out 

alloca è nel malloc famiglia di funzioni, tranne che allocata memoria sullo stack regolando il puntatore dello stack.

Answer 2

abusi alloca() o _alloca() Se si sta sviluppando su Windows SDK/VS:

La funzione alloca() alloca byte dimensione dello spazio nella stack frame del chiamante.

Nota _alloca() è ora obsoleto a favore di _malloca().

Answer 3

Fondamentalmente lo "stack" è solo un po 'di memoria e un overflow dello stack si verifica quando ESP/EBP esce dai limiti di questa memoria.

È possibile raggiungere questo obiettivo in diversi modi:

1. creare una grande pila di allineamenti-allocato che è più grande rispetto alle dimensioni del rimanente spazio di stack: int x[10000000];
2. Set ESP direttamente: __asm mov esp, 0x0
3. Correggere la pila in modo che quando la funzione corrente si srotola, ESP/EBP verrà impostato su spazzatura: int x; memset(&x, 0, 10000000);

E tless altri modi ...

Answer 4

dichiarando e utilizzando una matrice più grande la dimensione dello stack:

$ ulimit -s 
8192 
$ 

poi

int main(void) 
{ 
    volatile char bla[8192 * 1024 + 16] = {0}; 
} 

rischia di segfault quando eseguito.