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
We require your services once again. An employee from our company had recently been identified as a known criminal named Brett Thwaits. He is considered to have stolen missile launch codes from the US navy which unfortunately were handed to us for a brief period of time. As of now, we are accussed of the theft and unless we do something about it, we’re gonna end in some serious trouble. Before Brett left, he formatted the thumbdrive which used to store the launch codes. Fortunately, our system had made a backup image of the drive. See if you can recover the fourth launch code. Good luck!
Requerimos una vez más sus servicios. Un empleado de nuestra empresa había sido identificado recientemente como el conocido criminal Brett Thwaites. Se considera que ha robado los códigos de lanzamiento de misiles de la Armada de Estados Unidos, que por desgracia fueron entregados a nosotros por un breve período de tiempo. A partir de ahora, se nos acusa del robo y a menos que hagamos algo al respecto, vamos a tener serios problemas. Antes de que Brett se fuera formateó el dispositivo que se usa para almacenar los códigos de lanzamiento. Afortunadamente, nuestro sistema había hecho una copia de seguridad de la unidad. Mira a ver si puedes recuperar los cuatro códigos de lanzamiento. ¡Buena suerte!
Echamos un vistazo al archivo con un editor hexadecimal y vemos encabezados de tipos de archivos conocidos, por lo que la unidad no está encriptada. Al no estar encriptada la imagen, usaremos una herramienta de creación propia, Ancillary. En esta ocasión usaremos la versión 2 alpha, que actualmente está en desarrollo, pero podéis usar tranquilamente la versión 1.x.
Ancillary nos muestra lo que ha encontrado en el archivo por lo que pasamos a analizarlo.
Como siempre os digo en este tipo de retos, es difícil discriminar unos ficheros en favor de otros, ya que no sabemos si lo que buscamos va a estar en una imagen, documento u otro tipo de fichero codificado o no.
Tras analizar todos los ficheros, rápidamente suscitan nuestro interés los ficheros RAR, y más cuando el fichero que contienen es un fichero de audio y su nombre es tan sugerente como «conversation_dtmf.wav«. Como podéis apreciar en la imagen, el fichero RAR está protegido con clave por lo que necesitamos esquivar ese obstaculo.
En este caso el software que voy a utilizar es cRARk, pero podéis utilizar cualquier otro. Como se muestra en la imagen de abajo, mi procesador es más bien modesto pero la clave no tiene más que tres dígitos por lo que no supone ninguna dificultad recuperarla.
Una vez recuperado el archivo WAV, al reproducirlo escuchamos 16 tonos telefónicos que inmediatamente me recuerdan las aventuras del mítico «Capitán Crunch«. Os animo a leer la historia de John Draper y su famosa «Blue Box» ya que no tiene desperdicio y forma parte de la historia del Phreaking.
Por si no conocías la historia, el propio nombre del fichero wav nos da la pista clave de qué buscar al contener las siglas «DTMF«.
Al ser pulsada en el teléfono la tecla correspondiente al dígito que quiere marcar, se envían dos tonos, de distinta frecuencia: uno por columna y otro por fila en la que esté la tecla, que la central decodifica a través de filtros especiales, detectando qué dígito se marcó.
No tenemos más que buscar un decodificador de tonos para obtener los preciados códigos de lanzamiento.
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);
}
En este reto se nos entrega un archivo WAV de 9,92 MB. Tras escucharlo y analizarlo por encima con Audacity no llego a ningún lado por lo que me tiro al descarte de herramientas conocidas, y en ésta ocasión sale a escena DeepSound.
Sin más dilación extraemos el JPG y continuamos.
La aparición en escena de DeepSound me hace sospechar sobre el uso de herramientas conocidas y ¡bingo!, sale a escena StegHide. En esta ocasión el autor del reto nos lo ha puesto fácil y la extracción no requiere clave.
Al abrir el archivo TXT como texto vemos lo siguiente:
y si lo abrimos con un editor hexadecimal vemos esto otro:
Claramente el archivo esconde algo que por la repetición de los caracteres me hace sospechar de un simple XOR y efectivamente la flag está XOReada. Tras un ataque preliminar, digamos que los árboles no me dejaban ver el bosque, de modo que limpié los bytes correspondientes a la frase «this is the flag :)» y procesé de nuevo obteniendo por fin la ansiada flag.
RAW bytes
FF FE 74 00 68 00 69 00 73 00 20 00 40 DB 53 DC 40 DB 48 DC 40 DB 53 DC 40 DB 7B DC 40 DB 74 DC 69 00 73 00 20 00 40 DB 30 DC 40 DB 30 DC 40 DB 5F DC 40 DB 33 DC 40 DB 34 DC 74 00 68 00 65 00 20 00 40 DB 73 DC 40 DB 79 DC 40 DB 5F DC 40 DB 6D DC 40 DB 34 DC 66 00 6C 00 61 00 67 00 20 00 40 DB 6E DC 40 DB 7D DC 40 DB 20 DC 3A 00 29 00
Cleaned bytes [quitando this is the flag :)]
FF FE 40 DB 53 DC 40 DB 48 DC 40 DB 53 DC 40 DB 7B DC 40 DB 74 DC 40 DB 30 DC 40 DB 30 DC 40 DB 5F DC 40 DB 33 DC 40 DB 34 DC 40 DB 73 DC 40 DB 79 DC 40 DB 5F DC 40 DB 6D DC 40 DB 34 DC 40 DB 6E DC 40 DB 7D DC 40 DB 20 DC
clave XOR == 00fc60fb
Resultado
S H S { t 0 0 _ 3 4 s y _ m 4 n }
Hoy tenemos aquí otro crackme sacado del baúl de los recuerdos. En este caso se trata de una protección por tiempo límite a través de un keyfile llamado «data.det«. Disponemos de tres días o nueve sesiones antes de que el crackme expire.
La primera vez que ejecutamos el crackme, crea el fichero «data.det» y realiza lo siguiente:
00401000 t>/$ 6A 00 PUSH 0 ; /pModule = NULL 00401002 |. E8 0B020000 CALL <JMP.&KERNEL32.GetModuleHandleA> ; \GetModuleHandleA 00401007 |. A3 F4304000 MOV DWORD PTR DS:[4030F4],EAX ; kernel32.BaseThreadInitThunk 0040100C |. 6A 00 PUSH 0 ; /hTemplateFile = NULL 0040100E |. 68 80000000 PUSH 80 ; |Attributes = NORMAL 00401013 |. 6A 03 PUSH 3 ; |Mode = OPEN_EXISTING 00401015 |. 6A 00 PUSH 0 ; |pSecurity = NULL 00401017 |. 6A 00 PUSH 0 ; |ShareMode = 0 00401019 |. 68 000000C0 PUSH C0000000 ; |Access = GENERIC_READ|GENERIC_WRITE 0040101E |. 68 A2304000 PUSH timetria.004030A2 ; |FileName = "DATA.DET" 00401023 |. E8 DE010000 CALL <JMP.&KERNEL32.CreateFileA> ; \CreateFileA 00401028 |. 83F8 FF CMP EAX,-1 0040102B |. 74 07 JE SHORT timetria.00401034 0040102D |. A3 14314000 MOV DWORD PTR DS:[403114],EAX ; kernel32.BaseThreadInitThunk 00401032 |. EB 18 JMP SHORT timetria.0040104C 00401034 |> 6A 30 PUSH 30 ; /Style = MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL 00401036 |. 68 38304000 PUSH timetria.00403038 ; |Title = "I don't like this !" 0040103B |. 68 02304000 PUSH timetria.00403002 ; |Text = "Where is my DATA.DET file?\r\nI can't run without it..." 00401040 |. 6A 00 PUSH 0 ; |hOwner = NULL 00401042 |. E8 B3010000 CALL <JMP.&USER32.MessageBoxA> ; \MessageBoxA 00401047 |. E9 22010000 JMP timetria.0040116E 0040104C |> 6A 00 PUSH 0 ; /pOverlapped = NULL 0040104E |. 68 E0304000 PUSH timetria.004030E0 ; |pBytesRead = timetria.004030E0 00401053 |. 6A 32 PUSH 32 ; |BytesToRead = 32 (50.) 00401055 |. 68 AB304000 PUSH timetria.004030AB ; |Buffer = timetria.004030AB 0040105A |. FF35 14314000 PUSH DWORD PTR DS:[403114] ; |hFile = NULL 00401060 |. E8 B9010000 CALL <JMP.&KERNEL32.ReadFile> ; \ReadFile 00401065 |. 833D E0304000 0B CMP DWORD PTR DS:[4030E0],0B 0040106C |. 0F85 E9000000 JNZ timetria.0040115B 00401072 |. BB AB304000 MOV EBX,timetria.004030AB 00401077 |. 68 E4304000 PUSH timetria.004030E4 ; /pSystemTime = timetria.004030E4 0040107C |. E8 97010000 CALL <JMP.&KERNEL32.GetSystemTime> ; \GetSystemTime 00401081 |. 803B 00 CMP BYTE PTR DS:[EBX],0 00401084 |. 75 22 JNZ SHORT timetria.004010A8 ; Si existe el fichero salta a las comprobaciones 00401086 |. 51 PUSH ECX 00401087 |. 33C9 XOR ECX,ECX 00401089 |. EB 15 JMP SHORT timetria.004010A0 0040108B |> 66:8B81 E4304000 /MOV AX,WORD PTR DS:[ECX+4030E4] ; | 00401092 |. 66:35 6969 |XOR AX,6969 ; | 00401096 |. 66:8981 AB304000 |MOV WORD PTR DS:[ECX+4030AB],AX ; | 0040109D |. 83C1 02 |ADD ECX,2 ; | Bucle de codificacion de data.det por primera vez 004010A0 |> 83F9 08 CMP ECX,8 ; | 004010A3 |.^ 76 E6 \JBE SHORT timetria.0040108B ; | 004010A5 |. 59 POP ECX ; kernel32.7580EE1C 004010A6 |. EB 3A JMP SHORT timetria.004010E2
Vigilando el proceso de creación del archivo podemos llegar a la conclusión de como se genera.
Estado de la memoria:
004030AB B7 6E 63 69 6D 69 6B 69 68 69 60 ·ncimikihi`
004010E2 |> \A0 B5304000 MOV AL,BYTE PTR DS:[4030B5] 004010E7 |. 34 69 XOR AL,69 004010E9 |. 3C 00 CMP AL,0 004010EB |. /74 59 JE SHORT timetria.00401146 004010ED |. |FEC8 DEC AL 004010EF |. |A2 01304000 MOV BYTE PTR DS:[403001],AL 004010F4 |. |34 69 XOR AL,69 004010F6 |. |A2 B5304000 MOV BYTE PTR DS:[4030B5],AL 004010FB |. |6A 00 PUSH 0 ; /Origin = FILE_BEGIN 004010FD |. |6A 00 PUSH 0 ; |pOffsetHi = NULL 004010FF |. |6A 00 PUSH 0 ; |OffsetLo = 0 00401101 |. |FF35 14314000 PUSH DWORD PTR DS:[403114] ; |hFile = 00000034 (window) 00401107 |. |E8 18010000 CALL <JMP.&KERNEL32.SetFilePointer> ; \SetFilePointer 0040110C |. |6A 00 PUSH 0 ; /pOverlapped = NULL 0040110E |. |68 E0304000 PUSH timetria.004030E0 ; |pBytesWritten = timetria.004030E0 00401113 |. |6A 0B PUSH 0B ; |nBytesToWrite = B (11.) 00401115 |. |68 AB304000 PUSH timetria.004030AB ; |Buffer = timetria.004030AB 0040111A |. |FF35 14314000 PUSH DWORD PTR DS:[403114] ; |hFile = 00000034 (window) 00401120 |. |E8 05010000 CALL <JMP.&KERNEL32.WriteFile> ; \WriteFile
En cada ejecución realiza tres comprobaciones.
Recordemos el contenido del fichero:
B7 6E 63 69 6D 69 6B 69 68 69 60 ·ncimikihi`
1) Mes y año (4 primeros bytes)
004010A8 |> \8B0D AB304000 MOV ECX,DWORD PTR DS:[4030AB] ; ECX=69636EB7 004010AE |. 81F1 69696969 XOR ECX,69696969 ; 69636EB7 xor 69696969 = A07DE (A = mes y 7DE = año) 004010B4 |. A1 E4304000 MOV EAX,DWORD PTR DS:[4030E4] 004010B9 |. 3BC1 CMP EAX,ECX ; Compara con mes y año actuales 004010BB |. 0F85 85000000 JNZ timetria.00401146 ; Bad boy
2) Día (7º y 8º byte)
004010C1 |. 66:8B0D B1304000 MOV CX,WORD PTR DS:[4030B1] ; CX = 696B 004010C8 |. 66:81F1 6969 XOR CX,6969 ; 696B xor 6969 = 2 004010CD |. 66:A1 EA304000 MOV AX,WORD PTR DS:[4030EA] ; AX = día actual obtenido con GetSystemTime 004010D3 |. 66:2BC1 SUB AX,CX ; Los resta 004010D6 |. 66:83F8 03 CMP AX,3 ; Compara con 3 004010DA |. 77 6A JA SHORT timetria.00401146 ; Si el resultado >=3 Bad Boy
3) Sesiones (11º byte)
004010DC |. 2805 00304000 SUB BYTE PTR DS:[403000],AL ; 004010E2 |> A0 B5304000 MOV AL,BYTE PTR DS:[4030B5] ; AL = numero de sesiones actual 004010E7 |. 34 69 XOR AL,69 ; 61 Xor 69 = 8 004010E9 |. 3C 00 CMP AL,0 ; Compara con 0 004010EB |. 74 59 JE SHORT timetria.00401146 ; Salta si hemos superado las 9 sesiones. Bad boy 004010ED |. FEC8 DEC AL ; Si no le resta 1 004010EF |. A2 01304000 MOV BYTE PTR DS:[403001],AL 004010F4 |. 34 69 XOR AL,69 ; y le hace xor 69 para codificar el nuevo valor de sesión 004010F6 |. A2 B5304000 MOV BYTE PTR DS:[4030B5],AL
Con esto ya podemos alterar el archivo a nuestro antojo sin necesidad de parchear.
Try
ano = ano Xor 26985
mes = mes Xor 26985
dia = dia Xor 26985
anos = Hex(ano).ToString
mess = Hex(mes).ToString
dias = Hex(dia).ToString
If txtsesiones.Text <= 255 Then
sesioness = Hex(sesiones)
Else
sesiones = 255
End If
sesioness = Hex(sesiones)
'key = 00 00 00 00 00 00 00 00 00 00 00
'key = año+año+mes+mes+X+X+dia+dia+X+sesiones
key = Chr(Convert.ToInt32(anos.Substring(2, 2), 16)) & Chr(Convert.ToInt32(anos.Substring(0, 2), 16)) _
& Chr(Convert.ToInt32(mess.Substring(2, 2), 16)) & Chr(Convert.ToInt32(mess.Substring(0, 2), 16)) _
& Chr(106) & Chr(105) _
& Chr(Convert.ToInt32(dias.Substring(2, 2), 16)) & Chr(Convert.ToInt32(dias.Substring(0, 2), 16)) _
& Chr(103) & Chr(105) _
& Chr(Convert.ToInt32(sesioness.Substring(0, 2), 16))
'Creo el archivo llave
Dim ruta As String = Application.StartupPath & "\DATA.DET"
If File.Exists(ruta) Then
File.Delete(ruta)
End If
Using sw As StreamWriter = New StreamWriter(ruta, True, System.Text.Encoding.Default)
sw.Write(key)
sw.Close()
End Using
MsgBox("DATA.DET generado correctamente", MsgBoxStyle.Information + MsgBoxStyle.OkOnly, "Info")
Catch ex As Exception
MsgBox("Ocurrió algún error" & vbCrLf & ex.Message)
End Try
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.
This crackme is for the crack challenge 6 of canyouhack.it.
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.
Saludos !!
Karpoff
La serie «Expediente X» (The X-Files) ha capturado la imaginación de los espectadores desde su debut en 1993, con sus intrigantes historias de fenómenos paranormales y conspiraciones gubernamentales. Sin embargo, más allá de los extraterrestres y las criaturas sobrenaturales, la serie también exploró el mundo del hacking, la inteligencia artificial y la piratería informática, temas que se adelantaron a su tiempo y que siguen siendo relevantes hoy en día. A continuación, exploramos algunos de los episodios más emblemáticos que abordan estos temas, revelando detalles fascinantes, curiosidades y tomas falsas que los hicieron memorables.
En este episodio, Mulder y Scully investigan un asesinato en una empresa de tecnología avanzada, Eurisko, donde un sistema de inteligencia artificial llamado «COS» (Central Operating System) podría ser el responsable. La trama se centra en las posibles implicaciones de las IA descontroladas y las vulnerabilidades tecnológicas.
Curiosidades:
Tomas falsas:
Escrito por los renombrados autores de ciencia ficción William Gibson y Tom Maddox, este episodio trata sobre un hacker llamado Donald Gelman que desarrolla una inteligencia artificial avanzada y peligrosa. Mulder y Scully se encuentran en una carrera contra el tiempo para detener a la IA antes de que cause más daño.
Curiosidades:
Tomas falsas:
En este episodio, Mulder y Scully se encuentran atrapados en un videojuego de realidad virtual mientras investigan una serie de asesinatos en una empresa de desarrollo de videojuegos. La trama explora los peligros potenciales de la inmersión tecnológica y los límites entre la realidad y la ficción.
En este episodio, Mulder y Scully se encuentran atrapados en un videojuego de realidad virtual mientras investigan una serie de asesinatos en una empresa de desarrollo de videojuegos. La trama explora los peligros potenciales de la inmersión tecnológica y los límites entre la realidad y la ficción.
Curiosidades:
Tomas falsas:
Este episodio de la temporada más reciente se centra en el impacto de la inteligencia artificial y la tecnología moderna en la vida cotidiana. Mulder y Scully son perseguidos por drones y dispositivos automatizados después de un malentendido en un restaurante automatizado.
Curiosidades:
Tomas falsas:
Cabe mencionar que, en esta ocasión, no he incluido ningún episodio protagonizado por los Pistoleros Solitarios, el trío de hackers y teóricos de la conspiración favoritos de los fans. Este grupo merece un artículo dedicado para explorar en profundidad sus contribuciones únicas a la serie y su propio spin-off, que también aborda numerosos temas tecnológicos y conspirativos con su estilo distintivo.
Estos episodios no solo nos ofrecen emocionantes tramas y misterios tecnológicos, sino que también nos brindan un vistazo a un futuro potencial, uno en el que la línea entre lo humano y lo artificial se vuelve cada vez más difusa. Las curiosidades y tomas falsas detrás de cámaras añaden una capa adicional de encanto, mostrando el esfuerzo y la creatividad necesarios para dar vida a estos complejos temas.
Como fanáticos de «Expediente X», podemos apreciar cómo la serie ha sido capaz de mantenerse relevante y cautivadora al abordar cuestiones tecnológicas que son tanto atemporales como urgentes. Nos ha llevado a cuestionar nuestra confianza en las máquinas, a temer las posibles repercusiones de una inteligencia artificial sin control y a maravillarnos con las posibilidades de la realidad virtual.
En resumen, «Expediente X» no solo ha sido un pionero en la televisión de ciencia ficción y misterio, sino que también ha demostrado una notable capacidad para explorar y anticipar los dilemas tecnológicos que enfrentamos hoy en día. Estos episodios son un recordatorio de que, en el vasto universo de lo desconocido, la tecnología juega un papel crucial y, a veces, aterrador. Para los verdaderos fans, cada uno de estos episodios es una joya que merece ser revivida y analizada, apreciando su profundidad y relevancia en nuestro mundo cada vez más digital.
Todas las imágenes de esta entrada han sido generadas con ChatGPT.
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 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.
Ejemplo:
deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0
Veamos que hace con el serial introducido.
Convierte nuestro serial a hexadecimal y le hace XOR 0x1234.
Ejemplo:
Serial = 12345 –> 0x3039 XOR 0x1234 = 0x220D
Una vez que tenemos el SUMNombre y el SUMSerial los compara. Lo vemos en CMP EAX, EBX.
En resumen, si a nuestro SUMNombre le hacemos XOR 0x5678 y XOR 0x1234 ya tenemos el serial bueno.
Ejemplo:
deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0 XOR 0x1234 = 0x4594
0x4594 = 17812
char Nombre[20];
GetWindowText(hwndEdit1, Nombre, 20);
char Serial[20];
int len = strlen(Nombre);
int suma = 0;
boolean error = false;
for(int i = 0; i <= len; i = i + 1)
{
suma += toupper(Nombre[i]);
}
suma = suma^0x444C; //444C == 5678 xor 1234
wsprintf(Serial,"%d",suma);
SetWindowText(hwndEdit2, TEXT(Serial));
Aquí os dejo un video tutorial. El crackme lo podeis encontrar en crackmes.de.
Enemigo público (Enemy of the State) es una película de acción y suspense dirigida por Tony Scott, estrenada en 1998. La historia sigue a Robert Clayton Dean (Will Smith), un abogado de Washington D.C. que se ve atrapado en una conspiración de vigilancia masiva cuando recibe, sin saberlo, una cinta de video que documenta el asesinato de un congresista a manos de un alto funcionario de la Agencia de Seguridad Nacional (NSA), interpretado por Jon Voight. La situación se complica cuando la NSA utiliza toda su tecnología de espionaje para seguir y neutralizar a Dean.
Dean encuentra ayuda en Edward «Brill» Lyle (Gene Hackman), un exanalista de la NSA convertido en un experto en vigilancia que vive en el anonimato. Juntos intentan descubrir la verdad y exponer la conspiración, mientras son perseguidos por la propia NSA. Un papel crucial también lo desempeña el personaje de Daniel Zavitz, interpretado por Jason Lee, un joven investigador que graba accidentalmente el asesinato y termina transmitiendo la evidencia a Dean. El elenco incluye además a Lisa Bonet, Regina King, Jack Black, Barry Pepper, y Seth Green.
En Enemigo Público, la tecnología juega un papel crucial no solo en la trama sino también en la ambientación de la película. La precisión y el realismo de los equipos informáticos utilizados contribuyen a la atmósfera de paranoia y vigilancia que define la narrativa.
Jason Lee, en su papel de Daniel Zavitz, utiliza un PC clónico, claramente identificado por el logo de Sun Microsystems en la torre del ordenador. Sin embargo, el sistema operativo que corre en esta máquina es Windows 3.1, una versión que, para 1998, ya estaba obsoleta, habiendo sido lanzada en 1992. Esta elección subraya el hecho de que Zavitz utiliza equipamiento más económico y anticuado, en contraste con la tecnología más avanzada de otros personajes.
Zavitz también utiliza Media Player, un reproductor de video básico integrado en Windows 3.1. Durante la reproducción del archivo de video crucial para la trama, se puede observar que la extensión del archivo es .CAM. Este tipo de archivo podría implicar un video capturado por una cámara, pero también sugiere (por otros fotogramas de la película) que el codec utilizado para comprimir el video podría ser QuickTime, permitiendo una reproducción cruzada entre diferentes sistemas operativos.
Además, Zavitz utiliza un reproductor portátil NEC Turbo Express, un dispositivo de videojuegos portátil de la época. En la película, este dispositivo es empleado de manera innovadora para reproducir y transferir datos, algo poco realista pero que añade dramatismo a la escena. La tarjeta PCMCIA de 200MB que Zavitz utiliza para almacenar el video es otro ejemplo de la tecnología de la época, reflejando la capacidad de almacenamiento portátil antes de la popularización de los dispositivos USB.
Por su parte, Gene Hackman, en su papel de Brill, maneja un sistema considerablemente más avanzado, utilizando Windows 98. Este sistema operativo, lanzado también en 1998, representaba lo más avanzado en términos de compatibilidad y usabilidad en ese momento, lo que refuerza la imagen de Brill como un experto en tecnología con acceso a mejores recursos.
Aunque en la película no se detalla el hardware específico de Brill, el hecho de que use Windows 98, junto con las capacidades de manipulación y decodificación de video que se muestran, sugiere que tiene acceso a tecnología de alta gama para la época. En una escena clave, se observa cómo Brill decodifica el video utilizando una interfaz gráfica llamativa, diseñada claramente para atraer la atención del espectador, más que para reflejar la realidad de la tecnología disponible en ese momento.
La producción de Enemigo Público es destacable por su atención al detalle en lo referente al equipamiento tecnológico de los personajes. El contraste entre el equipo más antiguo y económico utilizado por Daniel Zavitz (Jason Lee) y el sistema más avanzado de Edward Lyle (Gene Hackman) refleja de manera efectiva el trasfondo de los personajes. Zavitz, como investigador freelance, se maneja con recursos limitados, mientras que Lyle, con su pasado en la NSA y mayor poder adquisitivo, tiene acceso a tecnología más avanzada.
Otro detalle interesante es la diferenciación en el equipamiento dentro de la central de la NSA. Mientras los empleados comunes utilizan monitores CRT, que eran estándar en la época, el personaje de Thomas Reynolds (Jon Voight) dispone de una pantalla plana, lo que subraya su estatus superior dentro de la agencia. Estos detalles de producción contribuyen a la autenticidad y la profundidad visual de la película.
Sin embargo, la película no está exenta de licencias creativas que sacrifican el realismo tecnológico en favor del impacto visual. Un ejemplo claro es cuando un técnico de la NSA, a partir de un fotograma de un vídeo de seguridad, rota la imagen en 3D para simular lo que Zavitz podría haber introducido en la bolsa de Dean. Aunque esta secuencia añade dramatismo, carece de una base tecnológica realista.
Del mismo modo, la escena donde Brill decodifica el vídeo utilizando una interfaz visualmente llamativa es un claro ejemplo de cómo la película opta por elementos más glamurosos para captar la atención del espectador, alejándose de la realidad técnica, donde estos procesos serían mucho menos espectaculares y más funcionales. Además se pueden observar las siguientes curiosidades:
En resumen, Enemigo Público logra un equilibrio eficaz entre el realismo tecnológico y las exigencias dramáticas del cine. A pesar de algunas exageraciones en la representación de la tecnología, la atención al detalle en los aspectos técnicos y la diferenciación de equipos según los personajes y sus circunstancias es un testimonio del buen trabajo de producción que hace que la película siga siendo entretenida, incluso más de dos décadas después de su estreno.
Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma más limpia posible.
Abrimos el crackme con Olly y ya a simple vista vemos los mensajes de la Nag y parte del código interesante. Si necesitaramos localizar la Nag podemos mirar en las intermodular calls las típicas subrutinas, en este caso se ve claramente a MessageBoxA, bastaría con poner un breakpoint para localizar quien llama.
Aquí vemos la implicación de MessageBoxA.
004010A7 |> \6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 004010A9 |. 68 61304000 PUSH Nag1.00403061 ; |Title = "[NAG] Please register this software!" 004010AE |. 68 86304000 PUSH Nag1.00403086 ; |Text = "[BULLSHIT] Please register this software for support and you'll receive the full version!" 004010B3 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 004010B6 |. E8 49010000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401137 |. 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 00401139 |. 68 6E324000 PUSH Nag1.0040326E ; |Title = "Thank you!" 0040113E |. 68 79324000 PUSH Nag1.00403279 ; |Text = "Thank you for registering this software!" 00401143 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 00401146 |. E8 B9000000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401155 |. 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 00401157 |. 68 E0304000 PUSH Nag1.004030E0 ; |Title = "About" 0040115C |. 68 E6304000 PUSH Nag1.004030E6 ; |Text = "Remove the NAG by TDC\r\n\n..: Coded by\t: TDC\t\t\t:..\t\r\n..: Also known as\t: The Dutch Cracker\t:..\t\r\n..: Protection\t: Custom\t\t\t:..\t\r\n..: Contact info\t: tdc123@gmail.com\t:..\t\r\n..: Release date\t: 09-08-2005\t\t:..\t"... 00401161 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 00401164 |. E8 9B000000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA
Un poco encima vemos la función SetDlgItemTextA, que nos mostrará el mensaje de que hemos parcheado correctamente.
00401106 |> \68 21304000 PUSH Nag1.00403021 ; /Text = "Dirty crack! Nag removed not registered!" 0040110B |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040110D |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401110 |. E8 FB000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA 00401115 |. EB 36 JMP SHORT Nag1.0040114D 00401117 |> 68 10304000 PUSH Nag1.00403010 ; /Text = "Nag not removed!" 0040111C |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040111E |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401121 |. E8 EA000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA 00401126 |. EB 25 JMP SHORT Nag1.0040114D 00401128 |> 68 4A304000 PUSH Nag1.0040304A ; /Text = "Clean crack! Good Job!" 0040112D |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040112F |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401132 |. E8 D9000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA
Encima de SetDlgItemTextA vemos el código que analiza si la Nag tiene que aparecer.
004010E6 |. E8 C4000000 CALL Nag1.004011AF ; ; Llamada interesante a analizar 004010EB |. 803D B0324000 03 CMP BYTE PTR DS:[4032B0],3 004010F2 |. 74 12 JE SHORT Nag1.00401106 ; ; Si de la llamada volvemos con un 3 -> Parcheo chapuza 004010F4 |. 803D B0324000 02 CMP BYTE PTR DS:[4032B0],2 004010FB |. 74 1A JE SHORT Nag1.00401117 ; ; Si de la llamada volvemos con un 2 -> Sin parchear 004010FD |. 803D B0324000 01 CMP BYTE PTR DS:[4032B0],1 00401104 |. 74 22 JE SHORT Nag1.00401128 ; ; Si de la llamada volvemos con un 1 -> Buen trabajo Joe! ........ 004011AF /$ 68 A2324000 PUSH Nag1.004032A2 ; /String2 = "Value1" 004011B4 |. 68 A9324000 PUSH Nag1.004032A9 ; |String1 = "Value2" 004011B9 |. E8 64000000 CALL <JMP.&kernel32.lstrcmpA> ; \lstrcmpA 004011BE |. 50 PUSH EAX ; kernel32.BaseThreadInitThunk 004011BF |. 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 004011C1 |. 75 10 JNZ SHORT Nag1.004011D3 004011C3 |. 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011C5 |. 58 POP EAX ; kernel32.75CDEE1C 004011C6 |. 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 004011C8 |. 74 15 JE SHORT Nag1.004011DF 004011CA |. C605 B0324000 03 MOV BYTE PTR DS:[4032B0],3 004011D1 |. EB 17 JMP SHORT Nag1.004011EA 004011D3 |> 58 POP EAX ; kernel32.75CDEE1C 004011D4 |. 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011D6 |. C605 B0324000 02 MOV BYTE PTR DS:[4032B0],2 004011DD |. EB 0B JMP SHORT Nag1.004011EA 004011DF |> 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011E1 |. C605 B0324000 01 MOV BYTE PTR DS:[4032B0],1 004011E8 |. EB 00 JMP SHORT Nag1.004011EA 004011EA \> C3 RETN
Vemos dentro del Call 4011AF que Compara si Value1 = Value2 y dependiendo de esa comparación guarda en memoria (4032B0), los valores 1, 2 ó 3.
Basta con modificar en un editor hexadecimal la parabra «Value2» por «Value1» y ya tenemos el problema resuelto.
Al pulsar Re-Check
Se podía haber parcheado un montón de código para obtener el mismo resultado pero fijándonos en el código lo hemos conseguido parcheando un solo byte. Recuerda, cuando halla que parchear, cuantos menos bytes mejor.
En Parque Jurásico (1993), la informática no es solo un elemento narrativo, es una pieza clave del suspense y del conflicto. A diferencia de otras películas donde las pantallas muestran interfaces ficticias o visualmente espectaculares pero irreales, Parque Jurásico opta por una aproximación sorprendentemente sobria y auténtica.
Durante bastantes escenas, se nos muestran terminales, ventanas de código y comandos que, lejos de ser decorativos, pertenecen a sistemas reales utilizados por programadores profesionales de principios de los años 90. Este detalle, que puede pasar desapercibido para el público general, resulta especialmente interesante desde un punto de vista técnico. En otras palabras, el trabajo de producción es excelente y destaca como una de las películas más respetuosas con la informática real de su época.
No es “código de película”: es software real
Uno de los puntos más interesantes es que el código que aparece en pantalla no fue escrito para la película. No hay pseudocódigo, ni pantallas diseñadas solo para quedar bonitas en cámara. Lo que se ve es software real, ejecutándose en el entorno Macintosh Programmer’s Workshop (MPW), el kit oficial de Apple para desarrolladores en aquellos años. El sistema operativo que se reconoce es un Macintosh clásico (System 7) corriendo sobre máquinas de la serie Quadra, auténticos pepinos para la época. Vamos, que cuando John Hammond decía aquello de «no hemos reparado en gastos», también iba en serio en lo informático.
«No hemos reparado en gastos»
En este punto no se le puede reprochar demasiado a la película. En líneas generales es bastante fiel a la novela, aunque la resolución del problema de seguridad se aborda de forma distinta. En el libro es el ingeniero Ray Arnold quien detecta el fallo y consigue reconducir la situación. En la película, sin embargo, el personaje desaparece cuando va a los barracones a restablecer la corriente del parque, con el resultado que todos conocemos.
Lo curioso es que muchos personajes sí cambian de forma notable con respecto al libro, el niño es mayor y más friki de los ordenadores, Ray Arnold no muere y acaba salvando la situación, o Gennaro es más atlético y bastante más valiente. Sin embargo, el gran disparate técnico permanece intacto.
En la novela se menciona de pasada a un equipo de informáticos de Cambridge que supuestamente colaboró en el diseño del software. Aun así, la puesta en marcha y la explotación del sistema recaen prácticamente en una sola persona, Dennis Nedry. Evidentemente, tanto al libro como al guion les viene de perlas que todo dependa de una única persona para que el desastre sea posible, pero cuesta aceptar que en un parque donde todo está duplicado, el control informático central dependa de una sola persona.
Curiosamente, en uno de los monitores de Nedry se puede ver una foto de Oppenheimer con la frase «Beginning of baby boom», de la que podemos sacar la conclusión de que Nedry es perfectamente consciente de que su trabajo puede tener consecuencias catastróficas e irreversibles. También es un maravilloso guiño del equipo de producción que nos está indicando exactamente donde se va originar el desastre.
Al final, Parque Jurásico no va de dinosaurios, ni siquiera de genética. Va de personas. Y, más concretamente, de personas con demasiado poder y muy pocos compañeros de equipo y poca supervisión.
Desde el punto de vista informático, la película es casi entrañable. Todo es serio, profesional y real… hasta que descubrimos que el sistema más complejo jamás construido depende, en la práctica, de un solo programador cabreado, mal pagado y con demasiadas líneas de código en la cabeza. Ningún comité de arquitectura, ninguna auditoría externa, ningún segundo par de ojos. Solo Dennis Nedry y su teclado. ¿Qué podía salir mal?
Lo curioso es que ni la película ni el libro se molestan en disimularlo demasiado. Te hablan de sistemas redundantes, de seguridad, de control absoluto… pero el corazón digital del parque es un castillo de naipes. Eso sí, un castillo de naipes programado en máquinas de primera, con software real y pantallas que hoy siguen pareciendo más creíbles que muchas producciones actuales.
Quizá por eso Parque Jurásico envejece tan bien. Porque, incluso cuando se equivoca, lo hace con honestidad. No intenta venderte magia disfrazada de tecnología. Te muestra ordenadores de verdad, código de verdad y errores muy humanos. Y al final, tanto en la novela como en la película, el mensaje es el mismo, puedes clonar dinosaurios, diseñar parques imposibles y rodearte de la mejor tecnología del mundo, que si todo depende de una sola persona, tarde o temprano, el sistema se vendrá abajo.
Y no, el problema no eran los dinosaurios, nunca lo fueron.
Hoy vamos a hacer algo diferente, vamos a hacer un keygen con la propia víctima. El término anglosajón para esto es «selfkeygening» y no es que esté muy bien visto por los reversers pero a veces nos puede sacar de apuros.
La víctima elegida es el Crackme 2 de LaFarge. Está hecho en ensamblador.
Primeramente vamos a realizar un injerto light, con esto quiero decir que vamos a mostrar el serial bueno en la MessageBox de error.
Abrimos Olly y localizamos el código de comprobación del serial, tenemos suerte ya que el serial se muestra completamente y no se comprueba byte a byte ni cosas raras. En la imagen inferior os muestro el serial bueno para el nombre deurus y el mensaje de error. Como podeis observar el serial bueno se saca de memoria con la instrucción PUSH 406749 y el mensaje de error con PUSH 406306.
Si cambiamos el PUSH del serial por el de el mensaje de error ya lo tendriámos. Nos situamos encima del PUSH 406306 y pulsamos espacio, nos saldrá un diálogo con el push, lo modificamos y le damos a Assemble.
Ahora el crackme cada vez que le demos a Check it! nos mostrará:
Pero no nos vamos a quedar ahí. Lo interesante sería que el serial bueno lo mostrara en la caja de texto del serial. Esto lo vamos a hacer con la función user32.SetDlgItemTextA.
Según dice la función necesitamos el handle de la ventana, el ID de la caja de texto y el string a mostrar. La primera y segunda la obtenemos fijándonos en la función GetDlgItemTextA que recoje el serial introducido por nosotros. La string es el PUSH 406749.
Con esto ya tenemos todo lo que necesitamos excepto el espacio dentro del código, en este caso lo lógico es parchear las MessageBox de error y acierto. Las seleccionamos, click derecho y Edit > Fill with NOPs.
Ahora escribimos el injerto.
Finalmente con Resource Hack cambiamos el aspecto del programa para que quede más profesional y listo. Tenemos pendiente hacer el keygen puro y duro, venga agur.
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.
Abrimos la víctima con nuestro decompilador favorito y nos fijamos en su contenido.
En el primer vistazo con el editor hexadecimal ya vemos la solución al reto:
Al igual que el caso anterior con el editor hexadecimal tenemos más que suficiente para resolver el reto.
En el análisis inicial no destaca prácticamente nada excepto la palabra myadmin que podemos ver con un editor hexadecimal.
La palabra myadmin es una buena candidata a ser contraseña ante una decodificación. Probamos con lo estándar y conseguimos resultados con steghide. La decodificación nos devuelve la cadena AEMAVABGAGwAZQBhAHIAbgB7AHQAaABpAHMAXwBpAHMAXwBmAHU***** que rápidamente catalogamos como base64 para resolver el reto.
Se nos entrega una imagen GIF aparentemente corrupta. Estudiando un poco la cabecera de los archivos GIF llegamos rápidamente a la conclusión de que faltan los cuatro primeros bytes del archivo.
Bytes originales
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
00000000 39 61 F4 01 F4 01 F4 00 00 00 00 00 3A 00 00 00 9aô.ô.ô.....:...
00000010 00 3A 3A 00 3A 66 00 00 66 00 3A 00 00 66 90 3A .::.:f..f.:..f.:
00000020 00 90 3A 3A B6 66 00 B6 66 3A 90 90 3A DB 90 3A ..::¶f.¶f:..:Û.:
00000030 FF B6 66 00 3A 90 66 3A 90 00 66 90 00 66 B6 3A ÿ¶f.:.f:..f..f¶:
Después de insertar los bytes que faltan
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
00000000 47 49 46 38 39 61 F4 01 F4 01 F4 00 00 00 00 00 GIF89aô.ô.ô.....
00000010 3A 00 00 00 00 3A 3A 00 3A 66 00 00 66 00 3A 00 :....::.:f..f.:.
00000020 00 66 90 3A 00 90 3A 3A B6 66 00 B6 66 3A 90 90 .f.:..::¶f.¶f:..
00000030 3A DB 90 3A FF B6 66 00 3A 90 66 3A 90 00 66 90 :Û.:ÿ¶f.:.f:..f.Una vez insertados los bytes podemos ver una animación que contiene una cadena de texto fácilmente reconocible como base64. La decodificamos y ya tenemos la solución.
Mirando con un editor hexadecimal no encontramos nada excepto la frase This is not the flag you are looking for para intentar disuadirnos.
Cargamos la imagen en Aperi’Solve y enseguida nos llama la atención la sección Binwalk y un suculento Rar.
Descargamos el archivo Rar y al descomprimir nos encontramos con un archivo de texto con la misma frase desalentadora del inicio y una imagen JPG, esta vez con dos oreos. Inspeccionando la imagen damos con la solución.
File carving is the process of reassembling computer files from fragments in the absence of filesystem metadata. Wikipedia.
«File carving», literalmente tallado de archivos aunque lo traduciremos como extracción, es el proceso de re-ensamblado de archivos extraídos de un conjunto de mayor tamaño.
Header = Cabecera
Footer or tail = Pie
All this documents have the same header and footer, because of this, we need search the middle bytes. This type uses a ZIP file package.
Los documentos de Microsoft Office >2007 tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.
All this documents have the same header and footer, because of this, we need some bytes to differentiate them. In this case we can do this jumping 73 bytes from header. This type uses a ZIP file package.
Los documentos de OpenOffice tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.
Note: >2007 versions have two patterns and the key is the position 0x80. If in this position we get the bytes «68 40 F8 F7 92», we need to search again for this bytes and displace 107 bytes to find the end of the file. If in the position 0x80 we get another different bytes, we need to search again this bytes and displace 1024 bytes to find the end of the file.
Nota: Las versiones >2007 siguen dos patrones y la clave está en la posición 0x80. Si en la posicion 0x80 obtenemos los bytes «68 40 F8 F7 92», los buscamos una segunda vez y ha 107 bytes encontramos el final del archivo. Si en la posición 0x80 obtenemos otros bytes diferentes a los del primer caso, los volvemos a buscar y a 1024 bytes hallaremos el final del archivo.
Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie asociado a un nombre la comprobación se realiza mediante checkboxes con una matriz de 7×3. El CrackMe está realizado en Visual C++ lo que facilita en parte encontrar rápidamente la rutina de comprobación.
004013C5 > /8B7424 10 MOV ESI,[DWORD SS:ESP+10] ; 004013C9 . |33FF XOR EDI,EDI 004013CB > |8B86 74304000 MOV EAX,[DWORD DS:ESI+403074] ; 004013D1 . |8BCB MOV ECX,EBX 004013D3 . |50 PUSH EAX 004013D4 . |E8 6F020000 CALL <JMP.&MFC42.#3092_CWnd::GetDlgItem> ; Lee el estado del checkbox 004013D9 . |8B48 20 MOV ECX,[DWORD DS:EAX+20] 004013DC . |6A 00 PUSH 0 004013DE . |6A 00 PUSH 0 004013E0 . |68 F0000000 PUSH 0F0 004013E5 . |51 PUSH ECX ; 004013E6 . |FFD5 CALL NEAR EBP 004013E8 . |3B86 20304000 CMP EAX,[DWORD DS:ESI+403020] ; Comprueba el estado del checkbox (1 activado 0 desactivado) 004013EE . |75 20 JNZ SHORT Matrix_C.00401410 ; Salto a chico malo 004013F0 . |47 INC EDI ; Incrementa contador 004013F1 . |83C6 04 ADD ESI,4 004013F4 . |83FF 07 CMP EDI,7 ; ¿Hemos terminado de leer las columnas? ¿contador = 7? 004013F7 .^|7C D2 JL SHORT Matrix_C.004013CB ; si terminan las columnas deja pasar 004013F9 . |8B4424 10 MOV EAX,[DWORD SS:ESP+10] 004013FD . |83C0 1C ADD EAX,1C ; contador de filas 00401400 . |83F8 54 CMP EAX,54 ; 3 filas = 1C+1C+1C=54 00401403 . |894424 10 MOV [DWORD SS:ESP+10],EAX 00401407 .^\7C BC JL SHORT Matrix_C.004013C5 ; ¿Hemos terminado de leer la fila? ¿contador = 54? 00401409 . 68 D8304000 PUSH Matrix_C.004030D8 ; ASCII "Registration successful!" 0040140E . EB 05 JMP SHORT Matrix_C.00401415 00401410 > 68 C8304000 PUSH Matrix_C.004030C8 ; ASCII "Not registered!"
En la rutina de comprobación se ve fácil un CMP EDI,7 por lo que podemos deducir que si el creador no se ha molestado mucho la comprobación se realiza de izquierda a derecha y de arriba hacia abajo.
Tal es así que si ponemos un breakpoint en 4013E8, podemos ir sacando el estado correcto de los checkboxes sin mucha molestia.
Abrimos el crackme con Ollydbg y nos salta una protección Anti-Debug.
Retomemos analizando la rutina de comprobación.
FLD DWORD PTR DS:[403080] - Carga el entero "720300" en ST7 FSTP [LOCAL.1] - Guarda "720300" en memoria (Local 1) MOVSX EDX,BYTE PTR DS:[EAX] - Coje nuestro primer dígito en ascii y lo carga en EDX SUB EDX,30 - Le resta 30 a EDX PUSH EDX - Carga EDX en la pila FILD DWORD PTR SS:[ESP] - Carga el valor de EDX en ST0 POP EDX - Recupera el valor de la pila FDIVR [LOCAL.1] - Divide Local 1 entre nuestro dígito hex y lo guarda en ST0 FSTP [LOCAL.1] - Guarda el resultado de ST0 en Local 1 INC EAX - Siguiente dígito CMP BYTE PTR DS:[EAX],0 - Comprueba si quedan dígitos en nuestro serial JNZ SHORT 05_crack.004010F4 - Bucle
Después de la rutina de comprobación simplemente comprueba el valor del resultado de la división con 1 y si es verdad serial válido.
720300 / 2 = 360150 360150 / 2 = 180075 180075 / 5 = 36015 36015 / 5 = 7203 7203 / 3 = 2401 2401 / 7 = 343 343 / 7 = 49 49 / 7 = 7 7 / 7 = 1
Por lo que un serial válido sería: 225537777
La rutina de comprobación del serial podría resumirse también así:
720300 MOD serial = 720300
Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie asociado a un nombre la comprobación se realiza mediante checkboxes con una matriz de 7×3. El CrackMe está realizado en Visual C++ lo que facilita en parte encontrar rápidamente la rutina de comprobación.
004013C5 > /8B7424 10 MOV ESI,[DWORD SS:ESP+10] ; 004013C9 . |33FF XOR EDI,EDI 004013CB > |8B86 74304000 MOV EAX,[DWORD DS:ESI+403074] ; 004013D1 . |8BCB MOV ECX,EBX 004013D3 . |50 PUSH EAX 004013D4 . |E8 6F020000 CALL <JMP.&MFC42.#3092_CWnd::GetDlgItem> ; Lee el estado del checkbox 004013D9 . |8B48 20 MOV ECX,[DWORD DS:EAX+20] 004013DC . |6A 00 PUSH 0 004013DE . |6A 00 PUSH 0 004013E0 . |68 F0000000 PUSH 0F0 004013E5 . |51 PUSH ECX ; 004013E6 . |FFD5 CALL NEAR EBP 004013E8 . |3B86 20304000 CMP EAX,[DWORD DS:ESI+403020] ; Comprueba el estado del checkbox (1 activado 0 desactivado) 004013EE . |75 20 JNZ SHORT Matrix_C.00401410 ; Salto a chico malo 004013F0 . |47 INC EDI ; Incrementa contador 004013F1 . |83C6 04 ADD ESI,4 004013F4 . |83FF 07 CMP EDI,7 ; ¿Hemos terminado de leer las columnas? ¿contador = 7? 004013F7 .^|7C D2 JL SHORT Matrix_C.004013CB ; si terminan las columnas deja pasar 004013F9 . |8B4424 10 MOV EAX,[DWORD SS:ESP+10] 004013FD . |83C0 1C ADD EAX,1C ; contador de filas 00401400 . |83F8 54 CMP EAX,54 ; 3 filas = 1C+1C+1C=54 00401403 . |894424 10 MOV [DWORD SS:ESP+10],EAX 00401407 .^\7C BC JL SHORT Matrix_C.004013C5 ; ¿Hemos terminado de leer la fila? ¿contador = 54? 00401409 . 68 D8304000 PUSH Matrix_C.004030D8 ; ASCII "Registration successful!" 0040140E . EB 05 JMP SHORT Matrix_C.00401415 00401410 > 68 C8304000 PUSH Matrix_C.004030C8 ; ASCII "Not registered!"
En la rutina de comprobación se ve fácil un CMP EDI,7 por lo que podemos deducir que si el creador no se ha molestado mucho la comprobación se realiza de izquierda a derecha y de arriba hacia abajo.
Tal es así que si ponemos un breakpoint en 4013E8, podemos ir sacando el estado correcto de los checkboxes sin mucha molestia.
Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma más limpia posible.
Abrimos el crackme con Olly y ya a simple vista vemos los mensajes de la Nag y parte del código interesante. Si necesitaramos localizar la Nag podemos mirar en las intermodular calls las típicas subrutinas, en este caso se ve claramente a MessageBoxA, bastaría con poner un breakpoint para localizar quien llama.
Aquí vemos la implicación de MessageBoxA.
004010A7 |> \6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 004010A9 |. 68 61304000 PUSH Nag1.00403061 ; |Title = "[NAG] Please register this software!" 004010AE |. 68 86304000 PUSH Nag1.00403086 ; |Text = "[BULLSHIT] Please register this software for support and you'll receive the full version!" 004010B3 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 004010B6 |. E8 49010000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401137 |. 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 00401139 |. 68 6E324000 PUSH Nag1.0040326E ; |Title = "Thank you!" 0040113E |. 68 79324000 PUSH Nag1.00403279 ; |Text = "Thank you for registering this software!" 00401143 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 00401146 |. E8 B9000000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA ........ 00401155 |. 6A 40 PUSH 40 ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL 00401157 |. 68 E0304000 PUSH Nag1.004030E0 ; |Title = "About" 0040115C |. 68 E6304000 PUSH Nag1.004030E6 ; |Text = "Remove the NAG by TDC\r\n\n..: Coded by\t: TDC\t\t\t:..\t\r\n..: Also known as\t: The Dutch Cracker\t:..\t\r\n..: Protection\t: Custom\t\t\t:..\t\r\n..: Contact info\t: tdc123@gmail.com\t:..\t\r\n..: Release date\t: 09-08-2005\t\t:..\t"... 00401161 |. FF75 08 PUSH [ARG.1] ; |hOwner = 7FFDF000 00401164 |. E8 9B000000 CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA
Un poco encima vemos la función SetDlgItemTextA, que nos mostrará el mensaje de que hemos parcheado correctamente.
00401106 |> \68 21304000 PUSH Nag1.00403021 ; /Text = "Dirty crack! Nag removed not registered!" 0040110B |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040110D |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401110 |. E8 FB000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA 00401115 |. EB 36 JMP SHORT Nag1.0040114D 00401117 |> 68 10304000 PUSH Nag1.00403010 ; /Text = "Nag not removed!" 0040111C |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040111E |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401121 |. E8 EA000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA 00401126 |. EB 25 JMP SHORT Nag1.0040114D 00401128 |> 68 4A304000 PUSH Nag1.0040304A ; /Text = "Clean crack! Good Job!" 0040112D |. 6A 73 PUSH 73 ; |ControlID = 73 (115.) 0040112F |. FF75 08 PUSH [ARG.1] ; |hWnd = 7FFDF000 00401132 |. E8 D9000000 CALL <JMP.&user32.SetDlgItemTextA> ; \SetDlgItemTextA
Encima de SetDlgItemTextA vemos el código que analiza si la Nag tiene que aparecer.
004010E6 |. E8 C4000000 CALL Nag1.004011AF ; ; Llamada interesante a analizar 004010EB |. 803D B0324000 03 CMP BYTE PTR DS:[4032B0],3 004010F2 |. 74 12 JE SHORT Nag1.00401106 ; ; Si de la llamada volvemos con un 3 -> Parcheo chapuza 004010F4 |. 803D B0324000 02 CMP BYTE PTR DS:[4032B0],2 004010FB |. 74 1A JE SHORT Nag1.00401117 ; ; Si de la llamada volvemos con un 2 -> Sin parchear 004010FD |. 803D B0324000 01 CMP BYTE PTR DS:[4032B0],1 00401104 |. 74 22 JE SHORT Nag1.00401128 ; ; Si de la llamada volvemos con un 1 -> Buen trabajo Joe! ........ 004011AF /$ 68 A2324000 PUSH Nag1.004032A2 ; /String2 = "Value1" 004011B4 |. 68 A9324000 PUSH Nag1.004032A9 ; |String1 = "Value2" 004011B9 |. E8 64000000 CALL <JMP.&kernel32.lstrcmpA> ; \lstrcmpA 004011BE |. 50 PUSH EAX ; kernel32.BaseThreadInitThunk 004011BF |. 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 004011C1 |. 75 10 JNZ SHORT Nag1.004011D3 004011C3 |. 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011C5 |. 58 POP EAX ; kernel32.75CDEE1C 004011C6 |. 85C0 TEST EAX,EAX ; kernel32.BaseThreadInitThunk 004011C8 |. 74 15 JE SHORT Nag1.004011DF 004011CA |. C605 B0324000 03 MOV BYTE PTR DS:[4032B0],3 004011D1 |. EB 17 JMP SHORT Nag1.004011EA 004011D3 |> 58 POP EAX ; kernel32.75CDEE1C 004011D4 |. 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011D6 |. C605 B0324000 02 MOV BYTE PTR DS:[4032B0],2 004011DD |. EB 0B JMP SHORT Nag1.004011EA 004011DF |> 33C0 XOR EAX,EAX ; kernel32.BaseThreadInitThunk 004011E1 |. C605 B0324000 01 MOV BYTE PTR DS:[4032B0],1 004011E8 |. EB 00 JMP SHORT Nag1.004011EA 004011EA \> C3 RETN
Vemos dentro del Call 4011AF que Compara si Value1 = Value2 y dependiendo de esa comparación guarda en memoria (4032B0), los valores 1, 2 ó 3.
Basta con modificar en un editor hexadecimal la parabra «Value2» por «Value1» y ya tenemos el problema resuelto.
Al pulsar Re-Check
Se podía haber parcheado un montón de código para obtener el mismo resultado pero fijándonos en el código lo hemos conseguido parcheando un solo byte. Recuerda, cuando halla que parchear, cuantos menos bytes mejor.
Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.
El cifrado XOR es uno de los algoritmos más utilizados en el mundillo de la encriptación. Aunque por sí solo no es seguro, suele formar parte de cifrados más complejos e incluso si sois aficionados a los crackmes os habréis dado cuenta de que raro es el crackme que no lo utiliza.
Hoy vamos a hacer un recorrido sobre los retos de encriptación que nos propone yoire.com, que aunque son muy sencillos, nos proporcionan una estupenda base para iniciarnos en este tipo de retos.
En este primer reto, el autor te da directamente la solución, ya que, nos da un texto cifrado y nos dice que está cifrado con la clave 10. Lo que el autor no indica es que la clave es hexadecimal, mas adelante ya aprendereis a fijaros en esos detalles.
Texto cifrado: uqci0t~7d0ie0dxy~{
Clave: 10
Esta vez disponemos de un texto cifrado pero sin pistas. Si nos fijamos en el código fuente veremos que la clave utilizada esta vez es 20 y decimal.
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Easy"));
print Challenges::header();
?>
Convierte la solución que está cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
$solution_xored="m{a4s{`4}`5";
$key = sprintf("%2x",20);
$solution = Crypt::XorData($solution_xored,$key);
print "La solución es: ".$solution_xored;
print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
En esta ocasión debemos ojear el código fuente para averiguar como solucionar el reto. En esta ocasión y como de lo que se trata es de aprender, este lo dejaré sin solucionar.
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Mid"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
foreach (
preg_split("/\./","2.4.10.71.3698")
as $something
)
$value=pow($something,2);
$key = dechex($value);
$solution_xored = base64_decode("ucSnos+lo8Oqtw==");
$solution = Crypt::XorData($solution_xored,$key);
print Challenges::solutionBox();
print Challenges::checkSolution(Crypt::XorData($solution_xored,$key));
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>
<?php
if(Common::getString("showSource")!==false) {
print "<hr>";
highlight_file(__FILE__);
}
print Website::footer();
?>
Venga que casi lo tienes.
En este reto nos indican que el código fuente está encriptado. Cuando nos enfrentamos a XOR en texto grandes y teniendo un indicio de lo que puede contener el código desencriptado es sencillo encontrar lo que buscamos. En este caso en concreto podemos intuir que seguramente el texto contenga la palabra «php«, una vez llegamos a esa conclusión la solución llega sola. Este método no deja de ser un ataque por fuerza bruta.
Código encriptado
lo 8 p]Z9>3<%45xr~~~~~~3?"5~ 8 ryk]Z "9>$p52#9$5jj85145"x1""1)xr$9
lt;5rmnr85p p81<$p81<<5>75#jj85145"xyk]Zon]Z1"535p!%5p5$5p81p#94?p396"14?~~~p%===~~~p$5>4"±#p!%5p1&5"97%1"p3£=?p 1"1p?2$5>5"p<1p"5# %5#$1p1p5#$5p"5$?j]Zl2"nl2"n]Zlo 8 ]Z]Zt;5)ppppppppppppmpre`rk]Zt=5pppppppppppppmp69<575$3?>$5>$#x yk]Zt=5(?"54pppppppmp") $jj?"1$1xt=5|t;5)yk]Z]Z "9>$p81<<5>75#jj#?<%$9?>?(xyk]Z "9>$p81<<5>75#jj3853;?<%$9?>xr3````aryk]Zon]Zl1p8"56mrlomt r r onolom%"<5>3?45x") $jj?"1$1xr#8?'?%"35r|t;5)yyonrn5"p3£497?p6%5>$5l1n]Z]Zlo 8 ]Z96x?==?>jj75$$"9>7x") $jj?"1$1xr#8?'?%"35r|t;5)yyqmm61<#5yp+]ZY "9>$prl8"nrk]ZY "9>$pt=5(?"54k]Z-]Z "9>$p52#9$5jj6??$5"xyk]Zon]Z
Código desencriptado
En este último reto nos aparece un mensaje que nos dice «La solución es: 7b1a4147100a155a0f45574e0f58«. Nos fijamos en el código fuente y vemos que en la encriptación interviene una cookie llamada «PHPSESSID«.
Código fuente
<?php
include("../../../core.php");
print Website::header(array("title"=>"The XOR Chall - Hard"));
print Challenges::header();
?>
Convierte la solución que está codificada y cifrada con una clave XOR para obtener la respuesta a este reto:
<br><br>
<?php
$sessid = isset($_COOKIE["PHPSESSID"])?$_COOKIE["PHPSESSID"]:">hi!|m¬_ö_Ó_;m'`ñ·$\"<";
$key = Encoder::asc2hex($sessid);
$hiddenSolution = file_get_contents(Config::$challsHiddenData."crypt_xor_average.solution");
$hex_xored_solution = Encoder::data2hex(Crypt::XorData($hiddenSolution,$key));
print "La solucion es: ".$hex_xored_solution;
print "<br><br>";
print Challenges::solutionBox();
print Challenges::checkSolution($hiddenSolution);
?>
<a href="<?=$_SERVER["PHP_SELF"]?>?showSource">Ver código fuente</a>
<?php
if(Common::getString("showSource")!==false) {
print "<hr>";
highlight_file(__FILE__);
}
print Website::footer();
?>
Desde Firefox vamos a usar una extensión muy interesante llamada Advanced Cookie Manager que nos permitirá visualizar y modificar dicha cookie.
Una particularidad de la encriptación XOR es que si realizamos «algo XOR 0 == algo«, por lo que un ataque típico sería anular la cookie. La modificamos poniendo como valor 0 y guardamos. Recargamos la web con F5 y ahora nos fijamos que el valor de la solución ha cambiado a «7e5f4410435f1058514254100a19«. Finalmente y teniendo en cuenta que el texto que tenemos es hexadecimal, hacemos fuerza bruta marcando la opción Output First y clickamos en Search.
En el mismo directorio donde tenemos el programa se genera un archivo llamado «XOR_enumeration.txt«, que contiene todos los resultados, echamos un vistazo y hemos tenido suerte.
Continuamos con los BTM awards. Esta vez analizaremos brevemente una escena de la película del casi siempre excelente James Cameron, Mentiras Arriesgadas. En esta ocasión vamos a analizar una situación que se da mucho en el cine de Hollywood, esto es, el Plug and Play mágico. Cuando vemos películas de espías, es habitual encontrarnos con situaciones en las que el protagonista conecta un «algo» en el ordenador al que quiere acceder y ¡chas!, como por arte de magia sin tocar ninguna tecla se copian o se borran unos archivos, le da acceso remoto a algún compañero etc.
Este film no iba a ser menos y es que cuando Harry Tasker (Arnold Schwarzenegger) con sus inigualables dotes para el espionaje, entra en la mansión del objetivo en cuestión, conecta un módem, lo enciende y sin teclear un solo comando le da a su compañero Faisil (Grant Heslov) que se encuentra en una furgoneta a unos kilómetros, acceso a la máquina, nos quedamos perplejos.
Esta situación es posible en la vida real, lo que la hace difícil de creer es que Harry no teclee ni un solo comando al conectar el módem, independientemente del Sistema Operativo que corra la máquina. Si nos situamos un poco, estamos hablando del año 1995, con una máquina corriendo Windows 3.1 y estamos conectando un módem a un puerto RS-232. En aquella época, por avanzada que fuera la tecnología espía, es difícil de creer que las cosas funcionen solas. Otra cosa a destacar es que a no ser que Faisil estuviera conectados a un poste de teléfono, la conexión tendría que ser inalámbrica, casi una quimera hace 20 años. A continuación os muestro la secuencia.
Como se puede observar en el vídeo, incluso parece que el equipo de Faisil, que también corre Windows 3.1, accede al equipo en modo escritorio remoto, tecnología que no existía en aquella época. Para que la secuencia tuviera un mínimo de credibilidad, Harry al conectar el módem y encender el equipo, debiera de haber introducido un par de comandos como mínimo para asignarle un puerto COM al módem y así iniciar la comunicación con Faisil. Ni que decir tiene que Faisil hubiera tenido que hacer todas las transmisiones mediante línea de comandos.
Aunque la película es entretenida y me gustó mucho cuando la vi allá por el año 1998, no nos queda más remedio que ponerle nuestro sello BTM de NO credibilidad.
Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.
Echamos un vistazo a la web y lo único interesante que vemos es un buscador.
Miramos el código fuente y vemos una ruta interesante.
Ahora fijémonos en el menú productos. Pinchamos sobre cualquier producto y a continuación en la imagen para ampliarla, veremos el siguiente enlace.
Vamos a ver si podemos explotar «i.php«. Probamos a obtener información sensible del servidor.
Probamos «http://www.thisislegal.com/nc/i.php?img=adm/login.pwd» y nos da error, seguramente por que está anexionando la extensión de la imagen, es decir, el script está interpretando esto:
Vamos a anularlo con un caracter nulo. Probamos y ahora si.
El password está en base64. Lo decodificamos online, nos logueamos y reto superado.
En Parque Jurásico (1993), la informática no es solo un elemento narrativo, es una pieza clave del suspense y del conflicto. A diferencia de otras películas donde las pantallas muestran interfaces ficticias o visualmente espectaculares pero irreales, Parque Jurásico opta por una aproximación sorprendentemente sobria y auténtica.
Durante bastantes escenas, se nos muestran terminales, ventanas de código y comandos que, lejos de ser decorativos, pertenecen a sistemas reales utilizados por programadores profesionales de principios de los años 90. Este detalle, que puede pasar desapercibido para el público general, resulta especialmente interesante desde un punto de vista técnico. En otras palabras, el trabajo de producción es excelente y destaca como una de las películas más respetuosas con la informática real de su época.
No es “código de película”: es software real
Uno de los puntos más interesantes es que el código que aparece en pantalla no fue escrito para la película. No hay pseudocódigo, ni pantallas diseñadas solo para quedar bonitas en cámara. Lo que se ve es software real, ejecutándose en el entorno Macintosh Programmer’s Workshop (MPW), el kit oficial de Apple para desarrolladores en aquellos años. El sistema operativo que se reconoce es un Macintosh clásico (System 7) corriendo sobre máquinas de la serie Quadra, auténticos pepinos para la época. Vamos, que cuando John Hammond decía aquello de «no hemos reparado en gastos», también iba en serio en lo informático.
«No hemos reparado en gastos»
En este punto no se le puede reprochar demasiado a la película. En líneas generales es bastante fiel a la novela, aunque la resolución del problema de seguridad se aborda de forma distinta. En el libro es el ingeniero Ray Arnold quien detecta el fallo y consigue reconducir la situación. En la película, sin embargo, el personaje desaparece cuando va a los barracones a restablecer la corriente del parque, con el resultado que todos conocemos.
Lo curioso es que muchos personajes sí cambian de forma notable con respecto al libro, el niño es mayor y más friki de los ordenadores, Ray Arnold no muere y acaba salvando la situación, o Gennaro es más atlético y bastante más valiente. Sin embargo, el gran disparate técnico permanece intacto.
En la novela se menciona de pasada a un equipo de informáticos de Cambridge que supuestamente colaboró en el diseño del software. Aun así, la puesta en marcha y la explotación del sistema recaen prácticamente en una sola persona, Dennis Nedry. Evidentemente, tanto al libro como al guion les viene de perlas que todo dependa de una única persona para que el desastre sea posible, pero cuesta aceptar que en un parque donde todo está duplicado, el control informático central dependa de una sola persona.
Curiosamente, en uno de los monitores de Nedry se puede ver una foto de Oppenheimer con la frase «Beginning of baby boom», de la que podemos sacar la conclusión de que Nedry es perfectamente consciente de que su trabajo puede tener consecuencias catastróficas e irreversibles. También es un maravilloso guiño del equipo de producción que nos está indicando exactamente donde se va originar el desastre.
Al final, Parque Jurásico no va de dinosaurios, ni siquiera de genética. Va de personas. Y, más concretamente, de personas con demasiado poder y muy pocos compañeros de equipo y poca supervisión.
Desde el punto de vista informático, la película es casi entrañable. Todo es serio, profesional y real… hasta que descubrimos que el sistema más complejo jamás construido depende, en la práctica, de un solo programador cabreado, mal pagado y con demasiadas líneas de código en la cabeza. Ningún comité de arquitectura, ninguna auditoría externa, ningún segundo par de ojos. Solo Dennis Nedry y su teclado. ¿Qué podía salir mal?
Lo curioso es que ni la película ni el libro se molestan en disimularlo demasiado. Te hablan de sistemas redundantes, de seguridad, de control absoluto… pero el corazón digital del parque es un castillo de naipes. Eso sí, un castillo de naipes programado en máquinas de primera, con software real y pantallas que hoy siguen pareciendo más creíbles que muchas producciones actuales.
Quizá por eso Parque Jurásico envejece tan bien. Porque, incluso cuando se equivoca, lo hace con honestidad. No intenta venderte magia disfrazada de tecnología. Te muestra ordenadores de verdad, código de verdad y errores muy humanos. Y al final, tanto en la novela como en la película, el mensaje es el mismo, puedes clonar dinosaurios, diseñar parques imposibles y rodearte de la mejor tecnología del mundo, que si todo depende de una sola persona, tarde o temprano, el sistema se vendrá abajo.
Y no, el problema no eran los dinosaurios, nunca lo fueron.
Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie asociado a un nombre la comprobación se realiza mediante checkboxes con una matriz de 7×3. El CrackMe está realizado en Visual C++ lo que facilita en parte encontrar rápidamente la rutina de comprobación.
004013C5 > /8B7424 10 MOV ESI,[DWORD SS:ESP+10] ; 004013C9 . |33FF XOR EDI,EDI 004013CB > |8B86 74304000 MOV EAX,[DWORD DS:ESI+403074] ; 004013D1 . |8BCB MOV ECX,EBX 004013D3 . |50 PUSH EAX 004013D4 . |E8 6F020000 CALL <JMP.&MFC42.#3092_CWnd::GetDlgItem> ; Lee el estado del checkbox 004013D9 . |8B48 20 MOV ECX,[DWORD DS:EAX+20] 004013DC . |6A 00 PUSH 0 004013DE . |6A 00 PUSH 0 004013E0 . |68 F0000000 PUSH 0F0 004013E5 . |51 PUSH ECX ; 004013E6 . |FFD5 CALL NEAR EBP 004013E8 . |3B86 20304000 CMP EAX,[DWORD DS:ESI+403020] ; Comprueba el estado del checkbox (1 activado 0 desactivado) 004013EE . |75 20 JNZ SHORT Matrix_C.00401410 ; Salto a chico malo 004013F0 . |47 INC EDI ; Incrementa contador 004013F1 . |83C6 04 ADD ESI,4 004013F4 . |83FF 07 CMP EDI,7 ; ¿Hemos terminado de leer las columnas? ¿contador = 7? 004013F7 .^|7C D2 JL SHORT Matrix_C.004013CB ; si terminan las columnas deja pasar 004013F9 . |8B4424 10 MOV EAX,[DWORD SS:ESP+10] 004013FD . |83C0 1C ADD EAX,1C ; contador de filas 00401400 . |83F8 54 CMP EAX,54 ; 3 filas = 1C+1C+1C=54 00401403 . |894424 10 MOV [DWORD SS:ESP+10],EAX 00401407 .^\7C BC JL SHORT Matrix_C.004013C5 ; ¿Hemos terminado de leer la fila? ¿contador = 54? 00401409 . 68 D8304000 PUSH Matrix_C.004030D8 ; ASCII "Registration successful!" 0040140E . EB 05 JMP SHORT Matrix_C.00401415 00401410 > 68 C8304000 PUSH Matrix_C.004030C8 ; ASCII "Not registered!"
En la rutina de comprobación se ve fácil un CMP EDI,7 por lo que podemos deducir que si el creador no se ha molestado mucho la comprobación se realiza de izquierda a derecha y de arriba hacia abajo.
Tal es así que si ponemos un breakpoint en 4013E8, podemos ir sacando el estado correcto de los checkboxes sin mucha molestia.
