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
Los retos criptográficos son muy variados y muchas veces la dificultad está en saber a que te enfrentas. En este caso pasa eso, te dan un código y si no has visto algo parecido en la vida, no sabes por donde empezar. El título del autor da una pequeña pista pero para los desconocedores no es suficiente. La pista es el título y dice «WTF?!?» y el código a descifrar es el siguiente:
[-]>[-]< >+++++++++++[<+++++++++++>-]<. >+++[<--->-]<-. >++[<++>-]<++. +. >++++[<---->-]<-. ---. +++. . >+++[<+++>-]<. >+++[<--->-]<+. >++++[<++++>-]<-. >++++[<---->-]<--. >+++[<+++>-]<-. >++[<-->-]<--. -.
Si eres una persona con recursos, realizaras varias búsquedas por la red y al final llegarás a la conclusión de que te enfrentas a BRAINFUCK, un lenguaje de programación esotérico como ya vimos en el reto de Root-Me.
Como se muestra en la imagen siguiente, la creación del serial es muy sencilla y al final la comparación es lineal ya que se compara nuestro serial con el serial válido. Veamos el serial válido para el usuario “abc” cuyos dígitos en hexadecimal son 0x61, 0x62 y 0x63.
|
Letra a
|
Letra b
|
Letra c
|
|
Suma + 0x61
Suma * 0x20
Suma xor 0xBEFF
Suma / 4
Suma = 0x2CB7
|
Suma + 0x62
Suma * 0x20
Suma xor 0xBEFF
Suma / 4
Suma = 0x14777
|
Suma + 0x63
Suma * 0x20
Suma xor 0xBEFF
Suma / 4
Suma = 0xA116F
|
|
Suma xor 0xBEA4 = 0xAAFCB
|
||
|
Serial válido = 700363
|
||
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.
Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos encontrado es esto en un foro: шжзклмнпфъ = 1234567890
Mensaje secreto: нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл
Parece que el mensaje secreto está encriptado utilizando un alfabeto cifrado que corresponde a números. Según la clave proporcionada (шжзклмнпфъ = 1234567890), cada letra del alfabeto cirílico se sustituye por un número.
Primero, descompondremos la clave dada:
ш = 1
ж = 2
з = 3
к = 4
л = 5
м = 6
н = 7
п = 8
ф = 9
ъ = 0
Ahora, aplicamos esta clave al mensaje secreto:
нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл
Sustituyendo cada letra según la clave:
нж = 72
фн = 97
фф = 99
шън = 107
нф = 79
шшъ = 110
шжз = 123
мф = 69
шъп = 108
фл = 95
пк = 84
шъш = 101
шшм = 116
шшк = 114
шъл = 105
шшл = 115
фл = 95
шъш = 101
шшл = 115
фл = 95
шшн = 117
шшъ = 110
фл = 95
шъм = 106
шшн = 117
шъш = 101
шъз = 130
шшш = 111
фл = 95
пж = 82
шшн = 117
шшл = 115
шшш = 111
шжл = 125
El mensaje traducido a números es:
72, 97, 99, 107, 79, 110, 123, 69, 108, 95, 84, 101, 116, 114, 105, 115, 95, 101, 115, 95, 117, 110, 95, 106, 117, 101, 130, 111, 95, 82, 117, 115, 111, 125
Este parece ser un mensaje cifrado en números. La secuencia de números se puede interpretar de varias maneras (como ASCII, coordenadas, etc.). Si asumimos que es un texto codificado en ASCII:
Convertimos cada número a su correspondiente carácter ASCII:
72 = H
97 = a
99 = c
107 = k
79 = O
110 = n
123 = {
69 = E
108 = l
95 = _
84 = T
101 = e
116 = t
114 = r
105 = i
115 = s
95 = _
101 = e
115 = s
95 = _
117 = u
110 = n
95 = _
106 = j
117 = u
101 = e
130 = ?
111 = o
95 = _
82 = R
117 = u
115 = s
111 = o
125 = }
Juntando todo:
HackOn{El_Tetris_e_s_u_n_j_u_e?o_Ruso}
La parte «{El_Tetris_e_s_u_n_j_u_e?o_Ruso}» parece un mensaje en español. Probablemente deba ser leído como: HackOn{El_Tetris_es_un_juego_Ruso}
Así, el mensaje secreto es: HackOn{El_Tetris_es_un_juego_Ruso}.
La imagen de portada de la entrada ha sido generada con ChatGPT.
Cargamos el crackme en Ollydbg y vamos a las «Referenced Strings«. Vemos una referencia muy interesante que se llama «checkkey«.
Pinchamos sobre ella y aparecemos aquí:
Vemos una referencia a «GetDlgItemTextA» y depués un Call también interesante, vamos a explorarlo.
Dentro del Call hay dos bucles, uno realiza una operación con nuestro serial (bucle nombre) y el otro comprueba nuestro serial con «3d34273130276a» dígito a dígito (bucle comprobación).
Bucle nombre se puede resumir así:
MOVSX EAX,BYTE PTR DS:[EBX] --> Dígito a EAX XOR EAX,55 --> EAX xor 55 ... CMP BYTE PTR DS:[EBX],0 --> ¿hemos acabado? JNZ SHORT 10001022 --> bucle LEA ECX,DWORD PTR SS:[EBP-20] --> ECX = nuestro serial xoreado
Bucle comprobación se podría resumir así:
MOV EDX,10006000 --> EDX = "3d34273130276a" ... MOV AL,BYTE PTR DS:[ECX] --> AL = 1ºdígito serial xoreado CMP AL,BYTE PTR DS:[ECX+EDX] --> AL = 1ºdígito de EDX? JNZ SHORT 1000105A --> Si no son iguales bad boy INC ECX TEST AL,AL JNZ SHORT 1000104A --> bucle
Ejemplo para «deurus».
Nombre: d e u r u s
Ascii hex: 64 65 75 72 75 73
XOR 55: 31 30 20 27 20 26
Serial correcto XOReado: 3d 34 27 31 30 27 6a
XOR 55: 68 61 72 64 65 72 3F
Valor ascii: h a r d e r ?
Aquí os dejo un video tutorial. El crackme lo podeis encontrar en crackmes.de.
Aquí tenemos un Crackme clásico creado por Scarebyte hallá por el año 2000 y que cuenta con varias fases siendo un crackme muy interesante para iniciarse o simplemente para divertirse. Al estar realizado en Delphi, los apartados de las checkboxes y de las trackbars se simplifican y mucho, pero aún así hay que currarselo un poco para dejar todo bien atado. Si os fijáis en las soluciones que aparecen en crackmes.de, en aquellos años se usaba DEDE y aunque yo usaré otra herramienta, DEDE sigue siendo igual de útil.
PEiD nos dice que nos enfrentamos a ASPack 1.08.03 -> Alexey Solodovnikov, así que vamos al lío.
Tan sencillo como poner un Breakpoint a User32.MessageBoxA. La llamada a NOPear está en la dirección 441CF2.
Desde las string references localizamos los mensajes de chico bueno y chico malo que nos llevan al código a analizar.
0044C3CD |. E8 5294FDFF CALL CrackMe_.00425824 0044C3D2 |. 8B45 FC MOV EAX,[LOCAL.1] 0044C3D5 |. E8 9A76FBFF CALL CrackMe_.00403A74 0044C3DA |. 83F8 0C CMP EAX,0C ; Lengh C = 12 0044C3DD |. 0F85 53010000 JNZ CrackMe_.0044C536 ; Salto a chico malo 0044C3E3 |. 8D55 FC LEA EDX,[LOCAL.1] 0044C3E6 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C3EC |. E8 3394FDFF CALL CrackMe_.00425824 0044C3F1 |. 8B45 FC MOV EAX,[LOCAL.1] 0044C3F4 |. 8038 43 CMP BYTE PTR DS:[EAX],43 ; 1º dígito serial = C 0044C3F7 |. 0F85 27010000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C3FD |. 8D55 F8 LEA EDX,[LOCAL.2] 0044C400 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C406 |. E8 1994FDFF CALL CrackMe_.00425824 0044C40B |. 8B45 F8 MOV EAX,[LOCAL.2] 0044C40E |. 8078 03 6F CMP BYTE PTR DS:[EAX+3],6F ; 4º dígito serial = o 0044C412 |. 0F85 0C010000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C418 |. 8D55 F4 LEA EDX,[LOCAL.3] 0044C41B |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C421 |. E8 FE93FDFF CALL CrackMe_.00425824 0044C426 |. 8B45 F4 MOV EAX,[LOCAL.3] 0044C429 |. 8078 08 6F CMP BYTE PTR DS:[EAX+8],6F ; 9º dígito serial = o 0044C42D |. 0F85 F1000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C433 |. 8D55 F0 LEA EDX,[LOCAL.4] 0044C436 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C43C |. E8 E393FDFF CALL CrackMe_.00425824 0044C441 |. 8B45 F0 MOV EAX,[LOCAL.4] 0044C444 |. 8078 01 6C CMP BYTE PTR DS:[EAX+1],6C ; 2º dígito serial = l 0044C448 |. 0F85 D6000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C44E |. 8D55 EC LEA EDX,[LOCAL.5] 0044C451 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C457 |. E8 C893FDFF CALL CrackMe_.00425824 0044C45C |. 8B45 EC MOV EAX,[LOCAL.5] 0044C45F |. 8078 04 20 CMP BYTE PTR DS:[EAX+4],20 ; 5º dígito serial = espacio 0044C463 |. 0F85 BB000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C469 |. 8D55 E8 LEA EDX,[LOCAL.6] 0044C46C |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C472 |. E8 AD93FDFF CALL CrackMe_.00425824 0044C477 |. 8B45 E8 MOV EAX,[LOCAL.6] 0044C47A |. 8078 0A 52 CMP BYTE PTR DS:[EAX+A],52 ; 11º dígito serial = R 0044C47E |. 0F85 A0000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C484 |. 8D55 E4 LEA EDX,[LOCAL.7] 0044C487 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C48D |. E8 9293FDFF CALL CrackMe_.00425824 0044C492 |. 8B45 E4 MOV EAX,[LOCAL.7] 0044C495 |. 8078 07 75 CMP BYTE PTR DS:[EAX+7],75 ; 8º dígito serial = u 0044C499 |. 0F85 85000000 JNZ CrackMe_.0044C524 ; Salto a chico malo 0044C49F |. 8D55 E0 LEA EDX,[LOCAL.8] 0044C4A2 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4A8 |. E8 7793FDFF CALL CrackMe_.00425824 0044C4AD |. 8B45 E0 MOV EAX,[LOCAL.8] 0044C4B0 |. 8078 09 6E CMP BYTE PTR DS:[EAX+9],6E ; 10º dígito serial = n 0044C4B4 |. 75 6E JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4B6 |. 8D55 DC LEA EDX,[LOCAL.9] 0044C4B9 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4BF |. E8 6093FDFF CALL CrackMe_.00425824 0044C4C4 |. 8B45 DC MOV EAX,[LOCAL.9] 0044C4C7 |. 8078 02 6E CMP BYTE PTR DS:[EAX+2],6E ; 3º dígito serial = n 0044C4CB |. 75 57 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4CD |. 8D55 D8 LEA EDX,[LOCAL.10] 0044C4D0 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4D6 |. E8 4993FDFF CALL CrackMe_.00425824 0044C4DB |. 8B45 D8 MOV EAX,[LOCAL.10] 0044C4DE |. 8078 05 69 CMP BYTE PTR DS:[EAX+5],69 ; 6º dígito serial = i 0044C4E2 |. 75 40 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4E4 |. 8D55 D4 LEA EDX,[LOCAL.11] 0044C4E7 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C4ED |. E8 3293FDFF CALL CrackMe_.00425824 0044C4F2 |. 8B45 D4 MOV EAX,[LOCAL.11] 0044C4F5 |. 8078 0B 6E CMP BYTE PTR DS:[EAX+B],6E ; 12º dígito serial = n 0044C4F9 |. 75 29 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C4FB |. 8D55 D0 LEA EDX,[LOCAL.12] 0044C4FE |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C504 |. E8 1B93FDFF CALL CrackMe_.00425824 0044C509 |. 8B45 D0 MOV EAX,[LOCAL.12] 0044C50C |. 8078 06 67 CMP BYTE PTR DS:[EAX+6],67 ; 7º dígito serial = g 0044C510 |. 75 12 JNZ SHORT CrackMe_.0044C524 ; Salto a chico malo 0044C512 |. BA 78C54400 MOV EDX,CrackMe_.0044C578 ; ASCII "Right Password" 0044C517 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C51D |. E8 3293FDFF CALL CrackMe_.00425854 0044C522 |. EB 22 JMP SHORT CrackMe_.0044C546 0044C524 |> BA 90C54400 MOV EDX,CrackMe_.0044C590 ; ASCII "Wrong Password" 0044C529 |. 8B83 E8020000 MOV EAX,DWORD PTR DS:[EBX+2E8] 0044C52F |. E8 2093FDFF CALL CrackMe_.00425854 0044C534 |. EB 10 JMP SHORT CrackMe_.0044C546 0044C536 |> BA 90C54400 MOV EDX,CrackMe_.0044C590 ; ASCII "Wrong Password" Chequeo rápido ABCD EFGHIJK Clno iguonRn ; 1º dígito serial = C ; 4º dígito serial = o ; 9º dígito serial = o ; 2º dígito serial = l ; 5º dígito serial = espacio ; 11º dígito serial = R ; 8º dígito serial = u ; 10º dígito serial = n ; 3º dígito serial = n ; 6º dígito serial = i ; 12º dígito serial = n ; 7º dígito serial = g
Básicamente chequea la frase «Cool Running» de forma desordenada como se ve justo encima, siendo el password correcto «Clno iguonRn«. Os dejo el código para que lo analicéis.
De nuevo con las string references localizamos el código.
0044C648 /. 55 PUSH EBP 0044C649 |. 8BEC MOV EBP,ESP 0044C64B |. 83C4 F8 ADD ESP,-8 0044C64E |. 53 PUSH EBX 0044C64F |. 56 PUSH ESI 0044C650 |. 33C9 XOR ECX,ECX 0044C652 |. 894D F8 MOV [LOCAL.2],ECX 0044C655 |. 8BF0 MOV ESI,EAX 0044C657 |. 33C0 XOR EAX,EAX 0044C659 |. 55 PUSH EBP 0044C65A |. 68 83C74400 PUSH CrackMe_.0044C783 0044C65F |. 64:FF30 PUSH DWORD PTR FS:[EAX] 0044C662 |. 64:8920 MOV DWORD PTR FS:[EAX],ESP 0044C665 |. 33C0 XOR EAX,EAX 0044C667 |. 8945 FC MOV [LOCAL.1],EAX 0044C66A |. A1 80F84400 MOV EAX,DWORD PTR DS:[44F880] ; Eax = Nombre 0044C66F |. E8 0074FBFF CALL CrackMe_.00403A74 0044C674 |. 83F8 06 CMP EAX,6 ; Cmp lengh nombre con 6 0044C677 |. 0F8E F0000000 JLE CrackMe_.0044C76D ; Salta si <= 6 0044C67D |. A1 80F84400 MOV EAX,DWORD PTR DS:[44F880] ; Eax = Nombre 0044C682 |. E8 ED73FBFF CALL CrackMe_.00403A74 0044C687 |. 83F8 14 CMP EAX,14 ; Cmp lengh nombre con 20 (14h) 0044C68A |. 0F8D DD000000 JGE CrackMe_.0044C76D ; salta si >= 20 0044C690 |. A1 80F84400 MOV EAX,DWORD PTR DS:[44F880] 0044C695 |. E8 DA73FBFF CALL CrackMe_.00403A74 0044C69A |. 85C0 TEST EAX,EAX 0044C69C |. 7E 17 JLE SHORT CrackMe_.0044C6B5 0044C69E |. BA 01000000 MOV EDX,1 0044C6A3 |> 8B0D 80F84400 /MOV ECX,DWORD PTR DS:[44F880] ; Bucle in 0044C6A9 |. 0FB64C11 FF |MOVZX ECX,BYTE PTR DS:[ECX+EDX-1] 0044C6AE |. 014D FC |ADD [LOCAL.1],ECX ; Suma dig nombre y guarda en 12FBC4 0044C6B1 |. 42 |INC EDX 0044C6B2 |. 48 |DEC EAX 0044C6B3 |.^ 75 EE \JNZ SHORT CrackMe_.0044C6A3 ; Bucle out 0044C6B5 |> A1 84F84400 MOV EAX,DWORD PTR DS:[44F884] ; Eax = Compañia 0044C6BA |. E8 B573FBFF CALL CrackMe_.00403A74 0044C6BF |. 83F8 02 CMP EAX,2 ; Cmp lengh compañia con 2 0044C6C2 |. 7E 18 JLE SHORT CrackMe_.0044C6DC ; Salta si <= 2 0044C6C4 |. A1 84F84400 MOV EAX,DWORD PTR DS:[44F884] ; Eax = Compañia 0044C6C9 |. E8 A673FBFF CALL CrackMe_.00403A74 0044C6CE |. 83F8 08 CMP EAX,8 ; Cmp lengh compañia con 8 0044C6D1 |. 7D 09 JGE SHORT CrackMe_.0044C6DC ; Salta si >= 8 0044C6D3 |. 8B45 FC MOV EAX,[LOCAL.1] ; Eax = sum nombre 0044C6D6 |. 6BC0 02 IMUL EAX,EAX,2 ; Sum nombre * 2 0044C6D9 |. 8945 FC MOV [LOCAL.1],EAX 0044C6DC |> 68 98C74400 PUSH CrackMe_.0044C798 ; ASCII "I Love Cracking and " 0044C6E1 |. 8D55 F8 LEA EDX,[LOCAL.2] 0044C6E4 |. 8B45 FC MOV EAX,[LOCAL.1] 0044C6E7 |. E8 68B0FBFF CALL CrackMe_.00407754 0044C6EC |. FF75 F8 PUSH [LOCAL.2] ; sum del nombre 0044C6EF |. 68 B8C74400 PUSH CrackMe_.0044C7B8 ; ASCII " Girls ;)" 0044C6F4 |. B8 8CF84400 MOV EAX,CrackMe_.0044F88C 0044C6F9 |. BA 03000000 MOV EDX,3 0044C6FE |. E8 3174FBFF CALL CrackMe_.00403B34 ; Concatena 1º frase + sum nombre + 2ºfrase 0044C703 |. 33C0 XOR EAX,EAX 0044C705 |. 8945 FC MOV [LOCAL.1],EAX 0044C708 |. A1 88F84400 MOV EAX,DWORD PTR DS:[44F888] ; Eax = Serial 0044C70D |. E8 6273FBFF CALL CrackMe_.00403A74 0044C712 |. 8BD8 MOV EBX,EAX 0044C714 |. A1 8CF84400 MOV EAX,DWORD PTR DS:[44F88C] 0044C719 |. E8 5673FBFF CALL CrackMe_.00403A74 0044C71E |. 3BD8 CMP EBX,EAX ; Compara tamaño frase con tamaño serial 0044C720 |. 75 4B JNZ SHORT CrackMe_.0044C76D 0044C722 |. A1 88F84400 MOV EAX,DWORD PTR DS:[44F888] 0044C727 |. E8 4873FBFF CALL CrackMe_.00403A74 0044C72C |. 85C0 TEST EAX,EAX 0044C72E |. 7E 27 JLE SHORT CrackMe_.0044C757 0044C730 |. BA 01000000 MOV EDX,1 0044C735 |> 8B0D 88F84400 /MOV ECX,DWORD PTR DS:[44F888] ; Bucle in --> 0044C73B |. 0FB64C11 FF |MOVZX ECX,BYTE PTR DS:[ECX+EDX-1] 0044C740 |. 034D FC |ADD ECX,[LOCAL.1] 0044C743 |. 8B1D 8CF84400 |MOV EBX,DWORD PTR DS:[44F88C] 0044C749 |. 0FB65C13 FF |MOVZX EBX,BYTE PTR DS:[EBX+EDX-1] ; Compara dígito a dígito nuestro serial 0044C74E |. 2BCB |SUB ECX,EBX ; con la concatenación anterior 0044C750 |. 894D FC |MOV [LOCAL.1],ECX 0044C753 |. 42 |INC EDX 0044C754 |. 48 |DEC EAX 0044C755 |.^ 75 DE \JNZ SHORT CrackMe_.0044C735 ; <-- Bucle out 0044C757 |> 837D FC 00 CMP [LOCAL.1],0 0044C75B |. 75 10 JNZ SHORT CrackMe_.0044C76D ; Salta si algo ha ido mal 0044C75D |. 8B86 14030000 MOV EAX,DWORD PTR DS:[ESI+314] 0044C763 |. BA CCC74400 MOV EDX,CrackMe_.0044C7CC ; "You have found the correct Serial :)"
En resumen
Para afrontar esta parte del reto vamos a usar una herramienta llamada Interactive Delphi Reconstructor o IDR. En su día la mejor herramienta era DEDE, pero IDR a mi parecer es algo más potente.
Básicamente IDR nos permite sin quebraderos de cabeza localizar el código del botón que comprueba la secuencia de checkboxes correcta. Cargamos el crackme en IDR y dentro de la pestaña «Units (F2)«, abajo del todo hacemos doble click sobre «F Crack» y vemos que nos muestra todos los controles del formulario. El botón que nos interesa se llama «SpeedButton3«.
Si hacemos doble click sobre el nos muestra el código que se muestra a continuación.
crack::TForm1.SpeedButton3Click 0044C7F4 push ebp 0044C7F5 mov ebp,esp 0044C7F7 push 0 0044C7F9 push ebx 0044C7FA mov ebx,eax 0044C7FC xor eax,eax 0044C7FE push ebp 0044C7FF push 44C920 0044C804 push dword ptr fs:[eax] 0044C807 mov dword ptr fs:[eax],esp 0044C80A mov eax,dword ptr [ebx+324]; TForm1.cb3:TCheckBox 0044C810 mov edx,dword ptr [eax] 0044C812 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C818 test al,al >0044C81A je 0044C8ED 0044C820 mov eax,dword ptr [ebx+328]; TForm1.cb5:TCheckBox 0044C826 mov edx,dword ptr [eax] 0044C828 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C82E test al,al >0044C830 je 0044C8ED 0044C836 mov eax,dword ptr [ebx+32C]; TForm1.cb6:TCheckBox 0044C83C mov edx,dword ptr [eax] 0044C83E call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C844 test al,al >0044C846 je 0044C8ED 0044C84C mov eax,dword ptr [ebx+358]; TForm1.cb12:TCheckBox 0044C852 mov edx,dword ptr [eax] 0044C854 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C85A test al,al >0044C85C je 0044C8ED 0044C862 mov eax,dword ptr [ebx+364]; TForm1.cb15:TCheckBox 0044C868 mov edx,dword ptr [eax] 0044C86A call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C870 test al,al >0044C872 je 0044C8ED 0044C874 mov eax,dword ptr [ebx+330]; TForm1.cb20:TCheckBox 0044C87A mov edx,dword ptr [eax] 0044C87C call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C882 test al,al >0044C884 je 0044C8ED 0044C886 mov eax,dword ptr [ebx+34C]; TForm1.cb9:TCheckBox 0044C88C mov edx,dword ptr [eax] 0044C88E call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C894 test al,al >0044C896 je 0044C8ED 0044C898 mov eax,dword ptr [ebx+354]; TForm1.cb11:TCheckBox 0044C89E mov edx,dword ptr [eax] 0044C8A0 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C8A6 test al,al >0044C8A8 je 0044C8ED 0044C8AA mov eax,dword ptr [ebx+35C]; TForm1.cb13:TCheckBox 0044C8B0 mov edx,dword ptr [eax] 0044C8B2 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C8B8 test al,al >0044C8BA je 0044C8ED 0044C8BC mov eax,dword ptr [ebx+33C]; TForm1.cb19:TCheckBox 0044C8C2 mov edx,dword ptr [eax] 0044C8C4 call dword ptr [edx+0B8]; TCustomCheckBox.GetChecked 0044C8CA test al,al >0044C8CC je 0044C8ED 0044C8CE lea eax,[ebp-4] 0044C8D1 mov edx,44C934; 'Ìõô¸ö÷ê¥ó¤ÉÚÀƲÄæââîà䶶' 0044C8D6 call @LStrLAsg 0044C8DB lea eax,[ebp-4] 0044C8DE call 0044BF00 0044C8E3 mov eax,dword ptr [ebp-4] 0044C8E6 call ShowMessage >0044C8EB jmp 0044C90A 0044C8ED lea eax,[ebp-4] 0044C8F0 mov edx,44C958; 'Åÿæò衦óàù¨ïêçð®øé¤íüàî诹' 0044C8F5 call @LStrLAsg 0044C8FA lea eax,[ebp-4] 0044C8FD call 0044BF00 0044C902 mov eax,dword ptr [ebp-4] 0044C905 call ShowMessage 0044C90A xor eax,eax 0044C90C pop edx 0044C90D pop ecx 0044C90E pop ecx 0044C90F mov dword ptr fs:[eax],edx 0044C912 push 44C927 0044C917 lea eax,[ebp-4] 0044C91A call @LStrClr 0044C91F ret <0044C920 jmp @HandleFinally <0044C925 jmp 0044C917 0044C927 pop ebx 0044C928 pop ecx 0044C929 pop ebp 0044C92A ret
Como podéis apreciar, las checkboxes involucradas son la 3, 5, 6, 9, 11, 12, 13, 15, 19 y 20. Solo nos falta saber cuales se corresponden con esa numeración y aquí ya depende de cada uno, yo en su día saqué los números a mano mediante el orden de tabulación, pero ya que tenemos IDR, el nos va a dar la solución de una forma sencilla y rápida.
Vamos a la pestaña «Forms (F5)«, seleccionamos la opción Form y hacemos doble click sobre el formulario.
Veréis que aparece el formulario con todos los recursos, incluso los puedes modificar. Localizar los checkboxes ahora es un juego de niños.
Os dejo un vídeo.
De nuevo, con la ayuda de IDR, localizamos la parte del código y analizamos su funcionamiento. Esta parte es la más divertida ya que requiere de un keygen pero en vez de coger el número de serie de una caja de texto lo obtiene de 5 trackbars como muestra la siguiente imagen.
El código de comprobación es el siguiente.
CPU Disasm Address Hex dump Command Comments 0044C1FF |. E8 ECF6FCFF CALL 0041B8F0 ; b^3 0044C204 |. D805 50C34400 FADD DWORD PTR DS:[44C350] ; b^3+5 0044C20A |. D9FA FSQRT ; sqrt(b^3+5) 0044C20C |. E8 F365FBFF CALL 00402804 ; Cos(sqrt(b^3+5)) = U 0044C211 |. DB7D B8 FSTP TBYTE PTR SS:[EBP-48] 0044C214 |. 9B WAIT 0044C215 |. D905 54C34400 FLD DWORD PTR DS:[44C354] ; Coje a 0044C21B |. DC45 E8 FADD QWORD PTR SS:[EBP-18] ; a+1 0044C21E |. D9FA FSQRT ; sqrt(a+1) 0044C220 |. D9E0 FCHS ; -sqrt(a+1) = V 0044C222 |. DB6D B8 FLD TBYTE PTR SS:[EBP-48] 0044C225 |. DEC1 FADDP ST(1),ST 0044C227 |. DB7D AC FSTP TBYTE PTR SS:[EBP-54] 0044C22A |. 9B WAIT 0044C22B |. D905 58C34400 FLD DWORD PTR DS:[44C358] ; coje c 0044C231 |. DC4D D8 FMUL QWORD PTR SS:[EBP-28] ; c*3 0044C234 |. D805 54C34400 FADD DWORD PTR DS:[44C354] ; c*3+1 0044C23A |. D9ED FLDLN2 ; Ln(c*3+1) = X 0044C23C |. D9C9 FXCH ST(1) 0044C23E |. D9F1 FYL2X 0044C240 |. DB6D AC FLD TBYTE PTR SS:[EBP-54] 0044C243 |. DEC1 FADDP ST(1),ST ; U+V+X 0044C245 |. DB7D A0 FSTP TBYTE PTR SS:[EBP-60] 0044C248 |. 9B WAIT 0044C249 |. D905 5CC34400 FLD DWORD PTR DS:[44C35C] ; coje d 0044C24F |. DC45 D0 FADD QWORD PTR SS:[EBP-30] ; d+2 0044C252 |. D9FA FSQRT ; sqrt(d+2) = Y 0044C254 |. DB6D A0 FLD TBYTE PTR SS:[EBP-60] 0044C257 |. DEE1 FSUBRP ST(1),ST ; U+V+X+(-Y) 0044C259 |. D905 58C34400 FLD DWORD PTR DS:[44C358] ; coje e 0044C25F |. DC4D C8 FMUL QWORD PTR SS:[EBP-38] ; e*3 0044C262 |. D835 5CC34400 FDIV DWORD PTR DS:[44C35C] ; (e*3)/2 = Z 0044C268 |. DEC1 FADDP ST(1),ST ; U+V+X+Y+Z 0044C26A |. DB2D 60C34400 FLD TBYTE PTR DS:[44C360] 0044C270 |. DEC1 FADDP ST(1),ST ; U+V+X+Y+Z+0.37 0044C272 |. D80D 6CC34400 FMUL DWORD PTR DS:[44C36C] ; (U+V+X+Y+Z+0.37)*1000 0044C278 |. DD5D F0 FSTP QWORD PTR SS:[EBP-10] 0044C27B |. 9B WAIT 0044C27C |. DD45 F0 FLD QWORD PTR SS:[EBP-10] 0044C27F |. E8 9065FBFF CALL 00402814 ; Redondea((U+V+X+Y+Z+0,37)*1000) 0044C284 |. 8945 98 MOV DWORD PTR SS:[EBP-68],EAX 0044C287 |. 8955 9C MOV DWORD PTR SS:[EBP-64],EDX 0044C28A |. DF6D 98 FILD QWORD PTR SS:[EBP-68] 0044C28D |. 83C4 F4 ADD ESP,-0C 0044C290 |. DB3C24 FSTP TBYTE PTR SS:[LOCAL.33] 0044C293 |. 9B WAIT 0044C294 |. 8D45 FC LEA EAX,[EBP-4] 0044C297 |. E8 68BFFBFF CALL 00408204 0044C29C |. 8D45 FC LEA EAX,[EBP-4] 0044C29F |. E8 5CFCFFFF CALL 0044BF00 ; Llamada de generación de hash ........ 0044BF04 |. 8BF0 MOV ESI,EAX 0044BF06 |. 8B06 MOV EAX,DWORD PTR DS:[ESI] ; EAX = 5415 0044BF08 |. E8 677BFBFF CALL 00403A74 0044BF0D |. 8B15 98EE4400 MOV EDX,DWORD PTR DS:[44EE98] 0044BF13 |. 8902 MOV DWORD PTR DS:[EDX],EAX 0044BF15 |. 8B06 MOV EAX,DWORD PTR DS:[ESI] 0044BF17 |. E8 587BFBFF CALL 00403A74 0044BF1C |. 84C0 TEST AL,AL 0044BF1E |. 76 38 JBE SHORT 0044BF58 0044BF20 |. 880424 MOV BYTE PTR SS:[LOCAL.3],AL 0044BF23 |. B3 01 MOV BL,1 0044BF25 |> B8 1C000000 /MOV EAX,1C 0044BF2A |. E8 516AFBFF |CALL 00402980 0044BF2F |. 0D 80000000 |OR EAX,00000080 0044BF34 |. 8BFB |MOV EDI,EBX 0044BF36 |. 81E7 FF000000 |AND EDI,000000FF 0044BF3C |. 8B16 |MOV EDX,DWORD PTR DS:[ESI] 0044BF3E |. 0FB6543A FF |MOVZX EDX,BYTE PTR DS:[EDI+EDX-1] ; Coje dig a dig el hash, en este caso 5415 0044BF43 |. 33C2 |XOR EAX,EDX ; 1 dig XOR 83; 2 dig XOR 89; 3 dig XOR 86; 4 dig XOR 8D 0044BF45 |. 50 |PUSH EAX 0044BF46 |. 8BC6 |MOV EAX,ESI 0044BF48 |. E8 F77CFBFF |CALL 00403C44 0044BF4D |. 5A |POP EDX 0044BF4E |. 885438 FF |MOV BYTE PTR DS:[EDI+EAX-1],DL 0044BF52 |. 43 |INC EBX 0044BF53 |. FE0C24 |DEC BYTE PTR SS:[LOCAL.3] 0044BF56 |.^ 75 CD \JNZ SHORT 0044BF25 ........ 0044C2AC |. E8 D378FBFF CALL 00403B84 ; Llamada a comparación ........ 00403BAD |> /8B0E /MOV ECX,DWORD PTR DS:[ESI] ; ECX = nuestro Serial XOReado 00403BAF |. |8B1F |MOV EBX,DWORD PTR DS:[EDI] ; EBX = Serial bueno 00403BB1 |. |39D9 |CMP ECX,EBX ; Compara 00403BB3 |. |75 58 |JNE SHORT 00403C0D ; Chico malo 00403BB5 |. |4A |DEC EDX 00403BB6 |. |74 15 |JZ SHORT 00403BCD 00403BB8 |. |8B4E 04 |MOV ECX,DWORD PTR DS:[ESI+4] 00403BBB |. |8B5F 04 |MOV EBX,DWORD PTR DS:[EDI+4] 00403BBE |. |39D9 |CMP ECX,EBX 00403BC0 |. |75 4B |JNE SHORT 00403C0D 00403BC2 |. |83C6 08 |ADD ESI,8 00403BC5 |. |83C7 08 |ADD EDI,8 00403BC8 |. |4A |DEC EDX 00403BC9 |.^\75 E2 \JNZ SHORT 00403BAD
En resumen
1) Siendo nuestro serial : 1 2 3 4 5
a b c d e
2) Realiza las operaciones matemáticas:
Round(((Cos(sqrt(b^3+5)) + (-sqrt(a+1)) + Ln(c*3+1) + (-sqrt(d+2)) + ((e*3)/2))+0.37)*1000))
3) Obtenemos un hash resultante de 5415
4) XORea los dígitos de la siguiente manera:
(5)35 xor 86 = B6
(4)34 xor 83 = BD
(1)31 xor 86 = B7
(5)35 xor 8D = B8
De modo que tenemos B6BDB7B8
5) Compara B6BDB7B8 con B5BAB2BA
6) Revertimos el XOR para obtener el hash bueno
B5 xor 86 = 36(6)
BA xor 83 = 33(3)
B2 xor 86 = 34(4)
BA xor 8D = 37(7)
Luego el hash bueno es 6347
7) Debemos hacer fuerza bruta buscando:
Round(((Cos(sqrt(b^3+5)) + (-sqrt(a+1)) + Ln(c*3+1) + (-sqrt(d+2)) + ((e*3)/2))+0.37)*1000)) = 6347
Para obtener los seriales válidos podemos hacer bucles recursivos hasta recorrer las 10^5 opciones posibles. Una forma de hacerlo en VBNet es la siguiente.
Dim tmp As Double
Dim an, bn, cn, dn, en As Integer
For an = 0 To 9
For bn = 0 To 9
For cn = 0 To 9
For dn = 0 To 9
For en = 0 To 9
tmp = Round(((Cos(Sqrt((Pow(bn, 3)) + 5)) + (-Sqrt(an + 1)) + Log(cn * 3 + 1) + (-Sqrt(dn + 2)) + ((en * 3) / 2) + 0.37) * 1000))
txtdebug.Text = "a-b-c-d-e = Hash || " & an & "-" & bn & "-" & cn & "-" & dn & "-" & en & " = " & tmp
If tmp = 6347 Then
ListBox1.Items.Add("Serial: " & an & bn & cn & dn & en)
End If
Application.DoEvents()
Next
Next
Next
Next
Next
Os dejo como siempre el crackme y el keygen en los enlaces.
Se nos entrega un html con un juego que consiste en hacer clic en un botón tantas veces como podamos para ganar al juego. Acompañando al html tenemos un código javascript ofuscado aparentemente con Obfuscator.io
El código javascript ofuscado tiene el siguiente aspecto.
(function(_0x144932, _0xfc69c5) { var _0x187428 = _0x588c,
_0x3064c6 = _0x144932(); while (!![]) { try { var _0xb96d19 = -parseInt(_0x187428(0x1bd)) / 0x1 + parseInt(_0x187428(0x137)) / 0x2 + -parseInt(_0x187428(0x140)) / 0x3 * (-parseInt(_0x187428(0x13b)) / 0x4) + parseInt(_0x187428(0x15e)) / 0x5 * (parseInt(_0x187428(0x18c)) / 0x6) + -parseInt(_0x187428(0x159)) / 0x7 * (parseInt(_0x187428(0x1c3)) / 0x8) + parseInt(_0x187428(0x129)) / 0x9 * (-parseInt(_0x187428(0x149)) / 0xa) + parseInt(_0x187428(0x16d)) / 0xb; if (_0xb96d19 === _0xfc69c5) break;
else _0x3064c6['push'](_0x3064c6['shift']()); } catch (_0x377a04) { _0x3064c6['push'](_0x3064c6['shift']()); } } }(_0x5be3, 0x6fe59));;
function _0x5be3() { var _0x5a2048 = ['Utf8', 'push', 'createDecryptor', 'Malformed\x20UTF-8\x20data', '_ENC_XFORM_MODE', 'string', '_prevBlock', 'extend', '_doReset', 'AnsiX923', 'error', 'fromCharCode', 'object', '130340XnpiqM', '#res', 'HmacSHA256', 'DES', '4FuuDzS', 'finalize', 'byteLength', 'salt', '_keyPriorReset', '372669TnxSTf', '_xformMode', 'HMAC', 'stringify', 'Latin1', 'cfg', 'start', 'padding', 'show', '47650FNyFfQ', 'parse', 'TripleDES', 'MD5', 'ZeroPadding', 'length', 'Rabbit', 'console', 'Base', 'HmacSHA3', 'kdf', '_doFinalize', 'drop', 'BufferedBlockAlgorithm', 'Cipher', 'HmacSHA1', '7PKTjbP', 'CTR', '_reverseMap', 'clone', 'Encryptor', '43750GcrrDy', 'SHA384', 'byteOffset', 'indexOf', 'Word', '#loader', 'algo', 'apply', 'bind', 'HmacMD5', 'Base64', '_key', 'createEncryptor', 'min', '_counter', '4232173VijiOj', '_lBlock', 'You\x20Lose', 'ECB', 'BlockCipherMode', 'ciphertext', 'floor', 'constructor', 'log', 'search', 'flush', 'Iso10126', 'update', 'NoPadding', 'max', 'HmacSHA384', 'SHA512', 'decrypt', '_des2', '(((.+)+)+)+$', 'high', 'U2FsdGVkX189ylLOlgNSxq/TLeSxBr7cYDcRBgMXXS9VmwusKZx1XFDNdpkwg24v98iYGnUATwQVyWwFnlyoCg==', 'charAt', 'return\x20(function()\x20', 'pow', 'prototype', 'compute', 'reset', 'warn', '_rBlock', 'HmacSHA512', '498WcTnbi', 'join', 'HmacSHA224', 'display', '#trim', 'StreamCipher', 'enc', 'click', '#statistic', 'random', 'keySize', 'SHA1', '_process', 'sigBytes', '$super', '#mybut', 'clamp', 'RC4', '_invSubKeys', 'loader', '_cipher', '#backstart', 'BlockCipher', 'formatter', 'WordArray', 'slice', 'decryptBlock', '_minBufferSize', 'execute', '_iv', '_hash', 'mixIn', '__proto__', 'text', 'concat', 'RabbitLegacy', 'ceil', 'splice', 'Utf16LE', 'array[0]', 'function', 'SHA3', 'charCodeAt', 'EvpKDF', 'toString', 'css', '_state', 'Decryptor', 'Hex', '82275HVLogQ', 'ivSize', 'encrypt', '_des1', '_mode', 'words', '5353976ERfqhe', 'init', '_hasher', '_createHmacHelper', '_oKey', 'lib', 'CipherParams', 'x64', '_keySchedule', 'RC4Drop', 'PBKDF2', '__creator', '_subKeys', '_nDataBytes', '_DEC_XFORM_MODE', 'format', 'substr', '_createHelper', '_data', '_parse', '#cssfilter', '_map', 'create', 'OpenSSL', 'hasher', 'table', 'key', 'hide', 'iterations', '#timecount', 'undefined', 'pad', '_iKey', 'CBC', 'OFB', '#apply', 'SHA224', '_keystream', 'mode', 'exception', 'call', 'hasOwnProperty', 'Utf16', 'encryptBlock', '_invKeySchedule', '#buttons', '_doCryptBlock', 'RIPEMD160', 'blockSize', 'low', '_des3', '{}.constructor(\x22return\x20this\x22)(\x20)', '_nRounds', 'Hasher', 'addClass', 'AES', 'CFB', 'sqrt', '171bibExj'];
_0x5be3 = function() { return _0x5a2048; }; return _0x5be3(); }
...
Deofuscado el código con la web Obfuscator.io llegamos a interpretar la estructura aunque sigue siendo un galimatías en gran parte. Aún así, si nos fijamos al final encontramos una parte interesante con una clave encriptada cuya desencriptación depende de una comparación (línea 13 resaltada). Invirtiendo esa comparación engañamos al código y obtenemos la flag.
$("#mybut").click(function () {
_0x4171cc++;
$("#cssfilter").text(_0x4171cc);
});
$("#statistic").addClass("hide");
_0x35a8b9 = setInterval(function () {
_0x97292c--;
$("#timecount").text(_0x97292c);
if (_0x97292c == 0x0) {
clearInterval(_0x35a8b9);
$("#mybut").hide();
$("#buttons").show(0x64);
if (_0x4171cc > _0x43eef3) {
$('#trim').text(CryptoJS.AES.decrypt("U2FsdGVkX189ylLOlgNSxq/TLeSxBr7cYDcRBgMXXS9VmwusKZx1XFDNdpkwg24v98iYGnUATwQVyWwFnlyoCg==", "array[0]").toString(CryptoJS.enc.Utf8));
} else {
$("#trim").text("You Lose");
}
}
}, 0x3e8);
intervalcomp = setInterval(function () {
_0x43eef3++;
$('#apply').text(_0x43eef3);
if (_0x97292c == 0x0) {
clearInterval(intervalcomp);
}
}, 0x32);
}
});
Al descargar la imagen de la web del reto vemos que tiene la extensión php y lo más probable es que no nos abra correctamente.
... <br/> <img src="steg1img.php"/> <br/> ...
Abrimos la imagen con nuestro editor hexadecimal favorito y nos fijamos en la cabecera.
00000000h: 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 ; ‰PNG........IHDR
Renombramos entonces la extensión a png y continuamos.
Esta parte la afrontaremos con Steganabara, una herramienta muy útil que siempre uso cuando me enfrento a un reto «stego». En esta ocasión utilizaremos el análisis de color. Para ello pulsamos sobre «Analyse > Color table«.
En la tabla de colores tenemos la descomposición de colores RGBA y su frecuencia de aparición. Ordenamos por frecuencia descendiente y hacemos doble clic sobre la fila para abrir la imagen resultante.
A continuación un resumen de las imágenes obtenidas.
Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.
dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe
A partir de aquí el reto pasa a ser de encriptación. Con el tiempo diferenciareis fácilmente el tipo de cifrado con sólo ver el texto. En este caso lo primero que se nos ocurre es comprobar dos cifrados clásicos como son el cifrado César y el Vigenere.
Tras desestimar el cifrado César realizamos un ataque de «fuerza bruta» al cifrado Vigenere mediante análisis estadístico. En la imagen que muestro a continuación se puede ver que la clave está cerca de ser «HPHQTC» pero todavía no se lee correctamente.
Ya que la fuerza bruta de por sí no termina de darnos la respuesta correcta, pasamos a probar algo muy útil, esto es, descifrar por fuerza bruta pero dándole una palabra para comparar. En este caso en concreto vemos que una posible palabra que pudiera estar en el texto encriptado es «PASSWORD», probamos y reto terminado.
Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro keygen. Como comprobareis si no se ofusca o se toman otro tipo de medidas recuperar información sensible es muy sencillo.
AutoIt es un lenguaje freeware multiproposito y de automatización para Microsoft Windows. Es un Visual Basic Killer, ya que mejora las características de los ejecutables (entre otras portabilidad, velocidad y peso, no fat-coding), y facilitan la programación con un buen repertorio de funciones «pre-diseñadas», y usando un Basic de fácil aprendizaje. Se ha expandido desde sus comienzos de automatización incluyendo muchas mejoras en el diseño del lenguaje de programación y sobre todo en nuevas funcionalidades.
Func CHECKKEY($USER, $PASS) Local $OPKEY = "", $SIG = "" Local $USER_LEN = StringLen($USER) Local $PASS_LEN = StringLen($PASS) If $USER_LEN < $PASS_LEN Then MsgBox(0, "ERROR", "Invalid username or key.") Exit ElseIf $USER_LEN < 4 Then MsgBox(0, "ERROR", "Invalid username or key.") Exit EndIf $PASS_INT = Int($USER_LEN / $PASS_LEN) $PASS_MOD = Mod($USER_LEN, $PASS_LEN) $OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD) For $INDEX = 1 To $USER_LEN $SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1)))) Next If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then MsgBox(0, "INFO", "Your key was registered.") Exit Else MsgBox(0, "INFO", "Your key is invalid.") EndIf EndFunc
El algoritmo es tremendamente sencillo ya que es nuestro nombre al revés y en mayúsculas.
El decompilador se llama myAut2exe y tiene este aspecto.
Programar en AutoIt es muy sencillo e intuitivo. Nuestro keygen quedaría así.
$MAIN = GUICreate("Another keygen by deurus", 300, 80, -1, -1, 382205952, 385)
$NAME_LBL = GUICtrlCreateLabel("Username", 5, 5, 60, 20, BitOR(4096, 1))
$NAME_INP = GUICtrlCreateInput("", 70, 5, 225, 20, 1)
$PASS_LBL = GUICtrlCreateLabel("Key", 5, 30, 60, 20, BitOR(4096, 1))
$PASS_INP = GUICtrlCreateInput("", 70, 30, 225, 20, 1)
$REGISTER = GUICtrlCreateButton("Register", 5, 55, 60, 20)
$GIVE_UP = GUICtrlCreateButton("Generate", 70, 55, 60, 20) <- Change name of button, Give Up by Generate
$TASK = GUICtrlCreateButton("?", 140, 55, 20, 20)
$AUTHOR = GUICtrlCreateLabel("keygen by deurus", 165, 55, 130, 20, BitOR(4096, 1))
GUISetState(@SW_SHOW, $MAIN)
While True
$MSG = GUIGetMsg()
Switch $MSG
Case $REGISTER
Call("CHECKKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))
Case $GIVE_UP
Call("GETKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP)) <- Add the function to the button
Case $TASK
MsgBox(0, "Info", "keygen by deurus")
Case - 3
Exit
EndSwitch
Sleep(15)
WEnd
Func GETKEY($USER, $PASS) <- this is our keygen function
Local $OPKEY = "", $SIG = ""
Local $USER_LEN = StringLen($USER)
Local $PASS_LEN = StringLen($USER)
If $USER_LEN < 4 Then
GUICtrlSetData($PASS_INP ,"min 4 chars");
Else
For $INDEX = 1 To $USER_LEN
$SIG = Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), 32)) & $SIG
Next
GUICtrlSetData($PASS_INP ,$SIG);
EndIf
EndFunc
Func CHECKKEY($USER, $PASS) <- check function, the original
Local $OPKEY = "", $SIG = ""
Local $USER_LEN = StringLen($USER)
Local $PASS_LEN = StringLen($PASS)
If $USER_LEN < $PASS_LEN Then
MsgBox(0, "ERROR", "Invalid username or key.")
ElseIf $USER_LEN < 4 Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
EndIf
$PASS_INT = Int($USER_LEN / $PASS_LEN)
$PASS_MOD = Mod($USER_LEN, $PASS_LEN)
$OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
For $INDEX = 1 To $USER_LEN
$SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
Next
If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
MsgBox(0, "INFO", "Your key was registered.")
Else
MsgBox(0, "INFO", "Your key is invalid.")
EndIf
EndFunc
Este es el resultado.
Hoy vamos a enfrentarnos a cuatro retos de esteganografía relativamente sencillos, y digo relativamente, debido a que hay tantas formas de esconder información en un archivo, ya sea imagen, vídeo o sonido, que afrontarlos suele ser desesperante. Las cuatro imágenes son aparentemente las mismas que la que se ve en portada.
Una buena práctica cuando te enfrentas a retos stego de tipo imagen es realizar una búsqueda inversa. Una búsqueda inversa consiste en buscar la imagen original mediante buscadores especializados como TinEye o Google. Si conseguimos la imagen original podemos resolver el reto simplemente comparando o nos puede dar una idea del tipo de modificación por su diferencia de tamaño, colores, degradados, etc.
Descargamos la imagen del reto. Se trata de una imagen JPEG de 526×263 y 76.6 KB (78445 bytes). Su hash SHA1 es «89aed5bbc3542bf5c60c4c318fe99cb1489f267a«
Realizamos una búsqueda inversa de la imagen y encontramos sin dificultad la imagen original mediante TinEye.
Características de la imagen original:
Por lo que vemos ha cambiado el tamaño de 78447 bytes a 78445 bytes y su hash SHA1 tampoco coincide obviamente, lo que nos confirma que ha sufrido alguna modificación. Echando un vistazo con un editor hexadecimal te puedes volver loco por lo que vamos a realizar una comparación mediante la herramienta online DiffNow.
Al realizar la comparación sale a relucir lo que buscamos. La clave es una simple cadena de texto.
Lo primero es realizar de nuevo la comparación.
| Imagen | Tamaño | SHA1 |
|---|---|---|
| Original | 78447 bytes | 8924676317077fc07c252ddeec04bd2a0ecfdda4 |
| imagen2.jpeg | 116386 bytes | 7641e3906f795c137269cefef29f30fcb9cb1b07 |
Como vemos, la imagen ha aumentado significativamente, de 76,6 KB a 113 KB. Cuando el aumento de tamaño llama la atención normalmente tenemos otro archivo insertado. Lo primero que suelo hacer yo es fijarme si ha sido modificado el final del archivo con un editor hexadecimal. Los bytes de cola de un archivo jpg/jpeg son FFD9 y en este caso no vemos modificación alguna al final del archivo. Si el archivo no está al final requiere realizar una búsqueda más exhaustiva. Para estos casos tengo una herramienta de creación propia que se llama Ancillary y que sirve para buscar cierto tipo de archivos dentro de otros como imágenes, documentos de Office, Open Office, pdf, etc. Ancillary encuentra otro jpg que es el que le daba el peso extra y que vemos a continuación. La clave es el título de la película (ojo a las mayúsculas/minúsculas).
El tercer reto parece que tiene algún error debido a que el archivo coincide completamente con el original. Pienso que se ha subido la imagen original por error. Se lo he comunicado al admin del dominio y si algún día obtengo respuesta actualizaré la entrada.
| Imagen | Tamaño | SHA1 |
|---|---|---|
| Original | 78447 bytes | 8924676317077fc07c252ddeec04bd2a0ecfdda4 |
| imagen3.jpeg | 78447 bytes | 8924676317077fc07c252ddeec04bd2a0ecfdda4 |
Actualización 21/08/2016
Al parecer, la solución de este reto es llegar a la conclusión de que la imagen no está modificada. La respuesta del Administrador de la web así lo confirma.
desingsecurity [at] gmail [dot] com – Sorry about the delay, is precisely what is intended with that challenge, they can determine if the image is changed or not , the challenge was solved you . We’ll be equal way improving this point.
Greetings and Thanks
Stego 4
Lo primero es realizar de nuevo la comparación.
| Imagen | Tamaño | SHA1 |
|---|---|---|
| Original | 78447 bytes | 8924676317077fc07c252ddeec04bd2a0ecfdda4 |
| imagen4.jpeg | 93174 bytes | a6329ea4562ef997e5afd067f3b53bdab4665851 |
Al igual que en el caso dos el tamaño ha aumentado significativamente de modo que miramos al final del archivo y esta vez si vemos que hay insertado unos bytes tras el final del jpg (recordemos FFD9)
El archivo tiene pinta de ser una hoja de cálculo de Open Office o Libre Office según indica la palabra «spreadsheet«. Lo abrimos con Excel y tras analizar la maraña de datos enseguida vemos una clave que llama la atención.
Al descargar la imagen de la web del reto vemos que tiene la extensión php y lo más probable es que no nos abra correctamente.
... <br/> <img src="steg1img.php"/> <br/> ...
Abrimos la imagen con nuestro editor hexadecimal favorito y nos fijamos en la cabecera.
00000000h: 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 ; ‰PNG........IHDR
Renombramos entonces la extensión a png y continuamos.
Esta parte la afrontaremos con Steganabara, una herramienta muy útil que siempre uso cuando me enfrento a un reto «stego». En esta ocasión utilizaremos el análisis de color. Para ello pulsamos sobre «Analyse > Color table«.
En la tabla de colores tenemos la descomposición de colores RGBA y su frecuencia de aparición. Ordenamos por frecuencia descendiente y hacemos doble clic sobre la fila para abrir la imagen resultante.
A continuación un resumen de las imágenes obtenidas.
Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.
dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe
A partir de aquí el reto pasa a ser de encriptación. Con el tiempo diferenciareis fácilmente el tipo de cifrado con sólo ver el texto. En este caso lo primero que se nos ocurre es comprobar dos cifrados clásicos como son el cifrado César y el Vigenere.
Tras desestimar el cifrado César realizamos un ataque de «fuerza bruta» al cifrado Vigenere mediante análisis estadístico. En la imagen que muestro a continuación se puede ver que la clave está cerca de ser «HPHQTC» pero todavía no se lee correctamente.
Ya que la fuerza bruta de por sí no termina de darnos la respuesta correcta, pasamos a probar algo muy útil, esto es, descifrar por fuerza bruta pero dándole una palabra para comparar. En este caso en concreto vemos que una posible palabra que pudiera estar en el texto encriptado es «PASSWORD», probamos y reto terminado.
Este 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.
Hoy tenemos un crackme realizado en ensamblador y sin empacar. Consiste en el típico serial asociado a un nombre sin mucha complicación excepto en lo que a la utilización de memoria se refiere. Como veremos más adelante si no tenemos cuidado se solapan en memoria el nombre y el serial y como siempre evitaremos eso.
Abrimos el crackme con Olly y buscamos las string references, pinchamos sobre cualquiera y encima encontramos el código que no interesa.
Subimos hasta las funciones que recojen el nombre y serial (GetDlgItemTexA) y nos fijamos que guarda el nombre a partir de la dirección de memoria 403014 y el serial a partir de 40301A. Además el nombre debe tener por lo menos tres caracteres.
El algoritmo consiste en lo siguiente, recorre el nombre y comprueba si el dígito se corresponde con 5A(Z), 7A(z) y 39(9). Si coincide los deja como está y si no les suma 1 al valor ascii. A continuación concatena después de cada conversión de dígito el caracter 61(a) aumentándole en 1 para cada nuevo dígito del nombre.
Ejemplo:
Nombre: ZZZZZ Serial: ZaZbZcZdZe Nombre: zzzzz Serial: zazbzczdze Nombre: 99999 Serial: 9a9b9c9d9e
Como veréis a continuación, para el nombre «deuru» el serial correcto sería «eafbvcsdve«. Simplemente a los caracteres del nombre les suma 1, d es e, e es f, u es v, etc, y los concatena con digito+a+digito+b+digito+c…
Nombre: deuru Serial: eafbvcsdve Bucle se repite tantos veces como dígitos tenga el nombre d e u r u 64 65 75 72 75 e a f b v c s d v e 65 61 66 62 76 63 73 64 76 65 DUMP ---- 00403010 00 00 00 00 64 65 75 72 75 00 65 61 66 62 76 63 ....deuru.eafbvc 00403020 73 64 76 65 00 05 00 00 00 00 00 00 00 00 00 00 sdve...........
El problema viene cuando elegimos un nombre >5 caracteres, ya que, éste se solapa con la memoria del serial (recordemos 40301A y siguientes) haciendo que sea una chapuza. En la siguiente imagen queda claro. No se si es un error o es intencionado, pero nos conviene no utilizar nombres mayores de 5 dígitos para que nuestro keygen sea lo más limpio posible.
Está realizado en C++ y como véis el nombre debe tener entre 3 y 5 dígitos para que todo vaya bien.
char Nombre[10];
GetWindowText(hwndEdit1, Nombre, 10);
SetWindowText(hwndEdit2, "");
string serial = "";
int len = strlen(Nombre);
char consecutivo[5] = {'a','b','c','d','e'};
if (len <=5 && len >=3){
for(int i = 0; i <= len; i++)
{
if (Nombre[i] == 0x5A || Nombre[i] == 0x7A || Nombre[i] == 0x39)
{
serial+=Nombre[i];
serial+=consecutivo[i];
}else{
serial+=Nombre[i]+1;
serial+=consecutivo[i];
}
}
serial = serial.substr(0, len*2);
LPCTSTR Sfinal = serial.c_str();
SetWindowText(hwndEdit2, Sfinal);
}else{
MessageBox(NULL,"Nombre demasiado largo/corto","Info",MB_OK | MB_ICONINFORMATION);
}
Se nos proporciona la imagen anterior y se nos invita a resolver la ecuación para el menor entero positivo que representa cada fruta. La solución del reto es concatenar «Flag-» a la suma de los valores de las tres frutas.
El enunciado es breve pero ya nos adelanta que existen varias soluciones y que además sólo quieren los números más pequeños que podamos encontrar.
Las frutas están muy bien y son muy sanas pero a nosotros se nos hace más sencillo plantear la ecuación con letras.
\begin{align}
& \frac{x}{y+z}+\frac{y}{x+z}+\frac{z}{x+y}=4\\
\end{align}Para arrojar algo de luz veamos la representación gráfica en 2D y 3D con la ayuda de Desmos.
Las gráficas más que luz nos traen oscuridad de modo que preguntemos a ChatGPT.
resuelve: (x/y+z)+(y/x+z)+(z/x+y)=4 para enteros positivos
Dado que las variables x, y, z son enteros positivos, podemos intentar encontrar una solución para la ecuación bajo estas condiciones. Sin embargo, encontrar una solución exacta puede ser complejo debido a la naturaleza no lineal de la ecuación. Aun así, podemos intentar algunos enfoques:
Voy a realizar un análisis numérico con un rango limitado de valores para ver si encontramos alguna solución que cumpla con las condiciones. Vamos a probar con valores de 1 a 10 para cada variable.
El análisis numérico para valores de en el rango de 1 a 10 no ha encontrado ninguna solución que satisfaga la ecuación. Esto sugiere que, dentro de este rango, no existen combinaciones de enteros positivos que cumplan con la ecuación.
Dado que la ecuación es bastante compleja y no lineal, es posible que las soluciones, si existen, se encuentren fuera del rango considerado o que requieran un enfoque diferente para ser identificadas. Si tienes un rango específico de valores en mente o si hay alguna otra restricción o contexto relevante, por favor házmelo saber para poder ajustar el análisis en consecuencia.
Básicamente nos está invitando a utilizar prueba y error para encontrar una solución, y el prueba y error de las matemáticas no es más que la fuerza bruta en programación.
Partiendo del problema anterior dame un código en python que realice una comprobación recursiva de todas las variables con un rango de 1 a 999.
soluciones = []
rango_valores_x = range(1, 999)
rango_valores_y = range(1, 999)
rango_valores_z = range(1, 999)
for x in rango_valores_x:
for y in rango_valores_y:
for z in rango_valores_z:
# Calculamos el valor de la expresión para cada combinación de x, y, z
valor = x / (y + z) + y / (x + z) + z / (x + y)
# Comprobamos si el valor es igual a 4 y agregamos la solución a la lista
if abs(valor - 4) < 1e-6: # Usamos una pequeña tolerancia para evitar errores de precisión
soluciones.append((x, y, z))
print(soluciones)Dejo resaltada la línea 12 del código ya que en ella reside el problema. Está comprobando con un margen de tolerancia de 10-6 ya que el resultado de las diferentes fracciones no da como resultado exacto 4. Esto es un problema ya que nosotros necesitamos que de exactamente 4 para validar los valores enteros de x, y y z. Pongo un ejemplo para el que se haya perdido con una solución válida para la tolerancia 10-6 siendo x=2, y=264 y z=993.
\begin{align}
& \frac{2}{264+993}+\frac{264}{2+993}+\frac{993}{2+264}=4.000000429\\
\end{align}En otras palabras, ChatGPT nos ha brindado una solución aproximada que no sirve para nuestro propósito. Seguimos probando con el código anterior quitando la tolerancia y con rangos mayores hasta que en 106 paro. Me acaba de quedar claro que con la fuerza bruta no vamos a ninguna parte, o más bien, no tenemos capacidad de computación para resolverlo de ésta manera.
Lo que pasa es que estamos ante una ecuación algebraica de 3 incógnitas que deben ser enteros positivos cuya solución se alcanza mediante la teoría de curvas elípticas.
Las curvas elípticas son fundamentales en matemáticas avanzadas, representadas por la ecuación y2=x3+Ax+B, donde A y B son constantes. Estas curvas son un punto de encuentro entre la geometría, la teoría de números y el álgebra, ofreciendo un campo rico para la exploración y el análisis. En este CTF, nos enfocaremos en los puntos racionales de las curvas elípticas. Utilizando el método tangente-secante, un procedimiento geométrico iterativo, buscaremos ampliar un conjunto finito de soluciones conocidas a la ecuación de la curva. Este método nos permite indagar en la estructura de las soluciones racionales, que potencialmente pueden ser infinitas. Además, estableceremos una conexión entre las soluciones enteras de las ecuaciones diofánticas y los puntos racionales en las curvas elípticas partiendo de la ecuación (1) especificada en el análisis inicial. A pesar de su aparente simplicidad, esta ecuación es conocida por presentar soluciones mínimas de gran tamaño.
Antes de nada, necesitamos saber el grado de la ecuación, de modo que planteamos la ecuación en forma polinómica estándar deshaciéndonos de los denominadores.
\begin{align}
\begin{split}
n(a+b)(b+c)(c+a)=a(a+b)(c+a)+b(b+c)(a+b)+c(c+a)(b+c)
\end{split}
\end{align}Ahora necesitamos expandir y simplificar para llegar a la conclusión de que estamos ante una ecuación diofántica de grado 3. Este proceso es engorroso por la cantidad de términos a manejar así que vamos a utilizar Mathematica como software de respaldo para finalmente obtener el polinomio en la forma de Weierstrass según la ecuación 4.
\begin{align}
& y^2=x^3+109x^2+224x\\
\end{align}donde:
\begin{align}
x = \frac{−28(a+b+2c)}{(6a+6b−c)}\\
y = \frac{364(a−b)}{(6a+6b−c)}
\end{align}Las relación entre la ecuación 3 y los puntos de la curva elíptica se establecen mediante la ecuación 4. Las transformaciones entre las soluciones (a, b, c) y los puntos (x, y) en la curva elíptica vienen dados por las ecuaciones 5 y 6. Con estas transformaciones, cada solución de la ecuación diofántica se puede representar como un punto en la curva elíptica, y las operaciones de suma de puntos en la curva elíptica pueden usarse para encontrar nuevas soluciones de la ecuación diofántica.
El código que tenéis a continuación pertenece al gran trabajo de Aditi Kulkarni [7], que además nos da el resultado para cualquier valor de n. Ojo porque para n=4 el resultado tiene 81 dígitos, para n=6 tiene 134, para n=10 tiene 190 y para n=12 asciende a 2707 dígitos.
(* Asignar un valor numérico a n *)
n = 4;
(* Definir la ecuación de una curva elíptica en términos de n *)
curve4 = y^2 == x^3 + (4*n^2 + 12*n - 3)*x^2 + 32*(n + 3)*x;
(* Encontrar un punto racional en la curva que no sea (4,0) *)
P4 = {x, y} /. First[FindInstance[curve4 && x != 4 && y != 0, {x, y}, Integers]];
(* Función para calcular la pendiente entre dos puntos en la curva,
o la derivada en el punto si son iguales *)
Slope4[{x1_, y1_}, {x2_, y2_}] :=
If[x1 == x2 && y1 == y2,
ImplicitD[curve4, y, x] /. {x -> x1, y -> y1},
(y2 - y1)/(x2 - x1)];
(* Función para calcular la intersección en y de la línea entre dos puntos
o la tangente en el punto si son iguales *)
Intercept4[{x1_, y1_}, {x2_, y2_}] := y1 - Slope4[{x1, y1}, {x2, y2}]*x1;
(* Función para encontrar el siguiente punto racional en la curva *)
nextRational4[{x1_, y1_}, {x2_, y2_}] :=
{Slope4[{x1, y1}, {x2, y2}]^2 - CoefficientList[curve4[[2]], x][[3]] - x1 - x2,
-Slope4[{x1, y1}, {x2, y2}]^3 + Slope4[{x1, y1}, {x2, y2}]*(CoefficientList[curve4[[2]], x][[3]] + x1 + x2) - Intercept4[{x1, y1}, {x2, y2}]};
(* Función para convertir un punto en la curva elíptica a una solución diofántica *)
ellipticToDiophantine[n_, {x_, y_}] :=
{(8*(n + 3) - x + y)/(2*(4 - x)*(n + 3)),
(8*(n + 3) - x - y)/(2*(4 - x)*(n + 3)),
(-4*(n + 3) - (n + 2)*x)/((4 - x)*(n + 3))};
(* Usar nextRational4 para iterar desde P4 hasta encontrar una solución
válida y positiva para la ecuación diofántica *)
sol4 = ellipticToDiophantine[n,
NestWhile[nextRational4[#, P4] &, P4,
! AllTrue[ellipticToDiophantine[n, #], Function[item, item > 0]] &]];
(* Escalar la solución para obtener enteros mínimos *)
MinSol4 = sol4*(LCM @@ Denominator[sol4])
(* Suma de las tres variables*)
Total[MinSol4]
Concatenando Flag- con el resultado de Mathematica tenemos la ansiada flag.
Flag-195725546580804863527010379187516702463973843196699016314931210363268850137105614
ChatGPT ha demostrado ser eficaz en el análisis y la resolución de problemas, siempre que se le proporcione el contexto adecuado. Sin embargo, es importante ser conscientes de que la respuesta proporcionada puede ser aproximada, especialmente si la solución requiere una gran cantidad de recursos computacionales. Por ejemplo, al trabajar con una ecuación diofántica y valores específicos para (x) e (y), ChatGPT puede ayudar a calcular puntos como (P), (2P), (3P), etc., pero hay que tener en cuenta que los resultados para estos puntos pueden ser estimaciones.
Finalmente, os invito a leer la solución de Mingliang Z. [4], en la que se resuelve el problema por completo y de forma muy detallada.
Hoy analizamos Copycat, un thriller psicológico de 1995 que, como muchas películas de la época, no pudo resistirse a incorporar elementos tecnológicos que, vistos desde una perspectiva actual, nos sacan una sonrisa. Vamos a desmontar algunos gazapos tecnológicos y curiosidades relacionadas con los sistemas informáticos que aparecen en la película.
La protagonista, la Dra. Helen Hudson (Sigourney Weaver), trabaja en un escritorio con tres pantallas, algo futurista para la época. En 1995, esto no era tan común como hoy en día. Para lograrlo, probablemente necesitaría tres ordenadores conectados de forma independiente, ya que los sistemas operativos y hardware de la época no solían soportar múltiples monitores en una sola máquina. Esto plantea preguntas interesantes sobre la logística de su set-up: ¿Cómo sincronizaba su trabajo entre tres PCs?
Un detalle curioso es que, en algunas tomas, se distingue la marca Compaq en los equipos. Compaq era una de las compañías líderes en la fabricación de ordenadores personales durante los 90 y conocida por sus soluciones de alta calidad. Este dato refuerza la idea de que el set-up de Helen estaba diseñado para representar lo último en tecnología de la época, aunque hoy resulte un tanto rudimentario. La elección de Compaq no es casual: en ese momento, era sinónimo de equipos potentes, usados tanto en oficinas como en entornos domésticos avanzados.
En una escena, Helen navega por internet con lo que suponemos es un módem de 28.8 kbps (o como mucho, un flamante 33.6 kbps, tecnología de vanguardia allá por 1995). Hasta ahí, vale. Sin embargo, la fluidez de su conexión sorprende: carga archivos, recibe correos y no se queda esperando con una pantalla de “Conectando…”. Pero lo mejor llega cuando, estando conectada, ¡suena el teléfono! En la realidad, esto cortaría la conexión o comunicaría, a menos que tuviera dos líneas telefónicas (algo raro en domicilios particulares de la época) o algún dispositivo milagroso que no conocemos.
Aunque no se distingue claramente el sistema operativo, vemos una interfaz gráfica con ventanas y una consola de comandos. Esto podría ser un guiño a Windows 3.1 o Windows 3.11, ya maduro en esa época aunque la interfaz no termina de encajar. Sin embargo, también podría ser una mezcla ficticia para hacer que el entorno luciera “tecnológico” sin comprometerse demasiado con la realidad. Detalle curioso: en los 90, las películas solían personalizar las interfaces para no tener problemas legales.
En los 90, el email era el rey. En las películas, los escritorios siempre tenían un gran icono de correo (a menudo animado, porque lo cool siempre parpadeaba). En Copycat, Helen recibe un correo con un archivo AVI de unos 30 segundos, lo cual plantea otra duda técnica: ¿Cuánto espacio ocupaba ese archivo en 1995?
Un AVI de 30 segundos probablemente tendría una resolución baja (320×240 píxeles o menos) y una tasa de compresión eficiente para la época, pero aun así podría pesar entre 2 y 5 MB, dependiendo de la calidad del audio y vídeo. Eso hubiera supuesto una odisea por email, ya que los servidores de la época limitaban los adjuntos a unos pocos cientos de KB. ¿Quizás el villano usó un protocolo privado para saltarse las restricciones?
Tras recibir un inquietante archivo AVI, la protagonista llama a la policía, lo que desencadena una conversación cargada de decisiones tecnológicas cuestionables:
Copycat (1995) es un buen ejemplo de cómo el cine de los 90 abordaba la tecnología con una mezcla de admiración y confusión. Desde la exageración de tener tres monitores en el escritorio de Helen hasta la torpe gestión del archivo Tomorrow.AVI, la película refleja tanto las limitaciones tecnológicas de la época como las libertades creativas de los guionistas.
En el caso del archivo AVI, los personajes deciden que no se puede gestionar digitalmente y optan por convertirlo a vídeo analógico, ignorando soluciones más simples como volver a enviarlo por correo electrónico (suponiendo que fuera posible). Este detalle, combinado con la ausencia aparente de personal técnico en la policía, subraya una desconexión entre la narrativa y las capacidades reales de la tecnología, incluso para 1995.
Aunque estos detalles pueden parecer cómicos 30 años después, forman parte del encanto de un cine que imaginaba el futuro sin comprender del todo su presente. Más que errores, son un recordatorio de cómo la tecnología ha evolucionado y de cómo nuestra percepción de ella también lo ha hecho.
Un día cualquiera se te ocurre comprarte un disco duro de red NAS para centralizar todo tu contenido multimedia. Lo conectas y todo va genial, pero de repente vas a copiar unos cuantos gigas de fotos y te encuentras con que la operación va a tardar días. En ese mismo instante te planteas sacar el máximo provecho a tu red doméstica y la solución se llama gigabit.
Esta guía va dirigida a todo el mundo que esté pensando en hacer o mejorar la red LAN doméstica. Si eres un amante del WIFI, olvídate de esto, ya que para conseguir altas velocidades se necesita cablear la casa. Además, de lo que trata esta guía es de que se conecte un ordenador portátil o sobremesa de la forma más rápida posible al disco duro de red.
Probablemente dispongas de un Modem / Router proporcionado por tu compañia y que seguramente no sea gigabit (10/100/1000), esto es lo primero que debes comprobar. Busca tu modelo en internet y cerciorate.
También necesitas que la tarjeta de red del portátil o sobremesa sean gigabit, en este caso lo más probable es que lo sean pero asegúrate.
Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.
Si el nuestro no es gigabit existen soluciones económicas como el TP-Link TL-WR1043ND que lo tenemos por 44€ en pccomponentes. Os recomiendo esta tienda por rapidez, seriedad y no abusan con los gastos de envío.
En caso de que los cuatro puertos que vienen con el router se nos queden cortos, la solución más economica y acertada es un Switch ethernet gigabit como el TP-LINK TL-SG1005D que lo tenemos por 16€. Este dispositivo es una maravilla ya que nos brinda 4 puertos más y no requiere configuración alguna.
Son muy económicas, las puedes encontrar por 10€-15€ en cualquier tienda especializada. Ejemplo PCI. Ejemplo PCI-e. Video instalación de una tarjeta de red.
100m de cable UTP categoría 6 viene a costar sobre unos 42€.
Para interconexionado de equipos recomiento estos de 50cm por 1,5€. Para conexión del pc tienes otras larguras más apropiadas. También podéis haceros vosotros los cables con lo sobrante de la bobina, para ello necesitaréis una crimpadora y terminales rj45.
Esto depende de tu instalación y la gama que elijas. En mi caso utilizo tomas Niessen que solo el conector vale 16€, pero tienes tomas más económicas. De superficie por 2,75€ y empotrable por 8,25€.
Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.
Esto es una recomendación personal ya que la elección puede variar en función de las necesidades de almacenamiento y conexiones. Una solución barata y con espacio suficiente para uso doméstico es el disco WD My Cloud 3TB que lo podeis adquirir por 159€.
Esto puede variar en función de los componentes que elijas comprar pero el coste oscilará entre 250 y 350€, algo bastante asequible para centralizar contenido multimedia. Digo asequible por que la mitad del presupuesto se lo lleva el disco de red, los componentes son más bien baratos.
En mi esquema disponemos del router proporcionado por el proveedor de internet que en mi caso sí es gigabit pero que solo lo utilizo para dar internet al router neutro.El router neutro junto con el switch me proporcionan 8 puertos gigabit. El router neutro además gestiona el wifi de la casa, pero en el mejor de los casos (Wifi n) estos dispositivos solo podrán mover datos a 300mbps. Utilizo como media center mis amadas Raspberry Pi que en este caso no se benefician de la velocidad ya que disponen de conexión 10/100.
Lo primero a conectar es el router neutro y en este caso, TP-Link te lo pone fácil si no te defiendes muy bien con las redes, ya que proporciona un CD que se encarga de guiarte paso a paso. Lo más importante es la asignación de la IP privada, por defecto es 192.168.2.1 y a no ser que el router de la compañia tenga esa misma IP lo podéis dejar como está.
Para configurar el disco de red normalmente viene un CD para ayudar al usuario novel. Lo único que tenéis que tener en cuenta es que la IP debe estar en consonancia con la del router neutro, si el router neutro es 192.168.2.1 al disco NAS podéis asignarle 192.168.2.150. Para más información aquí tenéis la guía de instalación.
Podéis usar cable normal, también llamado conexión Pin a Pin ó 1:1, para toda la instalación ya que los dispositivos de hoy en día aceptan cualquier cable y resuelven internamente en función del cable conectado. Pero si nos ponemos quisquillosos, para conectar elementos pasivos entre sí (router a switch, etc) se utiliza cable normal 1:1. Para conectar elementos activos (PC a router/switch) cable cruzado.
Mi consejo es que uses el standard EIA/TIA 568B tanto en la conexión de las cajas como en la creación de los cables.
Cada roseta o toma en su interior tiene definido el orden que debes seguir para conectar los cables según el standard A o B, esto es una aproximación y puede no coincidir con tu toma.
Si estás seguro de que las rosetas están bien conectadas, que has usado los cables correctos, que todos los dispositivos son gigabit y tu pc hace de las suyas, quizás debas de forzar a tu tarjeta de red a trabajar en modo gigabit ó 100 full duplex ó 100FD. Esto es debido a que el driver de la tarjeta de red por defecto viene con la opción de «autonegociación» activada y a veces necesita que le «obligues» a trabajar en gigabit.
En cada tarjeta de red puede venir diferente, yo os muestro mi caso desde windows 7:
Diríjete a Inicio > Panel de control > Ver el estado y las tareas de red > conexión de area local
En mi caso marca 1 Gbps pero si estais teniendo problemas os marcará 100 mbps. A continuación pulsa Propiedades.
Pulsa Configurar.
En la pestaña Opciones avanzadas busca la opción de la velocidad, en mi caso «Speed/duplex settings» y selecciona 100 mb Full Duplex. De este modo le forzais a la tarjeta de red a trabajar en modo gigabit. Si no lo consiguiera trabajará en el modo que pueda pero no os dejará sin conexión.
Soy consciente de que me he dejado muchas cosas en el tintero pero mi pretensión es que el lector de un vistazo rápido tenga una idea clara de lo que necesita para lograr una red decente en casa.
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:
(5 * (char - 97) + 8) % 26 + 97.(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)