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.

Intro

This crackme is for the crack challenge 6 of canyouhack.it.

In this crackme the goal is to turn on all the lights. Note that a light off to the next, so if we interrupt this, we win.

Tools

Exeinfo (For crackme info)

Delphi Decompiler (For decompile)

 OllyDbg (For debug)

Decompiling

With Delphi Decompiler we can found easy the buttons and his offsets.
Go to the offset 401A64 in OllyDbg and analyze the code.
We view two jumps, one turn ON the light and the other Turn OFF the next light. Patching the call from offset 401A8B we get the serial.

Links


Este BTM va otra vez sobre IPs. Si amigos del séptimo arte, viendo un capítulo de mi querida "The Sinner"
Intro Hoy tenemos aquí otro crackme sacado del baúl de los recuerdos. En este caso se trata de una protección
Introducción Esta es la primera entrega de tres en las que vamos a  ver tres crackmes que todo reverser debería
Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he

Este BTM va otra vez sobre IPs. Si amigos del séptimo arte, viendo un capítulo de mi querida «The Sinner» me han vuelto a chirriar los dientes. La verdad que viendo el capítulo no te da tiempo a apreciarlo, únicamente me quedo con que aparece una URL y lo reviso a posteriori (esto lo digo para los curiosos que me preguntáis).

En esta ocasión me tiene un poco inquieto ya que es una serie que cuida enormemente los detalles y el fallo que os voy a mostrar parece intencionado. La imagen en cuestión es esta:

Fotograma del capítulo 2×06

Aparece un buscador con una URL más o menos creíble si no fuera porque la IP que aparece es IMPOSIBLE. La máxima IPv4 es 255.255.255.255, es decir, no han dado ni una, y eso es lo que me tiene mosca. Si hubieran utilizado 82.47.25.29 hubiera quedado bien y estaríamos hablando de un problema de geolocalización de IPs, ya que el rango 82.47.xx.xx le pertenece a UK y deberíamos discernir si el servidor está en EEUU o no…

En definitiva, puede ser un fallo a propósito, un guiño o tener un significado. No se que deciros, bueno si, ¡lo investigaré!

Enlaces

Intro

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.

El algoritmo

La primera vez que ejecutamos el crackme, crea el fichero «data.det» y realiza lo siguiente:

  • Lee el fichero data.det que inicialmente tiene 10 bytes a cero y el último byte un 60(`).
  • Comprueba que tenga 11 bytes (B) y continúa.
  • Al detectar el fichero vacío le mete valores codificandolos con XOR 6969. Los almacena en memoria 4030AB y siguientes.
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.

  • Los dos primeros bytes son el año = 2014 = 0x7DE. 7DE XOR 6969 = 6EB7.
  • Los dos siguientes son el mes = 10 = 0xA. A XOR 6969 = 6963.
  • Los dos siguientes usa un 4 (día de la semana???) = 0x4. 4 XOR 6969 = 696D.
  • Los dos siguientes son el día del mes = 2 = 0x2. 2 XOR 6969 = 696B
  • Los dos siguientes usa un 1 = 0x1. 1 XOR 6969 = 6968.
  • El número de sesiones lo deja como está, 60.

Estado de la memoria:

004030AB  B7 6E 63 69 6D 69 6B 69 68 69 60                 ·ncimikihi`
  •  Finalmente le resta 1 al número de sesiones y guarda el fichero.
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.

Keygen

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

 Links


Intro Hace poco me reencontré con esta entrañable serie que tanto me entretuvo cuando era pequeño y para mi sorpresa,
Introducción La película "Contact", estrenada en 1997 y dirigida por Robert Zemeckis, es una adaptación de la novela homónima de
Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si
Introducción Objetivo del juego y normas Código inicial Primeras modificaciones Terminando la faena Código ganador Curiosidades Enlaces Introducción Hace tiempo

Intro

Hace poco me reencontré con esta entrañable serie que tanto me entretuvo cuando era pequeño y para mi sorpresa, me percaté de que nunca había visto el episodio piloto. La nostalgia me llevó a tragarme el episodio entero y a disfrutar a lo grande de la parafernalia técnica de la que hace gala para justificar la creación que da nombre a la serie.

La visión tecnológica de los años 80

Esto hay que analizarlo con perspectiva. Estamos en los años 80 y nos están presentando un coche capaz de mantener una conversación, es decir, nos están presentando una inteligencia artificial (IA) llamada KITT. Puede parecer que el término inteligencia artificial es nuevo pero realmente se acuño en 1956 por John McCarthy. A partir de ese momento surgieron líneas de estudio e hipótesis pero a partir de los 70 se puede considerar que la investigación sobre la IA perdió financiación y quedó en el congelador hasta los años 90. Dicho esto, cuando nos presentan a KITT lo hacen de la siguiente manera:

Devon Miles: Está totalmente controlado por microprocesadores que hacen físicamente imposible que se vea implicado en ningún tipo de colisión o percance a no ser que se lo ordene su piloto específicamente

Michael Knight: ¿Piloto?, no me diga que esta cosa vuela

Devon Miles: ¡No!, pero piensa

Michael Knight: ¿Piensa?, ¿mi coche piensa?

Intel daba a conocer el primer microprocesador allá por el 71 y la serie se estrenó en el 82 lo que le da credibilidad en ese aspecto, aunque dudo que el público de esa época supiera que era un microprocesador, un ordenador y menos una IA.

Los Chips

La serie arranca con un grupo de personas realizando espionaje industrial donde nos muestran las hojas de datos de dos chips Japoneses como son el PD8257-5 y el PD780. Un aplauso para los guionistas y sus asesores ya que el PD8257-5 es una interfaz de comunicaciones y el PD780 un microprocesador de 8 bits.

Detalle del esquema del chip PD8257-5 y del set de instrucciones del chip PD780

Lo más interesante es que lo que se muestra es real como podéis apreciar en la siguiente imagen

Detalle del esquema mostrado en la serie VS la hoja de datos

A continuación un detalle de las capturas realizadas:

Más adelante vuelven a aparecer imágenes en un PC que parecen puestas en post-producción y que son robadas en un maravilloso disco de 5 1/4.

Los diálogos

Llaman la atención mucho los diálogos centrados en el microprocesador como si de un ser superior se tratase, éste es la referencia continua y la parte central del guion de los dos primeros capítulos. Curiosamente aparecen en pantalla multitud de imágenes de circuitos integrados pero no se llega a ver ningún microprocesador. Por otro lado, es interesante el esfuerzo que hacen los guionistas por que llamemos a KITT él en vez de ello, convirtiendo al coche en un personaje más.

Otra cosa que llama mucho la atención son los tópicos de los que hace gala como la asociación de los microprocesadores a los videojuegos o que la empresa villana esté afincada en Silicon Valley. Incluso el nombre KITT es un tópico ya que las siglas vienen de Knight Industries Two Thousand que en cristiano quiere decir Industrias Knight 2000. Y es que en mi opinión el año 2000 se imaginaba como una barrera lejana en la que todo iba a ser tecnológicamente más avanzado.

Conclusiones

Tengo que reconocer que me ha sorprendido que dieran realismo a los chips mostrados teniendo en cuenta que aparecen muy pocos segundos en pantalla y podían haber puesto cualquier cosa.

Por otro lado, la realidad es que en el año 2022 aún nos queda recorrido para llegar a tener un coche fantástico y lo más parecido que tenemos hoy día sería un Tesla con Alexa.

Enlaces de interés

Introducción

La película «Contact«, estrenada en 1997 y dirigida por Robert Zemeckis, es una adaptación de la novela homónima de Carl Sagan. Más allá de su profunda exploración sobre la existencia de vida extraterrestre y el debate entre ciencia y fe, la película ofrece un interesante vistazo a la tecnología de la época. En este análisis, nos enfocaremos en los aspectos tecnológicos presentes en la película, detallando los sistemas operativos, software y hardware utilizados por los protagonistas.

Sinopsis

La Dra. Eleanor «Ellie» Arroway, interpretada por Jodie Foster, es una científica dedicada al proyecto SETI (Búsqueda de Inteligencia Extraterrestre). Tras años de búsqueda, capta una señal proveniente del espacio profundo que contiene instrucciones para construir una máquina enigmática. A medida que se desarrolla la trama, Ellie enfrenta desafíos políticos, religiosos y personales mientras lucha por interpretar el mensaje y lo que podría significar para la humanidad.

Análisis Tecnológico

Sistemas Operativos y Software

Uno de los aspectos más destacados en Contact es la presencia del sistema operativo UNIX. A lo largo de la película, se observan pistas que indican su uso, como pegatinas en las pantallas con mensajes del estilo: «Join the UNIX PARTY (The open system platform)». UNIX, desarrollado en la década de 1970, es conocido por su estabilidad y eficiencia, características esenciales en entornos científicos y de investigación.

La utilización de Netscape Navigator es recurrente. El logo de Netscape aparece en varias ocasiones, especialmente durante las videoconferencias que se muestran sin retrasos apreciables. Netscape fue uno de los primeros navegadores web ampliamente utilizados y jugó un papel crucial en la expansión de Internet durante los años 90.

Es importante destacar que, aunque la película promueve la idea de sistemas abiertos a través del uso de UNIX, Netscape Navigator no era software libre en el momento en que se rodó la película. Durante esa época, antes de 1997, Netscape era un navegador propietario. Sin embargo, en sistemas UNIX, Netscape tenía poca competencia y era el navegador predominante, soportando estándares abiertos como HTTP y HTML. Curiosamente, en 1998, poco después del estreno de la película, Netscape liberó el código fuente de su navegador, iniciando el proyecto Mozilla y contribuyendo significativamente al movimiento del software libre.

El software o plataforma denominada MADDEN HADDEN es utilizado por los protagonistas en diversas localizaciones, sugiriendo que es un estándar en su campo. Aunque en la realidad no existe un software conocido con ese nombre en el ámbito científico, en la película parece ser una herramienta integral para el análisis de datos y comunicación.

Videoconferencias y Comunicaciones

Las videoconferencias sin «lags» (retrasos) que se muestran en la película son notables, especialmente considerando las limitaciones tecnológicas de la época. La presencia del logo de Netscape durante estas comunicaciones resalta el optimismo sobre las capacidades de Internet en 1997. En ese entonces, las conexiones de alta velocidad no eran comunes, y las videollamadas de calidad eran más una aspiración que una realidad.

Estándares y Sistemas Abiertos

La promoción de sistemas abiertos es evidente en la película. El uso de UNIX, basado en estándares abiertos, refleja una filosofía de colaboración y accesibilidad en el ámbito científico. Aunque Netscape Navigator no era software libre durante la producción de la película, su soporte para estándares abiertos de Internet lo convirtió en una herramienta esencial para la comunicación y el intercambio de información entre científicos y profesionales.

Hardware

En términos de hardware, la película presenta una variedad de equipos representativos de la tecnología de los años 90:

Monitor NEC MultiSync XE21: Un monitor CRT de 21 pulgadas conocido por su alta resolución y calidad de imagen, ideal para aplicaciones que requieren detalles precisos.

Monitores con marcas ocultas: Es interesante notar que en varios monitores se utilizan post-its o adhesivos para cubrir la marca y el modelo. Esto podría deberse a decisiones de producción para evitar publicidad no deseada o cuestiones legales relacionadas con derechos de marca.

Monitor CTX: Aunque no se especifica el modelo, los monitores CTX eran populares por su fiabilidad y rendimiento a un costo razonable.

Monitor Hansol Mazellan 17px: Los monitores Hansol eran reconocidos por su calidad en la reproducción de gráficos, siendo utilizados en diseño y aplicaciones multimedia.

Monitor IBM: IBM fue pionera en tecnología informática, y sus monitores eran sinónimo de calidad y durabilidad. Aunque no se especifica el modelo exacto, es probable que se trate de uno de sus populares monitores CRT utilizados en entornos profesionales.

Evolución de UNIX y Windows

Para entender el contexto tecnológico de la época, es útil comparar la evolución de UNIX y Windows, así como de los navegadores Netscape Navigator e Internet Explorer.

Detalles Adicionales

Cobertura de marcas: La práctica de cubrir las marcas y modelos en los monitores podría indicar un intento de la producción por crear un entorno más universal y atemporal, evitando asociar la tecnología presentada con productos específicos que podrían quedar obsoletos rápidamente. En bastantes fotogramas se nota que esto es completamente intencionado.

Representación de la tecnología: La película equilibra la precisión técnica con las necesidades narrativas. Si bien algunas representaciones, como las videoconferencias fluidas, eran tecnológicamente avanzadas para la época, sirven para enfatizar la conectividad y colaboración global entre los científicos.

SETI y la Búsqueda de Vida Extraterrestre: En Contact, la Dra. Ellie Arroway dedica su vida al proyecto SETI (Search for Extraterrestrial Intelligence), reflejando el esfuerzo real de la comunidad científica por encontrar señales de inteligencia extraterrestre. SETI es una iniciativa internacional que utiliza radiotelescopios para detectar posibles comunicaciones de civilizaciones fuera de la Tierra. La película captura la pasión y los desafíos asociados con este tipo de investigación, destacando la dedicación de los científicos que trabajan en el límite de lo conocido.

El Mensaje de Arecibo: El radiotelescopio de Arecibo en Puerto Rico juega un papel significativo tanto en la realidad como en la película. En 1974, desde este observatorio, se envió el famoso Mensaje de Arecibo, una transmisión de radio dirigida al cúmulo estelar M13, diseñada para demostrar los avances tecnológicos humanos y nuestra existencia a posibles civilizaciones extraterrestres. El mensaje contenía información codificada sobre la composición humana, nuestro sistema numérico, la estructura del ADN y nuestra posición en el sistema solar. En «Contact», aunque la señal recibida por Ellie proviene de Vega y no está directamente relacionada con el Mensaje de Arecibo, la película establece paralelismos con este acontecimiento histórico. La utilización de Arecibo como escenario subraya la conexión entre los esfuerzos reales y ficticios en la búsqueda de inteligencia extraterrestre. La película explora la posibilidad de que, así como enviamos mensajes al espacio, podríamos recibir respuestas o comunicaciones de otras civilizaciones.

Matthew McConaughey: Es interesante notar cómo este actor ha participado en dos de las películas más destacadas de la ciencia ficción: Contact e Interstellar. En Contact, McConaughey interpreta un papel secundario como Palmer Joss, un escritor y asesor espiritual que cuestiona las implicaciones éticas y filosóficas del descubrimiento científico. Diecisiete años después, en Interstellar, asume el rol protagonista de Cooper, un ex piloto de la NASA que emprende una misión interestelar para salvar a la humanidad.

Números primos: El inicio de la investigación seria de la señal extraterrestre en la película se desencadena cuando, al analizar la señal recibida, los científicos descubren que esta codifica una secuencia de números primos. Este hallazgo resulta crucial, ya que los números primos, al ser divisibles únicamente por 1 y por sí mismos, no surgen de forma aleatoria en procesos naturales conocidos. Su presencia en la señal sugiere intencionalidad e inteligencia detrás de su emisión, lo que confirma que no se trata de ruido cósmico sino de una posible comunicación deliberada desde una civilización avanzada. Este descubrimiento impulsa a los científicos a profundizar en la decodificación, marcando el verdadero inicio de la búsqueda de vida extraterrestre.

Conclusión

Contact no solo es una obra que invita a reflexionar sobre nuestro lugar en el universo y la posibilidad de vida más allá de la Tierra, sino que también es un retrato de la tecnología de su tiempo. La inclusión de sistemas operativos como UNIX, navegadores como Netscape y hardware específico refleja una atención al detalle que enriquece la narrativa. A pesar de que Netscape Navigator no era software libre durante la producción de la película, su presencia destaca la importancia de los estándares abiertos y la colaboración en el avance científico.

También destaca por su compromiso con la precisión científica, en gran parte debido a la influencia de Carl Sagan, autor de la novela original y asesor en la producción. La representación de los procedimientos del SETI, el análisis de señales y las discusiones éticas y filosóficas reflejan debates reales en la comunidad científica. La inclusión de elementos como el Mensaje de Arecibo y las operaciones del radiotelescopio añaden autenticidad a la narrativa y acercan al público a la realidad de la exploración espacial.

Bibliografía y Enlaces

Galería

Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si continuas leyendo este manual es que no utilices la respuesta para completar la prueba sin esfuerzo. 😉

Saltando el Anti-Debug

Abrimos el crackme con Ollydbg y nos salta una protección Anti-Debug.

Si nos fijamos en las «Text Strings» vemos que es la clásica isDebuggerPresent. Pinchamos en ella y vemos claramente el salto que debemos forzar, se encuentra en el offset 401015. Podemos invertir el salto o cambiarlo a JMP para que salte siempre.

Rutina de comprobación del serial

A simple vista vemos instrucciones como FILD y FIDIVR que trabajan con los registros FPU, por lo que tendremos que fijarnos en dichos registros.

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.

Buscando un serial válido

Podríamos hacer fuerza bruta, pero en esta ocasión no es necesario ya que con la calculadora, boli y papel lo sacamos rápido.
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

Links


Introducción Hoy tenemos aquí un crackme de los que te hacen temblar las conexiones neuronales. Estamos acostumbrados al típico serial
http://youtu.be/c4CNY902SAE Versión de texto Lista de reproducción
Alerta de Spoiler: El reto está en activo a fecha de publicación. Spoiler alert: The challenge is still alive. Este
Hace poco me puse a leer El oscuro pasajero de Jeff Lindsay, novela que inspiró la serie Dexter. La nostalgia

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.

Enlaces

  • Copycat [IMDb]
  • Historia de Internet [Wikipedia]
  • Correo electrónico [Wikipedia]
  • Compaq [Wikipedia]
  • Silicon Cowboys: la historia de cómo Compaq retó (y venció) a IBM y Apple [Xataka]
  • Formato de vídeo AVI [Wikipedia]
  • Analysis of video file formats in forensics (.avi example) [DiViLine]

Galería

Intro

El crackme que analizamos hoy está hecho en ensamblador y si bien su dificultad es baja, la creación del keygen es un poco liosa. Al keygen que veremos más adelante, le he dado cierta aleatoriedad para que quede más elegante.

El crackme comprueba el serial en función de un identificador de 4 dígitos que el mismo crackme genera.

Análisis

Coje nuestro serial mediante la función GetDlgItemTextA.

004010D3  |.  68 FF000000   PUSH 0FF                                 ; /MaxCount = 255.
004010D8  |.  68 40324000   PUSH OFFSET 00403240                     ; |String
004010DD  |.  68 EC030000   PUSH 3EC                                 ; |ItemID = 1004.
004010E2  |.  FF75 08       PUSH DWORD PTR SS:[ARG.1]                ; |hDialog => [ARG.1]
004010E5  |.  E8 6E010000   CALL <JMP.&user32.GetDlgItemTextA>       ; \USER32.GetDlgItemTextA
004010EA  |.  68 40324000   PUSH OFFSET 00403240                     ; /String
004010EF  |.  E8 52010000   CALL <JMP.&kernel32.lstrlenA>            ; \KERNEL32.lstrlen
004010F4  |.  A3 47334000   MOV DWORD PTR DS:[403347],EAX
004010F9  |.  33DB          XOR EBX,EBX
004010FB  |.  33C0          XOR EAX,EAX
004010FD  |.  EB 54         JMP SHORT 00401153

Comprueba que nuestro serial esté formado por números (30h – 39h), letras de la A a la F (41h – 46h) y el guión (2Dh), es decir, el alfabeto hexadecimal más el guión. Si hay algún dígito indeseado nos tira fuera.

004010FF  |>  8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240]
00401105  |.  3C 2D         |CMP AL,2D
00401107  |.  74 40         |JE SHORT 00401149
00401109  |.  3C 30         |CMP AL,30
0040110B  |.  74 3C         |JE SHORT 00401149
0040110D  |.  3C 31         |CMP AL,31
0040110F  |.  74 38         |JE SHORT 00401149
00401111  |.  3C 32         |CMP AL,32
00401113  |.  74 34         |JE SHORT 00401149
00401115  |.  3C 33         |CMP AL,33
00401117  |.  74 30         |JE SHORT 00401149
00401119  |.  3C 34         |CMP AL,34
0040111B  |.  74 2C         |JE SHORT 00401149
0040111D  |.  3C 35         |CMP AL,35
0040111F  |.  74 28         |JE SHORT 00401149
00401121  |.  3C 36         |CMP AL,36
00401123  |.  74 24         |JE SHORT 00401149
00401125  |.  3C 37         |CMP AL,37
00401127  |.  74 20         |JE SHORT 00401149
00401129  |.  3C 38         |CMP AL,38
0040112B  |.  74 1C         |JE SHORT 00401149
0040112D  |.  3C 39         |CMP AL,39
0040112F  |.  74 18         |JE SHORT 00401149
00401131  |.  3C 41         |CMP AL,41
00401133  |.  74 14         |JE SHORT 00401149
00401135  |.  3C 42         |CMP AL,42
00401137  |.  74 10         |JE SHORT 00401149
00401139  |.  3C 43         |CMP AL,43
0040113B  |.  74 0C         |JE SHORT 00401149
0040113D  |.  3C 44         |CMP AL,44
0040113F  |.  74 08         |JE SHORT 00401149
00401141  |.  3C 45         |CMP AL,45
00401143  |.  74 04         |JE SHORT 00401149
00401145  |.  3C 46         |CMP AL,46
00401147  |.  75 07         |JNE SHORT 00401150
00401149  |>  8305 4B334000 |ADD DWORD PTR DS:[40334B],1
00401150  |>  83C3 01       |ADD EBX,1
00401153  |>  3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347]
00401159  |.^ 76 A4         \JBE SHORT 004010FF
0040115B  |. A1 47334000 MOV EAX,DWORD PTR DS:[403347]
00401160  |. 3905 4B334000 CMP DWORD PTR DS:[40334B],EAX     ; si no coincide el tamaño del serial con el
00401166  |. 0F85 94000000 JNE 00401200                      ; contador nos tira fuera

La comprobación del serial la realiza sumando el valor ascii del primer dígito al valor ascii del tercero y sucesivos y a continuación restando la suma anterior al ID. Cuando finalice la comprobación de todos los dígitos del serial, el restador tiene que ser cero, de lo contrario nos tira fuera. Si el ID es cero también nos tira fuera.

Ejemplo (base 10)para ID = 4011 y SERIAL: 1-23456

  • Valores del serial: 1(49) -(no se usa) 2(50) 3(51) 4(52) 5(53) 6(54)
  • 1º + 3º: 49 + 50 = 99
  • 4011 – 99 = 3912
  • 1º + 4º: 49 + 51 = 100
  • 3912 – 100 = 3812
  • 1º + 5º: 49 + 52 = 101
  • 3812 – 101 = 3711
  • 1º + 6º: 49 + 53 = 102
  • 3711 – 102 = 3609
  • 1º + 7º: 49 + 54 = 103
  • 3609 – 103 = 3506
  • ¿3506 = 0?
0040116C  |.  33C0          XOR EAX,EAX
0040116E  |.  BB 02000000   MOV EBX,2
00401173  |.  A0 40324000   MOV AL,BYTE PTR DS:[403240]
00401178  |.  A3 43334000   MOV DWORD PTR DS:[403343],EAX
0040117D  |.  EB 13         JMP SHORT 00401192
0040117F  |>  8A83 40324000 /MOV AL,BYTE PTR DS:[EBX+403240]         ; Coje el dígito correspondiente
00401185  |.  0305 43334000 |ADD EAX,DWORD PTR DS:[403343]           ; 1ºdig + dig
0040118B  |.  2905 4F334000 |SUB DWORD PTR DS:[40334F],EAX           ; ID - (1ºdig + dig)
00401191  |.  43            |INC EBX
00401192  |>  3B1D 47334000 |CMP EBX,DWORD PTR DS:[403347]
00401198  |.^ 72 E5         \JB SHORT 0040117F
0040119A  |.  833D 4F334000 CMP DWORD PTR DS:[40334F],0              ; CHECK RESTADOR SEA = 0
004011A1  |.  75 49         JNE SHORT 004011EC
004011A3  |.  833D 3F334000 CMP DWORD PTR DS:[40333F],0              ; CHECK ID <> 0
004011AA  |.  74 40         JE SHORT 004011EC
004011AC  |.  FF35 3F334000 PUSH DWORD PTR DS:[40333F]               ; /<%d> = 0
004011B2  |.  68 00304000   PUSH OFFSET 00403000                     ; |Format = "REGISTRADO CON ID:%d"
004011B7  |.  68 40324000   PUSH OFFSET 00403240                     ; |Buf
004011BC  |.  E8 A9000000   CALL <JMP.&user32.wsprintfA>             ; \USER32.wsprintfA

Como veis, el resultado de ir restando todos los dígitos de nuestro serial con la ID debe ser cero para que el serial sea correcto.

Keygen

Lo primero que se me ocurre para obtener una solución directa es buscar una combinación de dígito + dígito que sea múltiplo del ID. Para ello podemos usar la función módulo. La función módulo lo que hace es darnos el resto de la división de dos números, de modo que si el resto es cero los números son múltiplos. Para ello debemos cruzar todos los números y letras hasta encontrar los dígitos múltiplos del ID. Un serial de este primer tipo quedaría algo así como 1-FFFFFFFFFFFFFFFFFF ya que como el primer dígito es fijo el otro se repetirá tanta veces como sea necesario para hacer que el ID sea cero.

Con nuestro reducido alfabeto, cabe la posibilidad de que no encontremos una combinación válida, por lo que tendremos que pensar en un plan B. El plan B que se me ocurre a mi es intentar forzar el plan A restando caracteres aleatorios al ID y volviendo a comprobar si encontramos múltiplos del nuevo ID. Un serial de este tipo quedaría más elegante, por ejemplo 3-A6D53B628BBBBB.

Os dejo unos cuantos números de serie.

  • Tipo A
    • ID: 1111 SERIAL: 0-55555555555
    • ID: 2500 SERIAL: 0-4444444444444444444444444
    • ID: 4982 SERIAL: 1-99999999999999999999999999999999999999999999999
    • ID: 4992 SERIAL: 0-0000000000000000000000000000000000000000000000000000
  • Tipo B
    • ID: 1112 SERIAL: 9-19247C5555
    • ID: 2499 SERIAL: A-C5ADC2233333333333333
    • ID: 4981 SERIAL: 7-C6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
    • ID: 4999 SERIAL: 4-A37BEEB8146A5CE6ECFB422B1BFF8474E852314F5A999
'Keygen for Flamer's asm keygenme
    Dim id As Integer
    Dim serial As String
    Dim tmp, tmp2, na, nb As Integer
    Dim alfabeto As Integer() = New Integer() {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70}
    Dim r As Random = New Random
    'Button generate
    Private Sub btngen_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btngen.Click
ini:
        If txtid.TextLength <> 4 Then GoTo Mal
        id = txtid.Text
        txtdebug.Text = ""
        na = alfabeto(r.Next(1, 16))
        serial = Chr(na) & "-"
        tmp = id
        For i = 0 To alfabeto.Length - 1
            For y = 0 To alfabeto.Length - 1
                'Solución directa
                If id Mod (alfabeto(i) + alfabeto(y)) = 0 Then
                    tmp = id / (alfabeto(i) + alfabeto(y))
                    txtserial.Text = Chr(alfabeto(i)) & "-"
                    For z = 0 To tmp - 1
                        txtserial.Text &= Chr(alfabeto(y))
                    Next
                    GoTo fuera
                End If
                'Indirecta con aleatoriedad
                nb = alfabeto(r.Next(1, 16))
                tmp = tmp - (na + nb)
                serial &= Chr(nb)
                If tmp Mod (na + nb) = 0 Then
                    tmp2 = tmp / (na + nb)
                    For z = 0 To tmp2 - 1
                        serial &= Chr(nb)
                    Next
                    txtserial.Text = serial
                    GoTo fuera
                End If
                If tmp < 0 Then
                    GoTo ini
                Else
                    txtdebug.Text &= tmp & " "
                End If
            Next
        Next
Mal:
        txtserial.Text = "¿id?"
fuera:

    End Sub

Me doy cuenta que en el keygen no he utilizado el guión, pero no pasa nada, se lo dejo al lector como curiosidad.

Links


st2 arcade
He de iniciar esta entrada diciendo que la segunda temporada de Stranger Things es sencillamente genial. Son 9 horas intensas
Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he
Introducción Continuamos con la segunda entrega de Cruehead. En este caso nos encontramos con un único campo de contraseña para
Intro Hoy tenemos un crackme realizado en ensamblador y sin empacar. Consiste en el típico serial asociado a un nombre

st2 arcade

He de iniciar esta entrada diciendo que la segunda temporada de Stranger Things es sencillamente genial. Son 9 horas intensas que no dejan indiferente a nadie y además en el capítulo 8 nos han dejado una de esas perlas informáticas que tanto nos gustan.

La escena la protagoniza Bob Newby, un buen hombre amante de la electrónica de aquella época que trabaja en RadioShack y transcurre en el laboratorio secreto de Hawkins. En un momento dado, Bob propone «saltarse» la seguridad del laboratorio y para ello se traslada al sótano donde se encuentran los «servidores».

El PC de la época

Para comprender esta escena hay que situarse temporalmente. Estamos hablando de los años 80, en concreto la escena transcurre en 1984 y los equipos de los que dispone el laboratorio son unos maravillosos IBM. No se llega a apreciar bien el modelo de IBM utilizado pero teniendo en cuenta que el monitor que aparece es un terminal IBM 3180, la búsqueda se reduce a los sistemas compatibles S/36, S/38, AS/400, 5294 ó 5394.

IBM 3180

IBM 3180 (https://www.argecy.com/3180)

Cracking BASIC or BASIC Cracking?

La escena plantea un ataque de fuerza bruta a un código de 4 dígitos como se puede observar en la imagen a continuación. Esto puede parecer una chorrada hoy día pero podía suponer un pequeño reto para un micro de 8 bits.

Cracking Basic or Basic Cracking?

Cracking Basic or Basic Cracking?

A simple vista se aprecian una serie de bucles recursivos, una llamada a una función y una sentencia condicional. Desconozco si la sintaxis del lenguaje es la correcta pero mucho me temo que es más bien una mezcla de BASIC y pseudocódigo. Pero lo que más me ha llamado la atención sin duda es que la palabra THEN parece que se sale del monitor como si estuviera realizado en post-producción. Os invito a que ampliéis la imagen y comentéis lo que os parece a vosotr@s.

Os dejo aquí el código para los más curiosos.

10 DIM FourDigitPassword INTEGER
20 FOR i = 0 TO 9
30 		FOR j = 0 TO 9
40			FOR k = 0 TO 9
50				FOR l = 0 TO 9
60					FourDigitPassword = getFourDigits (i,j,k,l)
70					IF checkPasswordMatch(FourDigitPassword) = TRUE THEN
80						GOTO 140
90					END
100				NEXT l
110			NEXT k
120		NEXT j
130 NEXT i
140 PRINT FourDigitPassword

Aunque  la entrada está dentro del contexto de los Blooper Tech Movies, digamos que en esta ocasión no voy a ir más allá. La escena es creíble y queda bien integrada en la época en la que se desarrolla el capítulo. Por esto mismo, solamente espero que las temporadas venideras sean tan buenas y cuiden tanto los detalles como sus predecesoras.

Referencias

[1] Ficha IMDB – Stranger Thing

[2] Wikia de Stranger Things

[3] IBM 3180

[4] BASIC

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he encontrado con que el repositorio no estaba preparado para todas las distros Linux de forma estándar. El resultado lo he colgado en Github, de modo que para montarlo en vuestra propia Raspi solo tenéis que seguir estos pasos:

1. Clonar el repositorio
git clone https://github.com/deurus/AperiSolve-Raspi3.git
cd AperiSolve-Raspi3/AperiSolve

2. Construir los contenedores
docker compose build
docker compose up -d

3. Abrir la web
http://<IP_RASPI>:5000

Si tenéis curiosidad de la adaptación que he tenido que hacer aquí están los pasos que he seguido:

1. Preparar el sistema
sudo apt update
sudo apt install -y git docker.io docker-compose
sudo usermod -aG docker $USER
newgrp docker

2. Clonar AperiSolve
git clone https://github.com/Zeecka/AperiSolve.git
cd AperiSolve

3. Crear la estructura de build para la imagen ARM/x86
nano docker-compose.yml

y pega este contenido:

FROM python:3.11-slim

RUN apt-get update && apt-get install -y \
    zip \
    p7zip-full \
    binwalk \
    foremost \
    exiftool \
    steghide \
    ruby \
    binutils \
    pngcheck \
    && rm -rf /var/lib/apt/lists/*

COPY aperisolve/ /aperisolve/

RUN pip install --no-cache-dir -r /aperisolve/requirements.txt

WORKDIR /aperisolve

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "wsgi:app"]

4. Arreglar docker-compose.yml para ser válido y compatible

services:
  web:
    image: aperisolve-local
    build: .
    container_name: aperisolve-web
    ports:
      - "5000:5000"
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  worker:
    image: aperisolve-local
    container_name: aperisolve-worker
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  redis:
    image: redis:7
    container_name: aperisolve-redis

  postgres:
    image: postgres:16
    container_name: aperisolve-postgres
    environment:
      POSTGRES_USER: aperiuser
      POSTGRES_PASSWORD: aperipass
      POSTGRES_DB: aperisolve
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

5. Modificar aperisolve/config.py
nano config.py

y pega este contenido:

from pathlib import Path

IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff"]

WORKER_FILES = ["binwalk", "foremost", "steghide", "zsteg"]

RESULT_FOLDER = Path(__file__).parent.resolve() / "results"
RESULT_FOLDER.mkdir(parents=True, exist_ok=True)

6. Modificación de aperisolve/app.py

Sustituir la línea: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI")
por:
default_db = "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI", default_db)

7. Construir la imagen
docker build -t aperisolve-local .

8. Levantar los contenedores
docker compose down
docker compose up -d

9. Comprobar logs
docker logs aperisolve-web --tail=50
docker logs aperisolve-worker --tail=50

10. Acceder a la web
 - Desde cualquier máquina de la red local: http://IP-DE-LA-MAQUINA:5000
 - Desde la Raspi: http://localhost:5000

11. Limpieza (cuando necesites)
 - Reiniciar contenedores:
docker compose restart
 - Borrar resultados antiguos:
sudo rm -r aperisolve/results/*

Introducción

Continuamos con la segunda entrega de Cruehead. En este caso nos encontramos con un único campo de contraseña para introducir.

El algoritmo

Abrimos con Olly y vemos dos saltos. El primer Call realiza una serie de operaciones con el serial introducido y el segundo comprueba si el serial es correcto.

01

A continuación llegamos aquí:

00401365     /$  C605 18214000 00         MOV BYTE PTR DS:[402118],0
0040136C     |.  8B7424 04                MOV ESI,DWORD PTR SS:[ESP+4]
00401370     |.  56                       PUSH ESI
00401371     |>  8A06                     /MOV AL,BYTE PTR DS:[ESI]      ; <---
00401373     |.  84C0                     |TEST AL,AL
00401375     |.  74 19                    |JE SHORT CRACKME2.00401390
00401377     |.  FE05 18214000            |INC BYTE PTR DS:[402118]
0040137D     |.  3C 41                    |CMP AL,41                     ; 41 = A
0040137F     |.  72 04                    |JB SHORT CRACKME2.00401385    ; ya es mayúscula
00401381     |.  3C 5A                    |CMP AL,5A                     ; 5A = Z
00401383     |.  73 03                    |JNB SHORT CRACKME2.00401388   ; Convertir a mayúscula
00401385     |>  46                       |INC ESI
00401386     |.^ EB E9                    |JMP SHORT CRACKME2.00401371   ; Bucle -->
00401388     |>  E8 25000000              |CALL CRACKME2.004013B2
0040138D     |.  46                       |INC ESI
0040138E     |.^ EB E1                    \JMP SHORT CRACKME2.00401371
00401390     |>  5E                       POP ESI
00401391     |.  E8 03000000              CALL CRACKME2.00401399         ;Convertido a mayúsculas continuamos
00401396     |.  EB 00                    JMP SHORT CRACKME2.00401398
00401398     \>  C3                       RETN

Si nuestro serial contiene solo letras, las convierte a mayúsculas y seguimos aquí. En resumen hace XOR byte a byte entre nuestro serial y la frase «Messing_in_bytes»

00401399     /$  33DB                     XOR EBX,EBX
0040139B     |.  33FF                     XOR EDI,EDI
0040139D     |>  8A8F A3214000            /MOV CL,BYTE PTR DS:[EDI+4021A3]  ; Carga el primer byte de 4021A3
004013A3     |.  8A1E                     |MOV BL,BYTE PTR DS:[ESI]         ;
004013A5     |.  84DB                     |TEST BL,BL
004013A7     |.  74 08                    |JE SHORT CRACKME2.004013B1
004013A9     |.  32D9                     |XOR BL,CL                        ; byteSerial XOR Byte"Messing_in..."
004013AB     |.  881E                     |MOV BYTE PTR DS:[ESI],BL
004013AD     |.  46                       |INC ESI                          ;Siguiente byte de "Messing_in_bytes"
004013AE     |.  47                       |INC EDI                          ;Siguiente byte del serial
004013AF     |.^ EB EC                    \JMP SHORT CRACKME2.0040139D
004013B1     \>  C3                       RETN                              ;XOR finalizado volvemos

Estado del DUMP (memoria) antes del XOR y con nuestro serial (12345678) cargado.

00402118  00 47 6F 6F 64 20 77 6F 72 6B 21 00 47 72 65 61  .Good work!.Grea
00402128  74 20 77 6F 72 6B 2C 20 6D 61 74 65 21 0D 4E 6F  t work, mate!.No
00402138  77 20 74 72 79 20 74 68 65 20 6E 65 78 74 20 43  w try the next C
00402148  72 61 63 6B 4D 65 21 00 1F 2C 37 36 3B 3D 28 19  rackMe!.,76;=(
00402158  3D 26 1A 31 2D 3B 37 3E 4E 6F 20 6C 75 63 6B 21  =&1-;7>No luck!
00402168  00 4E 6F 20 6C 75 63 6B 20 74 68 65 72 65 2C 20  .No luck there,
00402178  6D 61 74 65 21 00 31 32 33 34 35 36 37 38 39 00  mate!.123456789.
00402188  00 00 00 00 00 00 00 00 00 00 54 72 79 20 74 6F  ..........Try to
00402198  20 63 72 61 63 6B 20 6D 65 21 00 4D 65 73 73 69   crack me!.Messi
004021A8  6E 67 5F 69 6E 5F 62 79 74 65 73 00 00 00 00 00  ng_in_bytes.....

Estado del DUMP después del XOR.

00402118  0A 47 6F 6F 64 20 77 6F 72 6B 21 00 47 72 65 61  .Good work!.Grea
00402128  74 20 77 6F 72 6B 2C 20 6D 61 74 65 21 0D 4E 6F  t work, mate!.No
00402138  77 20 74 72 79 20 74 68 65 20 6E 65 78 74 20 43  w try the next C
00402148  72 61 63 6B 4D 65 21 00 1F 2C 37 36 3B 3D 28 19  rackMe!.,76;=(
00402158  3D 26 1A 31 2D 3B 37 3E 4E 6F 20 6C 75 63 6B 21  =&1-;7>No luck!
00402168  00 4E 6F 20 6C 75 63 6B 20 74 68 65 72 65 2C 20  .No luck there,
00402178  6D 61 74 65 21 00 7C 57 40 47 5C 58 50 67 50 5E  mate!.|W@G\XPgP^
00402188  00 00 00 00 00 00 00 00 00 00 54 72 79 20 74 6F  ..........Try to
00402198  20 63 72 61 63 6B 20 6D 65 21 00 4D 65 73 73 69   crack me!.Messi
004021A8  6E 67 5F 69 6E 5F 62 79 74 65 73                 ng_in_bytes

A continuación comprueba nuestro serial XOReado con los bytes en memoria.

004013B8     /$  33FF                     XOR EDI,EDI
004013BA     |.  33C9                     XOR ECX,ECX
004013BC     |.  8A0D 18214000            MOV CL,BYTE PTR DS:[402118]                                
004013C2     |.  8B7424 04                MOV ESI,DWORD PTR SS:[ESP+4]                    ; APUNTA AL DUMP 40217E
004013C6     |.  BF 50214000              MOV EDI,CRACKME2.00402150                       ; APUNTA AL DUMP 402150
004013CB     |.  F3:A6                    REPE CMPS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]   ; VER NOTA**
004013CD     \.  C3                       RETN

Nota**

Si buscamos el comando REPE encontramos que si el flag Z = 1 el bucle se corta y que trabaja con bytes. El problema es que en Olly la instrucción REPE nosotros la vemos con un solo paso y nos puede pasar desapercibida.
En resumen, está comprobando los bytes de las direcciones 402150 (1F 2C 37 36 3B 3D 28 19 3D 26 1A 31 2D 3B 37 3E) con nuestro serial XOReado, 40217E en adelante, por lo que si hacemos XOR entre los bytes de 402150 y la frase «Messing_in_bytes» obtendremos la clave correcta.

M  e  s  s  i  n  g  _  i  n  _  b  y  t  e  s
4D 65 73 73 69 6E 67 5F 69 6E 5F 62 79 74 65 73
                                                XOR
1F 2C 37 36 3B 3D 28 19 3D 26 1A 31 2D 3B 37 3E
-----------------------------------------------
52 49 44 45 52 53 4F 46 54 48 45 53 54 4F 52 4D
R  I  D  E  R  S  O  F  T  H  E  S  T  O  R  M

Serial: RIDERSOFTHESTORM

Links


Warning: This challenge is still active and therefore should not be resolved using this information.  Aviso: Este reto sigue en
Introducción Hoy tenemos aquí un crackme hecho en Visual Basic 6 (pcode), pero lo vamos a abordar de una manera
Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en
Intro Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir

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.

Introducción

 Realistic Challenge 1: Your friend tried to purchase some software off a company. But after he paid they decided to increase it’s price by a large amount. They are now refusing to send it him. Get them back by getting their most expensive software a lot cheaper than they intended you to.
Lo que nos dice el enunciado del reto a groso modo es que debemos cambiar el precio del software antes de comprarlo.

Firebug

 Para resolver este reto basta con tener instalado el complemento para Firefox «Firebug«. Abrimos la web y echamos un vistazo con Firebug
Vemos un parámetro oculto que se llama «amount» y que tiene un valor de 100$. Basta con cambiarlo a 00,01$ y ya tenemos resuelto el reto.

Links

Introducción

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.

29-08-2014 20-30-08

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á entre 70 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.

29-08-2014 22-49-22

En este caso el único problema se encuentra en la función checkcode en concreto en ésta línea:

var_94 = Int(((var_128 / CVar(Len(a) / CVar(Len(a)))))

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

29-08-2014 20-28-53

En crackmes.de podéis conseguir el crackme y el keygen.

Links


Intro Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma
Introducción Este es un crackme de la web de Karpoff programado por Sotanez y realizado en Delphi. Como máximo nos
Introducción Esta es la primera entrega de tres en las que vamos a  ver tres crackmes que todo reverser debería
Introducción Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por

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.

Introducció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.

/challenges/crypt/xor/0_chall_very_easy

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

challenges_crypt_xor_0_chall_very_easy

/challenges/crypt/xor/1_chall_easy

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));
?>

challenges_crypt_xor_1_chall_easy

/challenges/crypt/xor/2_chall_mid

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();
?>
  • Lo primero es mediante un compilador online de PHP, obtener la variable $key.
  • Decodificar la clave xoreada «ucSnos+lo8Oqtw==«.
  • Solución = base64_decode(«ucSnos+lo8Oqtw==») XOR $key

Venga que casi lo tienes.

/challenges/crypt/xor/3_chall_average

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;5rmnr85pp81<$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>$#xyk]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"56mrlomtrr 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

challenges_crypt_xor_3_chall_average

/challenges/crypt/xor/4_chall_hard

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.

challenges_crypt_xor_4_chall_hard_02

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.

crypt_xor_4_chall_hard_2

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.

crypt_xor_4_chall_hard_3

Enlaces

Introducción

Esta vez se trata de un crackme realizado en VC++ 5.0/6.0 y en sus entrañas utiliza RSA-24. En este caso la peculiaridad es que el nombre no interviene en la generación del serial siendo un resultado único.

Resumen RSA

Parámetros

p = Primer número primo
q = Segundo número primo
e = Exponente público que cumpla MCD(e,(p-1)*(q-1))==1
n = Módulo público siendo n=p*q
d = Exponente privado que cumpla d=e^(-1) mod ((p-1)*(q-1))

De este modo e y n son la parte pública de la clave y d y n la parte privada. Los número primos p y q se utilizan solo para generar los parámetros y de ahí en adelante se pueden desechar.

Funciones de Cifrado/Descifrado

cifrado = descifrado ^ e mod n
descifrado = cifrado ^ d mod n

OllyDbg

Nuestro primer vistazo con OllyDbg nos muestra cuatro números de los que podemos hacernos una idea de que 9901 es un buen candidato a ser el exponente público (e) y 12790891 el módulo n ya que casualmente es un número de 24 bits. Los otros dos números de momento no nos dicen nada.

Referencias de texto

A continuación de los números tenemos la rutina de comprobación en la que comprueba que nuestro serial tenga 14 dígitos y lo divide en dos partes de 7 dígitos. Interesante ya que los otros dos números que aparecían en las referencias de texto tienen 7 dígitos cada uno.

004029CD  |.  68 DC004200   PUSH    RSA24.004200DC                         ;  ASCII "9901"
004029D2  |.  8D8C24 E40000>LEA     ECX,[DWORD SS:ESP+E4]
004029D9  |.  E8 52E7FFFF   CALL    RSA24.00401130
004029DE  |.  68 D0004200   PUSH    RSA24.004200D0                         ;  ASCII "12790891"
004029E3  |.  8D4C24 1C     LEA     ECX,[DWORD SS:ESP+1C]
004029E7  |.  C78424 640600>MOV     [DWORD SS:ESP+664],0
004029F2  |.  E8 39E7FFFF   CALL    RSA24.00401130
004029F7  |.  68 C8004200   PUSH    RSA24.004200C8                         ;  ASCII "8483678"
004029FC  |.  8D8C24 740200>LEA     ECX,[DWORD SS:ESP+274]
00402A03  |.  C68424 640600>MOV     [BYTE SS:ESP+664],1
00402A0B  |.  E8 20E7FFFF   CALL    RSA24.00401130
00402A10  |.  68 C0004200   PUSH    RSA24.004200C0                         ;  ASCII "5666933"
00402A15  |.  8D8C24 AC0100>LEA     ECX,[DWORD SS:ESP+1AC]
00402A1C  |.  C68424 640600>MOV     [BYTE SS:ESP+664],2
00402A24  |.  E8 07E7FFFF   CALL    RSA24.00401130
00402A29  |.  8B9424 680600>MOV     EDX,[DWORD SS:ESP+668]
00402A30  |.  83CE FF       OR      ESI,FFFFFFFF
00402A33  |.  8BFA          MOV     EDI,EDX
00402A35  |.  8BCE          MOV     ECX,ESI
00402A37  |.  33C0          XOR     EAX,EAX
00402A39  |.  C68424 600600>MOV     [BYTE SS:ESP+660],3
00402A41  |.  F2:AE         REPNE   SCAS [BYTE ES:EDI]
00402A43  |.  F7D1          NOT     ECX
00402A45  |.  49            DEC     ECX
00402A46  |.  83F9 0E       CMP     ECX,0E                                 ;  serial 0xE chars -> 14 digitos
00402A49  |.  0F85 63010000 JNZ     RSA24.00402BB2
00402A4F  |.  33C9          XOR     ECX,ECX
00402A51  |>  8A0411        /MOV     AL,[BYTE DS:ECX+EDX]                  ;  {
00402A54  |.  3C 30         |CMP     AL,30
00402A56  |.  0F8C 56010000 |JL      RSA24.00402BB2
00402A5C  |.  3C 39         |CMP     AL,39                                 ;  comprueba que el serial sea numerico
00402A5E  |.  0F8F 4E010000 |JG      RSA24.00402BB2
00402A64  |.  41            |INC     ECX
00402A65  |.  83F9 0E       |CMP     ECX,0E
00402A68  |.^ 7C E7         \JL      SHORT RSA24.00402A51                  ;  }
00402A6A  |.  8BC2          MOV     EAX,EDX
00402A6C  |.  C64424 17 00  MOV     [BYTE SS:ESP+17],0                     ;  {
00402A71  |.  C64424 0F 00  MOV     [BYTE SS:ESP+F],0
00402A76  |.  8B08          MOV     ECX,[DWORD DS:EAX]
00402A78  |.  894C24 10     MOV     [DWORD SS:ESP+10],ECX
00402A7C  |.  66:8B48 04    MOV     CX,[WORD DS:EAX+4]
00402A80  |.  66:894C24 14  MOV     [WORD SS:ESP+14],CX
00402A85  |.  8B4A 07       MOV     ECX,[DWORD DS:EDX+7]
00402A88  |.  8A40 06       MOV     AL,[BYTE DS:EAX+6]                     ;  divide el serial en dos partes de 7 digitos
00402A8B  |.  894C24 08     MOV     [DWORD SS:ESP+8],ECX
00402A8F  |.  884424 16     MOV     [BYTE SS:ESP+16],AL
00402A93  |.  8D42 07       LEA     EAX,[DWORD DS:EDX+7]
00402A96  |.  8D4C24 10     LEA     ECX,[DWORD SS:ESP+10]
00402A9A  |.  66:8B50 04    MOV     DX,[WORD DS:EAX+4]
00402A9E  |.  8A40 06       MOV     AL,[BYTE DS:EAX+6]                     ;  }

A continuación hace una serie de operaciones matemáticas para finalmente comparar el resultado con 8483678 y con 5666933. Lo que está haciendo es cifrar con nuestro serial en dos partes para comprobar que tenemos el número descifrado. Veamos un ejemplo con el serial 12345678901234.

descifrado ^ e mod n = cifrado
x1 = 1234567 y x2 = 8901234
1º parte del serial
x1 ^ 9901 mod 12790891 != 8483678
2º parte del serial
x2 ^ 9901 mod 12790891 != 5666933

Obviamente el resultado de las operaciones anteriores no da ese resultado y el Crackme nos tira fuera de modo que no nos queda más que atacar a RSA para obtener los primos p y q y el módulo privado d. De este modo podremos obtener los números buenos.

Los primos p y q se obtienen factorizando (botón Factor N) y una vez que tenemos p y q hallamos d (botón Calc. D). Todo esto es coser y cantar con la ayuda de la herramienta RSA-Tool 2. El exponente público e se introduce en hexadecimal.

Obteniendo p, q y d

Una vez que tenemos d hallamos el serial de forma sencilla con la herramienta Big Integer Calculator.

cifrado ^ d mod n = descifrado
1º parte del serial
8483678 ^ 10961333 mod 12790891 = 7167622
2º parte del serial
5666933 ^ 10961333 mod 12790891 = 3196885

SERIAL = 71676223196885
1º parte del serial
2º parte del serial

Enlaces

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

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

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

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

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

import numpy as np
from PIL import Image

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

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

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

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

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

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

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

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

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

Rebuscando entre todo el caos que puede llegar a ser mi disco duro, he encontrado una serie de programas que utilizaba antiguamente cuando empezó a interesarme el Cracking. Ya sabéis que no soy partidario de crackear programas comerciales pero hoy voy a hacer una excepción ya que la versión del programa es muy vieja (1997) e incluso podría considerarse abandonware.

Este ejercicio es ideal para los que están empezando ya que es fácil localizar donde está el algoritmo y éste es sumamente sencillo.

Table of Contents

Algoritmo

Address   Hex dump          Command                                      Comments
00402213    E8 78170000     CALL HEdit.00403990
........
004039C0    8BC1            MOV EAX,ECX
004039C2    99              CDQ
004039C3    33C2            XOR EAX,EDX
004039C5    2BC2            SUB EAX,EDX
004039C7    83E0 03         AND EAX,00000003
004039CA    33C2            XOR EAX,EDX
004039CC    2BC2            SUB EAX,EDX
004039CE    8A540C 04       MOV DL,BYTE PTR SS:[ECX+ESP+4]  ;Coge el dígito i*3
004039D2    8A5C04 04       MOV BL,BYTE PTR SS:[EAX+ESP+4]  ;Coge el dígito i
004039D6    8D4404 04       LEA EAX,[EAX+ESP+4]             ;Guarda en memoria 12EE90
004039DA    32DA            XOR BL,DL
004039DC    41              INC ECX                         ; i +=1
004039DD    81F9 00010000   CMP ECX,100                     ;El bucle se repite 256 veces (0x100)
004039E3    8818            MOV BYTE PTR DS:[EAX],BL
004039E5  ^ 7C D9           JL SHORT HEdit.004039C0
004039E7    8B4424 04       MOV EAX,DWORD PTR SS:[ESP+4]
004039EB    85C0            TEST EAX,EAX                    ;Comprueba que el serial no sea 0
004039ED    7D 02           JGE SHORT HEdit.004039F1        ;Si es 0 se acabó
004039EF    F7D8            NEG EAX
004039F1    3B8424 0C010000 CMP EAX,DWORD PTR SS:[ESP+10C]  ;Comprobación de serial válido
004039F8    75 13           JNE SHORT HEdit.00403A0D        ;Si no es igual bad boy
004039FA    85C0            TEST EAX,EAX                    ;Comprueba que el serial no sea 0
004039FC    74 0F           JE SHORT HEdit.00403A0D         ;Si es 0 se acabó
004039FE    B8 01000000     MOV EAX,1
00403A03    5B              POP EBX
00403A04    81C4 00010000   ADD ESP,100
00403A0A    C2 0800         RETN 8

En resumen hace esto:

- Nombre introducido: deurus
- Convierte el nombre a mayúsculas

D  E  U  R  U  S
44 45 55 52 55 53 (En Hexadecimal)

1) 55 xor 44 = 11
2) 53 xor 45 = 16
3) 00 xor 55 = 55
4) 00 xor 52 = 52
   --------------- solo vale hasta aquí EAX(32 bits)
5) 00 xor 55 = 55
6) 00 xor 53 = 53
7) 00 xor 00 = 00
8) ...
            HEX         DEC
Serial = 52551611 = 1381307921

Como veis, realiza un bucle 256 veces pero como al final utiliza el registro EAX para hacer la comparación, solamente nos sirven las cuatro primeras operaciones. De hecho, no comprueba ni la longitud del nombre por lo que si introducimos un solo dígito como nombre, el serial será el valor ascii de ese dígito en decimal. La única comprobación que realiza es que el serial no sea 0.

Keygen

Os dejo una prueba de concepto en Javascript.

var nombre = "deurus";
nombre = nombre.toUpperCase();
var serial = "";

serial = serial + nombre.charCodeAt(3).toString(16) + nombre.charCodeAt(2).toString(16);
serial = serial + (nombre.charCodeAt(5) ^ nombre.charCodeAt(1)).toString(16);
serial = serial + (nombre.charCodeAt(2) ^ nombre.charCodeAt(0)).toString(16);
serial = "Nº Serie: " + parseInt(serial,16);

document.write(serial);

Enlaces

Yuri Software