Etiqueta: canyouhackit

CanYouHack.it Crack6 Challenge – Lights Out (English)

26 agosto, 2014 por deurus·Sin comentarios

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.

LaFarge’s Crackme 2 – Keygen por Injerto

10 septiembre, 2014 por deurus·Sin comentarios

Intro

Hoy vamos a hacer algo diferente, vamos a hacer un keygen con la propia víctima. El término anglosajón para esto es «selfkeygening» y no es que esté muy bien visto por los reversers pero a veces nos puede sacar de apuros.

La víctima elegida es el Crackme 2 de LaFarge. Está hecho en ensamblador.

Injerto Light

Primeramente vamos a realizar un injerto light, con esto quiero decir que vamos a mostrar el serial bueno en la MessageBox de error.

Abrimos Olly y localizamos el código de comprobación del serial, tenemos suerte ya que el serial se muestra completamente y no se comprueba byte a byte ni cosas raras. En la imagen inferior os muestro el serial bueno para el nombre deurus y el mensaje de error. Como podeis observar el serial bueno se saca de memoria con la instrucción PUSH 406749 y el mensaje de error con PUSH 406306.

Si cambiamos el PUSH del serial por el de el mensaje de error ya lo tendriámos. Nos situamos encima del PUSH 406306 y pulsamos espacio, nos saldrá un diálogo con el push, lo modificamos y le damos a Assemble.

Ahora el crackme cada vez que le demos a Check it! nos mostrará:

Keygen a partir de la víctima

Pero no nos vamos a quedar ahí. Lo interesante sería que el serial bueno lo mostrara en la caja de texto del serial. Esto lo vamos a hacer con la función user32.SetDlgItemTextA.

Según dice la función necesitamos el handle de la ventana, el ID de la caja de texto y el string a mostrar. La primera y segunda la obtenemos fijándonos en la función GetDlgItemTextA que recoje el serial introducido por nosotros. La string es el PUSH 406749.

Con esto ya tenemos todo lo que necesitamos excepto el espacio dentro del código, en este caso lo lógico es parchear las MessageBox de error y acierto. Las seleccionamos, click derecho y Edit > Fill with NOPs.

Ahora escribimos el injerto.

Finalmente con Resource Hack cambiamos el aspecto del programa para que quede más profesional y listo. Tenemos pendiente hacer el keygen puro y duro, venga agur.

Links

Cruehead's Crackme 3.0 Keygen [3/3]

Introducción Esta es la tercera y última entrega de los crackmes de Cruehead. En esta ocasión nos enfrentamos a un

Solución al Crackme 3 de Sotanez

Introducción Activar un botón en memoria Activar el botón de forma permanente Serial Hardcodeado Links Introducción Este crackme pertenece a

AperiSolve (Zsteg)

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

Revisión al Software de Innotechnix

Habitualmente suelo descargar shareware por diversión para evaluar de que manera protegen los programadores su software. Cada vez es más

« Previous 1 2 3 4 5 6 … 30 Next »

TripleTordo’s Ice9 Keygen

2 septiembre, 2014 por deurus·Sin comentarios

Introducción

Este un crackme muy interesante para principiantes ya que la rutina no es muy compleja. Está hecho en ensamblador.

Saltar el antidebug

Arrancamos el crackme en Olly damos al play y se cierra. Buscamos en las «Intermodular Calls» y vemos «IsDebuggerPresent«, clickamos sobre ella y vemos el típico call, lo NOPeamos.

Aquí vemos el call.

Call Nopeado.

Encontrando un serial válido

Encontrar en serial válido en esta ocasión es muy sencillo, basta con buscar en las «String References» el mensaje de «Bad boy» y fijarse en la comparación.

El algoritmo

Si nos fijamos en el serial generado nos da muchas pistas pero vamos a destriparlo ya que tampoco tiene mucha complicación. De nuevo miramos en las «String references» y clickamos sobre el mensaje de «bad boy«. Encima de los mensajes vemos claramente la rutina de creación del serial.

004010EB        |.  83F8 04             CMP EAX,4                      ;Longitud del nombre >4
004010EE        |.  72 05               JB SHORT Ice9.004010F5
004010F0        |.  83F8 0A             CMP EAX,0A                     ;Longitud del nombre <=10
004010F3        |.  76 15               JBE SHORT Ice9.0040110A
004010F5        |>  6A 00               PUSH 0                                ; /Style = MB_OK|MB_APPLMODAL
004010F7        |.  68 04304000         PUSH Ice9.00403004                    ; |Title = "Error, Bad Boy"
004010FC        |.  68 1C304000         PUSH Ice9.0040301C                    ; |Text = "name must be at least 4 chars"
00401101        |.  6A 00               PUSH 0                                ; |hOwner = NULL
00401103        |.  E8 70010000         CALL <JMP.&user32.MessageBoxA>        ; \MessageBoxA
........
00401183         .  3BD3                CMP EDX,EBX
00401185         .  74 15               JE SHORT Ice9.0040119C
00401187         .  8A07                MOV AL,BYTE PTR DS:[EDI]
00401189         .  3C 5A               CMP AL,5A                     ;Compara que el dígito < 5A
0040118B         .  7E 05               JLE SHORT Ice9.00401192
0040118D         >  03C8                ADD ECX,EAX                   ;ECX + Ascii(dígito)
0040118F         .  47                  INC EDI 
00401190         .^ EB EE               JMP SHORT Ice9.00401180
00401192         >  3C 41               CMP AL,41                     ;Compara que el dígito > 41
00401194         .  7D 02               JGE SHORT Ice9.00401198
00401196         .  EB 02               JMP SHORT Ice9.0040119A
00401198         >  04 2C               ADD AL,2C                     ;Si cumple lo anterior dígito +2C
0040119A         >^ EB F1               JMP SHORT Ice9.0040118D
0040119C         >  81C1 9A020000       ADD ECX,29A                   ;ECX + 29A
004011A2         .  69C9 39300000       IMUL ECX,ECX,3039             ;ECX * 3039
004011A8         .  83E9 17             SUB ECX,17                    ;ECX - 17
004011AB         .  6BC9 09             IMUL ECX,ECX,9                ;ECX * 9
004011AE         .  33DB                XOR EBX,EBX
004011B0         .  8BC1                MOV EAX,ECX                   ;Mueve nuestro SUM en EAX
004011B2         .  B9 0A000000         MOV ECX,0A                    ;ECX = A
004011B7         >  33D2                XOR EDX,EDX
004011B9         .  F7F1                DIV ECX                       ;SUM / ECX (Resultado a EAX)
004011BB         .  80C2 30             ADD DL,30
004011BE         .  881433              MOV BYTE PTR DS:[EBX+ESI],DL
004011C1         .  83C3 01             ADD EBX,1
004011C4         .  83F8 00             CMP EAX,0
004011C7         .  74 02               JE SHORT Ice9.004011CB
004011C9         .^ EB EC               JMP SHORT Ice9.004011B7
004011CB         >  BF C8304000         MOV EDI,Ice9.004030C8
004011D0         >  8A4433 FF           MOV AL,BYTE PTR DS:[EBX+ESI-1]
004011D4         .  8807                MOV BYTE PTR DS:[EDI],AL
004011D6         .  47                  INC EDI 
004011D7         .  4B                  DEC EBX
004011D8         .  83FB 00             CMP EBX,0
004011DB         .^ 75 F3               JNZ SHORT Ice9.004011D0
004011DD         .  C607 00             MOV BYTE PTR DS:[EDI],0               ;Coje letras del nombre en función
004011E0         .  8D3D B4304000       LEA EDI,DWORD PTR DS:[4030B4]         ;del resultado anterior
004011E6         .  68 B7304000         PUSH Ice9.004030B7                    ;  ASCII "rus"
004011EB         .  68 C8304000         PUSH Ice9.004030C8                    ;  ASCII "134992368rus"
004011F0         .  E8 BB000000         CALL Ice9.004012B0                    ; Concatena
004011F5         .  68 C8304000         PUSH Ice9.004030C8                    ; /String2 = "136325628rus"
004011FA         .  68 98314000         PUSH Ice9.00403198                    ; |String1 = "12345"
004011FF         .  E8 98000000         CALL <JMP.&kernel32.lstrcmpA>         ; \lstrcmpA

Resumen (valores hexadecimales):

Len(Nombre ) >=4 y <=A
Comprueba si el dígito está es mayúsculas y si está le sume 2C al valor ascii.
Suma el valor ascii de todos los dígitos menos el último.
SUM + 29A
SUM * 3039
SUM – 17
SUM * 9

Finalmente concatena letras siguiendo este criterio:

Len(nombre) = 4 -> coje la última letra
Len(nombre) = 5 -> coje las dos últimas
Len(nombre) = 6 -> coje las tres últimas
Len(nombre) = 7 -> coje las cuatro últimas
Len(nombre) = 8 -> coje las cinco últimas
Len(nombre) = 9 -> coje las seis últimas
Len(nombre) = A -> coje las siete últimas

Ejemplo para deurus

d  e  u  r  u  (s)
64+65+75+72+75 = 225
225 + 29A   = 4BF
4BF * 3039  = E4DE87
E4DE87 - 17 = E4DE70
E4DE70 * 9  = 80BD1F0
;Pasamos a decimal y concatenamos
134992368rus

Ejemplo para Deurus

D       e  u  r  u  (s)
44(+2C)+65+75+72+75 = 25D
25D + 29A   = 4F7
4BF * 3039  = EF6AFF
EF6AFF - 17 = EF6AE8
EF6AE8 * 9  = 86AC228
;Pasamos a decimal y concatenamos
141214248rus

Como curiosidad decirtos que con el tiempo valores del estilo 29A y 3039 os pegarán rápido al ojo ya que equivalen a 666 y 12345 en decimal. Por cierto 29A fue un grupo de hackers creadores de virus muy conocido en la escena Nacional e Internacional.

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 Ph0n3

27 abril, 2023 por deurus·Sin comentarios

Un error que habitualmente cometo cuando me enfrento a todo tipo de retos (especialmente en CTFs) es empezar a procesar el fichero proporcionado con todo tipo de herramientas como pollo sin cabeza. En el caso que nos ocupa se proporcionaba un fichero de audio WAV que procesé hasta con 4 herramientas diferentes antes de tomar aire y decidir simplemente escuchar el audio. Al escucharlo me di cuenta de que se trataba de una marcación por tonos comúnmente conocido como DTMF (Dual-Tone Multi-Frequency).

Decodificar DTMF

Con una rápida búsqueda por la web encontré una sencilla herramienta realizada en python llamada dtmf-decoder con la que enseguida obtenemos resultados. La herramienta es bastante sencilla, simplemente parte la señal en trozos, calcula la FFT (Fast Fourier Transform) para obtener las amplitudes y las compara con las de los tonos DTMF. Hay que tener en cuenta que el audio entregado es muy limpio y eso facilita mucho las cosas.

El siguiente comando nos devuelve los números marcados.

Como era de esperar, los números obtenidos no son la solución final aunque en este caso enseguida damos con que el tipo de codificación es simple y llanamente ASCII.

DTMF = 837283123119104521169510048951214811795119521101166363125
HEX  = 53 48 53 7B 77 68 34 74 5F 64 30 5F 79 30 75 5F 77 34 6E 74 3F 3F 7D
Solución: SHS{wh4t_d0_y0u_w4nt??}

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

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

Solución a los retos javascript de rogerfm.net

Introducción Javascript 1 (Serial a la vista) Javascript 2 (La función charAt()) Javascript 3 (Input) Javascript 4 (Fuerza bruta manual) Javascript

Reto Stego 1 de Hacker Games

Cambio de extensión Imagen oculta Descifrando el mensaje Enlaces Cambio de extensión (paso opcional) Al descargar la imagen de la

« Previous 1 2 3 4 5 6 … 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

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

Solución a los retos javascript de rogerfm.net

30 septiembre, 2016 por deurus·Sin comentarios

Introducción
Javascript 1 (Serial a la vista)
Javascript 2 (La función charAt())
Javascript 3 (Input)
Javascript 4 (Fuerza bruta manual)
Javascript 5 (Fuerza bruta)
Enlaces

Table of Contents

Introducción

Los retos de Javascript son los retos más sencillos que podemos encontrar. Muchas veces solamente mirando el código fuente obtenemos la respuesta. Suponen una mala implementación de seguridad debido a que el código se ejecuta del lado del cliente, por lo que el código fuente es accesible y por lo tanto, javascript no garantiza seguridad alguna. En estos cinco casos haremos un recorrido por lo más básico, cinco retos fáciles de superar y que nos proporcionan los conocimientos base para Javascript. Dicho esto os puedo asegurar que en ocasiones he encontrado retos javascript realmente complicados que requieren de horas descifrarlos y en los que es fácil tirar la toalla.

Cuando el reto lo requiera, es buena idea utilizar un compilador online para obtener de forma rápida el valor de una variable o realizar una prueba concreta. Yo utilizo Jsfiddle para realizar pruebas pero existen muchos más.

Javascript 1

Este primer reto es lo básico, en el código fuente se pueden apreciar directamente el usuario y la clave.

<script language=JavaScript>
function Verify(name,pass)
{
if (name=="admin" & pass=="3***3")
	{
	location.href = name + pass + '.htm';
	}
else 
	{
	alert("Si ya fallamos el primero...");
	};
}
</script>

Javascript 2

Este segundo reto es bastante sencillo pero ya te obliga a conocer la función charAt() de Javascript. Dicha función lo que hace es coger el caracter indicado mediante un índice que comienza en cero. Por ejemplo si nombre = deurus y hacemos letra = nombre.charAt(3), estariámos extrayendo la cuarta letra, es decir, la letra r de la variable nombre.

function Verify(name,pass)
{
var name1 = "CrawlinG", pass1 = "capriccio"
	if (name==name1 & pass==pass1)
	{
	location.href = name + ".htm";
	}
else 
	{
	var x =  name1.charAt(7) + pass1.charAt(3)+ name1.charAt(2) + pass1.charAt(5) +  name1.charAt(5) + pass1.charAt(1);x = x.toLowerCase();
	var y =  name.charAt(3) + name.charAt(1) + pass.charAt(1)+ pass.charAt(6) +  pass.charAt(7) + name.charAt(2);var x1 = "des" + y;
	if (x==y){location.href = x1 + ".htm"}else{alert("Esto no va bien");location.href = "js2.htm"}
	}
}

Lo interesante está en la formación de las variables x e y. La variable x se forma de las variables name1 y pass1, formando la palabra gracia. Por otro lado, la variable y se forma con el nombre y clave que introduzcamos nosotros. Vemos que la variable x e y deben ser iguales, por lo tanto debemos construir un nombre (name) y una clave (pass) que cumpla con lo siguiente:

4ª letra del nombre = 1ª letra de la palabra «gracia»
2ª letra del nombre = 2ª letra de la palabra «gracia»
2ª letra de la clave = 3ª letra de la palabra «gracia»
7ª letra de la clave = 4ª letra de la palabra «gracia»
8ª letra de la clave = 5ª letra de la palabra «gracia»
3ª letra del nombre = 6ª letra de la palabra «gracia«

Como véis simplemente se trata de interpretar correctamente la función charAt() y de fijarse bien en los nombres de las variables.

Javascript 3

Este reto nos muestra diálogo donde nos pide la contraseña para validar el reto. Al fallar o cancelar vuelve al índice para no dejarnos ver el código fuente. Aquí se pueden seguir varios caminos como bloquear el uso de javascript en el navegador o instalar un plugin en chrome o firefox para habilitar/deshabilitar de forma rápida el uso de javascript.

Una vez deshabilitado javascript vemos lo siguiente:

<script language="JavaScript" src="js3.gif" type=text/javascript>
<!--
function verify()
{
var pass="thebest";
var password=prompt("Introduce el password para superar el nivel","");
	if (password==pass)
		{
		location.href = pass + ".htm";
		}
	else
		{
		alert("No vamos bien...");
		location.href = "index.htm";
		}
}
//-->
</script>

Aquí el truco es darse cuenta que el código que se está ejecutando esta en «js3.gif» y no el código que nos muestra como válida la clave thebest. Si descargamos el archivo js3.gif y lo abrimos con un archivo de texto vemos nuestra querida clave.

function verify()
{
var pass="mo****ver";
var password=prompt("Introduce el password para superar el nivel","");
	if (password==pass)
		{
		location.href = pass + ".htm";
		}
	else
		{
		alert("No vamos bien...");
		location.href = "index.htm";
		}
}

Javascript 4

En este reto ya entramos con que la clave no es reversible y la debemos obtener por fuerza bruta. En este reto utiliza una nueva función como charCodeAt() que lo que hace es obtener el valor ascii del caracter indicado.

function Verify(pass1)
{
var cont1= 2, cont2= 6
var suma1 = 0, suma2 = 0
var pass2 = "FDRLF"
for(i = 0; i < pass1.length; i++) 
{
suma1 += (pass1.charCodeAt(i) * cont1);
cont1++
}
for(i = 0; i < pass2.length; i++) 
{
suma2 += (pass2.charCodeAt(i) * cont2);
cont2++
}
if (suma1==suma2)
{
window.location=suma1+".htm";
}
else
{
alert ("Algo no va bien...");
}
}

Vemos dos bucles en los que se calculan sendos valores suma que finalmente se comparan. la variable suma1 se calcula mediante nuestro password y la variable suma2 la obtiene de la palabra «FDRLF». Con el script que os muestro a continuación obtenemos que usando como clave deurus, suma1 = 3048 y suma2 = 2936. Nuestro punto de referencia es suma2 = 2936, de modo que vamos alterando con paciencia la variable pass1 obteniendo valores cercanos a 2936. Por ejemplo «deurua» nos da suma1 = 2922, un valor bastante cercano.

var pass1 = "deurus";
var cont1= 2, cont2= 6
var suma1 = 0, suma2 = 0
var pass2 = "FDRLF"
for(i = 0; i < pass1.length; i++) 
{
suma1 += (pass1.charCodeAt(i) * cont1);
cont1++
}
for(i = 0; i < pass2.length; i++) 
{
suma2 += (pass2.charCodeAt(i) * cont2);
cont2++
}
alert (suma1);
alert (suma2);

La solución a este reto es múltiple. Dos claves válidas son por ejemplo dfurqf y zwfabz.

Javascript 5

Este último reto es similar al anterior pero ya nos obliga a crearnos una pequeña herramienta que nos busque el serial válido.

function Verify(pass)
{
var suma=0
var cadena = "abcdefghijklmnopqrstuvwxyz"
for (var i = 0; i < pass.length; i++) 
	{
	var letra = pass.charAt(i)
	var valor = (cadena.indexOf(letra))
	valor++
	suma *= 26
	suma += valor
	}
if (suma==6030912063)
	{
	window.location=pass+".htm";
	}
else
	{
	alert ("Algo no va bien...");
	}
}

Para esta ocasión utiliza una nueva función llamada indexOf() que lo que hace es devolver un número entero que representa la posición en la que se encuentra el parámetro pasado a la función. Por ejemplo, si tengo variable = deurus y realizo posición = variable.indexOf(«s»), obtengo como resultado 5 (se empieza a contar desde cero).

Las operaciones que realiza el bucle son las siguientes:

Coge las letras del nombre una a una.
valor = posición de nuestra letra dentro de la variable de texto llamada cadena.
valor = valor + 1.
Multiplica la variable suma por 26.
Suma = suma + valor.

Aunque el proceso de recuperación de esta clave es algo más largo, podemos acortarlo introduciendo una clave de inicio de fuerza bruta próxima al objetivo. Al ser una función bastante lineal podemos rápidamente mediante pruebas con nuestro código de fuerza bruta o con un compilador online, establecer que la clave tendrá 7 caracteres e incluso que para ahorrar tiempo podemos aproximar la clave para que su valor suma esté cercano al valor suma buscado 6030912063.

Realizando pruebas obtenemos:

Clave = aaaaaaa -> suma = 321272407
Clave = zzzzzzz -> suma = 8353082582
Clave = smaaaaa -> suma = 6024332887
Clave = smkkkkk -> suma = 6029085437

Como vemos, la clave smkkkkk ya está bastante próxima al objetivo y será un buen punto para lanzar la fuerza bruta.

Os dejo el código de fuerza bruta en .Net

Module Module1
    Sub Main()
inicio:
        Console.WriteLine("-------------------------")
        Console.WriteLine("Modo [1] Prueba password")
        Console.WriteLine("Modo [2] Fuerza bruta")
        Console.WriteLine("-------------------------")
        Dim modo = Console.ReadLine()
        '
        If modo = 2 Then
            Console.WriteLine("¿Password para comenzar?")
            Dim pass = Console.ReadLine()
inicio2:
            Dim cadena As String = "abcdefghijklmnopqrstuvwxyz"
            Dim valor As Integer = 0
            Dim suma As Long = 0
            Dim letra As String
            For i = 0 To pass.Length - 1
                letra = Mid(pass, i + 1, 1)
                valor = cadena.IndexOf(letra)
                valor += 1
                suma *= 26
                suma += valor
            Next
            Console.WriteLine("Password: " & pass & " - Sum: " & suma.ToString)
            pass = IncrementString(pass)
            If suma = 6030912063 Then
                MsgBox("Password is " & pass)
            Else
                If pass = "aaaaaaaa" Then
                    Console.WriteLine("pass not found")
                    Console.ReadKey()
                Else
                    GoTo inicio2
                End If
            End If
        End If
        '------------------------------------------------
        If modo = 1 Then
            Console.WriteLine("Password:")
            Dim pass = Console.ReadLine()
            Dim cadena As String = "abcdefghijklmnopqrstuvwxyz"
            Dim valor As Integer = 0
            Dim suma As Long = 0
            Dim letra As String
            For i = 0 To pass.Length - 1
                letra = Mid(pass, i + 1, 1)
                valor = cadena.IndexOf(letra)
                valor += 1
                suma *= 26
                suma += valor
            Next
            Console.WriteLine("Password: " & pass & " - Sum: " & suma.ToString)
            Console.WriteLine(".......")
            Console.WriteLine("Good = 6030912063")
            Console.WriteLine("Suma = " & suma.ToString)
            Console.ReadKey()
            Console.Clear()
            GoTo inicio
        End If
    End Sub
    Function IncrementString(ByVal strString As String) As String
        '
        ' Increments a string counter
        ' e.g.  "a" -> "b"
        '       "az" -> "ba"
        '       "zzz" -> "aaaa"
        '
        ' strString is the string to increment, assumed to be lower-case alphabetic
        ' Return value is the incremented string
        '
        Dim lngLenString As Long
        Dim strChar As String
        Dim lngI As Long

        lngLenString = Len(strString)
        ' Start at far right
        For lngI = lngLenString To 0 Step -1
            ' If we reach the far left then add an A and exit
            If lngI = 0 Then
                strString = "a" & strString
                Exit For
            End If
            ' Consider next character
            strChar = Mid(strString, lngI, 1)
            If strChar = "z" Then
                ' If we find Z then increment this to A
                ' and increment the character after this (in next loop iteration)
                strString = Left$(strString, lngI - 1) & "a" & Mid(strString, lngI + 1, lngLenString)
            Else
                ' Increment this non-Z and exit
                strString = Left$(strString, lngI - 1) & Chr(Asc(strChar) + 1) & Mid(strString, lngI + 1, lngLenString)
                Exit For
            End If
        Next lngI
        IncrementString = strString
        Exit Function

    End Function
End Module

Enlaces

Web del reto
Jsfiddle (compilador online)

Reto Stego 1 de Hacker Games

2 diciembre, 2015 por deurus·Sin comentarios

Cambio de extensión
Imagen oculta
Descifrando el mensaje
Enlaces

Table of Contents

Cambio de extensión (paso opcional)

Al descargar la imagen de la web del reto vemos que tiene la extensión php y lo más probable es que no nos abra correctamente.

...
<br/>
<img src="steg1img.php"/>
<br/>
...

Abrimos la imagen con nuestro editor hexadecimal favorito y nos fijamos en la cabecera.

00000000h: 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 ; ‰PNG........IHDR

Renombramos entonces la extensión a png y continuamos.

Imagen oculta

Esta parte la afrontaremos con Steganabara, una herramienta muy útil que siempre uso cuando me enfrento a un reto «stego». En esta ocasión utilizaremos el análisis de color. Para ello pulsamos sobre «Analyse > Color table«.

En la tabla de colores tenemos la descomposición de colores RGBA y su frecuencia de aparición. Ordenamos por frecuencia descendiente y hacemos doble clic sobre la fila para abrir la imagen resultante.

A continuación un resumen de las imágenes obtenidas.

Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.

dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe

Descifrando el mensaje

A partir de aquí el reto pasa a ser de encriptación. Con el tiempo diferenciareis fácilmente el tipo de cifrado con sólo ver el texto. En este caso lo primero que se nos ocurre es comprobar dos cifrados clásicos como son el cifrado César y el Vigenere.

Tras desestimar el cifrado César realizamos un ataque de «fuerza bruta» al cifrado Vigenere mediante análisis estadístico. En la imagen que muestro a continuación se puede ver que la clave está cerca de ser «HPHQTC» pero todavía no se lee correctamente.

Ya que la fuerza bruta de por sí no termina de darnos la respuesta correcta, pasamos a probar algo muy útil, esto es, descifrar por fuerza bruta pero dándole una palabra para comparar. En este caso en concreto vemos que una posible palabra que pudiera estar en el texto encriptado es «PASSWORD», probamos y reto terminado.