elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Curso de javascript por TickTack


  Mostrar Temas
Páginas: 1 2 3 4 5 6 [7] 8 9 10 11 12
61  Foros Generales / Sugerencias y dudas sobre el Foro / Palabra curiosa en: 10 Febrero 2009, 11:15 am
Resulta que hay una palabra que cuando se escribe en un mensaje, al visualizarla es cambiada.

La palabra es:
Código:
H a c i é n d o n o s
Sin espacios...del verbo hacer

La pongo aquí ahora literal y es "traducida" por:
Haciéndonos

Solamente es una curiosidad.
62  Media / Diseño Gráfico / Saber tamaño selección - Photoshop en: 19 Enero 2009, 23:28 pm
Photoshop CS3
Cuando se utilizar la herramienta de selección rectangular (Herramienta Marco rectangular) y seleccionamos cualquier parte en una capa, ¿Cómo puedo saber el tamaño de esa selección?
Me refiero a la anchura y altura en píxeles. Tiene que haber alguna forma.

He buscado por todos los menús y por la red y no sé cómo hacerlo.

Gracias.
63  Programación / Ingeniería Inversa / Enlaces a los crackmes... en breve en: 1 Enero 2009, 22:39 pm
Como habéis comentado alguno, varios de los enlaces a los crackmes ya no existen y por la red tampoco están.

No os preocupéis porque como tenemos varias copias de seguridad  ;D en breve los subiremos a algún sitio donde puedan permanecer algún tiempo más.

Un saludo

PD. Hablo de los crackmes de esta sección:
Crackmes y tutoriales
64  Programación / Ingeniería Inversa / Tutorial Crackme MadCrack v1 por karmany en: 30 Diciembre 2008, 01:53 am
INTRODUCCIÓN

Hace unos meses, MadAntrax hizo un crackme curioso, en el que el registro se hacía mediante un keyfile. Como nadie más parece haberse interesando en él, publico ya el tutorial que hice entonces.

Dicho autor es moderador del subforo de Visual Basic y yo he descargado varias de sus colaboraciones, con lo que ya me imaginaba que este crackme iba tener bastante complejidad.

El crackme está compilado con Visual Basic en P-Code, así que este tutorial puede resultar de utilidad para saber analizarlos.
El post original de este crackme es el siguiente:
http://foro.elhacker.net/ingenieria_inversa/madcrack_crackme_v1_by_madantrax-t225985.0.html



TUTORIAL

La verdad que los programas compilados en Visual Basic con P-Code suelen ser más difíciles de analizar. Voy a mostrar cómo examiné este primer crackme de MadAntrax y seguro que para muchos P-Code puede ayudar.

Si utilizamos RDG Packer Detector 0.65 vemos que está empacado con UPX y nos muestra que ha sido compilado con Visual Basic. Si se ejecuta el crackme vemos que aparece un archivo oculto llamado "iexplore.exe" y tenemos un cuadrado de color rojo que para que esté crackeado tiene que estár de color verde, según el autor.

Descompilar UPX es sencillo y en Crackmes y tutoriales hay un link de cómo descomprimir UPX para ReNewbies, realizado por Shaddy.

Yo descomprimí UPX pero al ejecutarlo ví que el archivo "iexplore.exe"(que no le gusta OllyDBG) no aparece y algunas cosas más que no voy a comentar, así que debe de hacer algo el crackme para saber que ha sido descomprimido. Por este motivo sólo debuggeé el crackme directamente desde OllyDBG con un simple plugin para ocultarlo. El OEP es muy sencillo de descubrir: 401130

Por otro lado, como ya tengo el crackme descomprimido con UPX, lo analicé con P32Dasm v2.3 y lo desensambla perfectamente, y se obtiene muchísima información:

Código:
VB6 Aplicación detectada ... PCode

Form1 Eventos:
2. splet
3. lel
6. crypt
8. Check_KeyFile

clsCRC Eventos:
2. AddBytes
3. AddString
4. Algorithm
5. Algorithm
6. CalculateBytes
7. CalculateFile
8. CalculateString
9. Value
10. Value
12. Clear

El autor nos deja mucha información.
Hay muchas cosas interesantes, por ej.
Código:
00003DE3:  0D   VCallHresult App.Get_Path()
...
00003DEB:  1B   LitStr: "edocyek\"
00003DEE:  0B   ImpAdCallI2 StrReverse()
...
00003DF6:  2A   ConcatStr

Es muy fácil de entender. Primero toma la ruta del crackme. Después de una cadena "edocyek\" hace la inversa (StrReverse) obteniendo "\keycode" y lo une a la ruta. Después con ese archivo hace unas determinadas operaciones y finalmente tenemos un salto (BranchF) que nos pone el cuadrado rojo o verde.

La dificultad de P-Code es que se trabaja con opcodes y puede resultar muy lioso pero con un poco de práctica se entiende todo fácilmente.

Voy a hacer un ejemplo. La subrutina que nos interesa es la que nos pone el cuadrado verde o rojo. Esta subrutina es la Form1 1.8 (Check_KeyFile-->nombre muy llamativo jeje) y comienza en 00003DA0.
He mostrado que nos da la ruta de un archivo denominado "keycode". Y después de esto viene lo más difícil, aparece lo siguiente:

Código:
00003E3A:  1B   LitStr: "edocyek\"
00003E3D:  0B   ImpAdCallI2 StrReverse()
00003E42:  23   FStStrNoPop var_D0
00003E45:  2A   ConcatStr
00003E46:  46   CVarStr var_B4
00003E49:  25   PopAdLdVar
00003E4A:  04   FLdRfVar var_A4
00003E4D:  FF3E VarLateMemCallLdRfVar
00003E55:  04   FLdRfVar var_100
00003E58:  0A   ImpAdCallFPR4 Hex()

Lo más difícil es saber qué hace la función VarLateMemCallLdRfVar. Ni P32Dasm ni VB Decompiler nos da información, así que tiene que ser OllyDBG quién nos tenga que ayudar.
Como se observa, la función comienza por los opcodes FF3E y está en el offset 3E4D. Voy a cargar el crackme original en el OllyDBG.
Como el OEP es 401130 pongo un Hardware Breakpoint allí y pulso F9. Ahora estoy parado en el OEP.
Ahora tengo que parar antes de VarLateMemCallLdRfVar que está en 3ED4, por lo tanto como la image base está en 400000 pues la dirección final es 403ED4.
Parado en el OEP, voy a la ventana de dump, botón derecho goto --> 403ED4 (ahí tienes que ver ya los bytes FF 3E) y pongo un Breakpoint --> memory on access. Pulso F9 y se detiene en un

MOV AL,BYTE PTR DS:[ESI+2]

que está dentro de MSVBVM60.dll. Estamos justo antes de la llamada a VarLateMemCallLdRfVar.

Ahora simplemente hay que ir traceando con F7 hasta llegar a una Call ... y si miramos la pila observaremos algo parecido a esto:

Código:
0013F7EC   00402694  UNICODE "CalculateFile"
0013F7F0   00000001
0013F7F4   0013F804
0013F7F8   80000003
0013F7FC   0013F8D4
0013F800   0013F920
0013F804   00000008
0013F808   00000000
0013F80C   00174EF4  UNICODE "C:\Documents and Settings\usuario\Escritorio\keycode"

Como se observa, la función a la que hace referencia es a "CalculateFile"

Ya he mostrado cómo acceder desde el OllyDBG a cualquier opcode que nos muestre VB Decompiler Lite, así que cada uno ya puede examinar el código que quiera. Se pierde bastante tiempo sabiendo lo que hace cada cosa... también me ha costado a mi.

Si vamos ahora a VB Decompiler veremos que "CalculateFile" llama a la subrutina "CalculateBytes" y ésta última a su vez llama a la subrutina "AddBytes", que es la importante que interesa.

Ésta (AddBytes) tiene una función muy conocida y muy curiosa:

loc_4039A9: ImpAdCallFPR4 CallWindowProc(%x1, %x2, %x3, %x4, %x5)

A la que se le pasan 5 parámetros.
Ya sabéis parar antes de esta CallWindowProc, así que vamos a hacerlo.

Cuando estéis ahí, poner un BP en CallWindowProcA, F9 y mirar la pila:
Código:
0013EAB4   660FD37B  /CALL to CallWindowProcA from MSVBVM60.660FD379
0013EAB8   0016E130  |PrevProc = 0016E130
0013EABC   00160628  |hWnd = 00160628
0013EAC0   00174E58  |Message = MSG(174E58)
0013EAC4   00176C48  |wParam = 176C48
0013EAC8   00000004  \lParam = 4

Hay que observar ese interesante PrevProc = 0016E130, así que vamos en la ventana de desensamblado a esa dirección y nos encontramos con lo siguiente:

Código:
0016E130    55              PUSH EBP
0016E131    89E5            MOV EBP,ESP
0016E133    57              PUSH EDI
0016E134    56              PUSH ESI
0016E135    50              PUSH EAX
0016E136    53              PUSH EBX
0016E137    51              PUSH ECX
0016E138    8B45 08         MOV EAX,DWORD PTR SS:[EBP+8]
0016E13B    8B00            MOV EAX,DWORD PTR DS:[EAX]
0016E13D    8B75 0C         MOV ESI,DWORD PTR SS:[EBP+C]
0016E140    8B7D 10         MOV EDI,DWORD PTR SS:[EBP+10]
0016E143    8B4D 14         MOV ECX,DWORD PTR SS:[EBP+14]
0016E146    31DB            XOR EBX,EBX
0016E148    8A1E            MOV BL,BYTE PTR DS:[ESI]
0016E14A    30C3            XOR BL,AL
0016E14C    C1E8 08         SHR EAX,8
0016E14F    33049F          XOR EAX,DWORD PTR DS:[EDI+EBX*4]
0016E152    46              INC ESI
0016E153    49              DEC ECX
0016E154  ^ 75 F2           JNZ SHORT 0016E148
0016E156    8B4D 08         MOV ECX,DWORD PTR SS:[EBP+8]
0016E159    8901            MOV DWORD PTR DS:[ECX],EAX
0016E15B    59              POP ECX
0016E15C    5B              POP EBX
0016E15D    58              POP EAX
0016E15E    5E              POP ESI
0016E15F    5F              POP EDI
0016E160    89EC            MOV ESP,EBP
0016E162    5D              POP EBP
0016E163    C2 1000         RETN 10

Éste es todo el código que utiliza para obtener un CRC del archivo "keycode". Después hace ya una última operación que es un NOT.

¿Y con qué se compara?
Bueno, es también bien fácil...

Subrutina Check_KeyFile
...
Código:
00003E7D:  3A   LitVarStr: "2@G855G"
00003E82:  4E   FStVarCopyObj var_B4
00003E85:  04   FLdRfVar var_B4
00003E88:  10   ThisVCallHresult --> %x2 = crypt(%x1) ;aquí está el truco
00003E8D:  04   FLdRfVar var_F0
00003E90:  FB33 EqVarBool =
00003E92:  36   FFreeVar var_B4 var_F0
00003E99:  1C   BranchF   00003EAA

Con toda esta explicación pienso que ya están destripadas las entrañas del crackme, espero que se entienda.
Yo a partir de este momento creé un programa en ensamblador que fuera examinando CRC's y descubrí que si el archivo keycode tiene los siguientes caracteres: "4R)@" queda el cuadrado perfectamente de color verde... objetivo logrado.


Un saludo
karmany
09 - septiembre - 2008






65  Programación / Ingeniería Inversa / Windows API Reference en: 12 Diciembre 2008, 10:37 am
API: Interfaz de Programación de Aplicaciones

http://es.wikipedia.org/wiki/API_de_Windows:
La Interfaz de Programación de Aplicaciones, cuyo acrónimo en inglés es API (Application Programming Interface), es un conjunto de funciones residentes en bibliotecas (generalmente dinámicas, también llamadas DLLs por sus siglas en inglés) que permiten que una aplicación corra bajo el sistema operativo Windows.

Realmente son muy útiles y hacen que el trabajo del programador sea muchísimo más sencillo.
Desde el punto de vista de Ingeniería Inversa, nos puede mostrar información muy importante sobre lo que una aplicación está ejecutando. Por ejemplo, si una aplicación nos muestra un mensaje de advertencia, es muy posible que la API utilizada sea MessageBox.

Existen muchísimas API en Windows y gran cantidad también que están poco o casi nada documentadas, por este motivo, si no conocemos alguna en especial, tendremos que buscar simplemente en Internet.

Para todo programador o persona que depura aplicaciones, existen ayudas para conocer el funcionamiento de determinadas API, así simplemente abrimos el archivo de ayuda, buscamos la API en cuestión y vemos rápidamente los valores y datos que admite y el resultado que nos devolverá.
Podemos descargar este archivo desde aquí:
WinAPI32

Shaddy subió a su Web otro archivo que puede contener alguna API diferente:
http://shaddy.co.nr/win32.rar

Y finalmente y pienso que es la mejor guía, tenemos la que nos ofrece Microsoft:
http://msdn.microsoft.com/en-us/library/aa383749%28VS.85%29.aspx

Un saludo
66  Programación / Ingeniería Inversa / Se borrarán los post alusivos a programas comerciales en: 6 Noviembre 2008, 07:59 am
A partir de este momento, vamos a ser más serios y vamos a vigilar con más detalle que no se abran posts hablando de alguna aplicación comercial. Asimismo no se permitirá tampoco insertar imágenes reales de dicha aplicación.

En Ingeniería Inversa queremos mostrar las entrañas de cada software, pero siempre respetando las leyes. Nunca hemos subido ningún crack a la red y seguiremos luchando por este camino contra toda ilegalidad.

Si alguien incumple esta norma, es muy posible que dicho post sea eliminado.

Un saludo
67  Programación / Ingeniería Inversa / Cómo proteger tu programa en: 28 Julio 2008, 11:54 am
PRÓLOGO

Después de recibir varias consultas sobre este tema, hemos decicido abrir este nuevo post, dando a conocer principalmente a los programadores los distintos sistemas para proteger sus aplicaciones:

-Protecciones que pueden implementar ellos mismos en sus programas...
-Programas gratuitos que pueden utilizar para empaquetar sus aplicaciones
-Programas de pago..
-Consejos...

Nosotros sabemos que a una persona con buenos conocimientos, cualquier protección le es indiferente, porque no hay nada infalible, pero vamos a mostrar las distintas formas que conocemos.

¿Por qué abrimos este post? Pues porque la gente que diariamente trabaja con Ingeniería Inversa es la gente que se enfrenta con las protecciones actuales y sabe cuáles son las más difíciles (que no imposibles) y cuáles puede aconsejar...

Un saludo y esperamos que os pueda servir de guía antes de decidiros por una u otra opción...





INTRODUCCIÓN

Varias de las preocupaciones de un programador a la hora de distribuir su aplicación pueden ser:

-Disminuir el tamaño de la misma todo lo posible
-Crear licencias para usuarios registrados
-Crear versión DEMO
-Proteger la aplicación para que no sean usadas licencias ilícitas

         

Primeramente, y antes de todo, hay que comentar unos detalles que todo programador debe saber:
-Ningún programa es incrackeable.
-Hay protecciones fáciles,...., difíciles, ...., muy difíciles y muy muy difíciles, pero no imposibles.
-Muchos programadores piensan que por no tener el código fuente, al cracker le va a resultar más complicado estudiar la aplicación. Ya les puedo asegurar a todos los que piensen así: que se equivocan al 100%. Si analizaramos cualquier programa compilado con cualquier lenguaje de programación, llegaríamos a ver secuencias de 0 y 1 que el procesador entiende directamente. Pero existen muchos programas denominados desensambladores que lo que hacen es convertir esa secuencia de 0 y 1 en código ensamblador. El cracker domina este lenguaje.
-A parte de la ayuda que es un desensamblador, se unen los debugger que son herramientas para la depuración del código. Estos debuggers a día de hoy, están muy desarrollados y les puedo asegurar que su aplicación será incapaz de detectarlos.
-Las personas que comienzan su andadura por el mundo de la Ingeniería Inversa son denominadas Newbies. Y no hay que subestimar a nadie.
-Existen en la actualidad muchísimos programas para proteger y/o reducir tu aplicacion, estos programas se denominan empacadores, empaquetadores o en inglés packers.
-En este tutorial vamos a hablar principalmente de aplicaciones a 32 bits en ejecutadas en Microsoft Windows.

Después de todo esto seguro que ya sabrás que tienes dos opciones:
    -Implementar tú mismo la protección en tu aplicación
    -Utilizar uno de los muchos empacadores que existen


Implementar uno mismo la protección:
Como ya se puede uno imaginar, hay que crear licencias y una versión demo. Es realmente una labor un tanto costosa, pero con toda la información que hay en Internet seguro que puedes conseguir una base para comenzar. Hay muchas personas que ya tienen el código fuente preparado para distintos software y lo que hacen es modificar ciertos parámetros y así los nombre-contraseña también son diferentes.

Utilizar un packer:
La utilización de estos programas tiene una gran ventaja: que en la mayoría de ellos se pueden ya crear licencias, versiones demo, protecciones contra desensamblados/debuggers, e incluso la disminución del tamaño de la aplicación consideramente.
Por contra, si quieres crear una aplicación comercial, en la mayoría de ellos deberás comprar el producto, lo que requiere que tu aplicación aumente también de precio.
También se debe tener en cuenta que los packers que hace unos años eran muy complicados, actualmente han sido analizados hasta su último bit y gente Newbie es capaz incluso de enfrentarse a este tipo de protecciones. Pero todo esto lo veremos con más detenimiento después.

Hablaremos un poco de los métodos anti debugger/desensambladores
68  Programación / Ingeniería Inversa / ResCode Imagen v2.0.4 en: 15 Mayo 2008, 10:16 am
Después de un largo tiempo he conseguido actualizar este programa que estoy desarrollando. Alguno ya me pidió su ampliación.
El archivo ayuda tiene todo bien explicado.

ResCode Imagen es un programa de ayuda a los Editores de Recursos para poder añadir o modificar imágenes (gráficos) a programas que hayan sido compilados en Delphi o Borland C++.

Sé que todavía quedan bastantes cosas por añadir...

Bueno espero que a alguien le sirva.
Y todas las críticas, sean buenas o malas serán bienvenidas.

Un saludo.

DESCARGA:
(Gracias a Ricardo Narvaja):
ResCode Imagen v.2.0.4

karmany
69  Programación / Ingeniería Inversa / Problemas en el host de imágenes Pic2Up.net en: 22 Febrero 2008, 16:01 pm
Parece ser que desde hace ya unos días, la página http://www.pic2up.net/ está sufriendo algún tipo de problema y no permite ver las imágenes alojadas en el host.

Esto también es un problema para nuestro foro, ya que muchas imágenes fueron alojadas en dicho host y no se pueden ver.

Esperaremos un tiempo prudente a ver si se solucionan estos problemas y aparecen de nuevo las imágenes, si no, buscaré un nuevo host y poco a poco iré subiendo de nuevo todas las imágenes que tengo guardadas..

Un saludo
karmany
70  Programación / Ingeniería Inversa / Tutorial Crackme04 de x4uth por karmany en: 10 Noviembre 2007, 19:14 pm
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


TUTE ‘Crackme04 de x4uth’ por karmany

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
Páginas: 1 2 3 4 5 6 [7] 8 9 10 11 12
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines