1.1 Ejemplos en Ventana de desensamblado - OllyDBG:

Vamos a manejarnos un poco con lo más básico en esta ventana.
Voy a abrir un programa cualquiera con el OllyDBG y pongo una imagen de la ventana de desensamblado:


Estamos parados en el OEP (Punto de Entrada Original) del programa. Si se observa un poco vemos en la imagen un salto a la librería MSVBVM60, por lo tanto podemos ya imaginarnos que se trata de un programa compilado con Visual Basic.

Vamos a hacer unos pequeños ejercícios:

1.- Ir a la dirección 418E80.
-Como expliqué en el párrafo anterior podemos o bien pulsar el botón número 10 de la siguiente imagen:
o bien, podemos pulsar Ctrl+G o botón derecho --> Goto --> Expresion.

De estas 3 formas se nos abrirá una ventana y ahí podremos poner la dirección a la que queremos ir: 418E80:


pulsamos Ok y nos llevará directamente a esa dirección.

2.- Poner un Breakpoint (BP - lugar donde parará el debugger) en 418E80
Lo primero vamos a la dirección 418E80, explicado en el punto anterior.
Una vez ahí, pulsamos simplemente F2, o botón derecho --> Breakpoint --> Toggle o simplemente 2 clicks en la columna "Hex dump" y veremos cómo se pone la dirección en rojo. Ya tenemos puesto el punto de ruptura.

En este punto, voy a añadir que OllyDBG nos permite poner varios tipos de BP. Hemos visto el más común y típico, pero también podría ser necesario que parase en 418E80 solamente cuando por ej. el registro EAX sea igual a 2 (botón derecho --> Breakpoint --> Condicional) y ahí pondríamos la condición, que no se va a explicar aquí.
Otro tipo de BP son los Hardware Breakpoints. Sólo podemos poner 4. Si pulsamos botón derecho --> Breakpoints, veremos que en la ventana de desensamblado podemos poner un Hardware on execution. Para ver los HBP que tenemos podemos ir al menú: Debug --> Hardware Breakpoints y ahí veremos los que tenemos puestos. Si intentamos poner más de 4, OllyDBG nos avisará que debemos borrar uno.

3.- Modificar una instrucción
Imaginemos que tenemos lo siguiente:

402E40  DEC EAX
Después de analizar el código detenidamente, sabemos que ese DEC EAX (en mi programa) lo que hace es disminuir una vida. Como yo no quiero que me quite una vida, pues voy a modificar ese código.
Puedo hacerlo de varias formas:
-NOPEAR TODO: Nos ponemos sobre esa linea y pulsamos botón derecho --> binary --> Fill with NOPs y así rápidamente ya tenemos todo lleno de NOPs.
-DEC EAX se compone de un sólo byte. En la columna dissasembly podemos clickear dos veces y nos saldrá una ventana donde podremos modificar el código. Por ej. podríamos poner: NOP y tendremos lo mismo que antes, o simplemente INC EAX y nos incrementará EAX u otra cosa que se nos ocurra.
-Modificar el byte. En la columna Hex dump, podemos pulsar botón derecho --> Binary --> Edit y podemos modificar el byte.

4.- Ir a MessageBoxA
Los más Newbies desconocen esta opción. Lo primero que tenemos que asegurarnos es que se haya cargado la librería correspondiente.
Me explico. Por ejemplo la función MessageBoxA se encuentra en user32.dll. Si nuestro programa no ha cargado user32.dll esto que vamos a hacer no funcionará.
Simplemente hacemos como antes cuando quisimos ir a una dirección:
pulsar el botón número 10 de la siguiente imagen:
o bien, podemos pulsar Ctrl+G o botón derecho --> Goto --> Expresion
Y ahí escribimos: MessageBoxA, y OllyDBG nos llevará ahí.

5.- Poner un comentario
Es posible que algún código ya sepamos exactamente lo que hace. Para ver todo mucho más sencillo podemos poner nuestro propio lenguaje. Por ej.
401200 DEC EAX   <-- Quita un día
...
402000 Call 4032EC  <-- Call que pone un botón activado
etc...
De este modo, cuando lleguemos a este código ya sabemos qué hace exactamente todo y no tenemos que volver a analizar.
Para poner comentarios, como ya se ha explicado, podemos por ej. pulsar dos veces en la columna "Comment" y se abrirá una ventana y ahí podremos poner lo que queramos.
Esto aunque parezca una tontería, es realmente muy útil, sobre todo a la hora de trabajar con programas con mucho código. También nos ayuda a encontrar las zonas que nos interesan, ya que podemos buscar nuestros propios comentarios.
Para buscar nuestros comentarios pulsamos botón derecho --> Search for --> user-defined comment y podremos seleccionar lo que queramos. Muy útil.

6.- Me he movido por el código y ahora no sé volver donde estaba antes.
Estamos parados en un determinado código. Ahora vamos a una dirección y después a otra. Podemos volver a las dos anteriores simplemente pulsando la tecla "-" (menos). Si queremos ir ahora para adelante podemos pulsar la tecla "+" e iremos de nuevo a la última dirección que estuvimos.

Es posible también que lo que se quiera sea ir al lugar donde estaba detenido el debugger. Esto es muy fácil, ya que sabemos que el debugger está parado en el valor del registro EIP, por lo tanto podemos cliquear dos veces en este registro e iremos donde está parado nuestro debugger. Podemos también pulsar la tecla "C" de la barra de herramientas.

7.- Acabo de entrar en una CALL de una librería. Quiero volver al código de donde fue llamada.
Una opción manual sería ir a cada RET pulsando Ctrl+F9 y después F7 para pasar el RET y haciendo esto llegaríamos a nuestro código donde ha sido llamada la CALL.
Hay una opción que tiene OllyDBG y que nos puede facilitar este trabajo:
simplemente pulsando Alt+F9 (Execute till user code).

8.- Quiero que el código se ejecute hasta donde tengo el cursor puesto.
Pinchamos (hasta que marque en color) sobre un determinado código y pulsamos simplemente F4.



9.- Ya he hecho los cambios en el OllyDBG, ahora quiero guardar todos los cambios en el mismo ejecutable.
Esta pregunta la hace muchísima muchísima gente. Voy a explicar la teoría de cómo hay que modificarlo y explicaré la forma de hacerlo de manera muy SENCILLA con OllyDBG sin utilizar ningún Editor Hexadecimal y por lo tanto sin calcular el Offset:

Imaginemos por ejemplo que en la dirección 401000 tenemos lo siguiente:
401000 PUSH EBP ;push ebp corresponde al byte 55h.

Bien, nosotros hemos modificado ese PUSH EBP (55h) y hemos querido dejar un NOP, entonces veríamos lo siguiente:
401000 NOP ;nop corresponde a 90h

Ya tenemos el cambio que queremos hecho. Ahora viene la pregunta:
¿Cómo puedo guardar el exe (dll o lo que sea) con este nuevo cambio que acabo de hacer? Con OllyDBG lo haremos en tres pasos:

1.-Pulsamos botón derecho (en cualquier lugar en la ventana de desensamblado) y elegimos:
Copy to executable --> All modifications

2.-Se abrirá una nueva ventana con 4 botones que nos dice lo siguiente: "Copy selection to executable file?" Pulsamos en el botón: "Copy All"

3.-Y finalmente en la nueva ventana que aparece pulsamos botón derecho y elegimos: "Save file".

De este modo tan sencillo ya lo tenemos modificado .

TEORÍA de este punto 9. Esto que voy a explicar lo considero muy importante, muy esencial y que todo el mundo, ya seas iniciado o no debe saber.
Voy a tratar el punto 9 pero sin OllyDBG y entendiendo todo, y lo vamos a modificar manualmente.
Voy a utilizar un programa fácil de conseguir y que nos servirá de guía: OllyDBG 1.10. Lo vamos a abrir con un editor de PE (encabezado). Hay muchísimos programas, cada uno que elija el que más le guste.

Nos vamos a ir a ver las secciones y si miramos las del OllyDBG encontraremos lo siguiente:



Columna por columna:
-Name: Indica el nombre de la sección.
-Virtual Offset o Relative Virtual Address: Es la dirección virtual relativa a la Image Base donde se encuentra la sección. Muchas veces la veremos nombrada como RVA (Relative Virtual Address. No hay que confundirla con la Virtual Address ya que a esta última se le suma la Image Base. La mayoría de los programas tienen la Image Base igual a 400000h.
Ejemplo de esto último: (datos del OllyDBG que hemos abierto con un Editor PE)
Image Base: 400000h
RVA donde comienza la sección ".text": 1000
Por lo tanto la Dirección Virtual (Virtual Address) donde comienza la sección .text es:
Image Base + RVA = VA;  VA = 400000 + 1000 = 401000.
Esto nos quiere decir que la sección .text comienza en la dirección virtual 401000. Se puede comprobar si abrimos un OllyDBG con otro OllyDBG y vamos a esta dirección: veremos que es la primera instrucción...

-Virtual Size: Es el tamaño virtual de la sección. Por ej. el tamaño virtual de la sección .text son AF000h bytes.

-Raw Offset o PointerToRawData: indica el desplazamiento dentro del archivo donde comienza la sección. Ahora que ya sabemos un poco voy a entrar un pelín en detalle. Sabemos lo siguiente:
-que la Image Base es 400000h
-que la sección .text comienza en el RVA 1000
-que la primera instrucción (desensamblarlo) es JMP SHORT 00401012 que corresponde a los 2 bytes: EB 10
-que esta primera instrucción se encuentra en VA 401000


Pregunta: Estos dos bytes (EB 10) que se encuentran en RVA 1000, ¿Dónde se encuentran realmente en el archivo ejecutable?
Bien, esto nos lo dice: Raw Offset o PointerToRawData. En este caso es sencillo ya que estos 2 bytes (EB 10), se encuentran justo en el inicio de la sección .text, por lo tanto, dichos bytes se encuentran en el archivo en el offset: 600h.
Para comprobar esto que acabo de decir, voy a abrir al OllyDBG en un editor hexadecimal y voy a ir al offset 600h:

Perfecto, ahí tenemos los dos bytes.


Bueno, acabamos de ver un ejemplo muy sencillo, vamos a hacer otro que es lo que nos vamos a encontrar normalmente, y es lo que hay que aprender a entender.
Voy a abrir el OllyDBG con el OllyDBG y me voy a ir a una dirección cualquiera...:


Tenemos de nuevo los siguientes datos:
-Image Base = 400000h
-RVA (.text) = 1000h
-Raw Offset = 600h

En la dirección virtual 46123E encontramos los bytes 8B 4E 14.
Como la Image Base es 400000, tenemos que:
46123E - 400000 = 6123E que es una dirección virtual relativa (RVA). Sabemos que la VA 46123E se encuentra dentro de la sección .text. ¿Cómo sé esto? Pues porque si miráis la tabla que puse del editor de PE tenemos que:
-La RVA del comienzo de la sección .text = 1000h
-El tamaño virtual (virtual size) de la sección .text = AF000
Por lo tanto 6123E es mayor que 1000 y menor que AF000, por esto se encuentra dentro de .text.

Sigo. Como la sección .text comienza (RVA) en 1000h tenemos que:
6123E - 1000 = 6023E que es el desplazamiento en la sección .text, por este motivo, podemos sumar 6023E al offset de inicio de la sección .text en el mismo ejecutable, así:
600h (Raw Offset) + 6023E (desplazamiento) = 6083E (offset buscado)

Veamoslo mirando un editor hexadecimal:


Viendo esto, podemos poner una fórmula general:
VA = Dirección Virtual que queremos saber dónde se encuentra en el ejecutable.
RVA (.sección) = Es la RVA del comienzo de la sección en la que se encuentra VA
Raw Offset (.sección) = Es el offset del comienzo de la sección en la que se encuentra VA.
ImageBase = Es la ImageBase


Con esta fórmula voy a hacer el último ejemplo:


VA = 4BF008 (bytes que contiene: 44 F2 4B...) Está dentro de la sección .data
RVA (.data) = B0000h
Raw Offset (.data) = AEE00h
Image Base = 400000h

4BF008 - 400000 - B0000 + AEE00 = BDE08 (offset buscado, veamos en un editor hexadecimal a ver:)


SizeofRawData: Es el tamaño de la sección en el propio archivo ejecutable.

No quiero entrar más en detalle porque nos salimos de lo que se quiere explicar en este tutorial, pero esto que se ha mostrado pienso que tiene que quedar bien claro.

1.0 Ventana de desensamblado - OllyDBG:

Esta ventana (subventana mejor dicho) está dividida a su vez en 4 columnas. Existe una barra para describir estas cuatro columnas y la podemos hacer aparecer o desaparecer pulsando el botón derecho dentro de la ventana de desensamblado (CPU) y seleccionando: Appearance --> Show bar o Appearance --> Hide bar respectivamente.
La imagen de la ventana de desensamblado con la barra descriptiva comentada es la siguiente:


1) La primera columna "Address" muestra la dirección donde se ejecutará el código.
2) La segunda columna "Hex dump" muestra los bytes que forman la instrucción que hay a la derecha (columna "Disassembly).
3) La tercera columna "Disassembly" indica el desensamblado propiamente dicho. Como ya se ha hablado antes de él, no hace falta explicar mucho más.
4) La última columna "Comment" nos puede mostrar: comentarios propios, cadenas de texto, direcciones, nombres de funciones y direcciones, datos que vamos a insertar en la pila a cierta función o API etc... que nos pueden ayudar muchísimo.

Tomemos la primera linea:
 Address             Hex dump                 Disassembly             Comment
 40125C          68 2C 14 40 00            PUSH 40142C

La dirección donde se ejecuta ese PUSH 40142C es 40125C.
Los bytes que forman la instrucción PUSH 40142C son 68 2C 14 40 00, donde Olly ha hecho el desensamblado correcto, sabiendo que 68 equivale a PUSH y 2C 14 40 00 equivale al valor: 0040142C ya que ese PUSH (68) requiere como dato 4 bytes.
Bien sencillo.

Address:
Si cliqueamos dos veces sobre esta columna veremos, cómo nos muestra o cambia de direcciones absolutas a direcciones relativas y viceversa.

Hex dump:
Si cliqueamos dos veces, lo que equivale a pulsar F2, pondremos o quitaremos un punto de ruptura, breakpoint o lugar donde el debugger parará. Se pondrá la dirección en rojo.
Para ver todos los breakpoints que hemos colocado podemos verlos en:
View --> Breakpoints o Alt+B
Podemos también modificar los bytes, copiarlos, pegarlos, convertirlos a ceros o en NOP's etc... pulsando botón derecho y seleccionando Binary y sus submenus.

Disassembly:
Si cliqueamos dos veces (o pulsamos la tecla del espacio), se abrirá una pequeña ventana en donde podremos escribir nosotros mismos la instrucción que queramos. Tiene una opción: "Fill will NOP's": Si se tilda rellenará con NOP's lo que quede de la instrucción que hemos modificado, por el contrario, si no se tilda, lo que quede de código será de nuevo ensamblado dando posibles resultados inesperados. (Yo recomiendo tildarla).
Una de las cosas que hacen más fácil escribir en ensamblador desde el propio OllyDBG, es que permite escribir instrucciones sin poner por ej. el tamaño(BYTE-WORD-DWORD). Por ejemplo, sea la siguiente instrucción:
MOV EAX,DWORD PTR DS:[400000]
Nosotros simplemente con poner MOV EAX, DS:[400000], OllyDBG ya entenderá que estamos trabajando con el registro EAX que requiere un Dword y automáticamente pondrá: MOV EAX,DWORD PTR DS:[400000].
Si nos equivocamos siempre tenemos la opción: Botón derecho -->Undo Selection para restaurar lo original.

Comment:
OllyDBG rellena adecuadamente todos los comentarios necesarios, que hacen que el código sea mucho más entendible.
Nosotros del mismo modo, podemos modificar cualquier comentario y poner lo que nosotros queramos...a fin de que sea más fácil después entender todo.
Simplemente cliqueamos dos veces sobre esa columna y aparecerá una pequeña ventana que pondrá de título: "Add comment" o "Change comment" (añadir comentario o modificar comentario). Si modificamos un comentario que tenía ya OllyDBG, podemos simplemente borrar el nuestro y automáticamente volverá a aparecer el original.
Poner un comentario propio es realmente muy útil y además nos puede ayudar posteriormente a recordar ese punto... por ejemplo, imaginemos lo siguiente:
0040100A DEC EAX, podría ser que en EAX hubiera por ej. el número de vidas y en este momento nos la disminuye en una (DEC EAX). Podríamos poner de comentario: "Quita una vida".
Si después no nos acordamos de la dirección podemos buscarla pulsando botón derecho --> Seach for --> user-defined comment y ahí veremos nuestro "Quita una vida".


La ventana de desensamblado es la más utilizada, así que hay que conocerla un poco más a fondo en su manejo, ya que es posible que tengas que estar frente a ella muchas horas...

Vamos a ver ahora la barra de herramientas, y lo relacionado con esta ventana de desensamblado. Los primeros botones que he numerado son los siguientes:


El primero (el que está debajo de la C, no lo he numerado porque sencillamente es el que abre el cuadro de diálogo para abrir un archivo). Los siguientes y por orden tienen la siguiente función:

1.- Equivale a pulsar "Ctrl+F2" o ir al menú "Debug --> restart". Reinicia de nuevo la depuración del programa. Según la configuración de OllyDBG se reiniciará y se pausará normalmente en el Entry Point (EP) del programa que vamos a debugear.
2.- Equivale a pulsar "Alt+F2" o ir al menú "Debug --> Close". Termina el programa que está siendo debugeado, pero sin cerrar el OllyDBG.
3.- Equivale a pulsar "F9" o ir al menú "Debug --> Run". Ejecuta el programa que está siendo debugeado.
4.- Equivale a pulsar "F12" o ir al menú "Debug --> Pause". Pausa al programa que está siendo debugeado.
5.- Equivale a pulsar "F7" o ir al menú "Debug --> Step Into". Hace ir al debuger instrucción por instrucción entrando en todas las call y subrutinas.
6.- Equivale a pulsar "F8" o ir al menú "Debug --> Step Over". Hace ir al debuger instrucción por instrucción pero sin entrar en ninguna call o subrutina.
7.- y 8.- No las vamos a ver en este "Cracking desde cero" porque sale de nuestras espectativas.
9.- Equivale a pulsar "Ctrl+F9" o ir al menú "Debug --> Execute till return". Tras pulsar este botón el debuger parará en el siguiente RETN que haya. Puede ser muy útil por ejemplo al entrar en una subrutina y querer buscar el final.
10.- Equivale a pulsar "Ctrl+G". En la ventana que aparece, podemos introducir la dirección, y tras aceptar, en la ventana de desensamblado podremos ver el código que hay en dicha dirección.

Tenemos muchas más opciones pulsando el botón derecho, o seleccionando en los diferentes menús. Veremos las más importantes.

Aunque para los recién iniciados sea un poco lioso recordar todo, en el siguiente apartado haremos unos sencillos ejemplos utilizando lo más básico. Veremos cómo manejarnos en la ventana de desensamblado.

Sólo para los recién iniciados en el Arte de la Ingeniería Inversa...!!

A ver si alguien (abstenerse los foreros con experiencia) se atreve a hacer un pequeño tutorial de cómo resolver el crackme1. Con 2-3 lineas sobra 

Pd. Si alguien sabe cómo resolverlo, pero no está seguro de hacer bien el tutorial o tiene dudas.... un mp.

Es muy sencillo, no podemos dejar éste sin solucionar...

Un saludo
karmany

Este tutorial ha sido realizado por karmany el 10 de noviembre de 2007 como solución al CrackME04 de x4uth. Descarga del crackme y más información en:
http://foro.elhacker.net/index.php/topic,180720.msg860578.html#msg860578


Herramientas utilizadas: OllyDBG 1.10

INTRODUCCIÓN:
Viendo que nadie más se apunta a resolverlo, y porque se me está olvidando su solución pues creo conveniente realizar el tute de este fantástico CrackMe.
La verdad que el crackme no es que sea fácil, pero veremos cómo encontrarle puntos débiles que harán que todo sea mucho más sencillo.
Si analizamos el crackme con RDG Packer Detector, nos dice que no está empacado y que ha sido compilado con Microsoft Visual C++ 6.0. x4uth es un programador y cracker con experiencia así que podemos esperar muchas maldades.


TOMA DE CONTACTO:
Lo primero que voy a hacer es analizar el crackme y a escribir las cosas más importantes que veo:
1.- Después de examinarlo y ejecutarlo con el OllyDBG, observo que termina todo en un Exit Process. Así que cierro el OllyDBG y veo que el crackme se sigue ejecutando…
Ummm. En este punto mi lógica me dice que debe de haber algún proceso ejecutándose, así que simplemente pulso Ctrl+Alt+Supr y en procesos observo que se está ejecutando uno llamado: “Crackme04.exe”… ya te tengo…
2.- El crackme pide un UserName y un Keycode, así que yo voy a buscar la solución para UserName = “karmany”.
Si introduzco un nombre-serial inválido me saldrá una nag de:
-Título: “!!!!!!!!”
-Mensaje: “Invalid KeyCode”
3.- Curiosamente, si pulso la tecla “Enter” mientras tengo el cursor en cualquier TEdit veo que el crackme se cierra… ¡Vaya!


MANOS A LA OBRA:
Como he dicho en el punto 1, hay un proceso ejecutándose así que voy a atachearlo. Ejecuto directamente el “crackme04.exe” y posteriormente abro el OllyDBG y voy a: File --> Attach y selecciono el proceso “crackme04.exe”.
OllyDBG ya me avisa abajo: “Attached process paused at ntdll.DbgBreakPoint”.
Pulso F9 para que se ejecute correctamente ya debugeado. Como se puede uno imaginar.


MI FORMA DE ALCANZAR LA "ZONA CALIENTE":
Ahora muchas formas de continuar, así que cada uno que elija o pruebe la que más le guste. Mi idea es la siguiente para este crackme:
Voy a buscar la API con la que toma el UserName y el Keycode y siguiendo el código probablemente me lleve a la zona “caliente”.
Hay varias forma de tomar los datos de un TEdit, así que con el plugin “CommandBar” pongo varios Breakpoints y después de probar unas cuantas veces descubro que lo que interesa poner en la CommandBar es lo siguiente:
“BP GetWindowTextA”.

Pongo de nombre: “karmany” y de serial “1234567890”, pulso en Verificar y efectivamente se detiene el OllyDBG en GetWindowTextA pero para poder continuar hay que pulsar “Ctrl+Atl+Supr”. Paso la función y retorno seguidamente al código aquí:
407597    MOV ECX,DWORD PTR SS:[EBP+10], que es justo después de la llamada a GetWindowTextA.

Llego hasta el RET, lo paso con F7 y llego a:
4014F7  ADD ESI,7C
En este punto ya veo que las dos CALL que aparecen obtienen: una el nombre (4014F2  CALL 00407562) que es la que acabo de pasar y la otra el serial (401501  CALL 00407562) que es la que voy a pasar ahora.
Llego hasta el RET, lo paso, vuelvo a llegar hasta el siguiente RET lo vuelvo a pasar y ya por fin caigo en el código caliente en:
4016EF   XOR EAX, EAX

Esta ha sido una forma sencilla de caer rápidamente en la zona que nos interesa.
La subrutina que hay que analizar por lo tanto:
Comienza en: 4016A0  PUSH EBP
Termina en:   402227 RETN


ANÁLISIS DE LA GRAN SUBRUTINA:
Para analizar esta gran subrutina hay que ir poco a poco entendiendo las trampas que nos ha hecho x4uth.

Tras analizarla detenidamente y traceando muchas veces por el código, podemos echar un vistazo al final y observar lo siguiente:


Ahí donde está el BP, tenemos el byte a 1 que nos registra.
Pero para que llegue a ejecutarse ese código x4uth nos ha puesto una serie de obstáculos que hay que saltar, ya que nos mandan después de MOV BYTE PTR SS:[EBP-1],1 y por lo tanto no estaremos registrados... son los JMP 004021FC

Yo en un primer momento intenté solucionarlo por Fuerza Bruta, que no voy a explicar aquí, pero me cansé de esperar tanto tiempo y ya que tenemos un buen debuger pues accedí a analizar todo el código...

Voy a estudiar los saltos:
Pongo de nombre: karmany
Pongo de serial: 12345678

401778     JE SHORT 00401793 Probando descubrí que salta cuando dejamos vacío el UserName. Así que ya sé: dejo de nombre "karmany"
401789     JE SHORT 00401793 Aún dejando el serial vacío no salta, así que como karmany no salta pues karmany me vale.
401791     JE SHORT 0040179D Tiene que saltar y salta, así que no me preocupa más.
4017C3     JE SHORT 004017CF Tiene que saltar. Se ve cómo toma los valores de mi nombre pero aún poniendo el serial vacío salta perfectamente. Sigo.
401B14     JE SHORT 00401B17 Hasta llegar aquí, ha realizado una barbaridad de operaciones, pero lo que me interesa es que hace un XOR EDX, EAX y una comparación CMP  EDX, 17. Me detuve en el XOR EDX, EAX y observé el valor de los registros: EAX = 37 y EDX = 36. Ummm parece que son los valores ASCII de mis 2 penúltimas cifras!!! O sea que XOR EAX, EDX tiene que ser 17. hay muchas combinaciones. Yo puse varias pero cuando va trascurriendo el CrackMe te das cuenta que no vale así que para no alargar voy a poner la que descubrí al final: "+<":
+ = 2B
< = 3C
XOR 2B, 3C = 17
Queda un serial ahora: "12345+<8"

Ahora nos encontramos con 4 malignos saltos. No se tienen que cumplir porque nos mandan a un RET. Toca investigar.


1º Salto.
Si me pongo en la comparación en 401F19 veo que el dato es FFFFFFF5. Así que por probar voy a ir modificando valores de mi serial y observo que ese valor (FFFFFFF5) se modifica al variar la 2ª cifra. Si pongo de serial "10345+<8" el valor cambiará a FFFFFFF3. Se puede hacer a mano pero yo hice una sencilla Fuerza Bruta y me dió el siguiente resultado: "=" (símbolo igual)
Así que queda de serial: "1=345+<8"

2º Salto.
Esta vez veo que se modifica la 1ª cifra así que descubro esta vez que es la letra "R".
Serial: R=345+<8

3º Salto.
Corresponde a la 3ª letra. Encontré que podía ser la "O".
Serial: R=O45+<8

4º Salto.
Este salto me hizo modificar los valores del XOR EDX, EAX. Por eso los cambié. Lo hice por Fuerza Bruta. Recuerdo que paró enseguida.

401FF1   JE SHORT 00401FFD Se tiene que producir. Modificando la 4ª cifra cambiaba de valor, así que descubrí: ">".
Serial: R=O>5+<8

402026     JE SHORT 00402032 Se tiene que producir. Modifiqué la 5º cifra y descubrí un valor posible: "i"
Serial: R=O>i+<8 (sale con este serial una ventana curiosa jeje)

4020B0     JE SHORT 004020BC Tiene que saltar. Y salta.

4021F2     JE SHORT 004021F8 Por fín el último salto que nos registra. Se tiene que producir. Modifico la última cifra que queda y compruebo que salta con: "p".

Serial Final: R=O>i+<p

Voy a probar el serial a ver:


Espero que a alguien le pueda ayudar.
Seguro que se puede resolver de muchas otras formas.

Un saludo
karmany

Muy bueno x4uth...y enhorabuena por resolverlo.


Primeramente Karman quisiera darte mi enhorabuena por tan expléndido CrackMe, realmente a mí me costó encontrarle el punto... Me ha gustado mucho y si no tienes paciencia no lo solucionas.

Sólo quería añadir (ahora que ya está todo resuelto) un par de cosas que he visto en el crackme y me parecen muy dignas de contar aquí. Yo lo soluciné por otro lado:
El MessageBox que aparece al pulsar "Aceptar" lo tenemos en 401FF5 y proviene de una comparación con 0E2D0.
Después de indagar bastante descubrí que Karman malignamente crea dos Threads que son los que nos complican la vida. Al final de uno de los Threads que se ejecutan (en 401859) veremos una CALL y esa CALL va a parar a un SendMessage y le da un valor sorprendente: 0E2D0!!
A partir de ahí nos manda al MessageBox.

Pues bien el puntero que carga la cadena de "chico malo" lo tenemos un poco antes de 401859 y si nos fijamos la cadena de "chico bueno" está en un puntero así definido:
Puntero a cadena "chico bueno" = puntero a cadena "chico malo" + 4

Por lo tanto el salto que nos registra o no, está en 40183B. Ese salto no se tiene que cumplir, así que si ponemos un BP en 401837, podremos ver el resultado de la comparación y el resultado tiene que dar 0.

Para mi nombre "karmany" puse el BP comentado y descubrí que si ponemos de serial 8 dígitos, pues es muy sencillo porque cada dígito modifica un valor.
Así que me costó muy poco descubrir que:
Nombre: karmany
Serial: hpiw1g1q
por ej. porque hay varias soluciones...

Un saludo
karmany

Editado después:
--He comprobado que mi serial no funciona siempre (si se pone nada más ejecutar el programa, va bien) pero como x4uth lo ha resuelto expléndidamente pues no merece que siga investigando más.

Autor: Karman
Nombre: CrackMe if you can II (Reloaded)
Fecha: 29 de octubre de 2007
Tamaño: 36,0 KB
Compilador y/o Packer: Dev-C++ 4.9.9.2 (según RDG Packer Detector)
Objetivos:
     El crackme pide Usuario-Clave
Dificultad: 4(1-10)
Descarga del crackme:
http://h1.ripway.com/karman/Files/crackme2.rar
Post Original:
http://foro.elhacker.net/index.php/topic,186201.0.html
Tutorial con la solución:
Tutorial hecho por x4uth en el mismo post original.

---

Autor: karmany
Fecha: 28 de julio de 2008
Descripción:
Un pequeño tutorial que realicé hace algunos años sobre cómo intentar proteger tu programa contra el Cracking. En mi Web trato también este tema y con el tiempo será cada vez más completo.
Enlace:
http://foro.elhacker.net/ingenieria_inversa/como_proteger_tu_programa-t222129.0.html

Muchas gracias por la colaboración.
Son interesantes y los has explicado de forma clara y sencilla.

En tutoriales he puesto el link, y ya los he guardado en mi HD.

Gracias
un saludo
karmany

Hola...
Lo primero es que pueda que tenga protecciones anti-debuger y anti-OllyDBG.
Usa el OllyDBG con plugins para ocultarlo. Utiliza el OllyDBG de Shadow que está bastante oculto.
Si aún así sigue pasando lo mismo, prueba a ocultar el proceso. Hay un programa muy bueno que lo oculta y no es detectado ni siquiera por el Themida: HideToolz.

En la configuración del OllyDBG, ¿no tendrás puesto para que pare al cargar una librería o cualquier otra configuración distinta?

Si después de todo esto no consigues hacerlo funcionar correctamente, pon un link con el archivo que le echo un vistazo a ver qué pasa.

Un saludo

Después de echarles un vistazo, voy a añadir (aunque no sean del autor de este post), estos dos crackmes ya que son muy interesantes para Newbies:
-El crackme 1 porque del (1-10) tiene de dificultad 0.
-El crackme 2 es muy interesante ya que trabaja con variables de tipo Double, y  aunque es muy sencillo, utiliza los registros de la pila (hay 8, ST0-ST1-...-ST7) y puede despistar. Incluso hay una instrucción que hace referencia a un Qword = 8 bytes.
Todo esto de las operaciones con punto flotante es muy interesante... y difícil. Este crackme nos puede ayudar a comprender un poco todo este tema.

Hay un doc muy interesante sobre este tema del punto flotante. El enlace está en el post-it de "Links Interesantes".

Bien, hasta que no nos confirme tazzmk la autoría de los crackmes, no los añadiré a la lista.