comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

# How to exploit: Comienzos..

  • 10 Respuestas
  • 3955 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado cnfs

  • *
  • Underc0der
  • Mensajes: 103
  • Actividad:
    0%
  • Reputación 3
    • Ver Perfil
    • shad0whack
    • Email
  • Twitter: https://twitter.com/cmind33
« en: Enero 16, 2015, 07:43:22 pm »
Buenas antes que nada, queria aclarar que estos 3 papers que puse todo en uno son papers de autoria propia y enfocados a exploiting desde un entorno Linux, da igual para Windows a excepción de algunas herramientas obviamente.

Tengo usuario aca hace mucho tiempo y solo entro a leer pero decidi aportar esto que lo escribi hace un tiempo sinceramente pero debe tener el mismo valor de conocimientos que en su momento.. seguramente siga con el 4to paper en mis ratos libres para escribir, espero que sea de utilidad.

Son 3 posteos en 1 solo, ya que fui sacando por partes, es una introduccion a gdb desde linux.. una base para ir escalando y meternos en el exploiting. Es bueno ser autodidacta y sino entienden algo no quedarse con respuestas de un solo lugar, sino usar google e ir por mil lugares buscandolas.




#How to Exploit.
Me enfocare desde mi entorno Linux, pero es viable para Windows también, salvo excepciones de algunas herramientas, la esencia es la misma.

¿Requisitos?.
Simplemente tener conocimientos basicos de programación.. compiladores, arquitectura, todo lo que nos rodea y usamos habitualmente, y en otros casos lo usamos pero no tenemos idea que lo hacemos.. Un requisito mas podria ser el saber y querer entender 'el porque de las cosas', no tirar un exploit a lo scriptkiddie. De todas maneras intentare enfocarme y detallar lo maximo que pueda. Para el resto, Google. Usare muchas herramientas como GDB, Objdump, IDA, GCC, Python,etc, etc..

#Primero, lo aburrido, pero necesario para entender.
Vamos a familiarizarnos un poco con el código fuente, compilar, desensamblar, algunas herramientas que ayudan este proceso y todas esas cosas.
Para empezar tenemos preparado para esta prueba un pequeño codigo fuente  "analizaMe",
esta codeado en C, y es de lo mas básico, pero me ayudara a explicarlo de manera rápida.. asi que deberíamos compilarlo. ¿Compilar?.

Suponiendo que si llegan hasta acá, siguieron al pie los requisitos de tener conocimientos basicos de programación, assembler, etc..  no sera muy difícil entender lo que refresco por encima a continuacion. Para comprender realmente el significado de Compilar, tenemos que movernos al origen de los procesadores, pero resaltaremos lo importante, el procesador x86.
Intel desarrollo la cpu 8086 que fue el primer procesador x86.. luego creo otros mas avanzados como el 386, 486.. etc.. El procesador x86 que se refiere a los anteriormente mencionados, posee varios registros que son como las 'variables' internas para dicho procesador. Algunos de estos registros son los conocidos 'EAX,ECX,EDX,EBX', son registros usados para varios fines, entre ellos como contadores o acumuladores.. sirven como variables temporales para el procesador cuando esta ejecutando instrucciones. Hay 4 registros mas a resaltar que son 'EBP, ESP, ESI y EDI'.
Estos registros llevan el nombre de EBP puntero base, ESP puntero de pila, ESI indice de origen y EDI indice destino. El puntero EIP, es el puntero de instruccion, es quien nos ayuda y nos señala a la instruccion que el procesador esta leyendo en ese preciso momento.

Bueno, como sabrán con el código fuente no vamos a poder hacer nada, hasta el momento en el que lo compilamos y lo convertimos en un archivo ejecutable.
Let's Go!

El programa analizaMe:

Código: C
  1. #include <stdio.h>
  2. int main() {
  3.   int contar;
  4.   for(contar=0; contar < 5; contar++)
  5.   {
  6.     No tienes permisos para ver links. Registrate o Entra con tu cuenta("La variable contar vale: %i \n", contar);
  7.   }
  8. }

Bien, lo primero sera explicar un poco este código, y luego compilarlo.
Básicamente y de manera rápida, este programa lo que hace es mostrar en pantalla un mensaje y el valor de la variable 'contar'. Mientras sea la variable menor de 5 el mensaje sera mostrado via la funcion 'printf'. Cuando llega a 5, el programa finaliza. Analicémoslo mas en detalle..
(cada vez que vean $> es la manera de decirles que son comandos a tipear en la shell)

Vamos a compilarlo con GCC (es el GNU Compiler Collection), la función de los compiladores basicamente es la de convertir el código fuente en lenguaje maquina, la manera en la que entienden los procesadores.

$> gcc analizaMe.c -o analizaMe
$> chmod +x
$> ./analizaMe


Invocamos al compilador y le decimos que nos compile el codigo fuente en c. El resultado es un nuevo archivo llamado analizaMe. Le damos permisos de ejecución. Y luego lo ejecutamos..
El resultado es el siguiente:

La variable contar vale: 0
La variable contar vale: 1
La variable contar vale: 2
La variable contar vale: 3
La variable contar vale: 4

Ok, vemos el resultado del programa, pero veamos que es lo que no esta a simple vista, como es que funciona este programa realmente..

Invocamos en la shell, a ojbdump, es una gran utilidad para desensamblar facilmente binarios compilados.

$> objdump -D analizaMe -M intel |grep -A15 main.:

(Le decimos a objdump que (-D) desensamble el binario 'analizaMe', (-M intel) que nos muestre el resultado con la sintaxis Intel ya que es mas prolija y acostumbrado que la de AT&T (por default objdump nos arroja esta ultima por eso es que forzamos a que nos muestre con la de Intel)).. (grep -A15 main.:) invocamos a 'grep' y aplicamos una expresión regular para que nos muestre solo las primeras 15 lineas de la funciona principal, main.
Podríamos no limitar a 15, pero arrojaría muchas lineas innecesaria para este momento.
Y hasta acá esta primera parte de introducción..

No tienes permisos para ver links. Registrate o Entra con tu cuenta

---------------------------------------------------------------------------------------------------------------------

#How to exploit 2: Un poco de Assembler y GNU Debugger.




Traje esta segunda parte que escribí, nose si tienen sugerencias positivas o negativas, cualquiera me serviría. Saludos.

Retomando con el paper anterior, y nuestro código de ejemplo, vamos a repasar un poco sobre Assembler y GNU Debugger durante esta segunda parte. Veremos por 'encima' el tema de assembler ya que mi interés no es un tutorial de este, sino repasarlo para introducirlo con el Debugger.

Para invocar al GDB
Utilizaremos el crudo y puro gdb desde la linea de comandos con sintaxis INTEL.
Para configurar GDB con sintaxis INTEL, vamos a hacer lo siguiente:

$> sudo gedit /etc/gdb/gdbint

Y luego pegamos al final la siguiente linea y guardamos el archivo:

set disassembly-flavor intel

La sintaxis de intel nos mostrara las operaciones de esta manera en gdb:

instrucciones "[destino],[origen]"
Por ejemplo: "mov ebx, eax"

En este ejemplo el valor del registro 'eax', sera movido al registro 'ebx'.
Recordar que las operaciones del origen y destino pueden ser un valor,
una dirección de memoria, o un registro como en este caso.

Operaciones comunes que veremos en assembler para refrescar memoria:

MOV: Mueve contenido
INC: Incrementa de a 1 el valor
DEC: Resta de a 1 el valor
ADD: Suma 
SUB: Resta
CMP: Compara dos registros o un registro y dirección de memoria.
JMP/JNE etc: Todos los que empiecen con J.. son saltos condicionales e incondicionales.
Hay mas pero como dije, son los básicos y el paper no esta orientado a un manual de assembler.

 
# GDB

El debugger es una herramienta que nos permite ejecutar programas y analizarlos. Ya sea para localizar errores o entender un poco mas a fondo que es lo que hace una determinada aplicación.

GDB dispone de un comando muy particular y uno de los mas útiles a la hora de verificar la memoria.
Este comando se llama 'examine' y como su nombre indica, nos sirve para examinar la memoria.
GDB puede examinar detenidamente cada aspecto de la ejecución de un programa, ejecutarlo, detenerlo, verificar los registros, direcciones de memoria, lo que se nos ocurra.
(Lo practico de GDB también es que la mayoría de los comandos se pueden 'abreviar', por ejemplo examine se puede acortar a una simple 'x' y este se reconoce como un comando)

El comando examine, tiene varias maneras de arrojar la información que requerimos ver en una determinada dirección de memoria. Podemos especificar el formato en el que se muestra usando alguna de las siguiente abreviaturas:

x = Muestra el resultado en Hexadecimal
u = Muestra el resultado en Decimal.
o = Muestra el resultado en Octal.
t = Muestra el resultado en Binario.

Veamos un ejemplo con nuestro pequeño programa del paper anterior que adjunto nuevamente:


Código: C
  1. #include <stdio.h>
  2. int main() {
  3.   int contar;
  4.   for(contar=0; contar < 5; contar++)
  5.   {
  6.     No tienes permisos para ver links. Registrate o Entra con tu cuenta("La variable contar vale: %i \n", contar);
  7.   }
  8. }
    $> gdb -q ./analizaMe
    De esta manera le pasamos a gdb el binario a debugguear.

    (gdb) break main
    Punto de interrupción 1 at 0x804840f (en mi caso esto nos responde gdb al poner un break)

    Le decimos que genere un breakpoint en la función principal "main". Un breakpoint no hace otra cosa que poner una barrera una vez que se ejecuta el programa, le dice al gdb que cuando llegue a nuestro breakpoint el programa se parara obligatoriamente ahi en ese break. Podemos poner varios break, de momento solo haremos uno en la función main.

    (gdb) run
    Breakpoint 1, 0x0804840f in main () (esto nos responde el gdb al encontrar el break que seteamos)

    Corremos el programa desde el debugger con run o también con una simple 'r' y va a parar en el primer breakpoint que seteamos en la función "main"

    (gdb) info register

    eax            0x1    1
    ecx            0xbffff344    -1073745084
    edx            0xbffff2d4    -1073745196
    ebx            0xb7fc1000    -1208217600
    esp            0xbffff2a8    0xbffff2a8
    ebp            0xbffff2a8    0xbffff2a8
    esi            0x0    0
    edi            0x0    0
    eip            0x804840f    0x804840f <main+3>
    eflags         0x246    [ PF ZF IF ]
    cs             0x73    115
    ss             0x7b    123
    ds             0x7b    123
    es             0x7b    123
    fs             0x0    0
    gs             0x33    51

    Este comando "info register" nos permite ver el estado actual de los registros.
    Como ven obtenemos un status de todos los registros de ese preciso momento.

    (gdb) info register eip
    eip            0x804840f    0x804840f <main+3> (respuesta del gdb)

    Podemos filtrar a algún registro en particular escribiéndolo al lado como en el ejemplo 'eip'.
    Además, como les conté antes podemos 'abreviar' este comando asi: "i r eip"
    Vemos como EIP contiene el valor 0x804840f.

    (gdb) x/x $eip
    0x804840f <main+3>:    0x83f0e483 (ahora examinamos la memoria a la que esta señalando el registro EIP usando la dirección almacenada en EIP). Vemos que donde arriba EIP contenia '0x804840f', examinamos este registro y contiene lo siguiente: 0x83f0e483.

    De esa manera usamos el 'examine' abreviado con la primer 'x', luego le decimos que nos arroje la info en hexadecimal con la segunda 'x'. Y el registro 'eip'. Fíjense que en este caso hay que poner el registro luego de un $. A diferencia de el info register que no lo anteponíamos.

    También se puede anteponer un numero al formato del comando examine, para examinar varias unidades en esas direcciones objetivos que tengamos. Por ejemplo:

    (gdb) x/4x $eip
    0x804840f <main+3>:    0x83f0e483    0x44c720ec    0x00001c24    0x19eb0000

    Las unidades tienen un tamaño predeterminado de 4 bytes. Conocidas como WORD.
    De la misma manera que podemos cambiar el formato que nos arroja el resultado con 'examine' ya sea en hexadecimal, octal, binario o decimal, tambien podemos cambiar el tamaño de las unidades que estamos examinando, agregandole una letra de tamaño al final de la de formato y estos son:

    b: byte
    h: half-word (2 bytes)
    w: word (4 bytes)
    g: giant o qword (8 bytes)


    Veamos un ejemplo practico:

    1)(gdb) x/4xb $eip
    0x804840f <main+3>:    0x83    0xe4    0xf0    0x83

    2)(gdb) x/4xh $eip
    0x804840f <main+3>:    0xe483    0x83f0    0x20ec    0x44c7

    3) (gdb) x/4xw $eip
    0x804840f <main+3>:    0x83f0e483    0x44c720ec    0x00001c24    0x19eb0000

    4) (gdb) x/4xg $eip
    0x804840f <main+3>:    0x44c720ec83f0e483    0x19eb000000001c24
    0x804841f <main+19>:    0x042444891c24448b    0xe8080484e82404c7

    1- Como vemos en el ejemplo uno, le decimos a gdb que nos examine el registro $eip, y nos arroje en 4 unidades, en hexadecimal, y en tamaño byte.
    2- En el segundo de la misma manera pero ya con 2 bytes.
    3- Igual pero con 4 bytes.
    4- Por ultimo igual, pero con 8 bytes.

    #Resumen de este paper:

    Ya sabemos, compilar un código fuente, gcc analizaMe.c.
    Sabemos invocar el gdb y pasarle un binario para debuggearlo: gdb -q ./analizaMe
    Sabemos que para poner un breakpoint y que se detenga el programa invocamos el comando 'break' + nombre de la función, o dirección en memoria donde queremos que pare.
    Sabemos que una vez que para en el breakpoint, podemos verificar el status de los registros mediante 'info register' o alguno en particular como en nuestro caso anterior 'info register eip'.
    Sabemos que la herramienta 'examine' nos permite verificar todas la memoria, direcciones y valores que se nos ocurra y arrojar el resultado de la manera que mas cómoda nos parezca, como en el ejemplo de 'x/x $eip' para ver el valor que contiene el registro EIP en ese momento y que nos arroje el resultado en hexadecimal.
    Sabemos como mostrar por unidades como "x/2x"
    Sabemos como mostrar examine en tamaño de unidades b,h,w,g (byte, 2bytes,4bytes, 8bytes).[/left][/li]


De momento dejamos acá esta segunda parte, y ya pronto escribo la tercera.
c0nfused.


---------------------------------------------------------------------------------------------------------------------

Vamos a retomar con este tercer paper, y analizar lo que hace nuestro humilde programa codeado en C.

Antes que nada, vamos a eliminar nuestro analizaMe compilado anteriormente, y vamos a volverlo a compilar con un parámetro nuevo que es la option flag "-g".
Genera mayor información de debug para ser utilizada por GDB.
Let's work!.

$> gcc -g analizaMe.c -o analizaMe (compilas con option flag -g)
$> chmod +x analizaMe (le damos permisos de ejecucion)
$> ./analizaMe (ejecutamos el binario para testear que todo haya salido correcto y recordar que hacia)

La variable contar vale: 0
La variable contar vale: 1
La variable contar vale: 2
La variable contar vale: 3
La variable contar vale: 4

Ok, todo funciono bien por fuera, analicemos que hace por dentro, con lo aprendido anteriormente en GDB.

ACLARACIÓN: Puede que las direcciones de memoria de SUS PCS respecto a las mías en estos ejemplos NO SEAN IGUALES. Y seria algo lógico..
Asi que no se preocupen, que podrán seguir igual los ejemplos...

$> gdb -q ./analizaMe (abrimos el binario creado con nuestro debugger favorito :))

(gdb) b main  (breakpoint en la funcion principal main)
Punto de interrupción 1 at 0x8048415: file analizaMe.c, line 4. (respuesta del gdb).

(gdb) r (corremos el programa con el comando run o r abreviado)
Breakpoint 1, main () at analizaMe.c:4
4      for(contar=0; contar < 5; contar++)

Bien como vemos, para en el punto de interrupción que nosotros mismos pusimos en main.
Y como vemos nos adjunta '+ información' gracias al option flag -g que agregamos.
Bien, vamos a verificar como esta el panorama..

(gdb) i r $eip
eip            0x8048415    0x8048415 <main+9>
(verificamos la información del registro $eip y vemos que apunta a esa direccion).

(gdb) x/3i $eip
=> 0x8048415 <main+9>:    mov    DWORD PTR [esp+0x1c],0x0
      0x804841d <main+17>:    jmp    0x8048438 <main+44>
      0x804841f <main+19>:    mov    eax,DWORD PTR [esp+0x1c]

Como anteriormente vimos, la opción 'i' era la de instrucción. Le decimos a GDB que nos muestre solo las próximas 3 instrucciones a ejecutarse para guiarnos de que esta haciendo el programa y que va a hacer.

Si hicieron la tarea y refrescaron un poco assembler, fundamental para explotar cualquier vulnerabilidad... recordamos también cuando explique algunas instrucciones de assembler, como por ejemplo 'mov'.

A simple vista entonces, GDB nos dice que donde ahora mismo esta parado, va a realizar una operación en la cual 'moverá' el valor de la derecha '0x0' hacia la izquierda en donde tenemos como destino una dirección en memoria (esp+0x1c). Nota: Es muy común ver este tipo de direcciones, porque si recordamos sabemos que EAX, EBX, EDI, ESI, ESP, etc son registros y es común leer ESP+4 o EBP-4 y cosas asi, este caso nos dice que lo va a mover a ESP+0x1c. 0x1c en decimal equivale a 28. Por lo que seria $esp+28.
Si recordamos también que el programa paro en nuestro breakpoint en main justo cuando comenzaba el for y nos arrojo esta información:

"4   for(contar=0; contar < 5; contar++)"

Podríamos deducir que ese valor 0x0 que va a mover, es el que le dimos en el FOR a nuestra variable llamada 'contar'.
Analicemos esa dirección de memoria que valor contiene en este momento con el programa pausado en nuestro breakpoint:

(gdb) i r $esp
esp   0xbffff270 (En el registro ESP encontramos una dirección de memoria 0xbffff270)

Por lo tanto BFFFF270 + 1C  (ESP+28) = BFFFF28C. (tranquilos, todo eso el debugger lo obvia por nosotros y lo sabe, pero para que entendamos, otra aclaración for dummys, siempre que veamos 0x12345678 esa '0x' del principio nos indica que es una notación Hexadecimal, la dirección seria 12345678.)

Bien, volviendo a la practica verificamos con GDB, la siguiente linea:

=> 0x8048415 <main+9>:    mov    DWORD PTR [esp+0x1c],0x0

(gdb) x/x $esp+0x1c
0xbffff28c:    0xb7fc1000

Como vemos nos responde lo que anteriormente les aclare, esp contiene una dirección y esa dirección + 28 (1c) es BFFFF28c, y GDB nos dice que esa dirección contiene el siguiente valor: 0xb7fc1000.
Por lo tanto lo que pasaría ahora es que al ejecutar la siguiente instrucción:

"mov    DWORD PTR [esp+0x1c],0x0" ..ese valor dejaria de existir y pasaria a ser 0x0 con la operacion de mov.

Voy a comentarles un nuevo comando el cual nos permite por asi decirlo, crear temporalmente un 'acceso directo' a una determinada direccion, para no tener que escribirla constantemente y verificar si tiene cambios en su contenido:

(gdb) print $esp+0x1c
$1 = (void *) 0xbffff28c

(Le decimos a gdb que nos cree una variable temporal de la dirección de memoria $esp+0x1c, para accederla fácilmente cuando queramos, y gdb nos responde diciendo que se creo la variable $1)

Ahora usaremos el comando 'nexti' para ejecutar  la siguiente instrucción, nexti hace que el programa vaya paso a paso, instruccion por instruccion, luego del breakpoint que pusimos.

(gdb) nexti
0x0804841d    4      for(contar=0; contar < 5; contar++)

Ejecutamos nexti. Veamos si la dirección $esp+0x1c (0xbffff28c)    0xb7fc1000 que contenía valores aleatorios.. ha cambiado.

(gdb) x/x $1 
0xbffff28c:    0x00000000

Efectivamente, se cumplió la operación 'mov' y movió el valor '0x0' a la dirección de esp+0x1c.
Veamos donde esta parado ahora el registro EIP y cuales son sus siguientes operaciones:

(gdb) x/10i $eip  (le decimos a gdb que nos arroje las proximas 10 instrucciones).



Como vemos en la imagen, EIP apunta a una instrucción en donde hay un JMP (JUMP), un salto el cual tiene como destino la dirección 0x8048438. Que es la 7ma linea de las 10 que pedimos que nos muestre. Le damos a nexti.

(gdb) nexti
0x08048438    4      for(contar=0; contar < 5; contar++)

Vemos que seguimos en el FOR.

(gdb) x/3i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>
      0x804843f <main+51>:    leave

Ok, confirmamos que salto a la dirección 8048438 como sabíamos.

Y ahora lo que va a hacer es a comparar mediante la instrucción 'cmp'. El valor 0x4 (4) contra el valor que esta guardado en la dirección [esp+0x1c] (nuestra famosa dirección que podemos acceder temporalmente mediante la variable $1 que seteamos anteriormente).

Como sabemos por la ultima vez que vimos la dirección esa contenía el valor '0'. Por lo tanto comparara el valor 4, contra el valor 0. Exactamente en esta parte del FOR estamos: "contar < 5"
Le damos a nexti...

(gdb) nexti
0x0804843d    4      for(contar=0; contar < 5; contar++)

(gdb) x/i $eip
=> 0x804843d <main+49>:    jle    0x804841f <main+19>

Luego de ejecutar 'nexti' nos lleva a la siguiente instrucción, y si la verificamos con examine para ver donde esta parado EIP, nos encontramos con un JLE. Como recordamos, J.. es sinónimo de JUMP, pero en este caso es un salto 'condicional' que significa JUMP LESS EQUAL. Y quiere decir que SALTA, SI ES MENOR o IGUAL.....

Como evidentemente esto es cierto, ya que 0 es menor que 4.. entonces salta a la dirección 0x804841f.

(gdb) x/i $eip
=> 0x804841f <main+19>:    mov    eax,DWORD PTR [esp+0x1c]

Estábamos en lo correcto, y salto nomas a la dirección previamente dicha.
Si verificamos las siguientes 10 instrucciones:



Observamos que en la 4ta linea de las 10 solicitadas, hay un "CALL 0x80482F0".
Que es el encargado de llamar a la función PRINTF. (La que imprime en pantalla el primer mensaje de "La variable contar vale: 0" que observamos al ejecutar el programa).

Para que se entienda, cuando llegamos a una instrucción donde hay un CALL como en este caso el programa se desvia a una subrutina, es como si fuese una porción de código aparte en la cual se realizan otras operaciones y una vez que se concluyen al final de ese código de la subrutina hay una instrucción llamada RET (de return/regreso).

Vean la siguiente imagen.. (sacada de Google Imágenes).



Por lo tanto, luego de la llamada a esa función, el RET debería dejarnos justituto en la siguiente dirección 0x8048433:



Ok, siguiendo con nuestro análisis, ya estamos por el final, espero no se hayan perdido.

(gdb) x/5i $eip
=> 0x8048433 <main+39>:    add    DWORD PTR [esp+0x1c],0x1
      0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>
      0x804843f <main+51>:    leave
      0x8048440 <main+52>:    ret

EIP apunta a una instrucción conocida llamada 'add' la cual sirve para 'sumar' dos operandos y lo guarda en el lugar destino, en este caso 0x1 en nuestra conocida dirección de memoria ;).

Le damos a 'nexti'.. y luego verificamos después de esta operación si el valor de esa dirección de memoria tuvo algún cambio..

(gdb) nexti
0x08048438    4      for(contar=0; contar < 5; contar++)

(gdb) x/x $1
0xbffff28c:    0x00000001

Efectivamente.. ahora contiene el valor de 1.
Si miramos un poco mas las siguientes dos instrucciones:

(gdb) x/2i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>

Ya nos resulta conocida, y es que esta nuevamente comparando el valor de 4 con el ahora 1.
Luego viene el ya explicado JLE - va a saltar si es menor o igual que 4.
Como lo és, salta a 0x804841f. Y así seguiría el loop.. hasta que si seguimos analizando el programa paso a paso con nexti y verificando el valor de la dirección en $1.. llegaríamos a:

(gdb) x/x $1
0xbffff28c:    0x00000005

(gdb) x/i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4

(gdb) x/5i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>
      0x804843f <main+51>:    leave
      0x8048440 <main+52>:    ret

Luego de ir sumándole 1 por cada loop de imprimir en pantalla, nuestra famosa dirección contiene el valor de 5.
Por lo tanto al siguiente 'cmp', de comparar si 5 es menor o igual que 4? y matemáticamente es negativo, NO se cumpliría el JLE condicional por lo que las siguiente dos instrucciones serian:

(gdb) x/2i $eip
=> 0x804843f <main+51>:    leave
      0x8048440 <main+52>:    ret
      0xb7e344d3 <__libc_start_main+243>:    mov    DWORD PTR [esp],eax
      0xb7e344d6 <__libc_start_main+246>:    call   0xb7e4dfb0 <exit>

(gdb) nexti
[Inferior 1 (process 5324) exited with code 034]

De esta manera finaliza el tercer paper.. y uno de los mas largos.
Gracias :).

#c0nfused - allmenage[at]gmail.com - No tienes permisos para ver links. Registrate o Entra con tu cuenta
Security Researcher / Reverse Engineer
No tienes permisos para ver links. Registrate o Entra con tu cuenta

Desconectado Pr0ph3t

  • *
  • Underc0der
  • Mensajes: 443
  • Actividad:
    0%
  • Reputación 0
  • © Underc0de Team
    • Ver Perfil
  • Skype: thebrowfc
« Respuesta #1 en: Enero 24, 2015, 01:26:38 pm »
Muy bueno confused, se agradece el aporte.
Twitter: @The_Pr0ph3t
pr0ph3t@hotmail.es

Desconectado arthusu

  • *
  • Underc0der
  • Mensajes: 549
  • Actividad:
    13.33%
  • Reputación 2
  • Yo solo se que no se nada - Socrátes
    • Ver Perfil
    • Arthusu BLOG
  • Skype: arthusuxD
« Respuesta #2 en: Enero 24, 2015, 04:30:58 pm »
Excelente post +1

Desconectado Turka

  • *
  • Underc0der
  • Mensajes: 101
  • Actividad:
    0%
  • Reputación 0
  • Turca por herencia.
    • Ver Perfil
  • Skype: turka.xd
« Respuesta #3 en: Enero 24, 2015, 05:09:36 pm »
Bien, en primer lugar me gusta como redactas asi que me alegro que hayas publicado algo :) esta rama de bug hunting y exploit writing es fascinante es una de las que manejo y mas me gustan.

De todas maneras, tu paper es mas bien un manual de debugging con gdb :) ya que en realidad no estas mostrando como buffer overflodear, sobreescribir el EIP, insertar un shellcode, etc. que esta mas relacionado a los exploits.

Muy bueno,

Saludos.

Desconectado cnfs

  • *
  • Underc0der
  • Mensajes: 103
  • Actividad:
    0%
  • Reputación 3
    • Ver Perfil
    • shad0whack
    • Email
  • Twitter: https://twitter.com/cmind33
« Respuesta #4 en: Enero 27, 2015, 11:46:13 am »
Primero muchas gracias a todos.

Segundo, Turka, esta mas que claro que aun no llegue a eso.. si te fijas bien titule How To exploit: Comienzos..
La idea era hacer una serie de papers, hasta donde dé mi paciencia en numeros jeje.. De momento tengo mucho trabajo pero voy a continuarlo pronto. Es por eso que intente de una manera 'llevar' al usuario/interesado en el tema, a amigarse con gdb, assembler, y luego poder llegar a lo que decis.

Muchas gracias, un saludo a todos.
« Última modificación: Enero 27, 2015, 12:27:19 pm por cnfs »
Security Researcher / Reverse Engineer
No tienes permisos para ver links. Registrate o Entra con tu cuenta

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5396
  • Actividad:
    36.67%
  • Reputación 31
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« Respuesta #5 en: Enero 27, 2015, 11:51:50 am »
Muy bueno cnfs!!
Espero que la segunda parte quede lista muy pronto!! Ya tengo ganas de leerla!

Saludos!
ANTRAX


Desconectado MagoAstral

  • *
  • Underc0der
  • Mensajes: 115
  • Actividad:
    0%
  • Reputación 0
  • Nada resulta más engañoso que un hecho evidente.
    • Ver Perfil
« Respuesta #6 en: Enero 27, 2015, 01:41:48 pm »
No tienes permisos para ver links. Registrate o Entra con tu cuenta
Bien, en primer lugar me gusta como redactas asi que me alegro que hayas publicado algo :) esta rama de bug hunting y exploit writing es fascinante es una de las que manejo y mas me gustan.

De todas maneras, tu paper es mas bien un manual de debugging con gdb :) ya que en realidad no estas mostrando como buffer overflodear, sobreescribir el EIP, insertar un shellcode, etc. que esta mas relacionado a los exploits.

Muy bueno,

Saludos.
Criticar el trabajo de otros es muy fácil, maestro...

Respecto al aporte muy grande, bien redactado y entendible. Un lujo estos aportes, espero que la gente valore el esfuerzo del redactor.
Un saludo.
Lo que sabemos es una gota de agua; lo que ignoramos es el océano.

Desconectado Stuxnet

  • *
  • Underc0der
  • Mensajes: 259
  • Actividad:
    0%
  • Reputación 2
    • Ver Perfil
    • Devel Security
  • Twitter: _stuxnet
« Respuesta #7 en: Enero 27, 2015, 03:47:35 pm »
@MagoAstral; Nadie esta criticando nada, turkita solo esta haciendo una aclaración.

@cnfs excelente aporte +1. A la otra intenta ser más específico con los titulos para que no hayan confuciones, un saludo.

Bytes:3
No tienes permisos para ver links. Registrate o Entra con tu cuenta

Desconectado cnfs

  • *
  • Underc0der
  • Mensajes: 103
  • Actividad:
    0%
  • Reputación 3
    • Ver Perfil
    • shad0whack
    • Email
  • Twitter: https://twitter.com/cmind33
« Respuesta #8 en: Enero 27, 2015, 05:11:35 pm »
jaja relax gente, todo halago y critica constructiva conllevan a mejorar aun mas la situacion actual de algo.
De todas maneras, insisto. El titulo me parece acertado. How to exploit: Comienzos. Al continuar los papers, se llegara al tan esperado desbordamiento y toque de otros temas, pero considero que en toda historia se necesita de una introduccion.

Gracias nuevamente! esperare sacar otros pronto, estoy terminando algunos de Malware analysis que me toco trabajar en esta semana y me dio por escribir, ojala sean de utilidad tambien. Abrazo!.
Security Researcher / Reverse Engineer
No tienes permisos para ver links. Registrate o Entra con tu cuenta

Conectado Gabriela

  • *
  • Co Admin
  • Mensajes: 874
  • Actividad:
    1.67%
  • Reputación 15
    • Ver Perfil
    • Email
« Respuesta #9 en: Enero 29, 2015, 03:27:24 pm »

cnfs, un detallado trabajo muy bien logrado.

Nos alegra que decidieras a dejarlo en la Comunidad , y de paso te agradecemos!!!

Gabi.

Desconectado JNIOR

  • *
  • Underc0der
  • Mensajes: 15
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #10 en: Febrero 01, 2015, 07:56:04 pm »
excelente!! +10

 

¿Te gustó el post? COMPARTILO!



Exploit para Apache Struts (ejecución remota de comandos) [Tomcat]|CVE2017-5638

Iniciado por Eschiclers

Respuestas: 9
Vistas: 3260
Último mensaje Marzo 23, 2017, 03:57:38 pm
por zoro248
[Video/ing] Ms Word Office Silent Exploit Builder RECODED from scratch FUD 2016

Iniciado por simdia

Respuestas: 0
Vistas: 2013
Último mensaje Diciembre 25, 2015, 08:40:37 am
por simdia
Nuevo Exploit 0day para Internet Explorer 7, 8, 9 en Windows XP, Vista y 7

Iniciado por CalebBucker

Respuestas: 1
Vistas: 2188
Último mensaje Septiembre 17, 2012, 04:49:25 pm
por Slore
MS14-060 Microsoft Windows OLE Package Manager Code Execution Exploit

Iniciado por Stuxnet

Respuestas: 1
Vistas: 3290
Último mensaje Octubre 24, 2014, 09:18:14 pm
por zekurity
Exploit Full path disclosure and Sql Error ONLINE SHOP IGT

Iniciado por MaztoR

Respuestas: 0
Vistas: 1466
Último mensaje Abril 05, 2012, 09:20:06 pm
por MaztoR