Parcheado Elegante v1.1
por
ArthaXerxès de Central (Traducido por X-Grimator)


0.Información legal

Es mejor para todo el mundo si se indica claramente.

0.1.Garantía


Toda la información del tutorial de Parcheado Elegante se suministra "tal cual" sin garantía expresa o implícita, incluyendo, pero no restringiéndose a, el mercantilismo y a la conveniencia para cualquier propósito. Central y ArthaXerxès no se responsabilizan por cualquier tipo de daño directo o indirecto resultante del uso de la información contenida en el tutorial de Parcheado Elegante, incluso si el daño es resultado de defectos e incluso si el autor había sido avisado de la posibilidad de tal daño.
Central y ArthaXerxès incluso no asumen ninguna responsabilidad por ningún tipo de uso ilegal de la información suministrada.


0.2.Distribución

El tutorial de Parcheado Elegante es (por supuesto) gratis. Cualquiera puede distribuir el tutorial de Parcheado Elegante libremente en tanto en cuanto no se modifique de ninguna forma.
Para cualquier tipo de reproducción en un medio diferente, debería entrarse en contacto con Central o ArthaXerxès.


0.3.Condiciones de uso

Cualquier uso comercial, o más genéricamente hablando, cualquier uso que pueda generar beneficio, está estrictamente prohibido sin una autorización explícita y previa de Central y ArthaXerxès.
Cualquiera puede reutilizar partes del tutorial de Parcheado Elegante si en los créditos se menciona ArthaXerxès y Central con la correspondientes direcciones de URL y e-mail.


0.4.Créditos y agradecimientos


Créditos :

Agradecimientos:

  • HarverstR por distribuir mi tutorial.
  • Number 6 por la idea del objetivo.
  • Simple Nomad del NMRC por la respuesta.


1.Introducción


Es bastante útil saber cómo parchear un programa así como modificar la forma de comportarse. A mi parecer es importante para los hackers medios tener un mínimo conocimiento de ingeniería inversa y ser capaces de modificar la conducta de un programa. Esto puede ser usado para crear un troyano (por ejemplo alterando un programa de registro para grabar la clave introducida), o añadir opciones a un programa.

Añadir opciones a un programa es demasiado duro para empezar, y no veo apropiado enseñaros cómo convertir programas en troyanos. :-) Así, en este "tutorial", os mostraré, como ejemplo, cómo podéis quitar protecciones de un programa. Tened en mente que es ilegal quitar protecciones de un programa y usarlo luego si no sois los usuarios legítimos.

Estoy bastante seguro de que al autor del programa que vamos a crackear no le gustará, pero no hay nada personal en ello: precisamente voy a mostraros cómo "crackear" el programa, para que en el futuro seáis capaces de quitar otros tipos de protección en los programas.

Para tener ventaja completa en este tutorial, necesitáis un buen conocimiento del lenguaje ensamblador y un conocimiento correcto de Windows. La mejor forma de usar este tutorial es leer un capítulo, intentar hacer lo que se describe, y si no entendéis algo, leerlo de nuevo.


2.Parcheado elegante con un ejemplo


Elegí Awave 4.9 desde el momento en el que este programa incluye algunas rutinas de protección avanzadas para prevenir el crackeo, e incluso porque no he visto ningún trabajo completo de crackeo para él (para ser sincero, porque no uso este tipo de programas generalmente).

2.1.Llendo de reconocimiento

Antes de hacer cualquier cosa, debemos determinar qué vamos a hacer. :-)

Regla 1 : Nunca actuar con prisa.

Ejecutemos el programa. Comienza con una nag screen de tiempo. Ahora puedo acceder al programa, pero algunas opciones están inutilizadas; de momento nada fuera de lo ordinario.
Veamos cómo podemos registrarnos. Comprobemos el menú de "opciones", hay un diálogo de "setup del programa". Ah, hay un botón de "registro", presionémoslo. Hum, misterioso, el programa pide un "archivo llave", no hay ventana de diálogo aquí. La suerte es que va a ser más fácil quitar la nag screen y "desinutilizar" las opciones que entender cómo debe ser el archivo llave.


Regla 2 : Primero, elegir el camino más sencillo.

Recordad que deseamos desbloquear este programa, y en este punto, parece que el camino más fácil para hacerlo es quitar directamente los controles que previenen la ejecución de algunas opciones.

2.2.Empaquetando

Antes de que vayamos a crackear, necesitamos comprobar si tenéis todas las cosas para hacerlo correctamente.
En teoría, realmente no sabéis de entrada qué necesitaréis, puede ser que tengáis que expandir y/o descifrar el ejecutable, puede ser que necesitéis dumpear la memoria, etc...

Aquí, necesitaréis:
  • Un buen debugger
  • Un buen desensamblador
  • Un editor hexa que pueda contar lo ocurrido con una cadena, preferiblemente uno que funcione bajo windows.
  • Papel
  • Un lápiz

Las dos últimas cosas son muy importantes. Si no apuntáis lo que estáis haciendo, no seréis capaces de trabajar eficientemente. No os diré qué debéis anotar, o qué no debéis anotar, haced como deseéis, pero es mejor anotar demasiado que no lo suficiente.

En este tutorial, consideraré que vuestro debugger es Softice y que vuestro desensamblador es Win32dasm, porque yo usé ambos para crackear Awave.

nota avanzada : IDA podría haber sido una elección mejor aquí, pues el autor usó técnicas para esconder partes del código, y Win32dasm es muy vulnerable a esas técnicas. De todos modos Win32dasm es más fácil de usar, y quise que mi tutorial  quedase fácil de entender.

2.3.Primer contacto

Regla 3 : Conocer al enemigo mejor de lo que él se conoce a sí mismo.

La primera cosa que hay que hacer es desensamblar awave.exe, necesitamos ver cómo está hecho. La segunda cosa que hay que hacer es guardar el texto desensamblado, para evitarnos desensamblarlo más tarde.

Parece que hemos comenzado bien pues si miramos el texto desensamblado, no parece que Awave esté empaquetado o cifrado. Esto es bueno, seremos capaces de trabajar en un programa limpio, pues la expansión manual o descifrado pueden producir programas inestables.

Pienso que la primera cosa lógica por hacer es quitar la nag screen. Para hacerlo, debemos llegar a la cadena "About Awave", este es el título de la nag screen.

Win32dasm nos apunta esta parte del código :


* Possible StringData Ref from Data Obj ->"About - Awave v4.9"
|
:004036D5 C7459C60CA4700 mov [ebp-64], 0047CA60
:004036DC 8955A8 mov dword ptr [ebp-58], edx
:004036DF C745A002000000 mov [ebp-60], 00000002
:004036E6 51 push ecx

Suponemos que la comprobación se hace antes de ver si es la versión registrada, y si no es el caso la nag screen se muestra.
Y mientras subimos un poco, encontramos esto:


:00403660 E8A2480000 call 00407F07
:00403665 84C0 test al, al
:00403667 0F8494000000 je 00403701
 

Así que, si la función 407F07 devuelve un 1, el programa salta a 403701, evitando la nag screen. La primera cosa que podéis pensar de esto es reemplazar el "je 403701" por un "jmp 403701".
Pero, hay otras partes del programa que están inutilizadas, así que si modificáis la función 407F07 de forma que siempre devuelva un 1, no tendréis que modificar todos los chequeos en el programa, y será muchísimo más elegante.


Regla 4 : Evitar la fuerza bruta.

Primero, debemos echar un vistazo a esta función. Vemos que es llamada cinco veces. Es importante determinar qué hace el programa en esas direcciones.

Ahora, estamos bastantes seguros de que esa función es llamada para determinar si el programa ha sido registrado o no. ¿Cómo podemos hacer que 407F07 devuelva un 1 todas las veces?.

Esto es fácil, cambiad el código de la función por:


xor eax, eax
inc eax
ret 0004
 

Notad que usamos ret 0004 y no ret porque esta es la forma en que las funciones original retornan, y haciendo un ret se colgará el programa. No tenéis que reemplazar el código después del ret 0004 que hicimos con un "nop", nunca será ejecutado.
Incluso siempre intentamos trabajar a nivel de registro para evitar interferencias con la memoria. (en este caso no habría sido un problema).

Copiad el archivo protegido.exe a crack1.exe, y buscad en el último archivo los bytes correspondientes a la función que deseamos parchear. Un modo elegante de buscarla es contar los eventos ocurridos en vuestra cadena de búsqueda y sumar todos los bytes posibles para tener sólo un resultado.

En nuestro caso la cadena a buscar es: "55 8b ec 53 56 57 8b 5d 08 8d bb e8 0a 00 00 57 8d b3 a3 0a 00 00 56 e8 41".


nota avanzada: Veréis más tarde que hay una segunda función de protección que se asemeja mucho, esto es el porqué de que tengamos que añadir bytes.

Ahora deberíais estar al principio de la cadena. Introducid los bytes: "31 c0 40 c2 04 00" correspondientes a nuestro nuevo código. Para obtener los bytes correspondientes a nuestro nuevo código, podéis usar softice o win32dasm, ambos tienen un ensamblador incorporado.

Es el momento de ejecutar crack1.exe y ver qué tenemos, de momento no ha sido realmente duro.

Como esperábamos, la nag screen desapareció, y nosotros tenemos una alternativa con la pantalla que está siendo mostrada. Podemos abrir un archivo, pero el tiempo de caducidad no ha sido quitado. Otro punto problemático es que cuando escogemos "Setup del Programa" en el menú de "opciones", el programa se cierra.


Rule 5 : Que parezca ser fácil, no significa que lo sea.

2.4.De profundis

La primera cosa en la que hay que fijarse es eso de "setup del programa". Mi primera idea fue que el programa se colgaba porque la función devolvía un 1 visto que el programa no está realmente registrado. Descubrí luego que de hecho era una rutina de protección.

nota avanzada : Win32dasm no nos muestra esta rutina de protección. Puesto que lo estamos usando, emplearemos un modo menos elegante de quitar la protección.

Debemos mirar con más profundidad el código que está en torno a las llamadas de la función 407F07. En la dirección 406CF8, vemos :

:00406CF8 E80A120000 call 00407F07
:00406CFD 84C0 test al, al
:00406CFF 743D je 00406D3E
:00406D01 8BC3 mov eax, ebx
:00406D03 681EE44700 push 0047E41E
:00406D08 6A00 push 00000000
:00406D0A 6A0C push 0000000C

* Possible Reference to Dialog: DialogID_003C, CONTROL_ID:01F4, "Unregistered"
|
:00406D0C 68F4010000 push 000001F4
:00406D11 50 push eax

* Reference To: USER32.SendDlgItemMessageA, Ord:0000h
|
:00406D12 E84D420700 Call 0047AF64
:00406D17 8BC3 mov eax, ebx

* Possible StringData Ref from Data Obj ->"Registered!"
|
:00406D19 682AF04700 push 0047F02A
:00406D1E 6A00 push 00000000
:00406D20 6A0C push 0000000C

* Possible Reference to Dialog: DialogID_0022, CONTROL_ID:01F5, "Unregistered version"
|
:00406D22 68F5010000 push 000001F5
:00406D27 50 push eax
 

Aquí, el programa salta a 406D3E si la función devuelve un 0. Así que en nuestro caso, no estamos saltando a esta dirección. ¿Qué ocurriría si cambiásemos el salto condicional por un salto incondicional?.

Regla 6 : El único modo de encontrar la verdad es experimentar.

Copiad el programa crack1.exe a crack2.exe, y buscad la cadena "74 3D 8B C3". Al principio de la cadena, escribid "EB". El "je" es ahora un "jmp". Para buscar la cadena, usad el mismo método que usamos para evitar errores.

Ahora, cuando ejecutemos crack2.exe, veremos que el programa no se cierra nunca más cuando accedemos al setup. Muestra "unregistered" en la licencia, esto no es un problema en absoluto, no nos preocuparemos si el programa muestra "unregistered" o no, únicamente queremos quitar las limitaciones y las nag screen.


Rule 7 : Proceder con método.

Ahora tenemos que ver dónde están las otras comprobaciones, especialmente el límite por tiempo. Una buena idea es buscar en Win32Dasm la cadena "Sorry, this command is not supported...". Estamos apuntando a esta pieza de código :

* Possible StringData Ref from Data Obj ->"Sorry, this command is not supported "
->"in the *unregistered* version!"
|
:00404E5F BEF9D74700 mov esi, 0047D7F9
:00404E64 BF44F54700 mov edi, 0047F544
:00404E69 8BC7 mov eax, edi
:00404E6B B91A000000 mov ecx, 0000001A
:00404E70 F3 repz
:00404E71 A5 movsd
:00404E72 A4 movsb
:00404E73 33C0 xor eax, eax
:00404E75 E94D020000 jmp 004050C7

Si subimos un poco, encontramos :

:00404E46 E873300000 call 00407EBE
:00404E4B 84C0 test al, al
:00404E4D 742B je 00404E7A

¿Es eso otra función de comprobación?. Se llama a la función 407EBE, y si devuelve un 0, saltamos a 404E7A ejecutando de este modo el comando.

¿Podría 407EBE ser otra función de comprobación de registro ? El único modo de estar seguro, es echar un vistazo a esta función.

Vemos que esta función es llamada muchas más veces que 407F07, pero parece la misma, excepto que 407F07 devuelve un 1 cuando el programa está registrado y que 407EBE devuelve un 0 cuando es el caso.

Así, haremos lo mismo que para 407F07, excepto que nuestro código será esta vez:

xor eax, eax
ret 0004

Copiad crack2.exe a crack3.exe y buscad la cadena : "55 8b ec 53 56 57 8b 5d 08 8d bb e8 0a 00 00 57 8d b3 a3 0a 00 00 56 e8 8a" y escribid : "31 c0 c2 04 00".

Es el momento de ejecutar crack3.exe, todo parece trabajar correctamente... Y ahora no tenemos ninguna pantalla al inicio, lo cual es realmente bueno. Intentemos abrir un archivo.


Regla 8 : Tomarse el tiempo necesario para probar los programas parcheados.

¡¿Qué?! ¡El programa se cerró ! Debe haber otra comprobación hecha. O... No fue una buena idea en este caso reemplazar la función de comprobación con otra que siempre devuelva un 0.

Para comprobar esta teoría, husmearemos alrededor de las llamadas de la función 407EBE. Borrad crack3.exe, necesitamos trabajar con crack2.exe (deseamos que vuelva el viejo 407EBE).

Regla 9 : A veces, la fuerza bruta es necesaria.

Hay 13 llamadas a la función 407EBE, pero no necesitamos modificar el código que está alrededor de ellos.

:004012AC E80D6C0000 call 00407EBE
:004012B1 0FBED8 movsx ebx, al
:004012B4 C70730000000 mov dword ptr [edi], 00000030
:004012BA 33C0 xor eax, eax

La primera llamada parece rara, y no la modificaremos.

:00401894 E825660000 call 00407EBE
:00401899 84C0 test al, al
:0040189B 740B je 004018A8
:0040189D FF356CC34700 push dword ptr [0047C36C]
:004018A3 E8A71D0000 call 0040364F

La segunda llamada parece estar referida a la nag screen del inicio, pues la función 40364F despliega la pantalla de "acerca".
Entonces cambiaremos "je 4018A8" a "jmp 4018A8". Os permitiré hacer los cambios en crack3.exe, ahora deberíais saber cómo hacerlo.

:00402435 E8845A0000 call 00407EBE
:0040243A 84C0 test al, al
:0040243C 7412 je 00402450
:0040243E 6A00 push 00000000

* Possible StringData Ref from Data Obj ->"Unregistered"
|
:00402440 68EBC64700 push 0047C6EB
:00402445 8B55EC mov edx, dword ptr [ebp-14]
:00402448 52 push edx
:00402449 8B0A mov ecx, dword ptr [edx]
:0040244B FF510C call [ecx+0C]
:0040244E EB2B jmp 0040247B

La tercera llamada determina qué debería mostrarse en la ventana principal, "registrado o no". Como podéis adivinar, no lo modificaremos por dos razones:
- queremos modificar el mínimo de datos
- no nos preocupa que se muestre "Unregistered"

:0040300A E8AF4E0000 call 00407EBE
:0040300F 84C0 test al, al
:00403011 7414 je 00403027
* Possible StringData Ref from Data Obj ->"Function not available in the "
->"unregistered version!"
|
:00403013 6886C74700 push 0047C786

Es obvio que debemos cambiar la cuarta llamada. Cambiad "je 403027" a "jmp 403027".
Para todas las otras llamadas haced lo mismo, excepto para la llamada 11ª (4055C3 para mí), que no es útil cambiarla. (registration info) Generalmente sólo tendréis que reemplazar "74" por "EB" para hacer el salto incondicional.

Notad que para 6º llamada (403A35 para mí), tendréis que reemplazar : "0f 84 c3 00 00 00" por "e9 c4 00 00 00 90".

Regla 10 : Las instrucciones parcheadas deben tener el mismo tamaño que las originales.

Esto es porque en este caso el salto es un poco diferente pues se codifica en más bytes, cuando los cambiamos a uno incondicional, la instrucción coge un byte menos así que debemos añadir un "nop" (90) al final.

Vemos que ahora todo trabaja correctamente, verdaderamente había una llamada escondida en la función 407EBE que se comprobaba a ver si se comportaba correctamente. Win32dasm no era capaz de mostrárnoslo, debido al modo en que desensambla los programas.


Regla 11 : Las cosas pueden ser peores de lo que parece.

Pero recordad la regla 8, debemos comprobar el programa unos minutos para ver si está realmente parcheado. Carguemos algunos ejemplos, miremos las preferencias, etc. Misteriosamente, el programa se cierra a pesar de que yo no estaba haciendo nada. Puede ser que parcheásemos algo indebido...

2.5.Ser inteligentes

Regla 12 : Tener buenas herramientas es importante, saber cómo usarlas es bastante más importante.

Veamos la situación. El programa parece estar absolutamente desempaquetado y las nag screen se han quitado, pero continúa cerrándose. Win32dasm fue muy útil, pero ahora necesitamos Softice porque vamos a debuguear Awave y porque Win32dasm no es bueno cuando hay que tracear.

Hay varias soluciones :
  • el programa se cierra cuando se hace una operación particular o aleatoria.
  • el programa cuenta el número de clicks que hacemos y se cierra tras un número fijo o aleatorio de veces.
  • el programa mide la distancia que hizo el ratón y se cierra cuando se alcanza una distancia fija o aleatoria.
  • el programa se cierra después de una cantidad fija o aleatoria de tiempo.

Por supuesto que hay otras soluciones, pero esas son las más usadas.

Debemos determinar cuál se usa. Para hacerlo, ejecutaremos Awave y esperamos que el programa se cierre mientras no hacemos nada excepto esperar.

Awave se cerró, así que ciertamente es el cuarto método el usado. He cronometrado la salida y he deteminado que es de unos 45s. Esto es una rutina de protección, no hay duda sobre eso. Parece que el autor de Awave nos quiere. :-)

Ahora, ¿cómo puede el programa determinar cúando cerrarse? Es bastante probable que la función SetTimer sea usada. Poner un breakpoint en SetTimer no es una buena idea, Windows llama a esta función muchísimo, así que estaríamos de vuelta en softice a cada segundo.

Necesitamos sentarnos y pensar. ¿Cómo puede el programa determinar que Awave se ha corrompido? Puede ser que compruebe las dos funciones de chequeo de registro y si dan resultados ilógicos se cierra después de una cierta cantidad de tiempo.
Pero esta parte del código no podría ser visible (porque debe ser llamada al principio, y porque no hay nada inusual desde el principio del núcleo), y nosotros ya hemos comprobado y corregido todas las llamadas a funciones visibles.

La segunda cosa que me viene a la cabeza, es un tipo de comprobación CRC. Esto suena lógico.


Regla 13 : Intentar resolver un problema vagamente determinado es una pérdida de tiempo.

Copiad protected.exe (la versión sin modificar) a test.exe y modificad la cadena "This program requires...", cambiad la T a una U por ejemplo, no afectará al código en absoluto.

¡Bingo! ¡El programa se cerró automaticamente!

Sabemos que se hace un tipo de comprobación CRC, ahora necesitamos localizarla y quitarla.
Para hacer esto, tenemos que ir paso a paso en protected.exe desde la salida. Cargad protected.exe con el symbol loader, e id paso a paso (F10) a través del código. Finalmente alcanzaréis la "gran llamada", Awave se ejecutará y volveréis a Softice.
La próxima tendremos que ir paso a paso dentro de esa llamada, así que pensad en presionar F8 la próxima vez que lleguéis a ella.

Ahora estaréis dentro de esa función, es la función principal de Awave, un paso un paso un paso un paso...
Y encontraréis :


:00401915 833D78C0470000 cmp dword ptr [0047C078], 00000000
:0040191C 7413 je 00401931
:0040191E 6855154000 push 00401555
:00401923 68E0AB0000 push 0000ABE0
:00401928 6A00 push 00000000
:0040192A 6A00 push 00000000

* Reference To: USER32.SetTimer, Ord:0000h
|
:0040192C E86F960700 Call 0047AFA0

(notad que es una copia del código en Win32dasm, pero encontraréis casi lo mismo en Softice).

Para estar seguros de que hemos encontrado lo que queríamos, reemplazaremos "je 401931" por "jmp 401931" en test.exe.
Ahora el programa no se cerrará nunca más...

Pero no hemos hecho un parcheado elegante, como podéis ver, el programa comprueba si en 47C078 hay 00000000. Si no hay 00000000, entonces actúa el contador. Por lo tanto, sería elegante poner incondicionalmente este emplazamiento de memoria en 00000000.

Primero, debemos comprobar dónde se hace, podemos hacer esto con Win32dasm, es más cómodo. Buscaremos la cadena [0047C078], la ventaja es que una instrucción que acceda a esta dirección de memoria contendrá esta cadena.


Nuestro primer golpe es :

:004017D5 812D78C04700B7F6C60C sub dword ptr [0047C078], 0CC6F6B7
:004017DF 6A00 push 00000000
:004017E1 57 push edi

Hum, sí, podría ser lo que estamos buscando... Pero primero, echar un vistazo a los otros resultados.

:0040184D 8B10 mov edx, dword ptr [eax]
:0040184F 311578C04700 xor dword ptr [0047C078], edx
:00401855 83C004 add eax, 00000004

Ahaha, aún en la misma función, otro aceso... [0047C078] será igual a 00000000 si, y sólo si, es igual a lo que está en edx... Así que nuestro primer golpe ciertamente almacenó el resultado de la comprobación en [0047C078] y el segundo lo xorea con el resultado correcto.

El tercer golpe es la comprobación que encontramos con Softice, y no hay más golpes. Así que es altamente probable que sólo se haga una comprobación durante la ejecución de Awave.

De forma que el método que usamos (reemplazando "je 401931" por "jmp 401931") trabajaría mientras no parezca haber otras comprobaciones. De todos modos, como dije, es meramente mundano proceder así. En mi humilde opinión, el mejor modo de parchear es reemplazar :

8B10 mov edx, dword ptr [eax]
311578C04700 xor dword ptr [0047C078], edx

with

31D2 xor edx, edx
891578c04700 mov dword ptr [0047C078], edx

Y afortunadamente, nuestro código parcheado tiene la misma longitud.

Es el momento de comprobar de nuevo Awave. Después de usarlo un rato, parece funcionar eficientemente. Por lo que veo, hemos desprotegido completamente Awave.


2.6.Resumiendo

Este crack no fue fácil. Tuvimos que trabajar alrededor de nag screens, opciones inutilizadas, varias comprobaciones internas y una comprobación checksum. A mi modo de ver es sorprendente tener tales protecciones en un programa tan pequeñito.
Os podríais preguntar "¿Qué pasa si hubiese más protecciones?".
Podéis estar seguros que la mayoría de los crackers habrían parado en nuestra primera modificación, preguntándose qué estaba mal. Entonces, para esos que no lo hubiesen hecho, habrían parado después de haber evitado la segunda protección, pensando que el trabajo estaba hecho...
De forma que si sois capaces de quitar la protección checksum, sois capaces de quitar más, y habría sido una pérdida de tiempo.

Me pregunto cuánto tiempo gastó el autor con la protección de Awave, espero que no fuera mucho más del día que aproximadamente me llevó crackearlo...


Regla 14 : ¡La resistencia es inútil!
Ahora que el crack está completo, deberíais borrar el programa crackeado, si usáis la versión crackeada estáis violando la ley, y yo nunca animo a nadie a violar la ley. Además, me pregunto si Awave es realmente útil para vosotros (no lo es para mí), deberíais mandarle dinero al autor.

Podríais desear hacer más y descubrir cómo se generan las llaves de registro. Si podéis hacer esto, escribidme un e-mail, soy curioso. Pero puedo deciros que no tendréis éxito haciéndolo con Win32dasm, las funciones de comprobación de llaves están escondidas. Usad IDA.


3.Para concluir

Este es el final de este tutorial de parcheado elegante, espero que aprendieseis algo.
Notad que sólo os mostré cómo crackear este programa para enseñaros las reglas básicas del parcheado elegante, tened en mente que esas reglas se basan sólo en mi experiencia y no pretenden ser reglas absolutas.

Las más recientes versiones de Awave están comprimidas con ASPack, será necesario un desempaquetador para modificarlas. (Procdump trabaja bien en este caso) De todos modos, debería ser fácil crackear las nuevas versiones con la ayuda de este tutorial : hay pocas probabilidades de que el completo sistema de protección haya sido reprogramado.

Si deseáis contactar conmigo, entonces escribidme un e-mail a xerxes@altern.org, incluso podéis visitar mi site (clickead aquí o aquí) o el site de Central (clickead aquí) donde encontraréis una versión vieja de este tutorial. Yo fervientemente os animo a usar PGP, encontraréis mi llave pública en mi site. Cambio regularmente esta llave, así que estad seguros que la llave que estáis usando aún es válida.


ArthaXerxès de Central - <xerxes@altern.org>
No usaré mi conocimiento en vano

El Archivo ArthaXerxès- http://altern.org/xerxes/
La Central WHQ - http://altern.org/central/

www.000webhost.com