Buenas noches a todos, compañeros.
Primero que todo, soy nuevo en el foro en calidad de usuario, generalmente vengo en calidad de invitado, espero poder sacar conocimiento de acá y poder aportar en mayor medida en todo aquello que tenga al alcance.
El día de hoy me encuentro acá porque entre tanto investigar no encuentro al respuesta a un problema que tengo. Pasa que estoy iniciandome en todo lo que vendría a ser la programación en C, y pues... Estoy buscando entender las vulnerabilidades en los programas en C, ahorita me encuentro estudiando el buffer overflow, y para practicarlo intento hacer un programa vulnerable.
Bueno, primero que todo, este es mi codigo:

#include <stdio.h>
#include <string.h>
int main (int argc, char *argv[])
{
char buffer[2];
scanf("%s",&buffer);
printf("Tamaño a rebosar: %i\nTamaño de la entrada: %i\n",sizeof buffer,strlen(buffer));
return 0;
}

Ahora, mi problema es que según mi teoría, si yo asigno un tamaño n a una variable y quiero escribir sobre dicha variable, la variable no puede ser mayor al buffer porque empieza a escribir aquello que sobra en una zona de la memoria aledaña a ella. Pero a mi no me pasa.
Quiero decir, en el codigo anterior se puede observar que si mi objetivo es lograr una sobrecarga al buffer solo nesecito meter un caracter -tomando en cuenta que el segundo char vendría siendo el típico "\0"-, pero yo puedo insertar un caracter, dos, tres, y no es sino hasta el sexto caracter que me salta el overflow. Luego de tocar el programa varias veces me he dado cuenta de que el tamaño que asigne a la variable no devuelve un aviso de sobrecarga sino hasta que se rebasan cuatro caracteres mas de lo que le he asignado al programa. Así pues, si tengo una variable "char n[1]" no muestra sobrecarga sino hasta que ingreso 1+4 caracteres, lo mismo si asigno 2, 3, 4 y basicamente con cualquier número que inserte me sigue el error.
He probado tambien haciendo un strcpy del argv al buffer y no me da resultado, de todas formas sigue manteniendose el fallo.

---------------------------------------------------------------------------
----------------------------- Actualización -----------------------------
---------------------------------------------------------------------------

Por cierto, para experimentar y analizar la variable cree un codigo que vendría siendo este:

#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
char buffer[1];
scanf("%s",buffer);
//printf("%s\n",buffer);
printf("%s\n%i\n%i\n%p\n%p\n",buffer,sizeof buffer,strlen(buffer),&buffer,*buffer);
return 0;
}
 

Y considero que es un misterio, este codigo que he puesto si que funciona como espero -apenas escribo un caracter de mas sobrecarga el buffer-, pero solo es así mientras tengo esa ultima salida activa, puesto que cuando comento la linea que contiene la salida con los datos del buffer, me vuelve a lo del caso anterior en el que me saltaba overflow al n+4 caracter y no entiendo.
Como extra, llegué a creer tambien que era problema en la salida de datos -lo llegué a creer por lo expuesto en el anterior parrafo- pero lo descarté puesto de que incluso suprimiendo la salida de datos me sigue con el fallo que comento.
Disculpen las molestias, agradezco cualquier respuesta constructiva.
Sin mas que decir, un saludo, exitos y paz.

El segmentation fault salta cuando el Sistema Operativo lo detecta y así ocurre. Digo esto, porque es posible que, si bien la memoria no pertenece a esa variable, pertenezca igualmente a tu programa. Luego, están los mecanismos que use el SO para detectar este problema, de los cuales no tengo información.

Por ejemplo, a mi ese programa me tira la violación de acceso al salir del buffer por 13 bytes, mientras que por 12 bytes no tira error.

Si quieres aprender más busca sobre el modelo de memoria de un programa [ http://www.geeksforgeeks.org/memory-layout-of-c-program ] y sobre convención de llamadas [ https://en.wikipedia.org/wiki/X86_calling_conventions ].