Etiqueta: piratas

Blooper Tech Movie II – Hackers

25 noviembre, 2015 por deurus·Sin comentarios

En esta ocasión vamos a hablar de una película de culto de los años 90, Hackers – Piratas Informáticos. La verdad es que aunque puede ser entretenida, tecnológicamente es una pesadilla y es que esta película es un claro ejemplo de cuando Hollywood prefiere agradar visualmente a representar escenas realistas.

Tras cuatro minutos en los que se nos presenta a Dade (Jonny Lee Miller) y sus problemas con la ley a una temprana edad, saltamos unos años después hasta ver a Dade encerrado en su habitación volviendo a las andadas intentando acceder ilegítimamente a los servidores de una cadena de televisión. Para ello hace uso de algo muy conocido en el mundillo Hacker, la Ingeniería Social, y es que aunque ahora disponemos de «cierta» conciencia en seguridad informática, en los años 90 no había ninguna. Bien, el caso es que Dade llama a las oficinas de la citada cadena de televisión a una hora en la que no hay más que el vigilante de seguridad y éste le proporciona un número que debemos suponer que es la IP de un Módem y comienza la intrusión.

BTM

Para empezar, se le ve al protagonista escribir comandos cuando en la pantalla no hay más que una animación en algo parecido a una ventana de terminal al estilo «Commander», pero no vemos lo que escribe, algo irreal.

A continuación y como por arte de magia entra en el sistema y lo que se muestra es una animación parpadeante con el logo de la compañia y el nombre del sistema al que estamos accediendo, también irreal.

Finalmente nos muestra sus intenciones, y son nada más y nada menos que cambiar la programación actual simplemente cambiando de VHS, inmejorable. A continuación os muestro la secuencia.

Por lo menos nos queda el consuelo de que cambia la tertulia de un tipejo con ciertos prejuicios raciales por una programación más interesante como «The Outer limits«, aquí conocida como «Más allá del límite«.

El resto de escenas informáticas de la película carecen de veracidad, la única que se salva, puede ser cuando accede al servidor del Instituto para programar el sistema contra incendios y vengarse de Kate (Angelina Jolie), ya que las imágenes que aparecen son de los primeros entornos gráficos de Mac.

Es extraño que casi todas las intrusiones las realiza desde su propia casa, algo poco inteligente, ya que por muy bueno que seas, siempre dejas huellas. Solo cuando se enfrentan a un Super-Hacker se empiezan a tomar las cosas en serio y realizan los ataques desde cabinas telefónicas.

En la película También hacen mención al Phreaking y a algunos de los libros que eran famosos por aquella época pero poco más que destacar. Por todo esto y mucho más, y aunque me caen igual de bien tanto Angelina como Jonny, la película se merece un majestuoso sello de BTM.

Enlaces

Ficha en IMDB

Blooper Tech Movie IV – La Jungla 4.0 (Live Free or Die Hard)

La esperada cuarta entrega de La Jungla de Cristal se metió de lleno en el mundo de los Hackers. Cuando

Wechall Stegano Attachment (Esteganografía)

Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

List of file signatures for file carving

File carving is the process of reassembling computer files from fragments in the absence of filesystem metadata. Wikipedia. "File carving", literalmente tallado

Solución al Crackme RSA (RSA24) de TSC

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

crackmes

24 febrero, 2016 por deurus·Comentarios desactivados

Blooper Tech Movie XIV – Parque Jurásico

27 diciembre, 2025 por deurus·Sin comentarios

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.

Retos stego 1-4 de Challengeland.co

20 junio, 2016 por deurus·Sin comentarios

Table of Contents

Introducción

Hoy vamos a enfrentarnos a cuatro retos de esteganografía relativamente sencillos, y digo relativamente, debido a que hay tantas formas de esconder información en un archivo, ya sea imagen, vídeo o sonido, que afrontarlos suele ser desesperante. Las cuatro imágenes son aparentemente las mismas que la que se ve en portada.

Una buena práctica cuando te enfrentas a retos stego de tipo imagen es realizar una búsqueda inversa. Una búsqueda inversa consiste en buscar la imagen original mediante buscadores especializados como TinEye o Google. Si conseguimos la imagen original podemos resolver el reto simplemente comparando o nos puede dar una idea del tipo de modificación por su diferencia de tamaño, colores, degradados, etc.

Stego 1

Descargamos la imagen del reto. Se trata de una imagen JPEG de 526×263 y 76.6 KB (78445 bytes). Su hash SHA1 es «89aed5bbc3542bf5c60c4c318fe99cb1489f267a«

Realizamos una búsqueda inversa de la imagen y encontramos sin dificultad la imagen original mediante TinEye.

Características de la imagen original:

Resolución: 526×263
Tamaño: 78447 bytes (76.6 KB)
Hash SHA1: 8924676317077fc07c252ddeec04bd2a0ecfdda4

Por lo que vemos ha cambiado el tamaño de 78447 bytes a 78445 bytes y su hash SHA1 tampoco coincide obviamente, lo que nos confirma que ha sufrido alguna modificación. Echando un vistazo con un editor hexadecimal te puedes volver loco por lo que vamos a realizar una comparación mediante la herramienta online DiffNow.

Al realizar la comparación sale a relucir lo que buscamos. La clave es una simple cadena de texto.

Stego 2

Lo primero es realizar de nuevo la comparación.

Imagen	Tamaño	SHA1
Original	78447 bytes	8924676317077fc07c252ddeec04bd2a0ecfdda4
imagen2.jpeg	116386 bytes	7641e3906f795c137269cefef29f30fcb9cb1b07

Como vemos, la imagen ha aumentado significativamente, de 76,6 KB a 113 KB. Cuando el aumento de tamaño llama la atención normalmente tenemos otro archivo insertado. Lo primero que suelo hacer yo es fijarme si ha sido modificado el final del archivo con un editor hexadecimal. Los bytes de cola de un archivo jpg/jpeg son FFD9 y en este caso no vemos modificación alguna al final del archivo. Si el archivo no está al final requiere realizar una búsqueda más exhaustiva. Para estos casos tengo una herramienta de creación propia que se llama Ancillary y que sirve para buscar cierto tipo de archivos dentro de otros como imágenes, documentos de Office, Open Office, pdf, etc. Ancillary encuentra otro jpg que es el que le daba el peso extra y que vemos a continuación. La clave es el título de la película (ojo a las mayúsculas/minúsculas).

Stego 3

El tercer reto parece que tiene algún error debido a que el archivo coincide completamente con el original. Pienso que se ha subido la imagen original por error. Se lo he comunicado al admin del dominio y si algún día obtengo respuesta actualizaré la entrada.

Imagen	Tamaño	SHA1
Original	78447 bytes	8924676317077fc07c252ddeec04bd2a0ecfdda4
imagen3.jpeg	78447 bytes	8924676317077fc07c252ddeec04bd2a0ecfdda4

Actualización 21/08/2016

Al parecer, la solución de este reto es llegar a la conclusión de que la imagen no está modificada. La respuesta del Administrador de la web así lo confirma.

desingsecurity [at] gmail [dot] com – Sorry about the delay, is precisely what is intended with that challenge, they can determine if the image is changed or not , the challenge was solved you . We’ll be equal way improving this point.

Greetings and Thanks

Stego 4

Lo primero es realizar de nuevo la comparación.

Imagen	Tamaño	SHA1
Original	78447 bytes	8924676317077fc07c252ddeec04bd2a0ecfdda4
imagen4.jpeg	93174 bytes	a6329ea4562ef997e5afd067f3b53bdab4665851

Al igual que en el caso dos el tamaño ha aumentado significativamente de modo que miramos al final del archivo y esta vez si vemos que hay insertado unos bytes tras el final del jpg (recordemos FFD9)

El archivo tiene pinta de ser una hoja de cálculo de Open Office o Libre Office según indica la palabra «spreadsheet«. Lo abrimos con Excel y tras analizar la maraña de datos enseguida vemos una clave que llama la atención.

Enlaces

Challengeland (El dominio ya no existe) [Archive]

Herramientas utilizadas

Editor Hexadecimal: HxD Freeware Hex Editor
Búsqueda inversa de imágenes: TinEye | Google
Comparador de archivos online: DiffNow
File Carving Tool: Ancillary.

Solución para el KeygenMe ASM de Flamer

10 febrero, 2016 por deurus·4 comentarios

Intro
Análisis
Keygen
Links

Table of Contents

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

TDC's Remove the NAG - Parche

Intro Es un crackme realizado en ensamblador y en el que el objetivo es remover la NAG de la forma

Migas de pan

Se nos entrega el siguiente ELF: Extracción de la Flag Si nos fijamos en las líneas 41 a la 45

Solución al KeygenMe1 (RSA200) de Dihux

Introducción Funcionamiento de RSA OllyDbg Calculando un serial válido Ejemplo operacional Keygen Links Introducción Empezamos con lo que espero que

CanYouHack.it Crack6 Challenge - Lights Out (English)

Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

1 2 3 … 30 Next »

Solución al KeyGenMe1 (RSA127) de C00lw0lf

16 febrero, 2015 por deurus·Sin comentarios

Introducción
Funcionamiento de RSA
OllyDbg
Calculando la clave privada (d)
Ejemplo operacional
Keygen
Links

Introducción

Segunda crackme con RSA que afrontamos. Esta vez se trata de un crackme realizado en VC++ 7.0 y en sus entrañas utiliza RSA-127. Una cosa que no comenté en la entrega anterior (RSA-200), es que conviene utilizar el plugin Kanal de PEiD para localizar cuando se utilizan números grandes o determinados hashes como MD5 o SHA1.

Otra cosa es que os quería comentar es la coletilla 127. Esta lo determina el módulo n e indica el número de bits de éste.

Funcionamiento de RSA

Inicialmente es necesario generar aleatoriamente dos números primos grandes, a los que llamaremos p y q.
A continuación calcularemos n como producto de p y q:
```
n = p * q
```
Se calcula fi:
```
fi(n)=(p-1)(q-1)
```
Se calcula un número natural e de manera que MCD(e, fi(n))=1 , es decir e debe ser primo relativo de fi(n). Es lo mismo que buscar un numero impar por el que dividir fi(n) que de cero como resto.
Mediante el algoritmo extendido de Euclides se calcula d que es el inverso modular de e.
```
Puede calcularse d=((Y*fi(n))+1)/e para Y=1,2,3,... hasta encontrar un d entero.
```
El par de números (e,n) son la clave pública.
El par de números (d,n) son la clave privada.
Cifrado: La función de cifrado es.
```
c = m^e mod n
```
Descifrado: La función de descifrado es.
```
m = c^d mod n
```

OllyDbg

Con OllyDbg analizamos la parte del código que nos interesa.

0040109B    .  68 00010000         PUSH 100                                  ; /Count = 100 (256.)
004010A0    .  52                  PUSH EDX                                  ; |Buffer = RSA127.<ModuleEntryPoint>
004010A1    .  68 EA030000         PUSH 3EA                                  ; |ControlID = 3EA (1002.)
004010A6    .  8B8C24 28020000     MOV ECX,DWORD PTR SS:[ESP+228]            ; |
004010AD    .  51                  PUSH ECX                                  ; |hWnd = NULL
004010AE    .  FF15 F0B04000       CALL DWORD PTR DS:[<&USER32.GetDlgItemTex>; \GetDlgItemTextA
004010B4    .  8D5424 04           LEA EDX,DWORD PTR SS:[ESP+4]
004010B8    .  57                  PUSH EDI
004010B9    .  52                  PUSH EDX                                  ;  RSA127.<ModuleEntryPoint>
004010BA    .  50                  PUSH EAX                                  ;  kernel32.BaseThreadInitThunk
004010BB    .  E8 201E0000         CALL RSA127.00402EE0
004010C0    .  83C4 0C             ADD ESP,0C
004010C3    .  8D9424 04010000     LEA EDX,DWORD PTR SS:[ESP+104]
004010CA    .  68 00010000         PUSH 100                                  ; /Count = 100 (256.)
004010CF    .  52                  PUSH EDX                                  ; |Buffer = RSA127.<ModuleEntryPoint>
004010D0    .  68 EB030000         PUSH 3EB                                  ; |ControlID = 3EB (1003.)
004010D5    .  8B8C24 28020000     MOV ECX,DWORD PTR SS:[ESP+228]            ; |
004010DC    .  51                  PUSH ECX                                  ; |hWnd = NULL
004010DD    .  FF15 F0B04000       CALL DWORD PTR DS:[<&USER32.GetDlgItemTex>; \GetDlgItemTextA
004010E3    .  8D9424 04010000     LEA EDX,DWORD PTR SS:[ESP+104]
004010EA    .  52                  PUSH EDX                                  ;  RSA127.<ModuleEntryPoint>
004010EB    .  8B4C24 04           MOV ECX,DWORD PTR SS:[ESP+4]
004010EF    .  51                  PUSH ECX
004010F0    .  E8 5B1F0000         CALL RSA127.00403050
004010F5    .  68 08B14000         PUSH RSA127.0040B108                      ;  ASCII "666AAA422FDF79E1D4E41EDDC4D42C51"
004010FA    .  55                  PUSH EBP
004010FB    .  E8 501F0000         CALL RSA127.00403050
00401100    .  68 2CB14000         PUSH RSA127.0040B12C                      ;  ASCII "29F8EEDBC262484C2E3F60952B73D067"
00401105    .  56                  PUSH ESI
00401106    .  E8 451F0000         CALL RSA127.00403050
0040110B    .  53                  PUSH EBX
0040110C    .  55                  PUSH EBP
0040110D    .  56                  PUSH ESI
0040110E    .  8B5424 24           MOV EDX,DWORD PTR SS:[ESP+24]
00401112    .  52                  PUSH EDX                                  ;  RSA127.<ModuleEntryPoint>
00401113    .  E8 38250000         CALL RSA127.00403650
00401118    .  53                  PUSH EBX
00401119    .  57                  PUSH EDI
0040111A    .  E8 31130000         CALL RSA127.00402450
0040111F    .  83C4 30             ADD ESP,30
00401122    .  85C0                TEST EAX,EAX                              ;  kernel32.BaseThreadInitThunk
00401124    .  74 12               JE SHORT RSA127.00401138
00401126    .  B8 01000000         MOV EAX,1
0040112B    .  81C4 08020000       ADD ESP,208
00401131    .  5B                  POP EBX                                   ;  kernel32.7590EE1C
00401132    .  5D                  POP EBP                                   ;  kernel32.7590EE1C
00401133    .  5E                  POP ESI                                   ;  kernel32.7590EE1C
00401134    .  5F                  POP EDI                                   ;  kernel32.7590EE1C
00401135    .  C2 1000             RETN 10
00401138    >  6A 40               PUSH 40                                   ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
0040113A    .  68 5CB14000         PUSH RSA127.0040B15C                      ; |Title = "Yeah!"
0040113F    .  68 50B14000         PUSH RSA127.0040B150                      ; |Text = "Nice job!!!"
00401144    .  6A 00               PUSH 0                                    ; |hOwner = NULL
00401146    .  FF15 F4B04000       CALL DWORD PTR DS:[<&USER32.MessageBoxA>] ; \MessageBoxA

El código nos proporciona el exponente público (e) y el módulo (n).

e = 29F8EEDBC262484C2E3F60952B73D067
n = 666AAA422FDF79E1D4E41EDDC4D42C51

Finalmente realiza un PowMod con el número de serie del disco C y el par de claves (e,n).

Calculando la clave privada (d)

Una vez localizados los datos anteriores lo siguiente es factorizar para obtener los primos p y q y finalmente d.

d = 65537

Ejemplo operacional

Nº serie disco C = -1295811883
Serial = hdd.getBytes()^d mod n
Serial = 2d31323935383131383833^65537 mod 666AAA422FDF79E1D4E41EDDC4D42C51
Serial = 1698B6CE6BE0D388C31E8E7895AF445A

Keygen

El keygen está hecho en Java ya que permite trabajar con números grandes de forma sencilla.

JButton btnNewButton = new JButton("Generar");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                BigInteger serial = new BigInteger("0");
                BigInteger n = new BigInteger("136135092290573418981810449482425576529");
                BigInteger d = new BigInteger("415031");
                String hdd = t1.getText();
                BigInteger tmp = new BigInteger(hdd.getBytes());
                serial = tmp.modPow(d, n);
                t2.setText(serial.toString(16).toUpperCase());
            }
        });

QR Stego Challenge

15 septiembre, 2018 por deurus·Sin comentarios

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece.

Ya sabéis que los retos stego son muy variopintos. El otro día me encontré con uno que parecía que iba a ser complejo pero en realidad era bastante sencillo.

Tras varias pruebas complejas infructuosas, se me ocurrió descomponer por canales y efectivamente ese era el camino. Para ello yo utilicé la herramienta StegSolve de mi querido Caesum, pero podéis resolverlo incluso online con Pinetools.

Solución al CrackMe Matrix de ZemoZ

19 agosto, 2020 por deurus·Sin comentarios

Table of Contents

Introducción

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.

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.

Enlaces

CrackMe

AfKayAs’s CrackMe#2 KeyGen

13 septiembre, 2014 por deurus·Sin comentarios

Intro

Hoy vamos a desmitificar un poco a Visual Basic. El Crackme reza que acabemos con la nag y hagamos un keygen.

La NAG

Lo primero que debemos establecer es a que tipo de Nag nos estamos enfrentando, si es una MessageBox, se localiza y se parchea, si es un formulario la cosa ya cambia un poco, ya que encontrar esa parte del código puede resultar tedioso.

Yo voy a utilizar el camino fácil. En VB contamos con una estupenda herramienta como es VBReformer, que nos muestra las entrañas del crackme y nos posibilita cambiar ciertos parametros.

Abrimos el crackme con VBReformer y vemos su contenido. Localizamos rápidamente el formulario que aparece inicialmente (CMSplash) y el temporizador que contiene (Timer1). Inicialmente el timer tiene un interval de 7000, es decir, la nag se muestra durante 7 segundos. Es tan sencillo como cambiarlo por 1 y guardar el ejecutable (File > Save binary as).

Si no disponemos de esta estupenda herramienta, siempre podemos localizar el timer con un editor hexadecimal. Localizamos en Olly el nombre del timer (en las string references lo veréis), y lo buscamos en el editor hexadecimal. La duración de la nag la debemos estimar nosotros y a continuación buscar ese valor hexadecimal. Imaginemos que estimamos que son 7 segundos, lo pasamos a milisegundos y a hexadecimal. 7000 = 0x1B58. Buscamos en el editor hexadecimal «Timer1» y a continuación localizamos el valor 1B58 invertido, es decir, 581B. En las imágenes inferiores se ve claro.

Cambiando el valor ya lo tendriámos.

El algoritmo

El algoritmo de este crackme es muy sencillo pero he elegido este en concreto para que veáis las vueltas que da VB para hacer 6 operaciones matemáticas. A continuación tenéis el código íntegro comentado y debajo el resumen.

004081F5      .  FF15 F8B04000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]    ;  MSVBVM50.__vbaLenBstr
004081FB      .  8BF8                     MOV EDI,EAX
004081FD      .  8B4D E8                  MOV ECX,DWORD PTR SS:[EBP-18]
00408200      .  69FF 385B0100            IMUL EDI,EDI,15B38                              ;  TEMP = Len(nombre) *15B38
00408206      .  51                       PUSH ECX
00408207      .  0F80 B7050000            JO CrackmeV.004087C4
0040820D      .  FF15 0CB14000            CALL DWORD PTR DS:[<&MSVBVM50.#516>]            ;  MSVBVM50.rtcAnsiValueBstr
00408213      .  0FBFD0                   MOVSX EDX,AX                                    ;  digito a ax
00408216      .  03FA                     ADD EDI,EDX                                     ;  TEMP +=1digito
00408218      .  0F80 A6050000            JO CrackmeV.004087C4
0040821E      .  57                       PUSH EDI                                        ;  MSVBVM50.__vbaObjSet
0040821F      .  FF15 F4B04000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrI4>]      ;  MSVBVM50.__vbaStrI4
00408225      .  8BD0                     MOV EDX,EAX
00408227      .  8D4D E0                  LEA ECX,DWORD PTR SS:[EBP-20]
0040822A      .  FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408230      .  8BBD 50FFFFFF            MOV EDI,DWORD PTR SS:[EBP-B0]
00408236      .  50                       PUSH EAX
00408237      .  57                       PUSH EDI                                        ;  MSVBVM50.__vbaObjSet
00408238      .  FF93 A4000000            CALL DWORD PTR DS:[EBX+A4]                      ;  MSVBVM50.0F050D32
0040823E      .  85C0                     TEST EAX,EAX
00408240      .  7D 12                    JGE SHORT CrackmeV.00408254
00408242      .  68 A4000000              PUSH 0A4
00408247      .  68 AC6F4000              PUSH CrackmeV.00406FAC
0040824C      .  57                       PUSH EDI                                        ;  MSVBVM50.__vbaObjSet
0040824D      .  50                       PUSH EAX
0040824E      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
00408254      >  8D45 E0                  LEA EAX,DWORD PTR SS:[EBP-20]
00408257      .  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
0040825A      .  50                       PUSH EAX
0040825B      .  8D55 E8                  LEA EDX,DWORD PTR SS:[EBP-18]
0040825E      .  51                       PUSH ECX
0040825F      .  52                       PUSH EDX
00408260      .  6A 03                    PUSH 3
00408262      .  FF15 80B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>;  MSVBVM50.__vbaFreeStrList
00408268      .  83C4 10                  ADD ESP,10
0040826B      .  8D45 D4                  LEA EAX,DWORD PTR SS:[EBP-2C]
0040826E      .  8D4D D8                  LEA ECX,DWORD PTR SS:[EBP-28]
00408271      .  8D55 DC                  LEA EDX,DWORD PTR SS:[EBP-24]
00408274      .  50                       PUSH EAX
00408275      .  51                       PUSH ECX
00408276      .  52                       PUSH EDX
00408277      .  6A 03                    PUSH 3
00408279      .  FF15 08B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>;  MSVBVM50.__vbaFreeObjList
0040827F      .  8B9D 40FFFFFF            MOV EBX,DWORD PTR SS:[EBP-C0]                   ;  CrackmeV.00409A68
00408285      .  83C4 10                  ADD ESP,10
00408288      .  8B83 FC020000            MOV EAX,DWORD PTR DS:[EBX+2FC]
0040828E      .  56                       PUSH ESI
0040828F      .  8985 38FFFFFF            MOV DWORD PTR SS:[EBP-C8],EAX
00408295      .  FFD0                     CALL EAX
00408297      .  8B3D 20B14000            MOV EDI,DWORD PTR DS:[<&MSVBVM50.__vbaObjSet>]  ;  MSVBVM50.__vbaObjSet
0040829D      .  50                       PUSH EAX
0040829E      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
004082A1      .  50                       PUSH EAX
004082A2      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet; <&MSVBVM50.__vbaObjSet>
004082A4      .  56                       PUSH ESI
004082A5      .  8985 58FFFFFF            MOV DWORD PTR SS:[EBP-A8],EAX
004082AB      .  FF93 08030000            CALL DWORD PTR DS:[EBX+308]
004082B1      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
004082B4      .  50                       PUSH EAX
004082B5      .  51                       PUSH ECX
004082B6      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004082B8      .  8BD8                     MOV EBX,EAX
004082BA      .  8D45 E8                  LEA EAX,DWORD PTR SS:[EBP-18]
004082BD      .  50                       PUSH EAX
004082BE      .  53                       PUSH EBX
004082BF      .  8B13                     MOV EDX,DWORD PTR DS:[EBX]                      ;  MSVBVM50.0F025A95
004082C1      .  FF92 A0000000            CALL DWORD PTR DS:[EDX+A0]
004082C7      .  85C0                     TEST EAX,EAX
004082C9      .  7D 12                    JGE SHORT CrackmeV.004082DD
004082CB      .  68 A0000000              PUSH 0A0
004082D0      .  68 AC6F4000              PUSH CrackmeV.00406FAC
004082D5      .  53                       PUSH EBX
004082D6      .  50                       PUSH EAX
004082D7      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
004082DD      >  8B8D 58FFFFFF            MOV ECX,DWORD PTR SS:[EBP-A8]
004082E3      .  8B55 E8                  MOV EDX,DWORD PTR SS:[EBP-18]
004082E6      .  52                       PUSH EDX
004082E7      .  8B19                     MOV EBX,DWORD PTR DS:[ECX]
004082E9      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004082EF      .  D905 08104000            FLD DWORD PTR DS:[401008]
004082F5      .  833D 00904000 00         CMP DWORD PTR DS:[409000],0
004082FC      .  75 08                    JNZ SHORT CrackmeV.00408306
004082FE      .  D835 0C104000            FDIV DWORD PTR DS:[40100C]                      ;  10 / 5 = 2
00408304      .  EB 0B                    JMP SHORT CrackmeV.00408311
00408306      >  FF35 0C104000            PUSH DWORD PTR DS:[40100C]
0040830C      .  E8 578DFFFF              CALL <JMP.&MSVBVM50._adj_fdiv_m32>
00408311      >  83EC 08                  SUB ESP,8
00408314      .  DFE0                     FSTSW AX
00408316      .  A8 0D                    TEST AL,0D
00408318      .  0F85 A1040000            JNZ CrackmeV.004087BF
0040831E      .  DEC1                     FADDP ST(1),ST                                  ;  TEMP +=2
00408320      .  DFE0                     FSTSW AX
00408322      .  A8 0D                    TEST AL,0D
00408324      .  0F85 95040000            JNZ CrackmeV.004087BF
0040832A      .  DD1C24                   FSTP QWORD PTR SS:[ESP]
0040832D      .  FF15 48B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>]      ;  MSVBVM50.__vbaStrR8
00408333      .  8BD0                     MOV EDX,EAX
00408335      .  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
00408338      .  FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
0040833E      .  899D 34FFFFFF            MOV DWORD PTR SS:[EBP-CC],EBX
00408344      .  8B9D 58FFFFFF            MOV EBX,DWORD PTR SS:[EBP-A8]
0040834A      .  50                       PUSH EAX
0040834B      .  8B85 34FFFFFF            MOV EAX,DWORD PTR SS:[EBP-CC]
00408351      .  53                       PUSH EBX
00408352      .  FF90 A4000000            CALL DWORD PTR DS:[EAX+A4]
00408358      .  85C0                     TEST EAX,EAX
0040835A      .  7D 12                    JGE SHORT CrackmeV.0040836E
0040835C      .  68 A4000000              PUSH 0A4
00408361      .  68 AC6F4000              PUSH CrackmeV.00406FAC
00408366      .  53                       PUSH EBX
00408367      .  50                       PUSH EAX
00408368      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
0040836E      >  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
00408371      .  8D55 E8                  LEA EDX,DWORD PTR SS:[EBP-18]
00408374      .  51                       PUSH ECX
00408375      .  52                       PUSH EDX
00408376      .  6A 02                    PUSH 2
00408378      .  FF15 80B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>;  MSVBVM50.__vbaFreeStrList
0040837E      .  83C4 0C                  ADD ESP,0C
00408381      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
00408384      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
00408387      .  50                       PUSH EAX
00408388      .  51                       PUSH ECX
00408389      .  6A 02                    PUSH 2
0040838B      .  FF15 08B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>;  MSVBVM50.__vbaFreeObjList
00408391      .  8B95 40FFFFFF            MOV EDX,DWORD PTR SS:[EBP-C0]                   ;  CrackmeV.00409A68
00408397      .  83C4 0C                  ADD ESP,0C
0040839A      .  8B82 00030000            MOV EAX,DWORD PTR DS:[EDX+300]
004083A0      .  56                       PUSH ESI
004083A1      .  8985 30FFFFFF            MOV DWORD PTR SS:[EBP-D0],EAX
004083A7      .  FFD0                     CALL EAX
004083A9      .  50                       PUSH EAX
004083AA      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
004083AD      .  50                       PUSH EAX
004083AE      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004083B0      .  56                       PUSH ESI
004083B1      .  8985 58FFFFFF            MOV DWORD PTR SS:[EBP-A8],EAX
004083B7      .  FF95 38FFFFFF            CALL DWORD PTR SS:[EBP-C8]                      ;  MSVBVM50.0F10C340
004083BD      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
004083C0      .  50                       PUSH EAX
004083C1      .  51                       PUSH ECX
004083C2      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004083C4      .  8BD8                     MOV EBX,EAX
004083C6      .  8D45 E8                  LEA EAX,DWORD PTR SS:[EBP-18]
004083C9      .  50                       PUSH EAX
004083CA      .  53                       PUSH EBX
004083CB      .  8B13                     MOV EDX,DWORD PTR DS:[EBX]                      ;  MSVBVM50.0F025A95
004083CD      .  FF92 A0000000            CALL DWORD PTR DS:[EDX+A0]
004083D3      .  85C0                     TEST EAX,EAX
004083D5      .  7D 12                    JGE SHORT CrackmeV.004083E9
004083D7      .  68 A0000000              PUSH 0A0
004083DC      .  68 AC6F4000              PUSH CrackmeV.00406FAC
004083E1      .  53                       PUSH EBX
004083E2      .  50                       PUSH EAX
004083E3      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
004083E9      >  8B8D 58FFFFFF            MOV ECX,DWORD PTR SS:[EBP-A8]
004083EF      .  8B55 E8                  MOV EDX,DWORD PTR SS:[EBP-18]
004083F2      .  52                       PUSH EDX
004083F3      .  8B19                     MOV EBX,DWORD PTR DS:[ECX]
004083F5      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004083FB      .  DC0D 10104000            FMUL QWORD PTR DS:[401010]                      ;  *3
00408401      .  83EC 08                  SUB ESP,8                                       ;  -2
00408404      .  DC25 18104000            FSUB QWORD PTR DS:[401018]
0040840A      .  DFE0                     FSTSW AX
0040840C      .  A8 0D                    TEST AL,0D
0040840E      .  0F85 AB030000            JNZ CrackmeV.004087BF
00408414      .  DD1C24                   FSTP QWORD PTR SS:[ESP]
00408417      .  FF15 48B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>]      ;  MSVBVM50.__vbaStrR8
0040841D      .  8BD0                     MOV EDX,EAX
0040841F      .  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
00408422      .  FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408428      .  899D 2CFFFFFF            MOV DWORD PTR SS:[EBP-D4],EBX
0040842E      .  8B9D 58FFFFFF            MOV EBX,DWORD PTR SS:[EBP-A8]
00408434      .  50                       PUSH EAX
00408435      .  8B85 2CFFFFFF            MOV EAX,DWORD PTR SS:[EBP-D4]
0040843B      .  53                       PUSH EBX
0040843C      .  FF90 A4000000            CALL DWORD PTR DS:[EAX+A4]
00408442      .  85C0                     TEST EAX,EAX
00408444      .  7D 12                    JGE SHORT CrackmeV.00408458
00408446      .  68 A4000000              PUSH 0A4
0040844B      .  68 AC6F4000              PUSH CrackmeV.00406FAC
00408450      .  53                       PUSH EBX
00408451      .  50                       PUSH EAX
00408452      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
00408458      >  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
0040845B      .  8D55 E8                  LEA EDX,DWORD PTR SS:[EBP-18]
0040845E      .  51                       PUSH ECX
0040845F      .  52                       PUSH EDX
00408460      .  6A 02                    PUSH 2
00408462      .  FF15 80B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>;  MSVBVM50.__vbaFreeStrList
00408468      .  83C4 0C                  ADD ESP,0C
0040846B      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
0040846E      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
00408471      .  50                       PUSH EAX
00408472      .  51                       PUSH ECX
00408473      .  6A 02                    PUSH 2
00408475      .  FF15 08B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>;  MSVBVM50.__vbaFreeObjList
0040847B      .  8B95 40FFFFFF            MOV EDX,DWORD PTR SS:[EBP-C0]                   ;  CrackmeV.00409A68
00408481      .  83C4 0C                  ADD ESP,0C
00408484      .  8B82 04030000            MOV EAX,DWORD PTR DS:[EDX+304]
0040848A      .  56                       PUSH ESI
0040848B      .  8985 28FFFFFF            MOV DWORD PTR SS:[EBP-D8],EAX
00408491      .  FFD0                     CALL EAX
00408493      .  50                       PUSH EAX
00408494      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
00408497      .  50                       PUSH EAX
00408498      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
0040849A      .  56                       PUSH ESI
0040849B      .  8985 58FFFFFF            MOV DWORD PTR SS:[EBP-A8],EAX
004084A1      .  FF95 30FFFFFF            CALL DWORD PTR SS:[EBP-D0]                      ;  MSVBVM50.0F10C348
004084A7      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
004084AA      .  50                       PUSH EAX
004084AB      .  51                       PUSH ECX
004084AC      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004084AE      .  8BD8                     MOV EBX,EAX
004084B0      .  8D45 E8                  LEA EAX,DWORD PTR SS:[EBP-18]
004084B3      .  50                       PUSH EAX
004084B4      .  53                       PUSH EBX
004084B5      .  8B13                     MOV EDX,DWORD PTR DS:[EBX]                      ;  MSVBVM50.0F025A95
004084B7      .  FF92 A0000000            CALL DWORD PTR DS:[EDX+A0]
004084BD      .  85C0                     TEST EAX,EAX
004084BF      .  7D 12                    JGE SHORT CrackmeV.004084D3
004084C1      .  68 A0000000              PUSH 0A0
004084C6      .  68 AC6F4000              PUSH CrackmeV.00406FAC
004084CB      .  53                       PUSH EBX
004084CC      .  50                       PUSH EAX
004084CD      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
004084D3      >  8B8D 58FFFFFF            MOV ECX,DWORD PTR SS:[EBP-A8]
004084D9      .  8B55 E8                  MOV EDX,DWORD PTR SS:[EBP-18]
004084DC      .  52                       PUSH EDX
004084DD      .  8B19                     MOV EBX,DWORD PTR DS:[ECX]
004084DF      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004084E5      .  DC25 20104000            FSUB QWORD PTR DS:[401020]                      ;  TEMP -= -15
004084EB      .  83EC 08                  SUB ESP,8
004084EE      .  DFE0                     FSTSW AX
004084F0      .  A8 0D                    TEST AL,0D
004084F2      .  0F85 C7020000            JNZ CrackmeV.004087BF
........
00408677      . /74 62                    JE SHORT CrackmeV.004086DB
00408679      . |8B35 14B14000            MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>]  ;  MSVBVM50.__vbaStrCat
0040867F      . |68 C06F4000              PUSH CrackmeV.00406FC0                          ;  UNICODE "You Get It"
00408684      . |68 DC6F4000              PUSH CrackmeV.00406FDC                          ;  UNICODE "\r\n"
00408689      . |FFD6                     CALL ESI                                        ;  <&MSVBVM50.__vbaStrCat>
0040868B      . |8BD0                     MOV EDX,EAX
0040868D      . |8D4D E8                  LEA ECX,DWORD PTR SS:[EBP-18]
00408690      . |FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408696      . |50                       PUSH EAX
00408697      . |68 E86F4000              PUSH CrackmeV.00406FE8                          ;  UNICODE "KeyGen It Now"

Que se puede resumir en esto.

004081F5      .  FF15 F8B04000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]    ;  MSVBVM50.__vbaLenBstr
004081FB      .  8BF8                     MOV EDI,EAX
004081FD      .  8B4D E8                  MOV ECX,DWORD PTR SS:[EBP-18]
00408200      .  69FF 385B0100            IMUL EDI,EDI,15B38                              ;  TEMP = Len(nombre) *15B38
00408206      .  51                       PUSH ECX
00408207      .  0F80 B7050000            JO CrackmeV.004087C4
0040820D      .  FF15 0CB14000            CALL DWORD PTR DS:[<&MSVBVM50.#516>]            ;  MSVBVM50.rtcAnsiValueBstr
00408213      .  0FBFD0                   MOVSX EDX,AX                                    ;  digito a ax
00408216      .  03FA                     ADD EDI,EDX                                     ;  TEMP +=1digito
00408218      .  0F80 A6050000            JO CrackmeV.004087C4
........
004082E9      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004082EF      .  D905 08104000            FLD DWORD PTR DS:[401008]
004082F5      .  833D 00904000 00         CMP DWORD PTR DS:[409000],0
004082FC      .  75 08                    JNZ SHORT CrackmeV.00408306
004082FE      .  D835 0C104000            FDIV DWORD PTR DS:[40100C]                      ;  10 / 5 = 2
00408304      .  EB 0B                    JMP SHORT CrackmeV.00408311
00408306      >  FF35 0C104000            PUSH DWORD PTR DS:[40100C]
0040830C      .  E8 578DFFFF              CALL <JMP.&MSVBVM50._adj_fdiv_m32>
00408311      >  83EC 08                  SUB ESP,8
00408314      .  DFE0                     FSTSW AX
00408316      .  A8 0D                    TEST AL,0D
00408318      .  0F85 A1040000            JNZ CrackmeV.004087BF
0040831E      .  DEC1                     FADDP ST(1),ST                                  ;  TEMP +=2
00408320      .  DFE0                     FSTSW AX
00408322      .  A8 0D                    TEST AL,0D
........
004083F5      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004083FB      .  DC0D 10104000            FMUL QWORD PTR DS:[401010]                      ;  TEMP *=3
00408401      .  83EC 08                  SUB ESP,8                                       ;  TEMP -=2
00408404      .  DC25 18104000            FSUB QWORD PTR DS:[401018]
0040840A      .  DFE0                     FSTSW AX
0040840C      .  A8 0D                    TEST AL,0D
........
004084DF      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004084E5      .  DC25 20104000            FSUB QWORD PTR DS:[401020]                      ;  TEMP -= -15
004084EB      .  83EC 08                  SUB ESP,8
004084EE      .  DFE0                     FSTSW AX
004084F0      .  A8 0D                    TEST AL,0D
004084F2      .  0F85 C7020000            JNZ CrackmeV.004087BF
........
00408677      . /74 62                    JE SHORT CrackmeV.004086DB
00408679      . |8B35 14B14000            MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>]  ;  MSVBVM50.__vbaStrCat
0040867F      . |68 C06F4000              PUSH CrackmeV.00406FC0                          ;  UNICODE "You Get It"
00408684      . |68 DC6F4000              PUSH CrackmeV.00406FDC                          ;  UNICODE "\r\n"
00408689      . |FFD6                     CALL ESI                                        ;  <&MSVBVM50.__vbaStrCat>
0040868B      . |8BD0                     MOV EDX,EAX
0040868D      . |8D4D E8                  LEA ECX,DWORD PTR SS:[EBP-18]
00408690      . |FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408696      . |50                       PUSH EAX
00408697      . |68 E86F4000              PUSH CrackmeV.00406FE8                          ;  UNICODE "KeyGen It Now"

Y en esto:

TEMP = Len(nombre) *15B38
TEMP += 1ºdigitoascii
TEMP +=2
TEMP *=3
TEMP -=2
TEMP +=15

Y el KeyGen nos ocupa una sola línea

txtserial.Text = (((((Len(txtnombre.Text) * 88888) + Asc(Mid(txtn.Text, 1, 1))) + 2) * 3) - 2) + 15

Huevo de pascua (Easter egg)

Si nos fijamos en el VBReformer, en el formulario principal vemos muchas cajas de texto.

Las hacemos visibles, guardamos y ejecutamos haber que pasa.

Lo que pasa es que va guardando el resultado de las operaciones en ellas y en la de arriba concretamente está nuestro serial bueno, lo que nos hace poseedores de un KeyGen encubierto.

Links

Algoritmo de HEdit 2.1.11

Rebuscando entre todo el caos que puede llegar a ser mi disco duro, he encontrado una serie de programas que

Solución al Time Trial de Detten

Intro Hoy tenemos aquí otro crackme sacado del baúl de los recuerdos. En este caso se trata de una protección

VideoTutorial - KeyGen para el Crackme#2 de AfKayAs

http://youtu.be/mk_rzitZ4CM Lista de reproducción

AperiSolve (Zsteg)

AperiSolve es un conjunto de herramientas de análisis esteganográfico que nos ayuda a echar un primer vistazo cuando sospechamos que

1 2 3 … 30 Next »

Algoritmo de HEdit 2.1.11

10 agosto, 2018 por deurus·2 comentarios

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

Solución al Time Trial de Detten

21 octubre, 2014 por deurus·Sin comentarios

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

Yoire PE Reversing Challenge (Crackme Very Hard)

Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si

Solución para el KeygenMe ASM de Flamer

Intro Análisis Keygen Links Intro El crackme que analizamos hoy está hecho en ensamblador y si bien su dificultad es

Afinador

Se nos entrega un ELF que decompilado presenta este aspecto: Para resolver el juego y obtener una licencia válida, nos

List of file signatures for file carving

File carving is the process of reassembling computer files from fragments in the absence of filesystem metadata. Wikipedia. "File carving", literalmente tallado

1 2 3 … 30 Next »

Cruehead’s Crackme 3.0 Keygen [3/3]

8 septiembre, 2014 por deurus·1 comentario

Introducción

Esta es la tercera y última entrega de los crackmes de Cruehead. En esta ocasión nos enfrentamos a un «keyfile«, un archivo llave para que nos entendamos. Tiene un poco más de dificultad que los anteriores pero es ideal para los que empiezan.

El algoritmo

Si iniciamos el crackme no pasa nada, lo único que vemos es la palabra «UNCRACKED» en el título. Abrimos el crackme con Olly y empezamos. En las «string references» vemos el nombre del archivo llave «crackme3.key«. Lo creamos y escribimos el serial 12345678 y empezamos a tracear.

El CMP EAX,-1 significa que está comprobando que el archivo no esté vacio, como no es nuestro caso continuamos.

A continuación vemos que compara nuestra longitud de serial con 0x12 (18 en decimal). Nuestro serial tiene 8 dígitos así que nos tira fuera.

Escribimos en el archivo llave el serial «deurus123456789012» y volvemos a tracear. Vemos que ahora si pasa los filtros iniciales y llegamos a la primera zona interesante. En la imágen está explicado pero os hago un resumen. En el bucle lo que hace es un XOR a los primeros 14 dígitos de nuestro serial con los valores del 41 al 4E (4F finaliza). El bucle solo se rompe si llegamos a 4F o si el resultado del XOR da 0. Además en EAX acumula la suma del resultado del XOR.

Ejemplo:

d  e  u  r  u  s  1  2  3  4  5  6  7  8  9  0  1  2
64 65 75 72 75 73 31 32 33 34 35 36 37 38
                                          XOR
41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E
-----------------------------------------
25 27 36 36 30 35 76 7A 7A 7E 7E 7A 7A 76 = 4ED (Suma)

A continuación hace XOR entre 12345678 y 4ED, coge los 4 últimos dígitos de nuestro serial y los compara.

Ejemplo:

12345678 XOR 4ED = 12345295
Compara 12345295 con 32313039
32313039 = 2109, nuestros 4 últimos dígitos al revés. Recordemos que nuestro serial era "deurus123456789012"

El serial bueno para el nombre deurus12345678 serían los bytes correspondientes de «12345295», es decir, nuestro serial bueno sería:

Ejemplo:

Necesitamos 12345295 para la comparación.
12 34 52 95 hexadecimal
18 52 82 149 decimal
Tenemos que escribirlo al revés. Con Alt-Izq + 149 escribimos el primer caracter, el resto igual.
Nuestro serial quedaría: deurus12345678òR4↕

Metemos el serial y vemos que lo acepta pero que nos muestra un nombre extraño. Esto es por que nos está mostrando los bytes del nombre xoreados, tendremos que hacer un XOR antes al nombre que queramos para que lo muestre correctamente.

Recapitulando

Con lo que sabemos ahora hay que empezar a coger el toro por los cuernos. Lo primero que queremos que muestre el nombre deurus y no deurus12345678. Para ello debemos cortar el bucle y eso solo lo podemos hacer forzando que el resultado del XOR sea 0. Ok pues para deurus el siguiente valor de BL, es decir el séptimo, en el bucle sería 47 lo que corresponde a la letra G. Pues si ponemos de serial deurusGxxxxxxxxxxx ya tendríamos la primera parte solucionada.

Pero recordemos que necesitamos XORear el nombre inicialmente, luego debemos escribir el resultado del XOR.

Ejemplo:

d  e  u  r  u  s  
64 65 75 72 75 73
                  XOR
41 42 43 44 45 46
-----------------
25 27 36 36 30 35

25 27 36 36 30 35 ----- debemos meter esto en el archivo llave.
                  XOR
41 42 43 44 45 46
-----------------
64 65 75 72 75 73 ----- Al desencriptarlo el bucle se verá nuestro nombre correctamente.

En el archivo llave escribiriamos: %'6605

Ahora nos faltaría calcular el nuevo SUM. Como el resultado del XOR ahora es nuestro nombre, basta con sumar sus valores ascii (64+65+75+72+75+73 == 0x298)

0x12345678 XOR 0x298 == 0x123454E0

Luego nuestros 4 últimos dígitos deben ser lo correspondiente a los bytes E0, 54, 34, 12. Los pasamos a decimal y los escribimos en el archivo llave con el truco del ALT-Izq que hemos comentado antes.

El contenido final del archivo llave para el nombre deurus sería:

%’6605GxxxxxxxÓT4↕

Aquí vemos el archivo llave normal.

Y aquí lo vemos con un editor hexadecimal. Como veis se ven claramente los bytes E0, 54, 34, 12.

Os dejo un keygen hecho en .Net para que probéis. Os genera el contenido del archivo y el archivo «crackme3.key».

Links

lost_in_bin

Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la

Blooper Tech Movie XIV – Parque Jurásico

En Parque Jurásico (1993), la informática no es solo un elemento narrativo, es una pieza clave del suspense y del

SPECtacular

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece. En este reto stego nos proporcionan

Stego XVI - Bytes

Intro Os comparto un reto stego que me gustó cuando lo hice hace unos años. En realidad se tarda pocos

1 2 3 … 30 Next »

lost_in_bin

8 agosto, 2024 por deurus·Sin comentarios

Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la solución en el decompilado y quizá por evocar recuerdos de tiempos pretéritos.

Table of Contents

ELF Decompilado

/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
   Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

__int64 (**init_proc())(void);
__int64 sub_400650(); // weak
// int printf(const char *format, ...);
// int puts(const char *s);
// void __noreturn exit(int status);
// size_t strlen(const char *s);
// __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD); weak
// int sprintf(char *s, const char *format, ...);
// __int64 ptrace(enum __ptrace_request request, ...);
// __int64 strtol(const char *nptr, char **endptr, int base);
// __int64 __isoc99_scanf(const char *, ...); weak
// int memcmp(const void *s1, const void *s2, size_t n);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void *sub_400730();
__int64 sub_400760();
void *sub_4007A0();
__int64 sub_4007D0();
void fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// __int64 _gmon_start__(void); weak

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN main;
_UNKNOWN init;
__int64 (__fastcall *funcs_400E29)() = &sub_4007D0; // weak
__int64 (__fastcall *off_601DF8)() = &sub_4007A0; // weak
__int64 (*qword_602010)(void) = NULL; // weak
char *off_602080 = "FLAG-%s\n"; // idb
char a7yq2hryrn5yJga[16] = "7Yq2hrYRn5Y`jga"; // weak
const char aO6uH[] = "(O6U,H\""; // idb
_UNKNOWN unk_6020B8; // weak
_UNKNOWN unk_6020C8; // weak
char byte_6020E0; // weak
char s1; // idb
char byte_602110[]; // weak
char byte_602120[33]; // weak
char byte_602141[7]; // idb
__int64 qword_602148; // weak
__int64 qword_602150; // weak
__int64 qword_602158; // weak
__int64 qword_602160; // weak
__int64 qword_602178; // weak


//----- (0000000000400630) ----------------------------------------------------
__int64 (**init_proc())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}
// 6021D8: using guessed type __int64 _gmon_start__(void);

//----- (0000000000400650) ----------------------------------------------------
__int64 sub_400650()
{
  return qword_602010();
}
// 400650: using guessed type __int64 sub_400650();
// 602010: using guessed type __int64 (*qword_602010)(void);

//----- (0000000000400700) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  _libc_start_main((int (__fastcall *)(int, char **, char **))main, v4, &retaddr, (void (*)(void))init, fini, a3, &v5);
  __halt();
}
// 400706: positive sp value 8 has been found
// 40070D: variable 'v3' is possibly undefined

//----- (0000000000400730) ----------------------------------------------------
void *sub_400730()
{
  return &unk_6020C8;
}

//----- (0000000000400760) ----------------------------------------------------
__int64 sub_400760()
{
  return 0LL;
}

//----- (00000000004007A0) ----------------------------------------------------
void *sub_4007A0()
{
  void *result; // rax

  if ( !byte_6020E0 )
  {
    result = sub_400730();
    byte_6020E0 = 1;
  }
  return result;
}
// 6020E0: using guessed type char byte_6020E0;

//----- (00000000004007D0) ----------------------------------------------------
__int64 sub_4007D0()
{
  return sub_400760();
}

//----- (00000000004007D7) ----------------------------------------------------
__int64 __fastcall main(int a1, char **a2, char **a3)
{
  size_t v3; // rax
  size_t v4; // rax
  int i; // [rsp+1Ch] [rbp-24h]
  int n; // [rsp+20h] [rbp-20h]
  int m; // [rsp+24h] [rbp-1Ch]
  int k; // [rsp+28h] [rbp-18h]
  int j; // [rsp+2Ch] [rbp-14h]

  if ( ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1 )
    goto LABEL_2;
  if ( a1 > 4 )
  {
    qword_602148 = strtol(a2[1], 0LL, 10);
    if ( qword_602148 )
    {
      qword_602150 = strtol(a2[2], 0LL, 10);
      if ( qword_602150 )
      {
        qword_602158 = strtol(a2[3], 0LL, 10);
        if ( qword_602158 )
        {
          qword_602160 = strtol(a2[4], 0LL, 10);
          if ( qword_602160 )
          {
            if ( -24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
              && 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
              && 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
              && -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613 )
            {
              qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
              sprintf(byte_602141, "%06x", qword_602178);
              v4 = strlen(byte_602141);
              MD5(byte_602141, v4, byte_602110);
              for ( i = 0; i <= 15; ++i )
                sprintf(&byte_602120[2 * i], "%02x", (unsigned __int8)byte_602110[i]);
              printf(off_602080, byte_602120);
              exit(0);
            }
          }
        }
      }
    }
LABEL_2:
    printf("password : ");
    __isoc99_scanf("%s", &s1);
    if ( strlen(&s1) > 0x10 )
    {
      puts("the password must be less than 16 character");
      exit(1);
    }
    for ( j = 0; j < strlen(&s1); ++j )
      *(&s1 + j) ^= 6u;
    if ( !strcmp(&s1, a7yq2hryrn5yJga) )
    {
      v3 = strlen(&s1);
      MD5(&s1, v3, byte_602110);
      for ( k = 0; k <= 15; ++k )
        sprintf(&byte_602120[2 * k], "%02x", (unsigned __int8)byte_602110[k]);
      printf(off_602080, byte_602120);
      exit(0);
    }
    puts("bad password!");
    exit(0);
  }
  printf("password : ");
  __isoc99_scanf("%s", &s1);
  if ( strlen(&s1) > 0x10 )
  {
    puts("the password must be less than 16 character");
    exit(1);
  }
  for ( m = 0; m < strlen(&s1); ++m )
  {
    *(&s1 + m) ^= 2u;
    ++*(&s1 + m);
    *(&s1 + m) = ~*(&s1 + m);
  }
  if ( !memcmp(&s1, &unk_6020B8, 9uLL) )
  {
    for ( n = 0; n < strlen(aO6uH); n += 2 )
    {
      aO6uH[n] ^= 0x45u;
      aO6uH[n + 1] ^= 0x26u;
    }
    puts(aO6uH);
  }
  else
  {
    puts("bad password!");
  }
  return 0LL;
}
// 4006A0: using guessed type __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD);
// 4006E0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 602148: using guessed type __int64 qword_602148;
// 602150: using guessed type __int64 qword_602150;
// 602158: using guessed type __int64 qword_602158;
// 602160: using guessed type __int64 qword_602160;
// 602178: using guessed type __int64 qword_602178;

//----- (0000000000400DE0) ----------------------------------------------------
void __fastcall init(unsigned int a1, __int64 a2, __int64 a3)
{
  signed __int64 v3; // rbp
  __int64 i; // rbx

  v3 = &off_601DF8 - &funcs_400E29;
  init_proc();
  if ( v3 )
  {
    for ( i = 0LL; i != v3; ++i )
      (*(&funcs_400E29 + i))();
  }
}
// 601DF0: using guessed type __int64 (__fastcall *funcs_400E29)();
// 601DF8: using guessed type __int64 (__fastcall *off_601DF8)();

//----- (0000000000400E54) ----------------------------------------------------
void term_proc()
{
  ;
}

// nfuncs=33 queued=10 decompiled=10 lumina nreq=0 worse=0 better=0
// ALL OK, 10 function(s) have been successfully decompiled

Análisis estático

Anti-debug

Si la función ptrace retorna -1, significa que el programa está siendo depurado y redirige a LABEL_2.

if (ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1) {
    goto LABEL_2;
}

Cálculos y validaciones

El programa espera al menos 5 argumentos (nombre del programa y cuatro números enteros). Si se proporcionan los cuatro números enteros, se realizan los siguientes cálculos:

if (-24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
    && 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
    && 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
    && -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613)

Esto es un sistema de ecuaciones lineales mondo y lirondo que debe ser resuelto para encontrar los valores correctos de qword_602148, qword_602150, qword_602158 y qword_602160. Una vez resuelto el sistema de ecuaciones se realiza la operación:

 qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;

A continuación se pasa el resultado de la variable qword_602178 a hexadecimal y se genera su hash MD5.

Solución en Python

Lo más rápido en esta ocasión es usar Python, pero esto se puede resolver hasta con lápiz y papel 😉

from sympy import symbols, Eq, solve
import hashlib

# Definir las variables
A, B, C, D = symbols('A B C D')

# Definir las ecuaciones
eq1 = Eq(-24*A - 18*B - 15*C - 12*D, -18393)
eq2 = Eq(9*C + 18*(A + B) - 9*D, 4419)
eq3 = Eq(4*C + 16*A + 12*B + 2*D, 7300)
eq4 = Eq(-6*(A + B) - 3*C - 11*D, -8613)

# Resolver el sistema de ecuaciones
solution = solve((eq1, eq2, eq3, eq4), (A, B, C, D))

# Verificar si se encontró una solución
if solution:
    print("Solución encontrada:")
    print(solution)

    # Obtener los valores de A, B, C y D
    A_val = solution[A]
    B_val = solution[B]
    C_val = solution[C]
    D_val = solution[D]

    # Mostrar los valores encontrados
    print(f"A = {A_val}")
    print(f"B = {B_val}")
    print(f"C = {C_val}")
    print(f"D = {D_val}")

    # Calcular qword_602178
    qword_602178 = C_val + B_val * A_val - D_val
    qword_602178 = int(qword_602178)  # Convertir a entero de Python
    print(f"qword_602178 = {qword_602178}")

    # Convertir qword_602178 a una cadena en formato hexadecimal
    byte_602141 = f"{qword_602178:06x}"
    print(f"byte_602141 (hex) = {byte_602141}")

    # Calcular el MD5 de la cadena
    md5_hash = hashlib.md5(byte_602141.encode()).hexdigest()
    print(f"MD5 hash = {md5_hash}")

    # Generar la flag
    flag = f"FLAG-{md5_hash}"
    print(f"Flag = {flag}")

else:
    print("No se encontró una solución.")

Al ejecutar el script veremos algo como esto:

Solución encontrada:
{A: 227, B: 115, C: 317, D: 510}
A = 227
B = 115
C = 317
D = 510
qword_602178 = 25912
byte_602141 (hex) = 006538
MD5 hash = 21a84f2c7c7fd432edf1686215db....
Flag = FLAG-21a84f2c7c7fd432edf1686215db....

Blooper Tech Movie XIV – Parque Jurásico

27 diciembre, 2025 por deurus·Sin comentarios

No es “código de película”: es software real

«No hemos reparado en gastos»

Y no, el problema no eran los dinosaurios, nunca lo fueron.

SPECtacular

15 septiembre, 2018 por deurus·Sin comentarios

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece.

En este reto stego nos proporcionan un archivo MP3 y nos dan una pequeña pista con el título.

Inicialmente lo pasé con GoldWave y me fijé en el la parte de control en el SPECtrogram y en el SPECtrum, pero no conseguí ver nada. A punto de rendirme di con un programa online llamado SPEK, que me dio la respuesta al instante.

Se puede apreciar una palabra que escrita en Inglés nos da la solución al reto.

Stego XVI – Bytes

6 noviembre, 2022 por deurus·Sin comentarios

Table of Contents

Intro

Os comparto un reto stego que me gustó cuando lo hice hace unos años. En realidad se tarda pocos minutos en resolverlo pero depende de tus recursos es posible que se te atragante.

Procesando a la víctima

Cuando te has enfrentado a unos cuantos retos stego lo normal es que tengas un arsenal de herramientas por las que vas a pasar a la víctima. En mi caso cuando se trata de imágenes, mi fondo de armario está formado por steganabara y stegsolve. Si con esas dos herramientas no lo veo claro ya empiezo a mirar en sus entrañas y en este caso es justo lo que hace falta, mirar en su interior.

La víctima

imagen original del reto

Estamos ante una imagen GIF de 6,36KB (6513 bytes) cuya resolución es 236×42. Debido a la extensión tenderemos a analizar los frames por si se trata de una animación. Una vez desestimada la animación entran en juego steganabara, stegsolve y demás familia. Si todo lo anterior falla abro el archivo con un editor hexadecimal y lo reviso manualmente por si hay algo que me llama la atención.

Bytes

Explorando el interior del archivo enseguida encontramos algo que llama la atención, una sucesión de bytes con espacios intercalados.

Tras copiar los bytes lo primero es eliminar los espacios y empezar a jugar con ellos. Una de las cosas que podemos hacer es convertir los bytes a ascii y voilá, nos encontramos con lo que parece otro archivo GIF.

Copiamos los bytes con la ayuda de nuestro editor hexadecimal favorito, guardamos el archivo como GIF y reto superado.

Enlaces

Nota: si algo os pide clave es deurus.info

Steganabara by quangntenemy [Mirror] [Github]
Stegsolve by Caesum [Original] [mirror]
GIF – Graphics Interchange Format [Wikipedia]