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
El crackme que analizamos hoy está hecho en ensamblador y si bien su dificultad es baja, la creación del keygen es un poco liosa. Al keygen que veremos más adelante, le he dado cierta aleatoriedad para que quede más elegante.
El crackme comprueba el serial en función de un identificador de 4 dígitos que el mismo crackme genera.
Coje nuestro serial mediante la función GetDlgItemTextA.
004010D3 |. 68 FF000000 PUSH 0FF ; /MaxCount = 255. 004010D8 |. 68 40324000 PUSH OFFSET 00403240 ; |String 004010DD |. 68 EC030000 PUSH 3EC ; |ItemID = 1004. 004010E2 |. FF75 08 PUSH DWORD PTR SS:[ARG.1] ; |hDialog => [ARG.1] 004010E5 |. E8 6E010000 CALL <JMP.&user32.GetDlgItemTextA> ; \USER32.GetDlgItemTextA 004010EA |. 68 40324000 PUSH OFFSET 00403240 ; /String 004010EF |. E8 52010000 CALL <JMP.&kernel32.lstrlenA> ; \KERNEL32.lstrlen 004010F4 |. A3 47334000 MOV DWORD PTR DS:[403347],EAX 004010F9 |. 33DB XOR EBX,EBX 004010FB |. 33C0 XOR EAX,EAX 004010FD |. EB 54 JMP SHORT 00401153
Comprueba que nuestro serial esté formado por números (30h – 39h), letras de la A a la F (41h – 46h) y el guión (2Dh), es decir, el alfabeto hexadecimal más el guión. Si hay algún dígito indeseado nos tira fuera.
004010FF |> 8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240] 00401105 |. 3C 2D |CMP AL,2D 00401107 |. 74 40 |JE SHORT 00401149 00401109 |. 3C 30 |CMP AL,30 0040110B |. 74 3C |JE SHORT 00401149 0040110D |. 3C 31 |CMP AL,31 0040110F |. 74 38 |JE SHORT 00401149 00401111 |. 3C 32 |CMP AL,32 00401113 |. 74 34 |JE SHORT 00401149 00401115 |. 3C 33 |CMP AL,33 00401117 |. 74 30 |JE SHORT 00401149 00401119 |. 3C 34 |CMP AL,34 0040111B |. 74 2C |JE SHORT 00401149 0040111D |. 3C 35 |CMP AL,35 0040111F |. 74 28 |JE SHORT 00401149 00401121 |. 3C 36 |CMP AL,36 00401123 |. 74 24 |JE SHORT 00401149 00401125 |. 3C 37 |CMP AL,37 00401127 |. 74 20 |JE SHORT 00401149 00401129 |. 3C 38 |CMP AL,38 0040112B |. 74 1C |JE SHORT 00401149 0040112D |. 3C 39 |CMP AL,39 0040112F |. 74 18 |JE SHORT 00401149 00401131 |. 3C 41 |CMP AL,41 00401133 |. 74 14 |JE SHORT 00401149 00401135 |. 3C 42 |CMP AL,42 00401137 |. 74 10 |JE SHORT 00401149 00401139 |. 3C 43 |CMP AL,43 0040113B |. 74 0C |JE SHORT 00401149 0040113D |. 3C 44 |CMP AL,44 0040113F |. 74 08 |JE SHORT 00401149 00401141 |. 3C 45 |CMP AL,45 00401143 |. 74 04 |JE SHORT 00401149 00401145 |. 3C 46 |CMP AL,46 00401147 |. 75 07 |JNE SHORT 00401150 00401149 |> 8305 4B334000 |ADD DWORD PTR DS:[40334B],1 00401150 |> 83C3 01 |ADD EBX,1 00401153 |> 3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347] 00401159 |.^ 76 A4 \JBE SHORT 004010FF 0040115B |. A1 47334000 MOV EAX,DWORD PTR DS:[403347] 00401160 |. 3905 4B334000 CMP DWORD PTR DS:[40334B],EAX ; si no coincide el tamaño del serial con el 00401166 |. 0F85 94000000 JNE 00401200 ; contador nos tira fuera
La comprobación del serial la realiza sumando el valor ascii del primer dígito al valor ascii del tercero y sucesivos y a continuación restando la suma anterior al ID. Cuando finalice la comprobación de todos los dígitos del serial, el restador tiene que ser cero, de lo contrario nos tira fuera. Si el ID es cero también nos tira fuera.
Ejemplo (base 10)para ID = 4011 y SERIAL: 1-23456
0040116C |. 33C0 XOR EAX,EAX 0040116E |. BB 02000000 MOV EBX,2 00401173 |. A0 40324000 MOV AL,BYTE PTR DS:[403240] 00401178 |. A3 43334000 MOV DWORD PTR DS:[403343],EAX 0040117D |. EB 13 JMP SHORT 00401192 0040117F |> 8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240] ; Coje el dígito correspondiente 00401185 |. 0305 43334000 |ADD EAX,DWORD PTR DS:[403343] ; 1ºdig + dig 0040118B |. 2905 4F334000 |SUB DWORD PTR DS:[40334F],EAX ; ID - (1ºdig + dig) 00401191 |. 43 |INC EBX 00401192 |> 3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347] 00401198 |.^ 72 E5 \JB SHORT 0040117F 0040119A |. 833D 4F334000 CMP DWORD PTR DS:[40334F],0 ; CHECK RESTADOR SEA = 0 004011A1 |. 75 49 JNE SHORT 004011EC 004011A3 |. 833D 3F334000 CMP DWORD PTR DS:[40333F],0 ; CHECK ID <> 0 004011AA |. 74 40 JE SHORT 004011EC 004011AC |. FF35 3F334000 PUSH DWORD PTR DS:[40333F] ; /<%d> = 0 004011B2 |. 68 00304000 PUSH OFFSET 00403000 ; |Format = "REGISTRADO CON ID:%d" 004011B7 |. 68 40324000 PUSH OFFSET 00403240 ; |Buf 004011BC |. E8 A9000000 CALL <JMP.&user32.wsprintfA> ; \USER32.wsprintfA
Como veis, el resultado de ir restando todos los dígitos de nuestro serial con la ID debe ser cero para que el serial sea correcto.
Lo primero que se me ocurre para obtener una solución directa es buscar una combinación de dígito + dígito que sea múltiplo del ID. Para ello podemos usar la función módulo. La función módulo lo que hace es darnos el resto de la división de dos números, de modo que si el resto es cero los números son múltiplos. Para ello debemos cruzar todos los números y letras hasta encontrar los dígitos múltiplos del ID. Un serial de este primer tipo quedaría algo así como 1-FFFFFFFFFFFFFFFFFF ya que como el primer dígito es fijo el otro se repetirá tanta veces como sea necesario para hacer que el ID sea cero.
Con nuestro reducido alfabeto, cabe la posibilidad de que no encontremos una combinación válida, por lo que tendremos que pensar en un plan B. El plan B que se me ocurre a mi es intentar forzar el plan A restando caracteres aleatorios al ID y volviendo a comprobar si encontramos múltiplos del nuevo ID. Un serial de este tipo quedaría más elegante, por ejemplo 3-A6D53B628BBBBB.
Os dejo unos cuantos números de serie.
'Keygen for Flamer's asm keygenme
Dim id As Integer
Dim serial As String
Dim tmp, tmp2, na, nb As Integer
Dim alfabeto As Integer() = New Integer() {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70}
Dim r As Random = New Random
'Button generate
Private Sub btngen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btngen.Click
ini:
If txtid.TextLength <> 4 Then GoTo Mal
id = txtid.Text
txtdebug.Text = ""
na = alfabeto(r.Next(1, 16))
serial = Chr(na) & "-"
tmp = id
For i = 0 To alfabeto.Length - 1
For y = 0 To alfabeto.Length - 1
'Solución directa
If id Mod (alfabeto(i) + alfabeto(y)) = 0 Then
tmp = id / (alfabeto(i) + alfabeto(y))
txtserial.Text = Chr(alfabeto(i)) & "-"
For z = 0 To tmp - 1
txtserial.Text &= Chr(alfabeto(y))
Next
GoTo fuera
End If
'Indirecta con aleatoriedad
nb = alfabeto(r.Next(1, 16))
tmp = tmp - (na + nb)
serial &= Chr(nb)
If tmp Mod (na + nb) = 0 Then
tmp2 = tmp / (na + nb)
For z = 0 To tmp2 - 1
serial &= Chr(nb)
Next
txtserial.Text = serial
GoTo fuera
End If
If tmp < 0 Then
GoTo ini
Else
txtdebug.Text &= tmp & " "
End If
Next
Next
Mal:
txtserial.Text = "¿id?"
fuera:
End Sub
Me doy cuenta que en el keygen no he utilizado el guión, pero no pasa nada, se lo dejo al lector como curiosidad.
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.
El cifrado XOR es uno de los algoritmos más utilizados en el mundillo de la encriptación. Aunque por sí solo no es seguro, suele formar parte de cifrados más complejos e incluso si sois aficionados a los crackmes os habréis dado cuenta de que raro es el crackme que no lo utiliza.
Hoy vamos a hacer un recorrido sobre los retos de encriptación que nos propone yoire.com, que aunque son muy sencillos, nos proporcionan una estupenda base para iniciarnos en este tipo de retos.
En este primer reto, el autor te da directamente la solución, ya que, nos da un texto cifrado y nos dice que está cifrado con la clave 10. Lo que el autor no indica es que la clave es hexadecimal, mas adelante ya aprendereis a fijaros en esos detalles.
Texto cifrado: uqci0t~7d0ie0dxy~{
Clave: 10
Esta vez disponemos de un texto cifrado pero sin pistas. Si nos fijamos en el código fuente veremos que la clave utilizada esta vez es 20 y decimal.
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Easy"));
print Challenges::header();
?>
Convierte la solución que está cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
$solution_xored="m{a4s{`4}`5";
$key = sprintf("%2x",20);
$solution = Crypt::XorData($solution_xored,$key);
print "La solución es: ".$solution_xored;
print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
En esta ocasión debemos ojear el código fuente para averiguar como solucionar el reto. En esta ocasión y como de lo que se trata es de aprender, este lo dejaré sin solucionar.
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Mid"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
foreach (
preg_split("/\./","2.4.10.71.3698")
as $something
)
$value=pow($something,2);
$key = dechex($value);
$solution_xored = base64_decode("ucSnos+lo8Oqtw==");
$solution = Crypt::XorData($solution_xored,$key);
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>
<?php
if(Common::getString("showSource")!==false) {
print "<hr>";
highlight_file(__FILE__);
}
print Website::footer();
?>
Venga que casi lo tienes.
En este reto nos indican que el código fuente está encriptado. Cuando nos enfrentamos a XOR en texto grandes y teniendo un indicio de lo que puede contener el código desencriptado es sencillo encontrar lo que buscamos. En este caso en concreto podemos intuir que seguramente el texto contenga la palabra «php«, una vez llegamos a esa conclusión la solución llega sola. Este método no deja de ser un ataque por fuerza bruta.
Código encriptado
lo 8 p]Z9>3<%45xr~~~~~~3?"5~ 8 ryk]Z "9>$p52#9$5jj85145"x1""1)xr$9
lt;5rmnr85p p81<$p81<<5>75#jj85145"xyk]Zon]Z1"535p!%5p5$5p81p#94?p396"14?~~~p%===~~~p$5>4"±#p!%5p1&5"97%1"p3£=?p 1"1p?2$5>5"p<1p"5# %5#$1p1p5#$5p"5$?j]Zl2"nl2"n]Zlo 8 ]Z]Zt;5)ppppppppppppmpre`rk]Zt=5pppppppppppppmp69<575$3?>$5>$#x yk]Zt=5(?"54pppppppmp") $jj?"1$1xt=5|t;5)yk]Z]Z "9>$p81<<5>75#jj#?<%$9?>?(xyk]Z "9>$p81<<5>75#jj3853;?<%$9?>xr3````aryk]Zon]Zl1p8"56mrlomt r r onolom%"<5>3?45x") $jj?"1$1xr#8?'?%"35r|t;5)yyonrn5"p3£497?p6%5>$5l1n]Z]Zlo 8 ]Z96x?==?>jj75$$"9>7x") $jj?"1$1xr#8?'?%"35r|t;5)yyqmm61<#5yp+]ZY "9>$prl8"nrk]ZY "9>$pt=5(?"54k]Z-]Z "9>$p52#9$5jj6??$5"xyk]Zon]Z
Código desencriptado
En este último reto nos aparece un mensaje que nos dice «La solución es: 7b1a4147100a155a0f45574e0f58«. Nos fijamos en el código fuente y vemos que en la encriptación interviene una cookie llamada «PHPSESSID«.
Código fuente
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Hard"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
$sessid = isset($_COOKIE["PHPSESSID"])?$_COOKIE["PHPSESSID"]:">hi!|m¬_ö_Ó_;m'`ñ·$\"<";
$key = Encoder::asc2hex($sessid);
$hiddenSolution = file_get_contents(Config::$challsHiddenData."crypt_xor_average.solution");
$hex_xored_solution = Encoder::data2hex(Crypt::XorData($hiddenSolution,$key));
print "La solucion es: ".$hex_xored_solution;
print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution($hiddenSolution);
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>
<?php
if(Common::getString("showSource")!==false) {
print "<hr>";
highlight_file(__FILE__);
}
print Website::footer();
?>
Desde Firefox vamos a usar una extensión muy interesante llamada Advanced Cookie Manager que nos permitirá visualizar y modificar dicha cookie.
Una particularidad de la encriptación XOR es que si realizamos «algo XOR 0 == algo«, por lo que un ataque típico sería anular la cookie. La modificamos poniendo como valor 0 y guardamos. Recargamos la web con F5 y ahora nos fijamos que el valor de la solución ha cambiado a «7e5f4410435f1058514254100a19«. Finalmente y teniendo en cuenta que el texto que tenemos es hexadecimal, hacemos fuerza bruta marcando la opción Output First y clickamos en Search.
En el mismo directorio donde tenemos el programa se genera un archivo llamado «XOR_enumeration.txt«, que contiene todos los resultados, echamos un vistazo y hemos tenido suerte.
Cargamos el crackme en Ollydbg y vamos a las «Referenced Strings«. Vemos una referencia muy interesante que se llama «checkkey«.
Pinchamos sobre ella y aparecemos aquí:
Vemos una referencia a «GetDlgItemTextA» y depués un Call también interesante, vamos a explorarlo.
Dentro del Call hay dos bucles, uno realiza una operación con nuestro serial (bucle nombre) y el otro comprueba nuestro serial con «3d34273130276a» dígito a dígito (bucle comprobación).
Bucle nombre se puede resumir así:
MOVSX EAX,BYTE PTR DS:[EBX] --> Dígito a EAX XOR EAX,55 --> EAX xor 55 ... CMP BYTE PTR DS:[EBX],0 --> ¿hemos acabado? JNZ SHORT 10001022 --> bucle LEA ECX,DWORD PTR SS:[EBP-20] --> ECX = nuestro serial xoreado
Bucle comprobación se podría resumir así:
MOV EDX,10006000 --> EDX = "3d34273130276a" ... MOV AL,BYTE PTR DS:[ECX] --> AL = 1ºdígito serial xoreado CMP AL,BYTE PTR DS:[ECX+EDX] --> AL = 1ºdígito de EDX? JNZ SHORT 1000105A --> Si no son iguales bad boy INC ECX TEST AL,AL JNZ SHORT 1000104A --> bucle
Ejemplo para «deurus».
Nombre: d e u r u s
Ascii hex: 64 65 75 72 75 73
XOR 55: 31 30 20 27 20 26
Serial correcto XOReado: 3d 34 27 31 30 27 6a
XOR 55: 68 61 72 64 65 72 3F
Valor ascii: h a r d e r ?
Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la solución en el decompilado y quizá por evocar recuerdos de tiempos pretéritos.
/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>
Detected compiler: GNU C++
*/
#include <defs.h>
//-------------------------------------------------------------------------
// Function declarations
__int64 (**init_proc())(void);
__int64 sub_400650(); // weak
// int printf(const char *format, ...);
// int puts(const char *s);
// void __noreturn exit(int status);
// size_t strlen(const char *s);
// __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD); weak
// int sprintf(char *s, const char *format, ...);
// __int64 ptrace(enum __ptrace_request request, ...);
// __int64 strtol(const char *nptr, char **endptr, int base);
// __int64 __isoc99_scanf(const char *, ...); weak
// int memcmp(const void *s1, const void *s2, size_t n);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void *sub_400730();
__int64 sub_400760();
void *sub_4007A0();
__int64 sub_4007D0();
void fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// __int64 _gmon_start__(void); weak
//-------------------------------------------------------------------------
// Data declarations
_UNKNOWN main;
_UNKNOWN init;
__int64 (__fastcall *funcs_400E29)() = &sub_4007D0; // weak
__int64 (__fastcall *off_601DF8)() = &sub_4007A0; // weak
__int64 (*qword_602010)(void) = NULL; // weak
char *off_602080 = "FLAG-%s\n"; // idb
char a7yq2hryrn5yJga[16] = "7Yq2hrYRn5Y`jga"; // weak
const char aO6uH[] = "(O6U,H\""; // idb
_UNKNOWN unk_6020B8; // weak
_UNKNOWN unk_6020C8; // weak
char byte_6020E0; // weak
char s1; // idb
char byte_602110[]; // weak
char byte_602120[33]; // weak
char byte_602141[7]; // idb
__int64 qword_602148; // weak
__int64 qword_602150; // weak
__int64 qword_602158; // weak
__int64 qword_602160; // weak
__int64 qword_602178; // weak
//----- (0000000000400630) ----------------------------------------------------
__int64 (**init_proc())(void)
{
__int64 (**result)(void); // rax
result = &_gmon_start__;
if ( &_gmon_start__ )
return (__int64 (**)(void))_gmon_start__();
return result;
}
// 6021D8: using guessed type __int64 _gmon_start__(void);
//----- (0000000000400650) ----------------------------------------------------
__int64 sub_400650()
{
return qword_602010();
}
// 400650: using guessed type __int64 sub_400650();
// 602010: using guessed type __int64 (*qword_602010)(void);
//----- (0000000000400700) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
__int64 v3; // rax
int v4; // esi
__int64 v5; // [rsp-8h] [rbp-8h] BYREF
char *retaddr; // [rsp+0h] [rbp+0h] BYREF
v4 = v5;
v5 = v3;
_libc_start_main((int (__fastcall *)(int, char **, char **))main, v4, &retaddr, (void (*)(void))init, fini, a3, &v5);
__halt();
}
// 400706: positive sp value 8 has been found
// 40070D: variable 'v3' is possibly undefined
//----- (0000000000400730) ----------------------------------------------------
void *sub_400730()
{
return &unk_6020C8;
}
//----- (0000000000400760) ----------------------------------------------------
__int64 sub_400760()
{
return 0LL;
}
//----- (00000000004007A0) ----------------------------------------------------
void *sub_4007A0()
{
void *result; // rax
if ( !byte_6020E0 )
{
result = sub_400730();
byte_6020E0 = 1;
}
return result;
}
// 6020E0: using guessed type char byte_6020E0;
//----- (00000000004007D0) ----------------------------------------------------
__int64 sub_4007D0()
{
return sub_400760();
}
//----- (00000000004007D7) ----------------------------------------------------
__int64 __fastcall main(int a1, char **a2, char **a3)
{
size_t v3; // rax
size_t v4; // rax
int i; // [rsp+1Ch] [rbp-24h]
int n; // [rsp+20h] [rbp-20h]
int m; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+28h] [rbp-18h]
int j; // [rsp+2Ch] [rbp-14h]
if ( ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1 )
goto LABEL_2;
if ( a1 > 4 )
{
qword_602148 = strtol(a2[1], 0LL, 10);
if ( qword_602148 )
{
qword_602150 = strtol(a2[2], 0LL, 10);
if ( qword_602150 )
{
qword_602158 = strtol(a2[3], 0LL, 10);
if ( qword_602158 )
{
qword_602160 = strtol(a2[4], 0LL, 10);
if ( qword_602160 )
{
if ( -24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
&& 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
&& 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
&& -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613 )
{
qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
sprintf(byte_602141, "%06x", qword_602178);
v4 = strlen(byte_602141);
MD5(byte_602141, v4, byte_602110);
for ( i = 0; i <= 15; ++i )
sprintf(&byte_602120[2 * i], "%02x", (unsigned __int8)byte_602110[i]);
printf(off_602080, byte_602120);
exit(0);
}
}
}
}
}
LABEL_2:
printf("password : ");
__isoc99_scanf("%s", &s1);
if ( strlen(&s1) > 0x10 )
{
puts("the password must be less than 16 character");
exit(1);
}
for ( j = 0; j < strlen(&s1); ++j )
*(&s1 + j) ^= 6u;
if ( !strcmp(&s1, a7yq2hryrn5yJga) )
{
v3 = strlen(&s1);
MD5(&s1, v3, byte_602110);
for ( k = 0; k <= 15; ++k )
sprintf(&byte_602120[2 * k], "%02x", (unsigned __int8)byte_602110[k]);
printf(off_602080, byte_602120);
exit(0);
}
puts("bad password!");
exit(0);
}
printf("password : ");
__isoc99_scanf("%s", &s1);
if ( strlen(&s1) > 0x10 )
{
puts("the password must be less than 16 character");
exit(1);
}
for ( m = 0; m < strlen(&s1); ++m )
{
*(&s1 + m) ^= 2u;
++*(&s1 + m);
*(&s1 + m) = ~*(&s1 + m);
}
if ( !memcmp(&s1, &unk_6020B8, 9uLL) )
{
for ( n = 0; n < strlen(aO6uH); n += 2 )
{
aO6uH[n] ^= 0x45u;
aO6uH[n + 1] ^= 0x26u;
}
puts(aO6uH);
}
else
{
puts("bad password!");
}
return 0LL;
}
// 4006A0: using guessed type __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD);
// 4006E0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 602148: using guessed type __int64 qword_602148;
// 602150: using guessed type __int64 qword_602150;
// 602158: using guessed type __int64 qword_602158;
// 602160: using guessed type __int64 qword_602160;
// 602178: using guessed type __int64 qword_602178;
//----- (0000000000400DE0) ----------------------------------------------------
void __fastcall init(unsigned int a1, __int64 a2, __int64 a3)
{
signed __int64 v3; // rbp
__int64 i; // rbx
v3 = &off_601DF8 - &funcs_400E29;
init_proc();
if ( v3 )
{
for ( i = 0LL; i != v3; ++i )
(*(&funcs_400E29 + i))();
}
}
// 601DF0: using guessed type __int64 (__fastcall *funcs_400E29)();
// 601DF8: using guessed type __int64 (__fastcall *off_601DF8)();
//----- (0000000000400E54) ----------------------------------------------------
void term_proc()
{
;
}
// nfuncs=33 queued=10 decompiled=10 lumina nreq=0 worse=0 better=0
// ALL OK, 10 function(s) have been successfully decompiled
Si la función ptrace retorna -1, significa que el programa está siendo depurado y redirige a LABEL_2.
if (ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1) {
goto LABEL_2;
}
El programa espera al menos 5 argumentos (nombre del programa y cuatro números enteros). Si se proporcionan los cuatro números enteros, se realizan los siguientes cálculos:
if (-24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
&& 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
&& 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
&& -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613)
Esto es un sistema de ecuaciones lineales mondo y lirondo que debe ser resuelto para encontrar los valores correctos de qword_602148, qword_602150, qword_602158 y qword_602160. Una vez resuelto el sistema de ecuaciones se realiza la operación:
qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
A continuación se pasa el resultado de la variable qword_602178 a hexadecimal y se genera su hash MD5.
Lo más rápido en esta ocasión es usar Python, pero esto se puede resolver hasta con lápiz y papel 😉
from sympy import symbols, Eq, solve
import hashlib
# Definir las variables
A, B, C, D = symbols('A B C D')
# Definir las ecuaciones
eq1 = Eq(-24*A - 18*B - 15*C - 12*D, -18393)
eq2 = Eq(9*C + 18*(A + B) - 9*D, 4419)
eq3 = Eq(4*C + 16*A + 12*B + 2*D, 7300)
eq4 = Eq(-6*(A + B) - 3*C - 11*D, -8613)
# Resolver el sistema de ecuaciones
solution = solve((eq1, eq2, eq3, eq4), (A, B, C, D))
# Verificar si se encontró una solución
if solution:
print("Solución encontrada:")
print(solution)
# Obtener los valores de A, B, C y D
A_val = solution[A]
B_val = solution[B]
C_val = solution[C]
D_val = solution[D]
# Mostrar los valores encontrados
print(f"A = {A_val}")
print(f"B = {B_val}")
print(f"C = {C_val}")
print(f"D = {D_val}")
# Calcular qword_602178
qword_602178 = C_val + B_val * A_val - D_val
qword_602178 = int(qword_602178) # Convertir a entero de Python
print(f"qword_602178 = {qword_602178}")
# Convertir qword_602178 a una cadena en formato hexadecimal
byte_602141 = f"{qword_602178:06x}"
print(f"byte_602141 (hex) = {byte_602141}")
# Calcular el MD5 de la cadena
md5_hash = hashlib.md5(byte_602141.encode()).hexdigest()
print(f"MD5 hash = {md5_hash}")
# Generar la flag
flag = f"FLAG-{md5_hash}"
print(f"Flag = {flag}")
else:
print("No se encontró una solución.")
Al ejecutar el script veremos algo como esto:
Solución encontrada:
{A: 227, B: 115, C: 317, D: 510}
A = 227
B = 115
C = 317
D = 510
qword_602178 = 25912
byte_602141 (hex) = 006538
MD5 hash = 21a84f2c7c7fd432edf1686215db....
Flag = FLAG-21a84f2c7c7fd432edf1686215db....
Hace tiempo que me aficioné a los retos de Hacking y Cracking, y si bien la mayoría de ellos consisten en desencriptar una clave o realizar ingeniería inversa sobre un ejecutable, también los hay sobre programación pura y dura.
En esta ocasión se nos proporciona un código «muestra» parecido a PHP o C++ y tenemos que ingeniarnoslas para mejorarlo y ganar a la máquina.
El objetivo de esta misión es ganar a Tr0n en su propio juego: las carreras de motos. Se te proporcionará un programa (código) funcional para que veas como se controla el vehiculo. Usando tu inteligencia, tendrás que entender su uso y mejorarlo, ya que no es lo suficientemente bueno como para ganar a Tr0n. Tr0n lleva ya bastante tiempo en la parrilla de juegos y es bastante habilidoso 🙂
Cuando venzas a Tr0n un mínimo de 5 veces consecutivas, se te dará por superada esta prueba.
Buena suerte!!!
[ Available functions / Funciones disponibles ]
direction() returns current direction, change to a new one with direction([newdir])
getX(), getY() returns X and Y coordinates
collisionDistance() | collisionDistance([anydir]) returns the distance until collision
Note: parameters [*dir] can be empty or one of this values: UP DOWN LEFT or RIGHT[ Constants / Constantes ]
UP DOWN LEFT RIGHT MAX_X MAX_Y[ Rules / Reglas ]
Try to survive driving your bike and … / Intenta sobrevivir conduciendo tu moto y…
Don’t cross any line / No cruces ninguna línea
or crash with the corners! / o choques con las esquinas![ Mission / Mision ]
Use well this controller and beat Tr0n 5 consecutive times to score in this game
Usa bien este controlador y vence a Tr0n 5 veces consecutivas para puntuar en este juego
Nada más comenzar vemos que hemos perdido nuestra primera partida con el siguiente código:
function controller(playerController $c){
if($c->direction()==UP && $c->getY()<10){
if(rand(0,1)==0) $c->direction(LEFT);
else $c->direction(RIGHT);
goto done;
}
if($c->direction()==DOWN && MAX_Y-$c->getY()<10){
if(rand(0,1)==0) $c->direction(LEFT);
else $c->direction(RIGHT);
goto done;
}
if($c->direction()==LEFT && $c->getX()<10){
if(rand(0,1)==0) $c->direction(UP);
else $c->direction(DOWN);
goto done;
}
if($c->direction()==RIGHT && MAX_X-$c->getX()<10){
if(rand(0,1)==0) $c->direction(UP);
else $c->direction(DOWN);
}
done:
}
Nosotros somos el AZUL y la máquina es el VERDE.
Lo primero que tenemos que modificar son las distancias de las coordenadas que estan puestas en «<10» al mínimo, que sería «<2«. También sustituir la aleatoriedad «rand(0,1)==0» por algo más útil y comenzar a usar la función «collisionDistance()«.
Como podéis observar en el código inferior, usamos la función «collisionDistance()» para detectar cuando estamos a punto de chocar «collisionDistance() ==1» y para detectar a que lado nos conviene más girar en función de donde podamos recorrer más distancia «if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT); else $c->direction(RIGHT);«.
if($c->direction()==UP && $c->getY()==1 && $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
else $c->direction(RIGHT);
}
if($c->direction()==DOWN && MAX_Y-$c->getY()<2 || $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
else $c->direction(RIGHT);
}
if($c->direction()==LEFT && $c->getX()==1 && $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) >2)
$c->direction(UP);
else
$c->direction(DOWN);
}
if($c->direction()==RIGHT && MAX_X-$c->getX()<2 || $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) >2) $c->direction(UP);
else $c->direction(DOWN);
}
El código anterior de por sí no nos resuelve mucho si no afinamos un poco más, comprobando todos las posibles colisiones y tomando la dirección correcta en función de la mayor distancia a recorrer.
if($c->collisionDistance([UP])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
$c->direction(LEFT);
else
$c->direction(RIGHT);
}
if($c->collisionDistance([DOWN])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
$c->direction(LEFT);
else
$c->direction(RIGHT);
}
if($c->collisionDistance([RIGHT])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
$c->direction(UP);
else
$c->direction(DOWN);
}
if($c->collisionDistance([LEFT])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
$c->direction(UP);
else
$c->direction(DOWN);
}
El código que utilicé yo para ganar a Tron es el siguiente:
function controller(playerController $c){
uno:
if($c->direction()==UP && $c->getY()==1 && $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
else $c->direction(RIGHT);
}
if($c->direction()==DOWN && MAX_Y-$c->getY()<2 || $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
else $c->direction(RIGHT);
}
if($c->direction()==LEFT && $c->getX()==1 && $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) >2)
$c->direction(UP);
else
$c->direction(DOWN);
}
if($c->direction()==RIGHT && MAX_X-$c->getX()<2 || $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) >2) $c->direction(UP);
else $c->direction(DOWN);
}
dos:
if($c->collisionDistance([UP])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
$c->direction(LEFT);
else
$c->direction(RIGHT);
}
if($c->collisionDistance([DOWN])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
$c->direction(LEFT);
else
$c->direction(RIGHT);
}
if($c->collisionDistance([RIGHT])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
$c->direction(UP);
else
$c->direction(DOWN);
}
if($c->collisionDistance([LEFT])==1 || $c->collisionDistance() ==1){
if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
$c->direction(UP);
else
$c->direction(DOWN);
}
done:
}
Mis jugadas ganadoras:
El código no es infalible ya que como comprabaréis vosotros mismos, no se puede ganar siempre por el mero hecho de la aleatoriedad y de la suerte. Cuando dispongais de un código decente, ejecutarlo varias veces para estar seguros antes de desecharlo.
Como se suele decir, la banca siempre gana, y en este caso no iba a ser menos y es que en caso de empate ¡la banca gana!
Por último deciros que podéis utilizar el código ya que la web detecta los códigos ganadores para que no se repitan.
En una entrada anterior sobre cómo Expediente X abordó la tecnología de vanguardia, comenté que dedicaría un espacio a esos tres personajes tan peculiares y entrañables que, desde el segundo plano, se ganaron un hueco en el corazón de los seguidores de la serie: los Pistoleros Solitarios. Pues bien, ha llegado el momento.
Estos tres tipos —John Fitzgerald Byers, Melvin Frohike y Richard “Ringo” Langly— no necesitaban armas ni placas del FBI. Su poder estaba en los teclados, los cables enredados y los monitores de tubo que parpadeaban en un sótano lleno de conspiraciones y café frío. Eran los outsiders de Expediente X, tres hackers con alma de periodistas que luchaban por algo tan simple y tan enorme como la verdad.
Su primera aparición fue en E.B.E. (temporada 1), casi como un alivio cómico: tres frikis que ayudaban a Mulder a rastrear información sobre ovnis. Pero pronto quedó claro que había algo especial en ellos. No solo eran fuente de datos, sino conciencia crítica en un mundo plagado de mentiras digitales y gobiernos con demasiados secretos. Con el tiempo se convirtieron en aliados imprescindibles de Mulder y Scully, y también en el reflejo más humano de lo que significa ser hacker: curiosos, testarudos, torpes a veces, pero con un sentido moral inquebrantable.
Byers era el idealista, el que aún creía en la decencia y en las instituciones (al menos en teoría). Frohike, el cínico veterano con corazón de oro, siempre dispuesto a arriesgarse por una buena causa… o por impresionar a Scully. Y Langly, el genio rebelde que parecía vivir en permanente conversación con su módem de 56 k. Juntos formaban un trío excéntrico, pero perfectamente equilibrado.
Mientras Mulder y Scully perseguían abducciones y virus extraterrestres, los pistoleros combatían en otra trinchera: la digital. Hackeaban redes gubernamentales, interceptaban comunicaciones cifradas y desmantelaban cortafuegos que, en los noventa, parecían pura ciencia ficción. Lo suyo no era la acción física, sino la resistencia informativa. Y aunque muchas veces eran el chiste del capítulo, también representaban algo muy real: la gente corriente que lucha contra el poder desde el conocimiento.
Su lema no declarado podría haber sido el clásico “la información quiere ser libre”, y en eso se mantuvieron firmes hasta el final. Si había que elegir entre la seguridad o la verdad, ellos siempre elegían la verdad, aunque les costara caro.
| Temporada | Episodio | Título | Comentario |
|---|---|---|---|
| 1 | 17 | E.B.E. | Primera aparición de los pistoleros. |
| 2 | 3 | Blood | Manipulación de dispositivos y mensajes ocultos. También control mental a través de la tecnología. |
| 2 | 25 | Anasazi | Un hacker roba archivos clasificados. Se tratan temas como el cifrado y filtración de datos del gobierno. |
| 3 | 15 | Apocrypha | Acceso a bases de datos secretas y descifrado de archivos comprometidos. |
| 3 | 23 | Wetwired | Manipulación de señales televisivas. |
| 4 | 14 | Memento Mori | Infiltración digital en sistemas médicos y vigilancia biotecnológica. |
| 5 | 1 | Redux | Robo y manipulación de pruebas digitales. |
| 5 | 3 | Unusual Suspects | Orígenes de los pistoleros: intrusión, cifrado y espíritu hacker de los noventa. |
| 5 | 11 | Kill Switch | IA autónoma y malware inteligente. |
| 6 | 20 | Three of a Kind | Hacking social, suplantación y síntesis de voz para infiltración corporativa. |
| 7 | 13 | First Person Shooter | Hackeo de entornos virtuales y brechas de seguridad en sistemas de realidad aumentada. |
| 9 | 15 | Jump the Shark | Su sacrificio final: bloqueo de una amenaza biológica, ética hacker y altruismo extremo. |
| 11 | 2 | This | Langly como conciencia digital en un servidor. Debate sobre IA y trascendencia del código. |
El final de los pistoleros fue tan inesperado como heroico. En el episodio “Jump the Shark” de la novena temporada, descubren un complot bioterrorista que amenaza con liberar un virus mortal. No hay tiempo para avisar a nadie, ni margen para escapar. Así que, fieles a su estilo, deciden sacrificarse para salvar a otros. Sellan el laboratorio desde dentro, sabiendo que no volverán a salir.
Lo reconozco, este desenlace mi cogió completamente por sorpresa. No hay épica de Hollywood, ni música grandilocuente. Solo tres hombres anónimos haciendo lo correcto. Mueren juntos, sin reconocimiento, sin medallas, pero con la serenidad de quienes saben que su causa era justa. Y en ese silencio final, Expediente X nos recordó algo que las grandes historias suelen olvidar: que los verdaderos héroes a veces no llevan traje ni pistola, solo convicción.
Años después, Mulder vuelve a verlos —o cree verlos— en The Truth. Ya no están en este mundo, pero siguen a su lado, como fantasmas digitales de la conciencia hacker. Es un homenaje discreto a quienes siempre pelearon desde las sombras por liberar la verdad.
Para cerrar el círculo, Langly reaparece de forma inesperada en la temporada 11, dentro del episodio This. Su mente, o más bien su copia digital, sobrevive atrapada en un servidor, reclamando ser liberada. Es el epílogo perfecto: el hacker que muere físicamente, pero cuya conciencia sigue inmortal. Una vez más me volvió a sorprender Chris Carter con este homenaje.
Me gusta pensar que los pistoleros solitarios representaban algo más que tres hackers secundarios en una serie de los noventa. Fueron el reflejo de una época en la que creíamos que la tecnología podía liberar al ser humano, antes de que las redes sociales y la hiperconectividad lo diluyeran todo. Byers, Frohike y Langly no luchaban por fama ni por dinero: luchaban por entender el sistema para exponerlo, por esa curiosidad genuina que hoy apenas sobrevive entre líneas de código y algoritmos opacos. Quizá por eso seguimos recordándolos y mola tanto volver a ver los capítulos. Porque, de algún modo, todos los que amamos el conocimiento libre llevamos dentro un pequeño pistolero solitario, buscando la verdad entre los bits.
El crackme que analizamos hoy está hecho en ensamblador y si bien su dificultad es baja, la creación del keygen es un poco liosa. Al keygen que veremos más adelante, le he dado cierta aleatoriedad para que quede más elegante.
El crackme comprueba el serial en función de un identificador de 4 dígitos que el mismo crackme genera.
Coje nuestro serial mediante la función GetDlgItemTextA.
004010D3 |. 68 FF000000 PUSH 0FF ; /MaxCount = 255. 004010D8 |. 68 40324000 PUSH OFFSET 00403240 ; |String 004010DD |. 68 EC030000 PUSH 3EC ; |ItemID = 1004. 004010E2 |. FF75 08 PUSH DWORD PTR SS:[ARG.1] ; |hDialog => [ARG.1] 004010E5 |. E8 6E010000 CALL <JMP.&user32.GetDlgItemTextA> ; \USER32.GetDlgItemTextA 004010EA |. 68 40324000 PUSH OFFSET 00403240 ; /String 004010EF |. E8 52010000 CALL <JMP.&kernel32.lstrlenA> ; \KERNEL32.lstrlen 004010F4 |. A3 47334000 MOV DWORD PTR DS:[403347],EAX 004010F9 |. 33DB XOR EBX,EBX 004010FB |. 33C0 XOR EAX,EAX 004010FD |. EB 54 JMP SHORT 00401153
Comprueba que nuestro serial esté formado por números (30h – 39h), letras de la A a la F (41h – 46h) y el guión (2Dh), es decir, el alfabeto hexadecimal más el guión. Si hay algún dígito indeseado nos tira fuera.
004010FF |> 8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240] 00401105 |. 3C 2D |CMP AL,2D 00401107 |. 74 40 |JE SHORT 00401149 00401109 |. 3C 30 |CMP AL,30 0040110B |. 74 3C |JE SHORT 00401149 0040110D |. 3C 31 |CMP AL,31 0040110F |. 74 38 |JE SHORT 00401149 00401111 |. 3C 32 |CMP AL,32 00401113 |. 74 34 |JE SHORT 00401149 00401115 |. 3C 33 |CMP AL,33 00401117 |. 74 30 |JE SHORT 00401149 00401119 |. 3C 34 |CMP AL,34 0040111B |. 74 2C |JE SHORT 00401149 0040111D |. 3C 35 |CMP AL,35 0040111F |. 74 28 |JE SHORT 00401149 00401121 |. 3C 36 |CMP AL,36 00401123 |. 74 24 |JE SHORT 00401149 00401125 |. 3C 37 |CMP AL,37 00401127 |. 74 20 |JE SHORT 00401149 00401129 |. 3C 38 |CMP AL,38 0040112B |. 74 1C |JE SHORT 00401149 0040112D |. 3C 39 |CMP AL,39 0040112F |. 74 18 |JE SHORT 00401149 00401131 |. 3C 41 |CMP AL,41 00401133 |. 74 14 |JE SHORT 00401149 00401135 |. 3C 42 |CMP AL,42 00401137 |. 74 10 |JE SHORT 00401149 00401139 |. 3C 43 |CMP AL,43 0040113B |. 74 0C |JE SHORT 00401149 0040113D |. 3C 44 |CMP AL,44 0040113F |. 74 08 |JE SHORT 00401149 00401141 |. 3C 45 |CMP AL,45 00401143 |. 74 04 |JE SHORT 00401149 00401145 |. 3C 46 |CMP AL,46 00401147 |. 75 07 |JNE SHORT 00401150 00401149 |> 8305 4B334000 |ADD DWORD PTR DS:[40334B],1 00401150 |> 83C3 01 |ADD EBX,1 00401153 |> 3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347] 00401159 |.^ 76 A4 \JBE SHORT 004010FF 0040115B |. A1 47334000 MOV EAX,DWORD PTR DS:[403347] 00401160 |. 3905 4B334000 CMP DWORD PTR DS:[40334B],EAX ; si no coincide el tamaño del serial con el 00401166 |. 0F85 94000000 JNE 00401200 ; contador nos tira fuera
La comprobación del serial la realiza sumando el valor ascii del primer dígito al valor ascii del tercero y sucesivos y a continuación restando la suma anterior al ID. Cuando finalice la comprobación de todos los dígitos del serial, el restador tiene que ser cero, de lo contrario nos tira fuera. Si el ID es cero también nos tira fuera.
Ejemplo (base 10)para ID = 4011 y SERIAL: 1-23456
0040116C |. 33C0 XOR EAX,EAX 0040116E |. BB 02000000 MOV EBX,2 00401173 |. A0 40324000 MOV AL,BYTE PTR DS:[403240] 00401178 |. A3 43334000 MOV DWORD PTR DS:[403343],EAX 0040117D |. EB 13 JMP SHORT 00401192 0040117F |> 8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240] ; Coje el dígito correspondiente 00401185 |. 0305 43334000 |ADD EAX,DWORD PTR DS:[403343] ; 1ºdig + dig 0040118B |. 2905 4F334000 |SUB DWORD PTR DS:[40334F],EAX ; ID - (1ºdig + dig) 00401191 |. 43 |INC EBX 00401192 |> 3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347] 00401198 |.^ 72 E5 \JB SHORT 0040117F 0040119A |. 833D 4F334000 CMP DWORD PTR DS:[40334F],0 ; CHECK RESTADOR SEA = 0 004011A1 |. 75 49 JNE SHORT 004011EC 004011A3 |. 833D 3F334000 CMP DWORD PTR DS:[40333F],0 ; CHECK ID <> 0 004011AA |. 74 40 JE SHORT 004011EC 004011AC |. FF35 3F334000 PUSH DWORD PTR DS:[40333F] ; /<%d> = 0 004011B2 |. 68 00304000 PUSH OFFSET 00403000 ; |Format = "REGISTRADO CON ID:%d" 004011B7 |. 68 40324000 PUSH OFFSET 00403240 ; |Buf 004011BC |. E8 A9000000 CALL <JMP.&user32.wsprintfA> ; \USER32.wsprintfA
Como veis, el resultado de ir restando todos los dígitos de nuestro serial con la ID debe ser cero para que el serial sea correcto.
Lo primero que se me ocurre para obtener una solución directa es buscar una combinación de dígito + dígito que sea múltiplo del ID. Para ello podemos usar la función módulo. La función módulo lo que hace es darnos el resto de la división de dos números, de modo que si el resto es cero los números son múltiplos. Para ello debemos cruzar todos los números y letras hasta encontrar los dígitos múltiplos del ID. Un serial de este primer tipo quedaría algo así como 1-FFFFFFFFFFFFFFFFFF ya que como el primer dígito es fijo el otro se repetirá tanta veces como sea necesario para hacer que el ID sea cero.
Con nuestro reducido alfabeto, cabe la posibilidad de que no encontremos una combinación válida, por lo que tendremos que pensar en un plan B. El plan B que se me ocurre a mi es intentar forzar el plan A restando caracteres aleatorios al ID y volviendo a comprobar si encontramos múltiplos del nuevo ID. Un serial de este tipo quedaría más elegante, por ejemplo 3-A6D53B628BBBBB.
Os dejo unos cuantos números de serie.
'Keygen for Flamer's asm keygenme
Dim id As Integer
Dim serial As String
Dim tmp, tmp2, na, nb As Integer
Dim alfabeto As Integer() = New Integer() {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70}
Dim r As Random = New Random
'Button generate
Private Sub btngen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btngen.Click
ini:
If txtid.TextLength <> 4 Then GoTo Mal
id = txtid.Text
txtdebug.Text = ""
na = alfabeto(r.Next(1, 16))
serial = Chr(na) & "-"
tmp = id
For i = 0 To alfabeto.Length - 1
For y = 0 To alfabeto.Length - 1
'Solución directa
If id Mod (alfabeto(i) + alfabeto(y)) = 0 Then
tmp = id / (alfabeto(i) + alfabeto(y))
txtserial.Text = Chr(alfabeto(i)) & "-"
For z = 0 To tmp - 1
txtserial.Text &= Chr(alfabeto(y))
Next
GoTo fuera
End If
'Indirecta con aleatoriedad
nb = alfabeto(r.Next(1, 16))
tmp = tmp - (na + nb)
serial &= Chr(nb)
If tmp Mod (na + nb) = 0 Then
tmp2 = tmp / (na + nb)
For z = 0 To tmp2 - 1
serial &= Chr(nb)
Next
txtserial.Text = serial
GoTo fuera
End If
If tmp < 0 Then
GoTo ini
Else
txtdebug.Text &= tmp & " "
End If
Next
Next
Mal:
txtserial.Text = "¿id?"
fuera:
End Sub
Me doy cuenta que en el keygen no he utilizado el guión, pero no pasa nada, se lo dejo al lector como curiosidad.
Un día cualquiera se te ocurre comprarte un disco duro de red NAS para centralizar todo tu contenido multimedia. Lo conectas y todo va genial, pero de repente vas a copiar unos cuantos gigas de fotos y te encuentras con que la operación va a tardar días. En ese mismo instante te planteas sacar el máximo provecho a tu red doméstica y la solución se llama gigabit.
Esta guía va dirigida a todo el mundo que esté pensando en hacer o mejorar la red LAN doméstica. Si eres un amante del WIFI, olvídate de esto, ya que para conseguir altas velocidades se necesita cablear la casa. Además, de lo que trata esta guía es de que se conecte un ordenador portátil o sobremesa de la forma más rápida posible al disco duro de red.
Probablemente dispongas de un Modem / Router proporcionado por tu compañia y que seguramente no sea gigabit (10/100/1000), esto es lo primero que debes comprobar. Busca tu modelo en internet y cerciorate.
También necesitas que la tarjeta de red del portátil o sobremesa sean gigabit, en este caso lo más probable es que lo sean pero asegúrate.
Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.
Si el nuestro no es gigabit existen soluciones económicas como el TP-Link TL-WR1043ND que lo tenemos por 44€ en pccomponentes. Os recomiendo esta tienda por rapidez, seriedad y no abusan con los gastos de envío.
En caso de que los cuatro puertos que vienen con el router se nos queden cortos, la solución más economica y acertada es un Switch ethernet gigabit como el TP-LINK TL-SG1005D que lo tenemos por 16€. Este dispositivo es una maravilla ya que nos brinda 4 puertos más y no requiere configuración alguna.
Son muy económicas, las puedes encontrar por 10€-15€ en cualquier tienda especializada. Ejemplo PCI. Ejemplo PCI-e. Video instalación de una tarjeta de red.
100m de cable UTP categoría 6 viene a costar sobre unos 42€.
Para interconexionado de equipos recomiento estos de 50cm por 1,5€. Para conexión del pc tienes otras larguras más apropiadas. También podéis haceros vosotros los cables con lo sobrante de la bobina, para ello necesitaréis una crimpadora y terminales rj45.
Esto depende de tu instalación y la gama que elijas. En mi caso utilizo tomas Niessen que solo el conector vale 16€, pero tienes tomas más económicas. De superficie por 2,75€ y empotrable por 8,25€.
Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.
Esto es una recomendación personal ya que la elección puede variar en función de las necesidades de almacenamiento y conexiones. Una solución barata y con espacio suficiente para uso doméstico es el disco WD My Cloud 3TB que lo podeis adquirir por 159€.
Esto puede variar en función de los componentes que elijas comprar pero el coste oscilará entre 250 y 350€, algo bastante asequible para centralizar contenido multimedia. Digo asequible por que la mitad del presupuesto se lo lleva el disco de red, los componentes son más bien baratos.
En mi esquema disponemos del router proporcionado por el proveedor de internet que en mi caso sí es gigabit pero que solo lo utilizo para dar internet al router neutro.El router neutro junto con el switch me proporcionan 8 puertos gigabit. El router neutro además gestiona el wifi de la casa, pero en el mejor de los casos (Wifi n) estos dispositivos solo podrán mover datos a 300mbps. Utilizo como media center mis amadas Raspberry Pi que en este caso no se benefician de la velocidad ya que disponen de conexión 10/100.
Lo primero a conectar es el router neutro y en este caso, TP-Link te lo pone fácil si no te defiendes muy bien con las redes, ya que proporciona un CD que se encarga de guiarte paso a paso. Lo más importante es la asignación de la IP privada, por defecto es 192.168.2.1 y a no ser que el router de la compañia tenga esa misma IP lo podéis dejar como está.
Para configurar el disco de red normalmente viene un CD para ayudar al usuario novel. Lo único que tenéis que tener en cuenta es que la IP debe estar en consonancia con la del router neutro, si el router neutro es 192.168.2.1 al disco NAS podéis asignarle 192.168.2.150. Para más información aquí tenéis la guía de instalación.
Podéis usar cable normal, también llamado conexión Pin a Pin ó 1:1, para toda la instalación ya que los dispositivos de hoy en día aceptan cualquier cable y resuelven internamente en función del cable conectado. Pero si nos ponemos quisquillosos, para conectar elementos pasivos entre sí (router a switch, etc) se utiliza cable normal 1:1. Para conectar elementos activos (PC a router/switch) cable cruzado.
Mi consejo es que uses el standard EIA/TIA 568B tanto en la conexión de las cajas como en la creación de los cables.
Cada roseta o toma en su interior tiene definido el orden que debes seguir para conectar los cables según el standard A o B, esto es una aproximación y puede no coincidir con tu toma.
Si estás seguro de que las rosetas están bien conectadas, que has usado los cables correctos, que todos los dispositivos son gigabit y tu pc hace de las suyas, quizás debas de forzar a tu tarjeta de red a trabajar en modo gigabit ó 100 full duplex ó 100FD. Esto es debido a que el driver de la tarjeta de red por defecto viene con la opción de «autonegociación» activada y a veces necesita que le «obligues» a trabajar en gigabit.
En cada tarjeta de red puede venir diferente, yo os muestro mi caso desde windows 7:
Diríjete a Inicio > Panel de control > Ver el estado y las tareas de red > conexión de area local
En mi caso marca 1 Gbps pero si estais teniendo problemas os marcará 100 mbps. A continuación pulsa Propiedades.
Pulsa Configurar.
En la pestaña Opciones avanzadas busca la opción de la velocidad, en mi caso «Speed/duplex settings» y selecciona 100 mb Full Duplex. De este modo le forzais a la tarjeta de red a trabajar en modo gigabit. Si no lo consiguiera trabajará en el modo que pueda pero no os dejará sin conexión.
Soy consciente de que me he dejado muchas cosas en el tintero pero mi pretensión es que el lector de un vistazo rápido tenga una idea clara de lo que necesita para lograr una red decente en casa.
Recién rescatados del inframundo que es mi disco duro, os traigo un paquete de seis crackmes facilones para vuestro uso y disfrute. Desgraciadamente ya no está en activo la web de retos de donde los saqué así que os los dejo en descargas.
Los cuatro primero están realizados en Dev-C++ 4.9.9.2 siendo de estilo consola de comandos. Los dos restantes compilados con MingWin32 GCC 3.x carecen de GUI y vamos, que no se han esmerado mucho en darles forma.
No cuesta mucho dar con el código interesante mediante las referencias de texto. En Ollydbg clic derecho sobre el código y Search for > All referenced text strings.
004012E1 |. 8845 E8 MOV BYTE PTR SS:[EBP-18],AL ; |||| 004012E4 |. C70424 11304000 MOV DWORD PTR SS:[ESP],level1.00403011 ; ||||ASCII "Input Serial: " 004012EB |. E8 C0050000 CALL <JMP.&msvcrt.printf> ; |||\printf 004012F0 |. 8D45 C8 LEA EAX,[LOCAL.14] ; ||| 004012F3 |. 894424 04 MOV DWORD PTR SS:[ESP+4],EAX ; ||| 004012F7 |. C70424 20304000 MOV DWORD PTR SS:[ESP],level1.00403020 ; |||ASCII "%s" 004012FE |. E8 9D050000 CALL <JMP.&msvcrt.scanf> ; ||\scanf 00401303 |. 8D45 D8 LEA EAX,[LOCAL.10] ; || 00401306 |. 8D55 C8 LEA EDX,[LOCAL.14] ; || 00401309 |. 894424 04 MOV DWORD PTR SS:[ESP+4],EAX ; || 0040130D |. 891424 MOV DWORD PTR SS:[ESP],EDX ; ||level1.00403022 00401310 |. E8 7B050000 CALL <JMP.&msvcrt.strcmp> ; |\strcmp 00401315 |. 8945 C4 MOV [LOCAL.15],EAX ; | 00401318 |. 837D C4 00 CMP [LOCAL.15],0 ; | 0040131C |. 75 0E JNZ SHORT level1.0040132C ; | 0040131E |. C70424 23304000 MOV DWORD PTR SS:[ESP],level1.00403023 ; |ASCII "Well done. \n" 00401325 |. E8 86050000 CALL <JMP.&msvcrt.printf> ; \printf 0040132A |. EB 0C JMP SHORT level1.00401338 0040132C |> C70424 30304000 MOV DWORD PTR SS:[ESP],level1.00403030 ; |ASCII "Wrong. \n" 00401333 |. E8 78050000 CALL <JMP.&msvcrt.printf> ; \printf 00401338 |> C70424 39304000 MOV DWORD PTR SS:[ESP],level1.00403039 ; |ASCII "PAUSE" 0040133F |. E8 3C050000 CALL <JMP.&msvcrt.system> ; \system 00401344 |. B8 00000000 MOV EAX,0 00401349 |. C9 LEAVE 0040134A \. C3 RETN
La madre del cordero está en la dirección 401310 que es donde se lleva a cabo la función de comparación strcmp.
756296A0 msvcrt.strcmp 8B5424 04 MOV EDX,DWORD PTR SS:[ESP+4] 756296A4 8B4C24 08 MOV ECX,DWORD PTR SS:[ESP+8] 756296A8 F7C2 03000000 TEST EDX,3 ; 0-3 = 4 bucles. Divide la comprobación en 4 bloques 756296AE 75 3C JNZ SHORT msvcrt.756296EC ; salta si hemos terminado los 4 bucles 756296B0 > 8B02 MOV EAX,DWORD PTR DS:[EDX] ; coge 4 caracteres del serial (INICIO BUCLE) 756296B2 3A01 CMP AL,BYTE PTR DS:[ECX] ; compara el 1º/5º/9º/13º dígito en función del bucle 756296B4 75 2E JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296B6 0AC0 OR AL,AL 756296B8 74 26 JE SHORT msvcrt.756296E0 756296BA 3A61 01 CMP AH,BYTE PTR DS:[ECX+1] ; compara el 2º/6º/10º/14º dígito en función del bucle 756296BD 75 25 JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296BF 0AE4 OR AH,AH 756296C1 74 1D JE SHORT msvcrt.756296E0 756296C3 C1E8 10 SHR EAX,10 756296C6 3A41 02 CMP AL,BYTE PTR DS:[ECX+2] ; compara el 3º/7º/11º/15º dígito en función del bucle 756296C9 75 19 JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296CB 0AC0 OR AL,AL 756296CD 74 11 JE SHORT msvcrt.756296E0 756296CF 3A61 03 CMP AH,BYTE PTR DS:[ECX+3] ; compara el 4º/8º/12º/16º dígito en función del bucle 756296D2 75 10 JNZ SHORT msvcrt.756296E4 ; salto a zona mala 756296D4 83C1 04 ADD ECX,4 756296D7 83C2 04 ADD EDX,4 756296DA 0AE4 OR AH,AH 756296DC ^ 75 D2 JNZ SHORT msvcrt.756296B0 ; Si no hemos terminado... 756296DE 8BFF MOV EDI,EDI 756296E0 33C0 XOR EAX,EAX ; EAX = 0 que es lo deseado 756296E2 C3 RETN ; salimos de la función superando la comprobación 756296E3 90 NOP 756296E4 1BC0 SBB EAX,EAX ; Zona mala 756296E6 D1E0 SHL EAX,1 756296E8 83C0 01 ADD EAX,1 ; EAX = 1 implica bad boy 756296EB C3 RETN ; salimos de la función
Si atendemos al volcado vemos el serial bueno Kcgcv8LsmV3nizfJ.
0060FEF0 31 32 33 34 35 36 37 38 39 30 00 75 40 19 18 00 1234567890.u@. 0060FF00 4B 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A Kcgcv8LsmV3nizfJ
Curiosamente, si introducimos el serial bueno el crackme no lo acepta. Fijándome en la comprobación veo que al introducir un serial de 16 caracteres inserta un carácter nulo (0x00) alterando el serial correcto y falseando la comprobación.
0060FEF0 4B 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A Kcgcv8LsmV3nizfJ 0060FF00 00 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A .cgcv8LsmV3nizfJ
Ahora ya no podemos comprobarlo pero recuerdo que la web consideraba válido el serial Kcgcv8LsmV3nizfJ, por lo que considero lo anteriormente citado un bug o un intento de despiste del autor.
Es exactamente igual que el anterior cambiando el serial por 6LPw3vDYja9KrT2V.
La comprobación del serial es igual a las dos anteriores pero añade una función intermedia que suma 0xD a cada carácter de nuestro serial
00401355 |. A1 03304000 MOV EAX,DWORD PTR DS:[403003] ; || 0040135A |. 8945 E8 MOV [LOCAL.6],EAX ; || 0040135D |. A1 07304000 MOV EAX,DWORD PTR DS:[403007] ; || 00401362 |. 8945 EC MOV [LOCAL.5],EAX ; || 00401365 |. A1 0B304000 MOV EAX,DWORD PTR DS:[40300B] ; || 0040136A |. 8945 F0 MOV [LOCAL.4],EAX ; || 0040136D |. A1 0F304000 MOV EAX,DWORD PTR DS:[40300F] ; || 00401372 |. 8945 F4 MOV [LOCAL.3],EAX ; || 00401375 |. C70424 13304000 MOV DWORD PTR SS:[ESP],level3.00403013 ; ||ASCII "Input Serial: " 0040137C |. E8 CF050000 CALL <JMP.&msvcrt.printf> ; |\printf 00401381 |. 8D45 D8 LEA EAX,[LOCAL.10] ; | 00401384 |. 894424 04 MOV DWORD PTR SS:[ESP+4],EAX ; | 00401388 |. C70424 00304000 MOV DWORD PTR SS:[ESP],level3.00403000 ; |ASCII "%s" 0040138F |. E8 AC050000 CALL <JMP.&msvcrt.scanf> ; \scanf 00401394 |. 8D5D E8 LEA EBX,[LOCAL.6] 00401397 |. 8D45 D8 LEA EAX,[LOCAL.10] 0040139A |. 890424 MOV DWORD PTR SS:[ESP],EAX 0040139D |. E8 EEFEFFFF CALL level3.00401290 ; NUEVA FUNCIÓN SUMA 004013A2 |. 895C24 04 MOV DWORD PTR SS:[ESP+4],EBX ; || 004013A6 |. 890424 MOV DWORD PTR SS:[ESP],EAX ; || 004013A9 |. E8 82050000 CALL <JMP.&msvcrt.strcmp> ; |\strcmp 004013AE |. 8945 D4 MOV [LOCAL.11],EAX ; | 004013B1 |. 837D D4 00 CMP [LOCAL.11],0 ; | 004013B5 |. 75 0E JNZ SHORT level3.004013C5 ; | 004013B7 |. C70424 22304000 MOV DWORD PTR SS:[ESP],level3.00403022 ; |ASCII "Well done." 004013BE |. E8 8D050000 CALL <JMP.&msvcrt.printf> ; \printf 004013C3 |. EB 0C JMP SHORT level3.004013D1 004013C5 |> C70424 2D304000 MOV DWORD PTR SS:[ESP],level3.0040302D ; |ASCII "Wrong. \n" 004013CC |. E8 7F050000 CALL <JMP.&msvcrt.printf> ; \printf 004013D1 |> C70424 36304000 MOV DWORD PTR SS:[ESP],level3.00403036 ; |ASCII "PAUSE" 004013D8 |. E8 43050000 CALL <JMP.&msvcrt.system> ; \system 004013DD |. B8 00000000 MOV EAX,0 004013E2 |. 8B5D FC MOV EBX,[LOCAL.1] 004013E5 |. C9 LEAVE 004013E6 \. C3 RETN -------- 004012A4 |> /8B45 08 /MOV EAX,[ARG.1] ; | 004012A7 |. |890424 |MOV DWORD PTR SS:[ESP],EAX ; | 004012AA |. |E8 B1060000 |CALL <JMP.&msvcrt.strlen> ; \strlen 004012AF |. |3945 FC |CMP [LOCAL.1],EAX 004012B2 |. |73 1C |JNB SHORT level3.004012D0 004012B4 |. |8B45 08 |MOV EAX,[ARG.1] 004012B7 |. |8B55 FC |MOV EDX,[LOCAL.1] 004012BA |. |01C2 |ADD EDX,EAX 004012BC |. |8B45 08 |MOV EAX,[ARG.1] 004012BF |. |0345 FC |ADD EAX,[LOCAL.1] 004012C2 |. |0FB600 |MOVZX EAX,BYTE PTR DS:[EAX] 004012C5 |. |04 0D |ADD AL,0D ; char + 0xD 004012C7 |. |8802 |MOV BYTE PTR DS:[EDX],AL 004012C9 |. |8D45 FC |LEA EAX,[LOCAL.1] 004012CC |. |FF00 |INC DWORD PTR DS:[EAX] 004012CE |.^\EB D4 \JMP SHORT level3.004012A4 -------- 756296A0 msvcrt.strcmp 8B5424 04 MOV EDX,DWORD PTR SS:[ESP+4] 756296A4 8B4C24 08 MOV ECX,DWORD PTR SS:[ESP+8] 756296A8 F7C2 03000000 TEST EDX,3 756296AE 75 3C JNZ SHORT msvcrt.756296EC 756296B0 8B02 MOV EAX,DWORD PTR DS:[EDX] 756296B2 3A01 CMP AL,BYTE PTR DS:[ECX] 756296B4 75 2E JNZ SHORT msvcrt.756296E4 756296B6 0AC0 OR AL,AL 756296B8 74 26 JE SHORT msvcrt.756296E0 756296BA 3A61 01 CMP AH,BYTE PTR DS:[ECX+1] 756296BD 75 25 JNZ SHORT msvcrt.756296E4 756296BF 0AE4 OR AH,AH 756296C1 74 1D JE SHORT msvcrt.756296E0 756296C3 C1E8 10 SHR EAX,10 756296C6 3A41 02 CMP AL,BYTE PTR DS:[ECX+2] 756296C9 75 19 JNZ SHORT msvcrt.756296E4 756296CB 0AC0 OR AL,AL 756296CD 74 11 JE SHORT msvcrt.756296E0 756296CF 3A61 03 CMP AH,BYTE PTR DS:[ECX+3] 756296D2 75 10 JNZ SHORT msvcrt.756296E4 756296D4 83C1 04 ADD ECX,4 756296D7 83C2 04 ADD EDX,4 756296DA 0AE4 OR AH,AH 756296DC ^ 75 D2 JNZ SHORT msvcrt.756296B0 756296DE 8BFF MOV EDI,EDI 756296E0 33C0 XOR EAX,EAX 756296E2 C3 RETN 756296E3 90 NOP 756296E4 1BC0 SBB EAX,EAX 756296E6 D1E0 SHL EAX,1 756296E8 83C0 01 ADD EAX,1 756296EB C3 RETN
En la comparación vemos que el serial bueno es AvrQQsXjDk25Jrh por lo que si restamos 0xD (13 en decimal) a cada carácter obtendremos el serial bueno.
0060FF10 41 76 72 51 51 73 58 6A 44 6B 32 35 4A 72 68 00 AvrQQsXjDk25Jrh. 41 76 72 51 51 73 58 6A 44 6B 32 35 4A 72 68 - D 34 69 65 44 44 66 4B 5D 37 5E 25 28 3D 65 5B 4 i e D D f K ] 7 ^ % ( = e [ Serial bueno: 4ieDDfK]7^%(=e[
La comprobación del serial es igual que la anterior pero sustituyendo la función que sumaba un valor a cada dígito del serial por una que genera un hash con nuestro serial y después lo compara con otro hash almacenado en memoria. Si no nos viene a la mente el tipo de hash que puede ser PEiD ya nos avisaba de que efectivamente el crackme incorpora la función MD5.
La función MD5 hace tiempo que no se considera segura debido a la existencia de numerosos «diccionarios» de hashes que hacen que encontremos la solución en segundos. Yo he utilizado la web MD5 online pero existen muchas más.
0060FE5C 004013BF RETURN to level4.004013BF from <JMP.&msvcrt.strcmp> 0060FE60 0060FEA0 ASCII "e807f1fcf82d132f9bb018ca6738a19f" 0060FE64 0060FEE0 ASCII "fe01d67a002dfa0f3ac084298142eccd" e807f1fcf82d132f9bb018ca6738a19f == 1234567890 fe01d67a002dfa0f3ac084298142eccd == orange
La carta de presentación de este crackme es la imagen que veis arriba. Al explorarlo unos minutos enseguida nos damos cuenta de que no realiza ninguna comprobación y que nos está haciendo perder el tiempo. Ahí es cuando empezamos a revisar el ejecutable más a fondo y enseguida encontramos la solución con nuestro amigo el editor hexadecimal.
Misma carta de presentación que el anterior y misma ausencia de comprobación del serial. En esta ocasión echando un vistazo a los recursos encontramos la solución rápidamente.
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
Enemigo público (Enemy of the State) es una película de acción y suspense dirigida por Tony Scott, estrenada en 1998. La historia sigue a Robert Clayton Dean (Will Smith), un abogado de Washington D.C. que se ve atrapado en una conspiración de vigilancia masiva cuando recibe, sin saberlo, una cinta de video que documenta el asesinato de un congresista a manos de un alto funcionario de la Agencia de Seguridad Nacional (NSA), interpretado por Jon Voight. La situación se complica cuando la NSA utiliza toda su tecnología de espionaje para seguir y neutralizar a Dean.
Dean encuentra ayuda en Edward «Brill» Lyle (Gene Hackman), un exanalista de la NSA convertido en un experto en vigilancia que vive en el anonimato. Juntos intentan descubrir la verdad y exponer la conspiración, mientras son perseguidos por la propia NSA. Un papel crucial también lo desempeña el personaje de Daniel Zavitz, interpretado por Jason Lee, un joven investigador que graba accidentalmente el asesinato y termina transmitiendo la evidencia a Dean. El elenco incluye además a Lisa Bonet, Regina King, Jack Black, Barry Pepper, y Seth Green.
En Enemigo Público, la tecnología juega un papel crucial no solo en la trama sino también en la ambientación de la película. La precisión y el realismo de los equipos informáticos utilizados contribuyen a la atmósfera de paranoia y vigilancia que define la narrativa.
Jason Lee, en su papel de Daniel Zavitz, utiliza un PC clónico, claramente identificado por el logo de Sun Microsystems en la torre del ordenador. Sin embargo, el sistema operativo que corre en esta máquina es Windows 3.1, una versión que, para 1998, ya estaba obsoleta, habiendo sido lanzada en 1992. Esta elección subraya el hecho de que Zavitz utiliza equipamiento más económico y anticuado, en contraste con la tecnología más avanzada de otros personajes.
Zavitz también utiliza Media Player, un reproductor de video básico integrado en Windows 3.1. Durante la reproducción del archivo de video crucial para la trama, se puede observar que la extensión del archivo es .CAM. Este tipo de archivo podría implicar un video capturado por una cámara, pero también sugiere (por otros fotogramas de la película) que el codec utilizado para comprimir el video podría ser QuickTime, permitiendo una reproducción cruzada entre diferentes sistemas operativos.
Además, Zavitz utiliza un reproductor portátil NEC Turbo Express, un dispositivo de videojuegos portátil de la época. En la película, este dispositivo es empleado de manera innovadora para reproducir y transferir datos, algo poco realista pero que añade dramatismo a la escena. La tarjeta PCMCIA de 200MB que Zavitz utiliza para almacenar el video es otro ejemplo de la tecnología de la época, reflejando la capacidad de almacenamiento portátil antes de la popularización de los dispositivos USB.
Por su parte, Gene Hackman, en su papel de Brill, maneja un sistema considerablemente más avanzado, utilizando Windows 98. Este sistema operativo, lanzado también en 1998, representaba lo más avanzado en términos de compatibilidad y usabilidad en ese momento, lo que refuerza la imagen de Brill como un experto en tecnología con acceso a mejores recursos.
Aunque en la película no se detalla el hardware específico de Brill, el hecho de que use Windows 98, junto con las capacidades de manipulación y decodificación de video que se muestran, sugiere que tiene acceso a tecnología de alta gama para la época. En una escena clave, se observa cómo Brill decodifica el video utilizando una interfaz gráfica llamativa, diseñada claramente para atraer la atención del espectador, más que para reflejar la realidad de la tecnología disponible en ese momento.
La producción de Enemigo Público es destacable por su atención al detalle en lo referente al equipamiento tecnológico de los personajes. El contraste entre el equipo más antiguo y económico utilizado por Daniel Zavitz (Jason Lee) y el sistema más avanzado de Edward Lyle (Gene Hackman) refleja de manera efectiva el trasfondo de los personajes. Zavitz, como investigador freelance, se maneja con recursos limitados, mientras que Lyle, con su pasado en la NSA y mayor poder adquisitivo, tiene acceso a tecnología más avanzada.
Otro detalle interesante es la diferenciación en el equipamiento dentro de la central de la NSA. Mientras los empleados comunes utilizan monitores CRT, que eran estándar en la época, el personaje de Thomas Reynolds (Jon Voight) dispone de una pantalla plana, lo que subraya su estatus superior dentro de la agencia. Estos detalles de producción contribuyen a la autenticidad y la profundidad visual de la película.
Sin embargo, la película no está exenta de licencias creativas que sacrifican el realismo tecnológico en favor del impacto visual. Un ejemplo claro es cuando un técnico de la NSA, a partir de un fotograma de un vídeo de seguridad, rota la imagen en 3D para simular lo que Zavitz podría haber introducido en la bolsa de Dean. Aunque esta secuencia añade dramatismo, carece de una base tecnológica realista.
Del mismo modo, la escena donde Brill decodifica el vídeo utilizando una interfaz visualmente llamativa es un claro ejemplo de cómo la película opta por elementos más glamurosos para captar la atención del espectador, alejándose de la realidad técnica, donde estos procesos serían mucho menos espectaculares y más funcionales. Además se pueden observar las siguientes curiosidades:
En resumen, Enemigo Público logra un equilibrio eficaz entre el realismo tecnológico y las exigencias dramáticas del cine. A pesar de algunas exageraciones en la representación de la tecnología, la atención al detalle en los aspectos técnicos y la diferenciación de equipos según los personajes y sus circunstancias es un testimonio del buen trabajo de producción que hace que la película siga siendo entretenida, incluso más de dos décadas después de su estreno.
Al descargar la imagen de la web del reto vemos que tiene la extensión php y lo más probable es que no nos abra correctamente.
... <br/> <img src="steg1img.php"/> <br/> ...
Abrimos la imagen con nuestro editor hexadecimal favorito y nos fijamos en la cabecera.
00000000h: 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 ; ‰PNG........IHDR
Renombramos entonces la extensión a png y continuamos.
Esta parte la afrontaremos con Steganabara, una herramienta muy útil que siempre uso cuando me enfrento a un reto «stego». En esta ocasión utilizaremos el análisis de color. Para ello pulsamos sobre «Analyse > Color table«.
En la tabla de colores tenemos la descomposición de colores RGBA y su frecuencia de aparición. Ordenamos por frecuencia descendiente y hacemos doble clic sobre la fila para abrir la imagen resultante.
A continuación un resumen de las imágenes obtenidas.
Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.
dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe
A partir de aquí el reto pasa a ser de encriptación. Con el tiempo diferenciareis fácilmente el tipo de cifrado con sólo ver el texto. En este caso lo primero que se nos ocurre es comprobar dos cifrados clásicos como son el cifrado César y el Vigenere.
Tras desestimar el cifrado César realizamos un ataque de «fuerza bruta» al cifrado Vigenere mediante análisis estadístico. En la imagen que muestro a continuación se puede ver que la clave está cerca de ser «HPHQTC» pero todavía no se lee correctamente.
Ya que la fuerza bruta de por sí no termina de darnos la respuesta correcta, pasamos a probar algo muy útil, esto es, descifrar por fuerza bruta pero dándole una palabra para comparar. En este caso en concreto vemos que una posible palabra que pudiera estar en el texto encriptado es «PASSWORD», probamos y reto terminado.
Este un crackme muy interesante para principiantes ya que la rutina no es muy compleja. Está hecho en ensamblador.
Arrancamos el crackme en Olly damos al play y se cierra. Buscamos en las «Intermodular Calls» y vemos «IsDebuggerPresent«, clickamos sobre ella y vemos el típico call, lo NOPeamos.
Aquí vemos el call.
Call Nopeado.
Encontrar en serial válido en esta ocasión es muy sencillo, basta con buscar en las «String References» el mensaje de «Bad boy» y fijarse en la comparación.
Si nos fijamos en el serial generado nos da muchas pistas pero vamos a destriparlo ya que tampoco tiene mucha complicación. De nuevo miramos en las «String references» y clickamos sobre el mensaje de «bad boy«. Encima de los mensajes vemos claramente la rutina de creación del serial.
004010EB |. 83F8 04 CMP EAX,4 ;Longitud del nombre >4 004010EE |. 72 05 JB SHORT Ice9.004010F5 004010F0 |. 83F8 0A CMP EAX,0A ;Longitud del nombre <=10 004010F3 |. 76 15 JBE SHORT Ice9.0040110A 004010F5 |> 6A 00 PUSH 0 ; /Style = MB_OK|MB_APPLMODAL 004010F7 |. 68 04304000 PUSH Ice9.00403004 ; |Title = "Error, Bad Boy" 004010FC |. 68 1C304000 PUSH Ice9.0040301C ; |Text = "name must be at least 4 chars" 00401101 |. 6A 00 PUSH 0 ; |hOwner = NULL 00401103 |. E8 70010000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401183 . 3BD3 CMP EDX,EBX 00401185 . 74 15 JE SHORT Ice9.0040119C 00401187 . 8A07 MOV AL,BYTE PTR DS:[EDI] 00401189 . 3C 5A CMP AL,5A ;Compara que el dígito < 5A 0040118B . 7E 05 JLE SHORT Ice9.00401192 0040118D > 03C8 ADD ECX,EAX ;ECX + Ascii(dígito) 0040118F . 47 INC EDI 00401190 .^ EB EE JMP SHORT Ice9.00401180 00401192 > 3C 41 CMP AL,41 ;Compara que el dígito > 41 00401194 . 7D 02 JGE SHORT Ice9.00401198 00401196 . EB 02 JMP SHORT Ice9.0040119A 00401198 > 04 2C ADD AL,2C ;Si cumple lo anterior dígito +2C 0040119A >^ EB F1 JMP SHORT Ice9.0040118D 0040119C > 81C1 9A020000 ADD ECX,29A ;ECX + 29A 004011A2 . 69C9 39300000 IMUL ECX,ECX,3039 ;ECX * 3039 004011A8 . 83E9 17 SUB ECX,17 ;ECX - 17 004011AB . 6BC9 09 IMUL ECX,ECX,9 ;ECX * 9 004011AE . 33DB XOR EBX,EBX 004011B0 . 8BC1 MOV EAX,ECX ;Mueve nuestro SUM en EAX 004011B2 . B9 0A000000 MOV ECX,0A ;ECX = A 004011B7 > 33D2 XOR EDX,EDX 004011B9 . F7F1 DIV ECX ;SUM / ECX (Resultado a EAX) 004011BB . 80C2 30 ADD DL,30 004011BE . 881433 MOV BYTE PTR DS:[EBX+ESI],DL 004011C1 . 83C3 01 ADD EBX,1 004011C4 . 83F8 00 CMP EAX,0 004011C7 . 74 02 JE SHORT Ice9.004011CB 004011C9 .^ EB EC JMP SHORT Ice9.004011B7 004011CB > BF C8304000 MOV EDI,Ice9.004030C8 004011D0 > 8A4433 FF MOV AL,BYTE PTR DS:[EBX+ESI-1] 004011D4 . 8807 MOV BYTE PTR DS:[EDI],AL 004011D6 . 47 INC EDI 004011D7 . 4B DEC EBX 004011D8 . 83FB 00 CMP EBX,0 004011DB .^ 75 F3 JNZ SHORT Ice9.004011D0 004011DD . C607 00 MOV BYTE PTR DS:[EDI],0 ;Coje letras del nombre en función 004011E0 . 8D3D B4304000 LEA EDI,DWORD PTR DS:[4030B4] ;del resultado anterior 004011E6 . 68 B7304000 PUSH Ice9.004030B7 ; ASCII "rus" 004011EB . 68 C8304000 PUSH Ice9.004030C8 ; ASCII "134992368rus" 004011F0 . E8 BB000000 CALL Ice9.004012B0 ; Concatena 004011F5 . 68 C8304000 PUSH Ice9.004030C8 ; /String2 = "136325628rus" 004011FA . 68 98314000 PUSH Ice9.00403198 ; |String1 = "12345" 004011FF . E8 98000000 CALL <JMP.&kernel32.lstrcmpA> ; \lstrcmpA
Resumen (valores hexadecimales):
Finalmente concatena letras siguiendo este criterio:
Ejemplo para deurus
d e u r u (s) 64+65+75+72+75 = 225 225 + 29A = 4BF 4BF * 3039 = E4DE87 E4DE87 - 17 = E4DE70 E4DE70 * 9 = 80BD1F0 ;Pasamos a decimal y concatenamos 134992368rus
Ejemplo para Deurus
D e u r u (s) 44(+2C)+65+75+72+75 = 25D 25D + 29A = 4F7 4BF * 3039 = EF6AFF EF6AFF - 17 = EF6AE8 EF6AE8 * 9 = 86AC228 ;Pasamos a decimal y concatenamos 141214248rus
Como curiosidad decirtos que con el tiempo valores del estilo 29A y 3039 os pegarán rápido al ojo ya que equivalen a 666 y 12345 en decimal. Por cierto 29A fue un grupo de hackers creadores de virus muy conocido en la escena Nacional e Internacional.
Este BTM va otra vez sobre IPs. Si amigos del séptimo arte, viendo un capítulo de mi querida «The Sinner» me han vuelto a chirriar los dientes. La verdad que viendo el capítulo no te da tiempo a apreciarlo, únicamente me quedo con que aparece una URL y lo reviso a posteriori (esto lo digo para los curiosos que me preguntáis).
En esta ocasión me tiene un poco inquieto ya que es una serie que cuida enormemente los detalles y el fallo que os voy a mostrar parece intencionado. La imagen en cuestión es esta:
Aparece un buscador con una URL más o menos creíble si no fuera porque la IP que aparece es IMPOSIBLE. La máxima IPv4 es 255.255.255.255, es decir, no han dado ni una, y eso es lo que me tiene mosca. Si hubieran utilizado 82.47.25.29 hubiera quedado bien y estaríamos hablando de un problema de geolocalización de IPs, ya que el rango 82.47.xx.xx le pertenece a UK y deberíamos discernir si el servidor está en EEUU o no…
En definitiva, puede ser un fallo a propósito, un guiño o tener un significado. No se que deciros, bueno si, ¡lo investigaré!
En una entrada anterior sobre cómo Expediente X abordó la tecnología de vanguardia, comenté que dedicaría un espacio a esos tres personajes tan peculiares y entrañables que, desde el segundo plano, se ganaron un hueco en el corazón de los seguidores de la serie: los Pistoleros Solitarios. Pues bien, ha llegado el momento.
Estos tres tipos —John Fitzgerald Byers, Melvin Frohike y Richard “Ringo” Langly— no necesitaban armas ni placas del FBI. Su poder estaba en los teclados, los cables enredados y los monitores de tubo que parpadeaban en un sótano lleno de conspiraciones y café frío. Eran los outsiders de Expediente X, tres hackers con alma de periodistas que luchaban por algo tan simple y tan enorme como la verdad.
Su primera aparición fue en E.B.E. (temporada 1), casi como un alivio cómico: tres frikis que ayudaban a Mulder a rastrear información sobre ovnis. Pero pronto quedó claro que había algo especial en ellos. No solo eran fuente de datos, sino conciencia crítica en un mundo plagado de mentiras digitales y gobiernos con demasiados secretos. Con el tiempo se convirtieron en aliados imprescindibles de Mulder y Scully, y también en el reflejo más humano de lo que significa ser hacker: curiosos, testarudos, torpes a veces, pero con un sentido moral inquebrantable.
Byers era el idealista, el que aún creía en la decencia y en las instituciones (al menos en teoría). Frohike, el cínico veterano con corazón de oro, siempre dispuesto a arriesgarse por una buena causa… o por impresionar a Scully. Y Langly, el genio rebelde que parecía vivir en permanente conversación con su módem de 56 k. Juntos formaban un trío excéntrico, pero perfectamente equilibrado.
Mientras Mulder y Scully perseguían abducciones y virus extraterrestres, los pistoleros combatían en otra trinchera: la digital. Hackeaban redes gubernamentales, interceptaban comunicaciones cifradas y desmantelaban cortafuegos que, en los noventa, parecían pura ciencia ficción. Lo suyo no era la acción física, sino la resistencia informativa. Y aunque muchas veces eran el chiste del capítulo, también representaban algo muy real: la gente corriente que lucha contra el poder desde el conocimiento.
Su lema no declarado podría haber sido el clásico “la información quiere ser libre”, y en eso se mantuvieron firmes hasta el final. Si había que elegir entre la seguridad o la verdad, ellos siempre elegían la verdad, aunque les costara caro.
| Temporada | Episodio | Título | Comentario |
|---|---|---|---|
| 1 | 17 | E.B.E. | Primera aparición de los pistoleros. |
| 2 | 3 | Blood | Manipulación de dispositivos y mensajes ocultos. También control mental a través de la tecnología. |
| 2 | 25 | Anasazi | Un hacker roba archivos clasificados. Se tratan temas como el cifrado y filtración de datos del gobierno. |
| 3 | 15 | Apocrypha | Acceso a bases de datos secretas y descifrado de archivos comprometidos. |
| 3 | 23 | Wetwired | Manipulación de señales televisivas. |
| 4 | 14 | Memento Mori | Infiltración digital en sistemas médicos y vigilancia biotecnológica. |
| 5 | 1 | Redux | Robo y manipulación de pruebas digitales. |
| 5 | 3 | Unusual Suspects | Orígenes de los pistoleros: intrusión, cifrado y espíritu hacker de los noventa. |
| 5 | 11 | Kill Switch | IA autónoma y malware inteligente. |
| 6 | 20 | Three of a Kind | Hacking social, suplantación y síntesis de voz para infiltración corporativa. |
| 7 | 13 | First Person Shooter | Hackeo de entornos virtuales y brechas de seguridad en sistemas de realidad aumentada. |
| 9 | 15 | Jump the Shark | Su sacrificio final: bloqueo de una amenaza biológica, ética hacker y altruismo extremo. |
| 11 | 2 | This | Langly como conciencia digital en un servidor. Debate sobre IA y trascendencia del código. |
El final de los pistoleros fue tan inesperado como heroico. En el episodio “Jump the Shark” de la novena temporada, descubren un complot bioterrorista que amenaza con liberar un virus mortal. No hay tiempo para avisar a nadie, ni margen para escapar. Así que, fieles a su estilo, deciden sacrificarse para salvar a otros. Sellan el laboratorio desde dentro, sabiendo que no volverán a salir.
Lo reconozco, este desenlace mi cogió completamente por sorpresa. No hay épica de Hollywood, ni música grandilocuente. Solo tres hombres anónimos haciendo lo correcto. Mueren juntos, sin reconocimiento, sin medallas, pero con la serenidad de quienes saben que su causa era justa. Y en ese silencio final, Expediente X nos recordó algo que las grandes historias suelen olvidar: que los verdaderos héroes a veces no llevan traje ni pistola, solo convicción.
Años después, Mulder vuelve a verlos —o cree verlos— en The Truth. Ya no están en este mundo, pero siguen a su lado, como fantasmas digitales de la conciencia hacker. Es un homenaje discreto a quienes siempre pelearon desde las sombras por liberar la verdad.
Para cerrar el círculo, Langly reaparece de forma inesperada en la temporada 11, dentro del episodio This. Su mente, o más bien su copia digital, sobrevive atrapada en un servidor, reclamando ser liberada. Es el epílogo perfecto: el hacker que muere físicamente, pero cuya conciencia sigue inmortal. Una vez más me volvió a sorprender Chris Carter con este homenaje.
Me gusta pensar que los pistoleros solitarios representaban algo más que tres hackers secundarios en una serie de los noventa. Fueron el reflejo de una época en la que creíamos que la tecnología podía liberar al ser humano, antes de que las redes sociales y la hiperconectividad lo diluyeran todo. Byers, Frohike y Langly no luchaban por fama ni por dinero: luchaban por entender el sistema para exponerlo, por esa curiosidad genuina que hoy apenas sobrevive entre líneas de código y algoritmos opacos. Quizá por eso seguimos recordándolos y mola tanto volver a ver los capítulos. Porque, de algún modo, todos los que amamos el conocimiento libre llevamos dentro un pequeño pistolero solitario, buscando la verdad entre los bits.
En Parque Jurásico (1993), la informática no es solo un elemento narrativo, es una pieza clave del suspense y del conflicto. A diferencia de otras películas donde las pantallas muestran interfaces ficticias o visualmente espectaculares pero irreales, Parque Jurásico opta por una aproximación sorprendentemente sobria y auténtica.
Durante bastantes escenas, se nos muestran terminales, ventanas de código y comandos que, lejos de ser decorativos, pertenecen a sistemas reales utilizados por programadores profesionales de principios de los años 90. Este detalle, que puede pasar desapercibido para el público general, resulta especialmente interesante desde un punto de vista técnico. En otras palabras, el trabajo de producción es excelente y destaca como una de las películas más respetuosas con la informática real de su época.
No es “código de película”: es software real
Uno de los puntos más interesantes es que el código que aparece en pantalla no fue escrito para la película. No hay pseudocódigo, ni pantallas diseñadas solo para quedar bonitas en cámara. Lo que se ve es software real, ejecutándose en el entorno Macintosh Programmer’s Workshop (MPW), el kit oficial de Apple para desarrolladores en aquellos años. El sistema operativo que se reconoce es un Macintosh clásico (System 7) corriendo sobre máquinas de la serie Quadra, auténticos pepinos para la época. Vamos, que cuando John Hammond decía aquello de «no hemos reparado en gastos», también iba en serio en lo informático.
«No hemos reparado en gastos»
En este punto no se le puede reprochar demasiado a la película. En líneas generales es bastante fiel a la novela, aunque la resolución del problema de seguridad se aborda de forma distinta. En el libro es el ingeniero Ray Arnold quien detecta el fallo y consigue reconducir la situación. En la película, sin embargo, el personaje desaparece cuando va a los barracones a restablecer la corriente del parque, con el resultado que todos conocemos.
Lo curioso es que muchos personajes sí cambian de forma notable con respecto al libro, el niño es mayor y más friki de los ordenadores, Ray Arnold no muere y acaba salvando la situación, o Gennaro es más atlético y bastante más valiente. Sin embargo, el gran disparate técnico permanece intacto.
En la novela se menciona de pasada a un equipo de informáticos de Cambridge que supuestamente colaboró en el diseño del software. Aun así, la puesta en marcha y la explotación del sistema recaen prácticamente en una sola persona, Dennis Nedry. Evidentemente, tanto al libro como al guion les viene de perlas que todo dependa de una única persona para que el desastre sea posible, pero cuesta aceptar que en un parque donde todo está duplicado, el control informático central dependa de una sola persona.
Curiosamente, en uno de los monitores de Nedry se puede ver una foto de Oppenheimer con la frase «Beginning of baby boom», de la que podemos sacar la conclusión de que Nedry es perfectamente consciente de que su trabajo puede tener consecuencias catastróficas e irreversibles. También es un maravilloso guiño del equipo de producción que nos está indicando exactamente donde se va originar el desastre.
Al final, Parque Jurásico no va de dinosaurios, ni siquiera de genética. Va de personas. Y, más concretamente, de personas con demasiado poder y muy pocos compañeros de equipo y poca supervisión.
Desde el punto de vista informático, la película es casi entrañable. Todo es serio, profesional y real… hasta que descubrimos que el sistema más complejo jamás construido depende, en la práctica, de un solo programador cabreado, mal pagado y con demasiadas líneas de código en la cabeza. Ningún comité de arquitectura, ninguna auditoría externa, ningún segundo par de ojos. Solo Dennis Nedry y su teclado. ¿Qué podía salir mal?
Lo curioso es que ni la película ni el libro se molestan en disimularlo demasiado. Te hablan de sistemas redundantes, de seguridad, de control absoluto… pero el corazón digital del parque es un castillo de naipes. Eso sí, un castillo de naipes programado en máquinas de primera, con software real y pantallas que hoy siguen pareciendo más creíbles que muchas producciones actuales.
Quizá por eso Parque Jurásico envejece tan bien. Porque, incluso cuando se equivoca, lo hace con honestidad. No intenta venderte magia disfrazada de tecnología. Te muestra ordenadores de verdad, código de verdad y errores muy humanos. Y al final, tanto en la novela como en la película, el mensaje es el mismo, puedes clonar dinosaurios, diseñar parques imposibles y rodearte de la mejor tecnología del mundo, que si todo depende de una sola persona, tarde o temprano, el sistema se vendrá abajo.
Y no, el problema no eran los dinosaurios, nunca lo fueron.
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.
