flujo de control (desbordamiento de búfer) (pregunta introductoria)

Question

flujo de control (desbordamiento de búfer) (pregunta introductoria)

#1 de SYS_V (1 votos)

2

Estoy viendo el siguiente código y estoy tratando de averiguar cómo este error sería útil para algo como lanzar un shell.

int func(int i, double *data1, double data2) 
{

double  *p = data1;       
double  *vec[10];

if ((i<0) || (i>10)) return;   

vec[i] = data1; 
*p = data2;     

}

Hay una respuesta en el pdf vinculado a continuación ( Send i = 10 and data1 = RetAddr ) pero estoy buscando una explicación más detallada.

La pregunta proviene de la clase CS 155 de Dan Boneh y es la número 3 aquí:

enlace

buffer-overflow

pregunta Nathan Reitinger 07.12.2017 - 21:04

fuente

1 respuesta

Lea otras preguntas en las etiquetas buffer-overflow

Nessus scan informa de una vulnerabilidad de Dropbear en una máquina que no tiene instalado Dropbear Método compatible con PCI DSS para recibir datos de la tarjeta para un comerciante sin almacenamiento electrónico

score 1 · Accepted Answer

La respuesta corta es que el índice 10 está más allá de los límites de la matriz vec y escribir un doble de 8 bytes en vec[10] podría sobrescribir el puntero base de la función anterior y la dirección de retorno de la función, dependiendo de cómo el compilador asigne memoria en la pila para variables locales.

Aquí hay un diagrama de la pila de tiempo de ejecución cuando se ha llamado func (se supone arquitectura x86):

 <------------ 4 bytes ----------->
                 .
                 .
                 .
 +---------------------------------+
 |             data2               |
 +---------------------------------+  arg 3 (8 bytes)
 |             data2               |
 +---------------------------------+  
 |             data1               |
 +---------------------------------+  arg 2 (8 bytes)
 |             data1               |
 +---------------------------------+
 |               i                 |  arg 1 
 +---------------------------------+
 |         return address          |                 < 8 bytes to      <--\
 +---------------------------------+                 < be overwritten      |
 | previous ebp (old base pointer) |  <-- "vec[10]"  < by data1            |
 +---------------------------------+                                       |  stack
 |             vec[9]              |                                       |  frame
 +---------------------------------+                                       |  for
 |             vec[8]              |                                       |  "func"
 +---------------------------------+                                       |
                 .                                                         |
                 .                                                         |
                 .                                                         |
 +---------------------------------+                                       |
 |             vec[1]              |                                       |
 +---------------------------------+                                       |
 |             vec[0]              |                                   <--/
 +---------------------------------+

Tenga en cuenta que el compilador determina la disposición de la memoria asignada para las variables locales en un marco de pila. Esto significa que la alineación de la pila puede dar como resultado un "espacio de holgura" que elimina el cálculo del desplazamiento del búfer, por ejemplo. Además, si el compilador asigna memoria para la variable p entre ebp guardada y la memoria asignada para la matriz vec , p se sobrescribirá en lugar de la antigua ebp y la dirección de retorno de func .

Para obtener más información sobre el diseño del marco de pila, consulte: