¿Cómo rebosar la pila sin empujar nuevos marcos de pila?

Question

Una forma obvia de causar un desbordamiento de la pila y obtener Segmentation fault sería empujar recursivamente los marcos de la pila uno encima del otro hasta que se expanda. Me pregunto si el desbordamiento de pila podría ocurrir sin siquiera empujar nuevos marcos de pila.

Crear una matriz lo suficientemente grande podría hacerlo también por experiencia, ¿pero en cualquier otro escenario posible?

Answer 1

C99 usa una matriz de tamaño variable, que puede usar y seguir cambiando el tamaño de una matriz más grande. Sin embargo, esta matriz redimensionable se implementa utilizando alloca. He aquí un ejemplo de código en 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); 
} 

y su salida se verá así

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 está en el malloc familia de funciones, salvo que la memoria asignada a la pila mediante el ajuste el puntero de pila

Answer 2

Abuso alloca() o _alloca() si está desarrollando en Windows SDK/VS:

La función alloca() asigna size bytes de espacio en el marco de la pila de la persona que llama .

Nota _alloca() ahora está en desuso en favor de _malloca().

Answer 3

Fundamentalmente, la "pila" es solo algo de memoria, y un desbordamiento de pila ocurre cuando ESP/EBP salen de los límites de esta memoria.

Esto se puede hacer de varias maneras:

1. Crear una enorme variedad de pila asignado que es más grande que el tamaño del espacio de pila restante: int x[10000000];
2. Establecer ESP directamente: __asm mov esp, 0x0
3. Corromper la pila para que cuando se desenrolle la función actual, ESP/EBP se configure como basura: int x; memset(&x, 0, 10000000);

Y coun tless otras maneras ...

Answer 4

declarando y utilizando una matriz más grande que el tamaño de la pila:

$ ulimit -s 
8192 
$ 

continuación

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

es probable que segfault cuando se ejecuta.