Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar una serie de crackmes. Los dos primeros pasaron algo desapercibidos, pero el Crackme nº3 tuvo una gran repercusión en el mundillo y, aunque no fue el primer crackme para Android ni mucho menos, si que fue uno de los más estudiados. Todos ellos fueron publicados a través de crackmes.de y el nº3 en cuestión el 6 de Noviembre de 2010. Os dejo una lista de unas cuantas webs donde aparece analizado para que veáis la repercusión que a mi parecer tuvo.

Soluciones al crackme

Referencias al crackme

Links


Intro Aquí tenemos un crackme clásico realizado en Visual C++. La única particularidad que tiene es que no muestra MessageBox
Introducción Javascript 1 (Serial a la vista) Javascript 2 (La función charAt()) Javascript 3 (Input) Javascript 4 (Fuerza bruta manual) Javascript
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
Introducción Funcionamiento de RSA OllyDbg Calculando un serial válido Ejemplo operacional Keygen Links Introducción Empezamos con lo que espero que

Intro

Aquí tenemos un crackme clásico realizado en Visual C++. La única particularidad que tiene es que no muestra MessageBox al introducir bien o mal el serial, simplemente cambia una imagen de un emoticono. Si observamos el comportamiento del crackme notaremos que inicialmente el emoticono está neutral y al fallar se pone triste y por lo tanto es de suponer que al acertar se pondrá contento.

El BreakPoint

Intermodular Calls

Al mirar en las Intermodular Calls de OllyDbg vemos que LoadIconA es un buen candidato para ubicar la comprobación del serial. Si nos fijamos hay tres llamadas, ponemos un breakpoint en las tres y enseguida llegamos a la zona de comprobación del serial.

La comprobación

00401180   . 6A FF          PUSH -1
00401182   . 68 68194000    PUSH CrackMe_.00401968
00401187   . 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
0040118D   . 50             PUSH EAX
0040118E   . 64:8925 000000>MOV DWORD PTR FS:[0],ESP
00401195   . 83EC 0C        SUB ESP,0C
00401198   . 53             PUSH EBX
00401199   . 55             PUSH EBP
0040119A   . 8BE9           MOV EBP,ECX
0040119C   . 56             PUSH ESI
0040119D   . 57             PUSH EDI
0040119E   . 8D4C24 10      LEA ECX,DWORD PTR SS:[ESP+10]
004011A2   . E8 2F050000    CALL <JMP.&MFC42.#540>
004011A7   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
004011AB   . C74424 24 0000>MOV DWORD PTR SS:[ESP+24],0
004011B3   . E8 1E050000    CALL <JMP.&MFC42.#540>
004011B8   . 8D4424 10      LEA EAX,DWORD PTR SS:[ESP+10]
004011BC   . 8BCD           MOV ECX,EBP
004011BE   . 50             PUSH EAX
004011BF   . 68 E9030000    PUSH 3E9
004011C4   . C64424 2C 01   MOV BYTE PTR SS:[ESP+2C],1
004011C9   . E8 02050000    CALL <JMP.&MFC42.#3097>                  ;  Lee el tamano del nombre
004011CE   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
004011D2   . 51             PUSH ECX
004011D3   . 68 EA030000    PUSH 3EA
004011D8   . 8BCD           MOV ECX,EBP
004011DA   . E8 F1040000    CALL <JMP.&MFC42.#3097>                  ;  Lee el tamano del serial
004011DF   . 51             PUSH ECX
004011E0   . 8D5424 14      LEA EDX,DWORD PTR SS:[ESP+14]
004011E4   . 8BCC           MOV ECX,ESP
004011E6   . 896424 1C      MOV DWORD PTR SS:[ESP+1C],ESP
004011EA   . 52             PUSH EDX
004011EB   . E8 DA040000    CALL <JMP.&MFC42.#535>
004011F0   . 8D4424 1C      LEA EAX,DWORD PTR SS:[ESP+1C]   
004011F4   . 8BCD           MOV ECX,EBP       
004011F6   . 50             PUSH EAX                 
004011F7   . E8 D4010000    CALL CrackMe_.004013D0 
004011FC   . 50             PUSH EAX
004011FD   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
00401201   . C64424 28 02   MOV BYTE PTR SS:[ESP+28],2
00401206   . E8 B9040000    CALL <JMP.&MFC42.#858>
0040120B   . 8D4C24 18      LEA ECX,DWORD PTR SS:[ESP+18]
0040120F   . C64424 24 01   MOV BYTE PTR SS:[ESP+24],1
00401214   . E8 A5040000    CALL <JMP.&MFC42.#800>
00401219   . 8B4C24 10      MOV ECX,DWORD PTR SS:[ESP+10]
0040121D   . 8B5424 14      MOV EDX,DWORD PTR SS:[ESP+14]
00401221   . 8B41 F8        MOV EAX,DWORD PTR DS:[ECX-8]
00401224   . 8B4A F8        MOV ECX,DWORD PTR DS:[EDX-8]
00401227   . 3BC1           CMP EAX,ECX                              ;  CMP len nombre y len serial
00401229   . 0F85 2C010000  JNZ CrackMe_.0040135B
0040122F   . 83F8 03        CMP EAX,3                                ;  len nombre >=3
00401232   . 0F8C 23010000  JL CrackMe_.0040135B
00401238   . 50             PUSH EAX
00401239   . E8 7A040000    CALL <JMP.&MFC42.#823>
0040123E   . 8BF0           MOV ESI,EAX
00401240   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
00401244   . 83C4 04        ADD ESP,4
00401247   . 33C9           XOR ECX,ECX
00401249   . 8B50 F8        MOV EDX,DWORD PTR DS:[EAX-8]
0040124C   . 4A             DEC EDX
0040124D   . 85D2           TEST EDX,EDX
0040124F   . 7E 37          JLE SHORT CrackMe_.00401288
.......
1ºBUCLE
.......
00401251   > 8A1401         MOV DL,BYTE PTR DS:[ECX+EAX]
00401254   . 8A5C01 01      MOV BL,BYTE PTR DS:[ECX+EAX+1]
00401258   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
0040125C   . 0FBED2         MOVSX EDX,DL
0040125F   . 0FBE0401       MOVSX EAX,BYTE PTR DS:[ECX+EAX]
00401263   . 8D4410 FE      LEA EAX,DWORD PTR DS:[EAX+EDX-2]
00401267   . 99             CDQ
00401268   . 2BC2           SUB EAX,EDX
0040126A   . 0FBED3         MOVSX EDX,BL
0040126D   . D1F8           SAR EAX,1
0040126F   . 40             INC EAX
00401270   . 83EA 02        SUB EDX,2
00401273   . 3BC2           CMP EAX,EDX
00401275   . 0F94C0         SETE AL
00401278   . 880431         MOV BYTE PTR DS:[ECX+ESI],AL
0040127B   . 8B4424 10      MOV EAX,DWORD PTR SS:[ESP+10]
0040127F   . 41             INC ECX
00401280   . 8B50 F8        MOV EDX,DWORD PTR DS:[EAX-8]
00401283   . 4A             DEC EDX
00401284   . 3BCA           CMP ECX,EDX
00401286   .^7C C9          JL SHORT CrackMe_.00401251
........
Última comprobación
........
00401288   > 0FBE1401       MOVSX EDX,BYTE PTR DS:[ECX+EAX]
0040128C   . 0FBE78 01      MOVSX EDI,BYTE PTR DS:[EAX+1]
00401290   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
00401294   . 83C7 FE        ADD EDI,-2
00401297   . 0FBE0401       MOVSX EAX,BYTE PTR DS:[ECX+EAX]
0040129B   . 8D4410 FE      LEA EAX,DWORD PTR DS:[EAX+EDX-2]
0040129F   . 99             CDQ
004012A0   . 2BC2           SUB EAX,EDX
004012A2   . D1F8           SAR EAX,1
004012A4   . 40             INC EAX
004012A5   . 3BC7           CMP EAX,EDI
004012A7   . 0F94C2         SETE DL
004012AA   . 881431         MOV BYTE PTR DS:[ECX+ESI],DL

La comprobación es muy sencilla, en resumen hace esto con todas las letras del nombre excepto la última:

1º Caracter
(1ºname + 1ºserial - 2 = X)
(X / 2)
(X + 1)
(2ºname - 2 = Y)
¿Y = X?
2º Caracter
(2ºname + 2ºserial - 2 = X)
(X / 2)
(X + 1)
(3ºname - 2 = Y)
¿Y = X?
...
Con el último caracter del nombre hace lo siguiente:
(6ºname + 6ºserial - 2 = X)
(X / 2)
(X + 1)
(2ºname - 2 = Y)
¿Y = X?
---------
Para revertir la primera parte de la comprobación para el nombre deurus quedaría:
X1 = (((2ºname-2-1)*2)+2)-1ºname
X2 = (((3ºname-2-1)*2)+2)-2ºname
X3 = (((4ºname-2-1)*2)+2)-3ºname
X4 = (((5ºname-2-1)*2)+2)-4ºname
X5 = (((6ºname-2-1)*2)+2)-5ºname
X6 = (((2ºname-2-1)*2)+2)-6ºname

Keygen

var nombre = "deurus";
nombre = nombre.toUpperCase();
var serial = "";
var tmp = "";

var i;
for (i = 0; i < nombre.length-1 ; i++) {
  tmp = ((nombre.charCodeAt(i+1)-2-1)*2+2)-nombre.charCodeAt(i);
  serial += String.fromCharCode(tmp);
}

tmp = ((nombre.charCodeAt(1)-2-1)*2+2)-nombre.charCodeAt(nombre.length-1);
serial += String.fromCharCode(tmp);

document.write(serial);

Enlaces

Y eso es todo, ¡a disfrutar!

Introducción

Los retos de Javascript son los retos más sencillos que podemos encontrar. Muchas veces solamente mirando el código fuente obtenemos la respuesta. Suponen una mala implementación de seguridad debido a que el código se ejecuta del lado del cliente, por lo que el código fuente es accesible y por lo tanto, javascript no garantiza seguridad alguna. En estos cinco casos haremos un recorrido por lo más básico, cinco retos fáciles de superar y que nos proporcionan los conocimientos base para Javascript. Dicho esto os puedo asegurar que en ocasiones he encontrado retos javascript realmente complicados que requieren de horas descifrarlos y en los que es fácil tirar la toalla.

Cuando el reto lo requiera, es buena idea utilizar un compilador online para obtener de forma rápida el valor de una variable o realizar una prueba concreta. Yo utilizo Jsfiddle para realizar pruebas pero existen muchos más.

Javascript 1

Este primer reto es lo básico, en el código fuente se pueden apreciar directamente el usuario y la clave.

<script language=JavaScript>
function Verify(name,pass)
{
if (name=="admin" & pass=="3***3")
	{
	location.href = name + pass + '.htm';
	}
else 
	{
	alert("Si ya fallamos el primero...");
	};
}
</script>

Javascript 2

Este segundo reto es bastante sencillo pero ya te obliga a conocer la función charAt() de Javascript. Dicha función lo que hace es coger el caracter indicado mediante un índice que comienza en cero. Por ejemplo si nombre = deurus y hacemos letra = nombre.charAt(3), estariámos extrayendo la cuarta letra, es decir, la letra r de la variable nombre.

function Verify(name,pass)
{
var name1 = "CrawlinG", pass1 = "capriccio"
	if (name==name1 & pass==pass1)
	{
	location.href = name + ".htm";
	}
else 
	{
	var x =  name1.charAt(7) + pass1.charAt(3)+ name1.charAt(2) + pass1.charAt(5) +  name1.charAt(5) + pass1.charAt(1);x = x.toLowerCase();
	var y =  name.charAt(3) + name.charAt(1) + pass.charAt(1)+ pass.charAt(6) +  pass.charAt(7) + name.charAt(2);var x1 = "des" + y;
	if (x==y){location.href = x1 + ".htm"}else{alert("Esto no va bien");location.href = "js2.htm"}
	}
}

Lo interesante está en la formación de las variables x e y. La variable x se forma de las variables name1 y pass1, formando la palabra gracia. Por otro lado, la variable y se forma con el nombre y clave que introduzcamos nosotros. Vemos que la variable x e y deben ser iguales, por lo tanto debemos construir un nombre (name) y una clave (pass) que cumpla con lo siguiente:

  • 4ª letra del nombre = 1ª letra de la palabra «gracia»
  • 2ª letra del nombre = 2ª letra de la palabra «gracia»
  • 2ª letra de la clave = 3ª letra de la palabra «gracia»
  • 7ª letra de la clave = 4ª letra de la palabra «gracia»
  • 8ª letra de la clave = 5ª letra de la palabra «graci
  • 3ª letra del nombre = 6ª letra de la palabra «gracia«

Como véis simplemente se trata de interpretar correctamente la función charAt() y de fijarse bien en los nombres de las variables.

Javascript 3

Este reto nos muestra diálogo donde nos pide la contraseña para validar el reto. Al fallar  o cancelar vuelve al índice para no dejarnos ver el código fuente. Aquí se pueden seguir varios caminos como bloquear el uso de javascript en el navegador o instalar un plugin en chrome o firefox para habilitar/deshabilitar de forma rápida el uso de javascript.

Una vez deshabilitado javascript vemos lo siguiente:

<script language="JavaScript" src="js3.gif" type=text/javascript>
<!--
function verify()
{
var pass="thebest";
var password=prompt("Introduce el password para superar el nivel","");
	if (password==pass)
		{
		location.href = pass + ".htm";
		}
	else
		{
		alert("No vamos bien...");
		location.href = "index.htm";
		}
}
//-->
</script>

Aquí el truco es darse cuenta que el código que se está ejecutando esta en «js3.gif» y no el código que nos muestra como válida la clave thebest. Si descargamos el archivo js3.gif y lo abrimos con un archivo de texto vemos nuestra querida clave.

function verify()
{
var pass="mo****ver";
var password=prompt("Introduce el password para superar el nivel","");
	if (password==pass)
		{
		location.href = pass + ".htm";
		}
	else
		{
		alert("No vamos bien...");
		location.href = "index.htm";
		}
}

Javascript 4

En este reto ya entramos con que la clave no es reversible y la debemos obtener por fuerza bruta. En este reto utiliza una nueva función como charCodeAt() que lo que hace es obtener el valor ascii del caracter indicado.

function Verify(pass1)
{
var cont1= 2, cont2= 6
var suma1 = 0, suma2 = 0
var pass2 = "FDRLF"
for(i = 0; i < pass1.length; i++) 
{
suma1 += (pass1.charCodeAt(i) * cont1);
cont1++
}
for(i = 0; i < pass2.length; i++) 
{
suma2 += (pass2.charCodeAt(i) * cont2);
cont2++
}
if (suma1==suma2)
{
window.location=suma1+".htm";
}
else
{
alert ("Algo no va bien...");
}
}

Vemos dos bucles en los que se calculan sendos valores suma que finalmente se comparan. la variable suma1 se calcula mediante nuestro password y la variable suma2 la obtiene de la palabra «FDRLF». Con el script que os muestro a continuación obtenemos que usando como clave deurus, suma1 = 3048 y suma2 = 2936. Nuestro punto de referencia es suma2 = 2936, de modo que vamos alterando con paciencia la variable pass1 obteniendo valores cercanos a 2936. Por ejemplo «deurua» nos da suma1 = 2922, un valor bastante cercano.

var pass1 = "deurus";
var cont1= 2, cont2= 6
var suma1 = 0, suma2 = 0
var pass2 = "FDRLF"
for(i = 0; i < pass1.length; i++) 
{
suma1 += (pass1.charCodeAt(i) * cont1);
cont1++
}
for(i = 0; i < pass2.length; i++) 
{
suma2 += (pass2.charCodeAt(i) * cont2);
cont2++
}
alert (suma1);
alert (suma2);

La solución a este reto es múltiple. Dos claves válidas son por ejemplo dfurqfzwfabz.

Javascript 5

Este último reto es similar al anterior pero ya nos obliga a crearnos una pequeña herramienta que nos busque el serial válido.

function Verify(pass)
{
var suma=0
var cadena = "abcdefghijklmnopqrstuvwxyz"
for (var i = 0; i < pass.length; i++) 
	{
	var letra = pass.charAt(i)
	var valor = (cadena.indexOf(letra))
	valor++
	suma *= 26
	suma += valor
	}
if (suma==6030912063)
	{
	window.location=pass+".htm";
	}
else
	{
	alert ("Algo no va bien...");
	}
}

Para esta ocasión utiliza una nueva función llamada indexOf() que lo que hace es devolver un número entero que representa la posición en la que se encuentra el parámetro pasado a la función. Por ejemplo, si tengo variable = deurus y realizo posición = variable.indexOf(«s»), obtengo como resultado 5 (se empieza a contar desde cero).

Las operaciones que realiza el bucle son las siguientes:

  • Coge las letras del nombre una a una.
  • valor = posición de nuestra letra dentro de la variable de texto llamada cadena.
  • valor = valor + 1.
  • Multiplica la variable suma por 26.
  • Suma = suma + valor.

Aunque el proceso de recuperación de esta clave es algo más largo, podemos acortarlo introduciendo una clave de inicio de fuerza bruta próxima al objetivo. Al ser una función bastante lineal podemos rápidamente mediante pruebas con nuestro código de fuerza bruta o con un compilador online, establecer que la clave tendrá 7 caracteres e incluso que para ahorrar tiempo podemos aproximar la clave para que su valor suma esté cercano al valor suma buscado 6030912063.

Realizando pruebas obtenemos:

  • Clave = aaaaaaa -> suma = 321272407
  • Clave = zzzzzzz -> suma = 8353082582
  • Clave = smaaaaa -> suma = 6024332887
  • Clave = smkkkkk -> suma = 6029085437

Como vemos, la clave smkkkkk ya está bastante próxima al objetivo y será un buen punto para lanzar la fuerza bruta.

Os dejo el código de fuerza bruta en .Net

Module Module1
    Sub Main()
inicio:
        Console.WriteLine("-------------------------")
        Console.WriteLine("Modo [1] Prueba password")
        Console.WriteLine("Modo [2] Fuerza bruta")
        Console.WriteLine("-------------------------")
        Dim modo = Console.ReadLine()
        '
        If modo = 2 Then
            Console.WriteLine("¿Password para comenzar?")
            Dim pass = Console.ReadLine()
inicio2:
            Dim cadena As String = "abcdefghijklmnopqrstuvwxyz"
            Dim valor As Integer = 0
            Dim suma As Long = 0
            Dim letra As String
            For i = 0 To pass.Length - 1
                letra = Mid(pass, i + 1, 1)
                valor = cadena.IndexOf(letra)
                valor += 1
                suma *= 26
                suma += valor
            Next
            Console.WriteLine("Password: " & pass & " - Sum: " & suma.ToString)
            pass = IncrementString(pass)
            If suma = 6030912063 Then
                MsgBox("Password is " & pass)
            Else
                If pass = "aaaaaaaa" Then
                    Console.WriteLine("pass not found")
                    Console.ReadKey()
                Else
                    GoTo inicio2
                End If
            End If
        End If
        '------------------------------------------------
        If modo = 1 Then
            Console.WriteLine("Password:")
            Dim pass = Console.ReadLine()
            Dim cadena As String = "abcdefghijklmnopqrstuvwxyz"
            Dim valor As Integer = 0
            Dim suma As Long = 0
            Dim letra As String
            For i = 0 To pass.Length - 1
                letra = Mid(pass, i + 1, 1)
                valor = cadena.IndexOf(letra)
                valor += 1
                suma *= 26
                suma += valor
            Next
            Console.WriteLine("Password: " & pass & " - Sum: " & suma.ToString)
            Console.WriteLine(".......")
            Console.WriteLine("Good = 6030912063")
            Console.WriteLine("Suma = " & suma.ToString)
            Console.ReadKey()
            Console.Clear()
            GoTo inicio
        End If
    End Sub
    Function IncrementString(ByVal strString As String) As String
        '
        ' Increments a string counter
        ' e.g.  "a" -> "b"
        '       "az" -> "ba"
        '       "zzz" -> "aaaa"
        '
        ' strString is the string to increment, assumed to be lower-case alphabetic
        ' Return value is the incremented string
        '
        Dim lngLenString As Long
        Dim strChar As String
        Dim lngI As Long

        lngLenString = Len(strString)
        ' Start at far right
        For lngI = lngLenString To 0 Step -1
            ' If we reach the far left then add an A and exit
            If lngI = 0 Then
                strString = "a" & strString
                Exit For
            End If
            ' Consider next character
            strChar = Mid(strString, lngI, 1)
            If strChar = "z" Then
                ' If we find Z then increment this to A
                ' and increment the character after this (in next loop iteration)
                strString = Left$(strString, lngI - 1) & "a" & Mid(strString, lngI + 1, lngLenString)
            Else
                ' Increment this non-Z and exit
                strString = Left$(strString, lngI - 1) & Chr(Asc(strChar) + 1) & Mid(strString, lngI + 1, lngLenString)
                Exit For
            End If
        Next lngI
        IncrementString = strString
        Exit Function

    End Function
End Module

Enlaces

Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si continuas leyendo este manual es que no utilices la respuesta para completar la prueba sin esfuerzo. 😉

Saltando el Anti-Debug

Abrimos el crackme con Ollydbg y nos salta una protección Anti-Debug.

Si nos fijamos en las «Text Strings» vemos que es la clásica isDebuggerPresent. Pinchamos en ella y vemos claramente el salto que debemos forzar, se encuentra en el offset 401015. Podemos invertir el salto o cambiarlo a JMP para que salte siempre.

Rutina de comprobación del serial

A simple vista vemos instrucciones como FILD y FIDIVR que trabajan con los registros FPU, por lo que tendremos que fijarnos en dichos registros.

Retomemos analizando la rutina de comprobación.

FLD DWORD PTR DS:[403080]    - Carga el entero "720300" en ST7
FSTP [LOCAL.1]               - Guarda "720300" en memoria (Local 1)
MOVSX EDX,BYTE PTR DS:[EAX]  - Coje nuestro primer dígito en ascii y lo carga en EDX
SUB EDX,30                   - Le resta 30 a EDX
PUSH EDX                     - Carga EDX en la pila
FILD DWORD PTR SS:[ESP]      - Carga el valor de EDX en ST0
POP EDX                      - Recupera el valor de la pila
FDIVR [LOCAL.1]              - Divide Local 1 entre nuestro dígito hex y lo guarda en ST0
FSTP [LOCAL.1]               - Guarda el resultado de ST0 en Local 1
INC EAX                      - Siguiente dígito
CMP BYTE PTR DS:[EAX],0      - Comprueba si quedan dígitos en nuestro serial
JNZ SHORT 05_crack.004010F4  - Bucle

Después de la rutina de comprobación simplemente comprueba el valor del resultado de la división con 1 y si es verdad serial válido.

Buscando un serial válido

Podríamos hacer fuerza bruta, pero en esta ocasión no es necesario ya que con la calculadora, boli y papel lo sacamos rápido.
720300 / 2 = 360150
360150 / 2 = 180075
180075 / 5 = 36015
36015  / 5 = 7203
7203   / 3 = 2401
2401   / 7 = 343
343    / 7 = 49
49     / 7 = 7
7      / 7 = 1

Por lo que un serial válido sería: 225537777

La rutina de comprobación del serial podría resumirse también así:

720300 MOD serial = 720300

Links


http://youtu.be/c4CNY902SAE Versión de texto Lista de reproducción
Introducción Esta es la primera entrega de tres en las que vamos a  ver tres crackmes que todo reverser debería
Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos
While Crackmes.de returns, I leave a couple of files for practice. Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.

Introducción

Esta es la primera entrega de tres en las que vamos a  ver tres crackmes que todo reverser debería hacer. Son la serie del autor  Cruehead. Aunque los hice hace ya muchos años, he decidido documentarlos para que el lector que empieza pueda deleitarse. En este caso se trata del típico Nombre / Serial.

El algoritmo

 El algoritmo de este crackme es lo más sencillo que nos podemos encontrar.

Abrimos el crackme con Olly y buscamos en las «string references» el mensaje de error. Pinchamos sobre el y en la parte superior enseguida vemos 2 calls muy interesantes.

02

Veamos que hace con el nombre.

03

Para «deurus» pondría todo en mayúsculas, sumaría su valor ascii y le haría XOR 0x5678.

Ejemplo:

deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0

Veamos que hace con el serial introducido.

04

 Convierte nuestro serial a hexadecimal y le hace XOR 0x1234.

Ejemplo:

Serial = 12345 –> 0x3039 XOR 0x1234 = 0x220D

Una vez que tenemos el SUMNombre y el SUMSerial los compara. Lo vemos en CMP EAX, EBX.

02

En resumen, si a nuestro SUMNombre le hacemos XOR 0x5678 y XOR 0x1234 ya tenemos el serial bueno.

Ejemplo:

deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0 XOR 0x1234 = 0x4594

0x4594 = 17812

El Keygen

char Nombre[20];
GetWindowText(hwndEdit1, Nombre, 20);
char Serial[20];
int len = strlen(Nombre);
int suma = 0;
boolean error = false;
   for(int i = 0; i <= len; i = i + 1)
   {
      suma += toupper(Nombre[i]);
   }
suma = suma^0x444C; //444C == 5678 xor 1234
wsprintf(Serial,"%d",suma);
SetWindowText(hwndEdit2, TEXT(Serial));

 Links


En Parque Jurásico (1993), la informática no es solo un elemento narrativo, es una pieza clave del suspense y del
Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he
http://youtu.be/KR3PgtDMjmg Lista de reproducción
Introducción  Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro

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.

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he encontrado con que el repositorio no estaba preparado para todas las distros Linux de forma estándar. El resultado lo he colgado en Github, de modo que para montarlo en vuestra propia Raspi solo tenéis que seguir estos pasos:

1. Clonar el repositorio
git clone https://github.com/deurus/AperiSolve-Raspi3.git
cd AperiSolve-Raspi3/AperiSolve

2. Construir los contenedores
docker compose build
docker compose up -d

3. Abrir la web
http://<IP_RASPI>:5000

Si tenéis curiosidad de la adaptación que he tenido que hacer aquí están los pasos que he seguido:

1. Preparar el sistema
sudo apt update
sudo apt install -y git docker.io docker-compose
sudo usermod -aG docker $USER
newgrp docker

2. Clonar AperiSolve
git clone https://github.com/Zeecka/AperiSolve.git
cd AperiSolve

3. Crear la estructura de build para la imagen ARM/x86
nano docker-compose.yml

y pega este contenido:

FROM python:3.11-slim

RUN apt-get update && apt-get install -y \
    zip \
    p7zip-full \
    binwalk \
    foremost \
    exiftool \
    steghide \
    ruby \
    binutils \
    pngcheck \
    && rm -rf /var/lib/apt/lists/*

COPY aperisolve/ /aperisolve/

RUN pip install --no-cache-dir -r /aperisolve/requirements.txt

WORKDIR /aperisolve

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "wsgi:app"]

4. Arreglar docker-compose.yml para ser válido y compatible

services:
  web:
    image: aperisolve-local
    build: .
    container_name: aperisolve-web
    ports:
      - "5000:5000"
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  worker:
    image: aperisolve-local
    container_name: aperisolve-worker
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  redis:
    image: redis:7
    container_name: aperisolve-redis

  postgres:
    image: postgres:16
    container_name: aperisolve-postgres
    environment:
      POSTGRES_USER: aperiuser
      POSTGRES_PASSWORD: aperipass
      POSTGRES_DB: aperisolve
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

5. Modificar aperisolve/config.py
nano config.py

y pega este contenido:

from pathlib import Path

IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff"]

WORKER_FILES = ["binwalk", "foremost", "steghide", "zsteg"]

RESULT_FOLDER = Path(__file__).parent.resolve() / "results"
RESULT_FOLDER.mkdir(parents=True, exist_ok=True)

6. Modificación de aperisolve/app.py

Sustituir la línea: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI")
por:
default_db = "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI", default_db)

7. Construir la imagen
docker build -t aperisolve-local .

8. Levantar los contenedores
docker compose down
docker compose up -d

9. Comprobar logs
docker logs aperisolve-web --tail=50
docker logs aperisolve-worker --tail=50

10. Acceder a la web
 - Desde cualquier máquina de la red local: http://IP-DE-LA-MAQUINA:5000
 - Desde la Raspi: http://localhost:5000

11. Limpieza (cuando necesites)
 - Reiniciar contenedores:
docker compose restart
 - Borrar resultados antiguos:
sudo rm -r aperisolve/results/*

Introducción

 Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro keygen. Como comprobareis si no se ofusca o se toman otro tipo de medidas recuperar información sensible es muy sencillo.

AutoIt es un lenguaje freeware multiproposito y de automatización para Microsoft Windows. Es un Visual Basic Killer, ya que mejora las características de los ejecutables (entre otras portabilidad, velocidad y peso, no fat-coding), y facilitan la programación con un buen repertorio de funciones «pre-diseñadas», y usando un Basic de fácil aprendizaje. Se ha expandido desde sus comienzos de automatización incluyendo muchas mejoras en el diseño del lenguaje de programación y sobre todo en nuevas funcionalidades.

El Script

Func CHECKKEY($USER, $PASS)
Local $OPKEY = "", $SIG = ""
Local $USER_LEN = StringLen($USER)
Local $PASS_LEN = StringLen($PASS)
If $USER_LEN < $PASS_LEN Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
ElseIf $USER_LEN < 4 Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
EndIf
$PASS_INT = Int($USER_LEN / $PASS_LEN)
$PASS_MOD = Mod($USER_LEN, $PASS_LEN)
$OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
For $INDEX = 1 To $USER_LEN
$SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
Next
If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
MsgBox(0, "INFO", "Your key was registered.")
Exit
Else
MsgBox(0, "INFO", "Your key is invalid.")
EndIf
EndFunc

 El Algoritmo

El algoritmo es tremendamente sencillo ya que es nuestro nombre al revés y en mayúsculas.

 Modificando el script para generar nuestro propio keygen

El decompilador se llama myAut2exe y tiene este aspecto.

01-09-2014 11-56-37

Programar en AutoIt es muy sencillo e intuitivo. Nuestro keygen quedaría así.

$MAIN = GUICreate("Another keygen by deurus", 300, 80, -1, -1, 382205952, 385)
$NAME_LBL = GUICtrlCreateLabel("Username", 5, 5, 60, 20, BitOR(4096, 1))
$NAME_INP = GUICtrlCreateInput("", 70, 5, 225, 20, 1)
$PASS_LBL = GUICtrlCreateLabel("Key", 5, 30, 60, 20, BitOR(4096, 1))
$PASS_INP = GUICtrlCreateInput("", 70, 30, 225, 20, 1)
$REGISTER = GUICtrlCreateButton("Register", 5, 55, 60, 20)
$GIVE_UP = GUICtrlCreateButton("Generate", 70, 55, 60, 20)    <- Change name of button, Give Up by Generate
$TASK = GUICtrlCreateButton("?", 140, 55, 20, 20)
$AUTHOR = GUICtrlCreateLabel("keygen by deurus", 165, 55, 130, 20, BitOR(4096, 1))
GUISetState(@SW_SHOW, $MAIN)
While True
    $MSG = GUIGetMsg()
    Switch $MSG
        Case $REGISTER
            Call("CHECKKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))
        Case $GIVE_UP
            Call("GETKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))    <- Add the function to the button
        Case $TASK
            MsgBox(0, "Info", "keygen by deurus")
        Case - 3
            Exit
    EndSwitch
    Sleep(15)
WEnd

Func GETKEY($USER, $PASS)        <- this is our keygen function
    Local $OPKEY = "", $SIG = ""
    Local $USER_LEN = StringLen($USER)
    Local $PASS_LEN = StringLen($USER)
    If $USER_LEN < 4 Then
        GUICtrlSetData($PASS_INP  ,"min 4 chars");
    Else
    For $INDEX = 1 To $USER_LEN
        $SIG = Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), 32)) & $SIG
    Next
        GUICtrlSetData($PASS_INP  ,$SIG);
    EndIf
EndFunc

Func CHECKKEY($USER, $PASS)        <- check function, the original
    Local $OPKEY = "", $SIG = ""
    Local $USER_LEN = StringLen($USER)
    Local $PASS_LEN = StringLen($PASS)
    If $USER_LEN < $PASS_LEN Then
        MsgBox(0, "ERROR", "Invalid username or key.")
    ElseIf $USER_LEN < 4 Then
        MsgBox(0, "ERROR", "Invalid username or key.")
        Exit
    EndIf
    $PASS_INT = Int($USER_LEN / $PASS_LEN)
    $PASS_MOD = Mod($USER_LEN, $PASS_LEN)
    $OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
    For $INDEX = 1 To $USER_LEN
        $SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
    Next
    If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
        MsgBox(0, "INFO", "Your key was registered.")
    Else
        MsgBox(0, "INFO", "Your key is invalid.")
    EndIf
EndFunc

Este es el resultado.

01-09-2014 12-18-28

Links


Introducción  Este un crackme muy interesante para principiantes ya que la rutina no es muy compleja. Está hecho en ensamblador.
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
La esperada cuarta entrega de La Jungla de Cristal se metió de lleno en el mundo de los Hackers. Cuando
Toda esta aventura comienza con un archivo llamado pretty_raw, sin extensión. Porque sí. Porque las extensiones son una invención heredada

Cambio de extensión (paso opcional)

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.

Imagen oculta

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«.

02-12-2015 10-17-24

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.

02-12-2015 10-21-16

A continuación un resumen de las imágenes obtenidas.

colortable

Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.

dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe

Descifrando el mensaje

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.

02-12-2015 10-56-29

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.

02-12-2015 10-57-14

Enlaces

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he encontrado con que el repositorio no estaba preparado para todas las distros Linux de forma estándar. El resultado lo he colgado en Github, de modo que para montarlo en vuestra propia Raspi solo tenéis que seguir estos pasos:

1. Clonar el repositorio
git clone https://github.com/deurus/AperiSolve-Raspi3.git
cd AperiSolve-Raspi3/AperiSolve

2. Construir los contenedores
docker compose build
docker compose up -d

3. Abrir la web
http://<IP_RASPI>:5000

Si tenéis curiosidad de la adaptación que he tenido que hacer aquí están los pasos que he seguido:

1. Preparar el sistema
sudo apt update
sudo apt install -y git docker.io docker-compose
sudo usermod -aG docker $USER
newgrp docker

2. Clonar AperiSolve
git clone https://github.com/Zeecka/AperiSolve.git
cd AperiSolve

3. Crear la estructura de build para la imagen ARM/x86
nano docker-compose.yml

y pega este contenido:

FROM python:3.11-slim

RUN apt-get update && apt-get install -y \
    zip \
    p7zip-full \
    binwalk \
    foremost \
    exiftool \
    steghide \
    ruby \
    binutils \
    pngcheck \
    && rm -rf /var/lib/apt/lists/*

COPY aperisolve/ /aperisolve/

RUN pip install --no-cache-dir -r /aperisolve/requirements.txt

WORKDIR /aperisolve

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "wsgi:app"]

4. Arreglar docker-compose.yml para ser válido y compatible

services:
  web:
    image: aperisolve-local
    build: .
    container_name: aperisolve-web
    ports:
      - "5000:5000"
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  worker:
    image: aperisolve-local
    container_name: aperisolve-worker
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  redis:
    image: redis:7
    container_name: aperisolve-redis

  postgres:
    image: postgres:16
    container_name: aperisolve-postgres
    environment:
      POSTGRES_USER: aperiuser
      POSTGRES_PASSWORD: aperipass
      POSTGRES_DB: aperisolve
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

5. Modificar aperisolve/config.py
nano config.py

y pega este contenido:

from pathlib import Path

IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff"]

WORKER_FILES = ["binwalk", "foremost", "steghide", "zsteg"]

RESULT_FOLDER = Path(__file__).parent.resolve() / "results"
RESULT_FOLDER.mkdir(parents=True, exist_ok=True)

6. Modificación de aperisolve/app.py

Sustituir la línea: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI")
por:
default_db = "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI", default_db)

7. Construir la imagen
docker build -t aperisolve-local .

8. Levantar los contenedores
docker compose down
docker compose up -d

9. Comprobar logs
docker logs aperisolve-web --tail=50
docker logs aperisolve-worker --tail=50

10. Acceder a la web
 - Desde cualquier máquina de la red local: http://IP-DE-LA-MAQUINA:5000
 - Desde la Raspi: http://localhost:5000

11. Limpieza (cuando necesites)
 - Reiniciar contenedores:
docker compose restart
 - Borrar resultados antiguos:
sudo rm -r aperisolve/results/*

Intro

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.

Análisis

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

  • Valores del serial: 1(49) -(no se usa) 2(50) 3(51) 4(52) 5(53) 6(54)
  • 1º + 3º: 49 + 50 = 99
  • 4011 – 99 = 3912
  • 1º + 4º: 49 + 51 = 100
  • 3912 – 100 = 3812
  • 1º + 5º: 49 + 52 = 101
  • 3812 – 101 = 3711
  • 1º + 6º: 49 + 53 = 102
  • 3711 – 102 = 3609
  • 1º + 7º: 49 + 54 = 103
  • 3609 – 103 = 3506
  • ¿3506 = 0?
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.

Keygen

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.

  • Tipo A
    • ID: 1111 SERIAL: 0-55555555555
    • ID: 2500 SERIAL: 0-4444444444444444444444444
    • ID: 4982 SERIAL: 1-99999999999999999999999999999999999999999999999
    • ID: 4992 SERIAL: 0-0000000000000000000000000000000000000000000000000000
  • Tipo B
    • ID: 1112 SERIAL: 9-19247C5555
    • ID: 2499 SERIAL: A-C5ADC2233333333333333
    • ID: 4981 SERIAL: 7-C6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
    • ID: 4999 SERIAL: 4-A37BEEB8146A5CE6ECFB422B1BFF8474E852314F5A999
'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.

Links


Intro President’s cat was kidnapped by separatists. A suspect carrying a USB key has been arrested. Berthier, once again, up
While Crackmes.de returns, I leave a couple of files for practice. Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.
Intro Hoy tenemos aquí un crackme del 2009 originario de crackmes.de. El Crackme está hecho en VB6, sin empacar y
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

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


Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
Introducción Cripto 1 Cripto 2 Cripto 3 Cripto 4 Cripto 5 Cripto 6 Cripto 7 Cripto 8 Cripto 9 Cripto 10
Introducción Javascript 1 (Serial a la vista) Javascript 2 (La función charAt()) Javascript 3 (Input) Javascript 4 (Fuerza bruta manual) Javascript
https://www.youtube.com/watch?v=iOYAn4l4wco Lista de reproducción

Intro

Hoy tenemos aquí otro crackme sacado del baúl de los recuerdos. En este caso se trata de una protección por tiempo límite a través de un keyfile llamado «data.det«. Disponemos de tres días o nueve sesiones antes de que el crackme expire.

El algoritmo

La primera vez que ejecutamos el crackme, crea el fichero «data.det» y realiza lo siguiente:

  • Lee el fichero data.det que inicialmente tiene 10 bytes a cero y el último byte un 60(`).
  • Comprueba que tenga 11 bytes (B) y continúa.
  • Al detectar el fichero vacío le mete valores codificandolos con XOR 6969. Los almacena en memoria 4030AB y siguientes.
00401000 t>/$  6A 00               PUSH 0                                    ; /pModule = NULL
00401002   |.  E8 0B020000         CALL <JMP.&KERNEL32.GetModuleHandleA>     ; \GetModuleHandleA
00401007   |.  A3 F4304000         MOV DWORD PTR DS:[4030F4],EAX             ;  kernel32.BaseThreadInitThunk
0040100C   |.  6A 00               PUSH 0                                    ; /hTemplateFile = NULL
0040100E   |.  68 80000000         PUSH 80                                   ; |Attributes = NORMAL
00401013   |.  6A 03               PUSH 3                                    ; |Mode = OPEN_EXISTING
00401015   |.  6A 00               PUSH 0                                    ; |pSecurity = NULL
00401017   |.  6A 00               PUSH 0                                    ; |ShareMode = 0
00401019   |.  68 000000C0         PUSH C0000000                             ; |Access = GENERIC_READ|GENERIC_WRITE
0040101E   |.  68 A2304000         PUSH timetria.004030A2                    ; |FileName = "DATA.DET"
00401023   |.  E8 DE010000         CALL <JMP.&KERNEL32.CreateFileA>          ; \CreateFileA
00401028   |.  83F8 FF             CMP EAX,-1
0040102B   |.  74 07               JE SHORT timetria.00401034
0040102D   |.  A3 14314000         MOV DWORD PTR DS:[403114],EAX             ;  kernel32.BaseThreadInitThunk
00401032   |.  EB 18               JMP SHORT timetria.0040104C
00401034   |>  6A 30               PUSH 30                                   ; /Style = MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL
00401036   |.  68 38304000         PUSH timetria.00403038                    ; |Title = "I don't like this !"
0040103B   |.  68 02304000         PUSH timetria.00403002                    ; |Text = "Where is my DATA.DET file?\r\nI can't run without it..."
00401040   |.  6A 00               PUSH 0                                    ; |hOwner = NULL
00401042   |.  E8 B3010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401047   |.  E9 22010000         JMP timetria.0040116E
0040104C   |>  6A 00               PUSH 0                                    ; /pOverlapped = NULL
0040104E   |.  68 E0304000         PUSH timetria.004030E0                    ; |pBytesRead = timetria.004030E0
00401053   |.  6A 32               PUSH 32                                   ; |BytesToRead = 32 (50.)
00401055   |.  68 AB304000         PUSH timetria.004030AB                    ; |Buffer = timetria.004030AB
0040105A   |.  FF35 14314000       PUSH DWORD PTR DS:[403114]                ; |hFile = NULL
00401060   |.  E8 B9010000         CALL <JMP.&KERNEL32.ReadFile>             ; \ReadFile
00401065   |.  833D E0304000 0B    CMP DWORD PTR DS:[4030E0],0B
0040106C   |.  0F85 E9000000       JNZ timetria.0040115B
00401072   |.  BB AB304000         MOV EBX,timetria.004030AB
00401077   |.  68 E4304000         PUSH timetria.004030E4                    ; /pSystemTime = timetria.004030E4
0040107C   |.  E8 97010000         CALL <JMP.&KERNEL32.GetSystemTime>        ; \GetSystemTime
00401081   |.  803B 00             CMP BYTE PTR DS:[EBX],0
00401084   |.  75 22               JNZ SHORT timetria.004010A8               ;  Si existe el fichero salta a las comprobaciones
00401086   |.  51                  PUSH ECX
00401087   |.  33C9                XOR ECX,ECX
00401089   |.  EB 15               JMP SHORT timetria.004010A0
0040108B   |>  66:8B81 E4304000    /MOV AX,WORD PTR DS:[ECX+4030E4]          ;  |
00401092   |.  66:35 6969          |XOR AX,6969                              ;  |
00401096   |.  66:8981 AB304000    |MOV WORD PTR DS:[ECX+4030AB],AX          ;  |
0040109D   |.  83C1 02             |ADD ECX,2                                ;  | Bucle de codificacion de data.det por primera vez
004010A0   |>  83F9 08              CMP ECX,8                                ;  |
004010A3   |.^ 76 E6               \JBE SHORT timetria.0040108B              ;  |
004010A5   |.  59                  POP ECX                                   ;  kernel32.7580EE1C
004010A6   |.  EB 3A               JMP SHORT timetria.004010E2

 

Vigilando el proceso de creación del archivo podemos llegar a la conclusión de como se genera.

  • Los dos primeros bytes son el año = 2014 = 0x7DE. 7DE XOR 6969 = 6EB7.
  • Los dos siguientes son el mes = 10 = 0xA. A XOR 6969 = 6963.
  • Los dos siguientes usa un 4 (día de la semana???) = 0x4. 4 XOR 6969 = 696D.
  • Los dos siguientes son el día del mes = 2 = 0x2. 2 XOR 6969 = 696B
  • Los dos siguientes usa un 1 = 0x1. 1 XOR 6969 = 6968.
  • El número de sesiones lo deja como está, 60.

Estado de la memoria:

004030AB  B7 6E 63 69 6D 69 6B 69 68 69 60                 ·ncimikihi`
  •  Finalmente le resta 1 al número de sesiones y guarda el fichero.
004010E2   |> \A0 B5304000         MOV AL,BYTE PTR DS:[4030B5]
004010E7   |.  34 69               XOR AL,69
004010E9   |.  3C 00               CMP AL,0
004010EB   |. /74 59               JE SHORT timetria.00401146
004010ED   |. |FEC8                DEC AL
004010EF   |. |A2 01304000         MOV BYTE PTR DS:[403001],AL
004010F4   |. |34 69               XOR AL,69
004010F6   |. |A2 B5304000         MOV BYTE PTR DS:[4030B5],AL
004010FB   |. |6A 00               PUSH 0                                    ; /Origin = FILE_BEGIN
004010FD   |. |6A 00               PUSH 0                                    ; |pOffsetHi = NULL
004010FF   |. |6A 00               PUSH 0                                    ; |OffsetLo = 0
00401101   |. |FF35 14314000       PUSH DWORD PTR DS:[403114]                ; |hFile = 00000034 (window)
00401107   |. |E8 18010000         CALL <JMP.&KERNEL32.SetFilePointer>       ; \SetFilePointer
0040110C   |. |6A 00               PUSH 0                                    ; /pOverlapped = NULL
0040110E   |. |68 E0304000         PUSH timetria.004030E0                    ; |pBytesWritten = timetria.004030E0
00401113   |. |6A 0B               PUSH 0B                                   ; |nBytesToWrite = B (11.)
00401115   |. |68 AB304000         PUSH timetria.004030AB                    ; |Buffer = timetria.004030AB
0040111A   |. |FF35 14314000       PUSH DWORD PTR DS:[403114]                ; |hFile = 00000034 (window)
00401120   |. |E8 05010000         CALL <JMP.&KERNEL32.WriteFile>            ; \WriteFile

En cada ejecución realiza tres comprobaciones.
Recordemos el contenido del fichero:

B7 6E 63 69 6D 69 6B 69 68 69 60                 ·ncimikihi`

1) Mes y año (4 primeros bytes)

004010A8   |> \8B0D AB304000       MOV ECX,DWORD PTR DS:[4030AB] ; ECX=69636EB7
004010AE   |.  81F1 69696969       XOR ECX,69696969              ; 69636EB7 xor 69696969 = A07DE (A = mes y 7DE = año)
004010B4   |.  A1 E4304000         MOV EAX,DWORD PTR DS:[4030E4]
004010B9   |.  3BC1                CMP EAX,ECX                   ; Compara con mes y año actuales
004010BB   |.  0F85 85000000       JNZ timetria.00401146         ; Bad boy

2) Día (7º y 8º byte)

004010C1   |.  66:8B0D B1304000    MOV CX,WORD PTR DS:[4030B1]   ; CX = 696B
004010C8   |.  66:81F1 6969        XOR CX,6969                   ; 696B xor 6969 = 2
004010CD   |.  66:A1 EA304000      MOV AX,WORD PTR DS:[4030EA]   ; AX = día actual obtenido con GetSystemTime
004010D3   |.  66:2BC1             SUB AX,CX                     ; Los resta
004010D6   |.  66:83F8 03          CMP AX,3                      ; Compara con 3
004010DA   |.  77 6A               JA SHORT timetria.00401146    ; Si el resultado >=3 Bad Boy

3) Sesiones (11º byte)

004010DC   |.  2805 00304000       SUB BYTE PTR DS:[403000],AL   ;
004010E2   |>  A0 B5304000         MOV AL,BYTE PTR DS:[4030B5]   ; AL = numero de sesiones actual
004010E7   |.  34 69               XOR AL,69                     ; 61 Xor 69 = 8
004010E9   |.  3C 00               CMP AL,0                      ; Compara con 0
004010EB   |.  74 59               JE SHORT timetria.00401146    ; Salta si hemos superado las 9 sesiones. Bad boy
004010ED   |.  FEC8                DEC AL                        ; Si no le resta 1
004010EF   |.  A2 01304000         MOV BYTE PTR DS:[403001],AL
004010F4   |.  34 69               XOR AL,69                     ; y le hace xor 69 para codificar el nuevo valor de sesión
004010F6   |.  A2 B5304000         MOV BYTE PTR DS:[4030B5],AL

Con esto ya podemos alterar el archivo a nuestro antojo sin necesidad de parchear.

Keygen

Try
            ano = ano Xor 26985
            mes = mes Xor 26985
            dia = dia Xor 26985
            anos = Hex(ano).ToString
            mess = Hex(mes).ToString
            dias = Hex(dia).ToString
            If txtsesiones.Text <= 255 Then
                sesioness = Hex(sesiones)
            Else
                sesiones = 255
            End If
            sesioness = Hex(sesiones)
            'key = 00 00 00 00 00 00 00 00 00 00 00
            'key = año+año+mes+mes+X+X+dia+dia+X+sesiones
            key = Chr(Convert.ToInt32(anos.Substring(2, 2), 16)) & Chr(Convert.ToInt32(anos.Substring(0, 2), 16)) _
            & Chr(Convert.ToInt32(mess.Substring(2, 2), 16)) & Chr(Convert.ToInt32(mess.Substring(0, 2), 16)) _
            & Chr(106) & Chr(105) _
            & Chr(Convert.ToInt32(dias.Substring(2, 2), 16)) & Chr(Convert.ToInt32(dias.Substring(0, 2), 16)) _
            & Chr(103) & Chr(105) _
            & Chr(Convert.ToInt32(sesioness.Substring(0, 2), 16))
            'Creo el archivo llave
            Dim ruta As String = Application.StartupPath & "\DATA.DET"
            If File.Exists(ruta) Then
                File.Delete(ruta)
            End If
            Using sw As StreamWriter = New StreamWriter(ruta, True, System.Text.Encoding.Default)
                sw.Write(key)
                sw.Close()
            End Using
            MsgBox("DATA.DET generado correctamente", MsgBoxStyle.Information + MsgBoxStyle.OkOnly, "Info")
        Catch ex As Exception
            MsgBox("Ocurrió algún error" & vbCrLf & ex.Message)
        End Try

 Links


Intro Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir
Sinopsis Enemigo público (Enemy of the State) es una película de acción y suspense dirigida por Tony Scott, estrenada en
Introducción A quien va dirigido Comprobaciones previas Lo que necesitamos Presupuesto Ejemplo de instalación Preguntas frecuentes Glosario Notas finales Introducción
Cambio de extensión Imagen oculta Descifrando el mensaje Enlaces Cambio de extensión (paso opcional) Al descargar la imagen de la

Intro

Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir que para cada reto hay una herramienta que nos da la solución. En la entrada anterior os comenté que mi fondo de armario son steganabara y stegsolve aunque cuando la imagen es PNG, una herramienta de uso obligatorio es TweakPNG.

La víctima

imagen original del reto

Nos enfrentamos a una imagen PNG de 112KB (115477 bytes) con una resolución de 300×225 píxeles. A priori llama la atención el elevado tamaño VS la baja resolución, lo que aviva nuestras sospechas de que esos KB extras se deban a que haya insertado otro archivo en su interior.

Chunk

Los archivos PNG tienen la peculiaridad de que están divididos en secciones (chunks) en la que algunas son críticas como IHDR (cabecera), IDAT (la imagen) e IEND (final) y otras muchas secundarias como por ejemplo tEXt (para insertar texto). Al explorar el archivo con TweakPNG vemos la cabecera, varios chunks de texto, muchos IDAT que he combinado en uno para mejorar el análisis y la sección final. Si os fijáis, al combinar los IDAT ha cambiado el tamaño del PNG de 115447 a 110893 bytes aunque en este caso sigue siendo un tamaño elevado.

aspecto original de los chunks
aspecto de los chunks tras combinar todos los IDAT en uno

Llama la atención el chunk cHRm de 12595 bytes del que TweakPNG ya nos avisa que no reconoce su contenido. Cargamos la imagen en un editor hexadecimal y buscamos la palabra «Great» que es el texto que hay justo antes del chunk cHRm que nos interesa.

detalle del chunk cHRm en editor hexadecimal

La búsqueda da sus frutos ya que el chunk parece que está formado por un archivo mp4. A partir de aquí tenemos varias opciones, para mí la más limpia es con un editor hexadecimal apuntar los offsets de inicio y fin del chunk y crear un archivo nuevo con el contenido. Otra opción es exportar el chunk desde TweakPNG con extensión mp4 y borrar los bytes del nombre del chunk con un editor hexadecimal, de lo contrario no podréis reproducir el mp4.

nombre del chunk a borrar para que funcione el mp4

Hecho esto, al escuchar el mp4 obtenemos la solución del reto.

Enlaces

Nota: si algo os pide clave es deurus.info

Sinopsis

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.

Tecnología utilizada

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.

El PC de Daniel Zavitz (Jason Lee)

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.

El Equipo de Edward «Brill» Lyle (Gene Hackman)

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.

Conclusión

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:

  • Se ve el escritorio de Windows 98 con fondo negro y tres aplicaciones abiertas, QuickTime for Windows, una carpeta y una imagen.
  • Una carpeta abierta con cuatro archivos DIR y nombres que nos hacen creer que uno está encriptado y otro no. Dos archivos de imagen con extensión TIF y dos archivos de vídeo con extensión MOV. Ojo porque DIR es la extensión de proyectos de Adobe Director, ahí lo dejo.
  • La animación muestra el 100% antes que la barra de progreso llegue al final.
  • Una vez decodificado se nos muestra el vídeo pero como se nos mostró anteriormente con el media player de Windows 3.1. Incluso se ve el icono de minimizar típico de Windows 3.1 en la parte superior izquierda (última imagen).

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.

Introducción

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.

A quién va dirigido

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.

Comprobaciones previas

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.

Lo que necesitamos

Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.

  • Router gigabit (en caso del que tu compañia no lo sea).

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.

tp_link_tl_wr1043nd_ultimate_router_neutro_wifi_11n_usb_4

  • Switch gigabit (para ampliar puertos)

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.

tp_link_tl_sg1005d_switch_5_puertos_gigabit

  • Tarjeta de red gigabit (para pc sobremesa en caso de no ser o no disponer)

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.

tarjeta-de-red-tp-link-tg-3269-gigabit-pci-internet-101000-1859-MLU4520989306_062013-F

  • Bobina de cable de red Categoría 6.

100m de cable UTP categoría 6 viene a costar sobre unos 42€.

bobina_100m_cable_red_rigido_utp_cat_6_10_100_1000

  • Cables Cat6 interconexionado router / switch / pc.

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.

digitus_cable_de_red_rj45_cat_6_10_100_1000_gris__50cm_

  • Tomas RJ45 categoría 6.

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€.

roseta_de_superficie_cat6_conector_red_hembra_rj45 roseta_empotrable_cat5e_2_conectores_red_45__hembra_rj_45

  • Insertadora (punch down) para las tomas RJ45.

Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.

PCS058007_large

  • Disco duro de red NAS

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€.

wd_my_cloud_4tb

Presupuesto (Precios Octubre 2014)

  • Router = 44€
  • Switch = 16€
  • Tarjeta de red = 15€
  • Bobina de cable = 42€
  • Cables interconexionado 50cm x4 = 6€
  • Cable conexión pc / switch o router 1,8m = 2,95€
  • Tomas RJ45 x 2 = 16,5€
  • Disco duro de red NAS = 159€
  • TOTAL = 345,45€ + gastos de envío.

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.

Ejemplo de instalación

Esquema inicial

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.

esquema

Configurar router neutro

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á.

Disco duro de red NAS

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.

Preguntas frecuentes. FAQ

  • ¿El cable normal o cruzado?

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.

  • ¿Qué norma de colores uso?

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.

image002

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.

con_roseta

  • Tengo todo instalado y es categoría 6 pero mi pc me marca que me conecta a 100mbps ¿qué pasa?

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.

31-10-2014 21-47-55

Pulsa Configurar.

31-10-2014 21-49-19

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.

31-10-2014 21-50-31

Glosario

  1. NAS – del inglés Network Attached Storage, es el nombre dado a una tecnología de almacenamiento dedicada a compartir la capacidad de almacenamiento a través de una red. Estos discos vienen equipados como mínimo con una conexión RJ45 para integrarlo en una red de forma rápida y sencilla.
  2. Full Duplex – Que transmite y recibe en ambas direcciones al mismo tiempo por cables independientes.
  3. Switch – Un conmutador o switch es un dispositivo digital lógico de interconexión de equipos que opera en la capa de enlace de datos del modelo OSI. Su función es interconectar dos o más segmentos de red, de manera similar a los puentes de red, pasando datos de un segmento a otro de acuerdo con la dirección MAC de destino de las tramas en la red.
  4. Gigabit Ethernet – también conocida como GigaE, es una ampliación del estándar Ethernet (concretamente la versión 802.3ab y 802.3z del IEEE) que consigue una capacidad de transmisión de 1 gigabit por segundo, correspondientes a unos 1000 megabits por segundo de rendimiento contra unos 100 de Fast Ethernet (También llamado 100BASE-TX).

Notas finales

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.

Cambio de extensión (paso opcional)

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.

Imagen oculta

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«.

02-12-2015 10-17-24

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.

02-12-2015 10-21-16

A continuación un resumen de las imágenes obtenidas.

colortable

Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.

dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe

Descifrando el mensaje

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.

02-12-2015 10-56-29

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.

02-12-2015 10-57-14

Enlaces