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
Se nos entrega un ELF que decompilado presenta este aspecto:
/* 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_401020();
__int64 sub_401030(); // weak
__int64 sub_401040(); // weak
__int64 sub_401050(); // weak
__int64 sub_401060(); // weak
__int64 sub_401070(); // weak
// int puts(const char *s);
// int printf(const char *format, ...);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void dl_relocate_static_pie();
char *deregister_tm_clones();
__int64 register_tm_clones();
char *_do_global_dtors_aux();
__int64 frame_dummy();
int __fastcall main(int argc, const char **argv, const char **envp);
_BYTE *__fastcall encode(__int64 a1);
__int64 __fastcall validar(const char *a1);
int banner();
int comprar();
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);
// __int64 _gmon_start__(void); weak
//-------------------------------------------------------------------------
// Data declarations
_UNKNOWN _libc_csu_init;
const char a31mparaSeguirU[43] = "\x1B[31mPara seguir usando este producto deber"; // idb
const char a32myaPuedesSeg[61] = "\x1B[32mYa puedes seguir afinando tus instrumentos (y tus flags "; // idb
const char aDirigaseANuest[21] = "\nDirigase a nuestra p"; // idb
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
__int64 (*qword_404010)(void) = NULL; // weak
char _bss_start; // weak
//----- (0000000000401000) ----------------------------------------------------
__int64 (**init_proc())(void)
{
__int64 (**result)(void); // rax
result = &_gmon_start__;
if ( &_gmon_start__ )
return (__int64 (**)(void))_gmon_start__();
return result;
}
// 404090: using guessed type __int64 _gmon_start__(void);
//----- (0000000000401020) ----------------------------------------------------
__int64 sub_401020()
{
return qword_404010();
}
// 404010: using guessed type __int64 (*qword_404010)(void);
//----- (0000000000401030) ----------------------------------------------------
__int64 sub_401030()
{
return sub_401020();
}
// 401030: using guessed type __int64 sub_401030();
//----- (0000000000401040) ----------------------------------------------------
__int64 sub_401040()
{
return sub_401020();
}
// 401040: using guessed type __int64 sub_401040();
//----- (0000000000401050) ----------------------------------------------------
__int64 sub_401050()
{
return sub_401020();
}
// 401050: using guessed type __int64 sub_401050();
//----- (0000000000401060) ----------------------------------------------------
__int64 sub_401060()
{
return sub_401020();
}
// 401060: using guessed type __int64 sub_401060();
//----- (0000000000401070) ----------------------------------------------------
__int64 sub_401070()
{
return sub_401020();
}
// 401070: using guessed type __int64 sub_401070();
//----- (00000000004010D0) ----------------------------------------------------
// 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();
}
// 4010DA: positive sp value 8 has been found
// 4010E1: variable 'v3' is possibly undefined
//----- (0000000000401100) ----------------------------------------------------
void dl_relocate_static_pie()
{
;
}
//----- (0000000000401110) ----------------------------------------------------
char *deregister_tm_clones()
{
return &_bss_start;
}
// 404050: using guessed type char _bss_start;
//----- (0000000000401140) ----------------------------------------------------
__int64 register_tm_clones()
{
return 0LL;
}
//----- (0000000000401180) ----------------------------------------------------
char *_do_global_dtors_aux()
{
char *result; // rax
if ( !_bss_start )
{
result = deregister_tm_clones();
_bss_start = 1;
}
return result;
}
// 404050: using guessed type char _bss_start;
//----- (00000000004011B0) ----------------------------------------------------
__int64 frame_dummy()
{
return register_tm_clones();
}
//----- (00000000004011B6) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
int v4; // [rsp+10h] [rbp-10h] BYREF
int v5; // [rsp+14h] [rbp-Ch]
unsigned __int64 v6; // [rsp+18h] [rbp-8h]
v6 = __readfsqword(0x28u);
v5 = 0;
puts("\n\x1B[31m -----------Se le ha acabado el periodo de prueba gratuito-----------\n");
puts(a31mparaSeguirU);
do
{
banner();
__isoc99_scanf("%d", &v4);
if ( v4 == 3 )
exit(0);
if ( v4 > 3 )
goto LABEL_10;
if ( v4 == 1 )
{
comprar();
continue;
}
if ( v4 == 2 )
v5 = validar("%d");
else
LABEL_10:
puts("Opcion invalida, pruebe otra vez");
}
while ( !v5 );
puts(a32myaPuedesSeg);
return 0;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);
//----- (0000000000401291) ----------------------------------------------------
_BYTE *__fastcall encode(__int64 a1)
{
_BYTE *result; // rax
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; i <= 33; ++i )
{
if ( *(char *)(i + a1) <= 96 || *(char *)(i + a1) > 122 )
{
if ( *(char *)(i + a1) <= 64 || *(char *)(i + a1) > 90 )
{
result = (_BYTE *)*(unsigned __int8 *)(i + a1);
*(_BYTE *)(i + a1) = (_BYTE)result;
}
else
{
result = (_BYTE *)(i + a1);
*result = (5 * ((char)*result - 65) + 8) % 26 + 65;
}
}
else
{
result = (_BYTE *)(i + a1);
*result = (5 * ((char)*result - 97) + 8) % 26 + 97;
}
}
return result;
}
//----- (00000000004013DB) ----------------------------------------------------
__int64 __fastcall validar(const char *a1)
{
int i; // [rsp+Ch] [rbp-64h]
char v3[48]; // [rsp+10h] [rbp-60h] BYREF
__int64 v4[6]; // [rsp+40h] [rbp-30h] BYREF
v4[5] = __readfsqword(0x28u);
qmemcpy(v4, "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", 34);
printf("\nIntroduce tu licencia: ");
__isoc99_scanf("%s", v3);
encode((__int64)v3);
for ( i = 0; i <= 33; ++i )
{
if ( v3[i] != *((_BYTE *)v4 + i) )
{
puts("\n\x1B[31mTu licencia es incorrecta\x1B[37m\n");
return 0LL;
}
}
puts("\n\x1B[32mEres un crack, lo conseguiste\x1B[37m");
return 1LL;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4013DB: using guessed type char var_60[48];
//----- (00000000004014CE) ----------------------------------------------------
int banner()
{
puts(" ___________OPCIONES___________");
puts(" | 1: Comprar licencia premium |");
puts(" | 2: Validar clave de licencia |");
puts(" | 3: Salir |");
puts(" ------------------------------");
return printf("> ");
}
//----- (0000000000401526) ----------------------------------------------------
int comprar()
{
return puts(aDirigaseANuest);
}
//----- (0000000000401540) ----------------------------------------------------
void __fastcall _libc_csu_init(unsigned int a1, __int64 a2, __int64 a3)
{
signed __int64 v3; // rbp
__int64 i; // rbx
init_proc();
v3 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
if ( v3 )
{
for ( i = 0LL; i != v3; ++i )
(*(&_frame_dummy_init_array_entry + i))();
}
}
// 403E10: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 403E18: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();
//----- (00000000004015B0) ----------------------------------------------------
void _libc_csu_fini(void)
{
;
}
//----- (00000000004015B8) ----------------------------------------------------
void term_proc()
{
;
}
// nfuncs=33 queued=21 decompiled=21 lumina nreq=0 worse=0 better=0
// ALL OK, 21 function(s) have been successfully decompiled
Para resolver el juego y obtener una licencia válida, nos fijamos en el proceso de validación que se encuentra en la función validar (líneas 237 a 258). Esta función compara una entrada de licencia codificada con una licencia codificada almacenada en el programa.
La licencia almacenada es "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", y se utiliza la función encode (líneas 207 a 234) para codificar la entrada del usuario antes de compararla. La función encode aplica un cifrado simple a la entrada, alterando los caracteres alfabéticos según una fórmula específica.
La función de cifrado encode realiza lo siguiente:
(5 * (char - 97) + 8) % 26 + 97.(5 * (char - 65) + 8) % 26 + 65.Nos construimos una función en Python para decodificar la Flag y reto superado.
def decode(encoded_char):
if 'a' <= encoded_char <= 'z':
original_char = chr(((ord(encoded_char) - 97 - 8) * 21) % 26 + 97)
elif 'A' <= encoded_char <= 'Z':
original_char = chr(((ord(encoded_char) - 65 - 8) * 21) % 26 + 65)
else:
original_char = encoded_char
return original_char
encoded_license = "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}"
decoded_license = "".join(decode(char) for char in encoded_license)
print("Licencia descifrada:", decoded_license)
Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma más limpia posible.
Abrimos el crackme con Olly y ya a simple vista vemos los mensajes de la Nag y parte del código interesante. Si necesitaramos localizar la Nag podemos mirar en las intermodular calls las típicas subrutinas, en este caso se ve claramente a MessageBoxA, bastaría con poner un breakpoint para localizar quien llama.
Aquí vemos la implicación de MessageBoxA.
004010A7 |> \6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 004010A9 |. 68 61304000 PUSH Nag1.00403061 ; |Title = "[NAG] Please register this software!" 004010AE |. 68 86304000 PUSH Nag1.00403086 ; |Text = "[BULLSHIT] Please register this software for support and you'll receive the full version!" 004010B3 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 004010B6 |. E8 49010000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401137 |. 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 00401139 |. 68 6E324000 PUSH Nag1.0040326E ; |Title = "Thank you!" 0040113E |. 68 79324000 PUSH Nag1.00403279 ; |Text = "Thank you for registering this software!" 00401143 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 00401146 |. E8 B9000000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401155 |. 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 00401157 |. 68 E0304000 PUSH Nag1.004030E0 ; |Title = "About" 0040115C |. 68 E6304000 PUSH Nag1.004030E6 ; |Text = "Remove the NAG by TDC\r\n\n..: Coded by\t: TDC\t\t\t:..\t\r\n..: Also known as\t: The Dutch Cracker\t:..\t\r\n..: Protection\t: Custom\t\t\t:..\t\r\n..: Contact info\t: tdc123@gmail.com\t:..\t\r\n..: Release date\t: 09-08-2005\t\t:..\t"... 00401161 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 00401164 |. E8 9B000000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA
Un poco encima vemos la función SetDlgItemTextA, que nos mostrará el mensaje de que hemos parcheado correctamente.
00401106 |> \68 21304000 PUSH Nag1.00403021 ; /Text = "Dirty crack! Nag removed not registered!" 0040110B |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040110D |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401110 |. E8 FB000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA 00401115 |. EB 36 JMP SHORT Nag1.0040114D 00401117 |> 68 10304000 PUSH Nag1.00403010 ; /Text = "Nag not removed!" 0040111C |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040111E |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401121 |. E8 EA000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA 00401126 |. EB 25 JMP SHORT Nag1.0040114D 00401128 |> 68 4A304000 PUSH Nag1.0040304A ; /Text = "Clean crack! Good Job!" 0040112D |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040112F |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401132 |. E8 D9000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA
Encima de SetDlgItemTextA vemos el código que analiza si la Nag tiene que aparecer.
004010E6 |. E8 C4000000 CALL Nag1.004011AF ; ; Llamada interesante a analizar 004010EB |. 803D B0324000 03 CMP BYTE PTR DS:[4032B0],3 004010F2 |. 74 12 JE SHORT Nag1.00401106 ; ; Si de la llamada volvemos con un 3 -> Parcheo chapuza 004010F4 |. 803D B0324000 02 CMP BYTE PTR DS:[4032B0],2 004010FB |. 74 1A JE SHORT Nag1.00401117 ; ; Si de la llamada volvemos con un 2 -> Sin parchear 004010FD |. 803D B0324000 01 CMP BYTE PTR DS:[4032B0],1 00401104 |. 74 22 JE SHORT Nag1.00401128 ; ; Si de la llamada volvemos con un 1 -> Buen trabajo Joe! ........ 004011AF /$ 68 A2324000 PUSH Nag1.004032A2 ; /String2 = "Value1" 004011B4 |. 68 A9324000 PUSH Nag1.004032A9 ; |String1 = "Value2" 004011B9 |. E8 64000000 CALL <JMP.&kernel32.lstrcmpA> ; \lstrcmpA 004011BE |. 50 PUSH EAX ; kernel32.BaseThreadInitThunk 004011BF |. 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 004011C1 |. 75 10 JNZ SHORT Nag1.004011D3 004011C3 |. 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011C5 |. 58 POP EAX ; kernel32.75CDEE1C 004011C6 |. 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 004011C8 |. 74 15 JE SHORT Nag1.004011DF 004011CA |. C605 B0324000 03 MOV BYTE PTR DS:[4032B0],3 004011D1 |. EB 17 JMP SHORT Nag1.004011EA 004011D3 |> 58 POP EAX ; kernel32.75CDEE1C 004011D4 |. 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011D6 |. C605 B0324000 02 MOV BYTE PTR DS:[4032B0],2 004011DD |. EB 0B JMP SHORT Nag1.004011EA 004011DF |> 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011E1 |. C605 B0324000 01 MOV BYTE PTR DS:[4032B0],1 004011E8 |. EB 00 JMP SHORT Nag1.004011EA 004011EA \> C3 RETN
Vemos dentro del Call 4011AF que Compara si Value1 = Value2 y dependiendo de esa comparación guarda en memoria (4032B0), los valores 1, 2 ó 3.
Basta con modificar en un editor hexadecimal la parabra «Value2» por «Value1» y ya tenemos el problema resuelto.
Al pulsar Re-Check
Se podía haber parcheado un montón de código para obtener el mismo resultado pero fijándonos en el código lo hemos conseguido parcheando un solo byte. Recuerda, cuando halla que parchear, cuantos menos bytes mejor.
Este crackme pertenece a la página de Karpoff Spanish Tutor. Data del año 2000 y está realizado en «Borland Delphi 6.0 – 7.0», además, para resolverlo deberemos activar un botón y conseguir la clave de registro. La principal dificultad proviene a la hora de activar el botón ya que el serial es en realidad un serial hardcodeado muy sencillo.
Existen numerosas herramientas para facilitarnos esta tarea, una de las más conocidas en el entorno del Cracking es «Veoveo» realizado por Crack el Destripador & Marmota hace ya unos añitos. Con el crackme ejecutado, ejecutamos VeoVeo y nos aparece el icono en la barra de tareas, hacemos click derecho y elegimos Activar Botones (manual) y ya tenemos el botón activado. Claro está que en cada ejecución del Crackme debemos de Re-activarlo.
Lo que siempre nos interesa es que el botón esté activado de forma permanente y eso nos exige un poco más de atención. En este caso nos enfrentamos a Delphi y no nos sirve ni Resource Hacker ni Dede. Cuando nos encontramos en un punto muerto el último recurso siempre es realizar un programa en Delphi con un botón activado y otro desactivado y compararlos con un editor hexadecimal para saber que cambia. Si hacemos esto llegaremos a la conclusión de que en Delphi el bit que equivale a desactivado es 8 y ha activado es 9. Con este simple cambio ya tenemos el crackme parcheado. Comentar que en este caso el crackme no tiene ningún timer ni ninguna rutina que desactive el botón de forma periódica, este es el caso más simple.
Abrimos Ollydbg y en las «String references» encontramos los mensajes de versión registrada, pinchamos sobre ellos y vemos a simple vista la zona de comprobación del serial. Como podéis observar, el serial se vé a simple vista.
0045811A |. B8 10824500 MOV EAX,CrackMe3.00458210 ; ASCII "ESCRIBE ALGO JOER" 0045811F |. E8 D889FDFF CALL CrackMe3.00430AFC 00458124 |. EB 5C JMP SHORT CrackMe3.00458182 00458126 |> 807D FF 4F CMP BYTE PTR SS:[EBP-1],4F - O 0045812A |. 75 56 JNZ SHORT CrackMe3.00458182 0045812C |. 807D FE 41 CMP BYTE PTR SS:[EBP-2],41 - A 00458130 |. 75 50 JNZ SHORT CrackMe3.00458182 00458132 |. 807D FD 45 CMP BYTE PTR SS:[EBP-3],45 - E 00458136 |. 75 4A JNZ SHORT CrackMe3.00458182 00458138 |. 807D FC 4B CMP BYTE PTR SS:[EBP-4],4B - K 0045813C |. 75 44 JNZ SHORT CrackMe3.00458182 0045813E |. 807D FB 43 CMP BYTE PTR SS:[EBP-5],43 - C 00458142 |. 75 3E JNZ SHORT CrackMe3.00458182 00458144 |. 807D FA 41 CMP BYTE PTR SS:[EBP-6],41 - A 00458148 |. 75 38 JNZ SHORT CrackMe3.00458182 0045814A |. 807D F9 52 CMP BYTE PTR SS:[EBP-7],52 - R 0045814E |. 75 32 JNZ SHORT CrackMe3.00458182 00458150 |. 807D F8 4B CMP BYTE PTR SS:[EBP-8],4B - K 00458154 |. 75 2C JNZ SHORT CrackMe3.00458182 00458156 |. 807D F7 20 CMP BYTE PTR SS:[EBP-9],20 - 0045815A |. 75 26 JNZ SHORT CrackMe3.00458182 0045815C |. 807D F6 49 CMP BYTE PTR SS:[EBP-A],49 - I 00458160 |. 75 20 JNZ SHORT CrackMe3.00458182 00458162 |. 807D F5 4F CMP BYTE PTR SS:[EBP-B],4F - O 00458166 |. 75 1A JNZ SHORT CrackMe3.00458182 00458168 |. 807D F4 54 CMP BYTE PTR SS:[EBP-C],54 - T 0045816C |. 75 14 JNZ SHORT CrackMe3.00458182 0045816E |. 807D F3 20 CMP BYTE PTR SS:[EBP-D],20 - 00458172 |. 75 0E JNZ SHORT CrackMe3.00458182 00458174 |. 807D F2 41 CMP BYTE PTR SS:[EBP-E],41 - A 00458178 |. 75 08 JNZ SHORT CrackMe3.00458182 0045817A |. 807D F1 59 CMP BYTE PTR SS:[EBP-F],59 - Y 0045817E |. 75 02 JNZ SHORT CrackMe3.00458182 00458180 |. B3 01 MOV BL,1 00458182 |> 80FB 01 CMP BL,1 00458185 |. 75 4C JNZ SHORT CrackMe3.004581D3 00458187 |. BA 2C824500 MOV EDX,CrackMe3.0045822C 0045818C |. 8B86 F4020000 MOV EAX,DWORD PTR DS:[ESI+2F4] 00458192 |. E8 B5EBFDFF CALL CrackMe3.00436D4C 00458197 |. BA 48824500 MOV EDX,CrackMe3.00458248 ; ASCII "VERSION REGISTRADA :)" Serial = YA TOI KRACKEAO
Hoy vamos a hacer algo diferente, vamos a hacer un keygen con la propia víctima. El término anglosajón para esto es «selfkeygening» y no es que esté muy bien visto por los reversers pero a veces nos puede sacar de apuros.
La víctima elegida es el Crackme 2 de LaFarge. Está hecho en ensamblador.
Primeramente vamos a realizar un injerto light, con esto quiero decir que vamos a mostrar el serial bueno en la MessageBox de error.
Abrimos Olly y localizamos el código de comprobación del serial, tenemos suerte ya que el serial se muestra completamente y no se comprueba byte a byte ni cosas raras. En la imagen inferior os muestro el serial bueno para el nombre deurus y el mensaje de error. Como podeis observar el serial bueno se saca de memoria con la instrucción PUSH 406749 y el mensaje de error con PUSH 406306.
Si cambiamos el PUSH del serial por el de el mensaje de error ya lo tendriámos. Nos situamos encima del PUSH 406306 y pulsamos espacio, nos saldrá un diálogo con el push, lo modificamos y le damos a Assemble.
Ahora el crackme cada vez que le demos a Check it! nos mostrará:
Pero no nos vamos a quedar ahí. Lo interesante sería que el serial bueno lo mostrara en la caja de texto del serial. Esto lo vamos a hacer con la función user32.SetDlgItemTextA.
Según dice la función necesitamos el handle de la ventana, el ID de la caja de texto y el string a mostrar. La primera y segunda la obtenemos fijándonos en la función GetDlgItemTextA que recoje el serial introducido por nosotros. La string es el PUSH 406749.
Con esto ya tenemos todo lo que necesitamos excepto el espacio dentro del código, en este caso lo lógico es parchear las MessageBox de error y acierto. Las seleccionamos, click derecho y Edit > Fill with NOPs.
Ahora escribimos el injerto.
Finalmente con Resource Hack cambiamos el aspecto del programa para que quede más profesional y listo. Tenemos pendiente hacer el keygen puro y duro, venga agur.
Se nos entrega un ELF que decompilado presenta este aspecto:
/* 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_401020();
__int64 sub_401030(); // weak
__int64 sub_401040(); // weak
__int64 sub_401050(); // weak
__int64 sub_401060(); // weak
__int64 sub_401070(); // weak
// int puts(const char *s);
// int printf(const char *format, ...);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void dl_relocate_static_pie();
char *deregister_tm_clones();
__int64 register_tm_clones();
char *_do_global_dtors_aux();
__int64 frame_dummy();
int __fastcall main(int argc, const char **argv, const char **envp);
_BYTE *__fastcall encode(__int64 a1);
__int64 __fastcall validar(const char *a1);
int banner();
int comprar();
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);
// __int64 _gmon_start__(void); weak
//-------------------------------------------------------------------------
// Data declarations
_UNKNOWN _libc_csu_init;
const char a31mparaSeguirU[43] = "\x1B[31mPara seguir usando este producto deber"; // idb
const char a32myaPuedesSeg[61] = "\x1B[32mYa puedes seguir afinando tus instrumentos (y tus flags "; // idb
const char aDirigaseANuest[21] = "\nDirigase a nuestra p"; // idb
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
__int64 (*qword_404010)(void) = NULL; // weak
char _bss_start; // weak
//----- (0000000000401000) ----------------------------------------------------
__int64 (**init_proc())(void)
{
__int64 (**result)(void); // rax
result = &_gmon_start__;
if ( &_gmon_start__ )
return (__int64 (**)(void))_gmon_start__();
return result;
}
// 404090: using guessed type __int64 _gmon_start__(void);
//----- (0000000000401020) ----------------------------------------------------
__int64 sub_401020()
{
return qword_404010();
}
// 404010: using guessed type __int64 (*qword_404010)(void);
//----- (0000000000401030) ----------------------------------------------------
__int64 sub_401030()
{
return sub_401020();
}
// 401030: using guessed type __int64 sub_401030();
//----- (0000000000401040) ----------------------------------------------------
__int64 sub_401040()
{
return sub_401020();
}
// 401040: using guessed type __int64 sub_401040();
//----- (0000000000401050) ----------------------------------------------------
__int64 sub_401050()
{
return sub_401020();
}
// 401050: using guessed type __int64 sub_401050();
//----- (0000000000401060) ----------------------------------------------------
__int64 sub_401060()
{
return sub_401020();
}
// 401060: using guessed type __int64 sub_401060();
//----- (0000000000401070) ----------------------------------------------------
__int64 sub_401070()
{
return sub_401020();
}
// 401070: using guessed type __int64 sub_401070();
//----- (00000000004010D0) ----------------------------------------------------
// 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();
}
// 4010DA: positive sp value 8 has been found
// 4010E1: variable 'v3' is possibly undefined
//----- (0000000000401100) ----------------------------------------------------
void dl_relocate_static_pie()
{
;
}
//----- (0000000000401110) ----------------------------------------------------
char *deregister_tm_clones()
{
return &_bss_start;
}
// 404050: using guessed type char _bss_start;
//----- (0000000000401140) ----------------------------------------------------
__int64 register_tm_clones()
{
return 0LL;
}
//----- (0000000000401180) ----------------------------------------------------
char *_do_global_dtors_aux()
{
char *result; // rax
if ( !_bss_start )
{
result = deregister_tm_clones();
_bss_start = 1;
}
return result;
}
// 404050: using guessed type char _bss_start;
//----- (00000000004011B0) ----------------------------------------------------
__int64 frame_dummy()
{
return register_tm_clones();
}
//----- (00000000004011B6) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
int v4; // [rsp+10h] [rbp-10h] BYREF
int v5; // [rsp+14h] [rbp-Ch]
unsigned __int64 v6; // [rsp+18h] [rbp-8h]
v6 = __readfsqword(0x28u);
v5 = 0;
puts("\n\x1B[31m -----------Se le ha acabado el periodo de prueba gratuito-----------\n");
puts(a31mparaSeguirU);
do
{
banner();
__isoc99_scanf("%d", &v4);
if ( v4 == 3 )
exit(0);
if ( v4 > 3 )
goto LABEL_10;
if ( v4 == 1 )
{
comprar();
continue;
}
if ( v4 == 2 )
v5 = validar("%d");
else
LABEL_10:
puts("Opcion invalida, pruebe otra vez");
}
while ( !v5 );
puts(a32myaPuedesSeg);
return 0;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);
//----- (0000000000401291) ----------------------------------------------------
_BYTE *__fastcall encode(__int64 a1)
{
_BYTE *result; // rax
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; i <= 33; ++i )
{
if ( *(char *)(i + a1) <= 96 || *(char *)(i + a1) > 122 )
{
if ( *(char *)(i + a1) <= 64 || *(char *)(i + a1) > 90 )
{
result = (_BYTE *)*(unsigned __int8 *)(i + a1);
*(_BYTE *)(i + a1) = (_BYTE)result;
}
else
{
result = (_BYTE *)(i + a1);
*result = (5 * ((char)*result - 65) + 8) % 26 + 65;
}
}
else
{
result = (_BYTE *)(i + a1);
*result = (5 * ((char)*result - 97) + 8) % 26 + 97;
}
}
return result;
}
//----- (00000000004013DB) ----------------------------------------------------
__int64 __fastcall validar(const char *a1)
{
int i; // [rsp+Ch] [rbp-64h]
char v3[48]; // [rsp+10h] [rbp-60h] BYREF
__int64 v4[6]; // [rsp+40h] [rbp-30h] BYREF
v4[5] = __readfsqword(0x28u);
qmemcpy(v4, "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", 34);
printf("\nIntroduce tu licencia: ");
__isoc99_scanf("%s", v3);
encode((__int64)v3);
for ( i = 0; i <= 33; ++i )
{
if ( v3[i] != *((_BYTE *)v4 + i) )
{
puts("\n\x1B[31mTu licencia es incorrecta\x1B[37m\n");
return 0LL;
}
}
puts("\n\x1B[32mEres un crack, lo conseguiste\x1B[37m");
return 1LL;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4013DB: using guessed type char var_60[48];
//----- (00000000004014CE) ----------------------------------------------------
int banner()
{
puts(" ___________OPCIONES___________");
puts(" | 1: Comprar licencia premium |");
puts(" | 2: Validar clave de licencia |");
puts(" | 3: Salir |");
puts(" ------------------------------");
return printf("> ");
}
//----- (0000000000401526) ----------------------------------------------------
int comprar()
{
return puts(aDirigaseANuest);
}
//----- (0000000000401540) ----------------------------------------------------
void __fastcall _libc_csu_init(unsigned int a1, __int64 a2, __int64 a3)
{
signed __int64 v3; // rbp
__int64 i; // rbx
init_proc();
v3 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
if ( v3 )
{
for ( i = 0LL; i != v3; ++i )
(*(&_frame_dummy_init_array_entry + i))();
}
}
// 403E10: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 403E18: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();
//----- (00000000004015B0) ----------------------------------------------------
void _libc_csu_fini(void)
{
;
}
//----- (00000000004015B8) ----------------------------------------------------
void term_proc()
{
;
}
// nfuncs=33 queued=21 decompiled=21 lumina nreq=0 worse=0 better=0
// ALL OK, 21 function(s) have been successfully decompiled
Para resolver el juego y obtener una licencia válida, nos fijamos en el proceso de validación que se encuentra en la función validar (líneas 237 a 258). Esta función compara una entrada de licencia codificada con una licencia codificada almacenada en el programa.
La licencia almacenada es "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", y se utiliza la función encode (líneas 207 a 234) para codificar la entrada del usuario antes de compararla. La función encode aplica un cifrado simple a la entrada, alterando los caracteres alfabéticos según una fórmula específica.
La función de cifrado encode realiza lo siguiente:
(5 * (char - 97) + 8) % 26 + 97.(5 * (char - 65) + 8) % 26 + 65.Nos construimos una función en Python para decodificar la Flag y reto superado.
def decode(encoded_char):
if 'a' <= encoded_char <= 'z':
original_char = chr(((ord(encoded_char) - 97 - 8) * 21) % 26 + 97)
elif 'A' <= encoded_char <= 'Z':
original_char = chr(((ord(encoded_char) - 65 - 8) * 21) % 26 + 65)
else:
original_char = encoded_char
return original_char
encoded_license = "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}"
decoded_license = "".join(decode(char) for char in encoded_license)
print("Licencia descifrada:", decoded_license)
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.
Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de programación esotérico bastante complejo.
[-]>[-]<>++++++++[<++++++++++>-]<.+++++++++++++++++.>+++[<++++++>-]<..++++.- -------.+++.--------------.>++++++[<------>-]<-.>+++++[<------>-]<-.,>,>,>,> >>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++ +++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++>>>>++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<< <<<<<<<<<<<<<<<<[>>>>>>>-<<<<<<<-]>>>>>>><<+>>[[-]++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++++++++++++++++.<]<[>]<<<<<[>>>>>>>>>>-<<<<<<<< <<-]>>>>>>>>>><<+>>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++.<]<[>]<<<<<<<<[>>>>>>>>>>>>>-<<<<<<<<<<<<<-]>>>>>>>>>>>>><<+>>[ [-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ .<]<[>]<<<<<<<<<<<[>>>>>>>>>>>>>>>>-<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>><<+>>[ [-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++.<]<[>]>>>[-]>[-]<+++++++++++++.---.>+++++++[<++++++++++++>-]<.>+++++++[< --------->-]<+.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<--------- ->-]<.>++++++++[<+++++++++>-]<+.+++++++++++.>+++++++[<----------->-]<.>+++++ ++[<+++++++++++>-]<-.>+++++++[<------------>-]<+.>++++++++[<+++++++++++>-]<- .-----.---------.+++++++++++..---------------.+++++++++.>++++++[<----------- -->-]<.+++++++.>+++++[<++++++>-]<+.-----.++++++++.+++.>++++++[<------>-]<-.- ------.>++++++++[<++++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>++ +++[<++++++>-]<+.-----.+++++++++++.>++++++[<------>-]<-.-------.>++++++++[<+ +++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>+++++[<+++++>-]<+.+++ +++++.+++.>++++++[<------>-]<-.+++++++...--------------.>++++++++[<+++++++++ ++>-]<+.----------.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>- ]<.-------.>+++[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++ +++++[<++++++++++>-]<.-----.++++++++.+++.-------.-.>++++++[<--------->-]<.-- ------------.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<----------> -]<.>+++++++[<++++++++++++>-]<.------------.---.+++++++++++++.-------------. >+++++++[<---------->-]<+.>++++++++[<+++++++++>-]<+.++++++++++.>+++++++[<--- --------->-]<+.>++++++[<+++++++++++++>-]<.+.+++++.------------.+.+++++.----- --.>++++++[<---------->-]<+.------------.>++++++++[<+++++++++++>-]<+.------- ---.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-]<.-------.>+++ [<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++++++++[<+++++++ ++++>-]<-.--------------.+++++.>++++++[<------------->-]<.+.
La solución que he encontrado yo, es convertir el código brainfuck a algo más amigable y depurarlo hasta encontrar la solución. La conversión la he realizado con VBBrainFNET y luego la depuración con Visual Studio. El crackme te pide una clave de cuatro cifras para darte la solución, pero si no quieres volverte loco puedes amañar los bucles para encontrar la solución.
¡SUERTE!
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.
This crackme is for the crack challenge 6 of canyouhack.it.
Hoy tenemos aquí un capitulo del gran David Slade, productor de Series como American Gods o Hannibal y director de películas como Hard Candy o 30 días de oscuridad.
Lo que más me ha gustado del capítulo es el guiño que han hecho a la RaspBerry PI. La escena transcurre al inicio del capítulo cuando uno de los protagonistas se conecta a un vehículo para hackearlo con una Raspi 3 Model B con varios pines del GPIO doblados. Os dejo unas capturas a continuación donde se aprecia el logo.
Ya puestos, la conexión parece micro usb tipo B. Al fondo se ve lo que parece un puerto HDMI.
Lo que no me ha gustado es que al fijarme en el software que corre en el vehículo aparece un flamante OMNIBOOT.EXE con un aspecto parecido al símbolo de sistema, es decir, nos intentan vender que en un futuro el software que gestiona el vehículo es alguna variación de Windows, algo poco probable a día de hoy al menos. Con este tipo de predicciones no se puede escupir hacia arriba pero actualmente es más probable un nucleo tipo Linux u otro propietario al estilo Tesla.
Software del vehículo
Os dejo todas las capturas relevantes a continuación.
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.
Aquí tenemos un Crackme clásico creado por Scarebyte hallá por el año 2000 y que cuenta con varias fases siendo un crackme muy interesante para iniciarse o simplemente para divertirse. Al estar realizado en Delphi, los apartados de las checkboxes y de las trackbars se simplifican y mucho, pero aún así hay que currarselo un poco para dejar todo bien atado. Si os fijáis en las soluciones que aparecen en crackmes.de, en aquellos años se usaba DEDE y aunque yo usaré otra herramienta, DEDE sigue siendo igual de útil.
PEiD nos dice que nos enfrentamos a ASPack 1.08.03 -> Alexey Solodovnikov, así que vamos al lío.
Tan sencillo como poner un Breakpoint a User32.MessageBoxA. La llamada a NOPear está en la dirección 441CF2.
Desde las string references localizamos los mensajes de chico bueno y chico malo que nos llevan al código a analizar.
0044C3CD |. E8 5294FDFF CALL CrackMe_.00425824 0044C3D2 |. 8B45 FC MOV EAX,[LOCAL.1] 0044C3D5 |. E8 9A76FBFF CALL CrackMe_.00403A74 0044C3DA |. 83F8 0C CMP EAX,0C ; Lengh C = 12 0044C3DD |. 0F85 53010000 JNZ CrackMe_.0044C536 ; Salto a chico malo 0044C3E3 |. 8D55 FC LEA EDX,[LOCAL.1] 0044C3E6 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C3EC |. E8 3394FDFF CALL CrackMe_.00425824 0044C3F1 |. 8B45 FC MOV EAX,[LOCAL.1] 0044C3F4 |. 8038 43 CMP BYTE PTR DS:[EAX],43 ; 1º dígito serial = C 0044C3F7 |. 0F85 27010000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C3FD |. 8D55 F8 LEA EDX,[LOCAL.2] 0044C400 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C406 |. E8 1994FDFF CALL CrackMe_.00425824 0044C40B |. 8B45 F8 MOV EAX,[LOCAL.2] 0044C40E |. 8078 03 6F CMP BYTE PTR DS:[EAX+3],6F ; 4º dígito serial = o 0044C412 |. 0F85 0C010000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C418 |. 8D55 F4 LEA EDX,[LOCAL.3] 0044C41B |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C421 |. E8 FE93FDFF CALL CrackMe_.00425824 0044C426 |. 8B45 F4 MOV EAX,[LOCAL.3] 0044C429 |. 8078 08 6F CMP BYTE PTR DS:[EAX+8],6F ; 9º dígito serial = o 0044C42D |. 0F85 F1000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C433 |. 8D55 F0 LEA EDX,[LOCAL.4] 0044C436 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C43C |. E8 E393FDFF CALL CrackMe_.00425824 0044C441 |. 8B45 F0 MOV EAX,[LOCAL.4] 0044C444 |. 8078 01 6C CMP BYTE PTR DS:[EAX+1],6C ; 2º dígito serial = l 0044C448 |. 0F85 D6000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C44E |. 8D55 EC LEA EDX,[LOCAL.5] 0044C451 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C457 |. E8 C893FDFF CALL CrackMe_.00425824 0044C45C |. 8B45 EC MOV EAX,[LOCAL.5] 0044C45F |. 8078 04 20 CMP BYTE PTR DS:[EAX+4],20 ; 5º dígito serial = espacio 0044C463 |. 0F85 BB000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C469 |. 8D55 E8 LEA EDX,[LOCAL.6] 0044C46C |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C472 |. E8 AD93FDFF CALL CrackMe_.00425824 0044C477 |. 8B45 E8 MOV EAX,[LOCAL.6] 0044C47A |. 8078 0A 52 CMP BYTE PTR DS:[EAX+A],52 ; 11º dígito serial = R 0044C47E |. 0F85 A0000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C484 |. 8D55 E4 LEA EDX,[LOCAL.7] 0044C487 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C48D |. E8 9293FDFF CALL CrackMe_.00425824 0044C492 |. 8B45 E4 MOV EAX,[LOCAL.7] 0044C495 |. 8078 07 75 CMP BYTE PTR DS:[EAX+7],75 ; 8º dígito serial = u 0044C499 |. 0F85 85000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C49F |. 8D55 E0 LEA EDX,[LOCAL.8] 0044C4A2 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4A8 |. E8 7793FDFF CALL CrackMe_.00425824 0044C4AD |. 8B45 E0 MOV EAX,[LOCAL.8] 0044C4B0 |. 8078 09 6E CMP BYTE PTR DS:[EAX+9],6E ; 10º dígito serial = n 0044C4B4 |. 75 6E JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4B6 |. 8D55 DC LEA EDX,[LOCAL.9] 0044C4B9 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4BF |. E8 6093FDFF CALL CrackMe_.00425824 0044C4C4 |. 8B45 DC MOV EAX,[LOCAL.9] 0044C4C7 |. 8078 02 6E CMP BYTE PTR DS:[EAX+2],6E ; 3º dígito serial = n 0044C4CB |. 75 57 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4CD |. 8D55 D8 LEA EDX,[LOCAL.10] 0044C4D0 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4D6 |. E8 4993FDFF CALL CrackMe_.00425824 0044C4DB |. 8B45 D8 MOV EAX,[LOCAL.10] 0044C4DE |. 8078 05 69 CMP BYTE PTR DS:[EAX+5],69 ; 6º dígito serial = i 0044C4E2 |. 75 40 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4E4 |. 8D55 D4 LEA EDX,[LOCAL.11] 0044C4E7 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4ED |. E8 3293FDFF CALL CrackMe_.00425824 0044C4F2 |. 8B45 D4 MOV EAX,[LOCAL.11] 0044C4F5 |. 8078 0B 6E CMP BYTE PTR DS:[EAX+B],6E ; 12º dígito serial = n 0044C4F9 |. 75 29 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4FB |. 8D55 D0 LEA EDX,[LOCAL.12] 0044C4FE |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C504 |. E8 1B93FDFF CALL CrackMe_.00425824 0044C509 |. 8B45 D0 MOV EAX,[LOCAL.12] 0044C50C |. 8078 06 67 CMP BYTE PTR DS:[EAX+6],67 ; 7º dígito serial = g 0044C510 |. 75 12 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C512 |. BA 78C54400 MOV EDX,CrackMe_.0044C578 ; ASCII "Right Password" 0044C517 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C51D |. E8 3293FDFF CALL CrackMe_.00425854 0044C522 |. EB 22 JMP SHORT CrackMe_.0044C546 0044C524 |> BA 90C54400 MOV EDX,CrackMe_.0044C590 ; ASCII "Wrong Password" 0044C529 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C52F |. E8 2093FDFF CALL CrackMe_.00425854 0044C534 |. EB 10 JMP SHORT CrackMe_.0044C546 0044C536 |> BA 90C54400 MOV EDX,CrackMe_.0044C590 ; ASCII "Wrong Password" Chequeo rápido ABCD EFGHIJK Clno iguonRn ; 1º dígito serial = C ; 4º dígito serial = o ; 9º dígito serial = o ; 2º dígito serial = l ; 5º dígito serial = espacio ; 11º dígito serial = R ; 8º dígito serial = u ; 10º dígito serial = n ; 3º dígito serial = n ; 6º dígito serial = i ; 12º dígito serial = n ; 7º dígito serial = g
Básicamente chequea la frase «Cool Running» de forma desordenada como se ve justo encima, siendo el password correcto «Clno iguonRn«. Os dejo el código para que lo analicéis.
De nuevo con las string references localizamos el código.
0044C648 /. 55 PUSH EBP 0044C649 |. 8BEC MOV EBP,ESP 0044C64B |. 83C4 F8 ADD ESP,-8 0044C64E |. 53 PUSH EBX 0044C64F |. 56 PUSH ESI 0044C650 |. 33C9 XOR ECX,ECX 0044C652 |. 894D F8 MOV [LOCAL.2],ECX 0044C655 |. 8BF0 MOV ESI,EAX 0044C657 |. 33C0 XOR EAX,EAX 0044C659 |. 55 PUSH EBP 0044C65A |. 68 83C74400 PUSH CrackMe_.0044C783 0044C65F |. 64:FF30 PUSH DWORD PTR FS:[EAX] 0044C662 |. 64:8920 MOV DWORD PTR FS:[EAX],ESP 0044C665 |. 33C0 XOR EAX,EAX 0044C667 |. 8945 FC MOV [LOCAL.1],EAX 0044C66A |. A1 80F84400 MOV EAX,DWORD PTR DS:[44F880] ; Eax = Nombre 0044C66F |. E8 0074FBFF CALL CrackMe_.00403A74 0044C674 |. 83F8 06 CMP EAX,6 ; Cmp lengh nombre con 6 0044C677 |. 0F8E F0000000 JLE CrackMe_.0044C76D ; Salta si <= 6 0044C67D |. A1 80F84400 MOV EAX,DWORD PTR DS:[44F880] ; Eax = Nombre 0044C682 |. E8 ED73FBFF CALL CrackMe_.00403A74 0044C687 |. 83F8 14 CMP EAX,14 ; Cmp lengh nombre con 20 (14h) 0044C68A |. 0F8D DD000000 JGE CrackMe_.0044C76D ; salta si >= 20 0044C690 |. A1 80F84400 MOV EAX,DWORD PTR DS:[44F880] 0044C695 |. E8 DA73FBFF CALL CrackMe_.00403A74 0044C69A |. 85C0 TEST EAX,EAX 0044C69C |. 7E 17 JLE SHORT CrackMe_.0044C6B5 0044C69E |. BA 01000000 MOV EDX,1 0044C6A3 |> 8B0D 80F84400 /MOV ECX,DWORD PTR DS:[44F880] ; Bucle in 0044C6A9 |. 0FB64C11 FF |MOVZX ECX,BYTE PTR DS:[ECX+EDX-1] 0044C6AE |. 014D FC |ADD [LOCAL.1],ECX ; Suma dig nombre y guarda en 12FBC4 0044C6B1 |. 42 |INC EDX 0044C6B2 |. 48 |DEC EAX 0044C6B3 |.^ 75 EE \JNZ SHORT CrackMe_.0044C6A3 ; Bucle out 0044C6B5 |> A1 84F84400 MOV EAX,DWORD PTR DS:[44F884] ; Eax = Compañia 0044C6BA |. E8 B573FBFF CALL CrackMe_.00403A74 0044C6BF |. 83F8 02 CMP EAX,2 ; Cmp lengh compañia con 2 0044C6C2 |. 7E 18 JLE SHORT CrackMe_.0044C6DC ; Salta si <= 2 0044C6C4 |. A1 84F84400 MOV EAX,DWORD PTR DS:[44F884] ; Eax = Compañia 0044C6C9 |. E8 A673FBFF CALL CrackMe_.00403A74 0044C6CE |. 83F8 08 CMP EAX,8 ; Cmp lengh compañia con 8 0044C6D1 |. 7D 09 JGE SHORT CrackMe_.0044C6DC ; Salta si >= 8 0044C6D3 |. 8B45 FC MOV EAX,[LOCAL.1] ; Eax = sum nombre 0044C6D6 |. 6BC0 02 IMUL EAX,EAX,2 ; Sum nombre * 2 0044C6D9 |. 8945 FC MOV [LOCAL.1],EAX 0044C6DC |> 68 98C74400 PUSH CrackMe_.0044C798 ; ASCII "I Love Cracking and " 0044C6E1 |. 8D55 F8 LEA EDX,[LOCAL.2] 0044C6E4 |. 8B45 FC MOV EAX,[LOCAL.1] 0044C6E7 |. E8 68B0FBFF CALL CrackMe_.00407754 0044C6EC |. FF75 F8 PUSH [LOCAL.2] ; sum del nombre 0044C6EF |. 68 B8C74400 PUSH CrackMe_.0044C7B8 ; ASCII " Girls ;)" 0044C6F4 |. B8 8CF84400 MOV EAX,CrackMe_.0044F88C 0044C6F9 |. BA 03000000 MOV EDX,3 0044C6FE |. E8 3174FBFF CALL CrackMe_.00403B34 ; Concatena 1º frase + sum nombre + 2ºfrase 0044C703 |. 33C0 XOR EAX,EAX 0044C705 |. 8945 FC MOV [LOCAL.1],EAX 0044C708 |. A1 88F84400 MOV EAX,DWORD PTR DS:[44F888] ; Eax = Serial 0044C70D |. E8 6273FBFF CALL CrackMe_.00403A74 0044C712 |. 8BD8 MOV EBX,EAX 0044C714 |. A1 8CF84400 MOV EAX,DWORD PTR DS:[44F88C] 0044C719 |. E8 5673FBFF CALL CrackMe_.00403A74 0044C71E |. 3BD8 CMP EBX,EAX ; Compara tamaño frase con tamaño serial 0044C720 |. 75 4B JNZ SHORT CrackMe_.0044C76D 0044C722 |. A1 88F84400 MOV EAX,DWORD PTR DS:[44F888] 0044C727 |. E8 4873FBFF CALL CrackMe_.00403A74 0044C72C |. 85C0 TEST EAX,EAX 0044C72E |. 7E 27 JLE SHORT CrackMe_.0044C757 0044C730 |. BA 01000000 MOV EDX,1 0044C735 |> 8B0D 88F84400 /MOV ECX,DWORD PTR DS:[44F888] ; Bucle in --> 0044C73B |. 0FB64C11 FF |MOVZX ECX,BYTE PTR DS:[ECX+EDX-1] 0044C740 |. 034D FC |ADD ECX,[LOCAL.1] 0044C743 |. 8B1D 8CF84400 |MOV EBX,DWORD PTR DS:[44F88C] 0044C749 |. 0FB65C13 FF |MOVZX EBX,BYTE PTR DS:[EBX+EDX-1] ; Compara dígito a dígito nuestro serial 0044C74E |. 2BCB |SUB ECX,EBX ; con la concatenación anterior 0044C750 |. 894D FC |MOV [LOCAL.1],ECX 0044C753 |. 42 |INC EDX 0044C754 |. 48 |DEC EAX 0044C755 |.^ 75 DE \JNZ SHORT CrackMe_.0044C735 ; <-- Bucle out 0044C757 |> 837D FC 00 CMP [LOCAL.1],0 0044C75B |. 75 10 JNZ SHORT CrackMe_.0044C76D ; Salta si algo ha ido mal 0044C75D |. 8B86 14030000 MOV EAX,DWORD PTR DS:[ESI+314] 0044C763 |. BA CCC74400 MOV EDX,CrackMe_.0044C7CC ; "You have found the correct Serial :)"
En resumen
Para afrontar esta parte del reto vamos a usar una herramienta llamada Interactive Delphi Reconstructor o IDR. En su día la mejor herramienta era DEDE, pero IDR a mi parecer es algo más potente.
Básicamente IDR nos permite sin quebraderos de cabeza localizar el código del botón que comprueba la secuencia de checkboxes correcta. Cargamos el crackme en IDR y dentro de la pestaña «Units (F2)«, abajo del todo hacemos doble click sobre «F Crack» y vemos que nos muestra todos los controles del formulario. El botón que nos interesa se llama «SpeedButton3«.
Si hacemos doble click sobre el nos muestra el código que se muestra a continuación.
crack::TForm1.SpeedButton3Click 0044C7F4 push ebp 0044C7F5 mov ebp,esp 0044C7F7 push 0 0044C7F9 push ebx 0044C7FA mov ebx,eax 0044C7FC xor eax,eax 0044C7FE push ebp 0044C7FF push 44C920 0044C804 push dword ptr fs:[eax] 0044C807 mov dword ptr fs:[eax],esp 0044C80A mov eax,dword ptr [ebx+324]; TForm1.cb3:TCheckBox 0044C810 mov edx,dword ptr [eax] 0044C812 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C818 test al,al >0044C81A je 0044C8ED 0044C820 mov eax,dword ptr [ebx+328]; TForm1.cb5:TCheckBox 0044C826 mov edx,dword ptr [eax] 0044C828 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C82E test al,al >0044C830 je 0044C8ED 0044C836 mov eax,dword ptr [ebx+32C]; TForm1.cb6:TCheckBox 0044C83C mov edx,dword ptr [eax] 0044C83E call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C844 test al,al >0044C846 je 0044C8ED 0044C84C mov eax,dword ptr [ebx+358]; TForm1.cb12:TCheckBox 0044C852 mov edx,dword ptr [eax] 0044C854 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C85A test al,al >0044C85C je 0044C8ED 0044C862 mov eax,dword ptr [ebx+364]; TForm1.cb15:TCheckBox 0044C868 mov edx,dword ptr [eax] 0044C86A call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C870 test al,al >0044C872 je 0044C8ED 0044C874 mov eax,dword ptr [ebx+330]; TForm1.cb20:TCheckBox 0044C87A mov edx,dword ptr [eax] 0044C87C call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C882 test al,al >0044C884 je 0044C8ED 0044C886 mov eax,dword ptr [ebx+34C]; TForm1.cb9:TCheckBox 0044C88C mov edx,dword ptr [eax] 0044C88E call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C894 test al,al >0044C896 je 0044C8ED 0044C898 mov eax,dword ptr [ebx+354]; TForm1.cb11:TCheckBox 0044C89E mov edx,dword ptr [eax] 0044C8A0 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C8A6 test al,al >0044C8A8 je 0044C8ED 0044C8AA mov eax,dword ptr [ebx+35C]; TForm1.cb13:TCheckBox 0044C8B0 mov edx,dword ptr [eax] 0044C8B2 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C8B8 test al,al >0044C8BA je 0044C8ED 0044C8BC mov eax,dword ptr [ebx+33C]; TForm1.cb19:TCheckBox 0044C8C2 mov edx,dword ptr [eax] 0044C8C4 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C8CA test al,al >0044C8CC je 0044C8ED 0044C8CE lea eax,[ebp-4] 0044C8D1 mov edx,44C934; 'Ìõô¸ö÷ê¥ó¤ÉÚÀƲÄæââîà䶶' 0044C8D6 call @LStrLAsg 0044C8DB lea eax,[ebp-4] 0044C8DE call 0044BF00 0044C8E3 mov eax,dword ptr [ebp-4] 0044C8E6 call ShowMessage >0044C8EB jmp 0044C90A 0044C8ED lea eax,[ebp-4] 0044C8F0 mov edx,44C958; 'Åÿæò衦óàù¨ïêçð®øé¤íüàî诹' 0044C8F5 call @LStrLAsg 0044C8FA lea eax,[ebp-4] 0044C8FD call 0044BF00 0044C902 mov eax,dword ptr [ebp-4] 0044C905 call ShowMessage 0044C90A xor eax,eax 0044C90C pop edx 0044C90D pop ecx 0044C90E pop ecx 0044C90F mov dword ptr fs:[eax],edx 0044C912 push 44C927 0044C917 lea eax,[ebp-4] 0044C91A call @LStrClr 0044C91F ret <0044C920 jmp @HandleFinally <0044C925 jmp 0044C917 0044C927 pop ebx 0044C928 pop ecx 0044C929 pop ebp 0044C92A ret
Como podéis apreciar, las checkboxes involucradas son la 3, 5, 6, 9, 11, 12, 13, 15, 19 y 20. Solo nos falta saber cuales se corresponden con esa numeración y aquí ya depende de cada uno, yo en su día saqué los números a mano mediante el orden de tabulación, pero ya que tenemos IDR, el nos va a dar la solución de una forma sencilla y rápida.
Vamos a la pestaña «Forms (F5)«, seleccionamos la opción Form y hacemos doble click sobre el formulario.
Veréis que aparece el formulario con todos los recursos, incluso los puedes modificar. Localizar los checkboxes ahora es un juego de niños.
Os dejo un vídeo.
De nuevo, con la ayuda de IDR, localizamos la parte del código y analizamos su funcionamiento. Esta parte es la más divertida ya que requiere de un keygen pero en vez de coger el número de serie de una caja de texto lo obtiene de 5 trackbars como muestra la siguiente imagen.
El código de comprobación es el siguiente.
CPU Disasm Address Hex dump Command Comments 0044C1FF |. E8 ECF6FCFF CALL 0041B8F0 ; b^3 0044C204 |. D805 50C34400 FADD DWORD PTR DS:[44C350] ; b^3+5 0044C20A |. D9FA FSQRT ; sqrt(b^3+5) 0044C20C |. E8 F365FBFF CALL 00402804 ; Cos(sqrt(b^3+5)) = U 0044C211 |. DB7D B8 FSTP TBYTE PTR SS:[EBP-48] 0044C214 |. 9B WAIT 0044C215 |. D905 54C34400 FLD DWORD PTR DS:[44C354] ; Coje a 0044C21B |. DC45 E8 FADD QWORD PTR SS:[EBP-18] ; a+1 0044C21E |. D9FA FSQRT ; sqrt(a+1) 0044C220 |. D9E0 FCHS ; -sqrt(a+1) = V 0044C222 |. DB6D B8 FLD TBYTE PTR SS:[EBP-48] 0044C225 |. DEC1 FADDP ST(1),ST 0044C227 |. DB7D AC FSTP TBYTE PTR SS:[EBP-54] 0044C22A |. 9B WAIT 0044C22B |. D905 58C34400 FLD DWORD PTR DS:[44C358] ; coje c 0044C231 |. DC4D D8 FMUL QWORD PTR SS:[EBP-28] ; c*3 0044C234 |. D805 54C34400 FADD DWORD PTR DS:[44C354] ; c*3+1 0044C23A |. D9ED FLDLN2 ; Ln(c*3+1) = X 0044C23C |. D9C9 FXCH ST(1) 0044C23E |. D9F1 FYL2X 0044C240 |. DB6D AC FLD TBYTE PTR SS:[EBP-54] 0044C243 |. DEC1 FADDP ST(1),ST ; U+V+X 0044C245 |. DB7D A0 FSTP TBYTE PTR SS:[EBP-60] 0044C248 |. 9B WAIT 0044C249 |. D905 5CC34400 FLD DWORD PTR DS:[44C35C] ; coje d 0044C24F |. DC45 D0 FADD QWORD PTR SS:[EBP-30] ; d+2 0044C252 |. D9FA FSQRT ; sqrt(d+2) = Y 0044C254 |. DB6D A0 FLD TBYTE PTR SS:[EBP-60] 0044C257 |. DEE1 FSUBRP ST(1),ST ; U+V+X+(-Y) 0044C259 |. D905 58C34400 FLD DWORD PTR DS:[44C358] ; coje e 0044C25F |. DC4D C8 FMUL QWORD PTR SS:[EBP-38] ; e*3 0044C262 |. D835 5CC34400 FDIV DWORD PTR DS:[44C35C] ; (e*3)/2 = Z 0044C268 |. DEC1 FADDP ST(1),ST ; U+V+X+Y+Z 0044C26A |. DB2D 60C34400 FLD TBYTE PTR DS:[44C360] 0044C270 |. DEC1 FADDP ST(1),ST ; U+V+X+Y+Z+0.37 0044C272 |. D80D 6CC34400 FMUL DWORD PTR DS:[44C36C] ; (U+V+X+Y+Z+0.37)*1000 0044C278 |. DD5D F0 FSTP QWORD PTR SS:[EBP-10] 0044C27B |. 9B WAIT 0044C27C |. DD45 F0 FLD QWORD PTR SS:[EBP-10] 0044C27F |. E8 9065FBFF CALL 00402814 ; Redondea((U+V+X+Y+Z+0,37)*1000) 0044C284 |. 8945 98 MOV DWORD PTR SS:[EBP-68],EAX 0044C287 |. 8955 9C MOV DWORD PTR SS:[EBP-64],EDX 0044C28A |. DF6D 98 FILD QWORD PTR SS:[EBP-68] 0044C28D |. 83C4 F4 ADD ESP,-0C 0044C290 |. DB3C24 FSTP TBYTE PTR SS:[LOCAL.33] 0044C293 |. 9B WAIT 0044C294 |. 8D45 FC LEA EAX,[EBP-4] 0044C297 |. E8 68BFFBFF CALL 00408204 0044C29C |. 8D45 FC LEA EAX,[EBP-4] 0044C29F |. E8 5CFCFFFF CALL 0044BF00 ; Llamada de generación de hash ........ 0044BF04 |. 8BF0 MOV ESI,EAX 0044BF06 |. 8B06 MOV EAX,DWORD PTR DS:[ESI] ; EAX = 5415 0044BF08 |. E8 677BFBFF CALL 00403A74 0044BF0D |. 8B15 98EE4400 MOV EDX,DWORD PTR DS:[44EE98] 0044BF13 |. 8902 MOV DWORD PTR DS:[EDX],EAX 0044BF15 |. 8B06 MOV EAX,DWORD PTR DS:[ESI] 0044BF17 |. E8 587BFBFF CALL 00403A74 0044BF1C |. 84C0 TEST AL,AL 0044BF1E |. 76 38 JBE SHORT 0044BF58 0044BF20 |. 880424 MOV BYTE PTR SS:[LOCAL.3],AL 0044BF23 |. B3 01 MOV BL,1 0044BF25 |> B8 1C000000 /MOV EAX,1C 0044BF2A |. E8 516AFBFF |CALL 00402980 0044BF2F |. 0D 80000000 |OR EAX,00000080 0044BF34 |. 8BFB |MOV EDI,EBX 0044BF36 |. 81E7 FF000000 |AND EDI,000000FF 0044BF3C |. 8B16 |MOV EDX,DWORD PTR DS:[ESI] 0044BF3E |. 0FB6543A FF |MOVZX EDX,BYTE PTR DS:[EDI+EDX-1] ; Coje dig a dig el hash, en este caso 5415 0044BF43 |. 33C2 |XOR EAX,EDX ; 1 dig XOR 83; 2 dig XOR 89; 3 dig XOR 86; 4 dig XOR 8D 0044BF45 |. 50 |PUSH EAX 0044BF46 |. 8BC6 |MOV EAX,ESI 0044BF48 |. E8 F77CFBFF |CALL 00403C44 0044BF4D |. 5A |POP EDX 0044BF4E |. 885438 FF |MOV BYTE PTR DS:[EDI+EAX-1],DL 0044BF52 |. 43 |INC EBX 0044BF53 |. FE0C24 |DEC BYTE PTR SS:[LOCAL.3] 0044BF56 |.^ 75 CD \JNZ SHORT 0044BF25 ........ 0044C2AC |. E8 D378FBFF CALL 00403B84 ; Llamada a comparación ........ 00403BAD |> /8B0E /MOV ECX,DWORD PTR DS:[ESI] ; ECX = nuestro Serial XOReado 00403BAF |. |8B1F |MOV EBX,DWORD PTR DS:[EDI] ; EBX = Serial bueno 00403BB1 |. |39D9 |CMP ECX,EBX ; Compara 00403BB3 |. |75 58 |JNE SHORT 00403C0D ; Chico malo 00403BB5 |. |4A |DEC EDX 00403BB6 |. |74 15 |JZ SHORT 00403BCD 00403BB8 |. |8B4E 04 |MOV ECX,DWORD PTR DS:[ESI+4] 00403BBB |. |8B5F 04 |MOV EBX,DWORD PTR DS:[EDI+4] 00403BBE |. |39D9 |CMP ECX,EBX 00403BC0 |. |75 4B |JNE SHORT 00403C0D 00403BC2 |. |83C6 08 |ADD ESI,8 00403BC5 |. |83C7 08 |ADD EDI,8 00403BC8 |. |4A |DEC EDX 00403BC9 |.^\75 E2 \JNZ SHORT 00403BAD
En resumen
1) Siendo nuestro serial : 1 2 3 4 5
a b c d e
2) Realiza las operaciones matemáticas:
Round(((Cos(sqrt(b^3+5)) + (-sqrt(a+1)) + Ln(c*3+1) + (-sqrt(d+2)) + ((e*3)/2))+0.37)*1000))
3) Obtenemos un hash resultante de 5415
4) XORea los dígitos de la siguiente manera:
(5)35 xor 86 = B6
(4)34 xor 83 = BD
(1)31 xor 86 = B7
(5)35 xor 8D = B8
De modo que tenemos B6BDB7B8
5) Compara B6BDB7B8 con B5BAB2BA
6) Revertimos el XOR para obtener el hash bueno
B5 xor 86 = 36(6)
BA xor 83 = 33(3)
B2 xor 86 = 34(4)
BA xor 8D = 37(7)
Luego el hash bueno es 6347
7) Debemos hacer fuerza bruta buscando:
Round(((Cos(sqrt(b^3+5)) + (-sqrt(a+1)) + Ln(c*3+1) + (-sqrt(d+2)) + ((e*3)/2))+0.37)*1000)) = 6347
Para obtener los seriales válidos podemos hacer bucles recursivos hasta recorrer las 10^5 opciones posibles. Una forma de hacerlo en VBNet es la siguiente.
Dim tmp As Double
Dim an, bn, cn, dn, en As Integer
For an = 0 To 9
For bn = 0 To 9
For cn = 0 To 9
For dn = 0 To 9
For en = 0 To 9
tmp = Round(((Cos(Sqrt((Pow(bn, 3)) + 5)) + (-Sqrt(an + 1)) + Log(cn * 3 + 1) + (-Sqrt(dn + 2)) + ((en * 3) / 2) + 0.37) * 1000))
txtdebug.Text = "a-b-c-d-e = Hash || " & an & "-" & bn & "-" & cn & "-" & dn & "-" & en & " = " & tmp
If tmp = 6347 Then
ListBox1.Items.Add("Serial: " & an & bn & cn & dn & en)
End If
Application.DoEvents()
Next
Next
Next
Next
Next
Os dejo como siempre el crackme y el keygen en los enlaces.
Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos encontrado es esto en un foro: шжзклмнпфъ = 1234567890
Mensaje secreto: нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл
Parece que el mensaje secreto está encriptado utilizando un alfabeto cifrado que corresponde a números. Según la clave proporcionada (шжзклмнпфъ = 1234567890), cada letra del alfabeto cirílico se sustituye por un número.
Primero, descompondremos la clave dada:
ш = 1
ж = 2
з = 3
к = 4
л = 5
м = 6
н = 7
п = 8
ф = 9
ъ = 0
Ahora, aplicamos esta clave al mensaje secreto:
нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл
Sustituyendo cada letra según la clave:
нж = 72
фн = 97
фф = 99
шън = 107
нф = 79
шшъ = 110
шжз = 123
мф = 69
шъп = 108
фл = 95
пк = 84
шъш = 101
шшм = 116
шшк = 114
шъл = 105
шшл = 115
фл = 95
шъш = 101
шшл = 115
фл = 95
шшн = 117
шшъ = 110
фл = 95
шъм = 106
шшн = 117
шъш = 101
шъз = 130
шшш = 111
фл = 95
пж = 82
шшн = 117
шшл = 115
шшш = 111
шжл = 125
El mensaje traducido a números es:
72, 97, 99, 107, 79, 110, 123, 69, 108, 95, 84, 101, 116, 114, 105, 115, 95, 101, 115, 95, 117, 110, 95, 106, 117, 101, 130, 111, 95, 82, 117, 115, 111, 125
Este parece ser un mensaje cifrado en números. La secuencia de números se puede interpretar de varias maneras (como ASCII, coordenadas, etc.). Si asumimos que es un texto codificado en ASCII:
Convertimos cada número a su correspondiente carácter ASCII:
72 = H
97 = a
99 = c
107 = k
79 = O
110 = n
123 = {
69 = E
108 = l
95 = _
84 = T
101 = e
116 = t
114 = r
105 = i
115 = s
95 = _
101 = e
115 = s
95 = _
117 = u
110 = n
95 = _
106 = j
117 = u
101 = e
130 = ?
111 = o
95 = _
82 = R
117 = u
115 = s
111 = o
125 = }
Juntando todo:
HackOn{El_Tetris_e_s_u_n_j_u_e?o_Ruso}
La parte «{El_Tetris_e_s_u_n_j_u_e?o_Ruso}» parece un mensaje en español. Probablemente deba ser leído como: HackOn{El_Tetris_es_un_juego_Ruso}
Así, el mensaje secreto es: HackOn{El_Tetris_es_un_juego_Ruso}.
La imagen de portada de la entrada ha sido generada con ChatGPT.
Esta vez vamos a analizar los CrackMes de un antiguo colaborador de Karpoff Spanish Tutor, CrkViZ. En estas cinco soluciones vamos a pelearnos con Visual Basic 5/6 nativo y Pcode, con el registro de Windows y tendremos que parchear algúna rutina antidebug. Los CrackMes son del año 2000 y aunque algunos estaban ya solucionados, los analizaremos igualmente para ver la diferencia que existe con los análisis realizados en aquellos años, sí, estamos hablando del Softice.
Cuando hablamos de Visual Basic 5/6, podemos destacar 3 herramientas que nos facilitan mucho la vida, VB Decompiler, VB Reformer y ExDec. Las dos primeras se defienden bien tanto con código nativo como pcode y ExDec solamente nos sirve para pcode. Aún así, si todo lo demás falla, Ollydbg nos sacará de apuros.
Este primer crackme está compilado en Pcode y hoy día, con las herramientas de que disponemos no supone ninguna dificultad. Tan solo debemos abrirlo con VB Decompiler y ya nos encontramos con el serial válido.
Los opcodes obtenidos con ExDec se ven de la siguiente manera.
...... 402F14: 04 FLdRfVar local_008C 402F17: 21 FLdPrThis 402F18: 0f VCallAd 7b3fc340 402F1B: 19 FStAdFunc local_0088 402F1E: 08 FLdPr local_0088 402F21: 0d VCallHresult 7b3fbe88 402F26: 6c ILdRf local_008C 402F29: 1b LitStr: 57230198 <-------------- 402F2C: Lead0/30 EqStr 402F2E: 2f FFree1Str local_008C 402F31: 1a FFree1Ad local_0088 402F34: 1c BranchF: 403012 402F37: 21 FLdPrThis 402F38: 0d VCallHresult 7b3fc2b0 402F3D: 3a LitVarStr: ( local_00AC ) Gracias por Registrar!! 402F42: Lead2/00 FStVarCopy 402F46: 27 LitVar_Missing 402F49: 27 LitVar_Missing 402F4C: 3a LitVarStr: ( local_00AC ) CrkViz 402F51: 4e FStVarCopyObj local_00BC 402F54: 04 FLdRfVar local_00BC 402F57: f5 LitI4: 0x40 64 (...@) 402F5C: 04 FLdRfVar local_009C 402F5F: 0a ImpAdCallFPR4: _rtcMsgBox 402F64: 36 FFreeVar 402F6D: 27 LitVar_Missing 402F70: 25 PopAdLdVar 402F71: 27 LitVar_Missing ......
Este segundo crackme también está compilado en pcode. La rutina del serial es muy sencilla pero al introducir un número aleatorio nos obliga a parchear. Cargamos el crackme en VB Decompiler y nos muestra esto:
Básicamente vemos que genera un número aleatorio entre 1 y 999999999 y luego le suma 1. La forma de afrontar esto es parcheando. Nos fijamos en el offset aproximado (4037F2) y abrimos el crackme en un editor hexadecimal. La forma de convertir el offset que nos muestra VB Decompiler a lo que nos muestra un editor hexadecimal es la siguiente.
VBdec_offset - Image Base - VirtualOffset + RawOffset = Offset_Editor.H 4037F2 - 400000 - 1000 + 400 = 2BF2
Una vez localizados los bytes, los cambiamos por ceros y guardamos.
Una vez parcheado, el serial correcto es 1.
En esta tercera entrega, CrkViz aumentó la dificultad. El crackme está compilado en código nativo y nos enfrentamos a un serial asociado a un nombre y a una rutina antidebug que en realidad es una Nag, ya que se muestra siempre.
Afrontar la nag es muy sencillo, basta con localizarla y parchear la llamada.
CPU Disasm Address Hex dump Command Comments 004058E2 8D4D DC LEA ECX,[EBP-24] 004058E5 C785 BCFDFFFF B MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.004033B8 ; UNICODE " Debugger detectado!!! " 004058EF C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8 004058F9 FFD7 CALL EDI 004058FB B9 04000280 MOV ECX,80020004 00405900 B8 0A000000 MOV EAX,0A 00405905 898D FCFDFFFF MOV DWORD PTR SS:[EBP-204],ECX 0040590B 898D 0CFEFFFF MOV DWORD PTR SS:[EBP-1F4],ECX 00405911 8D95 B4FDFFFF LEA EDX,[EBP-24C] 00405917 8D8D 14FEFFFF LEA ECX,[EBP-1EC] 0040591D 8985 F4FDFFFF MOV DWORD PTR SS:[EBP-20C],EAX 00405923 8985 04FEFFFF MOV DWORD PTR SS:[EBP-1FC],EAX 00405929 C785 BCFDFFFF 8 MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.00403188 ; UNICODE "Error" 00405933 C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8 0040593D FF15 C8914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDup>] 00405943 8D85 F4FDFFFF LEA EAX,[EBP-20C] 00405949 8D8D 04FEFFFF LEA ECX,[EBP-1FC] 0040594F 50 PUSH EAX 00405950 8D95 14FEFFFF LEA EDX,[EBP-1EC] 00405956 51 PUSH ECX 00405957 52 PUSH EDX 00405958 8D45 DC LEA EAX,[EBP-24] 0040595B 6A 10 PUSH 10 0040595D 50 PUSH EAX 0040595E FF15 50914000 CALL DWORD PTR DS:[<&MSVBVM50.#595>] ; rtcMsgBox - NOPear para evitar la NAG 00405964 8D8D F4FDFFFF LEA ECX,[EBP-20C]
Antes de llegar al keygen vemos que realiza unas llamadas al registro de Windows, ponemos un breakpoint «bp RegOpenKeyW» y ejecutamos.
CPU Disasm Address Hex dump Command Comments 00405677 |. 8B8D B8FDFFFF MOV ECX,DWORD PTR SS:[EBP-248] 0040567D |. B8 54334000 MOV EAX,CrkMeViz-3.00403354 ; UNICODE "<Unregister>" 00405682 |. 68 B4304000 PUSH CrkMeViz-3.004030B4 ; UNICODE "Serial number" 00405687 |. 894A 04 MOV DWORD PTR DS:[EDX+4],ECX 0040568A |. 8985 BCFDFFFF MOV DWORD PTR SS:[EBP-244],EAX 00405690 |. 68 84304000 PUSH CrkMeViz-3.00403084 ; UNICODE "Register" 00405695 |. 68 58304000 PUSH CrkMeViz-3.00403058 ; UNICODE "CrkMeViz3" 0040569A |. 8942 08 MOV DWORD PTR DS:[EDX+8],EAX 0040569D |. 8B85 C0FDFFFF MOV EAX,DWORD PTR SS:[EBP-240] 004056A3 |. 8942 0C MOV DWORD PTR DS:[EDX+0C],EAX 004056A6 |. FF15 C0914000 CALL DWORD PTR DS:[<&MSVBVM50.#689>] ; rtcGetSetting - Lee el numero de serie del registro ........ 0040574F |. 68 9C304000 PUSH CrkMeViz-3.0040309C ; UNICODE "User Name" 00405754 |. 68 84304000 PUSH CrkMeViz-3.00403084 ; UNICODE "Register" 00405759 |. 68 58304000 PUSH CrkMeViz-3.00403058 ; UNICODE "CrkMeViz3" 0040575E |. 8948 08 MOV DWORD PTR DS:[EAX+8],ECX 00405761 |. 8B8D C0FDFFFF MOV ECX,DWORD PTR SS:[EBP-240] 00405767 |. 8948 0C MOV DWORD PTR DS:[EAX+0C],ECX 0040576A |. FF15 C0914000 CALL DWORD PTR DS:[<&MSVBVM50.#689>] ; rtcGetSetting - Lee el Usuario del registro
Reconstruyendo la llamada al registro vemos que lee de esta ruta: HKEY_CURRENT_USER\Software\VB and VBA Program Settings\CrkMeViz3\Register el contenido de User Name y del Serial number.
Quizá uno de los fallos de éste crackme, es que no comprueba la autenticidad de estos parámetros y si los modificas parece que estás registrado. Un ejemplo:
La rutina de comprobación del serial no es para nada complicada pero recordemos que estamos tratando con VB y éste delega el trabajo duro en otras librerias de modo que tenemos que «meternos» a tracear las llamadas para ver los valores que multiplica y divide.
CPU Disasm Address Hex dump Command Comments 00405A86 FF15 3C914000 CALL DWORD PTR DS:[<&MSVBVM50.#518>] ;MSVBVM50.rtcLowerCaseVar 00405A8C 8D95 14FEFFFF LEA EDX,[EBP-1EC] 00405A92 8D8D ACFEFFFF LEA ECX,[EBP-154] 00405A98 FFD6 CALL ESI 00405A9A 8D95 ACFEFFFF LEA EDX,[EBP-154] 00405AA0 8D8D 4CFEFFFF LEA ECX,[EBP-1B4] 00405AA6 FFD7 CALL EDI 00405AA8 8D95 4CFEFFFF LEA EDX,[EBP-1B4] 00405AAE 8D8D 7CFFFFFF LEA ECX,[EBP-84] 00405AB4 FFD7 CALL EDI 00405AB6 8D85 14FEFFFF LEA EAX,[EBP-1EC] 00405ABC 8D8D 7CFFFFFF LEA ECX,[EBP-84] 00405AC2 50 PUSH EAX 00405AC3 6A 01 PUSH 1 00405AC5 8D95 04FEFFFF LEA EDX,[EBP-1FC] 00405ACB 51 PUSH ECX 00405ACC 52 PUSH EDX 00405ACD C785 1CFEFFFF 0 MOV DWORD PTR SS:[EBP-1E4],1 00405AD7 C785 14FEFFFF 0 MOV DWORD PTR SS:[EBP-1EC],2 00405AE1 FF15 68914000 CALL DWORD PTR DS:[<&MSVBVM50.#632>] ;MSVBVM50.rtcMidCharVar (Esto lo hace 6 veces, lo omito para abreviar.) ........ 00405CE1 FF15 34914000 CALL DWORD PTR DS:[<&MSVBVM50.#516>] ;MSVBVM50.rtcAnsiValueBstr (Lo mismo, otras 6) ........ 00405E7C C785 BCFDFFFF 2 MOV DWORD PTR SS:[EBP-244],52E 00405E86 C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2 00405E90 50 PUSH EAX 00405E91 FF15 84914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>] | ->MSVBVM50.__vbaVarMul ........ 741C19D3 0FB745 FE MOVZX EAX,WORD PTR SS:[EBP-2] ;Valor1 741C19D7 0FB74D F2 MOVZX ECX,WORD PTR SS:[EBP-0E] ;Valor2 741C19DB 6BC0 12 IMUL EAX,EAX,12 ;Valor1*Valor2 ........ 00405E97 8D8D 04FEFFFF LEA ECX,[EBP-1FC] 00405E9D 50 PUSH EAX 00405E9E 51 PUSH ECX 00405E9F FF15 84914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>] 00405EA5 8D95 F4FDFFFF LEA EDX,[EBP-20C] 00405EAB 50 PUSH EAX 00405EAC 52 PUSH EDX 00405EAD FF15 84914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>] 00405EB3 50 PUSH EAX 00405EB4 8D85 E4FDFFFF LEA EAX,[EBP-21C] 00405EBA 50 PUSH EAX 00405EBB FF15 84914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>] 00405EC1 8D8D D4FDFFFF LEA ECX,[EBP-22C] 00405EC7 50 PUSH EAX 00405EC8 51 PUSH ECX 00405EC9 FF15 84914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>] 00405ECF 50 PUSH EAX 00405ED0 8D95 B4FDFFFF LEA EDX,[EBP-24C] 00405ED6 8D85 C4FDFFFF LEA EAX,[EBP-23C] 00405EDC 52 PUSH EDX 00405EDD 50 PUSH EAX 00405EDE FF15 94914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>] | ->MSVBVM50.__vbaVarDiv ........ 741C8094 DD43 08 FLD QWORD PTR DS:[EBX+8] ;Recupera el resultado de las multiplicaciones anteriores 741C8097 0FBF47 08 MOVSX EAX,WORD PTR DS:[EDI+8] ;EAX = 1326 (52E) 741C809B 8945 F8 MOV DWORD PTR SS:[EBP-8],EAX 741C809E DA75 F8 FIDIV DWORD PTR SS:[EBP-8] ;Divide los dos resultados 741C80A1 DD5E 08 FSTP QWORD PTR DS:[ESI+8] ........ 00405F44 FF15 24914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>] ;Len(nombre) ........ 00405F85 FF15 94914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>] ;Resultado anterior / Len(nombre) ........
En resumen:
Ejemplo para deurus
64*65*75*72*75*73 = 1A605D70EB8 1A605D70EB8 / 52E = 5179FBF4 5179FBF4 / 6 = D9454A9
Al estar correctamente registrados desaparece el botón de registrar.
El cuarto crackme es prácticamente igual que el tercero salvo que en vez de nag ahora contamos con limitación de ejecuciones. Del mismo modo utiliza el registro de Windows para guardar los datos de registro y las ejecuciones que llevamos.
Ponemos un breakpoint «bp RegOpenKeyW» y llegamos a la conclusión de que la ruta es HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register y los valores se guardan en Counter, User Name y Serial number respectivamente. Este crackme hereda el fallo del anterior y si alteramos los valores el crackme nos muestra como usuarios autorizados, aunque sabemos que no estamos registrados ya que seguimos limitados por ejecuciones. Ni que decir tiene que lo mismo que modificamos el nombre y número de serie, podemos modificar el contador a nuestro favor. Crear un archivo «Reiniciar_contador.reg» con el siguiente contenido sería suficiente.
Windows Registry Editor Version 5.00 [HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC] [HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register] "Counter"="0" "User Name"="deurus" "Serial number"="12345"
El keygen es prácticamente igual que en el crackme anterior, solo cambia el divisor.
CPU Disasm
Address Hex dump Command Comments
........
00404BD2 C785 BCFDFFFF C MOV DWORD PTR SS:[EBP-244],6C1
00404BDC C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00404BE6 FF15 A0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
|
->MSVBVM50.__vbaVarMul
741C19F9 0FBF4F 08 MOVSX ECX,WORD PTR DS:[EDI+8] ;Valor1
741C19FD 0FBF43 08 MOVSX EAX,WORD PTR DS:[EBX+8] ;Valor2
741C1A01 0FAFC8 IMUL ECX,EAX ;Valor1*Valor2
........
00404BEC 8D8D 04FEFFFF LEA ECX,[EBP-1FC]
00404BF2 50 PUSH EAX
00404BF3 51 PUSH ECX
00404BF4 FF15 A0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404BFA 8D95 F4FDFFFF LEA EDX,[EBP-20C]
00404C00 50 PUSH EAX
00404C01 52 PUSH EDX
00404C02 FF15 A0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C08 50 PUSH EAX
00404C09 8D85 E4FDFFFF LEA EAX,[EBP-21C]
00404C0F 50 PUSH EAX
00404C10 FF15 A0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C16 8D8D D4FDFFFF LEA ECX,[EBP-22C]
00404C1C 50 PUSH EAX
00404C1D 51 PUSH ECX
00404C1E FF15 A0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C24 50 PUSH EAX
00404C25 8D95 B4FDFFFF LEA EDX,[EBP-24C]
00404C2B 8D85 C4FDFFFF LEA EAX,[EBP-23C]
00404C31 52 PUSH EDX
00404C32 50 PUSH EAX
00404C33 FF15 B0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
|
->MSVBVM50.__vbaVarDiv
741C8094 DD43 08 FLD QWORD PTR DS:[EBX+8] ; Recupera el resultado de las multiplicaciones anteriores
741C8097 0FBF47 08 MOVSX EAX,WORD PTR DS:[EDI+8] ; EAX = 1729 (6C1)
741C809B 8945 F8 MOV DWORD PTR SS:[EBP-8],EAX
741C809E DA75 F8 FIDIV DWORD PTR SS:[EBP-8]
00404C39 8BD0 MOV EDX,EAX
........
00404CA0 FF15 3C914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>] ;Len(nombre)
........
00404CF1 FF15 B0914000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>] ;Resultado anterior / Len(nombre)
En resumen:
Ejemplo para deurus
64*65*75*72*75*73 = 1A605D70EB8 1A605D70EB8 / 6C1 = 3E7C594A 3E7C594A / 6 = A6A0EE2
Este último crackme está compilado en código nativo y simplemente se trata de una comparación lineal. La única diferencia reside en que no hay botón de registro, la comprobación la gestiona un evento «On Change«, de modo que está comprobando el tamaño del serial que introducimos y cuando éste tiene 8 dígitos llegamos aquí.
........ 0040A64F . C745 9C CDD4DD02 MOV DWORD PTR SS:[EBP-64],2DDD4CD ;2DDD4CD = 48092365 0040A656 . C745 94 03800000 MOV DWORD PTR SS:[EBP-6C],8003 0040A65D . FF15 08C14000 CALL DWORD PTR DS:[<&MSVBVM50.__vbaVa> ;MSVBVM50.__vbaVarTstEq 0040A663 . 66:85C0 TEST AX,AX 0040A666 . 0F84 BA000000 JE CrkMeViZ.0040A726 ;Si salta BAD BOY ........
Luego el serial correcto es 48092365.
¿Ha sido indoloro no?, claro que sí, Visual Basic es un coñazo de tracear pero hay que reconocer que con el tiempo las herramientas han mejorado mucho y nuestra vida es mucho más sencilla. Bueno, pués esto ha sido todo, como siempre os dejo todo el material utilizado y un Keygen.
Hoy tenemos aquí un crackme del 2009 originario de crackmes.de. El Crackme está hecho en VB6, sin empacar y consta de 4 tareas a superar. Un anti-debugger, un parcheo, una sorpresa y finalmente un algoritmo sencillo.
Nuestro primer incordio es el anti-debbuger. Este lo podemos afrontar de diferentes maneras, con un plugin desde Olly o de forma permanente parcheando. Si elegimos parchear debemos hacerlo en el offset 408328, cambiando el salto je por jmp.
00408328 /0F84 69030000 je T0RNAD0'.00408697
Si iniciamos el crackme nos encontramos con la siguiente nag que nos impide el arranque.
Las referencias de texto parecen encriptadas así que, ponemos un breakpoint a MSVBVM60.rtcMsgBox y vemos que la llamada se hace desde el offset 406897. Un poco más arriba encontramos un salto condicional muy interesante, concretamente en el offset 40677B. Lo cambiamos por un jmp y arrancamos el programa.
A continuación arranca el crackme y vemos lo siguiente.
La sorpresa es que el formulario no se mueve y no hay rastro de las cajas de texto del keygenme. Por suerte para nosotros este crackme está hecho en vb6 y como tal podemos abrirlo con VB Reformer para ver que se nos ofrece.
Abrimos VB Reformer y cambiamos la propiedad «Moveable» del formulario a true.
Ahora ya podemos mover el formulario y por suerte para nosotros, si lo movemos hacia la esquina superior izquierda aparecen las cajas de texto por arte de magia.
Como hemos dicho antes, las referencias de texto son inútiles, de modo que ponemos un breakpoint a MSVBVM60.__vbaStrCmp y enseguida obtenemos nuestro primer serial válido. También nos percatamos de que hasta que no metemos en el nombre 8 dígitos, no nos muestra un mensaje de error. De este mismo modo obtenemos que el nombre más grande puede tener 30 dígitos.
Username: deurusab (lenght 8)
0012F3F0 0040533A RETURN to T0RNAD0'.0040533A from MSVBVM60.__vbaStrCmp
0012F3F4 0015C954 UNICODE "L-8-deurus-0199F9CA"
Username: abcdefghijklmnopqrstuvwxyz1234 (lenght 30)
0012F3F0 0040533A RETURN to T0RNAD0'.0040533A from MSVBVM60.__vbaStrCmp
0012F3F4 0015F40C UNICODE "L-30-lmnopq-DD19F9CA"
Finalmente llegamos a la rutina de comprobación del serial. Usaremos como nombre: abcdefghijklmnopqrstuvwxyz1234.
00404E82 . 52 push edx 00404E83 . 56 push esi 00404E84 . C746 34 0DF0D1BA mov dword ptr ds:[esi+34],BAD1F00D |Variables cachondas 00404E8B . C746 38 01ADDE10 mov dword ptr ds:[esi+38],10DEAD01 |Variables cachondas 00404E92 . C746 3C EFBE1010 mov dword ptr ds:[esi+3C],1010BEEF |Variables cachondas 00404E99 . C746 40 D0BA0110 mov dword ptr ds:[esi+40],1001BAD0 |Variables cachondas 00404EA0 . FF91 2C070000 call ds:[ecx+72C] 00404EA6 . 3BC7 cmp eax,edi 00404EA8 . DBE2 fclex 00404EAA . 7D 12 jge short T0RNAD0'.00404EBE 00404EAC . 68 2C070000 push 72C 00404EB1 . 68 14404000 push T0RNAD0'.00404014 00404EB6 . 56 push esi 00404EB7 . 50 push eax 00404EB8 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 00404EBE > 8B45 B4 mov eax,ss:[ebp-4C] 00404EC1 . 8D55 E0 lea edx,ss:[ebp-20] 00404EC4 . 52 push edx 00404EC5 . 50 push eax 00404EC6 . 8B08 mov ecx,ds:[eax] 00404EC8 . 8985 48FFFFFF mov ss:[ebp-B8],eax 00404ECE . FF91 A0000000 call ds:[ecx+A0] 00404ED4 . 3BC7 cmp eax,edi 00404ED6 . DBE2 fclex 00404ED8 . 7D 18 jge short T0RNAD0'.00404EF2 00404EDA . 8B8D 48FFFFFF mov ecx,ss:[ebp-B8] 00404EE0 . 68 A0000000 push 0A0 00404EE5 . 68 7C414000 push T0RNAD0'.0040417C 00404EEA . 51 push ecx 00404EEB . 50 push eax 00404EEC . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 00404EF2 > 8B45 E0 mov eax,ss:[ebp-20] |Mueve el nombre a eax 00404EF5 . 8D55 A0 lea edx,ss:[ebp-60] 00404EF8 . 8945 A8 mov ss:[ebp-58],eax 00404EFB . 6A 01 push 1 00404EFD . 8D45 90 lea eax,ss:[ebp-70] 00404F00 . 52 push edx 00404F01 . 50 push eax 00404F02 . 897D E0 mov ss:[ebp-20],edi 00404F05 . C745 A0 08000000 mov dword ptr ss:[ebp-60],8 00404F0C . FF15 40114000 call ds:[<&MSVBVM60.#619>] ; MSVBVM60.rtcRightCharVar 00404F12 . 8B3D D0104000 mov edi,ds:[<&MSVBVM60.__vbaStrVarVal>] ; MSVBVM60.__vbaStrVarVal 00404F18 . 8D4D 90 lea ecx,ss:[ebp-70] 00404F1B . 8D55 DC lea edx,ss:[ebp-24] 00404F1E . 51 push ecx 00404F1F . 52 push edx 00404F20 . FFD7 call edi ; <&MSVBVM60.__vbaStrVarVal> 00404F22 . 50 push eax 00404F23 . FF15 30104000 call ds:[<&MSVBVM60.#516>] ; MSVBVM60.rtcAnsiValueBstr |Toma el último dígito en ascii (4 asc = 34) 00404F29 . 66:6BC0 7B imul ax,ax,7B |34 * 7B = 18FC 00404F2D . 8B4E 34 mov ecx,ds:[esi+34] |Mueve BAD1F00D a ecx 00404F30 . 0F80 05070000 jo T0RNAD0'.0040563B 00404F36 . 0FBFC0 movsx eax,ax 00404F39 . 33C8 xor ecx,eax |18FC xor BAD1F00D = BAD1E8F1 00404F3B . 894E 34 mov ds:[esi+34],ecx 00404F3E . 8D4D DC lea ecx,ss:[ebp-24] 00404F41 . FF15 5C114000 call ds:[<&MSVBVM60.__vbaFreeStr>] ; MSVBVM60.__vbaFreeStr 00404F47 . 8D4D B4 lea ecx,ss:[ebp-4C] 00404F4A . FF15 60114000 call ds:[<&MSVBVM60.__vbaFreeObj>] ; MSVBVM60.__vbaFreeObj 00404F50 . 8D4D 90 lea ecx,ss:[ebp-70] 00404F53 . 8D55 A0 lea edx,ss:[ebp-60] 00404F56 . 51 push ecx 00404F57 . 52 push edx 00404F58 . 6A 02 push 2 00404F5A . FF15 20104000 call ds:[<&MSVBVM60.__vbaFreeVarList>] ; MSVBVM60.__vbaFreeVarList 00404F60 . 8B06 mov eax,ds:[esi] 00404F62 . 83C4 0C add esp,0C 00404F65 . 8D4D B4 lea ecx,ss:[ebp-4C] 00404F68 . 51 push ecx 00404F69 . 56 push esi 00404F6A . FF90 2C070000 call ds:[eax+72C] 00404F70 . 85C0 test eax,eax 00404F72 . DBE2 fclex 00404F74 . 7D 12 jge short T0RNAD0'.00404F88 00404F76 . 68 2C070000 push 72C 00404F7B . 68 14404000 push T0RNAD0'.00404014 00404F80 . 56 push esi 00404F81 . 50 push eax 00404F82 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 00404F88 > 8B45 B4 mov eax,ss:[ebp-4C] 00404F8B . 8D4D E0 lea ecx,ss:[ebp-20] 00404F8E . 51 push ecx 00404F8F . 50 push eax 00404F90 . 8B10 mov edx,ds:[eax] 00404F92 . 8985 48FFFFFF mov ss:[ebp-B8],eax 00404F98 . FF92 A0000000 call ds:[edx+A0] 00404F9E . 85C0 test eax,eax 00404FA0 . DBE2 fclex 00404FA2 . 7D 18 jge short T0RNAD0'.00404FBC 00404FA4 . 8B95 48FFFFFF mov edx,ss:[ebp-B8] 00404FAA . 68 A0000000 push 0A0 00404FAF . 68 7C414000 push T0RNAD0'.0040417C 00404FB4 . 52 push edx 00404FB5 . 50 push eax 00404FB6 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 00404FBC > 8B45 E0 mov eax,ss:[ebp-20] 00404FBF . 6A 01 push 1 00404FC1 . 8945 A8 mov ss:[ebp-58],eax 00404FC4 . 8D45 A0 lea eax,ss:[ebp-60] 00404FC7 . 8D4D 90 lea ecx,ss:[ebp-70] 00404FCA . 50 push eax 00404FCB . 51 push ecx 00404FCC . C745 E0 00000000 mov dword ptr ss:[ebp-20],0 00404FD3 . C745 A0 08000000 mov dword ptr ss:[ebp-60],8 00404FDA . FF15 2C114000 call ds:[<&MSVBVM60.#617>] ; MSVBVM60.rtcLeftCharVar 00404FE0 . 8D55 90 lea edx,ss:[ebp-70] 00404FE3 . 8D45 DC lea eax,ss:[ebp-24] 00404FE6 . 52 push edx 00404FE7 . 50 push eax 00404FE8 . FFD7 call edi 00404FEA . 50 push eax 00404FEB . FF15 30104000 call ds:[<&MSVBVM60.#516>] ; MSVBVM60.rtcAnsiValueBstr |Toma el primer dígito en ascii (a asc = 61) 00404FF1 . 66:6BC0 7B imul ax,ax,7B |61 * 7B = 2E9B 00404FF5 . 8B56 3C mov edx,ds:[esi+3C] |Mueve 1010BEEF a edx 00404FF8 . 0F80 3D060000 jo T0RNAD0'.0040563B 00404FFE . 0FBFC8 movsx ecx,ax 00405001 . 33D1 xor edx,ecx | 2E9B xor 1010BEEF = 10109074 00405003 . 8D4D DC lea ecx,ss:[ebp-24] 00405006 . 8956 3C mov ds:[esi+3C],edx 00405009 . FF15 5C114000 call ds:[<&MSVBVM60.__vbaFreeStr>] ; MSVBVM60.__vbaFreeStr 0040500F . 8D4D B4 lea ecx,ss:[ebp-4C] 00405012 . FF15 60114000 call ds:[<&MSVBVM60.__vbaFreeObj>] ; MSVBVM60.__vbaFreeObj 00405018 . 8D55 90 lea edx,ss:[ebp-70] 0040501B . 8D45 A0 lea eax,ss:[ebp-60] 0040501E . 52 push edx 0040501F . 50 push eax 00405020 . 6A 02 push 2 00405022 . FF15 20104000 call ds:[<&MSVBVM60.__vbaFreeVarList>] ; MSVBVM60.__vbaFreeVarList 00405028 . 66:8BCB mov cx,bx |Mueve a CX el tamaño del nombre 0040502B . 83C4 0C add esp,0C 0040502E . 66:69C9 4101 imul cx,cx,141 |Tamaño nombre(1E) * 141 = 259E 00405033 . 8B46 3C mov eax,ds:[esi+3C] 00405036 . 0F80 FF050000 jo T0RNAD0'.0040563B 0040503C . 0FBFD1 movsx edx,cx 0040503F . 8B4E 38 mov ecx,ds:[esi+38] |Mueve a ECX 10DEAD01 00405042 . 33D0 xor edx,eax |10109074 xor 259E = 1010B5BA 00405044 . 33CA xor ecx,edx |1010B5BA xor 10DEAD01 = 00CE18EB 00405046 . 66:8BD3 mov dx,bx 00405049 . 66:69D2 4101 imul dx,dx,141 |Tamaño nombre(1E) * 141 = 259E 0040504E . 0F80 E7050000 jo T0RNAD0'.0040563B 00405054 . 894E 38 mov ds:[esi+38],ecx 00405057 . 81F1 01010101 xor ecx,1010101 |00CE18EB xor 1010101 = 01CF19EA (Temp1) 0040505D . 0FBFD2 movsx edx,dx 00405060 . 3356 34 xor edx,ds:[esi+34] |BAD1E8F1 xor 259E = BAD1CD6F 00405063 . 894E 38 mov ds:[esi+38],ecx 00405066 . 35 10101010 xor eax,10101010 |10109074 xor 10101010 = 8064 0040506B . 8D4D B4 lea ecx,ss:[ebp-4C] 0040506E . 3156 40 xor ds:[esi+40],edx |BAD1CD6F xor 1001BAD0 = AAD077BF (Temp2) 00405071 . 8946 3C mov ds:[esi+3C],eax 00405074 . 8B06 mov eax,ds:[esi] 00405076 . 51 push ecx 00405077 . 56 push esi 00405078 . FF90 2C070000 call ds:[eax+72C] 0040507E . 85C0 test eax,eax 00405080 . DBE2 fclex 00405082 . 7D 12 jge short T0RNAD0'.00405096 00405084 . 68 2C070000 push 72C 00405089 . 68 14404000 push T0RNAD0'.00404014 0040508E . 56 push esi 0040508F . 50 push eax 00405090 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 00405096 > 8B45 B4 mov eax,ss:[ebp-4C] 00405099 . 8D4D DC lea ecx,ss:[ebp-24] 0040509C . 51 push ecx 0040509D . 50 push eax 0040509E . 8B10 mov edx,ds:[eax] 004050A0 . 8985 48FFFFFF mov ss:[ebp-B8],eax 004050A6 . FF92 A0000000 call ds:[edx+A0] 004050AC . 85C0 test eax,eax 004050AE . DBE2 fclex 004050B0 . 7D 18 jge short T0RNAD0'.004050CA 004050B2 . 8B95 48FFFFFF mov edx,ss:[ebp-B8] 004050B8 . 68 A0000000 push 0A0 004050BD . 68 7C414000 push T0RNAD0'.0040417C 004050C2 . 52 push edx 004050C3 . 50 push eax 004050C4 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 004050CA > 8B06 mov eax,ds:[esi] 004050CC . 8D4D B0 lea ecx,ss:[ebp-50] 004050CF . 51 push ecx 004050D0 . 56 push esi 004050D1 . FF90 2C070000 call ds:[eax+72C] 004050D7 . 85C0 test eax,eax 004050D9 . DBE2 fclex 004050DB . 7D 12 jge short T0RNAD0'.004050EF 004050DD . 68 2C070000 push 72C 004050E2 . 68 14404000 push T0RNAD0'.00404014 004050E7 . 56 push esi 004050E8 . 50 push eax 004050E9 . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 004050EF > 8B45 B0 mov eax,ss:[ebp-50] 004050F2 . 8D4D D0 lea ecx,ss:[ebp-30] 004050F5 . 51 push ecx 004050F6 . 50 push eax 004050F7 . 8B10 mov edx,ds:[eax] 004050F9 . 8985 3CFFFFFF mov ss:[ebp-C4],eax 004050FF . FF92 A0000000 call ds:[edx+A0] 00405105 . 85C0 test eax,eax 00405107 . DBE2 fclex 00405109 . 7D 18 jge short T0RNAD0'.00405123 0040510B . 8B95 3CFFFFFF mov edx,ss:[ebp-C4] 00405111 . 68 A0000000 push 0A0 00405116 . 68 7C414000 push T0RNAD0'.0040417C 0040511B . 52 push edx 0040511C . 50 push eax 0040511D . FF15 40104000 call ds:[<&MSVBVM60.__vbaHresultCheckObj>] ; MSVBVM60.__vbaHresultCheckObj 00405123 > 8B45 D0 mov eax,ss:[ebp-30] 00405126 . 6A 01 push 1 00405128 . 8945 98 mov ss:[ebp-68],eax 0040512B . 8D45 90 lea eax,ss:[ebp-70] 0040512E . 8D4D 80 lea ecx,ss:[ebp-80] 00405131 . 50 push eax 00405132 . 51 push ecx 00405133 . C745 A8 06000000 mov dword ptr ss:[ebp-58],6 0040513A . C745 A0 02000000 mov dword ptr ss:[ebp-60],2 00405141 . C745 D0 00000000 mov dword ptr ss:[ebp-30],0 00405148 . C745 90 08000000 mov dword ptr ss:[ebp-70],8 0040514F . FF15 40114000 call ds:[<&MSVBVM60.#619>] ; MSVBVM60.rtcRightCharVar 00405155 . 8D55 80 lea edx,ss:[ebp-80] 00405158 . 8D45 CC lea eax,ss:[ebp-34] 0040515B . 52 push edx 0040515C . 50 push eax 0040515D . FFD7 call edi 0040515F . 50 push eax 00405160 . FF15 30104000 call ds:[<&MSVBVM60.#516>] ; MSVBVM60.rtcAnsiValueBstr 00405166 . 8B56 40 mov edx,ds:[esi+40] |Mueve a EDX AAD077BF (Temp2) 00405169 . 68 90414000 push T0RNAD0'.00404190 ; UNICODE "L-" |Comienza el serial 0040516E . 0FBFC8 movsx ecx,ax |Mueve a ECX último dígito en ascii (34) 00405171 . 8B46 38 mov eax,ds:[esi+38] |Mueve a EAX 01CF19EA (Temp1) 00405174 . 53 push ebx 00405175 . 03D0 add edx,eax |AAD077BF + 01CF19EA = AC9F91A9 00405177 . C785 70FFFFFF 0300000>mov dword ptr ss:[ebp-90],3 00405181 . 0F80 B4040000 jo T0RNAD0'.0040563B 00405187 . 03CA add ecx,edx |AC9F91A9 + 34 = AC9F91DD (Nuestro serial) 00405189 . 0F80 AC040000 jo T0RNAD0'.0040563B 0040518F . 898D 78FFFFFF mov ss:[ebp-88],ecx 00405195 . FF15 04104000 call ds:[<&MSVBVM60.__vbaStrI2>] ; MSVBVM60.__vbaStrI2 0040519B . 8B3D 38114000 mov edi,ds:[<&MSVBVM60.__vbaStrMove>] ; MSVBVM60.__vbaStrMove 004051A1 . 8BD0 mov edx,eax 004051A3 . 8D4D E0 lea ecx,ss:[ebp-20] 004051A6 . FFD7 call edi ; <&MSVBVM60.__vbaStrMove> 004051A8 . 50 push eax |EAX = tamaño del nombre 004051A9 . FF15 38104000 call ds:[<&MSVBVM60.__vbaStrCat>] ; MSVBVM60.__vbaStrCat |Concatena con "L-" 004051AF . 8BD0 mov edx,eax 004051B1 . 8D4D BC lea ecx,ss:[ebp-44] 004051B4 . FFD7 call edi 004051B6 . 66:83EB 06 sub bx,6 |Tamaño nombre - 6 = 18 004051BA . 50 push eax 004051BB . 0F80 7A040000 jo T0RNAD0'.0040563B 004051C1 . 0FBFCB movsx ecx,bx 004051C4 . 898D 08FFFFFF mov ss:[ebp-F8],ecx 004051CA . 8D45 A0 lea eax,ss:[ebp-60] 004051CD . DB85 08FFFFFF fild dword ptr ss:[ebp-F8] 004051D3 . 68 9C414000 push T0RNAD0'.0040419C 004051D8 . 50 push eax 004051D9 . DD9D 00FFFFFF fstp qword ptr ss:[ebp-100] 004051DF . DD85 00FFFFFF fld qword ptr ss:[ebp-100] 004051E5 . 833D 00A04000 00 cmp dword ptr ds:[40A000],0 004051EC . 75 08 jnz short T0RNAD0'.004051F6 004051EE . DC35 78114000 fdiv qword ptr ds:[401178] |18 / 2 = C (C es la posición para cojer dígitos del nombre, coje 6) 004051F4 . EB 11 jmp short T0RNAD0'.00405207 004051F6 > FF35 7C114000 push dword ptr ds:[40117C] 004051FC . FF35 78114000 push dword ptr ds:[401178] 00405202 . E8 3DC0FFFF call <jmp.&MSVBVM60._adj_fdiv_m64> 00405207 > DFE0 fstsw ax 00405209 . A8 0D test al,0D 0040520B . 0F85 25040000 jnz T0RNAD0'.00405636 00405211 . FF15 44114000 call ds:[<&MSVBVM60.__vbaR8IntI4>] ; MSVBVM60.__vbaR8IntI4 00405217 . 8B55 DC mov edx,ss:[ebp-24] |EDX = nombre 0040521A . 50 push eax |Eax = C 0040521B . 52 push edx 0040521C . FF15 6C104000 call ds:[<&MSVBVM60.#631>] ; MSVBVM60.rtcMidCharBstr |Mid(nombre,C,6) = "lmnopq" 00405222 . 8BD0 mov edx,eax 00405224 . 8D4D D8 lea ecx,ss:[ebp-28] 00405227 . FFD7 call edi 00405229 . 8B1D 38104000 mov ebx,ds:[<&MSVBVM60.__vbaStrCat>] ; MSVBVM60.__vbaStrCat 0040522F . 50 push eax 00405230 . FFD3 call ebx ; <&MSVBVM60.__vbaStrCat> |Concatena "-lmnopq" 00405232 . 8BD0 mov edx,eax 00405234 . 8D4D D4 lea ecx,ss:[ebp-2C] 00405237 . FFD7 call edi 00405239 . 50 push eax 0040523A . 68 9C414000 push T0RNAD0'.0040419C 0040523F . FFD3 call ebx |Concatena "-lmnopq-" 00405241 . 8BD0 mov edx,eax 00405243 . 8D4D C4 lea ecx,ss:[ebp-3C] 00405246 . FFD7 call edi 00405248 . 50 push eax 00405249 . 8D85 70FFFFFF lea eax,ss:[ebp-90] 0040524F . 50 push eax 00405250 . FF15 F0104000 call ds:[<&MSVBVM60.#572>] ; MSVBVM60.rtcHexBstrFromVar |serial "AC9F91DD" 00405256 . 8BD0 mov edx,eax 00405258 . 8D4D C8 lea ecx,ss:[ebp-38] 0040525B . FFD7 call edi 0040525D . 50 push eax 0040525E . FF15 B4104000 call ds:[<&MSVBVM60.#713>] ; MSVBVM60.rtcStrReverse |Invierte el serial "DD19F9CA" 00405264 . 8BD0 mov edx,eax 00405266 . 8D4D C0 lea ecx,ss:[ebp-40] 00405269 . FFD7 call edi 0040526B . 50 push eax 0040526C . FFD3 call ebx |Concatena "-lmnopq-DD19F9CA" 0040526E . 8BD0 mov edx,eax 00405270 . 8D4D B8 lea ecx,ss:[ebp-48] 00405273 . FFD7 call edi 00405275 . 50 push eax 00405276 . FFD3 call ebx |Concatena "L-30-lmnopq-DD19F9CA" ... 00405334 . FF15 80104000 call ds:[<&MSVBVM60.__vbaStrCmp>] ; MSVBVM60.__vbaStrCmp |Comparación final
Ejemplos:
Nombre: abcdefghijklmnopqrstuvwxyz1234 Serial: L-30-lmnopq-DD19F9CA Nombre: deurus2014 Serial: L-10-eurus2-84D8F9CA
Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por eso, vamos a tener que lidiar con ciertas peculiaridades al realizar el keygen con un lenguaje de bajo nivel.
Al inicio comprueba la longitud del nombre y de el número de serie. El nombre debe tener al menos 6 caracteres y el número de serie debe tener 10. Os adelanto ya que la asignación de memoria del nombre es de 9 caracteres, es decir, da igual la longitud del nombre que solo va a usar 9.
004014AD | E8 1A 02 00 00 | call <pythagoras.GetWindowTextA> | ;Lee el nombre 004014B2 | 83 F8 06 | cmp eax,6 | ;Nombre >=6 caracteres 004014B5 | 0F 82 03 01 00 00 | jb pythagoras.4015BE | 004014BB | 6A 14 | push 14 | 004014BD | 68 D9 31 40 00 | push pythagoras.4031D9 | ;004031D9:"1234567890" 004014C2 | FF 35 10 32 40 00 | push dword ptr ds:[403210] | 004014C8 | E8 FF 01 00 00 | call <pythagoras.GetWindowTextA> | ;Lee el serial 004014CD | 83 F8 0A | cmp eax,A | ;Serial debe tener 10 (A) caracteres 004014D0 | 0F 85 E8 00 00 00 | jne pythagoras.4015BE |
Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890
A continuación chequea que nuestro serial tenga caracteres hexadecimales.
004014DA | 8A 81 D9 31 40 00 | mov al,byte ptr ds:[ecx+4031D9] | ; ecx+004031D9:"1234567890" 004014E0 | 3C 00 | cmp al,0 | ; contador del bucle 004014E2 | 74 1F | je pythagoras.401503 | ; fin del bucle 004014E4 | 3C 30 | cmp al,30 | ; 0x30 = número 1 004014E6 | 0F 82 D2 00 00 00 | jb pythagoras.4015BE | ; < 30 bad boy 004014EC | 3C 46 | cmp al,46 | ; 0x46 = letra F 004014EE | 0F 87 CA 00 00 00 | ja pythagoras.4015BE | ; > 46 bad boy 004014F4 | 3C 39 | cmp al,39 | ; 0x39 = número 9 004014F6 | 76 08 | jbe pythagoras.401500 | ; <=39 ok continua el bucle 004014F8 | 3C 41 | cmp al,41 | ; 0x41 = letra A 004014FA | 0F 82 BE 00 00 00 | jb pythagoras.4015BE | ; <41 bad boy 00401500 | 41 | inc ecx | ; contador += 1 00401501 | EB D7 | jmp pythagoras.4014DA | ; bucle
Continua realizando un sumatorio con nuestro nombre, pero tenemos que tener especial cuidado al tratamiento de los datos, ya que el crackme al estar hecho en ensamblador puede jugar con los registros como quiere y eso nos puede inducir a error.
0040150B | 3C 00 | cmp al,0 | ; ¿Fin bucle? 0040150D | 74 05 | je pythagoras.401514 | ; Salta fuera del bucle si procede 0040150F | 02 D8 | add bl,al | ; bl = bl + al 00401511 | 41 | inc ecx | ; contador +=1 00401512 | EB F1 | jmp pythagoras.401505 | ; bucle
Si os fijáis utiliza registros de 8 bits como son AL y BL. Debajo os dejo una explicación de EAX pero para EBX es lo mismo.
EAX
-----------------------------------
AX
-----------------
AH AL
-------- --------
00000000 00000000 00000000 00000000
(8bit) (8bit) (8bit) (8bit)
EAX (32 bit)
--------
AX (16 bit)
----
AHAL (AH y AL 8 bit)
--------
00000000
El uso de registros de 8 bits nos implica tomar precauciones al realizar el Keygen debido a que por ejemplo, en .Net no tenemos la capacidad de decirle que haga una suma y que nos devuelva solamente 8 bits del resultado. Veamos como ejemplo para el nombre «deurus». La suma de los caracteres hexadecimales quedaría:
64+65+75+72+75+73 = 298, es decir, EAX = 00000298
Pero recordad que el crackme solo cogerá el 98 que es lo correspondiente al registro AL. De momento nos quedamos con nuestro SUMNOMBRE = 98.
A continuación coge los dos primeros caracteres del serial y les resta nuestro SUMNOMBRE y comprueba que el resultado esté entre 4 (0x4) y -4 (0xFC).
0040154B | 0F B6 05 F3 31 40 00 | movzx eax,byte ptr ds:[4031F3] | 00401552 | 8A C8 | mov cl,al | 00401554 | 2A CB | sub cl,bl | ; CL = CL - BL | CL = 12 - 98 = 7A 00401556 | 80 F9 04 | cmp cl,4 | ; Compara CL con 4 00401559 | 7F 63 | jg pythagoras.4015BE | ; Salta si es mayor 0040155B | 80 F9 FC | cmp cl,FC | ; Compara CL con FC (-4) 0040155E | 7C 5E | jl pythagoras.4015BE | ; Salta si es menor
Como veis, el resultado de la resta da 7A (122) que al ser mayor que 4 nos echa vilmente. Aquí de nuevo utiliza registros de 8 bits por lo que debemos tener cuidado con las operaciones matemáticas para no cometer errores, veamos un ejemplo para clarificar de aquí en adelante.
Utilizando 8 bits ----------------- 12 - 98 = 7A que en decimal es 122 Utilizando 16 bits ------------------ 0012 - 0098 = FF7A que en decimal es -134
Ahora ya veis la diferencia entre FC (252) y FFFC (-4). Estrictamente, el crackme comprueba el rango entre 4 (4) y FC (122) al trabajar con registros de 8 bits pero nosotros, como veremos más adelante tomaremos el rango entre 4 y -4. De momento, para poder continuar depurando cambiamos los dos primeros caracteres del serial de 12 a 98, ya que 98 – 98 = 0 y cumple la condición anterior.
Introducimos Nombre: deurus y Serial: 9834567890
Analicemos el siguiente código.
00401560 | F7 E0 | mul eax | ; EAX = EAX * EAX 00401562 | 8B D8 | mov ebx,eax | ; EBX = EAX 00401564 | 0F B7 05 F4 31 40 00 | movzx eax,word ptr ds:[4031F4] | ; EAX = 3456 (4 dígitos siguientes del serial) 0040156B | F7 E0 | mul eax | ; EAX = EAX * EAX 0040156D | 03 D8 | add ebx,eax | ; EBX = EBX + EAX 0040156F | 0F B7 05 F6 31 40 00 | movzx eax,word ptr ds:[4031F6] | ; EAX = 7890 (4 últimos dígitos del serial) 00401576 | F7 E0 | mul eax | ; EAX = EAX * EAX 00401578 | 33 C3 | xor eax,ebx | ; EAX 0040157A | 75 42 | jne pythagoras.4015BE | ; Salta si el flag ZF no se activa
En resumen:
Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²
Serial = aabbbbcccc
Finalmente comprueba lo siguiente:
0040157C | 66 A1 F6 31 40 00 | mov ax,word ptr ds:[4031F6] | ; AX = 7890 00401582 | 66 2B 05 F4 31 40 00 | sub ax,word ptr ds:[4031F4] | ; AX = 7890 - 3456 = 443A 00401589 | 2C 08 | sub al,8 | ; AL = 3A - 8 = 32 0040158B | 75 31 | jne pythagoras.4015BE | ; Si el resultado de la resta no ha sido cero, serial no válido 0040158D | 6A 30 | push 30 | 0040158F | 68 B0 31 40 00 | push pythagoras.4031B0 | ;004031B0:":-) Well done!!!" 00401594 | 68 7F 31 40 00 | push pythagoras.40317F | ;0040317F:"Bravo, hai trovato il seriale di questo CrackMe!" 00401599 | FF 75 08 | push dword ptr ds:[ebp+8] |
En resumen:
Nuestro serial tiene que cumplir tres condiciones para ser válido.
Como hemos dicho anteriormente, tomaremos el SUMNOMBRE y le sumaremos y restaremos valores siempre y cuando el resultado esté entre 4 y -4. Para deurus hemos dicho que el SUMNOMBRE es 98 por lo que los posibles valores de «a» se pueden ver debajo. Además debemos tener en cuenta que el crackme solo lee los 9 primeros dígitos del nombre.
98-4 = 94 98-3 = 95 98-2 = 96 98-1 = 97 98-0 = 98 98+1 = 99 98+2 = 9A 98+3 = 9B 98+4 = 9C
Es evidente que para encontrar el valor de «c» vamos a tener que utilizar fuerza bruta chequeando todos los valores de «b» comprendidos entre 0 y FFFF (65535). Además, como trabajaremos en un lenguaje de alto nivel, debemos descartar los resultados decimales. Esto nos limitará los seriales válidos asociados a un determinado nombre. Si realizáramos el keygen en ensamblador obtendríamos bastantes más seriales válidos.
Una vez encontrados los valores enteros de la operación «c² = a² + b²», se debe cumplir que «c – b – 8 = 0», lo que nos limitará bastante los resultados.
Private Sub btn_generar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_generar.Click
Try
If txt_nombre.TextLength > 5 Then
lst_serials.Items.Clear()
Dim tmp, c, cx As String
Dim sumanombre, tmp2 As Integer
If txt_nombre.TextLength > 9 Then tmp2 = 8 Else tmp2 = txt_nombre.TextLength - 1
'Calculo el SUMNOMBRE
For i = 0 To tmp2
sumanombre += Asc(Mid(txt_nombre.Text, i + 1, 1)) 'Acumulo suma
tmp = Strings.Right(Hex(sumanombre).ToString, 2) 'Solo 8 bits (Registro AL)
sumanombre = Val("&H" & tmp) 'Paso a decimal
Next
tmp = Strings.Right(Hex(sumanombre).ToString, 2)
sumanombre = CInt("&H" & tmp)
txtdebug.Text = "- SumNombre = " & Hex(sumanombre) & vbCrLf
txtdebug.Text &= "----------------------------------------------" & vbCrLf
Dim a(8) As Integer
'
'a - sumanombre >=4 y <=4
'
a(0) = sumanombre - 4
a(1) = sumanombre - 3
a(2) = sumanombre - 2
a(3) = sumanombre - 1
a(4) = sumanombre
a(5) = sumanombre + 1
a(6) = sumanombre + 2
a(7) = sumanombre + 3
a(8) = sumanombre + 4
txtdebug.Text &= "- Posibles valores de 'a'" & vbCrLf
For i = 0 To a.Length - 1
txtdebug.Text &= Hex(a(i)) & " "
Next
txtdebug.Text &= "----------------------------------------------" & vbCrLf
txtdebug.Text &= "- Buscando valores de b y c" & vbCrLf
txtdebug.Text &= "Serial = aabbbbcccc" & vbCrLf
'
'c = sqr(a^2 + b^2)
'
txtdebug.Text &= "(1) c = raiz(a^2 + b^2)" & vbCrLf
txtdebug.Text &= "(2) c - b - 8 = 0" & vbCrLf
For i = 0 To a.Length - 1 ' todas las posibilidades de a
For b = 0 To 65535 'b -> 0000 - FFFF
c = Math.Sqrt(a(i) ^ 2 + b ^ 2)
If c.Contains(".") Then 'busco enteros
Else
cx = c - b - 8
cx = Hex(cx).PadLeft(4, "0"c)
lbl_info.Text = cx
If cx = "0000" Then
txtdebug.Text &= " (1) " & Hex(c).PadLeft(4, "0"c) & " = raiz(" & Hex(a(i)).PadLeft(2, "0"c) & "^2 + " & Hex(b).PadLeft(4, "0"c) & "^2)" & vbCrLf
lst_serials.Items.Add(Hex(a(i)).PadLeft(2, "0"c) & Hex(b).PadLeft(4, "0"c) & Hex(c).PadLeft(4, "0"c))
txtdebug.Text &= " (2) " & Hex(c).PadLeft(4, "0"c) & " - " & Hex(b).PadLeft(4, "0"c) & " - 8 = 0" & vbCrLf
End If
End If
Application.DoEvents()
Next
Next
lbl_info.Text = "Búsqueda finalizada"
End If
Catch ex As Exception
MsgBox(ex.ToString)
End Try
La apacible existencia de Ángel Ríos da un vuelco cuando una antigua compañera de clase, de la que siempre ha estado enamorado, le pide ayuda para descifrar un misterioso archivo. A partir de entonces, Ángel se verá envuelto en una intriga relacionada con el contenido del archivo, que complicará su vida y lo expondrá a un grave peligro. En el camino hacia la verdad, únicamente contará con sus sorprendentes conocimientos de hacking y el apoyo de su peculiar amigo Marcos. Técnicas de hacking web, sistemas y análisis forense son algunos de los temas que se tratan con total rigor en esta mezcla de novela negra y manual técnico.
En 1990, la caída del sistema del día de Martin Luther King, que afecto a la compañía telefónica AT&T y dejó sin comunicaciones a millones de norteamericanos, desencadenó la persecución y detención de decenas de hackers, acusados de causar el hundimiento, que hasta ese momento era ignorados por la policía y las leyes. Bruce Sterling, considerado uno de los mayores expertos en el género del ciberpunk, nos ofrece un apasionante reportaje desde el principio de la era de internet, los ordenadores personales, y la frontera electrónica partiendo de la base de ese hecho inaudito. Con una entretenida prosa novelesca, Sterling nos lleva a conocer a todos los implicados en el asunto, desde los primeros activistas de internet hasta los policías encargados del caso, que cimentó los pilares de lo que hoy es la libertad de expresión en Internet. 25 años después de los sucesos del día de Martin King, «La Caza de Hackers», se ha convertido en un libro de culto y un documento histórico imprescindible para comprender y entender la transformación y el impacto de las nuevas comunicaciones en el Siglo XXI.
El título de este libro anima a que tomes control de la ciberseguridad no solo en tu trabajo, sino también para tus asuntos personales. La ciberdelincuencia es una industria delictiva que mueve miles de millones de dólares al año y cuyos actores apenas temen a las fuerzas del orden. Los incidentes siguen creciendo, y más allá de la protección en los lugares de trabajo, también es necesario protegernos a nosotros mismos y a nuestras familias.
Clint Watts, un ex agente especial del FBI, oficial del Ejército de Estados Unidos y destacado experto en ciberseguridad, ofrece una mirada devastadora y esencial a las campañas de desinformación, las noticias falsas y las operaciones de espionaje electrónico que se han convertido en la vanguardia de la guerra moderna. También ofrece consejos para protegernos en nuestro día a día.
Con multitud de ejemplos, este libro le mostrará que Internet no es simplemente una forma de ver vídeos de gatos monos; es un campo de batalla, un invento militar que se descubrió accidentalmente que era capaz de dominar cualquier amenaza económica, digital y políticamente.
Desde los foros más burdos hasta los servicios en línea más sofisticados, hay una guerra en marcha y, lo quieras o no, estás implicado por el mero hecho de estar aquí, así que mejor ármate de conocimientos.
Historia de la comunidad hacker en España, centrada en la década de los 90, cuando aparecen los primeros grupos y nace la cultura hacker. El libro narra el quién fue quién, así como sus hazañas, anécdotas y colectivos e individuales más punteros. Este ingente trabajo de investigación nació en 2009, con la puesta en marcha de un wiki, al estilo wikipedia, llamado Hackstory.net y donde en estos años la autora ha ido creando fichas, accesibles al público, que le han permitido escribir este libro, sin parangón en Europa. La comunidad hacker ha revisado los textos así como apoyado a la autora, tanto a la hora de aportar información, como en una campaña de «crowdfunding» con la que se consiguió una respetable cantidad para tener el tiempo suficiente de escribir el libro. Además de ser sus principales mecenas, protagonistas y aportadores de información, los hackers españoles han participado en todos los aspectos organizativos relacionados con la producción y distribución del libro.
Documental narrado por Kevin Spacey que explora los orígenes y la naturaleza de los hackers y los piratas informáticos.
Sigue las aventuras de Adrián Lamo, un célebre hacker y periodista estadounidense, conocido por haber delatado a Chelsea Manning, el soldado que presuntamente filtró a WikiLeaks el vídeo que mostraba a soldados americanos asesinando a civiles en
Afganistán.
Este documental tiene como objetivo retratar de forma exhaustiva la comunidad hacker. En un esfuerzo por cuestionar las ideas preconcebidas y los estereotipos de los medios de comunicación, HACKERS ARE PEOPLE TOO permite a los hackers hablar por sí mismos y presentar su comunidad al público.
Hackers in Wonderland es un documental del año 2000, producido y dirigido por Russell Barnes.
Se centra en los hackers del Reino Unido, y contiene entrevistas con ellos donde revelan lo que les impulsa a hackear y sus opiniones sobre el hacktivismo.
Este documental sobre la comunidad de hackers incluye imágenes de una conferencia de hackers y entrevistas con algunos de los programadores que crearon la revolución de los ordenadores personales, como Bill Atkinson, Bill Budge o Doug Carlston.
Convertido ya en un clásico sobre la revolución de los ordenadores, las entrevistas fueron grabadas durante un largo fin de semana en una conferencia de hackers
de 1984.
El único Podcast en español íntegramente dedicado al OSINT (Open Source Intelligence), conjunto de técnicas y herramientas para recopilar información pública, correlacionar los datos y procesarlos. Está dirigido por el Analista y Consultor OSINT David Sanz y son episodios de menos de una hora donde se habla de casos reales, herramientas, noticias, libros y documentales.
Ciberseguridad sin censura, es el podcast del Instituto de Ciberseguridad en el que se tocan temas relacionados a la tecnología y seguridad, de forma objetiva y sin censura.
Su visión es que a través de este podcast, puedas encontrar noticias, entrevistas y temas de tecnología y seguridad en general desde un punto de vista completamente imparcial.
Podcast centrado en ingeniería social. Entender cómo interactuamos, nos comunicamos y transmitimos información puede ayudarnos a proteger, mitigar y comprender este tipo de ataques.
Cada quince días, el hacker ético de Delinea Joseph Carson y los expertos en formación en ciberseguridad deCybrary comparten sus puntos de vista con invitados especiales en este interesante podcast sobre la actualidad en materia de ciberseguridad.
Sebastian acaba de conseguir su primer trabajo en la lejana ciudad de Dorisburg. Se traslada allí para
comenzar su vida adulta y averiguar quién quiere ser realmente.
Entre una extraña colección de personas, hackers y activistas, encuentra algunos verdaderos amigos, e incluso el amor. Pero, ¿podrán detener los terribles actos de la gente que gobierna la ciudad?
Else Heart.Break () es una vuelta de tuerca del juego de aventuras: una historia fantástica ambientada en un mundo totalmente dinámico e interactivo.
Hackmund es un simulador de hacking multijugador basado en texto para ordenadores personales compatibles con Intel.
En este emocionante videojuego, los jugadores pueden descifrar sistemas protegidos y resolver rompecabezas mientras exploran la abandonada Internet del futuro. Además, pueden escribir scripts para proteger sus ganancias y engañar a otros jugadores.
En este juego de programación desarrollado por Zachtronics Industries, puedes desarrollar un código de lenguaje ensamblador simulado para realizar ciertas tareas en un ordenador ficticio virtualizado de la década de 1970.
Will es un experto en seguridad informática que trabaja como consultor y hacker independiente en San Francisco.
Su vida da un vuelco cuando es contratado por un hombre que quiere pruebas de la infidelidad de su mujer. En su investigación, descubre un misterioso programa informático del gobierno, un aterrador sistema de identificación y tracking de personas.
Hannover, finales de los años ochenta. El huérfano Karl Koch invierte su herencia en un ordenador personal. Al principio lo usa para captar noticias sobre discusiones de teorías conspirativas inspiradas en su novela favorita, “Illuminatus”, de R.A. Wilson, pero pronto Karl y su amigo David empiezan a introducirse en ordenadores del gobierno y del ejército.
Esta apasionante historia real sobre unos jóvenes alemanes, obtuvo reconocimientos a premios importantes dentro de su país de origen.
Película de 1995 que tiene a Keanu Reeves como protagonista.
Corre el año 2021 y la mitad de la población sufre de una enfermedad llamada “síndrome de atenuación de los nervios”. Johnny es un mensajero de información, una persona que lleva los datos más importantes del siglo XXI directamente implantados en su cerebro. Su información será muy valiosa para una gran corporación, que no parará hasta dar con él.
A pesar de no haber recibido buenas críticas en su momento, su visionado futurista resulta entretenido.
Benjamin se siente invisible, pero esto cambia cuando conoce al carismático Max. Aunque aparentemente no podrían ser más diferentes, ambos comparten el mismo interés: la piratería informática.
Junto con los amigos de Max, forman un grupo subversivo de hackers que desafía al sistema y Benjamin se siente parte de algo por primera vez en su vida.
Pero la cosa se pone seria de repente, cuando el grupo es incluido en la lista de buscados de la policía alemana y la Europol.
Dade acaba de mudarse con su madre a la ciudad de Nueva York. En su primer día de escuela conocerá a un grupo de jóvenes cuya afición es piratear sistemas informáticos por diversión. Dadee se unirá a ellos, pero todo se complica cuando descubren que están siendo vigilados por las autoridades. Cuando el grupo se entera de la existencia de un plan para liberar un peligroso virus en la Red, todos deberán utilizar sus habilidades informáticas para conseguir pruebas de ello mientras el Servicio Secreto y el malvado genio de los ordenadores que ha creado el virus les pisan los talones.
Película biográfica dirigida por David Fincher, estrenada el 24 de septiembre de 2010, en el Festival de Cine de Nueva York. Esta narra un drama de tribunales, sobre las implicaciones morales del entonces ascendente Mark Zuckerberg (interpretado por Jesse Eisenberg), cuyas peripecias lo encaminaron en la construcción de un imperio billonario, y de cómo alguien poco sociable logró conectar a cientos de millones de personas a través de su creación, Facebook.
El primer día de sus vacaciones, una programadora de ordenadores recibe un extraño disquet para que lo investigue. Se lo guarda y descubre que posee una clave para acceder al control de las bases de datos protegidas de Estados Unidos. A la vez ve cómo todos los datos de su vida que figuran en archivos informáticos son suprimidos o tergiversados.
Thriller cibernético en el que varios agentes norteamericanos y chinos, con ayuda de un convicto liberado, se unen para detener a un misterioso hacker. Todo comienza cuando los gobiernos de Estados Unidos y China se ven obligados a cooperar por el bien de la seguridad nacional de ambas potencias. El motivo: una fuerte amenaza informática está poniendo en riesgo las vidas y el futuro de la población. Delitos informáticos de alto nivel para los que deberán recurrir a sus mejores agentes de campo si quieren llegar a tiempo para evitar lo peor.
Representa un futuro distópico en el que la humanidad está atrapada sin saberlo dentro de una realidad simulada llamada Matrix, que las máquinas inteligentes han creado para distraer a los humanos mientras usan sus cuerpos como fuente de energía en campos de cultivo. Cuando el programador informático Thomas Anderson, bajo el alias de hacker «Neo», descubre la incómoda verdad, se une a una rebelión contra las máquinas junto con otras personas que han sido liberadas de Matrix. Siendo estrenada en los Estados Unidos el 31 de marzo de 1999, es la primera entrega de la franquicia Matrix, de la que derivan (dado su éxito) una serie de videojuegos, cortos animados y cómics, llegando a ser un claro ejemplo del subgénero cyberpunk.
Un joven informático, con una gran habilidad para falsificar notas, entra en una compañía de juegos de ordenador para probarlos y consigue poner en jaque al Departamento de Defensa de los Estados Unidos y provocar la III Guerra Mundial.
La épica historia del hombre que en 2013 puso en jaque a los EE.UU. Cuando Edward J. Snowden desveló los documentos del programa de vigilancia mundial secreto de la NSA abrió los ojos del mundo y cerró las puertas de su propio futuro. Se vio obligado a renunciar a su carrera, a su novia de toda la vida y a su patria. ¿Fue un patriota o un traidor?
Esta serie de televisión estadounidense está basada en una novela y tiene como protagonista a Lindy Sampson, una solitaria hacker que tiene un blog en el que expone todo tipo de cosas: desde planes terroristas hasta presuntos asesinos.
Un día, Lindy se convierte en el blanco de un peligroso acosador cibernético y asesino en serie, que se obsesiona con ella. A partir de entonces, Lindy se sumerge en la investigación policial para capturar al asesino, utilizando su especial habilidad.
Esta aclamada serie de cuatro temporadas ha sido nominada durante varios años seguidos tanto a los Globos de Oro como a los Emmy y ha sido destacada por muchos críticos como una de las mejores series de los últimos años.
El protagonista es Elliot Anderson, interpretado por un estupendo Rami Malek. Un brillante programador con problemas para las relaciones sociales que durante el día trabaja como técnico de ciberseguridad y por la noche es un desinteresado justiciero cibernético, que se ve envuelto en una oscura trama.
Lily es una joven ingeniera informática que decide investigar a la empresa de tecnología para la que trabaja, pues cree que está detrás de la desaparición de su novio.
A medida que avanza la investigación, descubre que la empresa está desarrollando un código que desafía las leyes del espacio y el tiempo.
El director de Ex_Machina firma este hipnótico thriller que habla sobre el uso indiscriminado del Big Data, reflexiona sobre el determinismo, (alegando que ninguno de nuestros actos es libre), y diseña una interesante radiografía sobre las relaciones humanas.
Richard es un tímido programador que vive con sus tres únicos amigos y descubren un importante algoritmo que supondrá una batalla con intereses y falsas amistades. Además, una chica se cruza por primera vez en la vida de Richard.
