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.

Intro

This crackme is for the crack challenge 6 of canyouhack.it.

In this crackme the goal is to turn on all the lights. Note that a light off to the next, so if we interrupt this, we win.

Tools

Exeinfo (For crackme info)

Delphi Decompiler (For decompile)

 OllyDbg (For debug)

Decompiling

With Delphi Decompiler we can found easy the buttons and his offsets.
Go to the offset 401A64 in OllyDbg and analyze the code.
We view two jumps, one turn ON the light and the other Turn OFF the next light. Patching the call from offset 401A8B we get the serial.

Links


Introducción Funcionamiento de RSA OllyDbg Calculando la clave privada (d) Ejemplo operacional Keygen Links Introducción Segunda crackme con RSA que
Introducción El otro día navegando por la red fuí a dar a un mirror de la gran web "Karpoff Spanish
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Primeras impresiones El crackme es el típico de usuario y número de serie. Si no introduces un nombre te salta

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.

Introducción

Realistic Challenge 3: Your school is employing a web designer who is charging far too much for site design and doesn’t know anything about protecting the site. However, he’s sure that there’s no way anyone can hack into any site he’s designed, prove him wrong!
 En tu escuela están haciendo una web nueva muy rápido. El creador asegura que no le pueden hackear, demuéstrale que está equivocado.

Analizando a la víctima

Echamos un vistazo y vemos en el menú cosas interesantes. La primera de ellas es un Login que pronto descartamos ya que no parece llevar a ninguna parte. La segunda sirve para mandar enlaces al administrador y que este los publique posteriormente en la web.
Vamos a trastear un poco con la opción de mandar enlaces. En el código fuente ya vemos algo interesante y es que hay un campo oculto con el valor a 1 al mandar el enlace. Probamos a mandar un enlace sin tocar nada y nos dice que lo manda pero que lo tienen que aprobar. Vamos a probar ahora cambiando el valor del parámetro oculto a 0 con Firebug.

¡Funcionó!, el enlace ha pasado el filtro.

¿Cómo podemos aprovechar esto?, pués la forma más común es «XSS cross site scripting«. Veamos una prueba. Con el parámetro oculto otra vez en 0 mandamos el siguiente enlace y reto superado.

Links

Introducción

Empezamos con lo que espero que sea una serie de crackmes RSA. En este caso en particular y como el propio autor nos adelanta, se trata de RSA-200.

En criptografía, RSA (Rivest, Shamir y Adleman) es un sistema criptográfico de clave pública desarrollado en 1977. Es el primer y más utilizado algoritmo de este tipo y es válido tanto para cifrar como para firmar digitalmente.

 Funcionamiento de RSA

  1. Inicialmente es necesario generar aleatoriamente dos números primos grandes, a los que llamaremos p y q.
  2. A continuación calcularemos n como producto de p y q:
    n = p * q
  3. Se calcula fi:
    fi(n)=(p-1)(q-1)
  4. Se calcula un número natural e de manera que MCD(e, fi(n))=1 , es decir e debe ser primo relativo de fi(n). Es lo mismo que buscar un numero impar por el que dividir fi(n) que de cero como resto.
  5. Mediante el algoritmo extendido de Euclides se calcula d que es el inverso modular de e.
    Puede calcularse d=((Y*fi(n))+1)/e para Y=1,2,3,... hasta encontrar un d entero.
  6. El par de números (e,n) son la clave pública.
  7. El par de números (d,n) son la clave privada.
  8. Cifrado: La función de cifrado es.
    c = m^e mod n
  9. Descifrado: La función de descifrado es.
    m = c^d mod n

OllyDbg

Con OllyDbg analizamos la parte del código que nos interesa.

00401065  |>push    19                          ; /Count = 19 (25.)
00401067  |>push    00404330                    ; |Buffer = dihux_ke.00404330
0040106C  |>push    2711                        ; |ControlID = 2711 (10001.)
00401071  |>push    dword ptr [ebp+8]           ; |hWnd
00401074  |>call    <GetDlgItemTextA>           ; \GetDlgItemTextA
00401079  |>cmp     eax, 5                      ;  Tamaño nombre >= 5
0040107C  |>jb      00401214
00401082  |>cmp     eax, 14                     ;  Tamaño nombre <= 0x14
00401085  |>ja      00401214
0040108B  |>mov     [404429], eax
00401090  |>push    96                          ; /Count = 96 (150.)
00401095  |>push    00404349                    ; |Buffer = dihux_ke.00404349
0040109A  |>push    2712                        ; |ControlID = 2712 (10002.)
0040109F  |>push    dword ptr [ebp+8]           ; |hWnd
004010A2  |>call    <GetDlgItemTextA>           ; \GetDlgItemTextA
004010A7  |>test    al, al
........
004010D8  |>xor     ecx, ecx                    ;  Case 0 of switch 004010B6
004010DA  |>/push    0
004010DC  |>|call    <__BigCreate@4>
004010E1  |>|mov     [ecx*4+404411], eax
004010E8  |>|inc     ecx
004010E9  |>|cmp     ecx, 6
004010EC  |>\jnz     short 004010DA
004010EE  |>push    dword ptr [404411]          ; /Arg3 = 00B60000
004010F4  |>push    10                          ; |16??
004010F6  |>push    0040401F                    ; |Arg1 = 0040401F ASCII "8ACFB4D27CBC8C2024A30C9417BBCA41AF3FC3BD9BDFF97F89"
004010FB  |>call    <__BigIn@12>                ; \dihux_ke.004013F3
00401100  |>push    dword ptr [404415]          ; /Arg3 = 00C70000
00401106  |>push    10                          ; |Arg2 = 00000010
00401108  |>push    00404019                    ; |Arg1 = 00404019 ASCII "10001"
0040110D  |>call    <__BigIn@12>                ; \dihux_ke.004013F3
00401112  |>push    dword ptr [404425]          ; /Arg3 = 00CB0000
00401118  |>push    10                          ; |Arg2 = 00000010
0040111A  |>push    00404349                    ; |Arg1 = 00404349 ASCII "123456789123456789"
0040111F  |>call    <__BigIn@12>                ; \dihux_ke.004013F3
00401124  |>push    00404330                    ; /String = "deurus"
00401129  |>call    <lstrlenA>                  ; \lstrlenA
0040112E  |>push    dword ptr [404419]
00401134  |>push    eax
00401135  |>push    00404330                    ;  ASCII "deurus"
0040113A  |>call    <__BigInB256@12>
0040113F  |>push    dword ptr [404421]          ;  c
00401145  |>push    dword ptr [404411]          ;  n = 8ACFB4D27CBC8C2024A30C9417BBCA41AF3FC3BD9BDFF97F89
0040114B  |>push    dword ptr [404415]          ;  e = 10001
00401151  |>push    dword ptr [404425]          ;  serial
00401157  |>call    <__BigPowMod@16>            ;  c = serial^e (mod n)
0040115C  |>mov     eax, 1337
00401161  |>push    0                           ; /Arg4 = 00000000
00401163  |>push    dword ptr [40441D]          ; |x
00401169  |>push    eax                         ; |0x1337
0040116A  |>push    dword ptr [404421]          ; |c
00401170  |>call    <__BigDiv32@16>             ; \x = c/0x1337
00401175  |>push    dword ptr [40441D]          ;  x
0040117B  |>push    dword ptr [404419]          ;  nombre
00401181  |>call    <__BigCompare@8>            ; ¿x = nombre?
00401186  |>jnz     short 0040119C
00401188  |>push    0                           ; /Style = MB_OK|MB_APPLMODAL
0040118A  |>push    00404014                    ; |Title = "iNFO"
0040118F  |>push    00404004                    ; |Text = "Serial is valid"
00401194  |>push    dword ptr [ebp+8]           ; |hOwner
00401197  |>call    <MessageBoxA>               ; \MessageBoxA
0040119C  |>xor     ecx, ecx
0040119E  |>/push    dword ptr [ecx*4+404411]
004011A5  |>|call    <__BigDestroy@4>
004011AA  |>|inc     ecx
004011AB  |>|cmp     ecx, 6
004011AE  |>\jnz     short 0040119E

 Lo primero que observamos es que el código nos proporciona el exponente público (e) y el módulo (n).

  • e = 10001
  • n = 8ACFB4D27CBC8C2024A30C9417BBCA41AF3FC3BD9BDFF97F89

A continuación halla c = serial^d mod n. Finalmente Divide c entre 0x1337 y lo compara con el nombre.

Como hemos visto en la teoría de RSA, necesitamos hallar el exponente privado (d) para poder desencriptar, según la fórmula vista anteriormente.

  • Fórmula original: m=c^d mod n
  • Nuestra fórmula: Serial = x^d mod n. Siendo x = c * 0x1337

Calculando un serial válido

Existen varios ataques a RSA, nosotros vamos a usar el de factorización. Para ello vamos a usar la herramienta RSA Tool. Copiamos el módulo (n), el exponente público (e) y factorizamos (Factor N).

rsatool1

Hallados los primos p y q, hallamos d (Calc. D).

rsatool4

Una vez obtenido d solo nos queda obtener x, que recordemos es nombre * 0x1337.

Cuando decimos nombre nos referimos a los bytes del nombre en hexadecimal, para deurus serían 646575727573.

Ejemplo operacional

Nombre: deurus

x = 646575727573 * 0x1337 = 7891983BA4EC4B5
Serial = x^d mod n
Serial = 7891983BA4EC4B5^32593252229255151794D86C1A09C7AFCC2CCE42D440F55A2D mod 8ACFB4D27CBC8C2024A30C9417BBCA41AF3FC3BD9BDFF97F89
Serial = FD505CADDCC836FE32E34F5F202E34D11F385DEAD43D87FCD

Como la calculadora de Windows se queda un poco corta para trabajar con números tan grandes, vamos a usar la herramienta Big Integer Calculator. A continuación os dejo unas imágenes del proceso.

bigint_1

bigint_2

crackme_dihux_solved

Keygen

En esta ocasión hemos elegido Java ya que permite trabajar con números grandes de forma sencilla, os dejo el código más importante.

dihux_keygenme1_keygen

JButton btnNewButton = new JButton("Generar");
btnNewButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
BigInteger serial = new BigInteger("0");
BigInteger n = new BigInteger("871332984042175151665553882265818310920539633758381377421193");//módulo
BigInteger d = new BigInteger("316042180198461106401603389463895139535543421270452849695277");//exponente privado
BigInteger x = new BigInteger("4919");//0x1337
String nombre = t1.getText();
BigInteger nombre2 = new BigInteger(nombre.getBytes());
nombre2 = nombre2.multiply(x);
serial = nombre2.modPow(d, n);
t2.setText(serial.toString(16).toUpperCase());
}
});

Links


Introducción Javascript 1 (Serial a la vista) Javascript 2 (La función charAt()) Javascript 3 (Input) Javascript 4 (Fuerza bruta manual) Javascript
En Parque Jurásico (1993), la informática no es solo un elemento narrativo, es una pieza clave del suspense y del
Rebuscando entre todo el caos que puede llegar a ser mi disco duro, he encontrado una serie de programas que
Intro Hoy tenemos un crackme realizado en Visual C++ 6. Es el típico serial asociado a un nombre. El algoritmo

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

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.

Rebuscando entre todo el caos que puede llegar a ser mi disco duro, he encontrado una serie de programas que utilizaba antiguamente cuando empezó a interesarme el Cracking. Ya sabéis que no soy partidario de crackear programas comerciales pero hoy voy a hacer una excepción ya que la versión del programa es muy vieja (1997) e incluso podría considerarse abandonware.

Este ejercicio es ideal para los que están empezando ya que es fácil localizar donde está el algoritmo y éste es sumamente sencillo.

Table of Contents

Algoritmo

Address   Hex dump          Command                                      Comments
00402213    E8 78170000     CALL HEdit.00403990
........
004039C0    8BC1            MOV EAX,ECX
004039C2    99              CDQ
004039C3    33C2            XOR EAX,EDX
004039C5    2BC2            SUB EAX,EDX
004039C7    83E0 03         AND EAX,00000003
004039CA    33C2            XOR EAX,EDX
004039CC    2BC2            SUB EAX,EDX
004039CE    8A540C 04       MOV DL,BYTE PTR SS:[ECX+ESP+4]  ;Coge el dígito i*3
004039D2    8A5C04 04       MOV BL,BYTE PTR SS:[EAX+ESP+4]  ;Coge el dígito i
004039D6    8D4404 04       LEA EAX,[EAX+ESP+4]             ;Guarda en memoria 12EE90
004039DA    32DA            XOR BL,DL
004039DC    41              INC ECX                         ; i +=1
004039DD    81F9 00010000   CMP ECX,100                     ;El bucle se repite 256 veces (0x100)
004039E3    8818            MOV BYTE PTR DS:[EAX],BL
004039E5  ^ 7C D9           JL SHORT HEdit.004039C0
004039E7    8B4424 04       MOV EAX,DWORD PTR SS:[ESP+4]
004039EB    85C0            TEST EAX,EAX                    ;Comprueba que el serial no sea 0
004039ED    7D 02           JGE SHORT HEdit.004039F1        ;Si es 0 se acabó
004039EF    F7D8            NEG EAX
004039F1    3B8424 0C010000 CMP EAX,DWORD PTR SS:[ESP+10C]  ;Comprobación de serial válido
004039F8    75 13           JNE SHORT HEdit.00403A0D        ;Si no es igual bad boy
004039FA    85C0            TEST EAX,EAX                    ;Comprueba que el serial no sea 0
004039FC    74 0F           JE SHORT HEdit.00403A0D         ;Si es 0 se acabó
004039FE    B8 01000000     MOV EAX,1
00403A03    5B              POP EBX
00403A04    81C4 00010000   ADD ESP,100
00403A0A    C2 0800         RETN 8

En resumen hace esto:

- Nombre introducido: deurus
- Convierte el nombre a mayúsculas

D  E  U  R  U  S
44 45 55 52 55 53 (En Hexadecimal)

1) 55 xor 44 = 11
2) 53 xor 45 = 16
3) 00 xor 55 = 55
4) 00 xor 52 = 52
   --------------- solo vale hasta aquí EAX(32 bits)
5) 00 xor 55 = 55
6) 00 xor 53 = 53
7) 00 xor 00 = 00
8) ...
            HEX         DEC
Serial = 52551611 = 1381307921

Como veis, realiza un bucle 256 veces pero como al final utiliza el registro EAX para hacer la comparación, solamente nos sirven las cuatro primeras operaciones. De hecho, no comprueba ni la longitud del nombre por lo que si introducimos un solo dígito como nombre, el serial será el valor ascii de ese dígito en decimal. La única comprobación que realiza es que el serial no sea 0.

Keygen

Os dejo una prueba de concepto en Javascript.

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

serial = serial + nombre.charCodeAt(3).toString(16) + nombre.charCodeAt(2).toString(16);
serial = serial + (nombre.charCodeAt(5) ^ nombre.charCodeAt(1)).toString(16);
serial = serial + (nombre.charCodeAt(2) ^ nombre.charCodeAt(0)).toString(16);
serial = "Nº Serie: " + parseInt(serial,16);

document.write(serial);

Enlaces

Yuri Software

Intro

Hoy tenemos un crackme realizado en Visual C++ 6. Es el típico serial asociado a un nombre.

El algoritmo

Localizamos con Olly la rutina de comprobación del serial y empezamos a analizar. Vemos una serie de Calls que lo único que hacen es comprobar el tamaño de nuestro nombre y serial y si es <5 dígitos nos tira afuera.

saltos_iniciales

Una vez pasada la traba anterior procede con un bucle para el nombre y otro para el serial. Yo he metido deurus y 123456. El bucle del nombre hace xor al los dígitos ascii con un valor incremental a partir de 1. Reconvierte el valor resultante en su caracter correspondiente y lo almacena.

00401576     |.  B9 01000000   MOV ECX,1                         ; ECX = 1
0040157B     |.  33D2          XOR EDX,EDX
0040157D     |.  8B45 E4       MOV EAX,[LOCAL.7]                 ; EAX = Nombre
00401580     |>  8A18          /MOV BL,BYTE PTR DS:[EAX]         ; BL = digito que toque  <--
00401582     |.  32D9          |XOR BL,CL                        ; digito XOR ECX
00401584     |.  8818          |MOV BYTE PTR DS:[EAX],BL         ; sustituye el digito nombre por el resultante del xor
00401586     |.  41            |INC ECX                          ; ECX++
00401587     |.  40            |INC EAX                          ; Siguiente digito
00401588     |.  8038 00       |CMP BYTE PTR DS:[EAX],0
0040158B     |.^ 75 F3         \JNZ SHORT crackme3.00401580      ; Bucle -->

 Ejemplo:

d  e  u  r  u  s
64 65 75 72 75 73

(d)64 xor 1 = 65(e)
(e)65 xor 2 = 67(g)
(u)75 xor 3 = 76(v)
(r)72 xor 4 = 76(v)
(u)75 xor 5 = 70(p)
(s)73 xor 6 = 75(u)

Nombre:    deurus
Resultado: egvvpu

Hace lo mismo con el serial pero con el valor incremental a partir de 0xA (10).

00401593     |.  B9 0A000000    MOV ECX,0A                      ; ECX = A
00401598     |.  33D2           XOR EDX,EDX
0040159A     |.  8B45 F0        MOV EAX,[LOCAL.4]               ; EAX = Serial
0040159D     |>  8A18           /MOV BL,BYTE PTR DS:[EAX]       ; BL = digito que toque  <--
0040159F     |.  32D9           |XOR BL,CL                      ; BL XOR CL
004015A1     |.  8818           |MOV BYTE PTR DS:[EAX],BL       ; sustituye el digito serial por el resultante del xor
004015A3     |.  41             |INC ECX                        ; ECX++
004015A4     |.  40             |INC EAX                        ; Siguiente digito
004015A5     |.  8038 00        |CMP BYTE PTR DS:[EAX],0
004015A8     |.^ 75 F3          \JNZ SHORT crackme3.0040159D    ; Bucle -->

Ejemplo:

1  2  3  4  5  6
31 32 33 34 35 35

(1)31 xor A = 3B(;)
(2)32 xor B = 39(9)
(3)33 xor C = 3F(?)
(4)34 xor D = 39(9)
(5)35 xor E = 3B(;)
(6)36 xor F = 39(9)

Serial:    123456
Resultado: ;9?9;9

A continuación compara «egvvpu» con «;9?9;9» byte a byte.

KeyGen

El KeyGen quedaría así

for(int i = 0; i <= strlen(Nombre); i = i + 1)
                {
                        Serial[i] = (Nombre[i]^(i+1))^(0xA + i);
                }

 Links


Se nos entrega el siguiente ELF: Extracción de la Flag Si nos fijamos en las líneas 41 a la 45
Hoy en día, la descarga de contenido multimedia de ciertas webs es imposible o muy difícil. En ciertos casos lo
http://youtu.be/KR3PgtDMjmg Lista de reproducción
MI_cartel
Intro La primera entrega de Misión Imposible es ya un clásico y poco o nada tiene que envidiar a sus

Se nos entrega el siguiente ELF:

/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
   Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

__int64 (**init_proc())(void);
void sub_1020();
// int printf(const char *format, ...);
// int getchar(void);
// int fflush(FILE *stream);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
// int __fastcall _cxa_finalize(void *);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
FILE **deregister_tm_clones();
__int64 register_tm_clones(); // weak
FILE **_do_global_dtors_aux();
__int64 __fastcall frame_dummy(_QWORD, _QWORD, _QWORD); // weak
int __fastcall main(int argc, const char **argv, const char **envp);
_BOOL8 __fastcall comprobacion(char a1, char a2, int a3);
void _libc_csu_fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// int __fastcall __cxa_finalize(void *);
// __int64 _gmon_start__(void); weak

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN _libc_csu_init;
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
void *_dso_handle = &_dso_handle; // idb
char *a = "MdfnJk"; // weak
char *b = "jYx}"; // weak
char *c = "gWmfk"; // weak
char *d = "mlvpc"; // weak
char *f = "neU++w"; // weak
FILE *_bss_start; // idb
char completed_0; // weak


//----- (0000000000001000) ----------------------------------------------------
__int64 (**init_proc())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}
// 40D0: using guessed type __int64 _gmon_start__(void);

//----- (0000000000001020) ----------------------------------------------------
void sub_1020()
{
  JUMPOUT(0LL);
}
// 1026: control flows out of bounds to 0

//----- (0000000000001090) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  _libc_start_main(
    (int (__fastcall *)(int, char **, char **))main,
    v4,
    &retaddr,
    (void (*)(void))_libc_csu_init,
    _libc_csu_fini,
    a3,
    &v5);
  __halt();
}
// 1096: positive sp value 8 has been found
// 109D: variable 'v3' is possibly undefined

//----- (00000000000010C0) ----------------------------------------------------
FILE **deregister_tm_clones()
{
  return &_bss_start;
}

//----- (00000000000010F0) ----------------------------------------------------
__int64 register_tm_clones()
{
  return 0LL;
}
// 10F0: using guessed type __int64 register_tm_clones();

//----- (0000000000001130) ----------------------------------------------------
FILE **_do_global_dtors_aux()
{
  FILE **result; // rax

  if ( !completed_0 )
  {
    if ( &__cxa_finalize )
      _cxa_finalize(_dso_handle);
    result = deregister_tm_clones();
    completed_0 = 1;
  }
  return result;
}
// 4080: using guessed type char completed_0;

//----- (0000000000001175) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
  char v4; // [rsp+7h] [rbp-9h] BYREF
  int v5; // [rsp+8h] [rbp-8h]
  bool v6; // [rsp+Fh] [rbp-1h]

  v6 = 1;
  v5 = 0;
  while ( v6 )
  {
    fflush(_bss_start);
    printf("\nIntroduce la letra correcta:\t");
    __isoc99_scanf("%c", &v4);
    getchar();
    if ( v5 > 5 )
    {
      if ( v5 > 9 )
      {
        if ( v5 > 14 )
        {
          if ( v5 > 19 )
            v6 = comprobacion(v4, f[v5 - 20], 10);
          else
            v6 = comprobacion(v4, d[v5 - 15], 2);
        }
        else
        {
          v6 = comprobacion(v4, c[v5 - 10], 8);
        }
      }
      else
      {
        v6 = comprobacion(v4, b[v5 - 6], 17);
      }
    }
    else
    {
      v6 = comprobacion(v4, a[v5], 5);
    }
    if ( !v6 )
    {
      printf("Incorrecta");
      exit(1);
    }
    printf("\n%c\n", (unsigned int)v4);
    if ( v5 == 25 )
    {
      printf("Ya tienes la flag!!");
      exit(1);
    }
    ++v5;
  }
  return 0;
}
// 1060: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4050: using guessed type char *a;
// 4058: using guessed type char *b;
// 4060: using guessed type char *c;
// 4068: using guessed type char *d;
// 4070: using guessed type char *f;

//----- (0000000000001352) ----------------------------------------------------
_BOOL8 __fastcall comprobacion(char a1, char a2, int a3)
{
  return a1 == (a3 ^ a2);
}

//----- (0000000000001390) ----------------------------------------------------
void __fastcall _libc_csu_init(unsigned int a1, __int64 a2, __int64 a3)
{
  signed __int64 v4; // rbp
  __int64 i; // rbx

  init_proc();
  v4 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
  if ( v4 )
  {
    for ( i = 0LL; i != v4; ++i )
      ((void (__fastcall *)(_QWORD, __int64, __int64))*(&_frame_dummy_init_array_entry + i))(a1, a2, a3);
  }
}
// 1170: using guessed type __int64 __fastcall frame_dummy(_QWORD, _QWORD, _QWORD);
// 3DE8: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 3DF0: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();

//----- (00000000000013F4) ----------------------------------------------------
void term_proc()
{
  ;
}

Extracción de la Flag

Si nos fijamos en las líneas 41 a la 45 vemos las siguientes cadenas:

a = «MdfnJk»
b = «jYx}»
c = «gWmfk»
d = «mlvpc»
f = «neU++w»

Usaremos las cadenas y los valores XOR especificados para cada rango de v5 en el main (líneas 123 a 182) para determinar los caracteres correctos.

Para v5 de 0 a 5: v6 = comprobacion(v4, a[v5], 5);
Significa que: v4 debe ser igual a a[v5] ^ 5

Para v5 de 6 a 9: v6 = comprobacion(v4, b[v5 – 6], 17);
Significa que: v4 debe ser igual a b[v5 – 6] ^ 17

Para v5 de 10 a 14: v6 = comprobacion(v4, c[v5 – 10], 8);
Significa que: v4 debe ser igual a c[v5 – 10] ^ 8

Para v5 de 15 a 19: v6 = comprobacion(v4, d[v5 – 15], 2);
Significa que: v4 debe ser igual a d[v5 – 15] ^ 2

Para v5 de 20 a 25: v6 = comprobacion(v4, f[v5 – 20], 10);
Significa que: v4 debe ser igual a f[v5 – 20] ^ 10

Cálculo de los caracteres correctos:
Para v5 de 0 a 5:
a[0] = ‘M’, M ^ 5 = 0x4D ^ 0x05 = 0x48 -> ‘H’
a[1] = ‘d’, d ^ 5 = 0x64 ^ 0x05 = 0x61 -> ‘a’
a[2] = ‘f’, f ^ 5 = 0x66 ^ 0x05 = 0x63 -> ‘c’
a[3] = ‘n’, n ^ 5 = 0x6E ^ 0x05 = 0x6B -> ‘k’
a[4] = ‘J’, J ^ 5 = 0x4A ^ 0x05 = 0x4F -> ‘O’
a[5] = ‘k’, k ^ 5 = 0x6B ^ 0x05 = 0x6E -> ‘n’
Resulta en la cadena: HackOn

Para v5 de 6 a 9:
b[0] = ‘j’, j ^ 17 = 0x6A ^ 0x11 = 0x7B -> ‘{‘
b[1] = ‘Y’, Y ^ 17 = 0x59 ^ 0x11 = 0x48 -> ‘H’
b[2] = ‘x’, x ^ 17 = 0x78 ^ 0x11 = 0x69 -> ‘i’
b[3] = ‘}’, } ^ 17 = 0x7D ^ 0x11 = 0x6C -> ‘l’
Resulta en la cadena: {Hil

Para v5 de 10 a 14:
c[0] = ‘g’, g ^ 8 = 0x67 ^ 0x08 = 0x6F -> ‘o’
c[1] = ‘W’, W ^ 8 = 0x57 ^ 0x08 = 0x5F -> ‘_’
c[2] = ‘m’, m ^ 8 = 0x6D ^ 0x08 = 0x65 -> ‘e’
c[3] = ‘f’, f ^ 8 = 0x66 ^ 0x08 = 0x6E -> ‘n’
c[4] = ‘k’, k ^ 8 = 0x6B ^ 0x08 = 0x63 -> ‘c’
Resulta en la cadena: o_enc

Para v5 de 15 a 19:
d[0] = ‘m’, m ^ 2 = 0x6D ^ 0x02 = 0x6F -> ‘o’
d[1] = ‘l’, l ^ 2 = 0x6C ^ 0x02 = 0x6E -> ‘n’
d[2] = ‘v’, v ^ 2 = 0x76 ^ 0x02 = 0x74 -> ‘t’
d[3] = ‘p’, p ^ 2 = 0x70 ^ 0x02 = 0x72 -> ‘r’
d[4] = ‘c’, c ^ 2 = 0x63 ^ 0x02 = 0x61 -> ‘a’
Resulta en la cadena: ontra

Para v5 de 20 a 25:
f[0] = ‘n’, n ^ 10 = 0x6E ^ 0x0A = 0x64 -> ‘d’
f[1] = ‘e’, e ^ 10 = 0x65 ^ 0x0A = 0x6F -> ‘o’
f[2] = ‘U’, U ^ 10 = 0x55 ^ 0x0A = 0x5F -> ‘_
f[3] = ‘+’, + ^ 10 = 0x2B ^ 0x0A = 0x21 -> ‘!’
f[4] = ‘+’, + ^ 10 = 0x2B ^ 0x0A = 0x21 -> ‘!’
f[5] = ‘w’, w ^ 10 = 0x77 ^ 0x0A = 0x7D -> ‘}’
Resulta en la cadena: do_!!}

Uniendo todas las partes, obtenemos la flag completa: HackOn{Hilo_enc_ontrado_!!}

Hoy en día, la descarga de contenido multimedia de ciertas webs es imposible o muy difícil. En ciertos casos lo entiendo, exponer el contenido supone una pérdida de ingresos y eso es inaceptable. Las cadenas de TV son tema aparte, emiten contenido por varios medios y les gusta que lo veas y que lo compartas, eso sí, que lo compartas desde su plataforma, ya que lo que estás compartiendo es un enlace, no el vídeo.

Este caso es un caso intermedio entre una plataforma de pago que codifica sus contenidos y una web que nos permita descargar su contenido directamente.

Imaginemos que vemos un vídeo y queremos mandarlo por Whatsapp a nuestros amigos. Lo primero es echar un vistazo al código fuente de la web y localizar el código del reproductor web (player). Para esta tarea podemos ayudarnos de una extensión muy conocida para navegadores como es Firebug. Una vez instalada, la activamos con F12 y mediante el botón Inspect localizamos el player.

...    
<p itemprop="keywords" itemscope="itemscope" itemtype="http://schema.org/Text" class="antetitulo" lang="es">EL INTERMEDIO LE PILLA EN "EL TRONO"</p>
    <h1 class="title-new" itemprop="headline">Joaquín Reyes se mete en la piel de Juan Carlos I: "Soy tan campechano que podéis llamarme Juan Carlos Palote"</h1>
    <sumary class="entradilla" itemprop="description">
<p><p class="MsoNormal">Los reyes eméritos han celebrado sus bodas de esmeralda y
con motivo de tan señalada fecha, Juan Carlos I ha hecho un hueco en su
apretada agenda para concederle unos minutos a <a title="<b>El Intermedio</b>" href="http://www.lasexta.com/temas/el_intermedio-1" target="_blank"><b>El Intermedio</b></a>. Eso sí, en su
versión de <a title="<b>Joaquín Reyes</b>" href="http://www.lasexta.com/temas/joaquin_reyes-1" target="_blank"><b>Joaquín Reyes</b></a>.  <o:p></o:p></p>	</sumary>

	<div class="great-element-multimedia">
	    <section class="modVideo a3mod_player" data-mod="a3mod_player" data-model="/json/video/7/2017/05/15/591a08c1986b2810b31577c1.json">
	        <a itemprop="url" href="#" class="icon link-content" title="" data-mod-elem="icon">
	            <div class="wrap-img" role="banner">
	                <div itemprop="video" itemscope itemtype="http://schema.org/VideoObject">
	                    <picture>
	                        <!--[if IE 9]><video style="display: none;"><![endif]-->
	                        <source media="(max-width:520px)" srcset="http://fotografias.lasexta.com/clipping/cmsimages02/2017/05/15/14069ECA-B0E4-4F09-A5B7-04B600C016AD/64.jpg" />
	                        <source media="(max-width:1023px)" srcset="http://fotografias.lasexta.com/clipping/cmsimages02/2017/05/15/14069ECA-B0E4-4F09-A5B7-04B600C016AD/60.jpg" />
	                        <source media="(min-width:1024px)" srcset="http://fotografias.lasexta.com/clipping/cmsimages02/2017/05/15/14069ECA-B0E4-4F09-A5B7-04B600C016AD/58.jpg" />
	                        <!--[if IE 9]></video><![endif]-->
								<img src="http://fotografias.lasexta.com/clipping/cmsimages02/2017/05/15/14069ECA-B0E4-4F09-A5B7-04B600C016AD/58.jpg" alt="Joaquín Reyes, como el rey Juan Carlos I" title="Joaquín Reyes, como el rey Juan Carlos I" />
	                    </picture>
	                    <meta itemprop="description" content=""/>
	                    <meta itemprop="name" content=""/>
	                    <meta itemprop="thumbnailUrl" content="" />
	                    <meta itemprop="uploadDate" content=""/>
	                    <meta itemprop="url" content=""/>
	                    <meta itemprop="width" content=""/>
	                    <meta itemprop="height" content=""/>
	                </div>
	            </div>
	        </a>
	    </section>
	</div>
...

Si os fijáis bien, el reproductor hace referencia a un archivo json (591a08c1986b2810b31577c1.json), reconstruimos la url y miramos su contenido

{"id":"591a08c1986b2810b31577c1","type":"video","tipo":"video","subtipo":"video","imgThumb":"http://fotografias.lasexta.com/clipping/cmsimages02/2017/05/15/14069ECA-B0E4-4F09-A5B7-04B600C016AD/29.jpg","imgPoster":"http://fotografias.lasexta.com/clipping/cmsimages02/2017/05/15/14069ECA-B0E4-4F09-A5B7-04B600C016AD/31.jpg","live":false,"autoplay":true,"sources":[{"src":"http://vclip.atresmedia.com/vclip/_definst_/smil:assets10/2017/05/15/01229E28-A57E-4AC9-AFE7-EF1C27B5AA2A/es.smil/manifest_mvlist.mpd","type":"application/dash+xml"},{"src":"http://vclip.atresmedia.com/vclip/_definst_/smil:assets10/2017/05/15/01229E28-A57E-4AC9-AFE7-EF1C27B5AA2A/es.smil/playlist.m3u8","type":"application/vnd.apple.mpegurl"}],"omniture":{"section":"Joaquín Reyes","category":"El Intermedio","channel":"lasexta","type":"short","name":"Joaquín Reyes se mete en la piel de Juan Carlos I: \"Soy tan campechano que podéis llamarme Juan Carlos Palote\"","embeddedMode":false},"comscore":{"comscoreTag":"LASEXTA.COM","channel":"lasexta","kantar":{"programID":"1019","firstBroadcastDate":"*null","firstBroadcastTime":"*null","typeTvStream":"0002","kantarGenre":"0","channelId":"240"},"content_form":"short_form"},"urlHits":"http://hits.lasexta.com/l6//591a08c1986b2810b31577c1/3/348128,351435,351827,351865/","duration":"211.797333","embeddedUrl":"<iframe src=\"http://www.lasexta.com/embed/el-intermedio-le-pilla-en-el-trono/video/7/2017/05/15/591a08c1986b2810b31577c1\" width=\"560\" height=\"315\" frameborder=\"0\" allowfullscreen></iframe>","playondraw":true,"nextRelated":{"service_url":"http://www.lasexta.com/json/video/7/2017/05/15/591a08c1986b2810b31577c1_related.json"},"subtitle":[],"titulo":"Joaquín Reyes se mete en la piel de Juan Carlos I: \"Soy tan campechano que podéis llamarme Juan Carlos Palote\"","descripcion":"","sociales":{"hasTwitter":true,"hasFacebook":true,"hasGooglePlus":true,"hasWhatsapp":true,"twitter":"EL INTERMEDIO LE PILLA EN “EL TRONO”","facebook":"EL INTERMEDIO LE PILLA EN “EL TRONO”","googlePlus":"EL INTERMEDIO LE PILLA EN “EL TRONO”","whatsapp":"","hashtag":"","via":"sextaNoticias","urlPage":"https://goo.gl/cu98f0"},"vp_data":{"vp_category":"Atresmedia/Lasexta/programas/el-intermedio*","vp_tags":"","vp_content_form":"short_form"}}

Se puede ver a simple vista una lista de reproducción playlist.m3u8, cuyo contenido contiene más listas de reproducción con diferentes calidades.

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-STREAM-INF:BANDWIDTH=796400,CODECS="avc1.77.30,mp4a.40.5",RESOLUTION=640x360
chunklist_b724000.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1159400,CODECS="avc1.77.30,mp4a.40.5",RESOLUTION=640x360
chunklist_b1054000.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1643400,CODECS="avc1.77.30,mp4a.40.5",RESOLUTION=720x404
chunklist_b1494000.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2248400,CODECS="avc1.77.31,mp4a.40.5",RESOLUTION=1280x720
chunklist_b2044000.m3u8

Reconstruimos la URL para la lista de reproducción de mayor calidad e inspeccionamos su contenido.

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:10
#EXT-X-MEDIA-SEQUENCE:0
#EXTINF:10.0,
media_b2044000_0.ts
#EXTINF:10.0,
media_b2044000_1.ts
#EXTINF:10.0,
media_b2044000_2.ts
#EXTINF:10.0,
media_b2044000_3.ts
#EXTINF:10.0,
media_b2044000_4.ts
#EXTINF:10.0,
media_b2044000_5.ts
#EXTINF:10.0,
media_b2044000_6.ts
#EXTINF:10.0,
media_b2044000_7.ts
#EXTINF:10.0,
media_b2044000_8.ts
#EXTINF:10.0,
media_b2044000_9.ts
#EXTINF:10.0,
media_b2044000_10.ts
#EXTINF:10.0,
media_b2044000_11.ts
#EXTINF:10.0,
media_b2044000_12.ts
#EXTINF:10.0,
media_b2044000_13.ts
#EXTINF:10.0,
media_b2044000_14.ts
#EXTINF:10.0,
media_b2044000_15.ts
#EXTINF:10.0,
media_b2044000_16.ts
#EXTINF:10.0,
media_b2044000_17.ts
#EXTINF:10.0,
media_b2044000_18.ts
#EXTINF:10.0,
media_b2044000_19.ts
#EXTINF:10.0,
media_b2044000_20.ts
#EXTINF:1.92,
media_b2044000_21.ts
#EXT-X-ENDLIST

Se pueden ver 21 archivos con extensión TS de 10 segundos cada uno a excepción del último que dura 1.92 segundos. Los archivos TS no son más que archivos MP4 por lo que una vez descargados, los podemos unir con MP4Tools por ejemplo.

La tarea es costosa, pero si os apetece enviar un vídeo en vez de un enlace, ya sabéis que en determinados casos se puede hacer.

MI_cartel

Intro

La primera entrega de Misión Imposible es ya un clásico y poco o nada tiene que envidiar a sus secuelas. Es ágil, entretenida y como toda peli de espías que se precie, los protagonistas tienen gadgets por un tubo.

El argumento gira sobre la lista NOC. Dicha lista relaciona nombres en clave de agentes repartidos por el mundo con sus nombres reales y al parecer la quiere todo el mundo.

Lista NOC

¿Donde está la lista aquí o aquí?

Al inicio nos hacen creer que la lista NOC está en un sótano de una embajada (No jodas), sin seguridad y accesible por todo el mundo que sepa llegar allí. En esta ocasión no se puede ni llamar hackeo, ya que, el tipo en cuestión simplemente copia la lista (bueno la mitad 😉 en un disco de 3,5″

Tipo robando la lista NOC

¿Eso son Emails o Newsgroups?

Aquí empieza la locura. ¿Os acordáis del BTM de Dexter donde empieza a escribir en foros aleatorios con la esperanza de contactar con el carnicero de la bahía?, pues aquí lo mismo pero con grupos de noticias o newsgroups.

La cosa es que a Ethan Hank no se le ocurre mejor idea para encontrar a Max que buscar en todo tipo de grupos de noticias relacionados con temas bíblicos y en concreto con el libro de Job. Vamos a ver Ethan, hijo del metal, eso es una puta locura, ya de paso anúnciate en el periódico y ponte una diana en el pecho. Pero como es una película resulta que funciona. El caso es que parece que existen la ostia de grupos de discusión donde incluso se puede hablar sobre un capítulo y versículo en particular.

Newsgroup sobre el Libro de Job

El error

El problema es que en cada grupo que encuentra escribe un mensaje muy parecido a como se escribe un email y claro, queda un poco mal. Tanto si quieren hacer creer que escriben un email como si no, el caso es que la escena pierde credibilidad. Ni podría ser un email ni parece factible que alguien se ponga ese nombre de usuario, en definitiva, una chapuza.

¿Parece un email no?

Os dejo una serie de imágenes para que os deleitéis.