While Crackmes.de returns, I leave a couple of files for practice.
Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.
In the folder crackmes.de_mirror you have two files:
En la carpeta crackmes.de_mirror tienes dos archivos:
password of files = deurus.info
Segunda crackme con RSA que afrontamos. Esta vez se trata de un crackme realizado en VC++ 7.0 y en sus entrañas utiliza RSA-127. Una cosa que no comenté en la entrega anterior (RSA-200), es que conviene utilizar el plugin Kanal de PEiD para localizar cuando se utilizan números grandes o determinados hashes como MD5 o SHA1.
Otra cosa es que os quería comentar es la coletilla 127. Esta lo determina el módulo n e indica el número de bits de éste.
n = p * q
fi(n)=(p-1)(q-1)
Puede calcularse d=((Y*fi(n))+1)/e para Y=1,2,3,... hasta encontrar un d entero.
c = m^e mod n
m = c^d mod n
Con OllyDbg analizamos la parte del código que nos interesa.
0040109B . 68 00010000 PUSH 100 ; /Count = 100 (256.) 004010A0 . 52 PUSH EDX ; |Buffer = RSA127.<ModuleEntryPoint> 004010A1 . 68 EA030000 PUSH 3EA ; |ControlID = 3EA (1002.) 004010A6 . 8B8C24 28020000 MOV ECX,DWORD PTR SS:[ESP+228] ; | 004010AD . 51 PUSH ECX ; |hWnd = NULL 004010AE . FF15 F0B04000 CALL DWORD PTR DS:[<&USER32.GetDlgItemTex>; \GetDlgItemTextA 004010B4 . 8D5424 04 LEA EDX,DWORD PTR SS:[ESP+4] 004010B8 . 57 PUSH EDI 004010B9 . 52 PUSH EDX ; RSA127.<ModuleEntryPoint> 004010BA . 50 PUSH EAX ; kernel32.BaseThreadInitThunk 004010BB . E8 201E0000 CALL RSA127.00402EE0 004010C0 . 83C4 0C ADD ESP,0C 004010C3 . 8D9424 04010000 LEA EDX,DWORD PTR SS:[ESP+104] 004010CA . 68 00010000 PUSH 100 ; /Count = 100 (256.) 004010CF . 52 PUSH EDX ; |Buffer = RSA127.<ModuleEntryPoint> 004010D0 . 68 EB030000 PUSH 3EB ; |ControlID = 3EB (1003.) 004010D5 . 8B8C24 28020000 MOV ECX,DWORD PTR SS:[ESP+228] ; | 004010DC . 51 PUSH ECX ; |hWnd = NULL 004010DD . FF15 F0B04000 CALL DWORD PTR DS:[<&USER32.GetDlgItemTex>; \GetDlgItemTextA 004010E3 . 8D9424 04010000 LEA EDX,DWORD PTR SS:[ESP+104] 004010EA . 52 PUSH EDX ; RSA127.<ModuleEntryPoint> 004010EB . 8B4C24 04 MOV ECX,DWORD PTR SS:[ESP+4] 004010EF . 51 PUSH ECX 004010F0 . E8 5B1F0000 CALL RSA127.00403050 004010F5 . 68 08B14000 PUSH RSA127.0040B108 ; ASCII "666AAA422FDF79E1D4E41EDDC4D42C51" 004010FA . 55 PUSH EBP 004010FB . E8 501F0000 CALL RSA127.00403050 00401100 . 68 2CB14000 PUSH RSA127.0040B12C ; ASCII "29F8EEDBC262484C2E3F60952B73D067" 00401105 . 56 PUSH ESI 00401106 . E8 451F0000 CALL RSA127.00403050 0040110B . 53 PUSH EBX 0040110C . 55 PUSH EBP 0040110D . 56 PUSH ESI 0040110E . 8B5424 24 MOV EDX,DWORD PTR SS:[ESP+24] 00401112 . 52 PUSH EDX ; RSA127.<ModuleEntryPoint> 00401113 . E8 38250000 CALL RSA127.00403650 00401118 . 53 PUSH EBX 00401119 . 57 PUSH EDI 0040111A . E8 31130000 CALL RSA127.00402450 0040111F . 83C4 30 ADD ESP,30 00401122 . 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 00401124 . 74 12 JE SHORT RSA127.00401138 00401126 . B8 01000000 MOV EAX,1 0040112B . 81C4 08020000 ADD ESP,208 00401131 . 5B POP EBX ; kernel32.7590EE1C 00401132 . 5D POP EBP ; kernel32.7590EE1C 00401133 . 5E POP ESI ; kernel32.7590EE1C 00401134 . 5F POP EDI ; kernel32.7590EE1C 00401135 . C2 1000 RETN 10 00401138 > 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 0040113A . 68 5CB14000 PUSH RSA127.0040B15C ; |Title = "Yeah!" 0040113F . 68 50B14000 PUSH RSA127.0040B150 ; |Text = "Nice job!!!" 00401144 . 6A 00 PUSH 0 ; |hOwner = NULL 00401146 . FF15 F4B04000 CALL DWORD PTR DS:[<&USER32.MessageBoxA>] ; \MessageBoxA
El código nos proporciona el exponente público (e) y el módulo (n).
Finalmente realiza un PowMod con el número de serie del disco C y el par de claves (e,n).
Una vez localizados los datos anteriores lo siguiente es factorizar para obtener los primos p y q y finalmente d.
d = 65537
Nº serie disco C = -1295811883 Serial = hdd.getBytes()^d mod n Serial = 2d31323935383131383833^65537 mod 666AAA422FDF79E1D4E41EDDC4D42C51 Serial = 1698B6CE6BE0D388C31E8E7895AF445A
El keygen está hecho en Java ya que permite trabajar con números grandes de forma sencilla.
JButton btnNewButton = new JButton("Generar");
btnNewButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
BigInteger serial = new BigInteger("0");
BigInteger n = new BigInteger("136135092290573418981810449482425576529");
BigInteger d = new BigInteger("415031");
String hdd = t1.getText();
BigInteger tmp = new BigInteger(hdd.getBytes());
serial = tmp.modPow(d, n);
t2.setText(serial.toString(16).toUpperCase());
}
});
File carving is the process of reassembling computer files from fragments in the absence of filesystem metadata. Wikipedia.
«File carving», literalmente tallado de archivos aunque lo traduciremos como extracción, es el proceso de re-ensamblado de archivos extraídos de un conjunto de mayor tamaño.
Header = Cabecera
Footer or tail = Pie
All this documents have the same header and footer, because of this, we need search the middle bytes. This type uses a ZIP file package.
Los documentos de Microsoft Office >2007 tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.
All this documents have the same header and footer, because of this, we need some bytes to differentiate them. In this case we can do this jumping 73 bytes from header. This type uses a ZIP file package.
Los documentos de OpenOffice tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.
Note: >2007 versions have two patterns and the key is the position 0x80. If in this position we get the bytes «68 40 F8 F7 92», we need to search again for this bytes and displace 107 bytes to find the end of the file. If in the position 0x80 we get another different bytes, we need to search again this bytes and displace 1024 bytes to find the end of the file.
Nota: Las versiones >2007 siguen dos patrones y la clave está en la posición 0x80. Si en la posicion 0x80 obtenemos los bytes «68 40 F8 F7 92», los buscamos una segunda vez y ha 107 bytes encontramos el final del archivo. Si en la posición 0x80 obtenemos otros bytes diferentes a los del primer caso, los volvemos a buscar y a 1024 bytes hallaremos el final del archivo.
Toda esta aventura comienza con un archivo llamado pretty_raw, sin extensión. Porque sí. Porque las extensiones son una invención heredada de CP/M, precursor de MS-DOS, que Windows terminó de popularizar. Porque son innecesarias. Y porque echo de menos cuando los archivos se reconocían por sus permisos… y no por cómo se llamaban.
Como iba diciendo, todo esto comienza mediante el análisis de pretty_raw. Mirando debajo de la falda con un editor hexadecimal encontramos unos cuantos bytes aleatorios hasta dar con una cabecera PNG.
Si atendemos a la captura, justo antes de la cabecera PNG tenemos 116.254 bytes (0x1C61E). Tomad nota que este número será relevante más adelante.
Extraemos el PNG, lo visualizamos y lo pasamos por todas las herramientas habidas y por haber. Nada funciona. Volvemos a visualizarlo con atención y vemos que hace referencia a un archivo llamado flag.png con unas dimensiones que no coinciden con la extraída.
Toca centrarse y pensar en que camino tomar. Hemos gastado tiempo con el PNG extraído y quizá lo mejor sea centrarse en los bytes que inicialmente hemos descartado. En concreto se trata de un bloque de 116.254 bytes, pero espera, 1570×74=116.180 bytes. ¡Mierda!, no coincide exactamente con los bytes extraídos. Bueno, da igual. Si suponemos que el PNG que buscamos no tiene compresión y que cada pixel ocupa un byte (escala de grises y 8 bits), su tamaño depende únicamente de la geometría y de cómo se almacenan las filas en memoria. Vamos a procesarlo con Python para salir de dudas.
import numpy as np
from PIL import Image
INPUT_FILE = "pretty_raw"
OUTPUT_FILE = "pretty_raw_flag.png"
WIDTH = 1570 # ¿estás seguro?
HEIGHT = 74
DEPTH = 8 # bits
# Leer archivo como RAW
with open(INPUT_FILE, "rb") as f:
raw = f.read()
expected_size = WIDTH * HEIGHT
if len(raw) < expected_size:
raise ValueError("El archivo no tiene suficientes datos")
# Convertir a array numpy (grayscale 8 bits)
img = np.frombuffer(raw[:expected_size], dtype=np.uint8)
img = img.reshape((HEIGHT, WIDTH))
# Crear imagen
image = Image.fromarray(img, mode="L")
image.save(OUTPUT_FILE)
print(f"Imagen generada correctamente: {OUTPUT_FILE}")
El script nos devuelve un PNG válido pero con las letras torcidas. Tras darle vueltas me di cuenta de que si en el script usamos como WIDTH=1571 en lugar de 1570, la imagen resultante es correcta y tiene todo el sentido del mundo ya que 1571×74=116.254, que son exactamente los bytes que se encuentran antes del png señuelo.
Aunque el ancho visible de la imagen es de 1570 píxeles, cada fila ocupa realmente 1571 bytes. Ese byte adicional actúa como relleno (padding) y forma parte del stride o bytes por fila. Ignorar este detalle lleva a un desplazamiento erróneo acumulativo y por eso se ve la imagen torcida. En este caso concreto da igual ya que el texto se aprecia, pero si el reto hubiera sido más exigente no se vería nada.
Hace unos días intenté contactar con Karpoff ya que fué una inspiración para mi y muchos otros, lo conseguí y se me ocurrió hacerle una entrevista, aquí tenéis el resultado.
Para los recién llegados diré que, Karpoff Spanish Tutor era (y sigue siendo aunque no se actualice), una gran web colaborativa donde encontrar cantidad de manuales y programas en Castellano.
deurus: ¿Qué te llevó a realizar la web?, es decir, que te hizo levantarte una mañana y decir, venga, voy a realizar una web sobre ingeniería inversa.
Karpoff: Pues mira, fue de la siguiente manera. Por aquel entonces (te hablo de los 90 y poco) yo pasaba mi tiempo libre intentando saltar las protecciones de los programas que conseguía generalmente en revistas de informática.
Desconocía que existía un mundillo dedicado a esas artes.
En los años 90 no había internet ni nada parecido que yo sepa, sobre el 95 creo recordar, telefónica saco una cosa que se llamaba Infobia y era una especie de intranet de telefónica donde accedías a un contenido muy limitado, pero te permitía salir de alguna manera bastante limitada también a lo que conocemos como internet (todo era mega lento, velocidades de uno o dos kb por segundo) con módem y llamadas analógicas.
No se como, ya que no existia o no era conocido Google tampoco había casi buscadores, conocí la famosa y maravillosa pagina de «Fravia» dedicada a la ingeniería inversa con muchísima documentación, y proyectos de estudio de protecciones, lamentablemente para el momento hispano, toda la documentación estaba en ingles .
Investigando conocí paginas hispanas con proyectos interesantes (aunque muchas de ellas aun siendo hispanas publicaban todo en ingles)
Conocí también otra pagina, el “ECD” estudio colectivo de desprotecciones + WTK en castellano e ingles que me sorprendió gratamente y donde se publicaban proyectos propios del grupo WTK y de otros grupos como estado+porcino.
los tres grupos hispanos del momento eran WTK, TNT y KUT, pertenecí a TNT durante algún tiempo, aunque el objetivo del grupo no me convencía ya que era exclusivamente la creación de cracks a mansalva por lo que no estuve más de un año.
Yo echaba de menos un sitio como “Fravia” pero en castellano donde todos los interesados pudiéramos colaborar y ayudarnos con temas de ingeniería inversa.
Ya en los 90 y mucho, todo lo relacionado con internet había evolucionado bastante, las conexiones también eran mas rápidas, ya no hacia falta conectarte a infobia sino directamente a internet.
Yo disponía de mucho tiempo libre y empecé un proyecto en solitario “Karpoff Spanish Tutor” mas conocido como “la pagina de karpoff” con proyectos de mi cosecha y con temas que me gustaban mucho, como la programación, los compiladores el software en general etc.
Luego todo lo demás fue llegando poco a poco, a la gente le gustaba y tenia muchísimas ganas de aprender y sobre todo de colaborar.
El proyecto alcanzo unos niveles impresionantes en cuanto a colaboración y recepción de material, había días que estaba mas de 14 horas actualizando la pagina y buscando nuevos servidores para alojarla, ya que me los cerraban casi semanalmente. Y la verdad.. cada vez me costaba mas tiempo mantener la pagina.
Luego gracias a Red Futura tuvimos un hostin de calidad y gratuito.
El proyecto era tan amplio que me fue imposible conciliar vida laboral y vida en internet todo esto empezaba a ser incompatible.
deurus: ¿Empezaste solo o erais un grupo de amiguetes?
Karpoff: Esta te la he contestado en la primera pregunta, vamos… que empecé yo solo.
deurus: ¿Echas de menos el proyecto?
Karpoff: Hoy en día no. Hace falta muchísimo tiempo libre y muchísima dedicación a nivel organizativo.
Echo de menos el movimiento que se creo y la actividad que alcanzo el movimiento cracking hispano. Salían grupos de cracker con nuevos proyectos y paginas hasta de debajo de las piedras 🙂 la ingenieria inversa se puso un poco de moda, conocí a gente muy interesante como Ricardo Narvaja, Numi_tor, Demian y muchas otras personas con muchos conocimientos.
Después de cerrar la pagina todo se quedo un poco cojo y todo el movimiento se empezó a diluir bastante rápido.
deurus: ¿Lo retomarías día de hoy?
Karpoff: La verdad es que no, ya no es mi tiempo, ahora me dedico al trabajo y mi familia y en ratos libres intento reventar algún programa. Sobre todo crackmes.
deurus: ¿Tienes o colaboras activamente en algún proyecto relacionado con la Ingeniería Inversa?
Karpoff: No, no tengo tiempo. Mantengo contacto por correo con gente de que conocí en esa época y me sorprende que la gente no se olvida de mí. Recibo bastante correo en esta cuenta pidiéndome alguna entrevistilla, opiniones y muchos muchos agradecimientos de mucha gente por la página.
deurus: Yo por aquel entonces tenía 17 años, ¿se le puede preguntar la edad a Karpoff?
Karpoff: Pues yo tengo 45, por aquel entonces tenia unos 29 . La ingeniería inversa siempre fue mi pasión. Desde bien pequeño mi obsesión ha sido conocer como y porque funcionaba todo 🙂 hasta el punto de desmontar todo aquello que me llamaba la atención, mi madre estaba desesperada ya que dejaba todo destripado y muchas veces sin posiblilidad de reparacion.
deurus: ¿Te dedicas a algo relacionado con la informática?
Karpoff: Si, desde esos tiempos me encargo de los sistemas informáticos y equipos técnicos de una empresa bastante conocida, además ese fue uno de los principales motivos del cierre de la página.
Hubo gente interesada en seguir con el proyecto, aunque finalmente todo quedó en nada. Supongo que vieron que el proyecto requería muchísimo tiempo y mucho mucho trabajo.
Me dio mucha lastima no poder seguir con la página y mucha más que nadie se hiciera cargo de ella.
No hace mucho al desaparecer los redireccionadores “come.to” adquirí un dominio “karpoff.es” donde enlace tres mirror de la página para dejar un punto de acceso a ellos.
deurus: Finalmente ¿quieres decir algo a los lectores?
Karpoff: Pues sí, sobre todo dar las gracias a los que me conocen y tuvieron relación con la página, siempre me han hecho sentir grande y siempre tuve mucha colaboración y muchos ánimos por parte de los lectores.
Para los que no me conocen y les gusta la ingeniería inversa, decirles que lo que se aprende crackeando no lo enseñan en ningún sitio 🙂 y es muy muy gratificante.
deurus: Muchas gracias por tu atención, ha sido un placer.
Karpoff: Muchas gracias a ti, me ha hecho mucha ilusión y me ha gustado mucho tu blog.
Saludos !!
Karpoff
Hoy tenemos un crackme realizado en ensamblador y sin empacar. Consiste en el típico serial asociado a un nombre sin mucha complicación excepto en lo que a la utilización de memoria se refiere. Como veremos más adelante si no tenemos cuidado se solapan en memoria el nombre y el serial y como siempre evitaremos eso.
Abrimos el crackme con Olly y buscamos las string references, pinchamos sobre cualquiera y encima encontramos el código que no interesa.
Subimos hasta las funciones que recojen el nombre y serial (GetDlgItemTexA) y nos fijamos que guarda el nombre a partir de la dirección de memoria 403014 y el serial a partir de 40301A. Además el nombre debe tener por lo menos tres caracteres.
El algoritmo consiste en lo siguiente, recorre el nombre y comprueba si el dígito se corresponde con 5A(Z), 7A(z) y 39(9). Si coincide los deja como está y si no les suma 1 al valor ascii. A continuación concatena después de cada conversión de dígito el caracter 61(a) aumentándole en 1 para cada nuevo dígito del nombre.
Ejemplo:
Nombre: ZZZZZ Serial: ZaZbZcZdZe Nombre: zzzzz Serial: zazbzczdze Nombre: 99999 Serial: 9a9b9c9d9e
Como veréis a continuación, para el nombre «deuru» el serial correcto sería «eafbvcsdve«. Simplemente a los caracteres del nombre les suma 1, d es e, e es f, u es v, etc, y los concatena con digito+a+digito+b+digito+c…
Nombre: deuru Serial: eafbvcsdve Bucle se repite tantos veces como dígitos tenga el nombre d e u r u 64 65 75 72 75 e a f b v c s d v e 65 61 66 62 76 63 73 64 76 65 DUMP ---- 00403010 00 00 00 00 64 65 75 72 75 00 65 61 66 62 76 63 ....deuru.eafbvc 00403020 73 64 76 65 00 05 00 00 00 00 00 00 00 00 00 00 sdve...........
El problema viene cuando elegimos un nombre >5 caracteres, ya que, éste se solapa con la memoria del serial (recordemos 40301A y siguientes) haciendo que sea una chapuza. En la siguiente imagen queda claro. No se si es un error o es intencionado, pero nos conviene no utilizar nombres mayores de 5 dígitos para que nuestro keygen sea lo más limpio posible.
Está realizado en C++ y como véis el nombre debe tener entre 3 y 5 dígitos para que todo vaya bien.
char Nombre[10];
GetWindowText(hwndEdit1, Nombre, 10);
SetWindowText(hwndEdit2, "");
string serial = "";
int len = strlen(Nombre);
char consecutivo[5] = {'a','b','c','d','e'};
if (len <=5 && len >=3){
for(int i = 0; i <= len; i++)
{
if (Nombre[i] == 0x5A || Nombre[i] == 0x7A || Nombre[i] == 0x39)
{
serial+=Nombre[i];
serial+=consecutivo[i];
}else{
serial+=Nombre[i]+1;
serial+=consecutivo[i];
}
}
serial = serial.substr(0, len*2);
LPCTSTR Sfinal = serial.c_str();
SetWindowText(hwndEdit2, Sfinal);
}else{
MessageBox(NULL,"Nombre demasiado largo/corto","Info",MB_OK | MB_ICONINFORMATION);
}
Hace poco me reencontré con esta entrañable serie que tanto me entretuvo cuando era pequeño y para mi sorpresa, me percaté de que nunca había visto el episodio piloto. La nostalgia me llevó a tragarme el episodio entero y a disfrutar a lo grande de la parafernalia técnica de la que hace gala para justificar la creación que da nombre a la serie.
Esto hay que analizarlo con perspectiva. Estamos en los años 80 y nos están presentando un coche capaz de mantener una conversación, es decir, nos están presentando una inteligencia artificial (IA) llamada KITT. Puede parecer que el término inteligencia artificial es nuevo pero realmente se acuño en 1956 por John McCarthy. A partir de ese momento surgieron líneas de estudio e hipótesis pero a partir de los 70 se puede considerar que la investigación sobre la IA perdió financiación y quedó en el congelador hasta los años 90. Dicho esto, cuando nos presentan a KITT lo hacen de la siguiente manera:
Devon Miles: Está totalmente controlado por microprocesadores que hacen físicamente imposible que se vea implicado en ningún tipo de colisión o percance a no ser que se lo ordene su piloto específicamente
Michael Knight: ¿Piloto?, no me diga que esta cosa vuela
Devon Miles: ¡No!, pero piensa
Michael Knight: ¿Piensa?, ¿mi coche piensa?
Intel daba a conocer el primer microprocesador allá por el 71 y la serie se estrenó en el 82 lo que le da credibilidad en ese aspecto, aunque dudo que el público de esa época supiera que era un microprocesador, un ordenador y menos una IA.
La serie arranca con un grupo de personas realizando espionaje industrial donde nos muestran las hojas de datos de dos chips Japoneses como son el PD8257-5 y el PD780. Un aplauso para los guionistas y sus asesores ya que el PD8257-5 es una interfaz de comunicaciones y el PD780 un microprocesador de 8 bits.
Lo más interesante es que lo que se muestra es real como podéis apreciar en la siguiente imagen
A continuación un detalle de las capturas realizadas:
Más adelante vuelven a aparecer imágenes en un PC que parecen puestas en post-producción y que son robadas en un maravilloso disco de 5 1/4.
Llaman la atención mucho los diálogos centrados en el microprocesador como si de un ser superior se tratase, éste es la referencia continua y la parte central del guion de los dos primeros capítulos. Curiosamente aparecen en pantalla multitud de imágenes de circuitos integrados pero no se llega a ver ningún microprocesador. Por otro lado, es interesante el esfuerzo que hacen los guionistas por que llamemos a KITT él en vez de ello, convirtiendo al coche en un personaje más.
Otra cosa que llama mucho la atención son los tópicos de los que hace gala como la asociación de los microprocesadores a los videojuegos o que la empresa villana esté afincada en Silicon Valley. Incluso el nombre KITT es un tópico ya que las siglas vienen de Knight Industries Two Thousand que en cristiano quiere decir Industrias Knight 2000. Y es que en mi opinión el año 2000 se imaginaba como una barrera lejana en la que todo iba a ser tecnológicamente más avanzado.
Tengo que reconocer que me ha sorprendido que dieran realismo a los chips mostrados teniendo en cuenta que aparecen muy pocos segundos en pantalla y podían haber puesto cualquier cosa.
Por otro lado, la realidad es que en el año 2022 aún nos queda recorrido para llegar a tener un coche fantástico y lo más parecido que tenemos hoy día sería un Tesla con Alexa.
Se nos entrega el siguiente ELF:
/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>
Detected compiler: GNU C++
*/
#include <defs.h>
//-------------------------------------------------------------------------
// Function declarations
__int64 (**init_proc())(void);
void sub_1020();
// int printf(const char *format, ...);
// int getchar(void);
// int fflush(FILE *stream);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
// int __fastcall _cxa_finalize(void *);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
FILE **deregister_tm_clones();
__int64 register_tm_clones(); // weak
FILE **_do_global_dtors_aux();
__int64 __fastcall frame_dummy(_QWORD, _QWORD, _QWORD); // weak
int __fastcall main(int argc, const char **argv, const char **envp);
_BOOL8 __fastcall comprobacion(char a1, char a2, int a3);
void _libc_csu_fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// int __fastcall __cxa_finalize(void *);
// __int64 _gmon_start__(void); weak
//-------------------------------------------------------------------------
// Data declarations
_UNKNOWN _libc_csu_init;
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
void *_dso_handle = &_dso_handle; // idb
char *a = "MdfnJk"; // weak
char *b = "jYx}"; // weak
char *c = "gWmfk"; // weak
char *d = "mlvpc"; // weak
char *f = "neU++w"; // weak
FILE *_bss_start; // idb
char completed_0; // weak
//----- (0000000000001000) ----------------------------------------------------
__int64 (**init_proc())(void)
{
__int64 (**result)(void); // rax
result = &_gmon_start__;
if ( &_gmon_start__ )
return (__int64 (**)(void))_gmon_start__();
return result;
}
// 40D0: using guessed type __int64 _gmon_start__(void);
//----- (0000000000001020) ----------------------------------------------------
void sub_1020()
{
JUMPOUT(0LL);
}
// 1026: control flows out of bounds to 0
//----- (0000000000001090) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
__int64 v3; // rax
int v4; // esi
__int64 v5; // [rsp-8h] [rbp-8h] BYREF
char *retaddr; // [rsp+0h] [rbp+0h] BYREF
v4 = v5;
v5 = v3;
_libc_start_main(
(int (__fastcall *)(int, char **, char **))main,
v4,
&retaddr,
(void (*)(void))_libc_csu_init,
_libc_csu_fini,
a3,
&v5);
__halt();
}
// 1096: positive sp value 8 has been found
// 109D: variable 'v3' is possibly undefined
//----- (00000000000010C0) ----------------------------------------------------
FILE **deregister_tm_clones()
{
return &_bss_start;
}
//----- (00000000000010F0) ----------------------------------------------------
__int64 register_tm_clones()
{
return 0LL;
}
// 10F0: using guessed type __int64 register_tm_clones();
//----- (0000000000001130) ----------------------------------------------------
FILE **_do_global_dtors_aux()
{
FILE **result; // rax
if ( !completed_0 )
{
if ( &__cxa_finalize )
_cxa_finalize(_dso_handle);
result = deregister_tm_clones();
completed_0 = 1;
}
return result;
}
// 4080: using guessed type char completed_0;
//----- (0000000000001175) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
char v4; // [rsp+7h] [rbp-9h] BYREF
int v5; // [rsp+8h] [rbp-8h]
bool v6; // [rsp+Fh] [rbp-1h]
v6 = 1;
v5 = 0;
while ( v6 )
{
fflush(_bss_start);
printf("\nIntroduce la letra correcta:\t");
__isoc99_scanf("%c", &v4);
getchar();
if ( v5 > 5 )
{
if ( v5 > 9 )
{
if ( v5 > 14 )
{
if ( v5 > 19 )
v6 = comprobacion(v4, f[v5 - 20], 10);
else
v6 = comprobacion(v4, d[v5 - 15], 2);
}
else
{
v6 = comprobacion(v4, c[v5 - 10], 8);
}
}
else
{
v6 = comprobacion(v4, b[v5 - 6], 17);
}
}
else
{
v6 = comprobacion(v4, a[v5], 5);
}
if ( !v6 )
{
printf("Incorrecta");
exit(1);
}
printf("\n%c\n", (unsigned int)v4);
if ( v5 == 25 )
{
printf("Ya tienes la flag!!");
exit(1);
}
++v5;
}
return 0;
}
// 1060: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4050: using guessed type char *a;
// 4058: using guessed type char *b;
// 4060: using guessed type char *c;
// 4068: using guessed type char *d;
// 4070: using guessed type char *f;
//----- (0000000000001352) ----------------------------------------------------
_BOOL8 __fastcall comprobacion(char a1, char a2, int a3)
{
return a1 == (a3 ^ a2);
}
//----- (0000000000001390) ----------------------------------------------------
void __fastcall _libc_csu_init(unsigned int a1, __int64 a2, __int64 a3)
{
signed __int64 v4; // rbp
__int64 i; // rbx
init_proc();
v4 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
if ( v4 )
{
for ( i = 0LL; i != v4; ++i )
((void (__fastcall *)(_QWORD, __int64, __int64))*(&_frame_dummy_init_array_entry + i))(a1, a2, a3);
}
}
// 1170: using guessed type __int64 __fastcall frame_dummy(_QWORD, _QWORD, _QWORD);
// 3DE8: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 3DF0: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();
//----- (00000000000013F4) ----------------------------------------------------
void term_proc()
{
;
}
Si nos fijamos en las líneas 41 a la 45 vemos las siguientes cadenas:
a = «MdfnJk»
b = «jYx}»
c = «gWmfk»
d = «mlvpc»
f = «neU++w»
Usaremos las cadenas y los valores XOR especificados para cada rango de v5 en el main (líneas 123 a 182) para determinar los caracteres correctos.
Para v5 de 0 a 5: v6 = comprobacion(v4, a[v5], 5);
Significa que: v4 debe ser igual a a[v5] ^ 5
Para v5 de 6 a 9: v6 = comprobacion(v4, b[v5 – 6], 17);
Significa que: v4 debe ser igual a b[v5 – 6] ^ 17
Para v5 de 10 a 14: v6 = comprobacion(v4, c[v5 – 10], 8);
Significa que: v4 debe ser igual a c[v5 – 10] ^ 8
Para v5 de 15 a 19: v6 = comprobacion(v4, d[v5 – 15], 2);
Significa que: v4 debe ser igual a d[v5 – 15] ^ 2
Para v5 de 20 a 25: v6 = comprobacion(v4, f[v5 – 20], 10);
Significa que: v4 debe ser igual a f[v5 – 20] ^ 10
Cálculo de los caracteres correctos:
Para v5 de 0 a 5:
a[0] = ‘M’, M ^ 5 = 0x4D ^ 0x05 = 0x48 -> ‘H’
a[1] = ‘d’, d ^ 5 = 0x64 ^ 0x05 = 0x61 -> ‘a’
a[2] = ‘f’, f ^ 5 = 0x66 ^ 0x05 = 0x63 -> ‘c’
a[3] = ‘n’, n ^ 5 = 0x6E ^ 0x05 = 0x6B -> ‘k’
a[4] = ‘J’, J ^ 5 = 0x4A ^ 0x05 = 0x4F -> ‘O’
a[5] = ‘k’, k ^ 5 = 0x6B ^ 0x05 = 0x6E -> ‘n’
Resulta en la cadena: HackOn
Para v5 de 6 a 9:
b[0] = ‘j’, j ^ 17 = 0x6A ^ 0x11 = 0x7B -> ‘{‘
b[1] = ‘Y’, Y ^ 17 = 0x59 ^ 0x11 = 0x48 -> ‘H’
b[2] = ‘x’, x ^ 17 = 0x78 ^ 0x11 = 0x69 -> ‘i’
b[3] = ‘}’, } ^ 17 = 0x7D ^ 0x11 = 0x6C -> ‘l’
Resulta en la cadena: {Hil
Para v5 de 10 a 14:
c[0] = ‘g’, g ^ 8 = 0x67 ^ 0x08 = 0x6F -> ‘o’
c[1] = ‘W’, W ^ 8 = 0x57 ^ 0x08 = 0x5F -> ‘_’
c[2] = ‘m’, m ^ 8 = 0x6D ^ 0x08 = 0x65 -> ‘e’
c[3] = ‘f’, f ^ 8 = 0x66 ^ 0x08 = 0x6E -> ‘n’
c[4] = ‘k’, k ^ 8 = 0x6B ^ 0x08 = 0x63 -> ‘c’
Resulta en la cadena: o_enc
Para v5 de 15 a 19:
d[0] = ‘m’, m ^ 2 = 0x6D ^ 0x02 = 0x6F -> ‘o’
d[1] = ‘l’, l ^ 2 = 0x6C ^ 0x02 = 0x6E -> ‘n’
d[2] = ‘v’, v ^ 2 = 0x76 ^ 0x02 = 0x74 -> ‘t’
d[3] = ‘p’, p ^ 2 = 0x70 ^ 0x02 = 0x72 -> ‘r’
d[4] = ‘c’, c ^ 2 = 0x63 ^ 0x02 = 0x61 -> ‘a’
Resulta en la cadena: ontra
Para v5 de 20 a 25:
f[0] = ‘n’, n ^ 10 = 0x6E ^ 0x0A = 0x64 -> ‘d’
f[1] = ‘e’, e ^ 10 = 0x65 ^ 0x0A = 0x6F -> ‘o’
f[2] = ‘U’, U ^ 10 = 0x55 ^ 0x0A = 0x5F -> ‘_‘
f[3] = ‘+’, + ^ 10 = 0x2B ^ 0x0A = 0x21 -> ‘!’
f[4] = ‘+’, + ^ 10 = 0x2B ^ 0x0A = 0x21 -> ‘!’
f[5] = ‘w’, w ^ 10 = 0x77 ^ 0x0A = 0x7D -> ‘}’
Resulta en la cadena: do_!!}
Uniendo todas las partes, obtenemos la flag completa: HackOn{Hilo_enc_ontrado_!!}
El crackme que analizamos hoy está hecho en ensamblador y si bien su dificultad es baja, la creación del keygen es un poco liosa. Al keygen que veremos más adelante, le he dado cierta aleatoriedad para que quede más elegante.
El crackme comprueba el serial en función de un identificador de 4 dígitos que el mismo crackme genera.
Coje nuestro serial mediante la función GetDlgItemTextA.
004010D3 |. 68 FF000000 PUSH 0FF ; /MaxCount = 255. 004010D8 |. 68 40324000 PUSH OFFSET 00403240 ; |String 004010DD |. 68 EC030000 PUSH 3EC ; |ItemID = 1004. 004010E2 |. FF75 08 PUSH DWORD PTR SS:[ARG.1] ; |hDialog => [ARG.1] 004010E5 |. E8 6E010000 CALL <JMP.&user32.GetDlgItemTextA> ; \USER32.GetDlgItemTextA 004010EA |. 68 40324000 PUSH OFFSET 00403240 ; /String 004010EF |. E8 52010000 CALL <JMP.&kernel32.lstrlenA> ; \KERNEL32.lstrlen 004010F4 |. A3 47334000 MOV DWORD PTR DS:[403347],EAX 004010F9 |. 33DB XOR EBX,EBX 004010FB |. 33C0 XOR EAX,EAX 004010FD |. EB 54 JMP SHORT 00401153
Comprueba que nuestro serial esté formado por números (30h – 39h), letras de la A a la F (41h – 46h) y el guión (2Dh), es decir, el alfabeto hexadecimal más el guión. Si hay algún dígito indeseado nos tira fuera.
004010FF |> 8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240] 00401105 |. 3C 2D |CMP AL,2D 00401107 |. 74 40 |JE SHORT 00401149 00401109 |. 3C 30 |CMP AL,30 0040110B |. 74 3C |JE SHORT 00401149 0040110D |. 3C 31 |CMP AL,31 0040110F |. 74 38 |JE SHORT 00401149 00401111 |. 3C 32 |CMP AL,32 00401113 |. 74 34 |JE SHORT 00401149 00401115 |. 3C 33 |CMP AL,33 00401117 |. 74 30 |JE SHORT 00401149 00401119 |. 3C 34 |CMP AL,34 0040111B |. 74 2C |JE SHORT 00401149 0040111D |. 3C 35 |CMP AL,35 0040111F |. 74 28 |JE SHORT 00401149 00401121 |. 3C 36 |CMP AL,36 00401123 |. 74 24 |JE SHORT 00401149 00401125 |. 3C 37 |CMP AL,37 00401127 |. 74 20 |JE SHORT 00401149 00401129 |. 3C 38 |CMP AL,38 0040112B |. 74 1C |JE SHORT 00401149 0040112D |. 3C 39 |CMP AL,39 0040112F |. 74 18 |JE SHORT 00401149 00401131 |. 3C 41 |CMP AL,41 00401133 |. 74 14 |JE SHORT 00401149 00401135 |. 3C 42 |CMP AL,42 00401137 |. 74 10 |JE SHORT 00401149 00401139 |. 3C 43 |CMP AL,43 0040113B |. 74 0C |JE SHORT 00401149 0040113D |. 3C 44 |CMP AL,44 0040113F |. 74 08 |JE SHORT 00401149 00401141 |. 3C 45 |CMP AL,45 00401143 |. 74 04 |JE SHORT 00401149 00401145 |. 3C 46 |CMP AL,46 00401147 |. 75 07 |JNE SHORT 00401150 00401149 |> 8305 4B334000 |ADD DWORD PTR DS:[40334B],1 00401150 |> 83C3 01 |ADD EBX,1 00401153 |> 3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347] 00401159 |.^ 76 A4 \JBE SHORT 004010FF 0040115B |. A1 47334000 MOV EAX,DWORD PTR DS:[403347] 00401160 |. 3905 4B334000 CMP DWORD PTR DS:[40334B],EAX ; si no coincide el tamaño del serial con el 00401166 |. 0F85 94000000 JNE 00401200 ; contador nos tira fuera
La comprobación del serial la realiza sumando el valor ascii del primer dígito al valor ascii del tercero y sucesivos y a continuación restando la suma anterior al ID. Cuando finalice la comprobación de todos los dígitos del serial, el restador tiene que ser cero, de lo contrario nos tira fuera. Si el ID es cero también nos tira fuera.
Ejemplo (base 10)para ID = 4011 y SERIAL: 1-23456
0040116C |. 33C0 XOR EAX,EAX 0040116E |. BB 02000000 MOV EBX,2 00401173 |. A0 40324000 MOV AL,BYTE PTR DS:[403240] 00401178 |. A3 43334000 MOV DWORD PTR DS:[403343],EAX 0040117D |. EB 13 JMP SHORT 00401192 0040117F |> 8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240] ; Coje el dígito correspondiente 00401185 |. 0305 43334000 |ADD EAX,DWORD PTR DS:[403343] ; 1ºdig + dig 0040118B |. 2905 4F334000 |SUB DWORD PTR DS:[40334F],EAX ; ID - (1ºdig + dig) 00401191 |. 43 |INC EBX 00401192 |> 3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347] 00401198 |.^ 72 E5 \JB SHORT 0040117F 0040119A |. 833D 4F334000 CMP DWORD PTR DS:[40334F],0 ; CHECK RESTADOR SEA = 0 004011A1 |. 75 49 JNE SHORT 004011EC 004011A3 |. 833D 3F334000 CMP DWORD PTR DS:[40333F],0 ; CHECK ID <> 0 004011AA |. 74 40 JE SHORT 004011EC 004011AC |. FF35 3F334000 PUSH DWORD PTR DS:[40333F] ; /<%d> = 0 004011B2 |. 68 00304000 PUSH OFFSET 00403000 ; |Format = "REGISTRADO CON ID:%d" 004011B7 |. 68 40324000 PUSH OFFSET 00403240 ; |Buf 004011BC |. E8 A9000000 CALL <JMP.&user32.wsprintfA> ; \USER32.wsprintfA
Como veis, el resultado de ir restando todos los dígitos de nuestro serial con la ID debe ser cero para que el serial sea correcto.
Lo primero que se me ocurre para obtener una solución directa es buscar una combinación de dígito + dígito que sea múltiplo del ID. Para ello podemos usar la función módulo. La función módulo lo que hace es darnos el resto de la división de dos números, de modo que si el resto es cero los números son múltiplos. Para ello debemos cruzar todos los números y letras hasta encontrar los dígitos múltiplos del ID. Un serial de este primer tipo quedaría algo así como 1-FFFFFFFFFFFFFFFFFF ya que como el primer dígito es fijo el otro se repetirá tanta veces como sea necesario para hacer que el ID sea cero.
Con nuestro reducido alfabeto, cabe la posibilidad de que no encontremos una combinación válida, por lo que tendremos que pensar en un plan B. El plan B que se me ocurre a mi es intentar forzar el plan A restando caracteres aleatorios al ID y volviendo a comprobar si encontramos múltiplos del nuevo ID. Un serial de este tipo quedaría más elegante, por ejemplo 3-A6D53B628BBBBB.
Os dejo unos cuantos números de serie.
'Keygen for Flamer's asm keygenme
Dim id As Integer
Dim serial As String
Dim tmp, tmp2, na, nb As Integer
Dim alfabeto As Integer() = New Integer() {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70}
Dim r As Random = New Random
'Button generate
Private Sub btngen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btngen.Click
ini:
If txtid.TextLength <> 4 Then GoTo Mal
id = txtid.Text
txtdebug.Text = ""
na = alfabeto(r.Next(1, 16))
serial = Chr(na) & "-"
tmp = id
For i = 0 To alfabeto.Length - 1
For y = 0 To alfabeto.Length - 1
'Solución directa
If id Mod (alfabeto(i) + alfabeto(y)) = 0 Then
tmp = id / (alfabeto(i) + alfabeto(y))
txtserial.Text = Chr(alfabeto(i)) & "-"
For z = 0 To tmp - 1
txtserial.Text &= Chr(alfabeto(y))
Next
GoTo fuera
End If
'Indirecta con aleatoriedad
nb = alfabeto(r.Next(1, 16))
tmp = tmp - (na + nb)
serial &= Chr(nb)
If tmp Mod (na + nb) = 0 Then
tmp2 = tmp / (na + nb)
For z = 0 To tmp2 - 1
serial &= Chr(nb)
Next
txtserial.Text = serial
GoTo fuera
End If
If tmp < 0 Then
GoTo ini
Else
txtdebug.Text &= tmp & " "
End If
Next
Next
Mal:
txtserial.Text = "¿id?"
fuera:
End Sub
Me doy cuenta que en el keygen no he utilizado el guión, pero no pasa nada, se lo dejo al lector como curiosidad.
Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la solución en el decompilado y quizá por evocar recuerdos de tiempos pretéritos.
/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>
Detected compiler: GNU C++
*/
#include <defs.h>
//-------------------------------------------------------------------------
// Function declarations
__int64 (**init_proc())(void);
__int64 sub_400650(); // weak
// int printf(const char *format, ...);
// int puts(const char *s);
// void __noreturn exit(int status);
// size_t strlen(const char *s);
// __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD); weak
// int sprintf(char *s, const char *format, ...);
// __int64 ptrace(enum __ptrace_request request, ...);
// __int64 strtol(const char *nptr, char **endptr, int base);
// __int64 __isoc99_scanf(const char *, ...); weak
// int memcmp(const void *s1, const void *s2, size_t n);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void *sub_400730();
__int64 sub_400760();
void *sub_4007A0();
__int64 sub_4007D0();
void fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// __int64 _gmon_start__(void); weak
//-------------------------------------------------------------------------
// Data declarations
_UNKNOWN main;
_UNKNOWN init;
__int64 (__fastcall *funcs_400E29)() = &sub_4007D0; // weak
__int64 (__fastcall *off_601DF8)() = &sub_4007A0; // weak
__int64 (*qword_602010)(void) = NULL; // weak
char *off_602080 = "FLAG-%s\n"; // idb
char a7yq2hryrn5yJga[16] = "7Yq2hrYRn5Y`jga"; // weak
const char aO6uH[] = "(O6U,H\""; // idb
_UNKNOWN unk_6020B8; // weak
_UNKNOWN unk_6020C8; // weak
char byte_6020E0; // weak
char s1; // idb
char byte_602110[]; // weak
char byte_602120[33]; // weak
char byte_602141[7]; // idb
__int64 qword_602148; // weak
__int64 qword_602150; // weak
__int64 qword_602158; // weak
__int64 qword_602160; // weak
__int64 qword_602178; // weak
//----- (0000000000400630) ----------------------------------------------------
__int64 (**init_proc())(void)
{
__int64 (**result)(void); // rax
result = &_gmon_start__;
if ( &_gmon_start__ )
return (__int64 (**)(void))_gmon_start__();
return result;
}
// 6021D8: using guessed type __int64 _gmon_start__(void);
//----- (0000000000400650) ----------------------------------------------------
__int64 sub_400650()
{
return qword_602010();
}
// 400650: using guessed type __int64 sub_400650();
// 602010: using guessed type __int64 (*qword_602010)(void);
//----- (0000000000400700) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
__int64 v3; // rax
int v4; // esi
__int64 v5; // [rsp-8h] [rbp-8h] BYREF
char *retaddr; // [rsp+0h] [rbp+0h] BYREF
v4 = v5;
v5 = v3;
_libc_start_main((int (__fastcall *)(int, char **, char **))main, v4, &retaddr, (void (*)(void))init, fini, a3, &v5);
__halt();
}
// 400706: positive sp value 8 has been found
// 40070D: variable 'v3' is possibly undefined
//----- (0000000000400730) ----------------------------------------------------
void *sub_400730()
{
return &unk_6020C8;
}
//----- (0000000000400760) ----------------------------------------------------
__int64 sub_400760()
{
return 0LL;
}
//----- (00000000004007A0) ----------------------------------------------------
void *sub_4007A0()
{
void *result; // rax
if ( !byte_6020E0 )
{
result = sub_400730();
byte_6020E0 = 1;
}
return result;
}
// 6020E0: using guessed type char byte_6020E0;
//----- (00000000004007D0) ----------------------------------------------------
__int64 sub_4007D0()
{
return sub_400760();
}
//----- (00000000004007D7) ----------------------------------------------------
__int64 __fastcall main(int a1, char **a2, char **a3)
{
size_t v3; // rax
size_t v4; // rax
int i; // [rsp+1Ch] [rbp-24h]
int n; // [rsp+20h] [rbp-20h]
int m; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
if ( ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1 )
goto LABEL_2;
if ( a1 > 4 )
{
qword_602148 = strtol(a2[1], 0LL, 10);
if ( qword_602148 )
{
qword_602150 = strtol(a2[2], 0LL, 10);
if ( qword_602150 )
{
qword_602158 = strtol(a2[3], 0LL, 10);
if ( qword_602158 )
{
qword_602160 = strtol(a2[4], 0LL, 10);
if ( qword_602160 )
{
if ( -24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
&& 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
&& 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
&& -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613 )
{
qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
sprintf(byte_602141, "%06x", qword_602178);
v4 = strlen(byte_602141);
MD5(byte_602141, v4, byte_602110);
for ( i = 0; i <= 15; ++i )
sprintf(&byte_602120[2 * i], "%02x", (unsigned __int8)byte_602110[i]);
printf(off_602080, byte_602120);
exit(0);
}
}
}
}
}
LABEL_2:
printf("password : ");
__isoc99_scanf("%s", &s1);
if ( strlen(&s1) > 0x10 )
{
puts("the password must be less than 16 character");
exit(1);
}
for ( j = 0; j < strlen(&s1); ++j )
*(&s1 + j) ^= 6u;
if ( !strcmp(&s1, a7yq2hryrn5yJga) )
{
v3 = strlen(&s1);
MD5(&s1, v3, byte_602110);
for ( k = 0; k <= 15; ++k )
sprintf(&byte_602120[2 * k], "%02x", (unsigned __int8)byte_602110[k]);
printf(off_602080, byte_602120);
exit(0);
}
puts("bad password!");
exit(0);
}
printf("password : ");
__isoc99_scanf("%s", &s1);
if ( strlen(&s1) > 0x10 )
{
puts("the password must be less than 16 character");
exit(1);
}
for ( m = 0; m < strlen(&s1); ++m )
{
*(&s1 + m) ^= 2u;
++*(&s1 + m);
*(&s1 + m) = ~*(&s1 + m);
}
if ( !memcmp(&s1, &unk_6020B8, 9uLL) )
{
for ( n = 0; n < strlen(aO6uH); n += 2 )
{
aO6uH[n] ^= 0x45u;
aO6uH[n + 1] ^= 0x26u;
}
puts(aO6uH);
}
else
{
puts("bad password!");
}
return 0LL;
}
// 4006A0: using guessed type __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD);
// 4006E0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 602148: using guessed type __int64 qword_602148;
// 602150: using guessed type __int64 qword_602150;
// 602158: using guessed type __int64 qword_602158;
// 602160: using guessed type __int64 qword_602160;
// 602178: using guessed type __int64 qword_602178;
//----- (0000000000400DE0) ----------------------------------------------------
void __fastcall init(unsigned int a1, __int64 a2, __int64 a3)
{
signed __int64 v3; // rbp
__int64 i; // rbx
v3 = &off_601DF8 - &funcs_400E29;
init_proc();
if ( v3 )
{
for ( i = 0LL; i != v3; ++i )
(*(&funcs_400E29 + i))();
}
}
// 601DF0: using guessed type __int64 (__fastcall *funcs_400E29)();
// 601DF8: using guessed type __int64 (__fastcall *off_601DF8)();
//----- (0000000000400E54) ----------------------------------------------------
void term_proc()
{
;
}
// nfuncs=33 queued=10 decompiled=10 lumina nreq=0 worse=0 better=0
// ALL OK, 10 function(s) have been successfully decompiled
Si la función ptrace retorna -1, significa que el programa está siendo depurado y redirige a LABEL_2.
if (ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1) {
goto LABEL_2;
}
El programa espera al menos 5 argumentos (nombre del programa y cuatro números enteros). Si se proporcionan los cuatro números enteros, se realizan los siguientes cálculos:
if (-24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
&& 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
&& 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
&& -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613)
Esto es un sistema de ecuaciones lineales mondo y lirondo que debe ser resuelto para encontrar los valores correctos de qword_602148, qword_602150, qword_602158 y qword_602160. Una vez resuelto el sistema de ecuaciones se realiza la operación:
qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
A continuación se pasa el resultado de la variable qword_602178 a hexadecimal y se genera su hash MD5.
Lo más rápido en esta ocasión es usar Python, pero esto se puede resolver hasta con lápiz y papel 😉
from sympy import symbols, Eq, solve
import hashlib
# Definir las variables
A, B, C, D = symbols('A B C D')
# Definir las ecuaciones
eq1 = Eq(-24*A - 18*B - 15*C - 12*D, -18393)
eq2 = Eq(9*C + 18*(A + B) - 9*D, 4419)
eq3 = Eq(4*C + 16*A + 12*B + 2*D, 7300)
eq4 = Eq(-6*(A + B) - 3*C - 11*D, -8613)
# Resolver el sistema de ecuaciones
solution = solve((eq1, eq2, eq3, eq4), (A, B, C, D))
# Verificar si se encontró una solución
if solution:
print("Solución encontrada:")
print(solution)
# Obtener los valores de A, B, C y D
A_val = solution[A]
B_val = solution[B]
C_val = solution[C]
D_val = solution[D]
# Mostrar los valores encontrados
print(f"A = {A_val}")
print(f"B = {B_val}")
print(f"C = {C_val}")
print(f"D = {D_val}")
# Calcular qword_602178
qword_602178 = C_val + B_val * A_val - D_val
qword_602178 = int(qword_602178) # Convertir a entero de Python
print(f"qword_602178 = {qword_602178}")
# Convertir qword_602178 a una cadena en formato hexadecimal
byte_602141 = f"{qword_602178:06x}"
print(f"byte_602141 (hex) = {byte_602141}")
# Calcular el MD5 de la cadena
md5_hash = hashlib.md5(byte_602141.encode()).hexdigest()
print(f"MD5 hash = {md5_hash}")
# Generar la flag
flag = f"FLAG-{md5_hash}"
print(f"Flag = {flag}")
else:
print("No se encontró una solución.")
Al ejecutar el script veremos algo como esto:
Solución encontrada:
{A: 227, B: 115, C: 317, D: 510}
A = 227
B = 115
C = 317
D = 510
qword_602178 = 25912
byte_602141 (hex) = 006538
MD5 hash = 21a84f2c7c7fd432edf1686215db....
Flag = FLAG-21a84f2c7c7fd432edf1686215db....
Los retos de encriptación son muy variados como hemos comentado anteriormente. Aquí tenemos unos buenos ejemplos de ello.
En este primer nivel nos encontramos con un método de encriptación muy antíguo. Sólo diré como pista, que es de los más antiguos que se conocen.
ozhlofxrlmvhxzorulimrz
Lo primero que suelo hacer en este tipo de retos cuando son solamente letras, es comprobar las dos opciones más típicas, que son el cifrado César y Vigenere. En este caso necesitamos ahondar un poco más, aunque enseguida llegamos a la conclusión de que el cifrado usado es el afín. Un ataque por fuerza bruta nos devuelve la solución y los coeficientes utilizados.
Solución: A=25,B=25 – LASOLUCIONESCALIFORNIA
Fuente: http://www.dcode.fr/chiffre-affine
En este segundo nivel recordaremos a un general romano muy conocido. Lo complicaremos un poco, sólo lo justo para que cueste algo más de cinco minutos encontrar la clave 🙂
oehoeahhjoexhkzqhfsvzhffhwrhotqk
Lo primero que nos viene a la cabeza es el cifrado César pero no va. Probando varios cifrados por sustitución al final damos con el correcto. De nuevo un ataque por fuerza bruta nos da frutos.
Solución: (3,4,5)/1 – LACLAVEDELASEGUNDAPRUEBAESMEKONG
Fuente: https://www.dcode.fr/chiffre-decalages
Este nivel también va a ser sencillo. Estos caracteres, pertenecientes a un sistema bastante conocido de encriptado, esconden una palabra que, al introducirla (en minúsculas), nos permitirá superar el nivel.
Investigando un poco llegamos a la conclusión de que se trata del cifrado Francmasón o Pig Pen.
Solución: primates
Fuente: https://www.dcode.fr/chiffre-pig-pen-francs-macons
Esta prueba es tan simple que la he dividido en dos partes que, aunque de apariencia similar, se resuelven de distinta manera. La clave es la unión de las dos palabras resultantes de descifrar las dos líneas de números y que, juntas, forman una tercera palabra.
0111001101110101011100000110010101110010
0001001110011000111110100100110010010001
La primera parte se puede convertir en bloque:
0111001101110101011100000110010101110010 = super
Fuente: https://www.rapidtables.com/convert/number/binary-to-ascii.html
Para la segunda debemos separar en grupos de 5 dígitos y listo:
00010 01110 01100 01111 10100 10011 00100 10001
C O M P U T E R
Fuente: www.lindau-nobel.org
Para descubrir la palabra clave sólo se necesita una mínima capacidad de observación.
31 04 40 23 20 34 33 13 23 22
Se trata del cuadrado de Polibio.
Aquí hay que hacer un poco de trabajo de investigación: Hay que descubrir la clave que empleó un escritor francés (Una pista: «Lagardère») en una de sus novelas, que es la empleada aquí para formar la palabra clave (en minúsculas) que, por cierto, es alemana.
RI3I2MIL2I2A3
POR RESOLVER
Seguimos con cosas fáciles. Se trata de descifrar este texto escrito en inglés.
kgw qkoev ol 617 qthpreoz iwjpz sdkg kgw pdeyeplk rwqdjzwe ipezwq spbbdq sgo sgwz goqkdbdkdwq iwjpz spq rwkwecdzwr ko cpmw gdq uweqozpb yozkedihkdoz ko kgw spe wlloek
Una vez descifrado, nos será fácil descubrir la clave:
pzpyozrp
Se trata de un cifrado de sustitución mono alfabético.
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZLMIRVHUBGTFJKOASDWQPYEXCN
THE STORY OF 617 SQUADRON BEGAN WITH THE AIRCRAFT DESIGNER BARNES WALLIS WHO WHEN HOSTILITIES BEGAN WAS DETERMINED TO MAJE HIS PERSONAL CONTRIBUTION TO THE WAR EFFORT
Una vez descifrado el alfabeto la solución queda:
pzpyozrp = anaconda
A veces, las cosas no son lo que parecen. Donde aparecen unos números, en realidad hay otros números distintos.
273664524572348321143738
853442616537643005319627
POR RESOLVER
Para resolver algunos problemas, hay que tener una buena base. Este es un buen ejemplo de ello:
ZW50ZXJwcmlzZQ0K
¿Os suena base 64?
Solución: enterprise
Fuente: https://www.base64decode.org/
Esto es más complicado. Para descifrar este texto que contiene la clave para superar el nivel, se necesita otra clave. Para que no sea demasiado difícil, he utilizado una palabra muy sencilla de sólo cuatro letras 🙂
myiemyuvbaeewcxweghkflxw
Mediante fuerza bruta matamos dos pájaros de un tiro.
lapalabraclaveesdiogenes
Fuente: https://www.guballa.de/vigenere-solver
Hoy vamos a desmitificar un poco a Visual Basic. El Crackme reza que acabemos con la nag y hagamos un keygen.
Lo primero que debemos establecer es a que tipo de Nag nos estamos enfrentando, si es una MessageBox, se localiza y se parchea, si es un formulario la cosa ya cambia un poco, ya que encontrar esa parte del código puede resultar tedioso.
Yo voy a utilizar el camino fácil. En VB contamos con una estupenda herramienta como es VBReformer, que nos muestra las entrañas del crackme y nos posibilita cambiar ciertos parametros.
Abrimos el crackme con VBReformer y vemos su contenido. Localizamos rápidamente el formulario que aparece inicialmente (CMSplash) y el temporizador que contiene (Timer1). Inicialmente el timer tiene un interval de 7000, es decir, la nag se muestra durante 7 segundos. Es tan sencillo como cambiarlo por 1 y guardar el ejecutable (File > Save binary as).
Si no disponemos de esta estupenda herramienta, siempre podemos localizar el timer con un editor hexadecimal. Localizamos en Olly el nombre del timer (en las string references lo veréis), y lo buscamos en el editor hexadecimal. La duración de la nag la debemos estimar nosotros y a continuación buscar ese valor hexadecimal. Imaginemos que estimamos que son 7 segundos, lo pasamos a milisegundos y a hexadecimal. 7000 = 0x1B58. Buscamos en el editor hexadecimal «Timer1» y a continuación localizamos el valor 1B58 invertido, es decir, 581B. En las imágenes inferiores se ve claro.
Cambiando el valor ya lo tendriámos.
El algoritmo de este crackme es muy sencillo pero he elegido este en concreto para que veáis las vueltas que da VB para hacer 6 operaciones matemáticas. A continuación tenéis el código íntegro comentado y debajo el resumen.
004081F5 . FF15 F8B04000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>] ; MSVBVM50.__vbaLenBstr 004081FB . 8BF8 MOV EDI,EAX 004081FD . 8B4D E8 MOV ECX,DWORD PTR SS:[EBP-18] 00408200 . 69FF 385B0100 IMUL EDI,EDI,15B38 ; TEMP = Len(nombre) *15B38 00408206 . 51 PUSH ECX 00408207 . 0F80 B7050000 JO CrackmeV.004087C4 0040820D . FF15 0CB14000 CALL DWORD PTR DS:[<&MSVBVM50.#516>] ; MSVBVM50.rtcAnsiValueBstr 00408213 . 0FBFD0 MOVSX EDX,AX ; digito a ax 00408216 . 03FA ADD EDI,EDX ; TEMP +=1digito 00408218 . 0F80 A6050000 JO CrackmeV.004087C4 0040821E . 57 PUSH EDI ; MSVBVM50.__vbaObjSet 0040821F . FF15 F4B04000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrI4>] ; MSVBVM50.__vbaStrI4 00408225 . 8BD0 MOV EDX,EAX 00408227 . 8D4D E0 LEA ECX,DWORD PTR SS:[EBP-20] 0040822A . FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408230 . 8BBD 50FFFFFF MOV EDI,DWORD PTR SS:[EBP-B0] 00408236 . 50 PUSH EAX 00408237 . 57 PUSH EDI ; MSVBVM50.__vbaObjSet 00408238 . FF93 A4000000 CALL DWORD PTR DS:[EBX+A4] ; MSVBVM50.0F050D32 0040823E . 85C0 TEST EAX,EAX 00408240 . 7D 12 JGE SHORT CrackmeV.00408254 00408242 . 68 A4000000 PUSH 0A4 00408247 . 68 AC6F4000 PUSH CrackmeV.00406FAC 0040824C . 57 PUSH EDI ; MSVBVM50.__vbaObjSet 0040824D . 50 PUSH EAX 0040824E . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 00408254 > 8D45 E0 LEA EAX,DWORD PTR SS:[EBP-20] 00408257 . 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 0040825A . 50 PUSH EAX 0040825B . 8D55 E8 LEA EDX,DWORD PTR SS:[EBP-18] 0040825E . 51 PUSH ECX 0040825F . 52 PUSH EDX 00408260 . 6A 03 PUSH 3 00408262 . FF15 80B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>; MSVBVM50.__vbaFreeStrList 00408268 . 83C4 10 ADD ESP,10 0040826B . 8D45 D4 LEA EAX,DWORD PTR SS:[EBP-2C] 0040826E . 8D4D D8 LEA ECX,DWORD PTR SS:[EBP-28] 00408271 . 8D55 DC LEA EDX,DWORD PTR SS:[EBP-24] 00408274 . 50 PUSH EAX 00408275 . 51 PUSH ECX 00408276 . 52 PUSH EDX 00408277 . 6A 03 PUSH 3 00408279 . FF15 08B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>; MSVBVM50.__vbaFreeObjList 0040827F . 8B9D 40FFFFFF MOV EBX,DWORD PTR SS:[EBP-C0] ; CrackmeV.00409A68 00408285 . 83C4 10 ADD ESP,10 00408288 . 8B83 FC020000 MOV EAX,DWORD PTR DS:[EBX+2FC] 0040828E . 56 PUSH ESI 0040828F . 8985 38FFFFFF MOV DWORD PTR SS:[EBP-C8],EAX 00408295 . FFD0 CALL EAX 00408297 . 8B3D 20B14000 MOV EDI,DWORD PTR DS:[<&MSVBVM50.__vbaObjSet>] ; MSVBVM50.__vbaObjSet 0040829D . 50 PUSH EAX 0040829E . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 004082A1 . 50 PUSH EAX 004082A2 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet; <&MSVBVM50.__vbaObjSet> 004082A4 . 56 PUSH ESI 004082A5 . 8985 58FFFFFF MOV DWORD PTR SS:[EBP-A8],EAX 004082AB . FF93 08030000 CALL DWORD PTR DS:[EBX+308] 004082B1 . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 004082B4 . 50 PUSH EAX 004082B5 . 51 PUSH ECX 004082B6 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004082B8 . 8BD8 MOV EBX,EAX 004082BA . 8D45 E8 LEA EAX,DWORD PTR SS:[EBP-18] 004082BD . 50 PUSH EAX 004082BE . 53 PUSH EBX 004082BF . 8B13 MOV EDX,DWORD PTR DS:[EBX] ; MSVBVM50.0F025A95 004082C1 . FF92 A0000000 CALL DWORD PTR DS:[EDX+A0] 004082C7 . 85C0 TEST EAX,EAX 004082C9 . 7D 12 JGE SHORT CrackmeV.004082DD 004082CB . 68 A0000000 PUSH 0A0 004082D0 . 68 AC6F4000 PUSH CrackmeV.00406FAC 004082D5 . 53 PUSH EBX 004082D6 . 50 PUSH EAX 004082D7 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 004082DD > 8B8D 58FFFFFF MOV ECX,DWORD PTR SS:[EBP-A8] 004082E3 . 8B55 E8 MOV EDX,DWORD PTR SS:[EBP-18] 004082E6 . 52 PUSH EDX 004082E7 . 8B19 MOV EBX,DWORD PTR DS:[ECX] 004082E9 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004082EF . D905 08104000 FLD DWORD PTR DS:[401008] 004082F5 . 833D 00904000 00 CMP DWORD PTR DS:[409000],0 004082FC . 75 08 JNZ SHORT CrackmeV.00408306 004082FE . D835 0C104000 FDIV DWORD PTR DS:[40100C] ; 10 / 5 = 2 00408304 . EB 0B JMP SHORT CrackmeV.00408311 00408306 > FF35 0C104000 PUSH DWORD PTR DS:[40100C] 0040830C . E8 578DFFFF CALL <JMP.&MSVBVM50._adj_fdiv_m32> 00408311 > 83EC 08 SUB ESP,8 00408314 . DFE0 FSTSW AX 00408316 . A8 0D TEST AL,0D 00408318 . 0F85 A1040000 JNZ CrackmeV.004087BF 0040831E . DEC1 FADDP ST(1),ST ; TEMP +=2 00408320 . DFE0 FSTSW AX 00408322 . A8 0D TEST AL,0D 00408324 . 0F85 95040000 JNZ CrackmeV.004087BF 0040832A . DD1C24 FSTP QWORD PTR SS:[ESP] 0040832D . FF15 48B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>] ; MSVBVM50.__vbaStrR8 00408333 . 8BD0 MOV EDX,EAX 00408335 . 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 00408338 . FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 0040833E . 899D 34FFFFFF MOV DWORD PTR SS:[EBP-CC],EBX 00408344 . 8B9D 58FFFFFF MOV EBX,DWORD PTR SS:[EBP-A8] 0040834A . 50 PUSH EAX 0040834B . 8B85 34FFFFFF MOV EAX,DWORD PTR SS:[EBP-CC] 00408351 . 53 PUSH EBX 00408352 . FF90 A4000000 CALL DWORD PTR DS:[EAX+A4] 00408358 . 85C0 TEST EAX,EAX 0040835A . 7D 12 JGE SHORT CrackmeV.0040836E 0040835C . 68 A4000000 PUSH 0A4 00408361 . 68 AC6F4000 PUSH CrackmeV.00406FAC 00408366 . 53 PUSH EBX 00408367 . 50 PUSH EAX 00408368 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 0040836E > 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 00408371 . 8D55 E8 LEA EDX,DWORD PTR SS:[EBP-18] 00408374 . 51 PUSH ECX 00408375 . 52 PUSH EDX 00408376 . 6A 02 PUSH 2 00408378 . FF15 80B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>; MSVBVM50.__vbaFreeStrList 0040837E . 83C4 0C ADD ESP,0C 00408381 . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 00408384 . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 00408387 . 50 PUSH EAX 00408388 . 51 PUSH ECX 00408389 . 6A 02 PUSH 2 0040838B . FF15 08B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>; MSVBVM50.__vbaFreeObjList 00408391 . 8B95 40FFFFFF MOV EDX,DWORD PTR SS:[EBP-C0] ; CrackmeV.00409A68 00408397 . 83C4 0C ADD ESP,0C 0040839A . 8B82 00030000 MOV EAX,DWORD PTR DS:[EDX+300] 004083A0 . 56 PUSH ESI 004083A1 . 8985 30FFFFFF MOV DWORD PTR SS:[EBP-D0],EAX 004083A7 . FFD0 CALL EAX 004083A9 . 50 PUSH EAX 004083AA . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 004083AD . 50 PUSH EAX 004083AE . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004083B0 . 56 PUSH ESI 004083B1 . 8985 58FFFFFF MOV DWORD PTR SS:[EBP-A8],EAX 004083B7 . FF95 38FFFFFF CALL DWORD PTR SS:[EBP-C8] ; MSVBVM50.0F10C340 004083BD . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 004083C0 . 50 PUSH EAX 004083C1 . 51 PUSH ECX 004083C2 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004083C4 . 8BD8 MOV EBX,EAX 004083C6 . 8D45 E8 LEA EAX,DWORD PTR SS:[EBP-18] 004083C9 . 50 PUSH EAX 004083CA . 53 PUSH EBX 004083CB . 8B13 MOV EDX,DWORD PTR DS:[EBX] ; MSVBVM50.0F025A95 004083CD . FF92 A0000000 CALL DWORD PTR DS:[EDX+A0] 004083D3 . 85C0 TEST EAX,EAX 004083D5 . 7D 12 JGE SHORT CrackmeV.004083E9 004083D7 . 68 A0000000 PUSH 0A0 004083DC . 68 AC6F4000 PUSH CrackmeV.00406FAC 004083E1 . 53 PUSH EBX 004083E2 . 50 PUSH EAX 004083E3 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 004083E9 > 8B8D 58FFFFFF MOV ECX,DWORD PTR SS:[EBP-A8] 004083EF . 8B55 E8 MOV EDX,DWORD PTR SS:[EBP-18] 004083F2 . 52 PUSH EDX 004083F3 . 8B19 MOV EBX,DWORD PTR DS:[ECX] 004083F5 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004083FB . DC0D 10104000 FMUL QWORD PTR DS:[401010] ; *3 00408401 . 83EC 08 SUB ESP,8 ; -2 00408404 . DC25 18104000 FSUB QWORD PTR DS:[401018] 0040840A . DFE0 FSTSW AX 0040840C . A8 0D TEST AL,0D 0040840E . 0F85 AB030000 JNZ CrackmeV.004087BF 00408414 . DD1C24 FSTP QWORD PTR SS:[ESP] 00408417 . FF15 48B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>] ; MSVBVM50.__vbaStrR8 0040841D . 8BD0 MOV EDX,EAX 0040841F . 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 00408422 . FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408428 . 899D 2CFFFFFF MOV DWORD PTR SS:[EBP-D4],EBX 0040842E . 8B9D 58FFFFFF MOV EBX,DWORD PTR SS:[EBP-A8] 00408434 . 50 PUSH EAX 00408435 . 8B85 2CFFFFFF MOV EAX,DWORD PTR SS:[EBP-D4] 0040843B . 53 PUSH EBX 0040843C . FF90 A4000000 CALL DWORD PTR DS:[EAX+A4] 00408442 . 85C0 TEST EAX,EAX 00408444 . 7D 12 JGE SHORT CrackmeV.00408458 00408446 . 68 A4000000 PUSH 0A4 0040844B . 68 AC6F4000 PUSH CrackmeV.00406FAC 00408450 . 53 PUSH EBX 00408451 . 50 PUSH EAX 00408452 . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 00408458 > 8D4D E4 LEA ECX,DWORD PTR SS:[EBP-1C] 0040845B . 8D55 E8 LEA EDX,DWORD PTR SS:[EBP-18] 0040845E . 51 PUSH ECX 0040845F . 52 PUSH EDX 00408460 . 6A 02 PUSH 2 00408462 . FF15 80B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>; MSVBVM50.__vbaFreeStrList 00408468 . 83C4 0C ADD ESP,0C 0040846B . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 0040846E . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 00408471 . 50 PUSH EAX 00408472 . 51 PUSH ECX 00408473 . 6A 02 PUSH 2 00408475 . FF15 08B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>; MSVBVM50.__vbaFreeObjList 0040847B . 8B95 40FFFFFF MOV EDX,DWORD PTR SS:[EBP-C0] ; CrackmeV.00409A68 00408481 . 83C4 0C ADD ESP,0C 00408484 . 8B82 04030000 MOV EAX,DWORD PTR DS:[EDX+304] 0040848A . 56 PUSH ESI 0040848B . 8985 28FFFFFF MOV DWORD PTR SS:[EBP-D8],EAX 00408491 . FFD0 CALL EAX 00408493 . 50 PUSH EAX 00408494 . 8D45 D8 LEA EAX,DWORD PTR SS:[EBP-28] 00408497 . 50 PUSH EAX 00408498 . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 0040849A . 56 PUSH ESI 0040849B . 8985 58FFFFFF MOV DWORD PTR SS:[EBP-A8],EAX 004084A1 . FF95 30FFFFFF CALL DWORD PTR SS:[EBP-D0] ; MSVBVM50.0F10C348 004084A7 . 8D4D DC LEA ECX,DWORD PTR SS:[EBP-24] 004084AA . 50 PUSH EAX 004084AB . 51 PUSH ECX 004084AC . FFD7 CALL EDI ; MSVBVM50.__vbaObjSet 004084AE . 8BD8 MOV EBX,EAX 004084B0 . 8D45 E8 LEA EAX,DWORD PTR SS:[EBP-18] 004084B3 . 50 PUSH EAX 004084B4 . 53 PUSH EBX 004084B5 . 8B13 MOV EDX,DWORD PTR DS:[EBX] ; MSVBVM50.0F025A95 004084B7 . FF92 A0000000 CALL DWORD PTR DS:[EDX+A0] 004084BD . 85C0 TEST EAX,EAX 004084BF . 7D 12 JGE SHORT CrackmeV.004084D3 004084C1 . 68 A0000000 PUSH 0A0 004084C6 . 68 AC6F4000 PUSH CrackmeV.00406FAC 004084CB . 53 PUSH EBX 004084CC . 50 PUSH EAX 004084CD . FF15 18B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>; MSVBVM50.__vbaHresultCheckObj 004084D3 > 8B8D 58FFFFFF MOV ECX,DWORD PTR SS:[EBP-A8] 004084D9 . 8B55 E8 MOV EDX,DWORD PTR SS:[EBP-18] 004084DC . 52 PUSH EDX 004084DD . 8B19 MOV EBX,DWORD PTR DS:[ECX] 004084DF . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004084E5 . DC25 20104000 FSUB QWORD PTR DS:[401020] ; TEMP -= -15 004084EB . 83EC 08 SUB ESP,8 004084EE . DFE0 FSTSW AX 004084F0 . A8 0D TEST AL,0D 004084F2 . 0F85 C7020000 JNZ CrackmeV.004087BF ........ 00408677 . /74 62 JE SHORT CrackmeV.004086DB 00408679 . |8B35 14B14000 MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>] ; MSVBVM50.__vbaStrCat 0040867F . |68 C06F4000 PUSH CrackmeV.00406FC0 ; UNICODE "You Get It" 00408684 . |68 DC6F4000 PUSH CrackmeV.00406FDC ; UNICODE "\r\n" 00408689 . |FFD6 CALL ESI ; <&MSVBVM50.__vbaStrCat> 0040868B . |8BD0 MOV EDX,EAX 0040868D . |8D4D E8 LEA ECX,DWORD PTR SS:[EBP-18] 00408690 . |FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408696 . |50 PUSH EAX 00408697 . |68 E86F4000 PUSH CrackmeV.00406FE8 ; UNICODE "KeyGen It Now"
Que se puede resumir en esto.
004081F5 . FF15 F8B04000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>] ; MSVBVM50.__vbaLenBstr 004081FB . 8BF8 MOV EDI,EAX 004081FD . 8B4D E8 MOV ECX,DWORD PTR SS:[EBP-18] 00408200 . 69FF 385B0100 IMUL EDI,EDI,15B38 ; TEMP = Len(nombre) *15B38 00408206 . 51 PUSH ECX 00408207 . 0F80 B7050000 JO CrackmeV.004087C4 0040820D . FF15 0CB14000 CALL DWORD PTR DS:[<&MSVBVM50.#516>] ; MSVBVM50.rtcAnsiValueBstr 00408213 . 0FBFD0 MOVSX EDX,AX ; digito a ax 00408216 . 03FA ADD EDI,EDX ; TEMP +=1digito 00408218 . 0F80 A6050000 JO CrackmeV.004087C4 ........ 004082E9 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004082EF . D905 08104000 FLD DWORD PTR DS:[401008] 004082F5 . 833D 00904000 00 CMP DWORD PTR DS:[409000],0 004082FC . 75 08 JNZ SHORT CrackmeV.00408306 004082FE . D835 0C104000 FDIV DWORD PTR DS:[40100C] ; 10 / 5 = 2 00408304 . EB 0B JMP SHORT CrackmeV.00408311 00408306 > FF35 0C104000 PUSH DWORD PTR DS:[40100C] 0040830C . E8 578DFFFF CALL <JMP.&MSVBVM50._adj_fdiv_m32> 00408311 > 83EC 08 SUB ESP,8 00408314 . DFE0 FSTSW AX 00408316 . A8 0D TEST AL,0D 00408318 . 0F85 A1040000 JNZ CrackmeV.004087BF 0040831E . DEC1 FADDP ST(1),ST ; TEMP +=2 00408320 . DFE0 FSTSW AX 00408322 . A8 0D TEST AL,0D ........ 004083F5 . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004083FB . DC0D 10104000 FMUL QWORD PTR DS:[401010] ; TEMP *=3 00408401 . 83EC 08 SUB ESP,8 ; TEMP -=2 00408404 . DC25 18104000 FSUB QWORD PTR DS:[401018] 0040840A . DFE0 FSTSW AX 0040840C . A8 0D TEST AL,0D ........ 004084DF . FF15 74B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>] ; MSVBVM50.__vbaR8Str 004084E5 . DC25 20104000 FSUB QWORD PTR DS:[401020] ; TEMP -= -15 004084EB . 83EC 08 SUB ESP,8 004084EE . DFE0 FSTSW AX 004084F0 . A8 0D TEST AL,0D 004084F2 . 0F85 C7020000 JNZ CrackmeV.004087BF ........ 00408677 . /74 62 JE SHORT CrackmeV.004086DB 00408679 . |8B35 14B14000 MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>] ; MSVBVM50.__vbaStrCat 0040867F . |68 C06F4000 PUSH CrackmeV.00406FC0 ; UNICODE "You Get It" 00408684 . |68 DC6F4000 PUSH CrackmeV.00406FDC ; UNICODE "\r\n" 00408689 . |FFD6 CALL ESI ; <&MSVBVM50.__vbaStrCat> 0040868B . |8BD0 MOV EDX,EAX 0040868D . |8D4D E8 LEA ECX,DWORD PTR SS:[EBP-18] 00408690 . |FF15 94B14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>] ; MSVBVM50.__vbaStrMove 00408696 . |50 PUSH EAX 00408697 . |68 E86F4000 PUSH CrackmeV.00406FE8 ; UNICODE "KeyGen It Now"
Y en esto:
TEMP = Len(nombre) *15B38 TEMP += 1ºdigitoascii TEMP +=2 TEMP *=3 TEMP -=2 TEMP +=15
Y el KeyGen nos ocupa una sola línea
txtserial.Text = (((((Len(txtnombre.Text) * 88888) + Asc(Mid(txtn.Text, 1, 1))) + 2) * 3) - 2) + 15
Si nos fijamos en el VBReformer, en el formulario principal vemos muchas cajas de texto.
Las hacemos visibles, guardamos y ejecutamos haber que pasa.
Lo que pasa es que va guardando el resultado de las operaciones en ellas y en la de arriba concretamente está nuestro serial bueno, lo que nos hace poseedores de un KeyGen encubierto.
Los retos criptográficos son muy variados y muchas veces la dificultad está en saber a que te enfrentas. En este caso pasa eso, te dan un código y si no has visto algo parecido en la vida, no sabes por donde empezar. El título del autor da una pequeña pista pero para los desconocedores no es suficiente. La pista es el título y dice «WTF?!?» y el código a descifrar es el siguiente:
[-]>[-]< >+++++++++++[<+++++++++++>-]<. >+++[<--->-]<-. >++[<++>-]<++. +. >++++[<---->-]<-. ---. +++. . >+++[<+++>-]<. >+++[<--->-]<+. >++++[<++++>-]<-. >++++[<---->-]<--. >+++[<+++>-]<-. >++[<-->-]<--. -.
Si eres una persona con recursos, realizaras varias búsquedas por la red y al final llegarás a la conclusión de que te enfrentas a BRAINFUCK, un lenguaje de programación esotérico como ya vimos en el reto de Root-Me.
AVISO: Debido a que este reto está en activo no publicaré a donde pertenece.
Ya sabéis que los retos stego son muy variopintos. El otro día me encontré con uno que parecía que iba a ser complejo pero en realidad era bastante sencillo.
Tras varias pruebas complejas infructuosas, se me ocurrió descomponer por canales y efectivamente ese era el camino. Para ello yo utilicé la herramienta StegSolve de mi querido Caesum, pero podéis resolverlo incluso online con Pinetools.
Antes que nada, es importante saber que un archivo ELF en Linux es equivalente a un archivo EXE en Windows. Dicho esto, es bastante común encontrarnos con ejecutables ELF en diversos CTFs (Capture The Flag), y a menudo representan un desafío para aquellos no familiarizados con el uso cotidiano de Linux. Sin embargo, tengo una buena noticia si no eres aficionado de Linux: existen herramientas que permiten realizar un análisis preliminar para determinar si es necesario abordar el problema desde Linux o si podemos resolverlo directamente desde Windows. Estas herramientas facilitan una transición más cómoda para los usuarios de Windows, permitiéndoles interactuar eficazmente con archivos ELF.
Un archivo ELF (Executable and Linkable Format) es un formato común de archivo para archivos ejecutables, código objeto, bibliotecas compartidas y volcados de memoria en sistemas basados en Unix, como Linux. Es el estándar de formato de archivo para programas compilados y enlazados en este tipo de sistemas operativos.
La cabecera de un archivo ELF es una estructura de datos al comienzo del archivo que proporciona información esencial sobre el contenido y la forma de procesar el archivo. Esta cabecera es fundamental para que el sistema operativo y otros programas puedan interpretar correctamente el archivo ELF. Aquí están los componentes clave de la cabecera de un archivo ELF:
0x7F 'E' 'L' 'F'. También incluye información como la clase del archivo (32 o 64 bits), la codificación de datos (endianness), y la versión del formato ELF.Se nos proporciona un fichero de 20KB que rápidamente catalogamos como ELF.
Para realizar un análisis preliminar siempre uso DogBolt, que no es más que un decompilador online con la ventaja de que usa varios motores y de esta forma casi siempre te da una decompilación aceptable. La versión actual tiene disponibles 11 motores y además es open source, ¿Qué más se puede pedir?
Echamos un vistazo y enseguida encontramos algo interesante.
La flag parece codificada de modo que vamos a indagar acerca de la función FUN_0010285d
Dentro de la función FUN_0010285d vemos que nuestra flag codificada la procesa la función FUN_00102752
Aquí os diría que depende de vuestra experiencia en programación veríais que se está procesando byte a byte la cadena de entrada (param_1) y haciendo a cada byte un XOR (^) con el param_3 (que es 1 según vemos en la llamada de la función FUN_00102752), pero en estos tiempos que corren vamos a preguntar a ChatGPT que opina.
Le pido a ChapGPT que me analice el código y me responde:
Este código en C define una función llamada
FUN_00102752que realiza una operación de XOR (exclusivo OR) byte a byte sobre un bloque de memoria. La función toma tres parámetros:
long param_1: Este parámetro es tratado como una dirección de memoria. Se utiliza como la base de un bloque de memoria sobre el que se realizará la operación.ulong param_2: Este parámetro especifica el tamaño del bloque de memoria que será afectado por la operación.byte param_3: Este es el valor de un solo byte que se utilizará en la operación XOR.El cuerpo de la función consiste en un bucle
forque itera sobre el bloque de memoria:
int local_cse declara como una variable local y se inicializa en 0. Esta variable actúa como un contador para el bucle.- La condición del bucle
(ulong)(long)local_c < param_2asegura que el bucle se ejecute sobre el rango completo del bloque de memoria especificado porparam_2.- Dentro del bucle,
*(byte *)(param_1 + local_c) = *(byte *)(param_1 + local_c) ^ param_3;realiza la operación XOR. Aquí,*(byte *)(param_1 + local_c)accede al byte actual en el bloque de memoria. Este byte se modifica aplicándole un XOR conparam_3. La operación XOR se realiza entre el byte actual en la memoria y el valor deparam_3, y el resultado se escribe de nuevo en la misma ubicación de memoria.En resumen, la función
by ChatGPTFUN_00102752modifica un bloque de memoria aplicando una operación XOR con un valor dado (param_3) a cada byte dentro del rango de memoria especificado desdeparam_1hastaparam_1 + param_2. Este tipo de operación es común en tareas como la manipulación de datos para cifrado/descifrado o para la generación de patrones específicos en un bloque de datos.
Ahora imaginad que no sois muy dados a programar o simplemente estáis vagos de modo que volvemos a recurrir a ChatGPT con el promt «Haz un XOR 1 con javascript a la cadena: gmfzuihr^vr^o^drx^nod^shfiu|» a lo que responde:
function xorString(str) {
return Array.from(str).map(char => String.fromCharCode(char.charCodeAt(0) ^ 1)).join(»);
}console.log(xorString(‘gm
by ChatGPTfzuihr^vr^o^drx^nod^shfiu|’));
Copiamos el código y lo pegamos en un entorno online como por ejemplo playcode.io.
Este es un ejemplo simple, pero ¿percibís su potencial?
La imagen de portada de esta entrada ha sido generada con ChatGPT.
Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.
