While Crackmes.de returns, I leave a couple of files for practice.
Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.
In the folder crackmes.de_mirror you have two files:
En la carpeta crackmes.de_mirror tienes dos archivos:
password of files = deurus.info
Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por eso, vamos a tener que lidiar con ciertas peculiaridades al realizar el keygen con un lenguaje de bajo nivel.
Al inicio comprueba la longitud del nombre y de el número de serie. El nombre debe tener al menos 6 caracteres y el número de serie debe tener 10. Os adelanto ya que la asignación de memoria del nombre es de 9 caracteres, es decir, da igual la longitud del nombre que solo va a usar 9.
004014AD | E8 1A 02 00 00 | call <pythagoras.GetWindowTextA> | ;Lee el nombre 004014B2 | 83 F8 06 | cmp eax,6 | ;Nombre >=6 caracteres 004014B5 | 0F 82 03 01 00 00 | jb pythagoras.4015BE | 004014BB | 6A 14 | push 14 | 004014BD | 68 D9 31 40 00 | push pythagoras.4031D9 | ;004031D9:"1234567890" 004014C2 | FF 35 10 32 40 00 | push dword ptr ds:[403210] | 004014C8 | E8 FF 01 00 00 | call <pythagoras.GetWindowTextA> | ;Lee el serial 004014CD | 83 F8 0A | cmp eax,A | ;Serial debe tener 10 (A) caracteres 004014D0 | 0F 85 E8 00 00 00 | jne pythagoras.4015BE |
Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890
A continuación chequea que nuestro serial tenga caracteres hexadecimales.
004014DA | 8A 81 D9 31 40 00 | mov al,byte ptr ds:[ecx+4031D9] | ; ecx+004031D9:"1234567890" 004014E0 | 3C 00 | cmp al,0 | ; contador del bucle 004014E2 | 74 1F | je pythagoras.401503 | ; fin del bucle 004014E4 | 3C 30 | cmp al,30 | ; 0x30 = número 1 004014E6 | 0F 82 D2 00 00 00 | jb pythagoras.4015BE | ; < 30 bad boy 004014EC | 3C 46 | cmp al,46 | ; 0x46 = letra F 004014EE | 0F 87 CA 00 00 00 | ja pythagoras.4015BE | ; > 46 bad boy 004014F4 | 3C 39 | cmp al,39 | ; 0x39 = número 9 004014F6 | 76 08 | jbe pythagoras.401500 | ; <=39 ok continua el bucle 004014F8 | 3C 41 | cmp al,41 | ; 0x41 = letra A 004014FA | 0F 82 BE 00 00 00 | jb pythagoras.4015BE | ; <41 bad boy 00401500 | 41 | inc ecx | ; contador += 1 00401501 | EB D7 | jmp pythagoras.4014DA | ; bucle
Continua realizando un sumatorio con nuestro nombre, pero tenemos que tener especial cuidado al tratamiento de los datos, ya que el crackme al estar hecho en ensamblador puede jugar con los registros como quiere y eso nos puede inducir a error.
0040150B | 3C 00 | cmp al,0 | ; ¿Fin bucle? 0040150D | 74 05 | je pythagoras.401514 | ; Salta fuera del bucle si procede 0040150F | 02 D8 | add bl,al | ; bl = bl + al 00401511 | 41 | inc ecx | ; contador +=1 00401512 | EB F1 | jmp pythagoras.401505 | ; bucle
Si os fijáis utiliza registros de 8 bits como son AL y BL. Debajo os dejo una explicación de EAX pero para EBX es lo mismo.
EAX
-----------------------------------
AX
-----------------
AH AL
-------- --------
00000000 00000000 00000000 00000000
(8bit) (8bit) (8bit) (8bit)
EAX (32 bit)
--------
AX (16 bit)
----
AHAL (AH y AL 8 bit)
--------
00000000
El uso de registros de 8 bits nos implica tomar precauciones al realizar el Keygen debido a que por ejemplo, en .Net no tenemos la capacidad de decirle que haga una suma y que nos devuelva solamente 8 bits del resultado. Veamos como ejemplo para el nombre «deurus». La suma de los caracteres hexadecimales quedaría:
64+65+75+72+75+73 = 298, es decir, EAX = 00000298
Pero recordad que el crackme solo cogerá el 98 que es lo correspondiente al registro AL. De momento nos quedamos con nuestro SUMNOMBRE = 98.
A continuación coge los dos primeros caracteres del serial y les resta nuestro SUMNOMBRE y comprueba que el resultado esté entre 4 (0x4) y -4 (0xFC).
0040154B | 0F B6 05 F3 31 40 00 | movzx eax,byte ptr ds:[4031F3] | 00401552 | 8A C8 | mov cl,al | 00401554 | 2A CB | sub cl,bl | ; CL = CL - BL | CL = 12 - 98 = 7A 00401556 | 80 F9 04 | cmp cl,4 | ; Compara CL con 4 00401559 | 7F 63 | jg pythagoras.4015BE | ; Salta si es mayor 0040155B | 80 F9 FC | cmp cl,FC | ; Compara CL con FC (-4) 0040155E | 7C 5E | jl pythagoras.4015BE | ; Salta si es menor
Como veis, el resultado de la resta da 7A (122) que al ser mayor que 4 nos echa vilmente. Aquí de nuevo utiliza registros de 8 bits por lo que debemos tener cuidado con las operaciones matemáticas para no cometer errores, veamos un ejemplo para clarificar de aquí en adelante.
Utilizando 8 bits ----------------- 12 - 98 = 7A que en decimal es 122 Utilizando 16 bits ------------------ 0012 - 0098 = FF7A que en decimal es -134
Ahora ya veis la diferencia entre FC (252) y FFFC (-4). Estrictamente, el crackme comprueba el rango entre 4 (4) y FC (122) al trabajar con registros de 8 bits pero nosotros, como veremos más adelante tomaremos el rango entre 4 y -4. De momento, para poder continuar depurando cambiamos los dos primeros caracteres del serial de 12 a 98, ya que 98 – 98 = 0 y cumple la condición anterior.
Introducimos Nombre: deurus y Serial: 9834567890
Analicemos el siguiente código.
00401560 | F7 E0 | mul eax | ; EAX = EAX * EAX 00401562 | 8B D8 | mov ebx,eax | ; EBX = EAX 00401564 | 0F B7 05 F4 31 40 00 | movzx eax,word ptr ds:[4031F4] | ; EAX = 3456 (4 dígitos siguientes del serial) 0040156B | F7 E0 | mul eax | ; EAX = EAX * EAX 0040156D | 03 D8 | add ebx,eax | ; EBX = EBX + EAX 0040156F | 0F B7 05 F6 31 40 00 | movzx eax,word ptr ds:[4031F6] | ; EAX = 7890 (4 últimos dígitos del serial) 00401576 | F7 E0 | mul eax | ; EAX = EAX * EAX 00401578 | 33 C3 | xor eax,ebx | ; EAX 0040157A | 75 42 | jne pythagoras.4015BE | ; Salta si el flag ZF no se activa
En resumen:
Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²
Serial = aabbbbcccc
Finalmente comprueba lo siguiente:
0040157C | 66 A1 F6 31 40 00 | mov ax,word ptr ds:[4031F6] | ; AX = 7890 00401582 | 66 2B 05 F4 31 40 00 | sub ax,word ptr ds:[4031F4] | ; AX = 7890 - 3456 = 443A 00401589 | 2C 08 | sub al,8 | ; AL = 3A - 8 = 32 0040158B | 75 31 | jne pythagoras.4015BE | ; Si el resultado de la resta no ha sido cero, serial no válido 0040158D | 6A 30 | push 30 | 0040158F | 68 B0 31 40 00 | push pythagoras.4031B0 | ;004031B0:":-) Well done!!!" 00401594 | 68 7F 31 40 00 | push pythagoras.40317F | ;0040317F:"Bravo, hai trovato il seriale di questo CrackMe!" 00401599 | FF 75 08 | push dword ptr ds:[ebp+8] |
En resumen:
Nuestro serial tiene que cumplir tres condiciones para ser válido.
Como hemos dicho anteriormente, tomaremos el SUMNOMBRE y le sumaremos y restaremos valores siempre y cuando el resultado esté entre 4 y -4. Para deurus hemos dicho que el SUMNOMBRE es 98 por lo que los posibles valores de «a» se pueden ver debajo. Además debemos tener en cuenta que el crackme solo lee los 9 primeros dígitos del nombre.
98-4 = 94 98-3 = 95 98-2 = 96 98-1 = 97 98-0 = 98 98+1 = 99 98+2 = 9A 98+3 = 9B 98+4 = 9C
Es evidente que para encontrar el valor de «c» vamos a tener que utilizar fuerza bruta chequeando todos los valores de «b» comprendidos entre 0 y FFFF (65535). Además, como trabajaremos en un lenguaje de alto nivel, debemos descartar los resultados decimales. Esto nos limitará los seriales válidos asociados a un determinado nombre. Si realizáramos el keygen en ensamblador obtendríamos bastantes más seriales válidos.
Una vez encontrados los valores enteros de la operación «c² = a² + b²», se debe cumplir que «c – b – 8 = 0», lo que nos limitará bastante los resultados.
Private Sub btn_generar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_generar.Click
Try
If txt_nombre.TextLength > 5 Then
lst_serials.Items.Clear()
Dim tmp, c, cx As String
Dim sumanombre, tmp2 As Integer
If txt_nombre.TextLength > 9 Then tmp2 = 8 Else tmp2 = txt_nombre.TextLength - 1
'Calculo el SUMNOMBRE
For i = 0 To tmp2
sumanombre += Asc(Mid(txt_nombre.Text, i + 1, 1)) 'Acumulo suma
tmp = Strings.Right(Hex(sumanombre).ToString, 2) 'Solo 8 bits (Registro AL)
sumanombre = Val("&H" & tmp) 'Paso a decimal
Next
tmp = Strings.Right(Hex(sumanombre).ToString, 2)
sumanombre = CInt("&H" & tmp)
txtdebug.Text = "- SumNombre = " & Hex(sumanombre) & vbCrLf
txtdebug.Text &= "----------------------------------------------" & vbCrLf
Dim a(8) As Integer
'
'a - sumanombre >=4 y <=4
'
a(0) = sumanombre - 4
a(1) = sumanombre - 3
a(2) = sumanombre - 2
a(3) = sumanombre - 1
a(4) = sumanombre
a(5) = sumanombre + 1
a(6) = sumanombre + 2
a(7) = sumanombre + 3
a(8) = sumanombre + 4
txtdebug.Text &= "- Posibles valores de 'a'" & vbCrLf
For i = 0 To a.Length - 1
txtdebug.Text &= Hex(a(i)) & " "
Next
txtdebug.Text &= "----------------------------------------------" & vbCrLf
txtdebug.Text &= "- Buscando valores de b y c" & vbCrLf
txtdebug.Text &= "Serial = aabbbbcccc" & vbCrLf
'
'c = sqr(a^2 + b^2)
'
txtdebug.Text &= "(1) c = raiz(a^2 + b^2)" & vbCrLf
txtdebug.Text &= "(2) c - b - 8 = 0" & vbCrLf
For i = 0 To a.Length - 1 ' todas las posibilidades de a
For b = 0 To 65535 'b -> 0000 - FFFF
c = Math.Sqrt(a(i) ^ 2 + b ^ 2)
If c.Contains(".") Then 'busco enteros
Else
cx = c - b - 8
cx = Hex(cx).PadLeft(4, "0"c)
lbl_info.Text = cx
If cx = "0000" Then
txtdebug.Text &= " (1) " & Hex(c).PadLeft(4, "0"c) & " = raiz(" & Hex(a(i)).PadLeft(2, "0"c) & "^2 + " & Hex(b).PadLeft(4, "0"c) & "^2)" & vbCrLf
lst_serials.Items.Add(Hex(a(i)).PadLeft(2, "0"c) & Hex(b).PadLeft(4, "0"c) & Hex(c).PadLeft(4, "0"c))
txtdebug.Text &= " (2) " & Hex(c).PadLeft(4, "0"c) & " - " & Hex(b).PadLeft(4, "0"c) & " - 8 = 0" & vbCrLf
End If
End If
Application.DoEvents()
Next
Next
lbl_info.Text = "Búsqueda finalizada"
End If
Catch ex As Exception
MsgBox(ex.ToString)
End Try
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.
Se encuentran en los eventos de carga y cierre del formulario.
// 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)».
Para la otra Nag sería lo mismo.
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 usuario + El número aleatorio
Ejemplo
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.
Ahora ya podemos registrarnos.
File carving is the process of reassembling computer files from fragments in the absence of filesystem metadata. Wikipedia.
«File carving», literalmente tallado de archivos aunque lo traduciremos como extracción, es el proceso de re-ensamblado de archivos extraídos de un conjunto de mayor tamaño.
Header = Cabecera
Footer or tail = Pie
All this documents have the same header and footer, because of this, we need search the middle bytes. This type uses a ZIP file package.
Los documentos de Microsoft Office >2007 tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.
All this documents have the same header and footer, because of this, we need some bytes to differentiate them. In this case we can do this jumping 73 bytes from header. This type uses a ZIP file package.
Los documentos de OpenOffice tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.
Note: >2007 versions have two patterns and the key is the position 0x80. If in this position we get the bytes «68 40 F8 F7 92», we need to search again for this bytes and displace 107 bytes to find the end of the file. If in the position 0x80 we get another different bytes, we need to search again this bytes and displace 1024 bytes to find the end of the file.
Nota: Las versiones >2007 siguen dos patrones y la clave está en la posición 0x80. Si en la posicion 0x80 obtenemos los bytes «68 40 F8 F7 92», los buscamos una segunda vez y ha 107 bytes encontramos el final del archivo. Si en la posición 0x80 obtenemos otros bytes diferentes a los del primer caso, los volvemos a buscar y a 1024 bytes hallaremos el final del archivo.
En este reto se nos entrega un archivo WAV de 9,92 MB. Tras escucharlo y analizarlo por encima con Audacity no llego a ningún lado por lo que me tiro al descarte de herramientas conocidas, y en ésta ocasión sale a escena DeepSound.
Sin más dilación extraemos el JPG y continuamos.
La aparición en escena de DeepSound me hace sospechar sobre el uso de herramientas conocidas y ¡bingo!, sale a escena StegHide. En esta ocasión el autor del reto nos lo ha puesto fácil y la extracción no requiere clave.
Al abrir el archivo TXT como texto vemos lo siguiente:
y si lo abrimos con un editor hexadecimal vemos esto otro:
Claramente el archivo esconde algo que por la repetición de los caracteres me hace sospechar de un simple XOR y efectivamente la flag está XOReada. Tras un ataque preliminar, digamos que los árboles no me dejaban ver el bosque, de modo que limpié los bytes correspondientes a la frase «this is the flag :)» y procesé de nuevo obteniendo por fin la ansiada flag.
RAW bytes
FF FE 74 00 68 00 69 00 73 00 20 00 40 DB 53 DC 40 DB 48 DC 40 DB 53 DC 40 DB 7B DC 40 DB 74 DC 69 00 73 00 20 00 40 DB 30 DC 40 DB 30 DC 40 DB 5F DC 40 DB 33 DC 40 DB 34 DC 74 00 68 00 65 00 20 00 40 DB 73 DC 40 DB 79 DC 40 DB 5F DC 40 DB 6D DC 40 DB 34 DC 66 00 6C 00 61 00 67 00 20 00 40 DB 6E DC 40 DB 7D DC 40 DB 20 DC 3A 00 29 00
Cleaned bytes [quitando this is the flag :)]
FF FE 40 DB 53 DC 40 DB 48 DC 40 DB 53 DC 40 DB 7B DC 40 DB 74 DC 40 DB 30 DC 40 DB 30 DC 40 DB 5F DC 40 DB 33 DC 40 DB 34 DC 40 DB 73 DC 40 DB 79 DC 40 DB 5F DC 40 DB 6D DC 40 DB 34 DC 40 DB 6E DC 40 DB 7D DC 40 DB 20 DC
clave XOR == 00fc60fb
Resultado
S H S { t 0 0 _ 3 4 s y _ m 4 n }
Un error que habitualmente cometo cuando me enfrento a todo tipo de retos (especialmente en CTFs) es empezar a procesar el fichero proporcionado con todo tipo de herramientas como pollo sin cabeza. En el caso que nos ocupa se proporcionaba un fichero de audio WAV que procesé hasta con 4 herramientas diferentes antes de tomar aire y decidir simplemente escuchar el audio. Al escucharlo me di cuenta de que se trataba de una marcación por tonos comúnmente conocido como DTMF (Dual-Tone Multi-Frequency).
Con una rápida búsqueda por la web encontré una sencilla herramienta realizada en python llamada dtmf-decoder con la que enseguida obtenemos resultados. La herramienta es bastante sencilla, simplemente parte la señal en trozos, calcula la FFT (Fast Fourier Transform) para obtener las amplitudes y las compara con las de los tonos DTMF. Hay que tener en cuenta que el audio entregado es muy limpio y eso facilita mucho las cosas.
El siguiente comando nos devuelve los números marcados.
Como era de esperar, los números obtenidos no son la solución final aunque en este caso enseguida damos con que el tipo de codificación es simple y llanamente ASCII.
DTMF = 837283123119104521169510048951214811795119521101166363125
HEX = 53 48 53 7B 77 68 34 74 5F 64 30 5F 79 30 75 5F 77 34 6E 74 3F 3F 7D
Solución: SHS{wh4t_d0_y0u_w4nt??}
Hoy tenemos un crackme hecho en ensamblador y que cuenta con tres niveles. En el primero de todos nos enfrentamos a una «Splash screen» o nag. El segundo en un serial Hardcodeado y el tercero un número de serie asociado a un nombre.
Abrimos el crackme con Olly y vamos a las «Intermodular Calls«, enseguida vemos la función que crea las ventanas «CreateWindowExA«. Se puede ver lo que parece ser la creación de la pantalla del crackme y al final hay algo que salta a la vista y es la propiedad «WS_TOPMOST», es decir, que se mantenga delante del resto de ventanas.
Pinchamos sobre la función y vamos a parar aquí.
Vemos la llamada a CreateWindowExA que podríamos parchear pero vamos a pensar un poco. Vemos la función GetTickCount y que carga el valor 7D0. 7D0 es 2000 en decimal, que perfectamente pueden ser milisegundos, por lo tanto el parcheo más elegante sería poner la función GetTickCount a 0. En la imagen inferior se puede ver como queda parcheado el valor 7D0.
Probamos y funciona, pasamos a lo siguiente.
El mensaje de error del serial hardcodeado dice «Sorry, please try again». Lo buscamos en las string references y vamos a parar aquí.
Vemos un bucle de comparación que carga unos bytes de la memoria, los bytes dicen «HardCoded«, probamos y prueba superada.
Con el mismo método de las string references localizamos el código que nos interesa. Metemos deurus como nombre y 12345 como serial y empezamos a tracear. Lo primero que hace es una serie de operaciones con nuestro nombre a las que podemos llamar aritmética modular. Aunque en la imagen viene bastante detallado se vé mejor con un ejemplo.
Ejemplo para Nombre: deurus
d e u r u s 64 65 75 72 75 73 -hex 100 101 117 114 117 115 -dec 1ºByte = ((Nombre[0] % 10)^0)+2 2ºByte = ((Nombre[1] % 10)^1)+2 3ºByte = ((Nombre[2] % 10)^2)+2 4ºByte = ((Nombre[3] % 10)^3)+2 5ºByte = ((Nombre[4] % 10)^4)+2 6ºByte = ((Nombre[5] % 10)^5)+2 1ºByte = ((100 Mod 10) Xor 0) + 2 2ºByte = ((101 Mod 10) Xor 1) + 2 3ºByte = ((117 Mod 10) Xor 2) + 2 4ºByte = ((114 Mod 10) Xor 3) + 2 5ºByte = ((117 Mod 10) Xor 4) + 2 6ºByte = ((115 Mod 10) Xor 5) + 2 Si el byte > 10 --> Byte = byte - 10 1ºByte = 2 2ºByte = 2 3ºByte = 7 4ºByte = 9 5ºByte = 5 6ºByte = 2
Lo que nos deja que los Bytes mágicos para deurus son: 227952.
Debido a la naturaleza de la operación IDIV y el bucle en general, llegamos a la conclusión de que para cada letra es un solo byte mágico y que este está comprendido entre 0 y 9.
A continuación realiza las siguientes operaciones con el serial introducido.
Ejemplo para serial: 12345
1 2 3 4 5 31 32 33 34 35 -hex 49 50 51 52 53 -dec 49 mod 10 = 9 50 mod 10 = 0 51 mod 10 = 1 52 mod 10 = 2 53 mod 10 = 3
Los bytes mágicos del serial son: 90123, que difieren bastante de los conseguidos con el nombre.
A continuación compara byte a byte 227952 con 90123.
En resumen, para cada nombre genera un código por cada letra y luego la comprobación del serial la realiza usando el módulo 10 del dígito ascii. Lo primero que se me ocurre es que necesitamos cotejar algún dígito del 0 al 9 para tener cubiertas todas las posibilidades. Realizamos manualmente mod 10 a los números del 0 al 9 y obtenemos sus valores.
(0) 48 mod 10 = 8 (1) 49 mod 10 = 9 (2) 50 mod 10 = 0 (3) 51 mod 10 = 1 (4) 52 mod 10 = 2 (5) 53 mod 10 = 3 (6) 54 mod 10 = 4 (7) 55 mod 10 = 5 (8) 56 mod 10 = 6 (9) 57 mod 10 = 7
Con esto ya podríamos generar un serial válido.
0123456789 - Nuestro alfabeto numérico 8901234567 - Su valor Mod 10
Por lo que para deurus un serial válido sería: 449174. Recordemos que los bytes mágicos para deurus eran «227952», solo hay que sustituir.
Para realizar un KeyGen más interesante, he sacado los valores de un alfabeto mayor y le he añadido una rutina aleatoria para que genere seriales diferentes para un mismo nombre.
'abcdefghijklmnñppqrstuvwxyz0123456789ABCDEFGHIJKLMNÑOPQRSTUVWXYZ - Alfabeto
'7890123456778901234567789018901234567567890123455678901234556880 - Valor
Dim suma As Integer = 0
'Para hacer el serial más divertido
Dim brute() As String = {"2", "3", "4", "5", "6", "7", "8", "9", "0", "1"}
Dim brute2() As String = {"d", "e", "f", "g", "h", "i", "j", "a", "b", "c"}
Dim brute3() As String = {"P", "Q", "R", "S", "T", "U", "j", "a", "D", "E"}
Dim alea As New Random()
txtserial.Text = ""
'Evito nombres mayores de 11 para evitar el BUG comentado en le manual
If Len(txtnombre.Text) > 0 And Len(txtnombre.Text) < 12 Then
For i = 1 To Len(txtnombre.Text)
Dim aleatorio As Integer = alea.Next(0, 9)
suma = (((Asc(Mid(txtnombre.Text, i, 1))) Mod 10) Xor i - 1) + 2
If suma > 9 Then
suma = suma - 10
End If
If (aleatorio) >= 0 And (aleatorio) <= 4 Then
txtserial.Text = txtserial.Text & brute(suma)
ElseIf (aleatorio) > 4 And (aleatorio) <= 7 Then
txtserial.Text = txtserial.Text & brute2(suma)
ElseIf (aleatorio) > 7 And (aleatorio) <= 10 Then
txtserial.Text = txtserial.Text & brute3(suma)
End If
suma = 0
Next
Else
txtserial.Text = "El Nombre..."
End If
Hay un pequeño bug en el almacenaje del nombre y serial y en el guardado de bytes mágicos del serial. Si nos fijamos en los bucles del nombre y el serial, vemos que los bytes mágicos del nombre los guarda a partir de la dirección de memoria 403258 y los bytes mágicos del serial a partir de 40324D. En la siguiente imagen podemos ver seleccionados los 11 primeros bytes donde se almacenan los bytes mágicos del serial. Vemos que hay seleccionados 11 bytes y que el siguiente sería ya 403258, precisamente donde están los bytes mágicos del nombre. Como puedes imaginar si escribes un serial >11 dígitos se solapan bytes y es una chapuza, de modo que el keygen lo he limitado a nombres de 11 dígitos.
Hoy tenemos aquí un capitulo del gran David Slade, productor de Series como American Gods o Hannibal y director de películas como Hard Candy o 30 días de oscuridad.
Lo que más me ha gustado del capítulo es el guiño que han hecho a la RaspBerry PI. La escena transcurre al inicio del capítulo cuando uno de los protagonistas se conecta a un vehículo para hackearlo con una Raspi 3 Model B con varios pines del GPIO doblados. Os dejo unas capturas a continuación donde se aprecia el logo.
Ya puestos, la conexión parece micro usb tipo B. Al fondo se ve lo que parece un puerto HDMI.
Lo que no me ha gustado es que al fijarme en el software que corre en el vehículo aparece un flamante OMNIBOOT.EXE con un aspecto parecido al símbolo de sistema, es decir, nos intentan vender que en un futuro el software que gestiona el vehículo es alguna variación de Windows, algo poco probable a día de hoy al menos. Con este tipo de predicciones no se puede escupir hacia arriba pero actualmente es más probable un nucleo tipo Linux u otro propietario al estilo Tesla.
Software del vehículo
Os dejo todas las capturas relevantes a continuación.
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.
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
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!
Aquí os dejo un video tutorial. El crackme lo podeis encontrar en crackmes.de.
Este crackme pertenece a la página de Karpoff Spanish Tutor. Data del año 2000 y está realizado en «Borland Delphi 6.0 – 7.0», además, para resolverlo deberemos activar un botón y conseguir la clave de registro. La principal dificultad proviene a la hora de activar el botón ya que el serial es en realidad un serial hardcodeado muy sencillo.
Existen numerosas herramientas para facilitarnos esta tarea, una de las más conocidas en el entorno del Cracking es «Veoveo» realizado por Crack el Destripador & Marmota hace ya unos añitos. Con el crackme ejecutado, ejecutamos VeoVeo y nos aparece el icono en la barra de tareas, hacemos click derecho y elegimos Activar Botones (manual) y ya tenemos el botón activado. Claro está que en cada ejecución del Crackme debemos de Re-activarlo.
Lo que siempre nos interesa es que el botón esté activado de forma permanente y eso nos exige un poco más de atención. En este caso nos enfrentamos a Delphi y no nos sirve ni Resource Hacker ni Dede. Cuando nos encontramos en un punto muerto el último recurso siempre es realizar un programa en Delphi con un botón activado y otro desactivado y compararlos con un editor hexadecimal para saber que cambia. Si hacemos esto llegaremos a la conclusión de que en Delphi el bit que equivale a desactivado es 8 y ha activado es 9. Con este simple cambio ya tenemos el crackme parcheado. Comentar que en este caso el crackme no tiene ningún timer ni ninguna rutina que desactive el botón de forma periódica, este es el caso más simple.
Abrimos Ollydbg y en las «String references» encontramos los mensajes de versión registrada, pinchamos sobre ellos y vemos a simple vista la zona de comprobación del serial. Como podéis observar, el serial se vé a simple vista.
0045811A |. B8 10824500 MOV EAX,CrackMe3.00458210 ; ASCII "ESCRIBE ALGO JOER" 0045811F |. E8 D889FDFF CALL CrackMe3.00430AFC 00458124 |. EB 5C JMP SHORT CrackMe3.00458182 00458126 |> 807D FF 4F CMP BYTE PTR SS:[EBP-1],4F - O 0045812A |. 75 56 JNZ SHORT CrackMe3.00458182 0045812C |. 807D FE 41 CMP BYTE PTR SS:[EBP-2],41 - A 00458130 |. 75 50 JNZ SHORT CrackMe3.00458182 00458132 |. 807D FD 45 CMP BYTE PTR SS:[EBP-3],45 - E 00458136 |. 75 4A JNZ SHORT CrackMe3.00458182 00458138 |. 807D FC 4B CMP BYTE PTR SS:[EBP-4],4B - K 0045813C |. 75 44 JNZ SHORT CrackMe3.00458182 0045813E |. 807D FB 43 CMP BYTE PTR SS:[EBP-5],43 - C 00458142 |. 75 3E JNZ SHORT CrackMe3.00458182 00458144 |. 807D FA 41 CMP BYTE PTR SS:[EBP-6],41 - A 00458148 |. 75 38 JNZ SHORT CrackMe3.00458182 0045814A |. 807D F9 52 CMP BYTE PTR SS:[EBP-7],52 - R 0045814E |. 75 32 JNZ SHORT CrackMe3.00458182 00458150 |. 807D F8 4B CMP BYTE PTR SS:[EBP-8],4B - K 00458154 |. 75 2C JNZ SHORT CrackMe3.00458182 00458156 |. 807D F7 20 CMP BYTE PTR SS:[EBP-9],20 - 0045815A |. 75 26 JNZ SHORT CrackMe3.00458182 0045815C |. 807D F6 49 CMP BYTE PTR SS:[EBP-A],49 - I 00458160 |. 75 20 JNZ SHORT CrackMe3.00458182 00458162 |. 807D F5 4F CMP BYTE PTR SS:[EBP-B],4F - O 00458166 |. 75 1A JNZ SHORT CrackMe3.00458182 00458168 |. 807D F4 54 CMP BYTE PTR SS:[EBP-C],54 - T 0045816C |. 75 14 JNZ SHORT CrackMe3.00458182 0045816E |. 807D F3 20 CMP BYTE PTR SS:[EBP-D],20 - 00458172 |. 75 0E JNZ SHORT CrackMe3.00458182 00458174 |. 807D F2 41 CMP BYTE PTR SS:[EBP-E],41 - A 00458178 |. 75 08 JNZ SHORT CrackMe3.00458182 0045817A |. 807D F1 59 CMP BYTE PTR SS:[EBP-F],59 - Y 0045817E |. 75 02 JNZ SHORT CrackMe3.00458182 00458180 |. B3 01 MOV BL,1 00458182 |> 80FB 01 CMP BL,1 00458185 |. 75 4C JNZ SHORT CrackMe3.004581D3 00458187 |. BA 2C824500 MOV EDX,CrackMe3.0045822C 0045818C |. 8B86 F4020000 MOV EAX,DWORD PTR DS:[ESI+2F4] 00458192 |. E8 B5EBFDFF CALL CrackMe3.00436D4C 00458197 |. BA 48824500 MOV EDX,CrackMe3.00458248 ; ASCII "VERSION REGISTRADA :)" Serial = YA TOI KRACKEAO
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.
Echamos un vistazo a la web y lo único interesante que vemos es un buscador.
Miramos el código fuente y vemos una ruta interesante.
Ahora fijémonos en el menú productos. Pinchamos sobre cualquier producto y a continuación en la imagen para ampliarla, veremos el siguiente enlace.
Vamos a ver si podemos explotar «i.php«. Probamos a obtener información sensible del servidor.
Probamos «http://www.thisislegal.com/nc/i.php?img=adm/login.pwd» y nos da error, seguramente por que está anexionando la extensión de la imagen, es decir, el script está interpretando esto:
Vamos a anularlo con un caracter nulo. Probamos y ahora si.
El password está en base64. Lo decodificamos online, nos logueamos y reto superado.
Hoy tenemos aquí un crackme del año 2000 empacado y con un algoritmo aunque no muy complicado largo de tracear. Está empacado varias veces, algo poco habitual pero recordemos que es un crackme antiguo. Tras el empacado se encuentra Delphi.
VideoTutorial del desempacado disponible
Si lo pasamos por PEiD nos dice que Aspack 2.1, Exeinfo no está muy seguro y RDG packer detector en el escaneo avanzado nos encuentra Aspack, UPX y PE-Pack.
En principio nos enfrentamos a Aspack 2.1, abrimos el crackme con OllyDbg y vemos el típico PUSHAD.
Pulsamos F8 (Step Over) y a continuación click derecho sobre el registro ESP y Follow in DUMP.
Seleccionamos los primeros cuatro bytes útiles del dump y les ponemos un Breakpoint de Hardware, Access y Dword.
Pulsamos F9 y nos para aquí:
Ya tenemos a Aspack contra las cuerdas, pulsamos F8 hasta después del RETN para llegar al OEP (Original Entry Point).
Pero en el supuesto OEP vemos otro PUSHAD por lo que esto no ha terminado. Investigando un poco más vemos que la segunda capa se corresponde con PE-PACK 1.0. La estrategia a seguir es la misma, como ya tenemos el breakpoint puesto pulsamos F9 y nos para aquí:
Pulsamos F8 y nos llega a otro PUSHAD. Esta vez es UPX.
Pulsamos de nuevo F9 y paramos aquí:
Pulsamos F8 y esta vez si llegamos al OEP (4576EC).
A continuación vamos a dumpear el archivo en memoria. Vamos a plugins > OllyDumpEX, pulsamos sobre «Get EIP as OEP» y finalmente sobre «Dump«.
Minimizamos Olly (no cerrar), abrimos el programa ImportREC y seleccionamos el ejecutable «Sweeet1.exe».
Pegamos el OEP original (576EC), le damos a AutoSearch y a continuación a Get Imports.
Finalmente pulsamos Fix Dump y elegimos el ejecutable dumpeado anteriormente. Esto nos genera un ejecutable dumpeado que es el ejecutable válido.
Ahora PEiD nos dice que estamos tratando con un crackme hecho en Delphi.
Hemos pasado por tres capas de compresión casi idénticas, vamos a analizarlas.
Cuando abrimos el crackme nos fijamos en que genera una key. Esta key se genera en función del disco duro desde el que se ejecuta.
Como la secuencia de generación del serial válido es larga os pongo lo más importante muy resumido y con ejemplos como siempre.
El serial es del siguiente tipo:
Serial = 1ªParte-2ªParte-3ªParte
Serial = 0000XXXXX-SerialCalculado-xxxx000Z8
Comprobación del tamaño del nombre ---------------------------------- ........ 00456EAA E8 01CCFAFF CALL sweeet1_Fix_dump_rebuilded.00403AB0 00456EAF 83F8 04 CMP EAX,4 ------------------------------------------------; Nombre >=4 00456EB2 7D 13 JGE SHORT sweeet1_Fix_dump_rebuilded.00456EC7 00456EB4 A1 08954500 MOV EAX,DWORD PTR DS:[sweeet1_Fix_dump_rebuilded.459508] 00456EB9 8B00 MOV EAX,DWORD PTR DS:[EAX] 00456EBB E8 0869FEFF CALL sweeet1_Fix_dump_rebuilded.0043D7C8 00456EC0 BB 01000000 MOV EBX,1 00456EC5 EB 15 JMP SHORT sweeet1_Fix_dump_rebuilded.00456EDC 00456EC7 83FB 25 CMP EBX,25 00456ECA 7D 0E JGE SHORT sweeet1_Fix_dump_rebuilded.00456EDA 00456ECC 83C3 32 ADD EBX,32 00456ECF 83C3 1E ADD EBX,1E 00456ED2 83EB 4F SUB EBX,4F 00456ED5 83FB 25 CMP EBX,25 -----------------------------------------------; Nombre <=25 00456ED8 ^ 7C F2 JL SHORT sweeet1_Fix_dump_rebuilded.00456ECC 00456EDA 33DB XOR EBX,EBX 00456EDC 33C0 XOR EAX,EAX ........ 1ºBucle - Nuestro nombre (A) ---------------------------- ........ 00456F55 BE 1B000000 MOV ESI,1B -------------------------------; ESI = 1B 00456F5A EB 21 JMP SHORT sweeet1_dump_.00456F7D 00456F5C 8D55 D4 LEA EDX,[EBP-2C] 00456F5F A1 34A84500 MOV EAX,DWORD PTR DS:[sweeet1_dump_.45A8 00456F64 8B80 C4020000 MOV EAX,DWORD PTR DS:[EAX+2C4] 00456F6A E8 B5DAFCFF CALL sweeet1_dump_.00424A24 00456F6F 8B45 D4 MOV EAX,DWORD PTR SS:[EBP-2C] 00456F72 0FB64418 FF MOVZX EAX,BYTE PTR DS:[EBX+EAX-1]---------; Coje digito 00456F77 03F0 ADD ESI,EAX ------------------------------; digito + ESI 00456F79 43 INC EBX 00456F7A 0FAFF3 IMUL ESI,EBX ----------------------------; multiplica por i (bucle) 00456F7D 8D55 D4 LEA EDX,[EBP-2C] ........ 2ºBucle - La key (B) -------------------- ........ 00456F9C |. BF 1A000000 MOV EDI,1A -------------------------;EDI = 1A 00456FA1 |. BB 01000000 MOV EBX,1 00456FA6 |. EB 1E JMP SHORT sweeet1_.00456FC6 00456FA8 |> 8D55 D4 /LEA EDX,[LOCAL.11] 00456FAB |. A1 34A84500 |MOV EAX,DWORD PTR DS:[45A834] 00456FB0 |. 8B80 D0020000 |MOV EAX,DWORD PTR DS:[EAX+2D0] 00456FB6 |. E8 69DAFCFF |CALL sweeet1_.00424A24 00456FBB |. 8B45 D4 |MOV EAX,[LOCAL.11] 00456FBE |. 0FB64418 FF |MOVZX EAX,BYTE PTR DS:[EAX+EBX-1]--;Coje dígito 00456FC3 |. 03F8 |ADD EDI,EAX -----------------------;Suma dígito a dígito 00456FC5 |. 43 |INC EBX 00456FC6 |> 8D55 D4 LEA EDX,[LOCAL.11] 00456FC9 |. A1 34A84500 |MOV EAX,DWORD PTR DS:[45A834] 00456FCE |. 8B80 D0020000 |MOV EAX,DWORD PTR DS:[EAX+2D0] 00456FD4 |. E8 4BDAFCFF |CALL sweeet1_.00424A24 00456FD9 |. 8B45 D4 |MOV EAX,[LOCAL.11] 00456FDC |. E8 CFCAFAFF |CALL sweeet1_.00403AB0 00456FE1 |. 3BD8 |CMP EBX,EAX 00456FE3 |.^ 7C C3 \JL SHORT sweeet1_.00456FA8 ........ Generación del serial central ----------------------------- ........ 00456FE5 |. B9 01000000 MOV ECX,1 00456FEA |. BB 01000000 MOV EBX,1 00456FEF |. 8BC7 MOV EAX,EDI 00456FF1 |. F7EE IMUL ESI ----------; C = A * B 00456FF3 |. 99 CDQ ........ 00456FFD |. 2345 E8 AND EAX,[LOCAL.6]--; D = A and C 00457000 |. 2355 EC AND EDX,[LOCAL.5] 00457003 |. 8945 E8 MOV [LOCAL.6],EAX 00457006 |. 8955 EC MOV [LOCAL.5],EDX ........ 00457032 |. 8BC7 MOV EAX,EDI 00457034 |. 99 CDQ 00457035 |. 0345 E8 ADD EAX,[LOCAL.6]--; E = D + B 00457038 |. 1355 EC ADC EDX,[LOCAL.5] 0045703B |. 8945 E0 MOV [LOCAL.8],EAX 0045703E |. 8955 E4 MOV [LOCAL.7],EDX ........ 00405732 8B4424 10 MOV EAX,DWORD PTR SS:[ESP+10] 00405736 F72424 MUL DWORD PTR SS:[ESP] 00405739 8BC8 MOV ECX,EAX 0040573B 8B4424 04 MOV EAX,DWORD PTR SS:[ESP+4] 0040573F F76424 0C MUL DWORD PTR SS:[ESP+C]------; F = B * D 00405743 03C8 ADD ECX,EAX 00405745 8B0424 MOV EAX,DWORD PTR SS:[ESP] 00405748 F76424 0C MUL DWORD PTR SS:[ESP+C]------; G = A * F ........ 0045705E |. 0B0424 OR EAX,DWORD PTR SS:[ESP]-----; Serial central = G or A ........ 00457077 |. E8 FC07FBFF CALL sweeet1_.00407878 0045707C |. 8B45 F8 MOV EAX,[LOCAL.2]-------------; EAX = Serial central ........ 004570D1 |. E8 A207FBFF CALL sweeet1_.00407878 004570D6 |. 8B45 D0 MOV EAX,[LOCAL.12] 004570D9 |. E8 D2C9FAFF CALL sweeet1_.00403AB0--------; Obtiene longitud del serial central en hexa 004570DE |. 8BD8 MOV EBX,EAX ........ 004570D1 |. E8 A207FBFF CALL sweeet1_.00407878--------;*Nota
*Nota:
A partir de aquí genera la primera y tercera parte del serial de la siguiente manera:
Serial = 1ªParte-2ªParte-3ªParte
Serial = 0000XXXXX-SerialCalculado-xxxx000Z8
1ºParte = 3ºdigSerial+1ºdigSerial+2ºdigSerial+3ºdigSerial+4ºdigNombreMayu+2ºdigNombreMayu+5ºdigNombreMayu+1ºdigNombreMayu+3ºdigNombreMayu 3ºParte = 3ºdigNombreMin+1ºdigNombreMin+4ºdigNombreMin+2ºdigNombreMin+Tamaño Serial_2ªParte en Hex y de tres dígitos+Z8
Ejemplo:
Nombre: deurus Key: C0C0A000 Serial: 6906REUDU-906297047918-udre00CZ8 1) A = 23A2A (Con nuestro nombre empezando por 1B se lo suma a ESI y se lo multiplica por i (la que toque cada vez)) 2) B = 1A1 (Con nuestra Key empezando por 1A va sumando los digitos) 3) C = B * A = 3A0BE6A 4) D = A and C = 3A2A 5) E = D + B = 3BCB (Offset 457035) 6) F = B * D = 5EBE6A (Offset 48704A) 7) G = A * F = D303834164 8) Serial = G or A (Serial = D303834164 or 23A2A = D303837B6E (906297047918))
A tener en cuenta:
**Nota:
Nombre: deurus.info Key: E09FF000 Serial: 9169REUDU-16918236-udre008Z8 Fíjate que: -16918236 = FFFFFFFFFEFDD924 Nombre: deurus Key: C0C0A000 Serial: 6906REUDU-906297047918-udre00CZ8 906297047918 = 000000D303837B6E
Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.
El cifrado XOR es uno de los algoritmos más utilizados en el mundillo de la encriptación. Aunque por sí solo no es seguro, suele formar parte de cifrados más complejos e incluso si sois aficionados a los crackmes os habréis dado cuenta de que raro es el crackme que no lo utiliza.
Hoy vamos a hacer un recorrido sobre los retos de encriptación que nos propone yoire.com, que aunque son muy sencillos, nos proporcionan una estupenda base para iniciarnos en este tipo de retos.
En este primer reto, el autor te da directamente la solución, ya que, nos da un texto cifrado y nos dice que está cifrado con la clave 10. Lo que el autor no indica es que la clave es hexadecimal, mas adelante ya aprendereis a fijaros en esos detalles.
Texto cifrado: uqci0t~7d0ie0dxy~{
Clave: 10
Esta vez disponemos de un texto cifrado pero sin pistas. Si nos fijamos en el código fuente veremos que la clave utilizada esta vez es 20 y decimal.
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Easy"));
print Challenges::header();
?>
Convierte la solución que está cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
$solution_xored="m{a4s{`4}`5";
$key = sprintf("%2x",20);
$solution = Crypt::XorData($solution_xored,$key);
print "La solución es: ".$solution_xored;
print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
En esta ocasión debemos ojear el código fuente para averiguar como solucionar el reto. En esta ocasión y como de lo que se trata es de aprender, este lo dejaré sin solucionar.
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Mid"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
foreach (
preg_split("/\./","2.4.10.71.3698")
as $something
)
$value=pow($something,2);
$key = dechex($value);
$solution_xored = base64_decode("ucSnos+lo8Oqtw==");
$solution = Crypt::XorData($solution_xored,$key);
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>
<?php
if(Common::getString("showSource")!==false) {
print "<hr>";
highlight_file(__FILE__);
}
print Website::footer();
?>
Venga que casi lo tienes.
En este reto nos indican que el código fuente está encriptado. Cuando nos enfrentamos a XOR en texto grandes y teniendo un indicio de lo que puede contener el código desencriptado es sencillo encontrar lo que buscamos. En este caso en concreto podemos intuir que seguramente el texto contenga la palabra «php«, una vez llegamos a esa conclusión la solución llega sola. Este método no deja de ser un ataque por fuerza bruta.
Código encriptado
lo 8 p]Z9>3<%45xr~~~~~~3?"5~ 8 ryk]Z "9>$p52#9$5jj85145"x1""1)xr$9
lt;5rmnr85p p81<$p81<<5>75#jj85145"xyk]Zon]Z1"535p!%5p5$5p81p#94?p396"14?~~~p%===~~~p$5>4"±#p!%5p1&5"97%1"p3£=?p 1"1p?2$5>5"p<1p"5# %5#$1p1p5#$5p"5$?j]Zl2"nl2"n]Zlo 8 ]Z]Zt;5)ppppppppppppmpre`rk]Zt=5pppppppppppppmp69<575$3?>$5>$#x yk]Zt=5(?"54pppppppmp") $jj?"1$1xt=5|t;5)yk]Z]Z "9>$p81<<5>75#jj#?<%$9?>?(xyk]Z "9>$p81<<5>75#jj3853;?<%$9?>xr3````aryk]Zon]Zl1p8"56mrlomt r r onolom%"<5>3?45x") $jj?"1$1xr#8?'?%"35r|t;5)yyonrn5"p3£497?p6%5>$5l1n]Z]Zlo 8 ]Z96x?==?>jj75$$"9>7x") $jj?"1$1xr#8?'?%"35r|t;5)yyqmm61<#5yp+]ZY "9>$prl8"nrk]ZY "9>$pt=5(?"54k]Z-]Z "9>$p52#9$5jj6??$5"xyk]Zon]Z
Código desencriptado
En este último reto nos aparece un mensaje que nos dice «La solución es: 7b1a4147100a155a0f45574e0f58«. Nos fijamos en el código fuente y vemos que en la encriptación interviene una cookie llamada «PHPSESSID«.
Código fuente
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Hard"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
$sessid = isset($_COOKIE["PHPSESSID"])?$_COOKIE["PHPSESSID"]:">hi!|m¬_ö_Ó_;m'`ñ·$\"<";
$key = Encoder::asc2hex($sessid);
$hiddenSolution = file_get_contents(Config::$challsHiddenData."crypt_xor_average.solution");
$hex_xored_solution = Encoder::data2hex(Crypt::XorData($hiddenSolution,$key));
print "La solucion es: ".$hex_xored_solution;
print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution($hiddenSolution);
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>
<?php
if(Common::getString("showSource")!==false) {
print "<hr>";
highlight_file(__FILE__);
}
print Website::footer();
?>
Desde Firefox vamos a usar una extensión muy interesante llamada Advanced Cookie Manager que nos permitirá visualizar y modificar dicha cookie.
Una particularidad de la encriptación XOR es que si realizamos «algo XOR 0 == algo«, por lo que un ataque típico sería anular la cookie. La modificamos poniendo como valor 0 y guardamos. Recargamos la web con F5 y ahora nos fijamos que el valor de la solución ha cambiado a «7e5f4410435f1058514254100a19«. Finalmente y teniendo en cuenta que el texto que tenemos es hexadecimal, hacemos fuerza bruta marcando la opción Output First y clickamos en Search.
En el mismo directorio donde tenemos el programa se genera un archivo llamado «XOR_enumeration.txt«, que contiene todos los resultados, echamos un vistazo y hemos tenido suerte.
Hace poco me reencontré con esta entrañable serie que tanto me entretuvo cuando era pequeño y para mi sorpresa, me percaté de que nunca había visto el episodio piloto. La nostalgia me llevó a tragarme el episodio entero y a disfrutar a lo grande de la parafernalia técnica de la que hace gala para justificar la creación que da nombre a la serie.
Esto hay que analizarlo con perspectiva. Estamos en los años 80 y nos están presentando un coche capaz de mantener una conversación, es decir, nos están presentando una inteligencia artificial (IA) llamada KITT. Puede parecer que el término inteligencia artificial es nuevo pero realmente se acuño en 1956 por John McCarthy. A partir de ese momento surgieron líneas de estudio e hipótesis pero a partir de los 70 se puede considerar que la investigación sobre la IA perdió financiación y quedó en el congelador hasta los años 90. Dicho esto, cuando nos presentan a KITT lo hacen de la siguiente manera:
Devon Miles: Está totalmente controlado por microprocesadores que hacen físicamente imposible que se vea implicado en ningún tipo de colisión o percance a no ser que se lo ordene su piloto específicamente
Michael Knight: ¿Piloto?, no me diga que esta cosa vuela
Devon Miles: ¡No!, pero piensa
Michael Knight: ¿Piensa?, ¿mi coche piensa?
Intel daba a conocer el primer microprocesador allá por el 71 y la serie se estrenó en el 82 lo que le da credibilidad en ese aspecto, aunque dudo que el público de esa época supiera que era un microprocesador, un ordenador y menos una IA.
La serie arranca con un grupo de personas realizando espionaje industrial donde nos muestran las hojas de datos de dos chips Japoneses como son el PD8257-5 y el PD780. Un aplauso para los guionistas y sus asesores ya que el PD8257-5 es una interfaz de comunicaciones y el PD780 un microprocesador de 8 bits.
Lo más interesante es que lo que se muestra es real como podéis apreciar en la siguiente imagen
A continuación un detalle de las capturas realizadas:
Más adelante vuelven a aparecer imágenes en un PC que parecen puestas en post-producción y que son robadas en un maravilloso disco de 5 1/4.
Llaman la atención mucho los diálogos centrados en el microprocesador como si de un ser superior se tratase, éste es la referencia continua y la parte central del guion de los dos primeros capítulos. Curiosamente aparecen en pantalla multitud de imágenes de circuitos integrados pero no se llega a ver ningún microprocesador. Por otro lado, es interesante el esfuerzo que hacen los guionistas por que llamemos a KITT él en vez de ello, convirtiendo al coche en un personaje más.
Otra cosa que llama mucho la atención son los tópicos de los que hace gala como la asociación de los microprocesadores a los videojuegos o que la empresa villana esté afincada en Silicon Valley. Incluso el nombre KITT es un tópico ya que las siglas vienen de Knight Industries Two Thousand que en cristiano quiere decir Industrias Knight 2000. Y es que en mi opinión el año 2000 se imaginaba como una barrera lejana en la que todo iba a ser tecnológicamente más avanzado.
Tengo que reconocer que me ha sorprendido que dieran realismo a los chips mostrados teniendo en cuenta que aparecen muy pocos segundos en pantalla y podían haber puesto cualquier cosa.
Por otro lado, la realidad es que en el año 2022 aún nos queda recorrido para llegar a tener un coche fantástico y lo más parecido que tenemos hoy día sería un Tesla con Alexa.
Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por eso, vamos a tener que lidiar con ciertas peculiaridades al realizar el keygen con un lenguaje de bajo nivel.
Al inicio comprueba la longitud del nombre y de el número de serie. El nombre debe tener al menos 6 caracteres y el número de serie debe tener 10. Os adelanto ya que la asignación de memoria del nombre es de 9 caracteres, es decir, da igual la longitud del nombre que solo va a usar 9.
004014AD | E8 1A 02 00 00 | call <pythagoras.GetWindowTextA> | ;Lee el nombre 004014B2 | 83 F8 06 | cmp eax,6 | ;Nombre >=6 caracteres 004014B5 | 0F 82 03 01 00 00 | jb pythagoras.4015BE | 004014BB | 6A 14 | push 14 | 004014BD | 68 D9 31 40 00 | push pythagoras.4031D9 | ;004031D9:"1234567890" 004014C2 | FF 35 10 32 40 00 | push dword ptr ds:[403210] | 004014C8 | E8 FF 01 00 00 | call <pythagoras.GetWindowTextA> | ;Lee el serial 004014CD | 83 F8 0A | cmp eax,A | ;Serial debe tener 10 (A) caracteres 004014D0 | 0F 85 E8 00 00 00 | jne pythagoras.4015BE |
Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890
A continuación chequea que nuestro serial tenga caracteres hexadecimales.
004014DA | 8A 81 D9 31 40 00 | mov al,byte ptr ds:[ecx+4031D9] | ; ecx+004031D9:"1234567890" 004014E0 | 3C 00 | cmp al,0 | ; contador del bucle 004014E2 | 74 1F | je pythagoras.401503 | ; fin del bucle 004014E4 | 3C 30 | cmp al,30 | ; 0x30 = número 1 004014E6 | 0F 82 D2 00 00 00 | jb pythagoras.4015BE | ; < 30 bad boy 004014EC | 3C 46 | cmp al,46 | ; 0x46 = letra F 004014EE | 0F 87 CA 00 00 00 | ja pythagoras.4015BE | ; > 46 bad boy 004014F4 | 3C 39 | cmp al,39 | ; 0x39 = número 9 004014F6 | 76 08 | jbe pythagoras.401500 | ; <=39 ok continua el bucle 004014F8 | 3C 41 | cmp al,41 | ; 0x41 = letra A 004014FA | 0F 82 BE 00 00 00 | jb pythagoras.4015BE | ; <41 bad boy 00401500 | 41 | inc ecx | ; contador += 1 00401501 | EB D7 | jmp pythagoras.4014DA | ; bucle
Continua realizando un sumatorio con nuestro nombre, pero tenemos que tener especial cuidado al tratamiento de los datos, ya que el crackme al estar hecho en ensamblador puede jugar con los registros como quiere y eso nos puede inducir a error.
0040150B | 3C 00 | cmp al,0 | ; ¿Fin bucle? 0040150D | 74 05 | je pythagoras.401514 | ; Salta fuera del bucle si procede 0040150F | 02 D8 | add bl,al | ; bl = bl + al 00401511 | 41 | inc ecx | ; contador +=1 00401512 | EB F1 | jmp pythagoras.401505 | ; bucle
Si os fijáis utiliza registros de 8 bits como son AL y BL. Debajo os dejo una explicación de EAX pero para EBX es lo mismo.
EAX
-----------------------------------
AX
-----------------
AH AL
-------- --------
00000000 00000000 00000000 00000000
(8bit) (8bit) (8bit) (8bit)
EAX (32 bit)
--------
AX (16 bit)
----
AHAL (AH y AL 8 bit)
--------
00000000
El uso de registros de 8 bits nos implica tomar precauciones al realizar el Keygen debido a que por ejemplo, en .Net no tenemos la capacidad de decirle que haga una suma y que nos devuelva solamente 8 bits del resultado. Veamos como ejemplo para el nombre «deurus». La suma de los caracteres hexadecimales quedaría:
64+65+75+72+75+73 = 298, es decir, EAX = 00000298
Pero recordad que el crackme solo cogerá el 98 que es lo correspondiente al registro AL. De momento nos quedamos con nuestro SUMNOMBRE = 98.
A continuación coge los dos primeros caracteres del serial y les resta nuestro SUMNOMBRE y comprueba que el resultado esté entre 4 (0x4) y -4 (0xFC).
0040154B | 0F B6 05 F3 31 40 00 | movzx eax,byte ptr ds:[4031F3] | 00401552 | 8A C8 | mov cl,al | 00401554 | 2A CB | sub cl,bl | ; CL = CL - BL | CL = 12 - 98 = 7A 00401556 | 80 F9 04 | cmp cl,4 | ; Compara CL con 4 00401559 | 7F 63 | jg pythagoras.4015BE | ; Salta si es mayor 0040155B | 80 F9 FC | cmp cl,FC | ; Compara CL con FC (-4) 0040155E | 7C 5E | jl pythagoras.4015BE | ; Salta si es menor
Como veis, el resultado de la resta da 7A (122) que al ser mayor que 4 nos echa vilmente. Aquí de nuevo utiliza registros de 8 bits por lo que debemos tener cuidado con las operaciones matemáticas para no cometer errores, veamos un ejemplo para clarificar de aquí en adelante.
Utilizando 8 bits ----------------- 12 - 98 = 7A que en decimal es 122 Utilizando 16 bits ------------------ 0012 - 0098 = FF7A que en decimal es -134
Ahora ya veis la diferencia entre FC (252) y FFFC (-4). Estrictamente, el crackme comprueba el rango entre 4 (4) y FC (122) al trabajar con registros de 8 bits pero nosotros, como veremos más adelante tomaremos el rango entre 4 y -4. De momento, para poder continuar depurando cambiamos los dos primeros caracteres del serial de 12 a 98, ya que 98 – 98 = 0 y cumple la condición anterior.
Introducimos Nombre: deurus y Serial: 9834567890
Analicemos el siguiente código.
00401560 | F7 E0 | mul eax | ; EAX = EAX * EAX 00401562 | 8B D8 | mov ebx,eax | ; EBX = EAX 00401564 | 0F B7 05 F4 31 40 00 | movzx eax,word ptr ds:[4031F4] | ; EAX = 3456 (4 dígitos siguientes del serial) 0040156B | F7 E0 | mul eax | ; EAX = EAX * EAX 0040156D | 03 D8 | add ebx,eax | ; EBX = EBX + EAX 0040156F | 0F B7 05 F6 31 40 00 | movzx eax,word ptr ds:[4031F6] | ; EAX = 7890 (4 últimos dígitos del serial) 00401576 | F7 E0 | mul eax | ; EAX = EAX * EAX 00401578 | 33 C3 | xor eax,ebx | ; EAX 0040157A | 75 42 | jne pythagoras.4015BE | ; Salta si el flag ZF no se activa
En resumen:
Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²
Serial = aabbbbcccc
Finalmente comprueba lo siguiente:
0040157C | 66 A1 F6 31 40 00 | mov ax,word ptr ds:[4031F6] | ; AX = 7890 00401582 | 66 2B 05 F4 31 40 00 | sub ax,word ptr ds:[4031F4] | ; AX = 7890 - 3456 = 443A 00401589 | 2C 08 | sub al,8 | ; AL = 3A - 8 = 32 0040158B | 75 31 | jne pythagoras.4015BE | ; Si el resultado de la resta no ha sido cero, serial no válido 0040158D | 6A 30 | push 30 | 0040158F | 68 B0 31 40 00 | push pythagoras.4031B0 | ;004031B0:":-) Well done!!!" 00401594 | 68 7F 31 40 00 | push pythagoras.40317F | ;0040317F:"Bravo, hai trovato il seriale di questo CrackMe!" 00401599 | FF 75 08 | push dword ptr ds:[ebp+8] |
En resumen:
Nuestro serial tiene que cumplir tres condiciones para ser válido.
Como hemos dicho anteriormente, tomaremos el SUMNOMBRE y le sumaremos y restaremos valores siempre y cuando el resultado esté entre 4 y -4. Para deurus hemos dicho que el SUMNOMBRE es 98 por lo que los posibles valores de «a» se pueden ver debajo. Además debemos tener en cuenta que el crackme solo lee los 9 primeros dígitos del nombre.
98-4 = 94 98-3 = 95 98-2 = 96 98-1 = 97 98-0 = 98 98+1 = 99 98+2 = 9A 98+3 = 9B 98+4 = 9C
Es evidente que para encontrar el valor de «c» vamos a tener que utilizar fuerza bruta chequeando todos los valores de «b» comprendidos entre 0 y FFFF (65535). Además, como trabajaremos en un lenguaje de alto nivel, debemos descartar los resultados decimales. Esto nos limitará los seriales válidos asociados a un determinado nombre. Si realizáramos el keygen en ensamblador obtendríamos bastantes más seriales válidos.
Una vez encontrados los valores enteros de la operación «c² = a² + b²», se debe cumplir que «c – b – 8 = 0», lo que nos limitará bastante los resultados.
Private Sub btn_generar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_generar.Click
Try
If txt_nombre.TextLength > 5 Then
lst_serials.Items.Clear()
Dim tmp, c, cx As String
Dim sumanombre, tmp2 As Integer
If txt_nombre.TextLength > 9 Then tmp2 = 8 Else tmp2 = txt_nombre.TextLength - 1
'Calculo el SUMNOMBRE
For i = 0 To tmp2
sumanombre += Asc(Mid(txt_nombre.Text, i + 1, 1)) 'Acumulo suma
tmp = Strings.Right(Hex(sumanombre).ToString, 2) 'Solo 8 bits (Registro AL)
sumanombre = Val("&H" & tmp) 'Paso a decimal
Next
tmp = Strings.Right(Hex(sumanombre).ToString, 2)
sumanombre = CInt("&H" & tmp)
txtdebug.Text = "- SumNombre = " & Hex(sumanombre) & vbCrLf
txtdebug.Text &= "----------------------------------------------" & vbCrLf
Dim a(8) As Integer
'
'a - sumanombre >=4 y <=4
'
a(0) = sumanombre - 4
a(1) = sumanombre - 3
a(2) = sumanombre - 2
a(3) = sumanombre - 1
a(4) = sumanombre
a(5) = sumanombre + 1
a(6) = sumanombre + 2
a(7) = sumanombre + 3
a(8) = sumanombre + 4
txtdebug.Text &= "- Posibles valores de 'a'" & vbCrLf
For i = 0 To a.Length - 1
txtdebug.Text &= Hex(a(i)) & " "
Next
txtdebug.Text &= "----------------------------------------------" & vbCrLf
txtdebug.Text &= "- Buscando valores de b y c" & vbCrLf
txtdebug.Text &= "Serial = aabbbbcccc" & vbCrLf
'
'c = sqr(a^2 + b^2)
'
txtdebug.Text &= "(1) c = raiz(a^2 + b^2)" & vbCrLf
txtdebug.Text &= "(2) c - b - 8 = 0" & vbCrLf
For i = 0 To a.Length - 1 ' todas las posibilidades de a
For b = 0 To 65535 'b -> 0000 - FFFF
c = Math.Sqrt(a(i) ^ 2 + b ^ 2)
If c.Contains(".") Then 'busco enteros
Else
cx = c - b - 8
cx = Hex(cx).PadLeft(4, "0"c)
lbl_info.Text = cx
If cx = "0000" Then
txtdebug.Text &= " (1) " & Hex(c).PadLeft(4, "0"c) & " = raiz(" & Hex(a(i)).PadLeft(2, "0"c) & "^2 + " & Hex(b).PadLeft(4, "0"c) & "^2)" & vbCrLf
lst_serials.Items.Add(Hex(a(i)).PadLeft(2, "0"c) & Hex(b).PadLeft(4, "0"c) & Hex(c).PadLeft(4, "0"c))
txtdebug.Text &= " (2) " & Hex(c).PadLeft(4, "0"c) & " - " & Hex(b).PadLeft(4, "0"c) & " - 8 = 0" & vbCrLf
End If
End If
Application.DoEvents()
Next
Next
lbl_info.Text = "Búsqueda finalizada"
End If
Catch ex As Exception
MsgBox(ex.ToString)
End Try
Aquí os dejo un video tutorial. El crackme lo podeis encontrar en crackmes.de.