crackmes

Intro Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma
Un error que habitualmente cometo cuando me enfrento a todo tipo de retos (especialmente en CTFs) es empezar a procesar
Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la
AperiSolve es un conjunto de herramientas de análisis esteganográfico que nos ayuda a echar un primer vistazo cuando sospechamos que

Shadow’s Register Me – Parchear un .Net

Introducción

Este es un crackme hecho en .Net con dos Nags a parchear y un algoritmo muy sencillo pero que tendremos que parchear para poder resolverlo.

Las Nags

Se encuentran en los eventos de carga y cierre del formulario.

01-09-2014 07-30-07

// RegisterMe.Form1
private void Form1_Load(object sender, EventArgs e)
{
    Interaction.MsgBox("Register me pl0x!", MsgBoxStyle.OkOnly, "Nag!!!!");
}

// RegisterMe.Form1
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    Interaction.MsgBox("Register me pl0x!", MsgBoxStyle.OkOnly, "Nag2!!!!");
}

 Para parchear un ejecutable realizado en .Net primero necesitamos ubicarnos. Abrimos IL Dasm y vamos al evento «Form_Load«, nos fijamos en los bytes y los buscamos con un editor hexadecimal. Fijaros bien en los bytes ya que siguen un orden específico, en la imágen del editor hexadecimal se aprecia perfectamente. Para que quede parcheada la Nag basta con sustituir los valores por ceros. Se parchea todo excepto el «RET (2A)».

01-09-2014 08-03-23

01-09-2014 08-04-01

Para la  otra Nag sería lo mismo.

El algoritmo

El algoritmo es muy sencillo, consiste en la concatenación de varias palabras y un número aleatorio. El problema viene con el número aleatorio ya que lo tendremos que parchear para poder registrar el programa.

// RegisterMe.Form1
private void Button1_Click(object sender, EventArgs e)
{
    this.shadow = this.rand.Next(1, 99999999);
    if (Operators.ConditionalCompareObjectEqual(this.TextBox2.Text, Operators.ConcatenateObject(this.TextBox1.Text + this.TextBox3.Text + this.TextBox4.Text + this.TextBox5.Text + this.TextBox6.Text + this.TextBox7.Text + this.TextBox8.Text + this.TextBox9.Text + this.TextBox1.Text, this.shadow), false))
    {
        this.Button2.Enabled = true;
        this.Button1.Enabled = false;
        this.Button1.Text = "Registered to Shadow";
        this.Text = "Registered to Shadow!";
    }
    else
    {
        Interaction.MsgBox("Incorrect serial, noob.", MsgBoxStyle.OkOnly, null);
    }
}

La concatenación quedaría así:

TextBox1.Text = Nuestro usuario + TextBox3.Text = «ur» + TextBox4.Text = «a» + TextBox5.Text = «stupid» + TextBox6.Text = «dumb» + TextBox7.Text = «idiotic» + TextBox8.Text = «crazy» + TextBox9.Text = «noob» + TextBox1.Text = Nuestro usuarioEl número aleatorio

 Ejemplo

  • Nombre: deurus
  • Clave: deurusurastupiddumbidioticcrazynoobdeurus98265385

Parcheando el número aleatorio

Buscamos el evento click en IL Dasm y nos fijamos que aparece el número «5F5E0FF» que en decimal equivale a «99999999«, buscamos los bytes en el editor hexadecimal y lo parcheamos a 1. De este modo anulamos la aletoriedad, ahora el número siempre es 1.

01-09-2014 09-25-23

01-09-2014 09-35-35

01-09-2014 09-36-59

Ahora ya podemos registrarnos.

01-09-2014 07-38-44

Links


Los retos de criptografía pueden ser muy variados como he dicho anteriormente. El secreto suele estar en saber a que
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos

Retos de Criptografía

Los retos de criptografía pueden ser muy variados como he dicho anteriormente. El secreto suele estar en saber a que te enfrentas y posteriormente construir una herramienta para descifrarlo o usar una ya existente (la mayoría de los casos).

Una web con la que suelo resolver la mayoría de retos es dcode.fr. Si os fijáis en el enlace, la lista de categorías asciende a 48 y disponéis de unos 800 algoritmos para rebanaros los sesos.

A continuación veamos unos cuantos retos que podéis encontrar por la red. Cabe destacar que normalmente el título del reto dice mucho del algoritmo.


  • Enunciado: The grass is always greener on the other side
  • Texto encriptado: TSDLN ILHSY OGSRE WOOFR OPOUK OAAAR RIRID
  • Solución: César

  • Enunciado: Prove you’re not drunk?
  • Texto encriptado: gsv kzhh blfi ollprmt uli rh zoxlslo
  • Solución: Atbash

  • Enunciado: ¿?
  • Texto encriptado: 4C240DDAB17D1796AAD3B435B51404EE
  • Solución: Aquí nuestro primer impulso es utilizar fuerza bruta a MD5, pero cuando nos damos contra la pared el siguiente candidato es LAN Manager. Aquí la opción que más os guste, Cain, John The Ripper, etc.

Con John The Ripper tenemos que preparar un archivo de texto del estilo: deurus.info:1011:4C240DDAB17D1796AAD3B435B51404EE:4C240DDAB17D1796AAD3B435B51404EE:::

y ejecutar el comando: john –format=lm LM.txt


  • Enunciado: a lot harder than SMS
  • Texto encriptado: .- -. . .- … -.– — -. . – …. . .–. .- … … .– — .-. -.. .. … -.. — – -.. .- … …. -.. .- … …. -.. — –
  • Solución: Morse

  • Enunciado: Now I see!

 


  • Enunciado: Polly the parrot loves to square dance?
  • Texto encriptado: 442315 3511434352344214 2443 442432154411123115
  • Solución: Polybios

  • Enunciado: Aquí hay problemas de base.
  • Texto encriptado: VGhlIHBhc3N3b3JkIGlzIG9qZXRlIG1vcmVubw==
  • Solución: Base64

  • Enunciado: Conversión
  • Texto encriptado: 6c6120736f6c756369c3b36e2065733a20366533303664333137333734333337323739
  • Solución: Hexadecimal

  • Enunciado: Método de encriptación de los más antiguos que se conocen.
  • Texto encriptado: ozhlofxrlmvhxzorulimrz
  • Solución: Cifrado Afín

  • Enunciado: /_vti_pvt/administrators.pwd
  • Texto encriptado: admin:dut4HlQyu4dSA
  • Solución: Creamos un archivo de texto con el texto encriptado y ponemos a John The Ripper a trabajar con el comando john –show administrators.pwd

  • Enunciado: En ocasiones veo en binario
  • Texto encriptado:0111001101110101011100000110010101110010
    0001001110011000111110100100110010010001
  • Solución: Para la primera parte la conversión es directa. Para la segunda, la dificultad reside en darse cuenta que hay que separar en grupos de cinco y decodificar por separado.

  • Enunciado: Un clásico
  • Texto encriptado: WLYGUKVAIIXAVGLRWCHVDRWC
  • Solución: Vigenere

  • Enunciado: Una antigua estirpe

  • Enunciado: eXORcism
  • Texto encriptado: 7d5313525e52475713544113414046025052
  • Solución: XOR. La clave la podéis obtener por fuerza bruta. Mira este artículo par saber como.

  • Enunciado: Edgar Allan Poe
  • Texto encriptado: 05-05¶88)8)-5(525,‡
  • Solución: Escarabajo de oro

  • Enunciado: MD encryption
  • Texto encriptado: 6FBCF7B5CE6637C28EEDC43988A9509B
  • Solución: MD5

  • Enunciado: American coding system used in the context of World War II
  • Texto encriptado: A-WOH LIN AH-JAH CLA-GI-AIH BE-LA-SANA KLESH DIBEH GLOE-IH NE-AHS-JAH GAH BE YEH-HES DIBEH A-CHIN WOL-LA-CHEE A-KEH-DI-GLINI TSE-NILL YIL-DOI A-KHA
  • Solución: Código Navajo

  • Enunciado: Run, run, run
  • Texto encriptado: T1H1E1P1A1S2W1O1R1D1I1S1R1U1N2I1N1G1
  • Solución: Run-length encoding

Conversiones, cifra clásica, hash, simétricos, asimétricos, combinaciones de varios algoritmos y un largo etcetera. Como veis los hay para todos los gustos, ten en cuenta que aquí os muestro una pequeñísima parte de lo que os encontrareis en las webs de retos, pero para despertar la curiosidad es suficiente.

¡Hala, a decodificar!

Enlaces

Yoire PE Stage 3 Reversing Challenge (Benten) – Fuerza Bruta

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

Analizando

Abrimos el crackme con Ollydbg y vamos a las referenced strings.

Pinchamos sobre cualquiera.

 

Vemos un «Call» donde seguramente se generará un SUM en función del serial metido ya que después del Call vemos una comprobación contra «B79E763E» lo que nos da una pista de que vamos a tener que utilizar fuerza bruta para llegar a ese valor. Vamos a explorar el Call.

Lo que resalto con la flecha son una par de Calls que podemos NOPear ya que lo único que hacen es ralentizar la generación del SUM.
A continuación vamos a analizar el algoritmo de generación del SUM.
MOV EDI,5EED                   - EDI = 5EED
JMP SHORT 01_crack.004010D7
/MOV EAX,EDI                   <----Bucle
|SHL EAX,5                     - 5EED * 32 = BDDA0
|MOVZX EDX,BYTE PTR DS:[EBX]   - Coge el dígito
|XOR EAX,EDX                   - BDDA0 XOR digito
|MOV EDI,EAX
|XOR EDI,1D0B1EED              - XOR 1D0B1EED
|INC EBX
|..
|MOV ESI,EAX
CMP BYTE PTR DS:[EBX],0
JNZ SHORT 01_crack.004010B4   - Bucle ---->

Para un serial de tres dígitos la secuencia sería esta (valores en hexadecimal):

1º Digit —> BDDA0 XOR 1D0B1EED XOR 1ºDigit XOR 1D0B1EED = Temp
2º Digit —> Temp = Temp * 20 Xor 1D0B1EED XOR 2ºDigit
3º Digit —> Temp = Temp * 20 Xor 1D0B1EED XOR 3ºDigit

CMP Temp, B79E763E

Aplicando Fuerza Bruta

La creación del «BruteForcer» os la dejo a vosotros. Aquí teneis un fragmento hecho en VB.Net.

Dim temp As Long
Dim temp2 As String
Dim letter As Integer
Dim brute As String
brute = TextBox4.Text
temp = 0
temp = Asc(Mid(brute, 1, 1)) Xor 487268077 Xor 777632
temp2 = Hex(temp)
temp2 = Microsoft.VisualBasic.Right(temp2, 8)
temp = Convert.ToUInt64(temp2, 16)
For i = 2 To Len(brute)
letter = Asc(Mid(brute, i, 1))
temp = temp * 32
temp2 = Hex(temp)
temp2 = Microsoft.VisualBasic.Right(temp2, 8)
temp = Convert.ToUInt64(temp2, 16)
temp = temp Xor 487268077
temp2 = Hex(temp)
temp2 = Microsoft.VisualBasic.Right(temp2, 8)
temp = Convert.ToUInt64(temp2, 16)
temp = temp Xor letter
'
temp2 = Hex(temp)
Next

Links


AVISO: Debido a que este reto está en activo no publicaré a donde pertenece. El reto en cuestión nos presenta
http://youtu.be/b9-GdmIQINQ Lista de reproducción
Introducción Funcionamiento de RSA OllyDbg Calculando un serial válido Ejemplo operacional Keygen Links Introducción Empezamos con lo que espero que
Introducción Recién rescatados del inframundo que es mi disco duro, os traigo un paquete de seis crackmes facilones para vuestro

Digi Logic Challenge

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece.

El reto en cuestión nos presenta un esquema de puertas lógicas y una secuencia binaria que al pasarla por las puertas nos devolverá la solución al reto.

La secuencia binaria es ésta:

110111000001110010010011101100011000001101111110000001011101110011101100011000001101011011111000011010100110111000001010100111111111000101110001010

Lo primero que necesitamos saber es que función realiza cada puerta. Si indagamos un poco enseguida llegamos a la conclusión de que el esquema lo componen 3 puertas NOT, cuatro puertas AND y una puerta OR.

El funcionamiento es muy sencillo, la puerta NOT simplemente invierte el dígito de entrada convirtiendo los unos en ceros y los ceros en unos. La puerta AND siempre dará como resultado cero excepto cuando todos dígitos de entrada sean unos, que dará como resultado uno. La puerta OR es contraria a la AND y siempre dará como resultado uno excepto cuando todos los dígitos de entrada sean ceros, que en este caso dará como resultado cero.

Esquema con apuntes

Nota: Aunque lo más normal es encontrarse puertas de dos entradas y una salida, cuando tenemos múltiples entradas el funcionamiento es el mismo pudiendo resolverlo de manera secuencial. Por ejemplo, a la primera puerta AND le entran la pista cuatro, la dos y la tres. La solución es hacer cuatro AND dos y el resultado AND tres -> (cuatro AND dos) AND tres

Teniendo en cuenta el funcionamiento de las puertas y con la ayuda del esquema anterior podemos automatizar el proceso fácilmente. A continuación os dejo el código en .Net.

Dim encoded As String = "110111000001110010010011101100011000001101111110000001011101110011101100011000001101011011111000011010100110111000001010100111111111000101110001010"

        Dim uno, dos, tres, cuatro, cinco, seis As String
        Dim w, x, y, z, tmp As Integer
        For i = 0 To encoded.Length - 1 Step 3
            uno = Mid(encoded, i + 1, 1)
            dos = Mid(encoded, i + 2, 1)
            tres = Mid(encoded, i + 3, 1)

            If uno = "1" Then cuatro = "0"
            If uno = "0" Then cuatro = "1"
            If dos = "1" Then cinco = "0"
            If dos = "0" Then cinco = "1"
            If tres = "1" Then seis = "0"
            If tres = "0" Then seis = "1"

            w = CInt(cuatro And dos) And CInt(tres)
            x = CInt(uno And cinco) And CInt(tres)
            y = CInt(uno And dos) And CInt(seis)
            z = CInt(uno And dos) And CInt(tres)

            tmp = (w Or x) Or (y Or z)
            txt_s.Text &= tmp.ToString
        Next

Obtenemos como resultado: 1100100110100111001111101001111010011000011101100

Si intentamos decodificar la secuencia resultante en bloque no obtenemos ningún resultado pero si tenemos en cuenta que cada letra en binario ocupa siete dígitos enseguida encontramos la solución.

1100100 1101001 1100111 1101001 1110100 1100001 1101100
   d       i       g       i       t       a       l

Enlaces

Solución al KeygenMe1 (RSA200) de Dihux

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


Toda esta aventura comienza con un archivo llamado pretty_raw, sin extensión. Porque sí. Porque las extensiones son una invención heredada
La serie "Expediente X" (The X-Files) ha capturado la imaginación de los espectadores desde su debut en 1993, con sus
Intro Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

Stego – Bytes en bruto

Toda esta aventura comienza con un archivo llamado pretty_raw, sin extensión. Porque sí. Porque las extensiones son una invención heredada de CP/M, precursor de MS-DOS, que Windows terminó de popularizar. Porque son innecesarias. Y porque echo de menos cuando los archivos se reconocían por sus permisos… y no por cómo se llamaban.

Como iba diciendo, todo esto comienza mediante el análisis de pretty_raw. Mirando debajo de la falda con un editor hexadecimal encontramos unos cuantos bytes aleatorios hasta dar con una cabecera PNG.

Si atendemos a la captura, justo antes de la cabecera PNG tenemos 116.254 bytes (0x1C61E). Tomad nota que este número será relevante más adelante.

Extraemos el PNG, lo visualizamos y lo pasamos por todas las herramientas habidas y por haber. Nada funciona. Volvemos a visualizarlo con atención y vemos que hace referencia a un archivo llamado flag.png con unas dimensiones que no coinciden con la extraída.

Toca centrarse y pensar en que camino tomar. Hemos gastado tiempo con el PNG extraído y quizá lo mejor sea centrarse en los bytes que inicialmente hemos descartado. En concreto se trata de un bloque de 116.254 bytes, pero espera, 1570×74=116.180 bytes. ¡Mierda!, no coincide exactamente con los bytes extraídos. Bueno, da igual. Si suponemos que el PNG que buscamos no tiene compresión y que cada pixel ocupa un byte (escala de grises y 8 bits), su tamaño depende únicamente de la geometría y de cómo se almacenan las filas en memoria. Vamos a procesarlo con Python para salir de dudas.

import numpy as np
from PIL import Image

INPUT_FILE  = "pretty_raw"
OUTPUT_FILE = "pretty_raw_flag.png"

WIDTH  = 1570 # ¿estás seguro?
HEIGHT = 74
DEPTH  = 8  # bits

# Leer archivo como RAW
with open(INPUT_FILE, "rb") as f:
    raw = f.read()

expected_size = WIDTH * HEIGHT
if len(raw) < expected_size:
    raise ValueError("El archivo no tiene suficientes datos")

# Convertir a array numpy (grayscale 8 bits)
img = np.frombuffer(raw[:expected_size], dtype=np.uint8)
img = img.reshape((HEIGHT, WIDTH))

# Crear imagen
image = Image.fromarray(img, mode="L")
image.save(OUTPUT_FILE)

print(f"Imagen generada correctamente: {OUTPUT_FILE}")

El script nos devuelve un PNG válido pero con las letras torcidas. Tras darle vueltas me di cuenta de que si en el script usamos como WIDTH=1571 en lugar de 1570, la imagen resultante es correcta y tiene todo el sentido del mundo ya que 1571×74=116.254, que son exactamente los bytes que se encuentran antes del png señuelo.

Aunque el ancho visible de la imagen es de 1570 píxeles, cada fila ocupa realmente 1571 bytes. Ese byte adicional actúa como relleno (padding) y forma parte del stride o bytes por fila. Ignorar este detalle lleva a un desplazamiento erróneo acumulativo y por eso se ve la imagen torcida. En este caso concreto da igual ya que el texto se aprecia, pero si el reto hubiera sido más exigente no se vería nada.

Del Hacking a la IA: Cómo Expediente X Abordó la Tecnología de Vanguardia

La serie «Expediente X» (The X-Files) ha capturado la imaginación de los espectadores desde su debut en 1993, con sus intrigantes historias de fenómenos paranormales y conspiraciones gubernamentales. Sin embargo, más allá de los extraterrestres y las criaturas sobrenaturales, la serie también exploró el mundo del hacking, la inteligencia artificial y la piratería informática, temas que se adelantaron a su tiempo y que siguen siendo relevantes hoy en día. A continuación, exploramos algunos de los episodios más emblemáticos que abordan estos temas, revelando detalles fascinantes, curiosidades y tomas falsas que los hicieron memorables.

«Ghost in the Machine» (Temporada 1, Episodio 7)

En este episodio, Mulder y Scully investigan un asesinato en una empresa de tecnología avanzada, Eurisko, donde un sistema de inteligencia artificial llamado «COS» (Central Operating System) podría ser el responsable. La trama se centra en las posibles implicaciones de las IA descontroladas y las vulnerabilidades tecnológicas.

Curiosidades:

  • Este episodio fue uno de los primeros en abordar el tema de la inteligencia artificial en la televisión.
  • El nombre «COS» es una referencia al sistema operativo OS/2 de IBM, que estaba en uso en la época.

Tomas falsas:

  • Durante una de las escenas de acción, el actor encargado de operar el COS tuvo dificultades para mantener la seriedad debido a los efectos especiales rudimentarios, resultando en varias tomas falsas.

«Kill Switch» (Temporada 5, Episodio 11)

Escrito por los renombrados autores de ciencia ficción William Gibson y Tom Maddox, este episodio trata sobre un hacker llamado Donald Gelman que desarrolla una inteligencia artificial avanzada y peligrosa. Mulder y Scully se encuentran en una carrera contra el tiempo para detener a la IA antes de que cause más daño.

Curiosidades:

  • William Gibson es considerado el padre del ciberpunk, y su influencia se nota en la atmósfera y el estilo del episodio.
  • La tecnología y los conceptos presentados en «Kill Switch» fueron increíblemente visionarios para su tiempo, anticipando el desarrollo de IA avanzada y redes cibernéticas.

Tomas falsas:

  • Las escenas de acción en el episodio, especialmente las que involucran a Mulder y Scully en entornos virtuales, resultaron en varios momentos divertidos detrás de cámaras, con los actores luchando por coordinar sus movimientos con los efectos especiales.

«First Person Shooter» (Temporada 7, Episodio 13)

En este episodio, Mulder y Scully se encuentran atrapados en un videojuego de realidad virtual mientras investigan una serie de asesinatos en una empresa de desarrollo de videojuegos. La trama explora los peligros potenciales de la inmersión tecnológica y los límites entre la realidad y la ficción.

En este episodio, Mulder y Scully se encuentran atrapados en un videojuego de realidad virtual mientras investigan una serie de asesinatos en una empresa de desarrollo de videojuegos. La trama explora los peligros potenciales de la inmersión tecnológica y los límites entre la realidad y la ficción.

Curiosidades:

  • Este episodio fue dirigido por Chris Carter, el creador de la serie, y escrito por William Gibson y Tom Maddox, quienes también escribieron «Kill Switch».
  • «First Person Shooter» fue criticado y elogiado a partes iguales por su tratamiento de la cultura de los videojuegos y la tecnología de realidad virtual.

Tomas falsas:

  • Las escenas dentro del videojuego requirieron el uso de efectos especiales avanzados para la época, lo que resultó en numerosos errores técnicos y momentos de risas entre el elenco.

«Rm9sbG93ZXJz» (Temporada 11, Episodio 7)

Este episodio de la temporada más reciente se centra en el impacto de la inteligencia artificial y la tecnología moderna en la vida cotidiana. Mulder y Scully son perseguidos por drones y dispositivos automatizados después de un malentendido en un restaurante automatizado.

Curiosidades:

  • El título del episodio, «Rm9sbG93ZXJz», es «Followers» en base64, una referencia a la temática del episodio sobre las redes sociales y la vigilancia tecnológica.
  • Este episodio es casi completamente sin diálogos, lo que crea una atmósfera única y tensa que subraya la dependencia moderna de la tecnología.

Tomas falsas:

  • La falta de diálogos resultó en situaciones cómicas durante el rodaje, ya que los actores tenían que comunicar mucho con expresiones faciales y movimientos, lo que llevó a varios malentendidos y momentos divertidos.

Cabe mencionar que, en esta ocasión, no he incluido ningún episodio protagonizado por los Pistoleros Solitarios, el trío de hackers y teóricos de la conspiración favoritos de los fans. Este grupo merece un artículo dedicado para explorar en profundidad sus contribuciones únicas a la serie y su propio spin-off, que también aborda numerosos temas tecnológicos y conspirativos con su estilo distintivo.

Estos episodios no solo nos ofrecen emocionantes tramas y misterios tecnológicos, sino que también nos brindan un vistazo a un futuro potencial, uno en el que la línea entre lo humano y lo artificial se vuelve cada vez más difusa. Las curiosidades y tomas falsas detrás de cámaras añaden una capa adicional de encanto, mostrando el esfuerzo y la creatividad necesarios para dar vida a estos complejos temas.

Como fanáticos de «Expediente X», podemos apreciar cómo la serie ha sido capaz de mantenerse relevante y cautivadora al abordar cuestiones tecnológicas que son tanto atemporales como urgentes. Nos ha llevado a cuestionar nuestra confianza en las máquinas, a temer las posibles repercusiones de una inteligencia artificial sin control y a maravillarnos con las posibilidades de la realidad virtual.

En resumen, «Expediente X» no solo ha sido un pionero en la televisión de ciencia ficción y misterio, sino que también ha demostrado una notable capacidad para explorar y anticipar los dilemas tecnológicos que enfrentamos hoy en día. Estos episodios son un recordatorio de que, en el vasto universo de lo desconocido, la tecnología juega un papel crucial y, a veces, aterrador. Para los verdaderos fans, cada uno de estos episodios es una joya que merece ser revivida y analizada, apreciando su profundidad y relevancia en nuestro mundo cada vez más digital.


Todas las imágenes de esta entrada han sido generadas con ChatGPT.

TDC’s Remove the NAG – Parche

Intro

Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma más limpia posible.

Analizando a la víctima

Abrimos el crackme con Olly y ya a simple vista vemos los mensajes de la Nag y parte del código interesante. Si necesitaramos localizar la Nag podemos mirar en las intermodular calls las típicas subrutinas, en este caso se ve claramente  a MessageBoxA, bastaría con poner un breakpoint para localizar quien llama.

Aquí vemos la implicación de MessageBoxA.

004010A7     |> \6A 40                    PUSH 40                                         ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
004010A9     |.  68 61304000              PUSH Nag1.00403061                              ; |Title = "[NAG] Please register this software!"
004010AE     |.  68 86304000              PUSH Nag1.00403086                              ; |Text = "[BULLSHIT] Please register this software for support and you'll receive the full version!"
004010B3     |.  FF75 08                  PUSH [ARG.1]                                    ; |hOwner = 7FFDF000
004010B6     |.  E8 49010000              CALL <JMP.&user32.MessageBoxA>                  ; \MessageBoxA
........
00401137     |.  6A 40                    PUSH 40                                         ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
00401139     |.  68 6E324000              PUSH Nag1.0040326E                              ; |Title = "Thank you!"
0040113E     |.  68 79324000              PUSH Nag1.00403279                              ; |Text = "Thank you for registering this software!"
00401143     |.  FF75 08                  PUSH [ARG.1]                                    ; |hOwner = 7FFDF000
00401146     |.  E8 B9000000              CALL <JMP.&user32.MessageBoxA>                  ; \MessageBoxA
........
00401155     |.  6A 40                    PUSH 40                                         ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
00401157     |.  68 E0304000              PUSH Nag1.004030E0                              ; |Title = "About"
0040115C     |.  68 E6304000              PUSH Nag1.004030E6                              ; |Text = "Remove the NAG by TDC\r\n\n..: Coded by\t: TDC\t\t\t:..\t\r\n..: Also known as\t: The Dutch Cracker\t:..\t\r\n..: Protection\t: Custom\t\t\t:..\t\r\n..: Contact info\t: tdc123@gmail.com\t:..\t\r\n..: Release date\t: 09-08-2005\t\t:..\t"...
00401161     |.  FF75 08                  PUSH [ARG.1]                                    ; |hOwner = 7FFDF000
00401164     |.  E8 9B000000              CALL <JMP.&user32.MessageBoxA>                  ; \MessageBoxA

 Un poco encima vemos la función SetDlgItemTextA, que nos mostrará el mensaje de que hemos parcheado correctamente.

dlgitem

00401106     |> \68 21304000              PUSH Nag1.00403021                              ; /Text = "Dirty crack! Nag removed not registered!"
0040110B     |.  6A 73                    PUSH 73                                         ; |ControlID = 73 (115.)
0040110D     |.  FF75 08                  PUSH [ARG.1]                                    ; |hWnd = 7FFDF000
00401110     |.  E8 FB000000              CALL <JMP.&user32.SetDlgItemTextA>              ; \SetDlgItemTextA
00401115     |.  EB 36                    JMP SHORT Nag1.0040114D
00401117     |>  68 10304000              PUSH Nag1.00403010                              ; /Text = "Nag not removed!"
0040111C     |.  6A 73                    PUSH 73                                         ; |ControlID = 73 (115.)
0040111E     |.  FF75 08                  PUSH [ARG.1]                                    ; |hWnd = 7FFDF000
00401121     |.  E8 EA000000              CALL <JMP.&user32.SetDlgItemTextA>              ; \SetDlgItemTextA
00401126     |.  EB 25                    JMP SHORT Nag1.0040114D
00401128     |>  68 4A304000              PUSH Nag1.0040304A                              ; /Text = "Clean crack! Good Job!"
0040112D     |.  6A 73                    PUSH 73                                         ; |ControlID = 73 (115.)
0040112F     |.  FF75 08                  PUSH [ARG.1]                                    ; |hWnd = 7FFDF000
00401132     |.  E8 D9000000              CALL <JMP.&user32.SetDlgItemTextA>              ; \SetDlgItemTextA

Encima de SetDlgItemTextA vemos el código que analiza si la Nag tiene que aparecer.

004010E6     |.  E8 C4000000              CALL Nag1.004011AF                              ;  ; Llamada interesante a analizar
004010EB     |.  803D B0324000 03         CMP BYTE PTR DS:[4032B0],3
004010F2     |.  74 12                    JE SHORT Nag1.00401106                          ;  ; Si de la llamada volvemos con un 3 -> Parcheo chapuza
004010F4     |.  803D B0324000 02         CMP BYTE PTR DS:[4032B0],2
004010FB     |.  74 1A                    JE SHORT Nag1.00401117                          ;  ; Si de la llamada volvemos con un 2 -> Sin parchear
004010FD     |.  803D B0324000 01         CMP BYTE PTR DS:[4032B0],1
00401104     |.  74 22                    JE SHORT Nag1.00401128                          ;  ; Si de la llamada volvemos con un 1 -> Buen trabajo Joe!
........
004011AF     /$  68 A2324000              PUSH Nag1.004032A2                              ; /String2 = "Value1"
004011B4     |.  68 A9324000              PUSH Nag1.004032A9                              ; |String1 = "Value2"
004011B9     |.  E8 64000000              CALL <JMP.&kernel32.lstrcmpA>                   ; \lstrcmpA
004011BE     |.  50                       PUSH EAX                                        ;  kernel32.BaseThreadInitThunk
004011BF     |.  85C0                     TEST EAX,EAX                                    ;  kernel32.BaseThreadInitThunk
004011C1     |.  75 10                    JNZ SHORT Nag1.004011D3
004011C3     |.  33C0                     XOR EAX,EAX                                     ;  kernel32.BaseThreadInitThunk
004011C5     |.  58                       POP EAX                                         ;  kernel32.75CDEE1C
004011C6     |.  85C0                     TEST EAX,EAX                                    ;  kernel32.BaseThreadInitThunk
004011C8     |.  74 15                    JE SHORT Nag1.004011DF
004011CA     |.  C605 B0324000 03         MOV BYTE PTR DS:[4032B0],3
004011D1     |.  EB 17                    JMP SHORT Nag1.004011EA
004011D3     |>  58                       POP EAX                                         ;  kernel32.75CDEE1C
004011D4     |.  33C0                     XOR EAX,EAX                                     ;  kernel32.BaseThreadInitThunk
004011D6     |.  C605 B0324000 02         MOV BYTE PTR DS:[4032B0],2
004011DD     |.  EB 0B                    JMP SHORT Nag1.004011EA
004011DF     |>  33C0                     XOR EAX,EAX                                     ;  kernel32.BaseThreadInitThunk
004011E1     |.  C605 B0324000 01         MOV BYTE PTR DS:[4032B0],1
004011E8     |.  EB 00                    JMP SHORT Nag1.004011EA
004011EA     \>  C3                       RETN

 Vemos dentro del Call 4011AF que Compara si Value1 = Value2 y dependiendo de esa comparación guarda en memoria (4032B0), los valores 1, 2 ó 3.

Basta con modificar en un editor hexadecimal la parabra «Value2» por «Value1» y ya tenemos el problema resuelto.

09-09-2014 11-04-03

09-09-2014 11-04-34

09-09-2014 11-05-26

Al pulsar Re-Check

09-09-2014 11-06-01

Notas finales

Se podía haber parcheado un montón de código para obtener el mismo resultado pero fijándonos en el código lo hemos conseguido parcheando un solo byte. Recuerda, cuando halla que parchear, cuantos menos bytes mejor.

 Links


Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
File carving is the process of reassembling computer files from fragments in the absence of filesystem metadata. Wikipedia. "File carving", literalmente tallado
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Intro Antes que nada, es importante saber que un archivo ELF en Linux es equivalente a un archivo EXE en

Afinador

Se nos entrega un ELF que decompilado presenta este aspecto:

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

   Detected compiler: GNU C++
*/

#include <defs.h>


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

__int64 (**init_proc())(void);
__int64 sub_401020();
__int64 sub_401030(); // weak
__int64 sub_401040(); // weak
__int64 sub_401050(); // weak
__int64 sub_401060(); // weak
__int64 sub_401070(); // weak
// int puts(const char *s);
// int printf(const char *format, ...);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void dl_relocate_static_pie();
char *deregister_tm_clones();
__int64 register_tm_clones();
char *_do_global_dtors_aux();
__int64 frame_dummy();
int __fastcall main(int argc, const char **argv, const char **envp);
_BYTE *__fastcall encode(__int64 a1);
__int64 __fastcall validar(const char *a1);
int banner();
int comprar();
void _libc_csu_fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// __int64 _gmon_start__(void); weak

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

_UNKNOWN _libc_csu_init;
const char a31mparaSeguirU[43] = "\x1B[31mPara seguir usando este producto deber"; // idb
const char a32myaPuedesSeg[61] = "\x1B[32mYa puedes seguir afinando tus instrumentos (y tus flags "; // idb
const char aDirigaseANuest[21] = "\nDirigase a nuestra p"; // idb
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
__int64 (*qword_404010)(void) = NULL; // weak
char _bss_start; // weak


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

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

//----- (0000000000401020) ----------------------------------------------------
__int64 sub_401020()
{
  return qword_404010();
}
// 404010: using guessed type __int64 (*qword_404010)(void);

//----- (0000000000401030) ----------------------------------------------------
__int64 sub_401030()
{
  return sub_401020();
}
// 401030: using guessed type __int64 sub_401030();

//----- (0000000000401040) ----------------------------------------------------
__int64 sub_401040()
{
  return sub_401020();
}
// 401040: using guessed type __int64 sub_401040();

//----- (0000000000401050) ----------------------------------------------------
__int64 sub_401050()
{
  return sub_401020();
}
// 401050: using guessed type __int64 sub_401050();

//----- (0000000000401060) ----------------------------------------------------
__int64 sub_401060()
{
  return sub_401020();
}
// 401060: using guessed type __int64 sub_401060();

//----- (0000000000401070) ----------------------------------------------------
__int64 sub_401070()
{
  return sub_401020();
}
// 401070: using guessed type __int64 sub_401070();

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

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

//----- (0000000000401100) ----------------------------------------------------
void dl_relocate_static_pie()
{
  ;
}

//----- (0000000000401110) ----------------------------------------------------
char *deregister_tm_clones()
{
  return &_bss_start;
}
// 404050: using guessed type char _bss_start;

//----- (0000000000401140) ----------------------------------------------------
__int64 register_tm_clones()
{
  return 0LL;
}

//----- (0000000000401180) ----------------------------------------------------
char *_do_global_dtors_aux()
{
  char *result; // rax

  if ( !_bss_start )
  {
    result = deregister_tm_clones();
    _bss_start = 1;
  }
  return result;
}
// 404050: using guessed type char _bss_start;

//----- (00000000004011B0) ----------------------------------------------------
__int64 frame_dummy()
{
  return register_tm_clones();
}

//----- (00000000004011B6) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
  int v4; // [rsp+10h] [rbp-10h] BYREF
  int v5; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  v5 = 0;
  puts("\n\x1B[31m    -----------Se le ha acabado el periodo de prueba gratuito-----------\n");
  puts(a31mparaSeguirU);
  do
  {
    banner();
    __isoc99_scanf("%d", &v4);
    if ( v4 == 3 )
      exit(0);
    if ( v4 > 3 )
      goto LABEL_10;
    if ( v4 == 1 )
    {
      comprar();
      continue;
    }
    if ( v4 == 2 )
      v5 = validar("%d");
    else
LABEL_10:
      puts("Opcion invalida, pruebe otra vez");
  }
  while ( !v5 );
  puts(a32myaPuedesSeg);
  return 0;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);

//----- (0000000000401291) ----------------------------------------------------
_BYTE *__fastcall encode(__int64 a1)
{
  _BYTE *result; // rax
  int i; // [rsp+14h] [rbp-4h]

  for ( i = 0; i <= 33; ++i )
  {
    if ( *(char *)(i + a1) <= 96 || *(char *)(i + a1) > 122 )
    {
      if ( *(char *)(i + a1) <= 64 || *(char *)(i + a1) > 90 )
      {
        result = (_BYTE *)*(unsigned __int8 *)(i + a1);
        *(_BYTE *)(i + a1) = (_BYTE)result;
      }
      else
      {
        result = (_BYTE *)(i + a1);
        *result = (5 * ((char)*result - 65) + 8) % 26 + 65;
      }
    }
    else
    {
      result = (_BYTE *)(i + a1);
      *result = (5 * ((char)*result - 97) + 8) % 26 + 97;
    }
  }
  return result;
}

//----- (00000000004013DB) ----------------------------------------------------
__int64 __fastcall validar(const char *a1)
{
  int i; // [rsp+Ch] [rbp-64h]
  char v3[48]; // [rsp+10h] [rbp-60h] BYREF
  __int64 v4[6]; // [rsp+40h] [rbp-30h] BYREF

  v4[5] = __readfsqword(0x28u);
  qmemcpy(v4, "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", 34);
  printf("\nIntroduce tu licencia: ");
  __isoc99_scanf("%s", v3);
  encode((__int64)v3);
  for ( i = 0; i <= 33; ++i )
  {
    if ( v3[i] != *((_BYTE *)v4 + i) )
    {
      puts("\n\x1B[31mTu licencia es incorrecta\x1B[37m\n");
      return 0LL;
    }
  }
  puts("\n\x1B[32mEres un crack, lo conseguiste\x1B[37m");
  return 1LL;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4013DB: using guessed type char var_60[48];

//----- (00000000004014CE) ----------------------------------------------------
int banner()
{
  puts("                     ___________OPCIONES___________");
  puts("                    | 1: Comprar licencia premium  |");
  puts("                    | 2: Validar clave de licencia |");
  puts("                    | 3: Salir                     |");
  puts("                     ------------------------------");
  return printf("> ");
}

//----- (0000000000401526) ----------------------------------------------------
int comprar()
{
  return puts(aDirigaseANuest);
}

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

  init_proc();
  v3 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
  if ( v3 )
  {
    for ( i = 0LL; i != v3; ++i )
      (*(&_frame_dummy_init_array_entry + i))();
  }
}
// 403E10: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 403E18: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();

//----- (00000000004015B0) ----------------------------------------------------
void _libc_csu_fini(void)
{
  ;
}

//----- (00000000004015B8) ----------------------------------------------------
void term_proc()
{
  ;
}

// nfuncs=33 queued=21 decompiled=21 lumina nreq=0 worse=0 better=0
// ALL OK, 21 function(s) have been successfully decompiled

Para resolver el juego y obtener una licencia válida, nos fijamos en el proceso de validación que se encuentra en la función validar (líneas 237 a 258). Esta función compara una entrada de licencia codificada con una licencia codificada almacenada en el programa.

La licencia almacenada es "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", y se utiliza la función encode (líneas 207 a 234) para codificar la entrada del usuario antes de compararla. La función encode aplica un cifrado simple a la entrada, alterando los caracteres alfabéticos según una fórmula específica.

La función de cifrado encode realiza lo siguiente:

  • Si el carácter es una letra minúscula (a-z), se convierte según la fórmula (5 * (char - 97) + 8) % 26 + 97.
  • Si el carácter es una letra mayúscula (A-Z), se convierte según la fórmula (5 * (char - 65) + 8) % 26 + 65.

Nos construimos una función en Python para decodificar la Flag y reto superado.

def decode(encoded_char):
    if 'a' <= encoded_char <= 'z':
        original_char = chr(((ord(encoded_char) - 97 - 8) * 21) % 26 + 97)
    elif 'A' <= encoded_char <= 'Z':
        original_char = chr(((ord(encoded_char) - 65 - 8) * 21) % 26 + 65)
    else:
        original_char = encoded_char
    return original_char

encoded_license = "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}"
decoded_license = "".join(decode(char) for char in encoded_license)

print("Licencia descifrada:", decoded_license)

CanYouHack.it Mobile2 Challenge – Follow The Web (English)

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.

Table of Contents

Intro

This crackme is for the challenge Mobile 2 of canyouhack.it.
This time you need to understand how the crackme works over the web.

Decompiling

The crackme is given again at Google Play, so the first step is to install and recover the APK for decompiling. The latter, I leave to you.
Open the victim with APK Studio and view the content of Mobile2.java
First we view one link:
http://canyouhack.it/Content/Challenges/Mobile/2/index.php
 If we go to the link, we view one string like a hash: 68a571bcf7bc9f76d43bf931f413ab2c. Umm, it’s like MD5. Go to decrypt online and we get the pass: «canyouhack.it». But if we test this password in the crackme, surprise!, nothing happens. We need to continue analyzing the code. Later we view the next interesting link:
«http://canyouhack.it/Content/Challenges/Mobile/2/submit.php?Token=» + Mobile2.token + «&Attempts=»
The program submit one token and concatenate with the number of attempts. Ok but what is the token and what is the number of attempts?
In this point we have to try with the information we already have.
Testing with the link of bottom we get “Nice try!” message.
http://canyouhack.it/Content/Challenges/Mobile/2/submit.php?Token=68a571bcf7bc9f76d43bf931f413ab2c&&Attempts=0
Testing with the link of bottom we get “Very Good, the password is Top*****!” message.
http://canyouhack.it/Content/Challenges/Mobile/2/submit.php?Token=68a571bcf7bc9f76d43bf931f413ab2c&&Attempts=1

  Links