DisidentS Team

Hola a todos, estoy nuevamente para mostrarles lo sencillo que puede ser crackear un componente para el entorno de desarrollo Delphi.

Las otras noches, nos juntamos en la casa de un amigo a comer unos canelones, después de comer, charlar y reirnos un rato, sacamos nuestras notebooks… fue ahí cuando me dije, ¿porque no crackear estas compos que hacen muy lindas interfaces a nuestras aplicaciones delphi?

No diré el nombre de estas componentes, ya que obviamente son pagas, sino no sería necesario crackearlas , no? xD

Pero sí daré una pista, empiezan con estas dos letras VGS y las que le siguen, sin espacios son 4 letras, muy conocida palabra en el “ambiente” en el que nos solemos mover. a alguien le gusta la demoscene? xD

Bien, no doy mas pistas, si no lo han agarrado dedíquense a otra cosa… xD

La protección es muy, pero muy sencilla, pero molesta, como todas.

Una pequeña NAG Screen, cuando se instala el componente en Delphi, aparecerá, si arrancamos el entorno, aparecerá, porque Delphi carga todas sus librerías al comienzo… si compilamos un proyecto de ejemplo que viene en el paquete, saldrá el NAG de nuevo, y obviamente si corremos el EXE generado aparte, también… en algún lugar más? xD

Lo que haremos serán dos parcheos simples y no aparecerán nunca más en ningún lado, solo con parchear un fichero. Hay que ir a la fuente, delphi compila y reconvierte todo a varios formatos para que todo en “su mundo” salga bien.

Podemos rompernos la cabeza parcheando 3 o 4 archivos, o 1 solo simplemente.

De que se trata todo esto

Bueno, como ya expliqué es un simple NAG molesto, las demás funcionalidades parecen completas, así que les mostraré el mensajito:

Bien, como les dije, este cartelito, todas las veces que les comenté aparece, ahora vamos a sacarnóslo de encima

Si miramos la carpeta de los componentes estos, veremos que tenemos la carpeta packages, dentro hay archivos con estas extensiones dpk, dcu, res, bpl y dcp.

Los DPK son Delphi Package, los DCU son Delphi Compiled Unit, los BPL son Borland Package Library y los DCP son Delphi Component Package.

Cuando abrimos un DPK, compilamos e intalamos, éste contiene las DCU compiladas, y la DPK utilizada se guardara en la carpeta de proyectos de Borland.

Con esto quiero decir, que si crackeamos lo que genera un DPK que es un BPL, no lo crackearemos del todo…

Miremos primero lo más facil.

Donde atacar

Si compilamos un ejemplo y lo abrimos con el IDA, buscaremos una parte del string del NAG, por ej, “trial”.

Encontraremos la parte de código como la siguiente:

CODE:004F4704                 mov     eax, offset _str_This_applicatio.Text

CODE:004F4709                 call    unknown_libname_164 ; BDS 2005-2006 and Delphi6-7 Visual Component Library

CODE:0050BED0                 mov     eax, offset _str_Resources.Text

CODE:0050BED5                 call    sub_4F7E78

CODE:0050BEDA                 call    nullsub_13

Ok, entonces, podemos parchear el segundo CALL.

Si miramos el código en hexa, será el siguiente: E8 C1 87 FE FF deberíamos NOPearlo, y listo, lo tenemos arreglado.

Pero!, siempre hay un pero, no nos conviene parchear cada EXE que compilamos, o si? sería muy tedioso, deberíamos correr el parche por cada ejemplo o aplicación que utilice estas librerías, entonces deberíamos parchear la fuente, donde se genera la cuestión, no creen?…

Buscando la fuente

Ok, busquemos lo mismo en el BPL que si lo abrimos es un PE armado por Delphi. En cambio no podremos hacerlo con un DPC.

Encontramos esto:

CODE:004560C1                 call    @Vg_scene@RegisterVGObjects$qqrx17System@AnsiStringpxpx17System@TMetaClassxi ; Vg_scene::RegisterVGObjects(System::AnsiString,System::TMetaClass **,int)

CODE:004560C6                 call    @Vg_version@ShowVersion2$qqrv ; Vg_version::ShowVersion2(void)

Con esto lograremos que Delphi 7 no sea interrumpido por la molesta NAG, pero al compilar los ejemplos, y al ejecutarlos saldrá nuestro NAG…

Entonces, donde está la magia de esto? nos queda una de las extensiones que expliqué antes: DCU.

Las DCU NO son PE’s así que tendremos que ver como los “atacamos”, la mejor idea creo que es con DEDE.

Mirando en la carpeta fuera de packages, vemos tooodos los DCU,  así que encontraremos uno de ellos que es vg_version.dcu

Podemos abrir el DEDE y hacer lo siguiente:

Como vemos, abrimos DEDE, y en el menú dumpers, podemos elegir la opcion Dumpeador de DCU. Si hacemos click en esa opción se abrirá la siguiente pantalla, donde elegimos el archivo vg_version.dcu y hacemos click en procesar.

Obtendremos lo siguiente:

Obtendremos el código de nuestra DCU, entonces ahí veremos lo siguiente:

procedure ShowVersion2;

const

  AboutText = 

    000: ÿÿÿÿP...This app|FF FF FF FF 50 01 00 00 54 68 69 73 20 61 70 70|

    010: lication uses a |6C 69 63 61 74 69 6F 6E 20 75 73 65 73 20 61 20|

    020: trial version of|74 72 69 61 6C 20 76 65 72 73 69 6F 6E 20 6F 66|

    030:  VGScene.....Ple|20 56 47 53 63 65 6E 65 2E 0D 0A 0D 0A 50 6C 65|

    040: ase contact the |61 73 65 20 63 6F 6E 74 61 63 74 20 74 68 65 20|

    050: provider of the |70 72 6F 76 69 64 65 72 20 6F 66 20 74 68 65 20|

    060: application for |61 70 70 6C 69 63 61 74 69 6F 6E 20 66 6F 72 20|

    070: a registered ver|61 20 72 65 67 69 73 74 65 72 65 64 20 76 65 72|

    080: sion.....%s..Cop|73 69 6F 6E 2E 0D 0A 0D 0A 25 73 0D 0A 43 6F 70|

    090: yright (C) 1998-|79 72 69 67 68 74 20 28 43 29 20 31 39 39 38 2D|

    0A0: 2009 by Eugene K|32 30 30 39 20 62 79 20 45 75 67 65 6E 65 20 4B|

    0B0: ryukov....For co|72 79 75 6B 6F 76 0D 0A 0D 0A 46 6F 72 20 63 6F|

    0C0: nditions of dist|6E 64 69 74 69 6F 6E 73 20 6F 66 20 64 69 73 74|

    0D0: ribution and use|72 69 62 75 74 69 6F 6E 20 61 6E 64 20 75 73 65|

    0E0: , see LICENSE.TX|2C 20 73 65 65 20 4C 49 43 45 4E 53 45 2E 54 58|

    0F0: T.....Visit our |54 2E 0D 0A 0D 0A 56 69 73 69 74 20 6F 75 72 20|

    100: web site for the|77 65 62 20 73 69 74 65 20 66 6F 72 20 74 68 65|

    110:  latest versions|20 6C 61 74 65 73 74 20 76 65 72 73 69 6F 6E 73|

    120:  of VGScene:....|20 6F 66 20 56 47 53 63 65 6E 65 3A 0D 0A 0D 0A|

    130: http://www.ksdev|68 74 74 70 3A 2F 2F 77 77 77 2E 6B 73 64 65 76|

    140: .com/..support@k|2E 63 6F 6D 2F 0D 0A 73 75 70 70 6F 72 74 40 6B|

    150: sdev.com.       |73 64 65 76 2E 63 6F 6D 00|;

var

Aquí vemos que está el mensaje de nuestra NAG, tenemos nuestro objetivo en la mira.

Como veremos, tenemos 2 procedimientos ShowVersion y ShowVersion2.

Lo que haremos será sencillo, en vez de parchear DENTRO, parchearemos solamente y PUSH EBP:

begin

   00000000 : 55                            PUSH EBP

   00000001 : 8B EC                         MOV EBP,ESP

   00000003 : 83 C4 F4                      ADD ESP,-12

   00000006 : 53                            PUSH EBX

   00000007 : 56                            PUSH ESI

   00000008 : 33 C0                         XOR EAX,EAX

   0000000A : 89 45 FC                      MOV DWORD PTR [EBP-4],EAX

   0000000D : 33 C0                         XOR EAX,EAX

   0000000F : 55                            PUSH EBP

   00000010 : 68(95 00 00 00                PUSH ShowVersion2{0x26}+149

Justamente el PUSH EBP, podemos cambiarlo por un RETN, entonces no entrará directamente a nuestra función, es decir, entrará y luego se irá y no habrá pasado nada.

Entonces tendremos que cambiar el 55 que es el código de operación del PUSH EBP, por un RETN que es un C3.

Parcheando

La pregunta que tendremos inmediatamente, es ¿cómo podemos interceptar ese PUSH EBP, en realidad los dos por las dudas…?

Lo mejor, es buscar el patrón de bytes, así nos aseguraremos que estamos en el lugar indicado..

El patrón que utilicé yo para buscar en ShowVersion2 es: 55 8B EC 83 C4 F4, será el mismo en ShowVersion, ya que es la “cabecera” de la función, y siempre es igual, idéntica.

Así que cambiaremos el 55 por un C3, y san se acabó la maldita NAG.

Conclusión

No hay mucho más que decir, son buenos componentes, si los utilizarán con fines lucrativos, cómprenlos, pero la forma en que está protegido esto, es… deplorable.

Luego podremos recompilar nuestro DPK y reemplazar los nuevos por los viejos, la NAG no aparecerá nunca más ni en Delphi, ni en ningún lado.

Espero que les haya gustado.

Nos vemos en la próxima.

convert this post to pdf.

Hola a todos, hoy a la mañana, enciendo mi notebook y descubro que mi NOD32 4.0 detecta intentos de conecciones de mi PC hacia servidores, con URL’s raras…

Esto me dió alegría ya que me dije, “bien, algo nuevo para investigar vino a mi!!”… así que me puse manos a la obra, y mientras publicaba un artículo viejo que escribí para la revista @rroba, me dediqué a mirar este bichito…

Mirando los logs de NOD

He aquí algunas líneas del log de mi AV’s…

06/06/2009 12:02:04 a.m. HTTP filter file http://174.133.147.18/p0508/2.0/w2.bin?829467 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:56 a.m. HTTP filter file http://174.133.73.178/p0508/2.0/w2.bin?405861 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:48 a.m. HTTP filter file http://174.133.34.178/p0612/2.0/w1.bin?413869 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:40 a.m. HTTP filter file http://174.133.72.250/p0508/2.0/w1.bin?762274 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:29 a.m. HTTP filter file http://174.133.147.18/p0508/2.0/w1.bin?875733 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:21 a.m. HTTP filter file http://174.133.73.178/p0508/2.0/w1.bin?233033 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:19 a.m. Real-time file system protection file C:\WINDOWS\system32\wtukd32.exe probably a variant of Win32/Adware.Coolezweb.AI application cleaned by deleting – quarantined NT AUTHORITY\SYSTEM Event occurred on a file modified by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:12 a.m. HTTP filter file http://174.133.34.178/p0612/2.0/w.bin?613307 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:01:04 a.m. HTTP filter file http://174.133.72.250/p0508/2.0/w.bin?333771 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:00:56 a.m. HTTP filter file http://174.133.147.18/p0508/2.0/w.bin?280812 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

06/06/2009 12:00:48 a.m. HTTP filter file http://174.133.73.178/p0508/2.0/w.bin?170629 probably a variant of Win32/Adware.Coolezweb.AI application connection terminated – quarantined NT AUTHORITY\SYSTEM Threat was detected upon access to web by the application: C:\WINDOWS\system32\svchost.exe.

05/06/2009 10:15:47 p.m. HTTP filter file http://bddanhdnfl.net/ccsuper3.php Win32/Small.NEK trojan connection terminated – quarantined NOTEBOOK\Sparkrisp Threat was detected upon access to web by the application: C:\fuwtkxex.exe.

05/06/2009 10:15:46 p.m. Real-time file system protection file C:\clftq.exe Win32/TrojanDownloader.Bredolab.AA trojan cleaned by deleting – quarantined NOTEBOOK\Sparkrisp Event occurred on a new file created by the application: C:\fuwtkxex.exe.

05/06/2009 10:15:45 p.m. Real-time file system protection file C:\Documents and Settings\Sparkrisp\Configuración local\Archivos temporales de Internet\Content.IE5\K13ASQ4J\ccsuper2[1].htm Win32/TrojanDownloader.Bredolab.AA trojan cleaned by deleting – quarantined NOTEBOOK\Sparkrisp Event occurred on a new file created by the application: C:\fuwtkxex.exe.

05/06/2009 10:15:45 p.m. HTTP filter file http://bddanhdnfl.net/ccsuper2.php Win32/TrojanDownloader.Bredolab.AA trojan connection terminated – quarantined NOTEBOOK\Sparkrisp Threat was detected upon access to web by the application: C:\fuwtkxex.exe.

05/06/2009 10:15:42 p.m. HTTP filter file http://bddanhdnfl.net/ccsuper1.php Win32/Small.NEK trojan connection terminated – quarantined NOTEBOOK\Sparkrisp Threat was detected upon access to web by the application: C:\fuwtkxex.exe.

05/06/2009 10:15:41 p.m. HTTP filter file http://bddanhdnfl.net/ccsuper0.php a variant of Win32/Rustock.NIK trojan connection terminated – quarantined NOTEBOOK\Sparkrisp Threat was detected upon access to web by the application: C:\fuwtkxex.exe.

05/06/2009 10:15:18 p.m. HTTP filter file http://bddanhdnfl.net/progs/xadmaa/molivjw.php Win32/Small.NEK trojan connection terminated – quarantined NOTEBOOK\Sparkrisp Threat was detected upon access to web by the application: C:\Documents and Settings\Sparkrisp\Configuración local\Temp\136.exe.

05/06/2009 10:15:17 p.m. HTTP filter file http://bddanhdnfl.net/progs/xadmaa/djdjjnxlcp.php Win32/Small.NEK trojan connection terminated – quarantined NOTEBOOK\Sparkrisp Threat was detected upon access to web by the application: C:\Documents and Settings\Sparkrisp\Configuración local\Temp\136.exe.

Bien, nuestra pequeña bestia intentó muchas cosas al mismo tiempo prácticamente.

Aparentemente, nuestro autor, o “autor” porque no creo que lo sea de todos estos virusillos, tiene un host y seguramente hace downloaders, para los mismos, estos consultan las url’s que estamos viendo en el log, baja los troyanos, y finalmente infecta nuestra PC, para robarnos información, tomar el control, etc.

Viendo que hay detrás

Si probamos alguna de las URL’s, y la ejecutamos en un navegador (sin miedo jejeje), veremos algo por el estilo:

Exactamente, el binario de uno de los troyanos, el cual NOD lo detecta como: Win32/Small.NEK.

Con una simple mirada en el código binario, podemos ver que está hecho en VB (MSVBVM60.DLL), y otra cosa más, en que carpeta el desarrollador lo tiene al proyecto entero!

D:\Documents and Settings\Administrator\Lhb—\installscash active!!nno form wow downloader\mycc\Project1.vbp

Aparentemende NOD lo detecta como un troyano, pero es un downloader…

Luego, veremos nombres de logs, archivos de log, serán archivos generados por el downloader?

xdfbxewhrrjdzdfbcvne5gwgaabaz36.log

xdfbxewhrrjdzdfbcvne5gwgaabaz37.log

xdfbxewhrrjdzdfbcvne5gwgaabaz38.log

xdfbxewhrrjdzdfbcvne5gwgaabaz39.log

Y la lista sigue…

Así veremos también en esa misma página, la utilización de la API: urlmonURLDownloadToFile, sabemos que es utilizada para bajar archivos de una URL, muy común en los downloaders.

Si guardamos el fichero obtenido de esa URL (sugiero hacerlo con wget), y utilizan el WKT VB Debugger, podremos ir viendo lo que va a haciendo…

Algunas de las cosas que veremos es que tiene strings encriptadas, para evitar el desensamblado y la identificación sencilla del virus en cuestión.

Así que debuggearemos un poco para ver que hace…

M8C9S8H5zcX9C9z3Q9UaKbRbA4y0k9EbybPcR9LcUaYby23azcJdOcFaR9z1

M8C9UaH5C9X9Faz3ObUaIdP9w0C4naJaIcEaLaRcOby27bH8Q8EbRcz8NbHdI3b8KaOcFaPbKazcUaB52bJcJdIcD8zaVbLcJcM8z3jaLdz8PbLcN9E9w0H3cb2bibG3w2

He aquí algunas de las strings encriptadas… es simple pensar que utiliza XOR, para encriptarlas, ya que no se necesita mucho más para estas tareas víricas…

AddService = zgtkg3jrsyzdb6wtgw3rh3wahhrjkae80,,My_AddService_Name

Quiere decir que este bichito debe instalar un servicio en nuestro sistema… pero que pícaro…

FStStr -> ’sc config   wscsvc start= DISABLED’

FStStrNoPop -> ‘C:\DOCUME~1\SPARKR~1\CONFIG~1\Temp\zgtkg3jrsyzdb6wtgw3rh3wahhrjkae35.log’

FStStrNoPop -> ‘C:\DOCUME~1\SPARKR~1\CONFIG~1\Temp\zgtkg3jrsyzdb6wtgw3rh3wahhrjkae43.exe’

FStStrNoPop -> ‘zgtkg3jrsyzdb6wtgw3rh3wahhrjkae81.exe’

Dije antes, que utiliza la famosa API para bajar un archivo de una URL en particular… hay trucos para evitar que los antivirus detecten que se está utilizando, generalmente la heurística detecta todo y está sonado..

loc_40401D: LitStr “U”

loc_404020: LitStr “R”

loc_404023: ConcatStr

loc_404024: FStStrNoPop var_A0

loc_404027: LitStr “L”

loc_40402A: ConcatStr

loc_40402B: FStStrNoPop var_A4

loc_40402E: LitStr “D”

loc_404031: ConcatStr

loc_404032: FStStrNoPop var_A8

loc_404035: LitStr “o”

loc_404038: ConcatStr

loc_404039: FStStrNoPop var_AC

loc_40403C: LitStr “w”

loc_40403F: ConcatStr

loc_404040: FStStrNoPop var_B0

loc_404043: LitStr “n”

loc_404046: ConcatStr

loc_404047: FStStrNoPop var_B4

Luego si miramos más el proyecto veremos que tiene una función para ejecutar las API’s de alguna manera especial.. no entraremos tanto en detalle, vamos a seguir mirando que mas nos ofrece…

Siguiendo el rastro

Si dejamos a este bichito ejecutarse un par de días, seguirá bajando copias y variantes de sí mismo. Parece que los programadores de estos downloaders, son muy activos, en dos días he bajado como 3 o 4 versiones del mismo downloader, con algunas diferencias…

Tenemos otro que modifica el registro de windows, instalándose en el inicio, para hacer las conecciones remotas, cada vez que arranca el sistema operativo.

Por ejemplo existe otra variante, la que se instala al inicio, que no instala el servicio…

En la segunda imagen de inicio, marco otros sospechosos que encontré, no sé si son de este virus o de otro que tengo xDDD, si es de otro, quizás tengamos más diversión xD…

Al ver que instala servicios, se me ocurre correr la utilidad GMER, muy utilizada. Y me avisa de una instalación de un servicio oculto…

Podemos desinstalarlo y borrarlo con GMER, sin problemas, al próximo reinicio no estará más. Si queremos analizarlo un poco más con IDA no veremos mucho, así que o Softice o Syser Debugger, que es bastante bueno también.

Bien, como dije cada uno de los “hijos” tiene sus características, la idea principal calculo que será infectarnos y hacernos zombies de alguna manera, o robarnos información, a su vez con una rápida actualización de los downloaders, los cuales no fueron detectados por NOD 4.0, sino que éste detectó las conecciones hacia el host.

Los dos ficheros de inicio, que tenía yo en mi PC, aparentemente están empaquetados, veremos con una pequeña sesión de Olly que sale…en la segunda parte.. xD

Veremos varias cosas más, otros archivos ocultos especialmente en las carpetas system32 de nuestro windows…. pero eso será como dije en la próxima…

Espero que les esté gustando.

Un saludo.

convert this post to pdf.

En la lección de este mes, les traigo un amigable crackme, que según el autor (  y con razón) es un tutorial, si lo desensamblamos, así que les pegaré el código y eso es todo… jeje , era broma, lo iremos descubriendo de a poco, y aprenderemos juntos.

Nos encontramos con una protección que no habíamos analizado aun, esta proteccion, es parecida a las utilizadas en los keymes, donde necesitamos un fichero clave para que el programa este registrado, este fichero clave contiene ciertas caracteristicas muy importantes que hacen, que se este registrado o no.

Bueno, este crackme no es un keyme, pero al principio actua como un keyme, nada mas que chequea un par de cosillas distintas, que ya veremos.

Reglas de Juego

Cuando ejecutamos el Crackme , tenemos en la pantalla principal de este, dos botones, y a la izquierda de estos, dos labels, que dicen Shareware y Unregistered.

Miremos en el boton About/Rules, donde nos dice, que hay tres caminos para crackear el crackme, y luego como les comente al principio del articulo, si lo desensamblamos, este crackme, es un tutorial por si mismo, tenemos permitido usar desensamblador y parchear; y por ultimo dice que si somos mejores con SoftIce, lo hagamos con SoftIce, pero nosotros no usaremos SoftIce, usaremos Olly Debugger, asi que no lo desensamblaremos, ni lo parchearemos fisicamente, solo en memoria.

Un poco de teoría

Desensamblemos el crackme, y veremos la pantalla principal de debugger, con el codigo ensamblador mostrandonos como es nuestra victima, debo decirles, que es un poco enradada, pero no nos asusteis, esta todo controlado…

Comenzamos en la dirección 401000, con un recibimiento poco comun en los crackmes (lo he  visto en algunos programas y juegos comerciales, y bastantes nuevos), nada mas ni nada menos que un “Hi Reverser”,

¿ pero quien es el reverser aquí ?, SI! Nosotros, o eso creo….

Luego otro PUSH ( que lo que hace es cargar con una direccion de memoria la cual apuna al string, el string propiamente dicho) que nos dice “Here Starts the test for the Versión” (Aquí empieza el chequeo por la versión).

Nueve instrucciones mas abajo encontramos otro texto que es PUSHeado a la memoria diciendo: “Here end the test for the Versión” (Aquí termina el chequeo por la verision).

Con razon el creador dijo que esto era un tutorial, miren, si nos marca el sector donde hace el chequeo para decirnos si esta registrado o no el programa, nosotros debemos conseguir que en esos dos labels que hay al ejecutarlo en la pantalla principal diga que esta registrado.

Bien, veamos que podemos hacer aquí tenemos lo siguiente:

En la direccion 0040100B  , la instrucción MOV [DWORD DS:40300C],1 y en la direccion 00401015 , la instrucción MOV [DWORD DS:403008],1 ;  analicemos para que sirven y porque las nombro de entre todas las demas, ¿ ustedes piensan que tienen coronita ? pues no, no la tienen, o de algun modo si…

Los dos MOV’s mueven un 1 en decimal, a dos direcciones de memoria diferentes…. Anotemos la direccion 403008.

Más abajo en la dirección 00401021 , tenemos la instruccion  LEA EAX,[DWORD DS:403010], que carga el valor que esta en la zona de memoria 403010 a  EAX, y luego la instrucción de la direccion 00401029 que nos dice:

CMP EAX,X-LOCK~1.00403012

Luego viene nuestro push querido indicandonos el fin del programa, un pop eax, y un salto JE, que nos lleva  a la direccion 401040….

Algo muy notorio

Muy bien, ¿que es lo notorio?, ese salto a 401040 nos lleva a continuar el flujo del programa normalmente, ¿pero que sucede si este salto no se realiza?, veamos:

00401036   MOV [DWORD DS:403008],0

¿Pero que sucede aquí?, en 403008, la que yo les dije que recordaran , pone un 0!!!, ¿porque? Sigamos mirando y deduzcamos si ese 0 es necesario para estar registrados o no…

Mas adelante en el programa , carga la ventana principal, en la direccion 401077 chequea , por si se ha clickeado un boton, y si es asi, pregunta cual de ellos, etc, etc. Esta rutina es comun en todos los programas, ya que es la rutina principal que chequea por cada opcion, o boton , si fue presionado o no, y en caso afirmativo se deriva el flujo del programa a la direccion correspondiente a la accion solicitada por el usuario.

Lo bueno comienza en la direccion 0040109D, donde nos encontramos el push identico, al primero que vimos en la apertura del programa desensamblado, y unas lineas de codigo mas abajo el otro push que nos indica que finaliza la seccion de registro, tal cual en el principio.

¿ Se acuerdan de los mirror checks que yo les habia explicado en articulos anteriores ?, bien, aquí lo tienen, la proteccion se repite en dos zonas de memoria distintas, o sea, que si nosotros parcheamos solamente la primera, o encontramos la segunda y parcheamos solamente esta, la otra seguira actuando normalmente y no nos dejara el programa registrado, por supuesto todo esto depende de cómo el programa este implementado, porque en nuestro caso, con modificar el segundo chequeo , nuestro crackme ya esta completamente funcional.

Fijense que en la direccion 0040109D vuelve a hacer lo mismo que antes.

Carga en EAX, lo que contiene la direccion 403010 y lo compara con lo que hay en la direccion 403012, si no llegan a ser iguales en la direccion 004010AD salta a la direccion 004010B9, pero la instrucción MOV [DWORD DS:40300C],0 de la linea anterior no es ejecutada, si se produce el salto, pero miren atentamente moveria un 0 decimal a la direccion 40300C, es otra zona!, es un doble chequeo, pero chequea dos zonas distintas de memoria, miremos mas,

miremos mas…..

En la direccion 004010A2  tenemos un  LEA EAX,[DWORD DS:403010], 403010 tiene un 31 en hexa (1 en decimal), lo que al compararlo en 4010A8 con el valor de 00403012 que contiene un 30 en decimal (0 en decimal), hara que no salte y entonces el mov de la direccion 004010AF pondra a 40300C en  0 y no estaremos registrados.

A partir de la direccion de memoria 4010E6 hasta 4010EE tenemos lo siguiente:

MOV EAX,[DWORD DS:403008]   ;  mueve lo que contiene 403008 a EAX

CMP EAX,1 ; lo compara con 1

JNZ SHORT X-LOCK~1.00401105 ; y luego si no es igual salta a 401105

Mas abajo miremos, las strings cargadas…

004010F6  |. 50             PUSH EAX                                 ; /Text => “Fullversion”

00401115  |. 50             PUSH EAX                                 ; /Text => “Registered”

Necesitamos que estas strings se carguen, para que nuestro crackme funcione correctamente!!!, pero como podemos hacerlo??? Bien, el salto de la direccion 4010EE no nos lleva a poder ejecutar esas strings, por lo menos la de Fullversion no, pero sin embargo salta a una direccion anterior a la de la string “Registered”, salta a 401105, y “Registered”, esta en 401115, o sea que algo debe haber en el medio..  >: \

Perfecto, en la dirección 401105 tenemos lo mismo que en la direccion 4010E6 nada mas que el MOV EAX,[DWORD DS:403008]  , cambia por MOV EAX,[DWORD DS:40300C]  , aquí sucede lo mismo que antes, si no se cumple la misma condicion, o sea en la direccion 40300C no esta el valor 1 decimal, tampoco carga la string “Registered”, y nuestro programa no estaria ni completo (Fullversion) ni registrado (Registered).

Alternativas de Cracking:

Hay muchas alternativas, para hacer que nuestro pequeño funcione, podemos modificar los saltos de las direcciones 401034 y 4010EE, entonces como los valores de las direccion 403008 y 40300C seran 0 saltara, y nos hara registrar, simplemente cambiar los JNZ por JZ y listo, o sino por JMP y estos se transformaran en saltos INcondicionales, o sea, no importa si son iguales o no los valores, el salto se realiza igual.

Otra alternativa mas “elite”, y menos sucia que cambiar saltos y forzar el flujo del programa, es modificar la instrucción LEA de la direccion 00401021  , donde mueve lo que contiene 403010 a EAX, como lo que contiene 403010 es un 1 en decimal, siempre no saltara y nos pondra en 403008 el valor 0 con lo que no estaremos registrados nunca, entonces ¿por cual valor podemos moficar el operando de la instrucción LEA? Por una direccion de memoria como por ejemplo 403012, que contiene 0, entonces cuando llegue al CMP EAX, 403012, simplemente comparara el valor que contiene 403012 con el que contiene 403012, ¿resultado?, se produce el salto, y asi nuestro soldadito atrapado en  403008 (el 1), seguira vivo y no sera machacado….

Otra alternativa seria cambiar el CMP EAX,403012 por 403010, ya que, sera lo mismo, nada mas que en 403010 hay un 1 y no un 0 decimal como en 403012.

Luego en 004010A2 podemos modificar la instrucción LEA , por 403012, o inclusive podemos hacer un MOV EAX,0  y seria suficiente porque 403012 contiene un 0 decimal, y debemos hacer que el salto se produzca, y como el salto se produce cuando son iguales, pues ya lo tenemos

Tambien podemos modificar el CMP, como en la zona de chequeo anterior o el salto JNZ.

Triunfadores:

Hemos  triunfado de nuevo, como podemos ver, nos aparece una ventanita, diciendonos, que hemos craqueado exitosamente el crakme, y que esperemos el segundo que sera mas difícil de crackear, ¿lo sera? Quizas si…. Quizas no….

¡Hasta la próxima!

convert this post to pdf.

Hemos llegado a una parte muy interesante de este curso, bienvenidos nuevamente a otro fascinante episodio de esta sección.

Espero que les guste y que les sea de agrado leerla, he elegido un elaborado Reverseme de ParaBytes aún sin solución, nosotros no implementaremos la solución completa, pero pasen y vean, vean que bestia he atrapado.

Bien, había comentado anteriormente que es un Reverseme, pero para todos aquellos que no lo sepan, o aún no lo entiendan, un Reverseme es justamente un programa el cual hay que agregarle, activarle, reprogramarle alguna función.

Estas funciones son dadas por el programador, como reglas del juego, como veremos mas adelante, tenemos reglas para jugar con nuestro Reverseme elegido, muy entretenidas, cubriremos la mayor parte de estas reglas, que son muy sencillas, y les ayudará muchísimo a la hora de entender alguna víctima de este tipo, o quizás nuevas, porque todo este conocimiento es reciclable.

Reglas de Juego

Bueno, el Reverseme nos dice, que tenemos un solo botón, llamado Exit, que justamente lo que hace es salir del programa; pero también hay un misterioso lugar arriba que nada esta ocupándolo, veremos porqué.

Esto es así porque, justamente lo que debemos hacer es crear un botón nuevo, en ese espacio, y luego programarlo para que muestre un número aleatorio en un messagebox, parece sencillo no?, veamos que sucede más adelante.

Un poco de teoría

Veamos algunas definiciones nuevas para los iniciados, y renovemos a los ya iniciados con un poco de teoría que no viene nada mal.

Un archivo PE,NE,MZ, ELF, COM, o cualquier formato que tengamos que analizar o modificar, debemos estudiar en primera instancia su estructura. Un fichero PE (los mas comunes de win32) está dividido en secciones, PE significa Portable Executable, y algunos nombres comunes de secciones que se suelen encontrar en un PE normal son: .code, .data, .rsrc, .udata, .text, .edata, y algunos más que posiblemente ahora no recuerde bien, pero para que más, esos son los más importantes.

Por supuesto que la cosa cambia cuando el EXE esta empaquetado, las secciones suelen cambiar sus características , incluyendo su nombre y demás atributos.

Cada sección, posee atributos, como el de ejecutable, o el de lectura, compartido, etc. Con un editor de  archivos PE pueden verse las secciones fácilmente, un programa para ello es PE-Editor, muy útil en estos casos, permite volcar secciones, editarlas, analizarlas, etc.

Cuando un programa es ejecutado, este es volcado en gran parte en memoria, o al menos el código que será ejecutado dentro de poco tiempo en memoria, esto hace que la mayoría de los recursos del archivo EXE se vuelquen también en memoria, y tengamos casi todo ahí para servirnos de ese manjar.

Cuando tenemos un Reverseme de este estilo que debemos AGREGAR un botón, justamente, debemos agregar código, y eso requiere cambios en el flujo del programa, cambios lógicos, o sea que no hagan que el programa se corrompa ni produzca errores, debemos controlarlo, para poder hacer lo que queramos hacer con él, ésta manera, es la mejor manera de entender el ensamblador  y que sucede dentro de la PC en Windows por ahora.

Desviación del Flujo de Programa

Debemos graficar esta situación, esta modificación es en primera instancia en memoria, luego podemos transladarla al archivo físicamente parcheándolo y dejándole agregada la función para siempre, pero antes para hacer todo esto debemos graficarnos como modificar el flujo de un programa.

Los virus hacen algo parecido al infectar EXE’s, justamente cambian el flujo de su víctima, para que el virus se ejecute primero y luego, infecta, o hace sus cosas malas, y luego le da el lugar a la víctima a que se ejecute normalmente; antes en DOS, se calculaba la cabecera del EXE, y luego se le agregaba el código de operación de un salto incondicional con la dirección en la que empezaba el virus, de esta manera, el programa lo primero que hacía era, ir al virus a través de ese salto y luego volver.

Algo parecido haremos aquí, primero dejaremos que muchas cosas propias del programa se ejecuten, porque no lo infectaremos, simplemente le agregaremos algunas cosas, así que debemos observar la víctima mirarla bien donde hay que agregar, como funciona y demás para luego decidir donde agregar y porque.

En programación en Win32Asm, tenemos que cualquier programa  que programemos en este lenguaje, tiene un bucle, este se denomina bucle de mensajes, y es ejecutado por cada programa siempre, para saber si algún mensaje fue enviado a ese programa, como por ejemplo el clickeo en un botón, la minimización del programa y muchísimas cosas más.

Generalmente las API’s ejecutadas son GetMessage, TranslateMessage y DispatchMessage, son utilizadas para este fin, de esta forma, ubicar este bucle se nos hace muy fácil simplemente buscando estas API’s.

Generalmente cuando el programa se está cargando antes que nada, genera los recursos, o sea, la ventana, los botones, y todos los componentes que necesita para funcionar, estos son generados de diversas maneras, dependiendo el lenguaje en el que fué programado.

Por ejemplo en algunos programas hechos en Delphi , se utiliza el API LoadResource, mientras que en Win32Asm, se suele hacer de distintas maneras, generalmente se hace de la manera más tradicional, llamando a CreateWindowExa, para crear botones, ventanas , y demás componentes.

Pero esta API lleva parámetros que deben ser introducidos y respetados para que todo funcione como queremos.

Si ubicamos la rutina que crea un botón, ya podemos modificarla un poco y agregarla en algún lugar libre para redireccionar el programa hacia ese lugar en el momento que se comienzan a cargar los recursos para también cargar el nuestro que agregaremos, y luego devolverle el control para que el programa siga su rumbo normal sin ningún tropiezo.

Bien, grafiquemos esto:

Inicio del Programa —> Carga de Recursos – PARCHEO – —> desvío hacia nuevo código —> retorno al código original

Sabiendo que debemos hacer, analicemos nuestro amiguito, con Language vemos en que lenguaje está programado, cuando vemos que nada nos pone, es que está hecho en el lenguaje más puro Win32Asm, si señor, miremoslo, porque todo está entregado, no hay runtimes, ni llamadas a DLL’s sin sentido , ni cosas raras, es ASM, puro y simple.

Si lo desensamblamos, y miramos con W32Dasm, vamos a la ventana de String References y vemos una palabra BUTTON, bueno ahí tienes hijo, el botón declaradísimo, más claro imposible.

Hagamos doble click en la palabra, y nos lleva a la dirección donde parece que se declara el tipo de botón, nombre de este, y muchas cosas mas, luego si miramos mas abajo podemos observar que se llama a CreateWindowExa, exacto, con eso se crea el botón.

Ahora, una idea brillante se me ha ocurrido (milagro), podemos reutilizar este código ya compilado para usarlo para nuestros propósitos que en este caso es agregarle un botón más, por ahora, solamente haremos eso.

Bien, el código para la declaración del botón empieza con PUSH en la dirección 4011CB, si miramos más abajo podemos observar que en la dirección 4011E8 se encuentra el título del único botón que hay en el programa (hasta ahora), “Exit”, y una línea más abajo está el texto “BUTTON”,  estamos por buen camino.

Luego podemos ver que ingresa muchos parámetros más y luego ejecuta la API CreateFontA, que lo que hace justamente es darle un tipo de letra al botón, nosotros haremos exactamente lo mismo con el nuestro, luego ejecuta la API SendMessage simplemente para poner la letra al botón.

Nosotros copiaremos enteramente desde 4011CB a 40123D, y modificaremos, algunas cosas, si miramos el PUSH que pushea el texto “Exit”, este nos dice una dirección, que es 40303C, nosotros modificaremos ese PUSH poniendo un PUSH pero a una dirección lejana que sabemos que no será utilizada por nadie como por ejemplo 403FF8, ahí pondremos cualquier texto, con el Olly, simplemente apretamos control+G en la ventana de datos y ponemos esa dirección, luego seleccionamos 8 bytes y hacemos click en el botón derecho, haciendo click en la opción para modificar los datos, introducimos el texto que queramos, y listo.

Ahora, debemos cambiar el ID del botón, el del Exit es 7A69, el cual modificaremos y le pondremos uno más 7A6A por ejemplo. Nuestro botón debe tener distinto ID para poder poder existir y sobrevivir, sino haría conflictos con el existente.

Ahora si miramos un poco más arriba vemos que en 4011C5 y más arriba también está el bucle de mensajes del programa, el cual nos centraremos en 4011AC, que es donde pregunta por el ID del botón Exit, deberá hacer lo mismo para nuestro botón, asi que debemos parchear esa parte también de esta manera:

claramente se observa que exit sale del programa, o sea la API que hay mas abajo PostQuitMessage es ejecutada, quiere decir que cundo hacemos click en ese botón el salto JNZ que hay antes no se ejecuta, este se ejecuta cuando NO es clickeado el botón, o sea que si es presionado el nuestro, ahí podemos redireccionar con una dirección distinta hacia nuestro código, para que haga un CMP con nuestro ID tal cual como lo hizo con exit y luego un nuevo JNZ, y ahí si éste será idéntico al que modificaremos ahora, ¿porque? Pues porque este JNZ nos lleva a otra parte del bucle principal del programa que se encarga de los mensajes también, si no lo hacemos nuestro programa puede romperse y salir de repente o inclusive trabar a nuestro querido Windows.

Bien, he dado las pautas para poder modificarlo, ahora debemos situar el código de creación del botón en algún lado, para eso, usaremos un programa hecho por WKT (saludos esn-min) llamado Topo, este programa analizará nuestro EXE en busca de espacio libre para alojar injertos, y luego lo dejará fertilizado para nuestros propósitos.

Al ejecutarlo y analizar el fichero nos dice que hay 420 bytes disponibles, le decimos que lo agregue en la misma sección (o sea .code), y luego, operamos con el Olly de nuevo.

En 40225C en el offset A5C, a partir de ahí  estará seguro nuestro injerto, así que los saltos antes mencionados deben redireccionarse a éste código, el salto que debe ir hacia este código es un JMP a esta dirección, lo pondremos sobre el push 0 de la dirección 4011CB, y luego, de ir hacia nuestro código, antes de regresar pondremos un push 0 (que fue el que sobreescribimos) y luego un jump al segundo push, o sea a la dirección 4011CD,  de esta manera el programa no se dará cuenta de lo que está sucediendo en su interior.

Así nuestra víctima generará un botón que ni siquiera estaba previsto crear con algunos simples cambios.

Conclusión

Muy  bien, hemos hecho un injerto de código!, ahora con esto debemos profundizar y utilizarlo en más reversemes, crackmes, toolmes, y demás bestias que andan sueltas por la Red.

Espero que les sea de utilidad, y vean que hay cosas que no son tan difíciles como las plantean, o como se plantean en muchos sitios “elite”.-

convert this post to pdf.

Muy bien, he encontrado por ahí un buen crackme, un poco raro, con una proteccion linda de explicar, mas adelante les explicaré algunas técnicas y trucos de cómo podemos encontrar “pistas” para poder vencer estos hermosos juguetes llamados crackmes.

Empezaremos por el principio, como siempre debemos empezar, mirando la víctima, ejecutemoslo… listo? ¿Que tenemos?, una hermosa ventanita con un menú file, con la opción exit, y otro menú help con la opción register y about.

Experimentando con la bestia

Bueno, que sucede si hacemos click en la opción register del menú help?, nos aparece una ventanita que nos dice “Kill the nagscreen”, estas ventanitas, con esos iconos característicos son generalmente llamadas con una API llamada MessageBox o MessageBoxA, dependiendo si la aplicación es de 16 o 32 bits respectivamente.

Aquí ya tenemos una pista, estas eran las “pistas” que yo les mencioné anteriormente, que sirven para guíarnos a través del código.

Otra cosa interesante, es que aparece una ventanita aleatoriamente diciendo algunas cosas sin sentido e incitándonos a crackearlo. Destruyámosla.

Si hacemos click en la opción About, nos da datos sobre el autor del crackme, y demás cosas, que no tienen mucha importancia.

Reglas de juego

Ahora veamos que nos pide el autor del crackme, y seamos chicos aplicados cumpliendo con todo lo que él dice, al pie de la letra, ¿están listos? ¡¡Adelante!!

Bueno, dice que saquemos el messagebox que aparece cuando hacemos click en register, lo haremos, y luego debemos matar la ventanita chiquita que nos incita a crackearlo.

Sobre las “pistas”, API’s, y reconociendo patrones de código

Tenemos siempre, que tratar, debido al gran caos del código desensamblado de un programa, tener referencias y entender lo útil y principal, lo que verdaderamente está sucediendo en partes o en la totalidad del programa, para poder “descifrar” el funcionamiento del programa, encontrar la protección y poder anularla.

Otras veces, deberemos entender, varias cosas antes de desensamblar un programa, cuando veamos ejercicios del tipo reverseme’s, ya verán de lo que les hablo.

Las pistas que debemos encontrar, son las API’s, debemos conocer las más comunes , sus parámetros, sus valores de retorno, su función principal, aquí les detallo algunas:

MessageBox SystemTime Hmemcpy
OpenFile GetLocalTime
DialogBoxParamA createwindow
GetDlgItemText createwindowexa
WriteFile showwindow

Bueno, la mayoría de estos nombres de API’s se explican por sí solos, así que no hay que preocuparse mucho, lo que sí, les mostraré ahora algunos que he estado descubriendo, por ejemplo en este crackme, encontré uno que me sirvió y me dio la pista para poder matar la nagscreen que nos incita a crackear el crackme.

La API que me guió hasta esa ventana es, CreateThread , en breve les mostraré porqué y como razoné para deducir que esa API era la responsable.

Los patrones de código son reconocibles, con la práctica, el ojo humano al principio debe acostumbrarse a leer ensamblador, como dije antes, todo código sea ensamblador, c++, basic, pascal, es caótico, tiende a ser caótico.

Cuando programamos un sistema por ejemplo, un programa muy grande, debemos documentar debidamente cada función, cada proceso creado, que valores retorna, porque, y como funciona, para futuros arreglos o implementaciones, debemos organizar, e identar todas las instrucciones correctamente, sino sería ilegible, o muy difícil de entender, y aunque ustedes no lo crean, se hacen concursos de “ofuscados” son programas que hacen algo, como un cálculo o alguna cosa simple, pero que el ganador es aquel que lo hace “menos entendible”, sin querer decir que programe “suciamente”, simplemente hacerlo lo mas ilegible posible. Pero no nos meteremos en esos campos extraños de la informática.

Un programa desensamblado, es lo mas terrorífico que un programador se puede encontrar, el algo verdaderamente ilegible, si no se tiene el conocimiento real de la situación a bajo nivel, y cierta práctica como para reconocer los patrones de código de los cuales les hablo.

Cuando usamos Vc++, VB, Delphi, o algún otro RAD, el código generado por estos compiladores, se repite muchísimas veces en distintos programas programados bajo el mismo lenguaje, permitiéndonos, con la práctica ( o un buen tutorial a mano sobre el tema ) poder reconocer por ejemplo, cuando el programa chequea si las opciones de los menúes fueron clickeadas, etc.

¡¡Al Ataque!!

Muy bien, aclaradas algunas cosas antes, vayamos a nuestro pequeño ejercicio, haber si podemos calentar un poco nuestras neuronas…

Veamos de que se trata, a mí me gusta saber en que lenguaje está programada mi víctima, para saber con quien estoy “hablando”, es como una presentación…… bueno dejenme, son mañas.

Corramos el programa Language 2000, arrastremos la víctima hacia language 2000, y que nos dice…. Que está programado en Visual C++, ohps! muy bien, y ¿ahora que?, bien respiremos profundamente, porque cuando los programas están programados en Vc++, en C++ o en C, significa, que su código desensamblado, será más entendible (eso no significa más fácil). ¿Por qué digo esto?, porque cuando trabajamos con programas programados en VB, por ejemplo , este lenguaje es interpretado, y necesita runtimes, utiliza funciones propias del lenguaje, las cuales debemos analizar para que sirve cada una, porque raramente llama a una API, salvo que sea una llamada directa hecha por el programador.

Programas hechos en VB o en Delphi por ejemplo, tienen patrones de código bien reconocibles, y llamadas a rutinas, que realizan el trabajo “sucio”, entonces, el código desensamblado es mayor, mucho más caótico y difícil de descifrar si no tenemos la suficiente paciencia, pero no es imposible, no se me desanimen.

Ahora, tomemos un desensamblador, como por ejemplo el IDA, muy bueno a mi parecer, hace el código muy entendible, y tiene las librerías llamadas FLIRT, que si sabes en que está programada la víctima, puedes cargar una FLIRT para reconocer rutinas propias de los programas generados con X lenguaje, entonces de esa manera se entiende mucho más fácil, y puedes ir al punto directamente sin dar muchas vueltas.

Bueno, empecemos por lo más sencillo, buscar strings references, esto es lo más sencillo, porque nos lleva al punto directo, de cuando el mesagebox o X componente fue creado con X texto que busquemos, que no estará muy lejos de la llamada API correspondiente, les muestro que sucede en nuestro crackme:

Buscamos el texto “Kill the nagscreen.”, y lo encontramos, ahora hagamos doble click en él y nos lleva hasta aquí :

push offset aCanTRegister ; “Can’t register”
push offset aKillTheNagscreen_ ; “Kill the nagscreen.”
call ds:MessageBoxA

por problemas de espacio he dejado las instrucciones más importantes, a continuación explico cada una:
el primer, push es un parámetro al igual que el segundo push, debemos saber por eso que parámetros necesita la API MessageBoxA, para poder saber que esos son los parámetros usados para mostrar nuestra ventanita, que debemos anular.

Miremos un poco mas arriba en esa rutina y encontramos esto:

_text:00401355 loc_0_401355: ; CODE XREF: _text:0040132D j

hagamos click en la parte resaltada con amarillo y nos llevará al lugar desde donde es llamada esta rutina para mostrar la ventanita.

Aquí nos lleva:
jz short loc_0_401355

Ok, este es el salto que produce la ventana, matémoslo bruscamente, para eso usemos la instrucción NOP (No OPeration), para anular ese salto, el código de operación de esta instrucción es 90, ¿Qué es código de operación? Simplemente, el valor que toma la instrucción cuando es compilada por la computadora, entonces para entendernos con ella crudamente, debemos hablar su mismo idioma, esto quiere decir, tomar un editor hexadecimal, como hex workshop por ejemplo e ir al offset, de esta instrucción el cual nos dice IDA debajo de todo en el cuarto campo, este es 132D.

Como estos saltos ocupan dos posiciones compilados debemos poner dos NOP’s, o sea dos 90, en esa posición y en la que sigue.

Ejecutemos la víctima, hagamos click en la opcion Register…… ¡Bingo!

Ahora, vamos por la otra ventanita, esta ventana es creada debes en cuando, no tome el tiempo, pero estimo que si no es por tiempo fijo, es aleatoria, eso mucho no interesa, ya que lo que queremos es anularla, entonces, lo que me guió a mí como ya les comenté es la API CreateThread la cual sirve para crear un nuevo hilo de proceso, mientras la aplicación principal se ejecuta en otro proceso distinto, entonces, los mensajes de una ventana no traba a la otra, permitiendo el efecto “multitarea”, la teoría de programación multihilo es muy interesante pero no profundizaremos en esto más que por la definición que acabo de dar.

Busquemos el string “Kill the nagsreen.” De nuevo, miremos un poco más debajo de esa rutina y aparece nuestra querida API CreateThread, de esta manera: call ds:CreateThread

Ok, hagamos doble click la referencia de que hace al principio de la rutina, como la rutina analizada anteriormente, esto nos dice desde donde es llamada la rutina, viendo directamente el salto que debemos NOPear en nuestro caso.

Nos lleva aquí: jz short loc_0_401374

El cual debemos topear igual que el otro salto, para que ya no tenga más efecto esa rutina, y la asquerosa ventanita aleatoria no aparezca más.

Como verán, existen muchísimas formas de proteger un programa, y yo en particular pienso que deben existir cientos de otras formas, mezclas de protecciones, como por ejemplo la que acabamos de ver, en la que se implementa muy bien la API CreateThread, para crear una ventana nueva, y además una nag screen en la opción register.

Más adelante veremos, protecciones CD-Check, y quizás vayamos mas arriba aun, código automodificable, encriptación, key-files, etc.

Cada una, tiene su pro y su contra, en algún momento quizás también nos topemos, con programas que verdaderamente son DEMOS, y les falta implementar la opción “Save as…”, por ejemplo, en estos casos, usaremos las técnicas de reversing, en la que deberemos saber Win32Asm (ensamblador de 32bits para Windows), hacer injertos de código, conocer la estructura de los archivos PE, y demás cosas muy interesantes.

También, en esta carrera nos toparemos con los “loaders”, programas que parchean en memoria, y desprotegen “runtime” a los programas, veremos como funcionan, como hacer uno propio, en un lenguaje fácil (VB, Delphi), cuando y como usarlos.

Quizás lleguemos a ver mas adelante, protecciones llamadas dongles, las famosas “mochilas”, esta es una protección por hardware, que necesita de un determinado hardware conectado a uno de los puertos de la pc, para que el programa funcione.

El cracker, debe tener una mente abierta, analizar un programa protegido, es toda una aventura, es conocer, aprender, desafiarnos, y crecer, en conocimiento, y sobre todo en paciencia.

Ok, hasta aquí hemos llegado, para la próxima veremos opciones desactivadas y/o cd-checks.

¡Suerte!
¡Happy Cracking!

SparK

convert this post to pdf.

CuTedEvil CrackMe #1

Análisis y Parcheo.

Buenas, a todos los lectores de @rroba, soy SparK, del team DisidentS, y les ofrezco mis nobles y humildes conocimientos en este arte de la Ingeniería Inversa.

Espero que se diviertan tanto como yo lo he hecho con este crackme, en realidad no es nada difícil, pero a veces es lindo acorralar fácilmente a una víctima o no?

Quizás algunos de ustedes sean avezados Reverser’s y piensen al leerme, ¿pero que es esto? ¿El abecedario una y otra vez?, quizás otros novatos newbies, o simplemente lectores interesados en este arte digan: “mmmm, interesante”, quiero que sepan todos ustedes, intentaré darles siempre pensamientos frescos e ideas nuevas, por eso es bello este arte, es muy diverso.

Pero, vamos por partes, dijo Jack el Destripador, ¿Qué es un Crackme?

Ok, para los que no lo saben, un crackme es un programita que sirve para ejecitarse en el arte de la ingeniería inversa, en pocas palabras, es un “ejercicio de aplicación”.

¿ Que lograremos crackeando un crackme?

Pues, muchísimas cosas, primero, hay crackmes con las mas diversas protecciones y ocurrencias, en síntesis sirve para poder aprender, concentrarse en ese código difícil de aprender e interpretar a simple vista llamado Ensamblador, para poder memorizar técnicas, rutinas, y luego, en otro momento cuando miremos otro código digamos, “ah!, es mas o menos parecido a…” , en fin, ejercitas, la lógica, la memoria, y a la vez si no sabes o no entiendes ni medio de lo que pasa en ese maldito crackme, aprendes, que es lo más importante que te puede suceder aquí.

Les daré mas pistas, existen muchos tipos de ejercicios de aplicación, algunos de ellos son los Reverse me’s, los Tool me’s y demás, los primeros debes conocer ensamblador a fondo, y reprogramar la aplicación, o inclusive agregar código faltante, ¿ interesante no ? , ya veremos algunos, no desesperéis….

Este Crackme, lo he bajado de www.crackmes.de , y hasta hoy no tenía solución.

El crackme, tiene un aspecto como una caja de registro típica de cualquier programa, deberemos ingresar Nombre de Usuario, Serial, y luego click en Check.

Si hacemos click en Read the Rulez!, nos dirá que debemos programar un keygen, ok, ¿que es eso? Un programa que genere seriales aceptables para el crackme, ingresandole cualquier nombre de usuario, para poder hacer esto debemos conocer y entender que sucede dentro del crackme y como se calcula el serial a partir de un nombre de usuario dado.

Ok, empecemos parcheándolo, ¿porque? , pues porque no tenemos que analizar mucho para parchearlo, aunque no este permitido en las reglas del juego, lo haré para explicarles a los más novatillos como se debe hacer.

Les comento algo a todos, parchear es nocivo para la mente del cracker, se dice que es un sucio crack, aquel que pudiendo aplicar técnicas mas “finas”, parchea, ¿ porque ?, porque aquí queremos aprender, y el facilismo nos lleva a la mediocridad, entonces, si parcheamos, es fácil crackearlo, como verán solo cambiando uno o dos bytes, pero si hacemos un serial fishing, y aún muchísimo mejor , programamos una keygen, estamos demostrandonos sobre todo, que sabemos bien lo que sucede en nuestra querida pc, y que podemos entender tarde o temprano, lo que sea. Aunque si no está a nuestros alcances hacer un keygen aún, paciencia, parchear es divertido

Carguemos el Olly, (¿que porque olly?, porque me anda muy bien en mi win xp), y ejecutemoslo, presionando F9, ¿que sucede?, aparece nuestro programilla, ponemos un nombre de usuario, SparK, ahora un serial, 0123456, y click en Check, que sucede?……… NADA!

Ok, se dice en el Zen Cracking, que todo cracker necesita una referencia para penetrar en el código de un programa, los seres humanos, tenemos referencias, los objetos los identificamos con los sentidos, son distintos, son reconocibles, en el cracking sucede lo mismo, el cracker necesita un punto de referencia, al principio los novatos necesitan puntos de referencia mas “humanos”, pero luego, te acostumbras al lenguaje interno de las máquinas y empiezas a encontrar referencias que antes no veías, esto , se llama práctica.

Nuestro punto de referencia, aquí sería un cartel, llamado messagebox que diga “Incorrect Serial” o algo por el estilo, entonces, nosotros desensamblaríamos el programa, y buscaríamos donde se llama a ese messagebox y un poco antes encontraríamos el salto que nos lleva al cartel exitoso o al fracaso, simplemente invertirlo y PUM!, “You are registered”.

Pero no, no soñemos mas, enfrentemos la realidad, no hay messagebox, no nos dice nada, pero tampoco nos registra y eso nos pone mal, muy mal.

Ok, busquemos en el Olly, por alguna referencia de strings, miremos un poquito más abajo y encontramos algo como esto:

Perfecto!, algunas referencias hemos encontrado, miren esta, “Congratulations, you cracked this program ”, miremos mas arriba de esta referencia, y encontramos este salto:

004012E8 |. 74 0F |JE SHORT CuTedEvi.004012F9

Bien, si invertimos ese salto, tendríamos que estar registrados, probemos cambiar el 74 por un 75 (JNE), hagamos click sobre la instrucción de salto, presionemos la tecla espaciadora, y ahora, cambiemos el JE por un JNE, y listo, apretemos F9, ¿¿que pasa?? nada, sigue haciendo lo mismo, ¿pero que pasa aqui?

Seguramente existe lo que se llama, mirror check, es un chequeo primario o secundario, que se hace en otra parte del código, que seguramente chequea longitud del nombre de usuario, del serial ingresado, o algun cálculo con ellos posterior, miremos un poco más, ¿ven porque no es bueno parchear a lo bruto?, si no conoces el código y lo haces mecánicamente, puedes quedar mal parado ante una demostración ;oD

¿Pero, como encontrar el otro chequeo?, miremos, observermos, debugiemos el código, una y otra vez, pongamos breakpoints, haber, ¿ que sucede generalmente en estas rutinas a nivel interno para obtener los textos introducidos por el usuario?, una pista, referencia, aparentemente oculta, pero existe, generalmente se llama a la API GetDlgItemText, o GetDlgItemTextA, para obtener el texto, pues ¿que hace?, obtiene el texto del editbox del nombre de usuario por ejemplo, y pone en el registro EAX la longitud del texto introducido.

Busquemos la/las llamadas a esta hermosa API…..

Aquí hay algo interesante:

Ok, tenemos en 0040115B que carga el ID de uno de los editbox, seguramente el del nombre de usuario, y en

0040117E, el ID del serial, ahora 00401166 y en 00401191 es llamada la API mencionada.

Fijense algo curioso, luego de llamarlas a las APIs encontramos lo siguiente:

0040118E CMP EAX,0

00401191 JE CuTedEvi.0040132B

Recuerden que les conté en secreto que GetDlgItemTextA, devuelve en EAX la longitud del texto extraído de una editbox, entonces, aquí compara la longitud con 0 y si es 0, salta a otro lado, con lo que no iría por buen camino, ya que nosotros debemos ingresar un serial y un nombre de usuario, sino no chequeará nada y seguirá su rumbo…..

Existe otra API llamada lstrlenA, que justamente obtiene la longitud de una string. ¿ pero porque esta llamada aquí ?, si ya sabemos cuanto tiene cada string… quiere decir, que debe necesitarlo, miremos:

PUSH CuTedEvi.0040332B ; /String = “”

CALL <JMP.&KERNEL32.lstrlenA> ; \lstrlenA

CMP EAX,0

JE SHORT CuTedEvi.004012F7

De nuevo un chequeo por 0, y salta a donde el otro chequeo lo hace, 004012F7, como podemos ver, ese salto, es por donde NO debemos ir.

Bien, pensemos ahora, que sucede, ¿si no salta a 004012F7?, algo hace, algo debe hacer, y de hecho lo hace…

ROL es una instrucción de cálculo, rota los bits hacia la izquierda, hagamos de cuenta que multiplicamos por 5 (en decimal) un valor.

SUB resta 123 (en hexadecimal).

ADD suma 321 (en hexa también)

CMP compara con un valor, en este caso 2FE.

Luego si, no es EAX ese valor esperado, salta al famoso salto del fracaso.

Apliquemos Ingeniería Inversa:

el valor esperado en eax como resultado de los cálculos es 2FE (33 en decimal), en EAX, tenemos la longitud de la cadena serial luego de llamar a lstrlenA, entonces, hagamos el cálculo inverso para ver, que longitud necesitamos tener en el editbox serial.

Tomemos 2FE, restemosle 321, esto nos da un número negativo FFFFFFFFFFFFFFDD, ahora sumemos 123, y nos da 100 (siempre en hexadecimal, no se confundan), ahora ROL multiplica por 5, ahora DIVIDAMOS por 5, ¿¿ y que obtenemos ?? un lindo y hermoso 33.

Esa, esa cifra señores, es la longitud que el programa necesita que tenga el serial, para poder seguir chequeando.

Ahora , modifiquemos el valor del serial, y miremos, que pasa: 012345678901234567890123456789012 , ese serial introduje yo, 33 valores cualquiera ni más, ni menos…

Ahora miremos que estamos muy cerca de los cartelitos de antes, ¿se acuerdan?, ok, les muestro que pasa antes:

Ok, tenemos el salto que habíamos parcheado hoy, pero, con la diferencia que sabemos que pasa antes, ahora solamente lo que podemos hacer son dos cosas, o introducir un número cualquiera de 33 caracteres, y luego parchear ese salto, o sino, parchear los dos saltos:

Primero: CMP EAX,2FE

JNZ SHORT CuTedEvi.004012F7

Segundo: CMP BL,0

JE SHORT CuTedEvi.004012F9

y Listo!, felicidades lo has logrado.

convert this post to pdf.

Hola a todos, el otro día buscando un FlashFXP para bajar algo , encontré la última versión….la bajé….al ejecutarla, me pidió número de serie… utilicé el keygen que lo acompañaba.

Cuando puse el serial el programa siguió su camino, me apareció una ventanita que decía c:\windows\system32 ….

Me pareció muy raro y sospeché de un virus… obviamente seguí utilizando el programa, y NOD me avisó que “algo” se quería conectar… algo con nombre como qsyrjrwes.exe en la carpeta Datos de Programa de mi usuario en Windows XP.

Obviamente, escribí en arroba sobre ese EXE, para ver de que se trataba, era un simple downloader, definido como downloader.Win32… Ya postearé el artículo explicando de qué se trata…

Bueno obviamente, el EXE de flashfxp estaba “envuelto” por un dropper, éste sacaba el downloader, y después hacía ejecutar al flashfxp normalmente…

Empezando a mirar el EXE, encontramos algunas strings que se cargan, y mirándolas por arriba, pienso que son strings encriptadas que desencripta en tiempo de ejecución…

Seguramente para evitar que los AV’s detecten el proceso…

Cuando debuggeemos por las strings “.dll” y “.exe”, más precisamente en las direcciones 408D03 y 408D15 veremos estas cosas en la pila:

0012FFAC   01141C30  0
 ASCII “C:\WINDOWS\system32\niksr.dll”

y luego,

0012FFA8   01141CA4  ¤
 ASCII “C:\DOCUME~1\SPARKR~1\CONFIG~1\Temp\setup.exe”

Luego de eso, en estas direcciones podremos ver que el ejecutable creado en la carpeta temporal de nuestro windows, posee un icono de flashfxp… es raro..

00408D39  |. A1 C8A94000    MOV EAX,DWORD PTR DS:[40A9C8]

00408D3E  |. E8 BDFDFFFF    CALL setup-pr.00408B00

En estas dos líneas se ejecuta el EXE liberado en la carpeta temporal de Windows. Igualmente no es el EXE final.

Veremos que entrando al CALL mencionado dos líneas más arriba, y mirando un poco más, se crea un objeto Mutex.

Veamos para que sirve un mutex (una definición de la red…):

“Un mutex funciona exactamente del mismo modo que las secciones críticas. La única diferencia en las implementaciones Win32 es que la sección crítica esta limitada para ser usada con solamente un proceso. Si tienes un programa que usa varios hilos, entonces la sección crítica es liviana y adecuada para tus necesidades. Sin embargo, cuando escribes una DLL, es muy posible que diferentes procesos usen la DLL en el mismo momento. En este caso, debes usar mutexes, en lugar de secciones críticas.”

Veremos en la imagen, que genera un código único, que se utiliza como nombre del mutex, para crearlo, con la API CreateMutexA.

Seguido de esto, parece que nuestro troyano necesita descomprimir una dll denominada bcdsa.dll, veamos:

EAX apunta al string C:\WINDOWS\system32\bcdsa.dll.

El ejecutable busca el archivo bcdsa.dll y si no existe, lo crea.

Luego de crear la DLL, descomprime el segundo EXE como hemos visto que el path estaba en memoria y crea el Thread finalmente con la DLL deseada. Capturemos la DLL, para futuro análisis.

Si vamos a buscar la DLL y vemos propiedades encontraremos una descripción extraña:

O es una librería que necesitará el flashfxp final o es algo más…

Luego de que el Thread es creado, nos aparecerá la ventanita con el mensaje: “c:\windows\system32″, esto es lo que me hizo sospechar de la actividad de este ejecutable. Es una falla de programación importante, ya que se da a conocer muy sencillamente, parece que el programador tenía pocos recursos para poder darse cuenta cuando la DLL estaba cargada en memoria…

Ahora veremos el segundo ejecutable.

Una vez que nuestro amigo está descomprimido veremos que al cargarlo está hecho en C, por eso mismo carga nuestra DLL, que se trata nada más ni nada menos de las MFC, librerías runtime necesarias.

Este EXE, descomprimirá el FlashFXP final, pero además agregará la descompresión de un downloader… para fines non santos…

El ejecutable de FlashFXP será descomprimido en c:\windows\ bajo el nombre de setup.exe

En esta imagen, podemos ver como ejecuta a FlashFXP original y a su vez, descomprime y crea el downloader, cuyo nombre es aleatorio.

Finalmente, tratará de ejecutar el Downloader, como veremos acá:

Por último el proceso termina, llamando a ExitProcess.

Entonces si queremos nuestro EXE final de FlashFXP, directamente lo buscamos en la carpeta Windows de nuestro sistema.

Nos damos cuenta que el EXE es el original, porque al hacer botón derecho y propiedades, veremos los datos originales de la aplicación. Lo cuál ante un usuario atento, se dará cuenta que los otros ejecutables no son los originales.

Es importantísimo poder tener firmado los ejecutables de nuestras aplicaciones, además de poder tener la información guardada como propiedades del ejecutable, de manera que un usuario puede verificar la autenticidad de varias maneras.

Siempre hay que estar atento a actividades extrañas, como por ejemplo la ventana que sale a modo de información avisando que la DLL ya fue creada, para poder continuar la descompresión…. como lo vimos anteriormente.

Eso es todo, espero que les haya servido y gustado.

Nos vemos la próxima.

convert this post to pdf.

  En el presente escrito se abordará la resolución del CrackME de hispasec, llamado a partir de ahora crackme o reto, detallando las siguientes partes.

•  ¿Qué se pretende?
•  Encontrando la zona de interés.
•  Análisis del algoritmo.
•  Generación de un fichero válido.
•  Fallos de diseño.
•  Despedida y cierre.

  El crackme y el fichero de licencia lo podeis encontrar en el siguiente enlace.

• CrackME!

  El objetivo de este reto, es generar un fichero de licencia válido y explicar los fallos de diseño encontrados en los hilos. Quiero comentar que en este documento encontraremos lo que a mi juicio son fallos de diseño, no tienen porque coincidir con los criterios de los autores del reto. Para la resolución de este reto se ha utilizado un depurador y un editor hexadecimal, en mi caso he optado por Ollydbg y por Hex Workshop.    

  Para llegar a la zona que nos interesa analizar, y sabiendo de antemano que necesitamos un fichero de licencia, tenemos varia maneras de abordar nuestro cometido; explicaré un par de ellas.

•  Localizando la función de chequeo mediante referencias a cadenas.

Nada más cargar nuestro reto en el depurador, parados en el oep, buscamos referencias a cadenas con search for > All referenced text strings. Obtenemos esto.

Podemos ver las cadenas “crackem.lic”, “Good job!” y “Keep trying”, es evidente que nuestro objetivo es “Good job”. Seguimos la cadena y caemos en este punto.  

En función de un par de comparaciones carga una de las cadenas. Seguimos el código hacia arriba, para ver donde se inicia esta función.

Aquí encontramos el inicio de la función, en la dirección 004010B0, vamos a fijarnos un momento que llama a la API CreateFileA, pero el atributo Mode es OPEN_EXISTING. Esto es importante para el siguiente punto.

•  Localizando la función de chequeo utilizando la API de Windows.

Ahora vamos a utilizar la API de Windows para llegar al mismo punto. Nada más cargar nuestro reto en el depurador, parados en el oep, buscamos referencias a APIs cargadas con search for > Name (label) in current module. Obtenemos esto.

Vamos a poner un BP en cada API específica de ficheros.

KERNEL32.CreateFileA

KERNEL32.GetFileSize

KERNEL32.GetFileType

KERNEL32.ReadFile

KERNEL32.WriteFile

Ejecutamos varias veces y vemos unas cuantas paradas antes de llegar a este BP en la dirección 004010CB, tal como vemos en esta imagen.

Seguimos el código hacia arriba, para ver donde se inicia esta función. Encontramos el inicio en la dirección 004010B0.

Como ya hemos localizado la función de chequeo, ahora vamos a centrarnos en analizarla.

La función comprueba que existe el fichero “crackme.lic” , mira el tamaño del fichero, crea un buffer para guardar los datos, vuelca el contenido del fichero en el buffer creado, lanza los hilos que comprueban si los datos que hemos volcado son válidos y analiza el resultado de los hilos para decidir que cadena muestra. Esto corresponde al siguiente esquema.

Bueno, lo realmente interesante esta en los hilos de ejecución, así que vamos a ver que es lo que hacen los mismos. Vamos a fijarnos en el argumento Thread Function, vemos que tiene el parámetro 00401000, este es el inicio de la función que ejecuta el hilo.

Los bytes del fichero llave deben ser menores de 0Ah, es decir menores de 10d, si el hilo encuentra un byte igual a FFh, termina el análisis. Si nos fijamos, la función tiene dos salidas, una en la que realiza un “XOR EAX,EAX” o lo que es lo mismo, poner EAX a 0; y otra que realiza un “MOV EAX,1″ o lo que es lo mismo, poner EAX a 1.

¿Cómo conseguimos poner EAX a 1?, si solucionamos esta pregunta, tenemos solucionado el problema; para conseguir la ejecución de ese salto, debemos lograr que el resultado de AL tras la ejecución del código sea igual a 09h. Veamos más claramente la ejecución.

El proceso le el primer byte del fichero, carga otro byte que utiliza para los cálculos, vamos a llamarlo byte auxiliar o aux; este byte, al principio va a estar a 0. Tras esto realiza una operación con este byte, aux = aux + 4*aux, esto lo guarda en edx. Carga en bl el dato leído del fichero y este dato junto con aux, lo utiliza para acceder a una tabla de bytes; el calculo es el siguiente desplazamiento = dato + aux * 2.

En nuestro caso necesitamos un desplazamiento de 48h, si no conseguimos cargar el 09h, el byte apuntado se convierte en el nuevo aux. Y esto se repite hasta encontrar FFh.

Bueno, conociendo el algoritmo, es fácil generar un fichero válido, solo necesitamos conocer la tabla de bytes que hemos comentado anteriormente. Es la siguiente (las cabeceras de la tabla están representadas en decimal.).

1 .- Bytes hexadecimales.

Necesitamos conseguir un desplazamiento de 72d bytes. Para ello vamos a realizar las siguientes operaciones.

Aux = 0 (la primera pasada del algoritmo).

Data = 06 (Primer byte del fichero).

0 + 0*4 = 0.

6 + 0*2 = 6.

Cargamos el byte que hay con desplazamiento 6; el 04.

No es 09, por tanto lo usamos como nuevo aux.

Aux = 04.

Data = 07 (Segundo byte del fichero).

4 + 4*4 = 20.

7 + 20*2 = 47.

Cargamos el byte que hay con desplazamiento 46; el 08.

No es 09, por lo tanto lo usamos como nuevo aux.

Aux = 08.

Data = 01 (Tercer byte del fichero).

8 + 8*4 = 40.

1 + 40*2 = 81

Cargamos el byte que hay con desplazamiento 81; el 07;

No es 09, por lo tanto lo usamos como nuevo aux.

Aux = 07.

Data = 02 (Cuarto byte del fichero).

7 + 7*4 = 35.

02 + 35*2 = 72.

Cargamos el byte que hay con desplazamiento 72; el 09.

Es 09, por lo tanto terminamos en el return que nos interesa.

Si nos fijamos, el segundo hilo, utiliza exactamente la segunda función, además, la tabla de bytes no es modificada, por tanto, sólo tenemos que duplicar la cadena de bytes obtenida anteriormente y replicarla. Al final, añadimos el byte de fin que utiliza el programa, el FFh.

La cadena de bytes que necesitamos escribir para generar un fichero válido es la siguiente: “0607010206070102FF”. Esto lo podemos hacer con nuestro editor hexadecimal preferido. Una vez realizado esto, tenemos solucionado este reto.

A continuación, comento lo que a mi juicio son fallos de diseño en el algoritmo.

•  Existe un fragmento de código, que no es necesario para la resolución del reto,

00401070   .  68 CE070000   push 7CE

00401075   .  FFD6                call esi                                 ;  kernel32.Sleep

00401077   .  EB 04               jmp short crackme.0040107D

0040107D   > \E8 67010000  call crackme.004011E9

00401082   .  99                     cdq

00401083   .  B9 32000000   mov ecx,32

00401088   .  F7F9                idiv ecx

0040108A   .  52                    push edx

0040108B   .  FFD6               call esi                                 ;  kernel32.Sleep

Si se ha utilizado a modo de código basura, debería de repartirse más por la función o diseñarse de alguna otra manera ya que es muy obvio comprobar que no es necesario analizarlo para la resolución del reto.

•  Los dos hilos que se lanzan para comprobar el fichero llave, utilizan la misma función y esta hace exactamente lo miso. Podríamos haber solucionado esto utilizando por ejemplo dos puntos de entrada para la función o una modificación de la misma. Otra opción hubiese sido utilizar otra función que comprobase otras propiedades del los bytes del fichero.

•  Al utilizar el segundo hilo para chequear los bytes del fichero, si no hemos modificado la función ni hemos utilizado otra función distinta, al menos deberíamos haber cambiado la tabla de bytes para forzar un nuevo cálculo de la segunda parte de los bytes del fichero.

Un Saludo a los miembros de Disidents.org, al canal #crackers, a thEpOpE, a NoMuRyTo y a toda la gente que me dejo pero sabe que puede darse por saludada. Espero que no seais muy duros en las críticas de mi primera publicación.

convert this post to pdf.