|
|
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
Vamos a
ver porque no nos funcionaba el FSG que yo intente desempacar “a mi manera”. Empezamos
a tocar el tema de reconstrucción de IAT, un tema que si no hubiera sido por
la ayuda de Shoulck a mi me tendría dando vueltas todavía como un loco pues
se me complico demasiado por una tontería y por eso le tengo manía. Espero explicarlo de manera que lo entendáis claramente para que no os veáis como yo me vi, ya que es importante que os quede claro el tema de la reconstrucción de la IAT. |
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
Cargamos el crackme FSG en
PE_editor, es el mismo que utilizamos en el capitulo 12.
Y tomamos nota en un papel de los
apartados Image Base y Size of Image: 400000 y 6000
respectivamente. Cerramos PE_editor y cargamos el
crackme en Olly. Esto es lo que vemos (nada útil)
al examinar la APIs y las strings APIs -> Sigamos los pasos “malos” que di
al intentar descomprimirlo “a mi manera” en el cap 12 De primeras al cargarlo aparecemos
aquí: 405EF6
Bajamos por el código buscando el
salto lejano que nos lleve dentro de la sección de código y lo
encontramos aquí: 405F98
Lo cambiamos como hicimos en el
anterior capitulo para que salte directamente y ponemos un BP con F2
Ejecutamos con F9 y cuando para en el BP que hemos
puesto lo pasamos con F7 una sola vez y caemos en el OEP del crackme: 401200
Si lo intentamos volcar como hasta
ahora utilizando el plugin OllyDump – Dump debugged process no nos funcionara
como pudimos comprobar en el capitulo 12 así que lo haremos de otra manera,
utilizaremos el plugin IsDebuggerPresent. Una vez encontrado el OEP (apuntad
la dirección en un papel) abrimos el plugin IsDebuggerPresent y click
sobre Dumper
Aparecerá esta ventanita donde
debemos rellenar la casilla
Offset con la cantidad que apuntamos al examinarlo con PE_editor
correspondiente a la Image Base: 400000 Y en la casilla Size
escribiremos la cantidad correspondiente a Size of Image: 6000
Luego pulsaremos Dump y así
volcaremos el exe a una carpeta teniendo cuidado de escribir la extensión
.exe pues sino nos lo guardara con extensión .bin
Si miramos la carpeta donde lo
guardamos veremos el crackme empacado FSG.exe y el volcado dumpy.exe, hay una
diferencia muy clara con respecto a los volcados que vimos en anteriores
capítulos y es que este ejecutable que volcamos no tiene icono, debería
aparecer con el mismo icono negro que tiene FSG.exe.
Vamos a arreglar esto, Abramos dumpy.exe (en mi caso yo
llamo así al volcado del ejecutable, vosotros debéis abrir el vuestro) con
PE_editor y pulsemos el botón Aparece esta ventana y
poniéndonos encima de una de las líneas click derecho y pulsamos sobre
dumpfixer (RS=VS & RO=VO)
Por que hacemos esto ¿? Para
igualar el tamaño de las secciones del crackme volcado fijándolas (fix) Es decir: dejamos Raw Size = Virtual Size y Raw Offset = Virtual Offset. Si miramos ahora la carpeta donde
tenemos los ejecutable vemos algo que nos gusta mas:
El volcado (dumpy) ya tiene toda la
pinta de ser un exe de “verdad”. Bien si intentamos ejecutarlo nos
aparecerá un error que nos dice algo así como que no se encontró el
kernel32.dll, ahora viene lo que puede ser mas lioso o por lo menos lo
que a mi me llevo mas tiempo comprender, pues cometía el mismo error una y
otra vez, para explicarlo llanamente: nos falta localizar y fijar en el
crackme las llamadas que hace el mismo a las APIs, podríamos decir que al
volcar el crackme se desbarataron los bites, como si volcáramos un cajón y lo
que hay dentro se descolocara, hemos conseguido ordenar una parte de las
cosas que había en el cajón al fijar con PE_editor (RS=VS & RO=VO) pero aun
nos queda trabajo por hacer: reconstruir la tabla de importaciones IAT
(Import Address Table). Mientras no reconstruyamos la
tabla de importaciones el crackme no funcionará correctamente. Terminando de ordenar el
cajón: buscando la tabla de importaciones perdida y
reconstruyéndola. La tabla de importaciones
tiene un principio y un final que debemos encontrar para poder
seguir ordenando nuestro crackme. Desde el OEP del crackme en la
dirección 401200 vemos si miramos hacia arriba que el crackme parece estar
escrito en visual basic (ver cap anteriores)
Desde el OEP iremos pulsando F7 poco a
poco hasta caer en la primera dirección que sea del tipo FF25 XXXXXXXX JMP DWORD PTR
DS:[XXXXXX] una vez parados en ella click derecho Follow in
dump – Memory address (para seguir/examinar en el dump esta dirección de
memoria) En este caso caemos en 401094 (esto
variara según el crackme)
Vemos en el dump la dirección 401094 que es la
que estamos examinando y un montón de números – en este caso ceros – cada par
de números es un byte
Si sombreamos los primeros 4
bytes empezando por la izquierda en la dirección 401094 y hacemos
clic derecho Find references o control + R …
… nos encontraremos con esto:
JMP DWORD PTR DS:[XXXXXX] Si probamos los siguientes 4 bytes
(seguimos el orden izquierda -> derecha) vemos que también aparece un
salto del tipo JMP DWORD PTR DS:[XXXXXX] Fijaros en una cosa estábamos en 401094 y hemos
“avanzado” 4 bytes y ahora el JMP nos marca 401098 lo que es
igual a 401094 + 4 (ya veréis el
porque de este apunte)
Empezaremos buscando el final de la
IAT, el motivo es que en este crackme es más difícil encontrar el final que
el principio de la tabla de importación. Como lo encontramos ¿? Pues cuando sombreando
direcciones en el dump bajando desde la dirección donde estamos y buscando
referencias con control + R NO nos aparezcan los saltos del
tipo JMP DWORD PTR
DS:[XXXXXX] Voy buscando, sombreando los 4
bytes de cada dirección en el dump
y pulsando control +R en cada
uno de ellos y llego hasta la dirección 4010BC y veo un salto (aparte de
mas instrucciones que ahora no cuentan) del tipo JMP DWORD PTR
DS:[XXXXXX] La instrucción es JMP DWORD PTR DS:[4010BC]
Si continuo mas allá (hacia
“abajo”) de esta dirección y hago control + R no me aparece ninguna instrucción del
tipo JMP DWORD PTR DS:[XXXXXX]
Para asegurarme sombreo de una vez
una gran cantidad de direcciones en el dump
desde la siguiente (siempre hacia la izquierda) que pienso que es la
ultima dirección hacia abajo y veo que no encuentro mas instrucciones del
tipo JMP DWORD PTR DS:[XXXXXX]
Por si acaso y para que lo veáis
sombreo todo el dump hasta el final (siempre hacia abajo pues estamos
buscando el final de la IAT) y sigue sin aparecer ninguna instrucción del JMP
DWORD PTR DS:[XXXXXX]
Entonces para que quede claro: la IAT esta comprendida entre la
primera dirección del dump donde encontremos una instrucción tipo JMP
DWORD PTR DS:[XXXXXX] y la ultima
dirección donde encontremos una instrucción del mismo tipo, ambas incluidas
Esto lo vemos sombreando los 4
bytes de cada dirección y haciendo control + R en cada una de ellas. En este caso el final de la IAT
será la dirección 4010BC pues “debajo” de ella si seguimos buscando con control + R no
encontramos ninguna instrucción del tipo JMP DWORD PTR DS:[XXXXXX] Apuntaremos en un papel la
dirección del final de la IAT, para saber cual es la dirección
que debemos apuntar nos fiaremos del numero que vemos dentro del
paréntesis: JMP DWORD PTR DS:[4010BC] Bien pues si el final de la IAT se
busca partiendo hacia abajo desde esa dirección (en este caso 401094) el
principio lo hallaremos al revés. En este crackme es fácil, si
subimos desde 401094 buscando las referencias con control + R llegaremos al “tope”
del dump en la dirección 401000 si sombreamos los bytes
pertenecientes a esa dirección y control +R vemos una instrucción tipo JMP
DWORD PTR DS:[XXXXXX] Para buscar el principio de la
tabla iremos “subiendo” analizando las direcciones de derecha <-
izquierda, al revés de cómo lo hacíamos para buscar el final. Como no podemos ir mas
arriba y esa es la primera instrucción que tenemos tipo JMP DWORD
PTR DS:[XXXXXX] ese será el principio de la IAT
Por tanto el principio será como
se ve en la imagen 401000 JMP DWORD PTR DS:[401000] -siempre
fijándonos en el numero dentro del paréntesis que vemos en la ventana
references, ese es el que manda-. Si probamos a ir bajando desde
aquí analizando cada dirección con control + R veremos que las siguientes
instrucciones pertenecen todas a la tabla de importación hasta llegar a la
dirección que habíamos visto como final de la tabla: 4010BC
Tenemos entonces apuntadas en un
papel el principio y final de la tabla de importación: principio = 401000 final = 4010BC Un par de apuntes: Si miramos encima del OEP podemos
ver todas las instrucciones tipo FF25 XXXXXXXX JMP DWORD PTR DS:[XXXXXX] y fijándonos un poco mas veremos la dirección
mas baja y también la mas alta (marcadas en rojo) en visual basic se ven muy
bien todas juntitas encima del OEP del programa.
Si estando parado encima de 4011FA (el
primer FF25 XXXXXXXX JMP DWORD PTR DS:[XXXXXX] que encontramos partiendo
desde el OEP con F7) pulso F7 caigo en esta zona donde empiezo
a ver en el código las llamadas al kernel y a las APIs (recordad el aviso que
nos decía que no encontraba kernel32.dll al ejecutar el dumpy.exe)
Por eso para entendernos podríamos
decir que reconstruyendo IAT ponemos en su sitio cada llamada a las APIs que
hace el crackme. Una vez que sabemos el principio y
fin de la IAT debemos hallar su talla, lo que ocupa, la longitud, para
eso utilizaremos la calculadora de Windows en modo científico y restaremos el
principio del final: 4010BC – 401000 = BC (en hexadecimal) Y aquí esta el tema que me trajo
loco con la put@ reconstrucción de la IAT …
… hasta que Shoulck se cruzo en mi camino y me hizo ver la luz, mas
adelante veréis lo que paso por culpa de 4 bytes de mierd@ Con estos datos: principio, final
y longitud de la IAT ejecutamos el crackme FSG.exe, el comprimido con FSG, el
malo y después abrimos Import reconstructor. Ojo: ejecutamos el crackme malo
normalmente y luego abrimos el Import reconstructor, no os confundáis
e intentéis abrir el crackme con el Import pues lo que haremos será atacarlo
como proceso activo, esto es atacar el crackme malo mientras se esta
ejecutando. Nos aparece aquí este cartel que
os dejo por si queréis mirarlo ya que después de la primera ejecución del
Import creo que no vuelve a aparecer.
Aparece la ventana principal de
Import reconstructor y vemos de fondo ejecutándose normalmente el crackme
empacado con FSG
Atacamos el crackme desde el
Import simplemente desplegando y seleccionándolo
Una vez “cargado” el crackme en el
Import rellenaremos los datos que tomamos anteriormente En OEP ponemos 1200 que es el OEP
menos la Image Base (401200 – 400000) En RVA ponemos 1000 que es el
principio de la IAT menos la Image Base (401000 - 400000) En Size ponemos la medida de la IAT -> BC
Atención esto es lo que me
volvió loco durante varios días, ahora veremos que la talla real de la
IAT no es BC. Con estos tres datos pulsamos
Despleguemos el árbol pulsando el
signo + y bajemos hasta el final, fijaros donde pone RVA, vemos
que pone 000010B8 esto seria 4010B8 si le sumamos la Image Base, aquí hay una
cosa que no cuadra: si le damos el principio de la IAT (1000) y le decimos la
longitud (BC) lo lógico es que el final de la tabla fuera 000010BC (401000 +BC = 4010BC) que
sabemos que es el final de la IAT pues lo buscamos anteriormente “a mano” en
el dump.
Esto es una cosa que debemos
revisar siempre pues si no ponemos bien el principio y fin de la IAT
sacaremos un exe basura que no servirá para nada. Pulso
Pulso de nuevo
Esta tontada de los 4 bytes me tuvo
loco durante días pensando que era un inútil y que había llegado a mi limite
en esto del crack, hasta que Shoulck me advirtió que mirara el final de la
IAT en el Import reconstructor y pude ver que no terminaba donde debía y me
explico que debería sumarle 4 bytes mas que es lo que ocupa cada
dirección. Tal y como yo lo hacia fiándome de
la resta siempre me faltaba la ultima dirección de la IAT y era incapaz de
reconstruir crackme alguno, solo conseguía basura inútil y frustración permanente. Tomad la costumbre de añadir esos
4 bytes, o sea al hallar la talla o longitud de la IAT haremos esto : fin de IAT – principio de IAT + 4 y esa
será la longitud de la IAT, aunque
siempre lo comprobaremos en Import reconstructor y así
evitaremos sorpresas desagradables. Continuamos, al pulsar get imports
esta vez tenemos cargada en el Import la tabla completa (todas las APIs) Pulsaremos
Pulsamos
Sale en el log un aviso diciendo
que lo hicimos succesfully, o sea de c#ñ@
Miramos la carpeta y vemos que la
familia FSG ha crecido, ahora tenemos un nuevo exe: dumpy (espacio _) .exe Ese es el exe definitivo, el exe
totalmente desempacado y arreglado, funcional …
Lo cargamos en Olly y lo
comprobamos Vemos las APIs -> Fue duro y quizás parezca un poco
lioso pero no se tarda mas de 10 minutos en desempacar el crackme una vez
pillado el rollo Realmente es más fácil y rápido
como lo mostró Orimagic en su tuto, pero era necesario hacerlo así para tomar
un contacto suave con la IAT, creedme: lo necesitaremos. Resumen rápido: Abrimos el crackme con PE_editor y
apuntamos
Image base y Size of Image Abrimos el crackme en Olly y buscamos el
OEP con la técnica del salto lejano: buscamos el salto (-) -
cambiamos el salto condicional por un JMP - ponemos un BP con F2 y cuando
pare Olly una vez F7 y ya estamos en
el OEP, lo apuntamos. Una vez en el OEP volcamos con
IsDebuggerPresent – Dumper rellenando los dos datos que nos pide (Image
base y Size of Image) y le damos un nombre al volcado. Aprovechamos que esta cargado en
Olly y parado en el OEP y buscamos el principio y fin de la IAT Desde el OEP trazamos con F7 hasta
llegar a la primera instrucción tipo FF25 XXXXXXXX JMP DWORD PTR DS:[XXXXXX] y hacemos Follow in dump – Memory address. En el cuadro del dump partiendo de
esa dirección buscamos “hacia arriba” donde empiezan la primera dirección que
contenga una instrucción tipo JMP DWORD PTRDS:[XXXXXX] y ese será el
principio de la IAT Hacemos lo mismo buscando “hacia
abajo” para encontrar el final de la IAT. Restamos final de IAT
menos principio de IAT y le sumamos 4 para saber la longitud/talla de
la IAT y apuntamos estos tres datos. Abrimos PE_editor y cargamos el
archivo volcado para fixarle/igualarle las secciones con dumpfixer (RS=VS & RO=VO) Ejecutamos el crackme protegido Ejecutamos Import reconstructor y
“atacamos” el crackme mientras se ejecuta, rellenamos los 3 datos OEP, RVA
(principio de la IAT) y Size (de la IAT) pulsamos get imports y nos
aseguramos en Import Rec que el principio y final de la tabla son los que
deberían ser. Pulsamos show invalid y vemos que
todo es valid:YES, pulsamos fix dump y elegimos el exe volcado. Ya esta, nuestra primera IAT
reconstruida. Antes de terminar alguno os
preguntareis (espero) por que al hacerlo como dice Orimagic no hace falta
reconstruir la IAT, mirad esto:
Esta marcada rebuild import
(import table) en el plugin OllyDump Pues bien Orimagic busco el OEP con
el plugin OllyDump y desde ahí lo volcó teniendo esta opción marcada
(nosotros la hemos tenido siempre marcada también) pero por lo que se ve de
la forma que yo (novato) hago el desempacado manual de FSG fallo en algo
(probablemente al cambiar alegremente el salto lejano por un JMP sin mas) y
debo de reconstruir la tabla manualmente, lo cual dentro de “mi desgracia” me
sirve para enlazar de forma progresiva (en dificultad) estos capítulos del
curso. El que no se contenta es por que
no quiere. Como siempre esto esta explicado
de la manera mas llana y sencilla posible, el que necesite teoría pura y dura
que lea los tutos de los grandes maestros y podrá obtener la definición
técnica de lo que es una IAT por ejemplo. La put@ mierd@ esa de los 4 bytes
me tuvo loco, no hubiera podido aprender nunca a reconstruir una IAT sin la
ayuda de Shoulck que me explico lo que me estaba pasando. Así que si hay alguien que aun
siga el curso que le de gracias a Shoulck por haberme sacado de este
bache, pues sin el seguramente me hubiera desmoronado mentalmente y
físicamente pasando de escribir mas tutos forever y dedicándome a la cría del
champiñón o a estudiar la vida y costumbres de la marmota andina, por poner
un ejemplo. Al final le tendré que pagarle a
Shoulck alguna copa … … Nos vemos. |
||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||
|
||||||||||||||||||||||||||||||
