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.

Wechall Training LSB Challenge (Esteganografía)

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

Table of Contents

Introducción

Resumidamente, esta técnica consiste en ocultar información en el bit menos significativo de cada uno de los píxeles de una imagen, consiguiendo así que el cambio realizado sea invisible al ojo humano. El problema de esta técnica, es que la información oculta puede obtenerse fácilmente si esta no se ha codificado previamente o si no se sigue un patrón concreto a la hora de ocultarla.

Desde la web del reto nos avisan de que esto es un simple truco pero espectacular. Nos animan a descargar una imágen y a encontrar la solución oculta.

Aprovecho este reto para presentaros una herramienta vital al enfrentaros a ciertos retos sobre esteganografía, steganabara.

Steganabara tiene dos apartados muy interesantes, uno es «color table» y otro «bit mask«, hoy veremos en acción a «bit mask».

No os preocupéis por la solución ya que cambia para cada usuario y sesión.

Buscando la solución oculta

Abrimos steganabara y empezamos a trastear con bit mask.

Al poco tiempo ya vemos que vamos bien encaminados.

Finalmente no nos cuesta dar con la solución.

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

algoritmo HEdit yuri software

Reto Stego – Dos por Uno

13 diciembre, 2025 por deurus·Sin comentarios

El reto consiste en dos imágenes (v1.png y v2.png) que, a simple vista, parecen contener ruido aleatorio. Sin embargo, ambas forman parte de un sistema de criptografía visual en la que cada imagen contiene información parcial que no es interpretable por separado, pero que al combinarse correctamente revelan información oculta.

La trampa está en que la combinación no se hace con operaciones normales como suma, resta o multiplicación. El autor del reto espera que el jugador use una herramienta como StegSolve y pruebe distintas operaciones tipo XOR, AND o MUL hasta encontrar una transformación en la que uno de los métodos muestre algo significativo. El truco está en llegar a la conclusión de que una de las imágenes hay que invertirla antes de combinar ambas imágenes. Todo esto se puede hacer con StegSolve sin necesidad de utilizar ninguna herramienta adicional, pero voy a aprovechar para hacerlo con python y así de paso entendemos como realiza las operaciones StegSolve. En resumen, para resolver el reto basta con:

Invertir (Colour Inversion XOR) una de las imágenes.
Combinar ambas imágenes mediante Analyse > Combine images.
Operación MUL del combinador.

La operación MUL no es una multiplicación normalizada, sino una multiplicación de enteros de 24 bits (0xRRGGBB) con overflow, algo que la mayoría de herramientas no replican correctamente.

¿Por qué aparece la solución con esa combinación

Las imágenes están preparadas para que ciertos bits de color en una imagen sean el complemento de los de la otra. Por tanto:

Si se muestran tal cual → parecen ruido
Si se combinan mediante XOR → parte de la estructura aparece, pero no se ve el resultado correcto
Si se combinan mediante MUL «normal» → tampoco aparece
Si se aplica la multiplicación bitwise exacta usada por StegSolve → se alinean las partes ocultas

La operación MUL de StegSolve no es una multiplicación de píxeles, es decir, no hace:

R = (R1 * R2) / 255

sino:

c1 = 0xRRGGBB  (pixel 1)
c2 = 0xRRGGBB  (pixel 2)
resultado = (c1 * c2) & 0xFFFFFF

Con todo esto claro, he preparado un script para combinar las imágenes de forma automática.

import os
import numpy as np
from PIL import Image

# =========================================================
# UTILIDADES
# =========================================================

def ensure_output():
    if not os.path.exists("output"):
        os.makedirs("output")

def load_rgb(path):
    img = Image.open(path).convert("RGB")
    return np.array(img, dtype=np.uint32)

def save_rgb(arr, name):
    Image.fromarray(arr.astype(np.uint8), "RGB").save(os.path.join("output", name))

def invert_xor(arr):
    """Colour Inversion (Xor) de StegSolve."""
    out = arr.copy()
    out[..., :3] = 255 - out[..., :3]
    return out

# =========================================================
# FUNCIONES DE COMBINER EXACTAS DE STEGSOLVE
# =========================================================

def to24(arr):
    """Convierte RGB → entero 0xRRGGBB."""
    return ((arr[..., 0] << 16) |
            (arr[..., 1] << 8)  |
             arr[..., 2])

def from24(c):
    """Convierte entero 0xRRGGBB → RGB."""
    R = (c >> 16) & 0xFF
    G = (c >> 8)  & 0xFF
    B = c & 0xFF
    return np.stack([R, G, B], axis=-1).astype(np.uint8)

# ------------------------------
# Funciones auxiliares
# ------------------------------

def comb_xor(c1, c2):
    return from24((c1 ^ c2) & 0xFFFFFF)

def comb_or(c1, c2):
    return from24((c1 | c2) & 0xFFFFFF)

def comb_and(c1, c2):
    return from24((c1 & c2) & 0xFFFFFF)

def comb_add(c1, c2):
    return from24((c1 + c2) & 0xFFFFFF)

def comb_add_sep(c1, c2):
    R = (((c1 >> 16) & 0xFF) + ((c2 >> 16) & 0xFF)) & 0xFF
    G = (((c1 >> 8)  & 0xFF) + ((c2 >> 8)  & 0xFF)) & 0xFF
    B = ((c1 & 0xFF) + (c2 & 0xFF)) & 0xFF
    return from24((R << 16) | (G << 8) | B)

def comb_sub(c1, c2):
    return from24((c1 - c2) & 0xFFFFFF)

def comb_sub_sep(c1, c2):
    R = (((c1 >> 16) & 0xFF) - ((c2 >> 16) & 0xFF)) & 0xFF
    G = (((c1 >> 8)  & 0xFF) - ((c2 >> 8)  & 0xFF)) & 0xFF
    B = ((c1 & 0xFF) - (c2 & 0xFF)) & 0xFF
    return from24((R << 16) | (G << 8) | B)

def comb_mul(c1, c2):
    """MUL EXACTO StegSolve"""
    return from24((c1 * c2) & 0xFFFFFF)

def comb_mul_sep(c1, c2):
    R = (((c1 >> 16) & 0xFF) * ((c2 >> 16) & 0xFF)) & 0xFF
    G = (((c1 >> 8)  & 0xFF) * ((c2 >> 8)  & 0xFF)) & 0xFF
    B = ((c1 & 0xFF) * (c2 & 0xFF)) & 0xFF
    return from24((R << 16) | (G << 8) | B)

def comb_lightest(c1, c2):
    """Máximo por canal"""
    R = np.maximum((c1 >> 16) & 0xFF, (c2 >> 16) & 0xFF)
    G = np.maximum((c1 >> 8)  & 0xFF, (c2 >> 8)  & 0xFF)
    B = np.maximum(c1 & 0xFF, c2 & 0xFF)
    return from24((R << 16) | (G << 8) | B)

def comb_darkest(c1, c2):
    """Mínimo por canal"""
    R = np.minimum((c1 >> 16) & 0xFF, (c2 >> 16) & 0xFF)
    G = np.minimum((c1 >> 8)  & 0xFF, (c2 >> 8)  & 0xFF)
    B = np.minimum(c1 & 0xFF, c2 & 0xFF)
    return from24((R << 16) | (G << 8) | B)

# Lista de transformaciones
TRANSFORMS = {
    "xor": comb_xor,
    "or": comb_or,
    "and": comb_and,
    "add": comb_add,
    "add_sep": comb_add_sep,
    "sub": comb_sub,
    "sub_sep": comb_sub_sep,
    "mul": comb_mul,
    "mul_sep": comb_mul_sep,
    "lightest": comb_lightest,
    "darkest": comb_darkest,
}

# =========================================================
# GENERACIÓN DE TODAS LAS COMBINACIONES
# =========================================================

def generate_all(imA, imB, labelA, labelB):
    print(f"Generando combinaciones: {labelA} vs {labelB}")

    c1 = to24(imA)
    c2 = to24(imB)

    for name, fun in TRANSFORMS.items():
        out = fun(c1, c2)
        save_rgb(out, f"{labelA}__{labelB}__{name}.png")

    print(f"{labelA}-{labelB} completado.")

# =========================================================
# MAIN
# =========================================================

ensure_output()

print("Cargando imágenes v1.png y v2.png...")
im1 = load_rgb("v1.png")
im2 = load_rgb("v2.png")

print("Generando invertidas estilo StegSolve...")
im1_x = invert_xor(im1)
im2_x = invert_xor(im2)

save_rgb(im1_x, "v1_xored.png")
save_rgb(im2_x, "v2_xored.png")

# Generar las 52 combinaciones:
generate_all(im1,   im2,   "v1",   "v2")
generate_all(im1_x, im2,   "v1x",  "v2")
generate_all(im1,   im2_x, "v1",   "v2x")
generate_all(im1_x, im2_x, "v1x",  "v2x")

print("\nResultados en carpeta ./output/")

A continuación os muestro parte de las imágenes generadas por el script. El secreto oculto era un código QR que nos da la solución al reto.

challenge Cripto visual reto

Cruehead’s Crackme 1.0 Keygen [1/3]

8 septiembre, 2014 por deurus·4 comentarios

Table of Contents

Introducción

Esta es la primera entrega de tres en las que vamos a ver tres crackmes que todo reverser debería hacer. Son la serie del autor Cruehead. Aunque los hice hace ya muchos años, he decidido documentarlos para que el lector que empieza pueda deleitarse. En este caso se trata del típico Nombre / Serial.

El algoritmo

El algoritmo de este crackme es lo más sencillo que nos podemos encontrar.

Abrimos el crackme con Olly y buscamos en las «string references» el mensaje de error. Pinchamos sobre el y en la parte superior enseguida vemos 2 calls muy interesantes.

Veamos que hace con el nombre.

Para «deurus» pondría todo en mayúsculas, sumaría su valor ascii y le haría XOR 0x5678.

Ejemplo:

deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0

Veamos que hace con el serial introducido.

Convierte nuestro serial a hexadecimal y le hace XOR 0x1234.

Ejemplo:

Serial = 12345 –> 0x3039 XOR 0x1234 = 0x220D

Una vez que tenemos el SUMNombre y el SUMSerial los compara. Lo vemos en CMP EAX, EBX.

En resumen, si a nuestro SUMNombre le hacemos XOR 0x5678 y XOR 0x1234 ya tenemos el serial bueno.

Ejemplo:

deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0 XOR 0x1234 = 0x4594

0x4594 = 17812

El Keygen

char Nombre[20];
GetWindowText(hwndEdit1, Nombre, 20);
char Serial[20];
int len = strlen(Nombre);
int suma = 0;
boolean error = false;
   for(int i = 0; i <= len; i = i + 1)
   {
      suma += toupper(Nombre[i]);
   }
suma = suma^0x444C; //444C == 5678 xor 1234
wsprintf(Serial,"%d",suma);
SetWindowText(hwndEdit2, TEXT(Serial));

Links

Solución al Crackme 7 de Scarebyte

Introducción Desempacado Eliminar la NAG Password Nº serie asociado a un nombre Checkbox Trackbar Links Introducción Aquí tenemos un Crackme

ThisIsLegal.com - Realistic Challenge 3

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

VideoTutorial - Keygen y desempacado UPX para el Crackme#1 de ECloZion

http://youtu.be/c4CNY902SAE Versión de texto Lista de reproducción

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

1 2 3 … 30 Next »

crackme Keygen VisionZ

Keygen para el Crackme 1 de VisionZ

26 julio, 2020 por deurus·Sin comentarios

Table of Contents

Intro

Aquí tenemos un crackme clásico realizado en Visual C++. La única particularidad que tiene es que no muestra MessageBox al introducir bien o mal el serial, simplemente cambia una imagen de un emoticono. Si observamos el comportamiento del crackme notaremos que inicialmente el emoticono está neutral y al fallar se pone triste y por lo tanto es de suponer que al acertar se pondrá contento.

El BreakPoint

Al mirar en las Intermodular Calls de OllyDbg vemos que LoadIconA es un buen candidato para ubicar la comprobación del serial. Si nos fijamos hay tres llamadas, ponemos un breakpoint en las tres y enseguida llegamos a la zona de comprobación del serial.

La comprobación

00401180   . 6A FF          PUSH -1
00401182   . 68 68194000    PUSH CrackMe_.00401968
00401187   . 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
0040118D   . 50             PUSH EAX
0040118E   . 64:8925 000000>MOV DWORD PTR FS:[0],ESP
00401195   . 83EC 0C        SUB ESP,0C
00401198   . 53             PUSH EBX
00401199   . 55             PUSH EBP
0040119A   . 8BE9           MOV EBP,ECX
0040119C   . 56             PUSH ESI
0040119D   . 57             PUSH EDI
0040119E   . 8D4C24 10      LEA ECX,DWORD PTR SS:[ESP+10]
004011A2   . E8 2F050000    CALL <JMP.&MFC42.#540>
004011A7   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
004011AB   . C74424 24 0000>MOV DWORD PTR SS:[ESP+24],0
004011B3   . E8 1E050000    CALL <JMP.&MFC42.#540>
004011B8   . 8D4424 10      LEA EAX,DWORD PTR SS:[ESP+10]
004011BC   . 8BCD           MOV ECX,EBP
004011BE   . 50             PUSH EAX
004011BF   . 68 E9030000    PUSH 3E9
004011C4   . C64424 2C 01   MOV BYTE PTR SS:[ESP+2C],1
004011C9   . E8 02050000    CALL <JMP.&MFC42.#3097>                  ;  Lee el tamano del nombre
004011CE   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
004011D2   . 51             PUSH ECX
004011D3   . 68 EA030000    PUSH 3EA
004011D8   . 8BCD           MOV ECX,EBP
004011DA   . E8 F1040000    CALL <JMP.&MFC42.#3097>                  ;  Lee el tamano del serial
004011DF   . 51             PUSH ECX
004011E0   . 8D5424 14      LEA EDX,DWORD PTR SS:[ESP+14]
004011E4   . 8BCC           MOV ECX,ESP
004011E6   . 896424 1C      MOV DWORD PTR SS:[ESP+1C],ESP
004011EA   . 52             PUSH EDX
004011EB   . E8 DA040000    CALL <JMP.&MFC42.#535>
004011F0   . 8D4424 1C      LEA EAX,DWORD PTR SS:[ESP+1C]   
004011F4   . 8BCD           MOV ECX,EBP       
004011F6   . 50             PUSH EAX                 
004011F7   . E8 D4010000    CALL CrackMe_.004013D0 
004011FC   . 50             PUSH EAX
004011FD   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
00401201   . C64424 28 02   MOV BYTE PTR SS:[ESP+28],2
00401206   . E8 B9040000    CALL <JMP.&MFC42.#858>
0040120B   . 8D4C24 18      LEA ECX,DWORD PTR SS:[ESP+18]
0040120F   . C64424 24 01   MOV BYTE PTR SS:[ESP+24],1
00401214   . E8 A5040000    CALL <JMP.&MFC42.#800>
00401219   . 8B4C24 10      MOV ECX,DWORD PTR SS:[ESP+10]
0040121D   . 8B5424 14      MOV EDX,DWORD PTR SS:[ESP+14]
00401221   . 8B41 F8        MOV EAX,DWORD PTR DS:[ECX-8]
00401224   . 8B4A F8        MOV ECX,DWORD PTR DS:[EDX-8]
00401227   . 3BC1           CMP EAX,ECX                              ;  CMP len nombre y len serial
00401229   . 0F85 2C010000  JNZ CrackMe_.0040135B
0040122F   . 83F8 03        CMP EAX,3                                ;  len nombre >=3
00401232   . 0F8C 23010000  JL CrackMe_.0040135B
00401238   . 50             PUSH EAX
00401239   . E8 7A040000    CALL <JMP.&MFC42.#823>
0040123E   . 8BF0           MOV ESI,EAX
00401240   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
00401244   . 83C4 04        ADD ESP,4
00401247   . 33C9           XOR ECX,ECX
00401249   . 8B50 F8        MOV EDX,DWORD PTR DS:[EAX-8]
0040124C   . 4A             DEC EDX
0040124D   . 85D2           TEST EDX,EDX
0040124F   . 7E 37          JLE SHORT CrackMe_.00401288
.......
1ºBUCLE
.......
00401251   > 8A1401         MOV DL,BYTE PTR DS:[ECX+EAX]
00401254   . 8A5C01 01      MOV BL,BYTE PTR DS:[ECX+EAX+1]
00401258   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
0040125C   . 0FBED2         MOVSX EDX,DL
0040125F   . 0FBE0401       MOVSX EAX,BYTE PTR DS:[ECX+EAX]
00401263   . 8D4410 FE      LEA EAX,DWORD PTR DS:[EAX+EDX-2]
00401267   . 99             CDQ
00401268   . 2BC2           SUB EAX,EDX
0040126A   . 0FBED3         MOVSX EDX,BL
0040126D   . D1F8           SAR EAX,1
0040126F   . 40             INC EAX
00401270   . 83EA 02        SUB EDX,2
00401273   . 3BC2           CMP EAX,EDX
00401275   . 0F94C0         SETE AL
00401278   . 880431         MOV BYTE PTR DS:[ECX+ESI],AL
0040127B   . 8B4424 10      MOV EAX,DWORD PTR SS:[ESP+10]
0040127F   . 41             INC ECX
00401280   . 8B50 F8        MOV EDX,DWORD PTR DS:[EAX-8]
00401283   . 4A             DEC EDX
00401284   . 3BCA           CMP ECX,EDX
00401286   .^7C C9          JL SHORT CrackMe_.00401251
........
Última comprobación
........
00401288   > 0FBE1401       MOVSX EDX,BYTE PTR DS:[ECX+EAX]
0040128C   . 0FBE78 01      MOVSX EDI,BYTE PTR DS:[EAX+1]
00401290   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
00401294   . 83C7 FE        ADD EDI,-2
00401297   . 0FBE0401       MOVSX EAX,BYTE PTR DS:[ECX+EAX]
0040129B   . 8D4410 FE      LEA EAX,DWORD PTR DS:[EAX+EDX-2]
0040129F   . 99             CDQ
004012A0   . 2BC2           SUB EAX,EDX
004012A2   . D1F8           SAR EAX,1
004012A4   . 40             INC EAX
004012A5   . 3BC7           CMP EAX,EDI
004012A7   . 0F94C2         SETE DL
004012AA   . 881431         MOV BYTE PTR DS:[ECX+ESI],DL

La comprobación es muy sencilla, en resumen hace esto con todas las letras del nombre excepto la última:

1º Caracter
(1ºname + 1ºserial - 2 = X)
(X / 2)
(X + 1)
(2ºname - 2 = Y)
¿Y = X?
2º Caracter
(2ºname + 2ºserial - 2 = X)
(X / 2)
(X + 1)
(3ºname - 2 = Y)
¿Y = X?
...
Con el último caracter del nombre hace lo siguiente:
(6ºname + 6ºserial - 2 = X)
(X / 2)
(X + 1)
(2ºname - 2 = Y)
¿Y = X?
---------
Para revertir la primera parte de la comprobación para el nombre deurus quedaría:
X1 = (((2ºname-2-1)*2)+2)-1ºname
X2 = (((3ºname-2-1)*2)+2)-2ºname
X3 = (((4ºname-2-1)*2)+2)-3ºname
X4 = (((5ºname-2-1)*2)+2)-4ºname
X5 = (((6ºname-2-1)*2)+2)-5ºname
X6 = (((2ºname-2-1)*2)+2)-6ºname

Keygen

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

var i;
for (i = 0; i < nombre.length-1 ; i++) {
  tmp = ((nombre.charCodeAt(i+1)-2-1)*2+2)-nombre.charCodeAt(i);
  serial += String.fromCharCode(tmp);
}

tmp = ((nombre.charCodeAt(1)-2-1)*2+2)-nombre.charCodeAt(nombre.length-1);
serial += String.fromCharCode(tmp);

document.write(serial);

Enlaces

Y eso es todo, ¡a disfrutar!

crackme Keygen VisionZ

Entrevista a Karpoff de «Karpoff Spanish Tutor»

15 septiembre, 2014 por deurus·Sin comentarios

Karpoff.es

Hace unos días intenté contactar con Karpoff ya que fué una inspiración para mi y muchos otros, lo conseguí y se me ocurrió hacerle una entrevista, aquí tenéis el resultado.

Para los recién llegados diré que, Karpoff Spanish Tutor era (y sigue siendo aunque no se actualice), una gran web colaborativa donde encontrar cantidad de manuales y programas en Castellano.

deurus: ¿Qué te llevó a realizar la web?, es decir, que te hizo levantarte una mañana y decir, venga, voy a realizar una web sobre ingeniería inversa.

Karpoff: Pues mira, fue de la siguiente manera. Por aquel entonces (te hablo de los 90 y poco) yo pasaba mi tiempo libre intentando saltar las protecciones de los programas que conseguía generalmente en revistas de informática.

Desconocía que existía un mundillo dedicado a esas artes.

En los años 90 no había internet ni nada parecido que yo sepa, sobre el 95 creo recordar, telefónica saco una cosa que se llamaba Infobia y era una especie de intranet de telefónica donde accedías a un contenido muy limitado, pero te permitía salir de alguna manera bastante limitada también a lo que conocemos como internet (todo era mega lento, velocidades de uno o dos kb por segundo) con módem y llamadas analógicas.

No se como, ya que no existia o no era conocido Google tampoco había casi buscadores, conocí la famosa y maravillosa pagina de «Fravia» dedicada a la ingeniería inversa con muchísima documentación, y proyectos de estudio de protecciones, lamentablemente para el momento hispano, toda la documentación estaba en ingles .

Investigando conocí paginas hispanas con proyectos interesantes (aunque muchas de ellas aun siendo hispanas publicaban todo en ingles)

Conocí también otra pagina, el “ECD” estudio colectivo de desprotecciones + WTK en castellano e ingles que me sorprendió gratamente y donde se publicaban proyectos propios del grupo WTK y de otros grupos como estado+porcino.

los tres grupos hispanos del momento eran WTK, TNT y KUT, pertenecí a TNT durante algún tiempo, aunque el objetivo del grupo no me convencía ya que era exclusivamente la creación de cracks a mansalva por lo que no estuve más de un año.

Yo echaba de menos un sitio como “Fravia” pero en castellano donde todos los interesados pudiéramos colaborar y ayudarnos con temas de ingeniería inversa.

Ya en los 90 y mucho, todo lo relacionado con internet había evolucionado bastante, las conexiones también eran mas rápidas, ya no hacia falta conectarte a infobia sino directamente a internet.

Yo disponía de mucho tiempo libre y empecé un proyecto en solitario “Karpoff Spanish Tutor” mas conocido como “la pagina de karpoff” con proyectos de mi cosecha y con temas que me gustaban mucho, como la programación, los compiladores el software en general etc.

Luego todo lo demás fue llegando poco a poco, a la gente le gustaba y tenia muchísimas ganas de aprender y sobre todo de colaborar.

El proyecto alcanzo unos niveles impresionantes en cuanto a colaboración y recepción de material, había días que estaba mas de 14 horas actualizando la pagina y buscando nuevos servidores para alojarla, ya que me los cerraban casi semanalmente. Y la verdad.. cada vez me costaba mas tiempo mantener la pagina.

Luego gracias a Red Futura tuvimos un hostin de calidad y gratuito.

El proyecto era tan amplio que me fue imposible conciliar vida laboral y vida en internet todo esto empezaba a ser incompatible.

deurus: ¿Empezaste solo o erais un grupo de amiguetes?

Karpoff: Esta te la he contestado en la primera pregunta, vamos… que empecé yo solo.

deurus: ¿Echas de menos el proyecto?

Karpoff: Hoy en día no. Hace falta muchísimo tiempo libre y muchísima dedicación a nivel organizativo.

Echo de menos el movimiento que se creo y la actividad que alcanzo el movimiento cracking hispano. Salían grupos de cracker con nuevos proyectos y paginas hasta de debajo de las piedras 🙂 la ingenieria inversa se puso un poco de moda, conocí a gente muy interesante como Ricardo Narvaja, Numi_tor, Demian y muchas otras personas con muchos conocimientos.

Después de cerrar la pagina todo se quedo un poco cojo y todo el movimiento se empezó a diluir bastante rápido.

deurus: ¿Lo retomarías día de hoy?

Karpoff: La verdad es que no, ya no es mi tiempo, ahora me dedico al trabajo y mi familia y en ratos libres intento reventar algún programa. Sobre todo crackmes.

deurus: ¿Tienes o colaboras activamente en algún proyecto relacionado con la Ingeniería Inversa?

Karpoff: No, no tengo tiempo. Mantengo contacto por correo con gente de que conocí en esa época y me sorprende que la gente no se olvida de mí. Recibo bastante correo en esta cuenta pidiéndome alguna entrevistilla, opiniones y muchos muchos agradecimientos de mucha gente por la página.

deurus: Yo por aquel entonces tenía 17 años, ¿se le puede preguntar la edad a Karpoff?

Karpoff: Pues yo tengo 45, por aquel entonces tenia unos 29 . La ingeniería inversa siempre fue mi pasión. Desde bien pequeño mi obsesión ha sido conocer como y porque funcionaba todo 🙂 hasta el punto de desmontar todo aquello que me llamaba la atención, mi madre estaba desesperada ya que dejaba todo destripado y muchas veces sin posiblilidad de reparacion.

deurus: ¿Te dedicas a algo relacionado con la informática?

Karpoff: Si, desde esos tiempos me encargo de los sistemas informáticos y equipos técnicos de una empresa bastante conocida, además ese fue uno de los principales motivos del cierre de la página.

Hubo gente interesada en seguir con el proyecto, aunque finalmente todo quedó en nada. Supongo que vieron que el proyecto requería muchísimo tiempo y mucho mucho trabajo.

Me dio mucha lastima no poder seguir con la página y mucha más que nadie se hiciera cargo de ella.

No hace mucho al desaparecer los redireccionadores “come.to” adquirí un dominio “karpoff.es” donde enlace tres mirror de la página para dejar un punto de acceso a ellos.

deurus: Finalmente ¿quieres decir algo a los lectores?

Karpoff: Pues sí, sobre todo dar las gracias a los que me conocen y tuvieron relación con la página, siempre me han hecho sentir grande y siempre tuve mucha colaboración y muchos ánimos por parte de los lectores.

Para los que no me conocen y les gusta la ingeniería inversa, decirles que lo que se aprende crackeando no lo enseñan en ningún sitio 🙂 y es muy muy gratificante.

deurus: Muchas gracias por tu atención, ha sido un placer.

Karpoff: Muchas gracias a ti, me ha hecho mucha ilusión y me ha gustado mucho tu blog.

Saludos !!

Karpoff

crackme crackmes entrevista ingeniería inversa karpoff karpoff spanish tutor

Yoire PE Stage 2 Reversing Challenge (Crackme Very Hard) – eXORcism

26 agosto, 2014 por deurus·Sin comentarios

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

Analizando…

Cargamos el crackme en Ollydbg y vamos a las «Referenced Strings«. Vemos una referencia muy interesante que se llama «checkkey«.

Pinchamos sobre ella y aparecemos aquí:

Vemos una referencia a «GetDlgItemTextA» y depués un Call también interesante, vamos a explorarlo.

Entendiendo la rutina de comprobación del serial

Dentro del Call hay dos bucles, uno realiza una operación con nuestro serial (bucle nombre) y el otro comprueba nuestro serial con «3d34273130276a» dígito a dígito (bucle comprobación).

Bucle nombre se puede resumir así:

MOVSX EAX,BYTE PTR DS:[EBX]   --> Dígito a EAX
XOR EAX,55                    --> EAX xor 55
...
CMP BYTE PTR DS:[EBX],0       --> ¿hemos acabado?
JNZ SHORT 10001022            --> bucle
LEA ECX,DWORD PTR SS:[EBP-20] --> ECX = nuestro serial xoreado

Bucle comprobación se podría resumir así:

MOV EDX,10006000             --> EDX = "3d34273130276a"
...
MOV AL,BYTE PTR DS:[ECX]     --> AL = 1ºdígito serial xoreado
CMP AL,BYTE PTR DS:[ECX+EDX] --> AL = 1ºdígito de EDX?
JNZ SHORT 1000105A           --> Si no son iguales bad boy
INC ECX 

TEST AL,AL
JNZ SHORT 1000104A           --> bucle

Ejemplo para «deurus».

Nombre: d e u r u s
Ascii hex: 64 65 75 72 75 73
XOR 55: 31 30 20 27 20 26

Serial XOReado para deurus sería = 313020272026 que obviamente se aleja bastante de 3d34273130276a.

Por suerte XOR es una función reversible por lo que si revertimos 3d34273130276a nos dará el serial correcto.

Serial correcto XOReado: 3d 34 27 31 30 27 6a
XOR 55: 68 61 72 64 65 72 3F
Valor ascii: h a r d e r ?

Blooper Tech Movie V – Algo huele a podrido en Hawkins

6 noviembre, 2017 por deurus·2 comentarios

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

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

Table of Contents

El PC de la época

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

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

Cracking BASIC or BASIC Cracking?

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

Cracking Basic or Basic Cracking?

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

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

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

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

Referencias

[1] Ficha IMDB – Stranger Thing

[2] Wikia de Stranger Things

[3] IBM 3180

[4] BASIC

Blooper Tech Movie btm Duffer brothers Hawkins ibm 3180 Stranger Things

Solución para el KeyGenMe#3 de T.0.R.N.A.D.0.

3 octubre, 2014 por deurus·Sin comentarios

Table of Contents

Intro

Hoy tenemos aquí un crackme del 2009 originario de crackmes.de. El Crackme está hecho en VB6, sin empacar y consta de 4 tareas a superar. Un anti-debugger, un parcheo, una sorpresa y finalmente un algoritmo sencillo.

Tarea#1 – Anti-Debugger

Nuestro primer incordio es el anti-debbuger. Este lo podemos afrontar de diferentes maneras, con un plugin desde Olly o de forma permanente parcheando. Si elegimos parchear debemos hacerlo en el offset 408328, cambiando el salto je por jmp.

00408328     /0F84 69030000         je T0RNAD0'.00408697

Tarea#2 – Parche

Si iniciamos el crackme nos encontramos con la siguiente nag que nos impide el arranque.

Las referencias de texto parecen encriptadas así que, ponemos un breakpoint a MSVBVM60.rtcMsgBox y vemos que la llamada se hace desde el offset 406897. Un poco más arriba encontramos un salto condicional muy interesante, concretamente en el offset 40677B. Lo cambiamos por un jmp y arrancamos el programa.

Tarea#3 – Encontrando el camino

A continuación arranca el crackme y vemos lo siguiente.

La sorpresa es que el formulario no se mueve y no hay rastro de las cajas de texto del keygenme. Por suerte para nosotros este crackme está hecho en vb6 y como tal podemos abrirlo con VB Reformer para ver que se nos ofrece.

Abrimos VB Reformer y cambiamos la propiedad «Moveable» del formulario a true.

Ahora ya podemos mover el formulario y por suerte para nosotros, si lo movemos hacia la esquina superior izquierda aparecen las cajas de texto por arte de magia.

Tarea#4 – El keygen

Como hemos dicho antes, las referencias de texto son inútiles, de modo que ponemos un breakpoint a MSVBVM60.__vbaStrCmp y enseguida obtenemos nuestro primer serial válido. También nos percatamos de que hasta que no metemos en el nombre 8 dígitos, no nos muestra un mensaje de error. De este mismo modo obtenemos que el nombre más grande puede tener 30 dígitos.

    Username: deurusab (lenght 8)
    0012F3F0   0040533A  RETURN to T0RNAD0'.0040533A from MSVBVM60.__vbaStrCmp
    0012F3F4   0015C954  UNICODE "L-8-deurus-0199F9CA"
    
    Username: abcdefghijklmnopqrstuvwxyz1234 (lenght 30)
    0012F3F0   0040533A  RETURN to T0RNAD0'.0040533A from MSVBVM60.__vbaStrCmp
    0012F3F4   0015F40C  UNICODE "L-30-lmnopq-DD19F9CA"

Finalmente llegamos a la rutina de comprobación del serial. Usaremos como nombre: abcdefghijklmnopqrstuvwxyz1234.

00404E82   .  52                    push edx
00404E83   .  56                    push esi
00404E84   .  C746 34 0DF0D1BA      mov dword ptr ds:[esi+34],BAD1F00D                                                    |Variables cachondas
00404E8B   .  C746 38 01ADDE10      mov dword ptr ds:[esi+38],10DEAD01                                                    |Variables cachondas
00404E92   .  C746 3C EFBE1010      mov dword ptr ds:[esi+3C],1010BEEF                                                    |Variables cachondas
00404E99   .  C746 40 D0BA0110      mov dword ptr ds:[esi+40],1001BAD0                                                    |Variables cachondas
00404EA0   .  FF91 2C070000         call ds:[ecx+72C]
00404EA6   .  3BC7                  cmp eax,edi
00404EA8   .  DBE2                  fclex
00404EAA   .  7D 12                 jge short T0RNAD0'.00404EBE
00404EAC   .  68 2C070000           push 72C
00404EB1   .  68 14404000           push T0RNAD0'.00404014
00404EB6   .  56                    push esi
00404EB7   .  50                    push eax
00404EB8   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
00404EBE   >  8B45 B4               mov eax,ss:[ebp-4C]
00404EC1   .  8D55 E0               lea edx,ss:[ebp-20]
00404EC4   .  52                    push edx
00404EC5   .  50                    push eax
00404EC6   .  8B08                  mov ecx,ds:[eax]
00404EC8   .  8985 48FFFFFF         mov ss:[ebp-B8],eax
00404ECE   .  FF91 A0000000         call ds:[ecx+A0]
00404ED4   .  3BC7                  cmp eax,edi
00404ED6   .  DBE2                  fclex
00404ED8   .  7D 18                 jge short T0RNAD0'.00404EF2
00404EDA   .  8B8D 48FFFFFF         mov ecx,ss:[ebp-B8]
00404EE0   .  68 A0000000           push 0A0
00404EE5   .  68 7C414000           push T0RNAD0'.0040417C
00404EEA   .  51                    push ecx
00404EEB   .  50                    push eax
00404EEC   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
00404EF2   >  8B45 E0               mov eax,ss:[ebp-20]                                                                       |Mueve el nombre a eax
00404EF5   .  8D55 A0               lea edx,ss:[ebp-60]
00404EF8   .  8945 A8               mov ss:[ebp-58],eax
00404EFB   .  6A 01                 push 1
00404EFD   .  8D45 90               lea eax,ss:[ebp-70]
00404F00   .  52                    push edx
00404F01   .  50                    push eax
00404F02   .  897D E0               mov ss:[ebp-20],edi
00404F05   .  C745 A0 08000000      mov dword ptr ss:[ebp-60],8
00404F0C   .  FF15 40114000         call ds:[<&MSVBVM60.#619>]                     ;  MSVBVM60.rtcRightCharVar
00404F12   .  8B3D D0104000         mov edi,ds:[<&MSVBVM60.__vbaStrVarVal>]        ;  MSVBVM60.__vbaStrVarVal
00404F18   .  8D4D 90               lea ecx,ss:[ebp-70]
00404F1B   .  8D55 DC               lea edx,ss:[ebp-24]
00404F1E   .  51                    push ecx
00404F1F   .  52                    push edx
00404F20   .  FFD7                  call edi                                       ;  <&MSVBVM60.__vbaStrVarVal>
00404F22   .  50                    push eax
00404F23   .  FF15 30104000         call ds:[<&MSVBVM60.#516>]                     ;  MSVBVM60.rtcAnsiValueBstr                |Toma el último dígito en ascii (4 asc = 34)
00404F29   .  66:6BC0 7B            imul ax,ax,7B                                                                              |34 * 7B = 18FC
00404F2D   .  8B4E 34               mov ecx,ds:[esi+34]                                                                        |Mueve BAD1F00D a ecx
00404F30   .  0F80 05070000         jo T0RNAD0'.0040563B
00404F36   .  0FBFC0                movsx eax,ax
00404F39   .  33C8                  xor ecx,eax                                                                                |18FC xor BAD1F00D = BAD1E8F1
00404F3B   .  894E 34               mov ds:[esi+34],ecx
00404F3E   .  8D4D DC               lea ecx,ss:[ebp-24]
00404F41   .  FF15 5C114000         call ds:[<&MSVBVM60.__vbaFreeStr>]             ;  MSVBVM60.__vbaFreeStr
00404F47   .  8D4D B4               lea ecx,ss:[ebp-4C]
00404F4A   .  FF15 60114000         call ds:[<&MSVBVM60.__vbaFreeObj>]             ;  MSVBVM60.__vbaFreeObj
00404F50   .  8D4D 90               lea ecx,ss:[ebp-70]
00404F53   .  8D55 A0               lea edx,ss:[ebp-60]
00404F56   .  51                    push ecx
00404F57   .  52                    push edx
00404F58   .  6A 02                 push 2
00404F5A   .  FF15 20104000         call ds:[<&MSVBVM60.__vbaFreeVarList>]         ;  MSVBVM60.__vbaFreeVarList
00404F60   .  8B06                  mov eax,ds:[esi]
00404F62   .  83C4 0C               add esp,0C
00404F65   .  8D4D B4               lea ecx,ss:[ebp-4C]
00404F68   .  51                    push ecx
00404F69   .  56                    push esi
00404F6A   .  FF90 2C070000         call ds:[eax+72C]
00404F70   .  85C0                  test eax,eax
00404F72   .  DBE2                  fclex
00404F74   .  7D 12                 jge short T0RNAD0'.00404F88
00404F76   .  68 2C070000           push 72C
00404F7B   .  68 14404000           push T0RNAD0'.00404014
00404F80   .  56                    push esi
00404F81   .  50                    push eax
00404F82   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
00404F88   >  8B45 B4               mov eax,ss:[ebp-4C]
00404F8B   .  8D4D E0               lea ecx,ss:[ebp-20]
00404F8E   .  51                    push ecx
00404F8F   .  50                    push eax
00404F90   .  8B10                  mov edx,ds:[eax]
00404F92   .  8985 48FFFFFF         mov ss:[ebp-B8],eax
00404F98   .  FF92 A0000000         call ds:[edx+A0]
00404F9E   .  85C0                  test eax,eax
00404FA0   .  DBE2                  fclex
00404FA2   .  7D 18                 jge short T0RNAD0'.00404FBC
00404FA4   .  8B95 48FFFFFF         mov edx,ss:[ebp-B8]
00404FAA   .  68 A0000000           push 0A0
00404FAF   .  68 7C414000           push T0RNAD0'.0040417C
00404FB4   .  52                    push edx
00404FB5   .  50                    push eax
00404FB6   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
00404FBC   >  8B45 E0               mov eax,ss:[ebp-20]
00404FBF   .  6A 01                 push 1
00404FC1   .  8945 A8               mov ss:[ebp-58],eax
00404FC4   .  8D45 A0               lea eax,ss:[ebp-60]
00404FC7   .  8D4D 90               lea ecx,ss:[ebp-70]
00404FCA   .  50                    push eax
00404FCB   .  51                    push ecx
00404FCC   .  C745 E0 00000000      mov dword ptr ss:[ebp-20],0
00404FD3   .  C745 A0 08000000      mov dword ptr ss:[ebp-60],8
00404FDA   .  FF15 2C114000         call ds:[<&MSVBVM60.#617>]                     ;  MSVBVM60.rtcLeftCharVar                    
00404FE0   .  8D55 90               lea edx,ss:[ebp-70]
00404FE3   .  8D45 DC               lea eax,ss:[ebp-24]
00404FE6   .  52                    push edx
00404FE7   .  50                    push eax
00404FE8   .  FFD7                  call edi
00404FEA   .  50                    push eax
00404FEB   .  FF15 30104000         call ds:[<&MSVBVM60.#516>]                     ;  MSVBVM60.rtcAnsiValueBstr                |Toma el primer dígito en ascii (a asc = 61)
00404FF1   .  66:6BC0 7B            imul ax,ax,7B                                                                              |61 * 7B = 2E9B
00404FF5   .  8B56 3C               mov edx,ds:[esi+3C]                                                                        |Mueve 1010BEEF a edx
00404FF8   .  0F80 3D060000         jo T0RNAD0'.0040563B
00404FFE   .  0FBFC8                movsx ecx,ax
00405001   .  33D1                  xor edx,ecx                                                                                | 2E9B xor 1010BEEF = 10109074
00405003   .  8D4D DC               lea ecx,ss:[ebp-24]
00405006   .  8956 3C               mov ds:[esi+3C],edx
00405009   .  FF15 5C114000         call ds:[<&MSVBVM60.__vbaFreeStr>]             ;  MSVBVM60.__vbaFreeStr
0040500F   .  8D4D B4               lea ecx,ss:[ebp-4C]
00405012   .  FF15 60114000         call ds:[<&MSVBVM60.__vbaFreeObj>]             ;  MSVBVM60.__vbaFreeObj
00405018   .  8D55 90               lea edx,ss:[ebp-70]
0040501B   .  8D45 A0               lea eax,ss:[ebp-60]
0040501E   .  52                    push edx
0040501F   .  50                    push eax
00405020   .  6A 02                 push 2
00405022   .  FF15 20104000         call ds:[<&MSVBVM60.__vbaFreeVarList>]         ;  MSVBVM60.__vbaFreeVarList
00405028   .  66:8BCB               mov cx,bx                                                                                 |Mueve a CX el tamaño del nombre
0040502B   .  83C4 0C               add esp,0C
0040502E   .  66:69C9 4101          imul cx,cx,141                                                                            |Tamaño nombre(1E) * 141 = 259E
00405033   .  8B46 3C               mov eax,ds:[esi+3C]
00405036   .  0F80 FF050000         jo T0RNAD0'.0040563B
0040503C   .  0FBFD1                movsx edx,cx
0040503F   .  8B4E 38               mov ecx,ds:[esi+38]                                                                       |Mueve a ECX 10DEAD01
00405042   .  33D0                  xor edx,eax                                                                               |10109074 xor 259E = 1010B5BA
00405044   .  33CA                  xor ecx,edx                                                                               |1010B5BA xor 10DEAD01 = 00CE18EB
00405046   .  66:8BD3               mov dx,bx
00405049   .  66:69D2 4101          imul dx,dx,141                                                                            |Tamaño nombre(1E) * 141 = 259E
0040504E   .  0F80 E7050000         jo T0RNAD0'.0040563B
00405054   .  894E 38               mov ds:[esi+38],ecx
00405057   .  81F1 01010101         xor ecx,1010101                                                                           |00CE18EB xor 1010101 = 01CF19EA (Temp1)
0040505D   .  0FBFD2                movsx edx,dx
00405060   .  3356 34               xor edx,ds:[esi+34]                                                                       |BAD1E8F1 xor 259E = BAD1CD6F
00405063   .  894E 38               mov ds:[esi+38],ecx
00405066   .  35 10101010           xor eax,10101010                                                                          |10109074 xor 10101010 = 8064
0040506B   .  8D4D B4               lea ecx,ss:[ebp-4C]
0040506E   .  3156 40               xor ds:[esi+40],edx                                                                       |BAD1CD6F xor 1001BAD0 = AAD077BF (Temp2)
00405071   .  8946 3C               mov ds:[esi+3C],eax
00405074   .  8B06                  mov eax,ds:[esi]
00405076   .  51                    push ecx
00405077   .  56                    push esi
00405078   .  FF90 2C070000         call ds:[eax+72C]
0040507E   .  85C0                  test eax,eax
00405080   .  DBE2                  fclex
00405082   .  7D 12                 jge short T0RNAD0'.00405096
00405084   .  68 2C070000           push 72C
00405089   .  68 14404000           push T0RNAD0'.00404014
0040508E   .  56                    push esi
0040508F   .  50                    push eax
00405090   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
00405096   >  8B45 B4               mov eax,ss:[ebp-4C]
00405099   .  8D4D DC               lea ecx,ss:[ebp-24]
0040509C   .  51                    push ecx
0040509D   .  50                    push eax
0040509E   .  8B10                  mov edx,ds:[eax]
004050A0   .  8985 48FFFFFF         mov ss:[ebp-B8],eax
004050A6   .  FF92 A0000000         call ds:[edx+A0]
004050AC   .  85C0                  test eax,eax
004050AE   .  DBE2                  fclex
004050B0   .  7D 18                 jge short T0RNAD0'.004050CA
004050B2   .  8B95 48FFFFFF         mov edx,ss:[ebp-B8]
004050B8   .  68 A0000000           push 0A0
004050BD   .  68 7C414000           push T0RNAD0'.0040417C
004050C2   .  52                    push edx
004050C3   .  50                    push eax
004050C4   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
004050CA   >  8B06                  mov eax,ds:[esi]
004050CC   .  8D4D B0               lea ecx,ss:[ebp-50]
004050CF   .  51                    push ecx
004050D0   .  56                    push esi
004050D1   .  FF90 2C070000         call ds:[eax+72C]
004050D7   .  85C0                  test eax,eax
004050D9   .  DBE2                  fclex
004050DB   .  7D 12                 jge short T0RNAD0'.004050EF
004050DD   .  68 2C070000           push 72C
004050E2   .  68 14404000           push T0RNAD0'.00404014
004050E7   .  56                    push esi
004050E8   .  50                    push eax
004050E9   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
004050EF   >  8B45 B0               mov eax,ss:[ebp-50]
004050F2   .  8D4D D0               lea ecx,ss:[ebp-30]
004050F5   .  51                    push ecx
004050F6   .  50                    push eax
004050F7   .  8B10                  mov edx,ds:[eax]
004050F9   .  8985 3CFFFFFF         mov ss:[ebp-C4],eax
004050FF   .  FF92 A0000000         call ds:[edx+A0]
00405105   .  85C0                  test eax,eax
00405107   .  DBE2                  fclex
00405109   .  7D 18                 jge short T0RNAD0'.00405123
0040510B   .  8B95 3CFFFFFF         mov edx,ss:[ebp-C4]
00405111   .  68 A0000000           push 0A0
00405116   .  68 7C414000           push T0RNAD0'.0040417C
0040511B   .  52                    push edx
0040511C   .  50                    push eax
0040511D   .  FF15 40104000         call ds:[<&MSVBVM60.__vbaHresultCheckObj>]     ;  MSVBVM60.__vbaHresultCheckObj
00405123   >  8B45 D0               mov eax,ss:[ebp-30]
00405126   .  6A 01                 push 1
00405128   .  8945 98               mov ss:[ebp-68],eax
0040512B   .  8D45 90               lea eax,ss:[ebp-70]
0040512E   .  8D4D 80               lea ecx,ss:[ebp-80]
00405131   .  50                    push eax
00405132   .  51                    push ecx
00405133   .  C745 A8 06000000      mov dword ptr ss:[ebp-58],6
0040513A   .  C745 A0 02000000      mov dword ptr ss:[ebp-60],2
00405141   .  C745 D0 00000000      mov dword ptr ss:[ebp-30],0
00405148   .  C745 90 08000000      mov dword ptr ss:[ebp-70],8
0040514F   .  FF15 40114000         call ds:[<&MSVBVM60.#619>]                     ;  MSVBVM60.rtcRightCharVar
00405155   .  8D55 80               lea edx,ss:[ebp-80]
00405158   .  8D45 CC               lea eax,ss:[ebp-34]
0040515B   .  52                    push edx
0040515C   .  50                    push eax
0040515D   .  FFD7                  call edi
0040515F   .  50                    push eax
00405160   .  FF15 30104000         call ds:[<&MSVBVM60.#516>]                     ;  MSVBVM60.rtcAnsiValueBstr
00405166   .  8B56 40               mov edx,ds:[esi+40]                                                                   |Mueve a EDX AAD077BF (Temp2)
00405169   .  68 90414000           push T0RNAD0'.00404190                         ;  UNICODE "L-"                        |Comienza el serial
0040516E   .  0FBFC8                movsx ecx,ax                                                                          |Mueve a ECX último dígito en ascii (34)
00405171   .  8B46 38               mov eax,ds:[esi+38]                                                                   |Mueve a EAX 01CF19EA (Temp1)
00405174   .  53                    push ebx                                                                                                                                                    
00405175   .  03D0                  add edx,eax                                                                           |AAD077BF + 01CF19EA = AC9F91A9
00405177   .  C785 70FFFFFF 0300000>mov dword ptr ss:[ebp-90],3
00405181   .  0F80 B4040000         jo T0RNAD0'.0040563B
00405187   .  03CA                  add ecx,edx                                                                           |AC9F91A9 + 34 = AC9F91DD (Nuestro serial)
00405189   .  0F80 AC040000         jo T0RNAD0'.0040563B
0040518F   .  898D 78FFFFFF         mov ss:[ebp-88],ecx
00405195   .  FF15 04104000         call ds:[<&MSVBVM60.__vbaStrI2>]               ;  MSVBVM60.__vbaStrI2
0040519B   .  8B3D 38114000         mov edi,ds:[<&MSVBVM60.__vbaStrMove>]          ;  MSVBVM60.__vbaStrMove
004051A1   .  8BD0                  mov edx,eax
004051A3   .  8D4D E0               lea ecx,ss:[ebp-20]
004051A6   .  FFD7                  call edi                                       ;  <&MSVBVM60.__vbaStrMove>
004051A8   .  50                    push eax                                                                              |EAX = tamaño del nombre
004051A9   .  FF15 38104000         call ds:[<&MSVBVM60.__vbaStrCat>]              ;  MSVBVM60.__vbaStrCat                |Concatena con "L-"
004051AF   .  8BD0                  mov edx,eax
004051B1   .  8D4D BC               lea ecx,ss:[ebp-44]
004051B4   .  FFD7                  call edi
004051B6   .  66:83EB 06            sub bx,6                                                                              |Tamaño nombre - 6 = 18
004051BA   .  50                    push eax
004051BB   .  0F80 7A040000         jo T0RNAD0'.0040563B
004051C1   .  0FBFCB                movsx ecx,bx
004051C4   .  898D 08FFFFFF         mov ss:[ebp-F8],ecx
004051CA   .  8D45 A0               lea eax,ss:[ebp-60]
004051CD   .  DB85 08FFFFFF         fild dword ptr ss:[ebp-F8]
004051D3   .  68 9C414000           push T0RNAD0'.0040419C
004051D8   .  50                    push eax
004051D9   .  DD9D 00FFFFFF         fstp qword ptr ss:[ebp-100]
004051DF   .  DD85 00FFFFFF         fld qword ptr ss:[ebp-100]
004051E5   .  833D 00A04000 00      cmp dword ptr ds:[40A000],0
004051EC   .  75 08                 jnz short T0RNAD0'.004051F6
004051EE   .  DC35 78114000         fdiv qword ptr ds:[401178]                                       |18 / 2 = C (C es la posición para cojer dígitos del nombre, coje 6)
004051F4   .  EB 11                 jmp short T0RNAD0'.00405207
004051F6   >  FF35 7C114000         push dword ptr ds:[40117C]
004051FC   .  FF35 78114000         push dword ptr ds:[401178]
00405202   .  E8 3DC0FFFF           call <jmp.&MSVBVM60._adj_fdiv_m64>
00405207   >  DFE0                  fstsw ax
00405209   .  A8 0D                 test al,0D
0040520B   .  0F85 25040000         jnz T0RNAD0'.00405636
00405211   .  FF15 44114000         call ds:[<&MSVBVM60.__vbaR8IntI4>]             ;  MSVBVM60.__vbaR8IntI4
00405217   .  8B55 DC               mov edx,ss:[ebp-24]                                                                   |EDX = nombre
0040521A   .  50                    push eax                                                                              |Eax = C
0040521B   .  52                    push edx
0040521C   .  FF15 6C104000         call ds:[<&MSVBVM60.#631>]                     ;  MSVBVM60.rtcMidCharBstr             |Mid(nombre,C,6) = "lmnopq"
00405222   .  8BD0                  mov edx,eax
00405224   .  8D4D D8               lea ecx,ss:[ebp-28]
00405227   .  FFD7                  call edi
00405229   .  8B1D 38104000         mov ebx,ds:[<&MSVBVM60.__vbaStrCat>]           ;  MSVBVM60.__vbaStrCat
0040522F   .  50                    push eax
00405230   .  FFD3                  call ebx                                       ;  <&MSVBVM60.__vbaStrCat>            |Concatena "-lmnopq"
00405232   .  8BD0                  mov edx,eax
00405234   .  8D4D D4               lea ecx,ss:[ebp-2C]
00405237   .  FFD7                  call edi
00405239   .  50                    push eax
0040523A   .  68 9C414000           push T0RNAD0'.0040419C
0040523F   .  FFD3                  call ebx                                                                             |Concatena "-lmnopq-"
00405241   .  8BD0                  mov edx,eax
00405243   .  8D4D C4               lea ecx,ss:[ebp-3C]
00405246   .  FFD7                  call edi
00405248   .  50                    push eax
00405249   .  8D85 70FFFFFF         lea eax,ss:[ebp-90]
0040524F   .  50                    push eax
00405250   .  FF15 F0104000         call ds:[<&MSVBVM60.#572>]                     ;  MSVBVM60.rtcHexBstrFromVar         |serial "AC9F91DD"
00405256   .  8BD0                  mov edx,eax
00405258   .  8D4D C8               lea ecx,ss:[ebp-38]
0040525B   .  FFD7                  call edi
0040525D   .  50                    push eax
0040525E   .  FF15 B4104000         call ds:[<&MSVBVM60.#713>]                     ;  MSVBVM60.rtcStrReverse             |Invierte el serial "DD19F9CA"
00405264   .  8BD0                  mov edx,eax
00405266   .  8D4D C0               lea ecx,ss:[ebp-40]
00405269   .  FFD7                  call edi
0040526B   .  50                    push eax
0040526C   .  FFD3                  call ebx                                                                             |Concatena "-lmnopq-DD19F9CA"
0040526E   .  8BD0                  mov edx,eax
00405270   .  8D4D B8               lea ecx,ss:[ebp-48]
00405273   .  FFD7                  call edi
00405275   .  50                    push eax
00405276   .  FFD3                  call ebx                                                                             |Concatena "L-30-lmnopq-DD19F9CA"
...
00405334   .  FF15 80104000         call ds:[<&MSVBVM60.__vbaStrCmp>]              ;  MSVBVM60.__vbaStrCmp               |Comparación final

Ejemplos:

Nombre: abcdefghijklmnopqrstuvwxyz1234

Serial: L-30-lmnopq-DD19F9CA

Nombre: deurus2014

Serial: L-10-eurus2-84D8F9CA

Stego – Bytes en bruto

15 diciembre, 2025 por deurus·Sin comentarios

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

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

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

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

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

import numpy as np
from PIL import Image

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

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

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

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

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

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

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

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

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

challenge reto stego stride

Andy’s Keygenme Keygen (AutoIt)

2 septiembre, 2014 por deurus·Sin comentarios

Introducción

Hoy vamos a ver como extraer el script de un ejecutable compilado por Autoit, modificarlo y recompilarlo como nuestro keygen. Como comprobareis si no se ofusca o se toman otro tipo de medidas recuperar información sensible es muy sencillo.

AutoIt es un lenguaje freeware multiproposito y de automatización para Microsoft Windows. Es un Visual Basic Killer, ya que mejora las características de los ejecutables (entre otras portabilidad, velocidad y peso, no fat-coding), y facilitan la programación con un buen repertorio de funciones «pre-diseñadas», y usando un Basic de fácil aprendizaje. Se ha expandido desde sus comienzos de automatización incluyendo muchas mejoras en el diseño del lenguaje de programación y sobre todo en nuevas funcionalidades.

El Script

Func CHECKKEY($USER, $PASS)
Local $OPKEY = "", $SIG = ""
Local $USER_LEN = StringLen($USER)
Local $PASS_LEN = StringLen($PASS)
If $USER_LEN < $PASS_LEN Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
ElseIf $USER_LEN < 4 Then
MsgBox(0, "ERROR", "Invalid username or key.")
Exit
EndIf
$PASS_INT = Int($USER_LEN / $PASS_LEN)
$PASS_MOD = Mod($USER_LEN, $PASS_LEN)
$OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
For $INDEX = 1 To $USER_LEN
$SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
Next
If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
MsgBox(0, "INFO", "Your key was registered.")
Exit
Else
MsgBox(0, "INFO", "Your key is invalid.")
EndIf
EndFunc

El Algoritmo

El algoritmo es tremendamente sencillo ya que es nuestro nombre al revés y en mayúsculas.

Modificando el script para generar nuestro propio keygen

El decompilador se llama myAut2exe y tiene este aspecto.

Programar en AutoIt es muy sencillo e intuitivo. Nuestro keygen quedaría así.

$MAIN = GUICreate("Another keygen by deurus", 300, 80, -1, -1, 382205952, 385)
$NAME_LBL = GUICtrlCreateLabel("Username", 5, 5, 60, 20, BitOR(4096, 1))
$NAME_INP = GUICtrlCreateInput("", 70, 5, 225, 20, 1)
$PASS_LBL = GUICtrlCreateLabel("Key", 5, 30, 60, 20, BitOR(4096, 1))
$PASS_INP = GUICtrlCreateInput("", 70, 30, 225, 20, 1)
$REGISTER = GUICtrlCreateButton("Register", 5, 55, 60, 20)
$GIVE_UP = GUICtrlCreateButton("Generate", 70, 55, 60, 20)    <- Change name of button, Give Up by Generate
$TASK = GUICtrlCreateButton("?", 140, 55, 20, 20)
$AUTHOR = GUICtrlCreateLabel("keygen by deurus", 165, 55, 130, 20, BitOR(4096, 1))
GUISetState(@SW_SHOW, $MAIN)
While True
    $MSG = GUIGetMsg()
    Switch $MSG
        Case $REGISTER
            Call("CHECKKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))
        Case $GIVE_UP
            Call("GETKEY", GUICtrlRead($NAME_INP), GUICtrlRead($PASS_INP))    <- Add the function to the button
        Case $TASK
            MsgBox(0, "Info", "keygen by deurus")
        Case - 3
            Exit
    EndSwitch
    Sleep(15)
WEnd

Func GETKEY($USER, $PASS)        <- this is our keygen function
    Local $OPKEY = "", $SIG = ""
    Local $USER_LEN = StringLen($USER)
    Local $PASS_LEN = StringLen($USER)
    If $USER_LEN < 4 Then
        GUICtrlSetData($PASS_INP  ,"min 4 chars");
    Else
    For $INDEX = 1 To $USER_LEN
        $SIG = Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), 32)) & $SIG
    Next
        GUICtrlSetData($PASS_INP  ,$SIG);
    EndIf
EndFunc

Func CHECKKEY($USER, $PASS)        <- check function, the original
    Local $OPKEY = "", $SIG = ""
    Local $USER_LEN = StringLen($USER)
    Local $PASS_LEN = StringLen($PASS)
    If $USER_LEN < $PASS_LEN Then
        MsgBox(0, "ERROR", "Invalid username or key.")
    ElseIf $USER_LEN < 4 Then
        MsgBox(0, "ERROR", "Invalid username or key.")
        Exit
    EndIf
    $PASS_INT = Int($USER_LEN / $PASS_LEN)
    $PASS_MOD = Mod($USER_LEN, $PASS_LEN)
    $OPKEY = _STRINGREPEAT($PASS, $PASS_INT) & StringLeft($PASS, $PASS_MOD)
    For $INDEX = 1 To $USER_LEN
        $SIG &= Chr(BitXOR(Asc(StringMid($USER, $INDEX, 1)), Asc(StringMid($OPKEY, $USER_LEN - $INDEX + 1, 1))))
    Next
    If $SIG = _STRINGREPEAT(Chr(32), $USER_LEN) Then
        MsgBox(0, "INFO", "Your key was registered.")
    Else
        MsgBox(0, "INFO", "Your key is invalid.")
    EndIf
EndFunc

Este es el resultado.

Links

Stego - Bytes en bruto

Toda esta aventura comienza con un archivo llamado pretty_raw, sin extensión. Porque sí. Porque las extensiones son una invención heredada

Blooper Tech Movie III – Mentiras arriesgadas

Continuamos con los BTM awards. Esta vez analizaremos brevemente una escena de la película del casi siempre excelente James Cameron,

Blooper Tech Movie VI - Dexter 1x08 (S01E08)

Hace poco me puse a leer El oscuro pasajero de Jeff Lindsay, novela que inspiró la serie Dexter. La nostalgia

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

1 2 3 … 30 Next »

challenge reto stego stride

Stego – Bytes en bruto

15 diciembre, 2025 por deurus·Sin comentarios

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

import numpy as np
from PIL import Image

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

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

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

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

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

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

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

challenge reto stego stride

Blooper Tech Movie III – Mentiras arriesgadas

26 noviembre, 2015 por deurus·Sin comentarios

Continuamos con los BTM awards. Esta vez analizaremos brevemente una escena de la película del casi siempre excelente James Cameron, Mentiras Arriesgadas. En esta ocasión vamos a analizar una situación que se da mucho en el cine de Hollywood, esto es, el Plug and Play mágico. Cuando vemos películas de espías, es habitual encontrarnos con situaciones en las que el protagonista conecta un «algo» en el ordenador al que quiere acceder y ¡chas!, como por arte de magia sin tocar ninguna tecla se copian o se borran unos archivos, le da acceso remoto a algún compañero etc.

BTM

Este film no iba a ser menos y es que cuando Harry Tasker (Arnold Schwarzenegger) con sus inigualables dotes para el espionaje, entra en la mansión del objetivo en cuestión, conecta un módem, lo enciende y sin teclear un solo comando le da a su compañero Faisil (Grant Heslov) que se encuentra en una furgoneta a unos kilómetros, acceso a la máquina, nos quedamos perplejos.

Esta situación es posible en la vida real, lo que la hace difícil de creer es que Harry no teclee ni un solo comando al conectar el módem, independientemente del Sistema Operativo que corra la máquina. Si nos situamos un poco, estamos hablando del año 1995, con una máquina corriendo Windows 3.1 y estamos conectando un módem a un puerto RS-232. En aquella época, por avanzada que fuera la tecnología espía, es difícil de creer que las cosas funcionen solas. Otra cosa a destacar es que a no ser que Faisil estuviera conectados a un poste de teléfono, la conexión tendría que ser inalámbrica, casi una quimera hace 20 años. A continuación os muestro la secuencia.

Como se puede observar en el vídeo, incluso parece que el equipo de Faisil, que también corre Windows 3.1, accede al equipo en modo escritorio remoto, tecnología que no existía en aquella época. Para que la secuencia tuviera un mínimo de credibilidad, Harry al conectar el módem y encender el equipo, debiera de haber introducido un par de comandos como mínimo para asignarle un puerto COM al módem y así iniciar la comunicación con Faisil. Ni que decir tiene que Faisil hubiera tenido que hacer todas las transmisiones mediante línea de comandos.

Aunque la película es entretenida y me gustó mucho cuando la vi allá por el año 1998, no nos queda más remedio que ponerle nuestro sello BTM de NO credibilidad.

Enlaces

Otros posts que te pueden interesar

Stego d33p

En este reto se nos entrega un archivo WAV de 9,92 MB. Tras escucharlo y analizarlo por encima con Audacity

¿El crackme de android más famoso del mundo?

Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar

Solución al KeyGenMe1 (RSA127) de C00lw0lf

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

Blooper Tech Movie XII – Enemigo público

Sinopsis Enemigo público (Enemy of the State) es una película de acción y suspense dirigida por Tony Scott, estrenada en

bytes XOR deepsound hex editor steghide stego xor

Stego d33p

1 mayo, 2023 por deurus·Sin comentarios

En este reto se nos entrega un archivo WAV de 9,92 MB. Tras escucharlo y analizarlo por encima con Audacity no llego a ningún lado por lo que me tiro al descarte de herramientas conocidas, y en ésta ocasión sale a escena DeepSound.

Sin más dilación extraemos el JPG y continuamos.

La aparición en escena de DeepSound me hace sospechar sobre el uso de herramientas conocidas y ¡bingo!, sale a escena StegHide. En esta ocasión el autor del reto nos lo ha puesto fácil y la extracción no requiere clave.

Al abrir el archivo TXT como texto vemos lo siguiente:

y si lo abrimos con un editor hexadecimal vemos esto otro:

Claramente el archivo esconde algo que por la repetición de los caracteres me hace sospechar de un simple XOR y efectivamente la flag está XOReada. Tras un ataque preliminar, digamos que los árboles no me dejaban ver el bosque, de modo que limpié los bytes correspondientes a la frase «this 󠁓󠁈󠁓󠁻󠁴is 󠀰󠀰󠁟󠀳󠀴the 󠁳󠁹󠁟󠁭󠀴flag 󠁮󠁽󠀠:)» y procesé de nuevo obteniendo por fin la ansiada flag.

RAW bytes
FF FE 74 00 68 00 69 00 73 00 20 00 40 DB 53 DC 40 DB 48 DC 40 DB 53 DC 40 DB 7B DC 40 DB 74 DC 69 00 73 00 20 00 40 DB 30 DC 40 DB 30 DC 40 DB 5F DC 40 DB 33 DC 40 DB 34 DC 74 00 68 00 65 00 20 00 40 DB 73 DC 40 DB 79 DC 40 DB 5F DC 40 DB 6D DC 40 DB 34 DC 66 00 6C 00 61 00 67 00 20 00 40 DB 6E DC 40 DB 7D DC 40 DB 20 DC 3A 00 29 00

Cleaned bytes [quitando this 󠁓󠁈󠁓󠁻󠁴is 󠀰󠀰󠁟󠀳󠀴the 󠁳󠁹󠁟󠁭󠀴flag 󠁮󠁽󠀠:)]
FF FE 40 DB 53 DC 40 DB 48 DC 40 DB 53 DC 40 DB 7B DC 40 DB 74 DC 40 DB 30 DC 40 DB 30 DC 40 DB 5F DC 40 DB 33 DC 40 DB 34 DC 40 DB 73 DC 40 DB 79 DC 40 DB 5F DC 40 DB 6D DC 40 DB 34 DC 40 DB 6E DC 40 DB 7D DC 40 DB 20 DC


clave XOR == 00fc60fb

Resultado
S   H   S   {   t   0   0   _   3   4   s   y   _   m   4   n   }

bytes XOR deepsound hex editor steghide stego xor

¿El crackme de android más famoso del mundo?

24 mayo, 2015 por deurus·1 comentario

Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar una serie de crackmes. Los dos primeros pasaron algo desapercibidos, pero el Crackme nº3 tuvo una gran repercusión en el mundillo y, aunque no fue el primer crackme para Android ni mucho menos, si que fue uno de los más estudiados. Todos ellos fueron publicados a través de crackmes.de y el nº3 en cuestión el 6 de Noviembre de 2010. Os dejo una lista de unas cuantas webs donde aparece analizado para que veáis la repercusión que a mi parecer tuvo.

Soluciones al crackme

Referencias al crackme

Android High Performance Programming (Libro)

Links

Canyouhack.it – Crack Challenge 4 (Brain Fuck Me)

Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de

Stego X - Chunk

Intro Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir

ideku_nih's Code this Keygen

Introducción Hoy tenemos aquí un crackme hecho en Visual Basic 6 (pcode), pero lo vamos a abordar de una manera

Retos de Criptografía

Los retos de criptografía pueden ser muy variados como he dicho anteriormente. El secreto suele estar en saber a que

1 2 3 … 30 Next »

brainfuck canyouhackit

Canyouhack.it – Crack Challenge 4 (Brain Fuck Me)

13 abril, 2017 por deurus·Sin comentarios

Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de programación esotérico bastante complejo.

[-]>[-]<>++++++++[<++++++++++>-]<.+++++++++++++++++.>+++[<++++++>-]<..++++.-
-------.+++.--------------.>++++++[<------>-]<-.>+++++[<------>-]<-.,>,>,>,>
>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++
+++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++>>>>++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<
<<<<<<<<<<<<<<<<[>>>>>>>-<<<<<<<-]>>>>>>><<+>>[[-]++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.<]<[>]<<<<<[>>>>>>>>>>-<<<<<<<<
<<-]>>>>>>>>>><<+>>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++.<]<[>]<<<<<<<<[>>>>>>>>>>>>>-<<<<<<<<<<<<<-]>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.<]<[>]<<<<<<<<<<<[>>>>>>>>>>>>>>>>-<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++.<]<[>]>>>[-]>[-]<+++++++++++++.---.>+++++++[<++++++++++++>-]<.>+++++++[<
--------->-]<+.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------
->-]<.>++++++++[<+++++++++>-]<+.+++++++++++.>+++++++[<----------->-]<.>+++++
++[<+++++++++++>-]<-.>+++++++[<------------>-]<+.>++++++++[<+++++++++++>-]<-
.-----.---------.+++++++++++..---------------.+++++++++.>++++++[<-----------
-->-]<.+++++++.>+++++[<++++++>-]<+.-----.++++++++.+++.>++++++[<------>-]<-.-
------.>++++++++[<++++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>++
+++[<++++++>-]<+.-----.+++++++++++.>++++++[<------>-]<-.-------.>++++++++[<+
+++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>+++++[<+++++>-]<+.+++
+++++.+++.>++++++[<------>-]<-.+++++++...--------------.>++++++++[<+++++++++
++>-]<+.----------.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-
]<.-------.>+++[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++
+++++[<++++++++++>-]<.-----.++++++++.+++.-------.-.>++++++[<--------->-]<.--
------------.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------->
-]<.>+++++++[<++++++++++++>-]<.------------.---.+++++++++++++.-------------.
>+++++++[<---------->-]<+.>++++++++[<+++++++++>-]<+.++++++++++.>+++++++[<---
--------->-]<+.>++++++[<+++++++++++++>-]<.+.+++++.------------.+.+++++.-----
--.>++++++[<---------->-]<+.------------.>++++++++[<+++++++++++>-]<+.-------
---.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-]<.-------.>+++
[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++++++++[<+++++++
++++>-]<-.--------------.+++++.>++++++[<------------->-]<.+.

La solución que he encontrado yo, es convertir el código brainfuck a algo más amigable y depurarlo hasta encontrar la solución. La conversión la he realizado con VBBrainFNET y luego la depuración con Visual Studio. El crackme te pide una clave de cuatro cifras para darte la solución, pero si no quieres volverte loco puedes amañar los bucles para encontrar la solución.

¡SUERTE!

Enlaces

brainfuck canyouhackit

Stego X – Chunk

7 noviembre, 2022 por deurus·Sin comentarios

Table of Contents

Intro

Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir que para cada reto hay una herramienta que nos da la solución. En la entrada anterior os comenté que mi fondo de armario son steganabara y stegsolve aunque cuando la imagen es PNG, una herramienta de uso obligatorio es TweakPNG.

La víctima

Nos enfrentamos a una imagen PNG de 112KB (115477 bytes) con una resolución de 300×225 píxeles. A priori llama la atención el elevado tamaño VS la baja resolución, lo que aviva nuestras sospechas de que esos KB extras se deban a que haya insertado otro archivo en su interior.

Chunk

Los archivos PNG tienen la peculiaridad de que están divididos en secciones (chunks) en la que algunas son críticas como IHDR (cabecera), IDAT (la imagen) e IEND (final) y otras muchas secundarias como por ejemplo tEXt (para insertar texto). Al explorar el archivo con TweakPNG vemos la cabecera, varios chunks de texto, muchos IDAT que he combinado en uno para mejorar el análisis y la sección final. Si os fijáis, al combinar los IDAT ha cambiado el tamaño del PNG de 115447 a 110893 bytes aunque en este caso sigue siendo un tamaño elevado.

aspecto de los chunks tras combinar todos los IDAT en uno

Llama la atención el chunk cHRm de 12595 bytes del que TweakPNG ya nos avisa que no reconoce su contenido. Cargamos la imagen en un editor hexadecimal y buscamos la palabra «Great» que es el texto que hay justo antes del chunk cHRm que nos interesa.

detalle del chunk cHRm en editor hexadecimal

La búsqueda da sus frutos ya que el chunk parece que está formado por un archivo mp4. A partir de aquí tenemos varias opciones, para mí la más limpia es con un editor hexadecimal apuntar los offsets de inicio y fin del chunk y crear un archivo nuevo con el contenido. Otra opción es exportar el chunk desde TweakPNG con extensión mp4 y borrar los bytes del nombre del chunk con un editor hexadecimal, de lo contrario no podréis reproducir el mp4.

nombre del chunk a borrar para que funcione el mp4

Hecho esto, al escuchar el mp4 obtenemos la solución del reto.

Enlaces

Nota: si algo os pide clave es deurus.info

TweakPNG by jsummers [Oficial] [GitHub] [mirror]
PNG – Portable Network Graphics [Wikipedia]
MP4 – Moving Picture Experts Group (4) [Wikipedia]

challenge reto stego

ideku_nih’s Code this Keygen

29 agosto, 2014 por deurus·Sin comentarios

Introducción

Hoy tenemos aquí un crackme hecho en Visual Basic 6 (pcode), pero lo vamos a abordar de una manera diferente, ya que, vamos a conseguir el código fuente mediante VB Decompiler, le vamos a hacer una serie de modificaciones para hacerlo funcional con la ayuda de ExDec, y a partir de eso vamos a generar nuestro propio keygen.

El funcionamiento del crackme es simple, tenemos una primera caja de texto «Code» que en función de lo que introduzcamos nos activa el botón «OK». Al pulsar el botón comprueba lo que tengamos en la caja de texto «Serial» para haber si está todo correcto.

Obteniendo el código fuente

Abrimos el crackme con VB Decompiler y vemos sus fauces.

Pinchando en cada parte obtenemos su respectivo código fuente.

El botón OK

Private Sub Command1_Click() '402F70
  'Data Table: 402724
  Dim ourserial As Variant
   ourserial = CVar(Me.SERIAL.Text) 'String
   If (ourserial = cript(Left$(Me.CODE.Text, &HA))) Then
     MsgBox "Great", 0, ourserial
     End
   End If
   Dim x As String
   x = cript(Left$(Me.CODE.Text, &HA))
   MsgBox "Not Completed - " & x, 0, ourserial
   Me.CODE.Text = ""
   Me.SERIAL.Text = ""
   Exit Sub
End Sub

El evento KeyUp

Private Sub CODE_KeyUp(KeyCode As Integer, Shift As Integer)
  'Data Table: 402724
   If (Len(Me.CODE.Text) > 4) Then
     ourserialsum = checkcode(Me.CODE.Text)
     If CBool((ourserialsum > 70) And (ourserialsum < 90)) Then
       Me.Command1.Enabled = True
     End If
   End If
   Exit Sub
End Sub

La función cript

Public Function cript(a) 
  'Data Table: 402724
  Dim var_9C As Long
   var_98 = CStr(UCase(a))
   For var_10C = 1 To CVar(Len(var_98)): var_CC = var_10C 'Variant
     var_9C = CLng((CVar(var_9C) + (CVar((Asc(Mid$(var_98, CLng(var_CC), 1)) - 9) Xor &H58) + var_CC) ^ 2))
   Next var_10C 'Variant
  For var_160 = 1 To 100: var_140 = var_160 
     If (Mid$(CVar(Me.CODE.Text), CLng(var_140), 1) = vbNullString) Then
      GoTo loc_4030C0
     End If
   Next var_160 
loc_4030C0:
   var_9C = CLng(((CVar(var_9C) * Int((var_140 / 2))) * 16))
   var_94 = Hex(var_9C) 'Variant
   cript = var_94
End Function

La función checkcode

Public Function checkcode(a) 
   For var_F4 = 1 To CVar(Len(a)): var_A4 = var_F4
     var_128 = var_128 + (CVar(Asc(Mid$(a, CLng(var_A4), 1))))
   Next var_F4
   var_94 = Int(((var_128 / CVar(Len(a) / CVar(Len(a)))))
   checkcode = var_94
End Function

La rutina de comprobación del serial

Se compone de dos partes, el código y el serial.

El código

Si el resultado de la función checkcode está entre 70 y 90 nos activa el botón OK.

El serial

Lo genera la función cript en función del código anterior.

Arreglando el código fuente

Con lo obtenido anteriormente podemos entender perfectamente el comportamiento de la comprobación del serial pero si los cargamos en Visual Basic 6 y lo intentamos ejecutar tal cual nos dará una serie de errores. Es aquí cuando entra ExDec, ya que, nos proporciona el desensamblado del programa en forma de Opcode para poder comparar con el código obtenido.

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

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

El problema está en que divide dos veces entre el número de dígitos de a, si lo analizamos vemos que es imposible ya que nunca nos daría un código entre 70 y 90. La corrección queda así:

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

El KeyGen

Finalmente el código fuente de nuestro keygen quedaría así:

Private Sub Command1_Click() 'Generate CODE
  Dim CODE As String
  Dim var As Integer
  Randomize
  var = CLng((0 - 9999) * Rnd + 9999)
  Me.CODE.Text = "deurus" & var
  codesum = checkcode(Me.CODE.Text)
  If CBool((codesum > 70) And (codesum < 90)) Then
       lbl.Caption = "Code valid, now generate a serial"
       Command2.Enabled = True
  Else
       Command2.Enabled = False
       Command1_Click
  End If
End Sub

Private Sub Command2_Click() 'Generate SERIAL
   If (Len(Me.CODE.Text) > 4) Then
     codesum = checkcode(Me.CODE.Text)
     If CBool((codesum > 70) And (codesum < 90)) Then
       SERIAL.Text = cript(Left$(Me.CODE.Text, 10))
       Else
       lbl.Caption = "Code not valid, first gen code"
     End If
   End If
End Sub

Private Sub CODE_KeyUp(KeyCode As Integer, Shift As Integer)
   If (Len(Me.CODE.Text) > 4) Then
     var_B0 = checkcode(Me.CODE.Text)
     lbl.Caption = "Value must be between 70 - 90. Yours: " & var_B0
     If CBool((var_B0 > 70) And (var_B0 < 90)) Then
       lbl.Caption = "Code valid, now generate a serial"
       Command2.Enabled = True
       Else
       Command2.Enabled = False
     End If
   End If
   Exit Sub
End Sub

Public Function cript(a)
  Dim var_9C As Long
   var_98 = CStr(UCase(a))
   For var_10C = 1 To CVar(Len(var_98)): var_CC = var_10C
     var_9C = CLng((CVar(var_9C) + (CVar((Asc(Mid$(var_98, CLng(var_CC), 1)) - 9) Xor &H58) + var_CC) ^ 2))
   Next var_10C
  For var_160 = 1 To 100: var_140 = var_160
     If (Mid$(CVar(Me.CODE.Text), CLng(var_140), 1) = vbNullString) Then
      GoTo loc_4030C0
     End If
   Next var_160
loc_4030C0:
   var_9C = CLng(((CVar(var_9C) * Int((var_140 / 2))) * 16))
   var_94 = Hex(var_9C)
   cript = var_94
End Function

Public Function checkcode(a)
   For var_F4 = 1 To CVar(Len(a)): var_A4 = var_F4
   'Suma el valor ascii de todos los caracteres / Add the ascii value of our code
     var_128 = var_128 + (CVar(Asc(Mid$(a, CLng(var_A4), 1))))
   Next var_F4
   'Lo divide entre la longitud del code / Divide our codesum by code lenght
   var_94 = Int(((var_128 / CVar(Len(a))))) 'corrección
   checkcode = var_94
End Function

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

Links

Blooper Tech Movie VI - Dexter 1x08 (S01E08)

Hace poco me puse a leer El oscuro pasajero de Jeff Lindsay, novela que inspiró la serie Dexter. La nostalgia

Keygen para el KeygenMe#01 de eBuC - Comparación lineal

Primeras impresiones Analizamos el programa con PEiD y nos muestra que está hecho en ensamblador. Unas pruebas introduciendo datos nos

Descargar contenido multimedia de ciertas webs

Hoy en día, la descarga de contenido multimedia de ciertas webs es imposible o muy difícil. En ciertos casos lo

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

1 2 3 … 30 Next »

Blooper btm Dexter season 1 temporada 1

Blooper Tech Movie VI – Dexter 1×08 (S01E08)

14 noviembre, 2017 por deurus·1 comentario

Hace poco me puse a leer El oscuro pasajero de Jeff Lindsay, novela que inspiró la serie Dexter. La nostalgia me invadió y al final decidí volver a ver la primera temporada que tanto me gustó hace unos años. Para mi sorpresa, muchos de los detalles que recordaba de la serie eran incorrectos o incompletos. Bueno, el caso es que en esta ocasión me he fijado más en los detalles y he descubierto una pequeña perla en el capítulo 8 de la primera temporada.

ALERTA DE SPOILER: Aunque la serie tiene unos añitos no quisiera fastidiarsela a nadie. Si continuas leyendo puede que te enteres de algo que no quieras.

Table of Contents

Missed connection

En un momento dado, a Dexter se le ocurre la feliz idea de contactar con el asesino en serie que le está dejando regalitos y no se le ocurre mejor idea que hacerlo en una web de contactos cualquiera. La web en cuestión es www.miamilist12.com/miami/main y Dexter decide escribir un mensaje en el hilo missed connections. A continuación la secuencia de imágenes.

mailto:frozenbarbie@hotmail.???

La simple idea de escribir en un tablón, foro, lista, etc y esperar que el asesino en serie lo lea ya es una locura. Pero señor@s, esto es ficción, y por supuesto el asesino no solo ve el mensaje si no que responde a Dexter creando un pequeño error con las direcciones de email. Y es que cuando el asesino ve el mensaje se puede apreciar que la dirección de email de Dexter es frozenbarbie@hotmail.web y cuando el asesino le responde, se ve claramente que lo hace a la dirección frozenbarbie@hotmail.com. A continuación las imágenes.

Además me ha llamado la atención que aunque es evidente que el asesino usa Windows XP, se puede apreciar que han retocado en post-producción el botón de inicio para que quede oculto.

Nos vemos en el siguiente BTM.

Blooper btm Dexter season 1 temporada 1

Keygen para el KeygenMe#01 de eBuC – Comparación lineal

25 agosto, 2014 por deurus·2 comentarios

Primeras impresiones

Analizamos el programa con PEiD y nos muestra que está hecho en ensamblador.

Unas pruebas introduciendo datos nos muestran que el nombre debe tener entre 3 y 10 dígitos.

Determinando la rutina de creación del serial con Ollydbg

Llegados a este punto tenemos dos opciones que funcionan en el 90% de los casos. La primera es mediante las referenced strings o mediante los names.

Para el primer caso, con el keygenme cargado en olly, click derecho y Search > All referenced text strings. Haciendo doble click en “You got it” o en “Bad boy” vamos directamente a la rutina de comprobación del serial o muy cerca de ella en la mayoría de los casos.

Para el segundo caso, haremos click derecho y Search > Name (label) in current módule, o Ctrl+N. Vemos dos llamadas interesantes como son user32.GetDlgItemInt y user32.GetDlgItemTextA. Lo más seguro es que user32.GetDlgItemInt coja del textbox nuestro serial y user32.GetDlgItemTextA coja nuestro nombre. Para este caso colocaríamos breakpoints en las dos llamadas.

En mi caso elijo la primera opción. Nada más pulsar en “You got it” nos fijamos un poco más arriba y vemos las funciones donde coge el nombre y el serial y a simple vista se ven las operaciones que hace con ellos.

Generando un serial válido

Como se muestra en la imagen siguiente, la creación del serial es muy sencilla y al final la comparación es lineal ya que se compara nuestro serial con el serial válido. Veamos el serial válido para el usuario “abc” cuyos dígitos en hexadecimal son 0x61, 0x62 y 0x63.

Letra a	Letra b	Letra c
Suma + 0x61 Suma * 0x20 Suma xor 0xBEFF Suma / 4 Suma = 0x2CB7	Suma + 0x62 Suma * 0x20 Suma xor 0xBEFF Suma / 4 Suma = 0x14777	Suma + 0x63 Suma * 0x20 Suma xor 0xBEFF Suma / 4 Suma = 0xA116F
Suma xor 0xBEA4 = 0xAAFCB
Serial válido = 700363

Generando un keygen con WinASM studio desde cero

Abrimos WinASM studio y pulsamos en File > New Project y en la pestaña dialog elegimos base.

Vemos que se nos generan tres archivos, uno con extensión asm, otro con extensión inc y otro con extensión rc. El archivo asm es el que contendrá nuestro código. El archivo inc no lo vamos a usar para simplificar las cosas y el archivo rc es nuestro formulario al que pondremos a nuestro gusto.

Empecemos con el aspecto del formulario. Por defecto viene como se muestra en la siguiente imagen. Que por cierto, es todo lo que necesitamos para un keygen básico.

Y el aspecto final:

Ahora veamos cómo viene nuestro archivo asm inicialmente y que haremos con él. En la siguiente imagen lo indico.

Encima de la sección .code hemos creado dos secciones como son .data y .data? y hemos declarado las variables necesarias.

szFormat está declarada en formato integer (%i). Más tarde la utilizaremos junto a la función wsprintf para dar formato a un número.

szSizeMin: habla por sí misma.

szSizeMax: habla por sí misma.

szCap: habla por sí misma.

szName: contendrá el nombre introducido.

szCode: contendrá el serial válido.

Nuestro código queda de la siguiente manera:

A partir de aquí ya simplemente es escribir el código necesario para generar el serial válido. Una de las ventajas que tiene el ensamblador para hacer keygens sin muchas complicaciones, es que prácticamente es copiar el código que nos muestra Ollydbg. Si os fijáis a continuación, en el botón llamado “IDC_OK” (no le he cambiado el nombre) he puesto todo el código necesario para generar la simple rutina del serial.

Como veis el bucle del nombre es una copia de lo que nos mostró Ollydbg. Una vez que tenemos en EAX nuestro serial válido, mediante la función wsprintf guardamos en la variable szCode el serial válido con formato integer. Finalmente mediante la función SetDlgItemText, mostramos el serial válido en la caja de texto 1002, que es la del serial.

Enlaces

Keygen para el Crackme Sweeet Dream 1.0 de 2Sweeet

Intro Hoy tenemos aquí un crackme del año 2000 empacado y con un algoritmo aunque no muy complicado largo de

VideoTutorial - KeyGen para el Crackme#1 de WinFan

http://youtu.be/b9-GdmIQINQ Lista de reproducción

Reto Crypt-art de Root-Me.org

Intro Extensión PPM Clave cifrada Un nuevo lenguaje de programación Enlaces Intro Hoy tenemos aquí un reto de esteganografía bastante

Stego d33p

En este reto se nos entrega un archivo WAV de 9,92 MB. Tras escucharlo y analizarlo por encima con Audacity

1 2 3 … 30 Next »

Bruce Willis btm Die Hard gazapo hacking Jungla de Cristal película toma falsa

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

12 diciembre, 2016 por deurus·Sin comentarios

La esperada cuarta entrega de La Jungla de Cristal se metió de lleno en el mundo de los Hackers. Cuando la vi en su época he de reconocer que el detalle que explicaremos a continuación me pasó desapercibido.

Hablemos de mineralismo.. digo de IPs privadas

Digamos que a día de hoy, quien más y quien menos, sabe lo que es una IP y para que sirve. Si no lo sabes, digamos resumidamente que es un número que nos identifica dentro de una red. En el protocolo IPv4 son 4 grupos de números entre 0 y 255. Como todo protocolo que se precie, tiene ciertos rangos de direcciones reservados para redes privadas y el resto digamos que son públicas. El rango de direcciones privadas para IPv4 es el siguiente:

De 10.0.0.0 a 10.255.255.255
172.16.0.0 a 172.31.255.255
192.168.0.0 a 192.168.255.255
169.254.0.0 a 169.254.255.255

BTM

Como hemos hablado en otras ocasiones, en el cine se exagera todo lo relacionado con el mundo tecnológico y en especial el mundo «Hacking«, y es normal encontrarnos elaborados entornos gráficos que quedan muy bien pero que no existen en el mundo real.

En la Jungla 4.0 usaron IPs privadas como públicas sin ton ni son y perdón si me repito pero, ¿nadie contrata consultores?, es decir, vas a realizar una película sobre hackers y ¿no contratas a alguien que tenga unos conocimientos mínimos?, pues al parecer es mucho pedir, las imágenes hablan por si solas.

En la imagen superior se puede ver como están conectados al sistema de ventilación del NDA. Podría pasar si estuvieran físicamente en las instalaciones del NDA y se conectaran desde un equipo de allí, pero al hacerlo de forma remota crean un enorme gazapo.

Esto es una pequeña muestra de lo que muestra la película. También hay escenas en las que se usan IPs públicas correctamente pero en general cometen el error de forma recurrente.

Enlaces

¿Qué es una IP? [Wikipedia]
Redes privadas [Wikipedia]
La Jungla 4.0 [IMDB]

Reto forense "Find the cat" de Root-Me.org

Intro President’s cat was kidnapped by separatists. A suspect carrying a USB key has been arrested. Berthier, once again, up

Solución a los CrackMes de CrkViZ 1-5

Introducción Herramientas disponibles CrkViz-1 (Serial a la vista) CrkViz-2 (Parcheando rutina aleatoria) CrkViz-3 (Nag+Keygen) CrkViz-4 (Límite de ejecuciones+Keygen) CrkViz-5 (Serial

Mirror Crackmes.de

While Crackmes.de returns, I leave a couple of files for practice. Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.

AfKayAs's CrackMe#2 KeyGen

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

challenge find the cat forense reto root-me root-me.org

Protegido: Reto forense «Find the cat» de Root-Me.org

20 diciembre, 2015 por deurus·Escribe tu contraseña para ver los comentarios.

challenge find the cat forense reto root-me root-me.org

Solución a los CrackMes de CrkViZ 1-5

12 marzo, 2015 por deurus·1 comentario

Introducción
Herramientas disponibles
CrkViz-1 (Serial a la vista)
CrkViz-2 (Parcheando rutina aleatoria)
CrkViz-3 (Nag+Keygen)
CrkViz-4 (Límite de ejecuciones+Keygen)
CrkViz-5 (Serial a la vista)
Notas finales
Enlaces

Table of Contents

Introducción

Esta vez vamos a analizar los CrackMes de un antiguo colaborador de Karpoff Spanish Tutor, CrkViZ. En estas cinco soluciones vamos a pelearnos con Visual Basic 5/6 nativo y Pcode, con el registro de Windows y tendremos que parchear algúna rutina antidebug. Los CrackMes son del año 2000 y aunque algunos estaban ya solucionados, los analizaremos igualmente para ver la diferencia que existe con los análisis realizados en aquellos años, sí, estamos hablando del Softice.

Herramientas disponibles

Cuando hablamos de Visual Basic 5/6, podemos destacar 3 herramientas que nos facilitan mucho la vida, VB Decompiler, VB Reformer y ExDec. Las dos primeras se defienden bien tanto con código nativo como pcode y ExDec solamente nos sirve para pcode. Aún así, si todo lo demás falla, Ollydbg nos sacará de apuros.

CrkViz-1

Este primer crackme está compilado en Pcode y hoy día, con las herramientas de que disponemos no supone ninguna dificultad. Tan solo debemos abrirlo con VB Decompiler y ya nos encontramos con el serial válido.

Los opcodes obtenidos con ExDec se ven de la siguiente manera.

......
402F14: 04 FLdRfVar                local_008C
402F17: 21 FLdPrThis              
402F18: 0f VCallAd                 7b3fc340
402F1B: 19 FStAdFunc               local_0088
402F1E: 08 FLdPr                   local_0088
402F21: 0d VCallHresult            7b3fbe88
402F26: 6c ILdRf                   local_008C
402F29: 1b LitStr:                 57230198        <--------------
402F2C: Lead0/30 EqStr            
402F2E: 2f FFree1Str               local_008C
402F31: 1a FFree1Ad                local_0088
402F34: 1c BranchF:                403012
402F37: 21 FLdPrThis              
402F38: 0d VCallHresult            7b3fc2b0
402F3D: 3a LitVarStr:              ( local_00AC )  Gracias por Registrar!!      
402F42: Lead2/00 FStVarCopy       
402F46: 27 LitVar_Missing         
402F49: 27 LitVar_Missing         
402F4C: 3a LitVarStr:              ( local_00AC ) CrkViz
402F51: 4e FStVarCopyObj           local_00BC
402F54: 04 FLdRfVar                local_00BC
402F57: f5 LitI4:                  0x40  64  (...@)
402F5C: 04 FLdRfVar                local_009C
402F5F: 0a ImpAdCallFPR4:          _rtcMsgBox
402F64: 36 FFreeVar
402F6D: 27 LitVar_Missing         
402F70: 25 PopAdLdVar             
402F71: 27 LitVar_Missing
......

CrkViz-2

Este segundo crackme también está compilado en pcode. La rutina del serial es muy sencilla pero al introducir un número aleatorio nos obliga a parchear. Cargamos el crackme en VB Decompiler y nos muestra esto:

Básicamente vemos que genera un número aleatorio entre 1 y 999999999 y luego le suma 1. La forma de afrontar esto es parcheando. Nos fijamos en el offset aproximado (4037F2) y abrimos el crackme en un editor hexadecimal. La forma de convertir el offset que nos muestra VB Decompiler a lo que nos muestra un editor hexadecimal es la siguiente.

VBdec_offset - Image Base - VirtualOffset + RawOffset = Offset_Editor.H

4037F2 - 400000 - 1000 + 400 = 2BF2

Una vez localizados los bytes, los cambiamos por ceros y guardamos.

Una vez parcheado, el serial correcto es 1.

CrkViz-3

En esta tercera entrega, CrkViz aumentó la dificultad. El crackme está compilado en código nativo y nos enfrentamos a un serial asociado a un nombre y a una rutina antidebug que en realidad es una Nag, ya que se muestra siempre.

Afrontar la nag es muy sencillo, basta con localizarla y parchear la llamada.

CPU Disasm
Address   Hex dump          Command                                            Comments
004058E2    8D4D DC         LEA ECX,[EBP-24]
004058E5    C785 BCFDFFFF B MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.004033B8     ; UNICODE "  Debugger detectado!!!   "
004058EF    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8
004058F9    FFD7            CALL EDI
004058FB    B9 04000280     MOV ECX,80020004
00405900    B8 0A000000     MOV EAX,0A
00405905    898D FCFDFFFF   MOV DWORD PTR SS:[EBP-204],ECX
0040590B    898D 0CFEFFFF   MOV DWORD PTR SS:[EBP-1F4],ECX
00405911    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00405917    8D8D 14FEFFFF   LEA ECX,[EBP-1EC]
0040591D    8985 F4FDFFFF   MOV DWORD PTR SS:[EBP-20C],EAX
00405923    8985 04FEFFFF   MOV DWORD PTR SS:[EBP-1FC],EAX
00405929    C785 BCFDFFFF 8 MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.00403188     ; UNICODE "Error"
00405933    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8
0040593D    FF15 C8914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDup>]
00405943    8D85 F4FDFFFF   LEA EAX,[EBP-20C]
00405949    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
0040594F    50              PUSH EAX
00405950    8D95 14FEFFFF   LEA EDX,[EBP-1EC]
00405956    51              PUSH ECX
00405957    52              PUSH EDX
00405958    8D45 DC         LEA EAX,[EBP-24]
0040595B    6A 10           PUSH 10
0040595D    50              PUSH EAX
0040595E    FF15 50914000   CALL DWORD PTR DS:[<&MSVBVM50.#595>]               ; rtcMsgBox - NOPear para evitar la NAG
00405964    8D8D F4FDFFFF   LEA ECX,[EBP-20C]

Antes de llegar al keygen vemos que realiza unas llamadas al registro de Windows, ponemos un breakpoint «bp RegOpenKeyW» y ejecutamos.

CPU Disasm
Address   Hex dump            Command                                  Comments
00405677  |.  8B8D B8FDFFFF   MOV ECX,DWORD PTR SS:[EBP-248]
0040567D  |.  B8 54334000     MOV EAX,CrkMeViz-3.00403354              ; UNICODE "<Unregister>"
00405682  |.  68 B4304000     PUSH CrkMeViz-3.004030B4                 ; UNICODE "Serial number"
00405687  |.  894A 04         MOV DWORD PTR DS:[EDX+4],ECX
0040568A  |.  8985 BCFDFFFF   MOV DWORD PTR SS:[EBP-244],EAX
00405690  |.  68 84304000     PUSH CrkMeViz-3.00403084                 ; UNICODE "Register"
00405695  |.  68 58304000     PUSH CrkMeViz-3.00403058                 ; UNICODE "CrkMeViz3"
0040569A  |.  8942 08         MOV DWORD PTR DS:[EDX+8],EAX
0040569D  |.  8B85 C0FDFFFF   MOV EAX,DWORD PTR SS:[EBP-240]
004056A3  |.  8942 0C         MOV DWORD PTR DS:[EDX+0C],EAX
004056A6  |.  FF15 C0914000   CALL DWORD PTR DS:[<&MSVBVM50.#689>] 	; rtcGetSetting - Lee el numero de serie del registro
........
0040574F  |.  68 9C304000     PUSH CrkMeViz-3.0040309C                  ; UNICODE "User Name"
00405754  |.  68 84304000     PUSH CrkMeViz-3.00403084                  ; UNICODE "Register"
00405759  |.  68 58304000     PUSH CrkMeViz-3.00403058                  ; UNICODE "CrkMeViz3"
0040575E  |.  8948 08         MOV DWORD PTR DS:[EAX+8],ECX
00405761  |.  8B8D C0FDFFFF   MOV ECX,DWORD PTR SS:[EBP-240]
00405767  |.  8948 0C         MOV DWORD PTR DS:[EAX+0C],ECX
0040576A  |.  FF15 C0914000   CALL DWORD PTR DS:[<&MSVBVM50.#689>]	; rtcGetSetting - Lee el Usuario del registro

Reconstruyendo la llamada al registro vemos que lee de esta ruta: HKEY_CURRENT_USER\Software\VB and VBA Program Settings\CrkMeViz3\Register el contenido de User Name y del Serial number.

Quizá uno de los fallos de éste crackme, es que no comprueba la autenticidad de estos parámetros y si los modificas parece que estás registrado. Un ejemplo:

La rutina de comprobación del serial no es para nada complicada pero recordemos que estamos tratando con VB y éste delega el trabajo duro en otras librerias de modo que tenemos que «meternos» a tracear las llamadas para ver los valores que multiplica y divide.

CPU Disasm
Address     Hex dump          Command                                            Comments
00405A86      FF15 3C914000   CALL DWORD PTR DS:[<&MSVBVM50.#518>]    ;MSVBVM50.rtcLowerCaseVar
00405A8C      8D95 14FEFFFF   LEA EDX,[EBP-1EC]
00405A92      8D8D ACFEFFFF   LEA ECX,[EBP-154]
00405A98      FFD6            CALL ESI
00405A9A      8D95 ACFEFFFF   LEA EDX,[EBP-154]
00405AA0      8D8D 4CFEFFFF   LEA ECX,[EBP-1B4]
00405AA6      FFD7            CALL EDI
00405AA8      8D95 4CFEFFFF   LEA EDX,[EBP-1B4]
00405AAE      8D8D 7CFFFFFF   LEA ECX,[EBP-84]
00405AB4      FFD7            CALL EDI
00405AB6      8D85 14FEFFFF   LEA EAX,[EBP-1EC]
00405ABC      8D8D 7CFFFFFF   LEA ECX,[EBP-84]
00405AC2      50              PUSH EAX
00405AC3      6A 01           PUSH 1
00405AC5      8D95 04FEFFFF   LEA EDX,[EBP-1FC]
00405ACB      51              PUSH ECX
00405ACC      52              PUSH EDX
00405ACD      C785 1CFEFFFF 0 MOV DWORD PTR SS:[EBP-1E4],1
00405AD7      C785 14FEFFFF 0 MOV DWORD PTR SS:[EBP-1EC],2
00405AE1      FF15 68914000   CALL DWORD PTR DS:[<&MSVBVM50.#632>]   ;MSVBVM50.rtcMidCharVar (Esto lo hace 6 veces, lo omito para abreviar.)
........
00405CE1      FF15 34914000   CALL DWORD PTR DS:[<&MSVBVM50.#516>]   ;MSVBVM50.rtcAnsiValueBstr (Lo mismo, otras 6)
........
00405E7C    C785 BCFDFFFF 2 MOV DWORD PTR SS:[EBP-244],52E
00405E86    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00405E90    50              PUSH EAX
00405E91    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
		|
		->MSVBVM50.__vbaVarMul
			........
			741C19D3      0FB745 FE       MOVZX EAX,WORD PTR SS:[EBP-2]       ;Valor1
			741C19D7      0FB74D F2       MOVZX ECX,WORD PTR SS:[EBP-0E]      ;Valor2
			741C19DB      6BC0 12         IMUL EAX,EAX,12                     ;Valor1*Valor2
			........
00405E97    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
00405E9D    50              PUSH EAX
00405E9E    51              PUSH ECX
00405E9F    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EA5    8D95 F4FDFFFF   LEA EDX,[EBP-20C]
00405EAB    50              PUSH EAX
00405EAC    52              PUSH EDX
00405EAD    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EB3    50              PUSH EAX
00405EB4    8D85 E4FDFFFF   LEA EAX,[EBP-21C]
00405EBA    50              PUSH EAX
00405EBB    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EC1    8D8D D4FDFFFF   LEA ECX,[EBP-22C]
00405EC7    50              PUSH EAX
00405EC8    51              PUSH ECX
00405EC9    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405ECF    50              PUSH EAX
00405ED0    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00405ED6    8D85 C4FDFFFF   LEA EAX,[EBP-23C]
00405EDC    52              PUSH EDX
00405EDD    50              PUSH EAX
00405EDE    FF15 94914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
		|
		->MSVBVM50.__vbaVarDiv
			........
			741C8094      DD43 08         FLD QWORD PTR DS:[EBX+8]      ;Recupera el resultado de las multiplicaciones anteriores
			741C8097      0FBF47 08       MOVSX EAX,WORD PTR DS:[EDI+8] ;EAX = 1326 (52E)
			741C809B      8945 F8         MOV DWORD PTR SS:[EBP-8],EAX
			741C809E      DA75 F8         FIDIV DWORD PTR SS:[EBP-8]    ;Divide los dos resultados
			741C80A1      DD5E 08         FSTP QWORD PTR DS:[ESI+8]
			........
00405F44      FF15 24914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]          ;Len(nombre)
........
00405F85      FF15 94914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]           ;Resultado anterior / Len(nombre)
........

En resumen:

Pasa nuestro nombre a minúsculas.
Obtiene el valor ascii de los 6 primeros dígitos del nombre.
Los multiplica entre sí y divide el resultado acumulado entre 1326 (52E).
Divide el resultado anterior entre el tamaño del nombre.

Ejemplo para deurus

64*65*75*72*75*73 = 1A605D70EB8
1A605D70EB8 / 52E = 5179FBF4
5179FBF4 / 6 = D9454A9

Al estar correctamente registrados desaparece el botón de registrar.

CrkViz-4

El cuarto crackme es prácticamente igual que el tercero salvo que en vez de nag ahora contamos con limitación de ejecuciones. Del mismo modo utiliza el registro de Windows para guardar los datos de registro y las ejecuciones que llevamos.

Ponemos un breakpoint «bp RegOpenKeyW» y llegamos a la conclusión de que la ruta es HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register y los valores se guardan en Counter, User Name y Serial number respectivamente. Este crackme hereda el fallo del anterior y si alteramos los valores el crackme nos muestra como usuarios autorizados, aunque sabemos que no estamos registrados ya que seguimos limitados por ejecuciones. Ni que decir tiene que lo mismo que modificamos el nombre y número de serie, podemos modificar el contador a nuestro favor. Crear un archivo «Reiniciar_contador.reg» con el siguiente contenido sería suficiente.

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC]

[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register]
"Counter"="0"
"User Name"="deurus"
"Serial number"="12345"

El keygen es prácticamente igual que en el crackme anterior, solo cambia el divisor.

CPU Disasm
Address   Hex dump          Command                                                   Comments
........
00404BD2    C785 BCFDFFFF C MOV DWORD PTR SS:[EBP-244],6C1
00404BDC    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00404BE6    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
   |
    ->MSVBVM50.__vbaVarMul
	741C19F9    0FBF4F 08       MOVSX ECX,WORD PTR DS:[EDI+8]      ;Valor1
	741C19FD    0FBF43 08       MOVSX EAX,WORD PTR DS:[EBX+8]      ;Valor2
	741C1A01    0FAFC8          IMUL ECX,EAX                       ;Valor1*Valor2
........
00404BEC    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
00404BF2    50              PUSH EAX
00404BF3    51              PUSH ECX
00404BF4    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404BFA    8D95 F4FDFFFF   LEA EDX,[EBP-20C]
00404C00    50              PUSH EAX
00404C01    52              PUSH EDX
00404C02    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C08    50              PUSH EAX
00404C09    8D85 E4FDFFFF   LEA EAX,[EBP-21C]
00404C0F    50              PUSH EAX
00404C10    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C16    8D8D D4FDFFFF   LEA ECX,[EBP-22C]
00404C1C    50              PUSH EAX
00404C1D    51              PUSH ECX
00404C1E    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C24    50              PUSH EAX
00404C25    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00404C2B    8D85 C4FDFFFF   LEA EAX,[EBP-23C]
00404C31    52              PUSH EDX
00404C32    50              PUSH EAX
00404C33    FF15 B0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
   |
    ->MSVBVM50.__vbaVarDiv
	741C8094    DD43 08         FLD QWORD PTR DS:[EBX+8]              ; Recupera el resultado de las multiplicaciones anteriores
	741C8097    0FBF47 08       MOVSX EAX,WORD PTR DS:[EDI+8]         ; EAX = 1729 (6C1)
	741C809B    8945 F8         MOV DWORD PTR SS:[EBP-8],EAX
	741C809E    DA75 F8         FIDIV DWORD PTR SS:[EBP-8]

00404C39    8BD0            MOV EDX,EAX
........
00404CA0    FF15 3C914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]  ;Len(nombre)
........
00404CF1    FF15 B0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]   ;Resultado anterior / Len(nombre)

En resumen:

Pasa nuestro nombre a minúsculas.
Obtiene el valor ascii de los 6 primeros dígitos del nombre.
Los multiplica entre sí y divide el resultado acumulado entre 1729 (6C1).
Divide el resultado anterior entre el tamaño del nombre.

Ejemplo para deurus

64*65*75*72*75*73 = 1A605D70EB8
1A605D70EB8 / 6C1 = 3E7C594A
3E7C594A / 6 = A6A0EE2

CrkViz-5

Este último crackme está compilado en código nativo y simplemente se trata de una comparación lineal. La única diferencia reside en que no hay botón de registro, la comprobación la gestiona un evento «On Change«, de modo que está comprobando el tamaño del serial que introducimos y cuando éste tiene 8 dígitos llegamos aquí.

........
0040A64F         .  C745 9C CDD4DD02    MOV DWORD PTR SS:[EBP-64],2DDD4CD      ;2DDD4CD = 48092365
0040A656         .  C745 94 03800000    MOV DWORD PTR SS:[EBP-6C],8003
0040A65D         .  FF15 08C14000       CALL DWORD PTR DS:[<&MSVBVM50.__vbaVa> ;MSVBVM50.__vbaVarTstEq
0040A663         .  66:85C0             TEST AX,AX
0040A666         .  0F84 BA000000       JE CrkMeViZ.0040A726                   ;Si salta BAD  BOY
........

Luego el serial correcto es 48092365.

Notas finales

¿Ha sido indoloro no?, claro que sí, Visual Basic es un coñazo de tracear pero hay que reconocer que con el tiempo las herramientas han mejorado mucho y nuestra vida es mucho más sencilla. Bueno, pués esto ha sido todo, como siempre os dejo todo el material utilizado y un Keygen.

Enlaces

crackme CrkViz deurus karpoff Keygen NAG Parche visual basic

Mirror Crackmes.de

29 marzo, 2017 por deurus·Sin comentarios

~~While Crackmes.de returns, I leave a couple of files for practice.~~

~~Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.~~

~~In the folder crackmes.de_mirror you have two files:~~

~~En la carpeta crackmes.de_mirror tienes dos archivos:~~

~~Crackmes.de (2011 – 2015).rar [491 MB] [password: tuts4you]~~
~~crackmes.de-2016-12.7z [639 MB]~~

 password of files = deurus.info

5 revistas sobre Hacking imprescindibles

Si te interesa el mundo del hacking, ya sea como aficionado o como profesional, seguramente querrás estar al día de

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

CanYouHack.it Mobile2 Challenge - Follow The Web (English)

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

Challengeland.co Realistic 1

Alerta de Spoiler: El reto está en activo a fecha de publicación. Spoiler alert: The challenge is still alive. Este

1 2 3 … 30 Next »

2600 HackSpace hakin9 PenTest phrack

5 revistas sobre Hacking imprescindibles

25 abril, 2023 por deurus·Sin comentarios

Si te interesa el mundo del hacking, ya sea como aficionado o como profesional, seguramente querrás estar al día de las últimas novedades, técnicas y herramientas que se utilizan en este campo. Para ello, una buena opción es suscribirte a alguna de las revistas sobre hacking que existen en el mercado. Estas publicaciones te ofrecen información de calidad, actualizada y veraz sobre todo lo relacionado con la seguridad informática, el pentesting, el hacking ético y otros temas de interés. En este artículo te presentamos cinco revistas sobre hacking que deberías leer si quieres ampliar tus conocimientos y habilidades en este ámbito.

Es una de las revistas más populares y reconocidas sobre hacking. Se publica desde el año 2005 y cuenta con una amplia comunidad de lectores y colaboradores. Su contenido abarca desde los aspectos más básicos hasta los más avanzados del hacking, con artículos, tutoriales, entrevistas, casos de estudio y reseñas de herramientas. Además, tiene ediciones especiales dedicadas a temas específicos como el hacking web, el hacking móvil, el malware o el IoT. Puedes acceder a su versión digital o impresa desde su página web.

hakin9.org

Es una revista electrónica sobre hacking que se publica desde el año 1985. Tiene una periodicidad irregular y se distribuye de forma gratuita a través de Internet. Sus contenidos son principalmente artículos técnicos sobre hacking, seguridad informática, programación, etc. También incluye algunos textos de ficción y humor relacionados con el hacking. Es una revista muy apreciada por la comunidad hacker por su calidad y originalidad.

phrack.org

2600: The Hacker Quarterly es una revista legendaria entre los hackers, ya que se publica desde 1984 y ha sido testigo de la evolución de este movimiento a lo largo de las décadas. Su nombre hace referencia a la frecuencia de 2600 Hz que se usaba para hackear las líneas telefónicas en los años 60 y 70. En sus páginas encontrarás artículos sobre hacking, seguridad informática, cultura hacker, activismo digital y mucho más.

2600.com

Revista especializada en pentesting o pruebas de penetración, una de las ramas más importantes del hacking ético. Su contenido está dirigido tanto a principiantes como a expertos en esta materia, con artículos prácticos, teóricos y metodológicos sobre cómo realizar pentests eficaces y profesionales. También incluye entrevistas a destacados pentesters, reseñas de herramientas y reportajes sobre proyectos y eventos relevantes. Puedes descargar su versión digital desde su página web o comprar su versión impresa.

pentestmag.com

Es una revista para los entusiastas del hacking creativo, es decir, aquellos que usan la tecnología para crear proyectos innovadores y divertidos. En sus páginas encontrarás ideas, tutoriales, consejos y reseñas sobre temas como la electrónica, la robótica, el hardware libre, el software libre, el internet de las cosas, la impresión 3D y mucho más..

hackspace.raspberrypi.com

2600 HackSpace hakin9 PenTest phrack

Yoire PE Reversing Challenge (Crackme Very Hard)

26 agosto, 2014 por deurus·Sin comentarios

Saltando el Anti-Debug

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

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

Rutina de comprobación del serial

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

Retomemos analizando la rutina de comprobación.

FLD DWORD PTR DS:[403080]    - Carga el entero "720300" en ST7
FSTP [LOCAL.1]               - Guarda "720300" en memoria (Local 1)
MOVSX EDX,BYTE PTR DS:[EAX]  - Coje nuestro primer dígito en ascii y lo carga en EDX
SUB EDX,30                   - Le resta 30 a EDX
PUSH EDX                     - Carga EDX en la pila
FILD DWORD PTR SS:[ESP]      - Carga el valor de EDX en ST0
POP EDX                      - Recupera el valor de la pila
FDIVR [LOCAL.1]              - Divide Local 1 entre nuestro dígito hex y lo guarda en ST0
FSTP [LOCAL.1]               - Guarda el resultado de ST0 en Local 1
INC EAX                      - Siguiente dígito
CMP BYTE PTR DS:[EAX],0      - Comprueba si quedan dígitos en nuestro serial
JNZ SHORT 05_crack.004010F4  - Bucle

Después de la rutina de comprobación simplemente comprueba el valor del resultado de la división con 1 y si es verdad serial válido.

Buscando un serial válido

Podríamos hacer fuerza bruta, pero en esta ocasión no es necesario ya que con la calculadora, boli y papel lo sacamos rápido.

720300 / 2 = 360150
360150 / 2 = 180075
180075 / 5 = 36015
36015  / 5 = 7203
7203   / 3 = 2401
2401   / 7 = 343
343    / 7 = 49
49     / 7 = 7
7      / 7 = 1

Por lo que un serial válido sería: 225537777

La rutina de comprobación del serial podría resumirse también así:

720300 MOD serial = 720300

Links

Guía rápida para tener una red Gigabit en casa

Introducción A quien va dirigido Comprobaciones previas Lo que necesitamos Presupuesto Ejemplo de instalación Preguntas frecuentes Glosario Notas finales Introducción

Retos reversing de Challengeland.co

Introducción Recién rescatados del inframundo que es mi disco duro, os traigo un paquete de seis crackmes facilones para vuestro

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

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 »

disco de red full duplex gigabit nas redes router tarjeta de red tplink

Guía rápida para tener una red Gigabit en casa

2 noviembre, 2014 por deurus·1 comentario

Introducción
A quien va dirigido
Comprobaciones previas
Lo que necesitamos
Presupuesto
Ejemplo de instalación
Preguntas frecuentes
Glosario
Notas finales

Table of Contents

Introducción

Un día cualquiera se te ocurre comprarte un disco duro de red NAS para centralizar todo tu contenido multimedia. Lo conectas y todo va genial, pero de repente vas a copiar unos cuantos gigas de fotos y te encuentras con que la operación va a tardar días. En ese mismo instante te planteas sacar el máximo provecho a tu red doméstica y la solución se llama gigabit.

A quién va dirigido

Esta guía va dirigida a todo el mundo que esté pensando en hacer o mejorar la red LAN doméstica. Si eres un amante del WIFI, olvídate de esto, ya que para conseguir altas velocidades se necesita cablear la casa. Además, de lo que trata esta guía es de que se conecte un ordenador portátil o sobremesa de la forma más rápida posible al disco duro de red.

Comprobaciones previas

Probablemente dispongas de un Modem / Router proporcionado por tu compañia y que seguramente no sea gigabit (10/100/1000), esto es lo primero que debes comprobar. Busca tu modelo en internet y cerciorate.

También necesitas que la tarjeta de red del portátil o sobremesa sean gigabit, en este caso lo más probable es que lo sean pero asegúrate.

Lo que necesitamos

Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.

Router gigabit (en caso del que tu compañia no lo sea).

Si el nuestro no es gigabit existen soluciones económicas como el TP-Link TL-WR1043ND que lo tenemos por 44€ en pccomponentes. Os recomiendo esta tienda por rapidez, seriedad y no abusan con los gastos de envío.

Switch gigabit (para ampliar puertos)

En caso de que los cuatro puertos que vienen con el router se nos queden cortos, la solución más economica y acertada es un Switch ethernet gigabit como el TP-LINK TL-SG1005D que lo tenemos por 16€. Este dispositivo es una maravilla ya que nos brinda 4 puertos más y no requiere configuración alguna.

Tarjeta de red gigabit (para pc sobremesa en caso de no ser o no disponer)

Son muy económicas, las puedes encontrar por 10€-15€ en cualquier tienda especializada. Ejemplo PCI. Ejemplo PCI-e. Video instalación de una tarjeta de red.

Bobina de cable de red Categoría 6.

100m de cable UTP categoría 6 viene a costar sobre unos 42€.

Cables Cat6 interconexionado router / switch / pc.

Para interconexionado de equipos recomiento estos de 50cm por 1,5€. Para conexión del pc tienes otras larguras más apropiadas. También podéis haceros vosotros los cables con lo sobrante de la bobina, para ello necesitaréis una crimpadora y terminales rj45.

Tomas RJ45 categoría 6.

Esto depende de tu instalación y la gama que elijas. En mi caso utilizo tomas Niessen que solo el conector vale 16€, pero tienes tomas más económicas. De superficie por 2,75€ y empotrable por 8,25€.

Insertadora (punch down) para las tomas RJ45.

Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.

Disco duro de red NAS

Esto es una recomendación personal ya que la elección puede variar en función de las necesidades de almacenamiento y conexiones. Una solución barata y con espacio suficiente para uso doméstico es el disco WD My Cloud 3TB que lo podeis adquirir por 159€.

Presupuesto (Precios Octubre 2014)

Router = 44€
Switch = 16€
Tarjeta de red = 15€
Bobina de cable = 42€
Cables interconexionado 50cm x4 = 6€
Cable conexión pc / switch o router 1,8m = 2,95€
Tomas RJ45 x 2 = 16,5€
Disco duro de red NAS = 159€
TOTAL = 345,45€ + gastos de envío.

Esto puede variar en función de los componentes que elijas comprar pero el coste oscilará entre 250 y 350€, algo bastante asequible para centralizar contenido multimedia. Digo asequible por que la mitad del presupuesto se lo lleva el disco de red, los componentes son más bien baratos.

Ejemplo de instalación

Esquema inicial

En mi esquema disponemos del router proporcionado por el proveedor de internet que en mi caso sí es gigabit pero que solo lo utilizo para dar internet al router neutro.El router neutro junto con el switch me proporcionan 8 puertos gigabit. El router neutro además gestiona el wifi de la casa, pero en el mejor de los casos (Wifi n) estos dispositivos solo podrán mover datos a 300mbps. Utilizo como media center mis amadas Raspberry Pi que en este caso no se benefician de la velocidad ya que disponen de conexión 10/100.

Configurar router neutro

Lo primero a conectar es el router neutro y en este caso, TP-Link te lo pone fácil si no te defiendes muy bien con las redes, ya que proporciona un CD que se encarga de guiarte paso a paso. Lo más importante es la asignación de la IP privada, por defecto es 192.168.2.1 y a no ser que el router de la compañia tenga esa misma IP lo podéis dejar como está.

Disco duro de red NAS

Para configurar el disco de red normalmente viene un CD para ayudar al usuario novel. Lo único que tenéis que tener en cuenta es que la IP debe estar en consonancia con la del router neutro, si el router neutro es 192.168.2.1 al disco NAS podéis asignarle 192.168.2.150. Para más información aquí tenéis la guía de instalación.

Preguntas frecuentes. FAQ

¿El cable normal o cruzado?

Podéis usar cable normal, también llamado conexión Pin a Pin ó 1:1, para toda la instalación ya que los dispositivos de hoy en día aceptan cualquier cable y resuelven internamente en función del cable conectado. Pero si nos ponemos quisquillosos, para conectar elementos pasivos entre sí (router a switch, etc) se utiliza cable normal 1:1. Para conectar elementos activos (PC a router/switch) cable cruzado.

¿Qué norma de colores uso?

Mi consejo es que uses el standard EIA/TIA 568B tanto en la conexión de las cajas como en la creación de los cables.

Cada roseta o toma en su interior tiene definido el orden que debes seguir para conectar los cables según el standard A o B, esto es una aproximación y puede no coincidir con tu toma.

Tengo todo instalado y es categoría 6 pero mi pc me marca que me conecta a 100mbps ¿qué pasa?

Si estás seguro de que las rosetas están bien conectadas, que has usado los cables correctos, que todos los dispositivos son gigabit y tu pc hace de las suyas, quizás debas de forzar a tu tarjeta de red a trabajar en modo gigabit ó 100 full duplex ó 100FD. Esto es debido a que el driver de la tarjeta de red por defecto viene con la opción de «autonegociación» activada y a veces necesita que le «obligues» a trabajar en gigabit.

En cada tarjeta de red puede venir diferente, yo os muestro mi caso desde windows 7:

Diríjete a Inicio > Panel de control > Ver el estado y las tareas de red > conexión de area local

En mi caso marca 1 Gbps pero si estais teniendo problemas os marcará 100 mbps. A continuación pulsa Propiedades.

Pulsa Configurar.

En la pestaña Opciones avanzadas busca la opción de la velocidad, en mi caso «Speed/duplex settings» y selecciona 100 mb Full Duplex. De este modo le forzais a la tarjeta de red a trabajar en modo gigabit. Si no lo consiguiera trabajará en el modo que pueda pero no os dejará sin conexión.

Glosario

NAS – del inglés Network Attached Storage, es el nombre dado a una tecnología de almacenamiento dedicada a compartir la capacidad de almacenamiento a través de una red. Estos discos vienen equipados como mínimo con una conexión RJ45 para integrarlo en una red de forma rápida y sencilla.
Full Duplex – Que transmite y recibe en ambas direcciones al mismo tiempo por cables independientes.
Switch – Un conmutador o switch es un dispositivo digital lógico de interconexión de equipos que opera en la capa de enlace de datos del modelo OSI. Su función es interconectar dos o más segmentos de red, de manera similar a los puentes de red, pasando datos de un segmento a otro de acuerdo con la dirección MAC de destino de las tramas en la red.
Gigabit Ethernet – también conocida como GigaE, es una ampliación del estándar Ethernet (concretamente la versión 802.3ab y 802.3z del IEEE) que consigue una capacidad de transmisión de 1 gigabit por segundo, correspondientes a unos 1000 megabits por segundo de rendimiento contra unos 100 de Fast Ethernet (También llamado 100BASE-TX).

Notas finales

Soy consciente de que me he dejado muchas cosas en el tintero pero mi pretensión es que el lector de un vistazo rápido tenga una idea clara de lo que necesita para lograr una red decente en casa.

disco de red full duplex gigabit nas redes router tarjeta de red tplink

Retos reversing de Challengeland.co

3 noviembre, 2022 por deurus·Sin comentarios

Table of Contents

Introducción

Recién rescatados del inframundo que es mi disco duro, os traigo un paquete de seis crackmes facilones para vuestro uso y disfrute. Desgraciadamente ya no está en activo la web de retos de donde los saqué así que os los dejo en descargas.

Los cuatro primero están realizados en Dev-C++ 4.9.9.2 siendo de estilo consola de comandos. Los dos restantes compilados con MingWin32 GCC 3.x carecen de GUI y vamos, que no se han esmerado mucho en darles forma.

Level 1

No cuesta mucho dar con el código interesante mediante las referencias de texto. En Ollydbg clic derecho sobre el código y Search for > All referenced text strings.

004012E1   |.  8845 E8         MOV BYTE PTR SS:[EBP-18],AL                                    ; ||||
004012E4   |.  C70424 11304000 MOV DWORD PTR SS:[ESP],level1.00403011                         ; ||||ASCII "Input Serial: "
004012EB   |.  E8 C0050000     CALL <JMP.&msvcrt.printf>                                      ; |||\printf
004012F0   |.  8D45 C8         LEA EAX,[LOCAL.14]                                             ; |||
004012F3   |.  894424 04       MOV DWORD PTR SS:[ESP+4],EAX                                   ; |||
004012F7   |.  C70424 20304000 MOV DWORD PTR SS:[ESP],level1.00403020                         ; |||ASCII "%s"
004012FE   |.  E8 9D050000     CALL <JMP.&msvcrt.scanf>                                       ; ||\scanf
00401303   |.  8D45 D8         LEA EAX,[LOCAL.10]                                             ; ||
00401306   |.  8D55 C8         LEA EDX,[LOCAL.14]                                             ; ||
00401309   |.  894424 04       MOV DWORD PTR SS:[ESP+4],EAX                                   ; ||
0040130D   |.  891424          MOV DWORD PTR SS:[ESP],EDX                                     ; ||level1.00403022
00401310   |.  E8 7B050000     CALL <JMP.&msvcrt.strcmp>                                      ; |\strcmp
00401315   |.  8945 C4         MOV [LOCAL.15],EAX                                             ; |
00401318   |.  837D C4 00      CMP [LOCAL.15],0                                               ; |
0040131C   |.  75 0E           JNZ SHORT level1.0040132C                                      ; |
0040131E   |.  C70424 23304000 MOV DWORD PTR SS:[ESP],level1.00403023                         ; |ASCII "Well done. \n"
00401325   |.  E8 86050000     CALL <JMP.&msvcrt.printf>                                      ; \printf
0040132A   |.  EB 0C           JMP SHORT level1.00401338
0040132C   |>  C70424 30304000 MOV DWORD PTR SS:[ESP],level1.00403030                         ; |ASCII "Wrong. \n"
00401333   |.  E8 78050000     CALL <JMP.&msvcrt.printf>                                      ; \printf
00401338   |>  C70424 39304000 MOV DWORD PTR SS:[ESP],level1.00403039                         ; |ASCII "PAUSE"
0040133F   |.  E8 3C050000     CALL <JMP.&msvcrt.system>                                      ; \system
00401344   |.  B8 00000000     MOV EAX,0
00401349   |.  C9              LEAVE
0040134A   \.  C3              RETN

La madre del cordero está en la dirección 401310 que es donde se lleva a cabo la función de comparación strcmp.

756296A0 msvcrt.strcmp     8B5424 04         MOV EDX,DWORD PTR SS:[ESP+4]
756296A4                   8B4C24 08         MOV ECX,DWORD PTR SS:[ESP+8] 
756296A8                   F7C2 03000000     TEST EDX,3				; 0-3 = 4 bucles. Divide la comprobación en 4 bloques
756296AE                   75 3C             JNZ SHORT msvcrt.756296EC		; salta si hemos terminado los 4 bucles
756296B0                 > 8B02              MOV EAX,DWORD PTR DS:[EDX]		; coge 4 caracteres del serial (INICIO BUCLE)
756296B2                   3A01              CMP AL,BYTE PTR DS:[ECX]		; compara el 1º/5º/9º/13º dígito en función del bucle
756296B4                   75 2E             JNZ SHORT msvcrt.756296E4		; salto a zona mala
756296B6                   0AC0              OR AL,AL
756296B8                   74 26             JE SHORT msvcrt.756296E0
756296BA                   3A61 01           CMP AH,BYTE PTR DS:[ECX+1]		; compara el 2º/6º/10º/14º dígito en función del bucle
756296BD                   75 25             JNZ SHORT msvcrt.756296E4		; salto a zona mala
756296BF                   0AE4              OR AH,AH
756296C1                   74 1D             JE SHORT msvcrt.756296E0
756296C3                   C1E8 10           SHR EAX,10
756296C6                   3A41 02           CMP AL,BYTE PTR DS:[ECX+2]		; compara el 3º/7º/11º/15º dígito en función del bucle
756296C9                   75 19             JNZ SHORT msvcrt.756296E4		; salto a zona mala
756296CB                   0AC0              OR AL,AL
756296CD                   74 11             JE SHORT msvcrt.756296E0
756296CF                   3A61 03           CMP AH,BYTE PTR DS:[ECX+3]		; compara el 4º/8º/12º/16º dígito en función del bucle
756296D2                   75 10             JNZ SHORT msvcrt.756296E4		; salto a zona mala
756296D4                   83C1 04           ADD ECX,4
756296D7                   83C2 04           ADD EDX,4
756296DA                   0AE4              OR AH,AH
756296DC                 ^ 75 D2             JNZ SHORT msvcrt.756296B0		; Si no hemos terminado... 
756296DE                   8BFF              MOV EDI,EDI                         
756296E0                   33C0              XOR EAX,EAX			; EAX = 0 que es lo deseado
756296E2                   C3                RETN				; salimos de la función superando la comprobación
756296E3                   90                NOP							
756296E4                   1BC0              SBB EAX,EAX			; Zona mala
756296E6                   D1E0              SHL EAX,1
756296E8                   83C0 01           ADD EAX,1				; EAX = 1 implica bad boy
756296EB                   C3                RETN				; salimos de la función

Si atendemos al volcado vemos el serial bueno Kcgcv8LsmV3nizfJ.

0060FEF0  31 32 33 34 35 36 37 38 39 30 00 75 40 19 18 00  1234567890.u@.
0060FF00  4B 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A  Kcgcv8LsmV3nizfJ

Curiosamente, si introducimos el serial bueno el crackme no lo acepta. Fijándome en la comprobación veo que al introducir un serial de 16 caracteres inserta un carácter nulo (0x00) alterando el serial correcto y falseando la comprobación.

0060FEF0  4B 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A  Kcgcv8LsmV3nizfJ
0060FF00  00 63 67 63 76 38 4C 73 6D 56 33 6E 69 7A 66 4A  .cgcv8LsmV3nizfJ

Ahora ya no podemos comprobarlo pero recuerdo que la web consideraba válido el serial Kcgcv8LsmV3nizfJ, por lo que considero lo anteriormente citado un bug o un intento de despiste del autor.

Level 2

Es exactamente igual que el anterior cambiando el serial por 6LPw3vDYja9KrT2V.

Level 3

La comprobación del serial es igual a las dos anteriores pero añade una función intermedia que suma 0xD a cada carácter de nuestro serial

00401355                 |.  A1 03304000     MOV EAX,DWORD PTR DS:[403003]                  ; ||
0040135A                 |.  8945 E8         MOV [LOCAL.6],EAX                              ; ||
0040135D                 |.  A1 07304000     MOV EAX,DWORD PTR DS:[403007]                  ; ||
00401362                 |.  8945 EC         MOV [LOCAL.5],EAX                              ; ||
00401365                 |.  A1 0B304000     MOV EAX,DWORD PTR DS:[40300B]                  ; ||
0040136A                 |.  8945 F0         MOV [LOCAL.4],EAX                              ; ||
0040136D                 |.  A1 0F304000     MOV EAX,DWORD PTR DS:[40300F]                  ; ||
00401372                 |.  8945 F4         MOV [LOCAL.3],EAX                              ; ||
00401375                 |.  C70424 13304000 MOV DWORD PTR SS:[ESP],level3.00403013         ; ||ASCII "Input Serial: "
0040137C                 |.  E8 CF050000     CALL <JMP.&msvcrt.printf>                      ; |\printf
00401381                 |.  8D45 D8         LEA EAX,[LOCAL.10]                             ; |
00401384                 |.  894424 04       MOV DWORD PTR SS:[ESP+4],EAX                   ; |
00401388                 |.  C70424 00304000 MOV DWORD PTR SS:[ESP],level3.00403000         ; |ASCII "%s"
0040138F                 |.  E8 AC050000     CALL <JMP.&msvcrt.scanf>                       ; \scanf
00401394                 |.  8D5D E8         LEA EBX,[LOCAL.6]
00401397                 |.  8D45 D8         LEA EAX,[LOCAL.10]
0040139A                 |.  890424          MOV DWORD PTR SS:[ESP],EAX
0040139D                 |.  E8 EEFEFFFF     CALL level3.00401290			    ; NUEVA FUNCIÓN SUMA
004013A2                 |.  895C24 04       MOV DWORD PTR SS:[ESP+4],EBX                   ; ||
004013A6                 |.  890424          MOV DWORD PTR SS:[ESP],EAX                     ; ||
004013A9                 |.  E8 82050000     CALL <JMP.&msvcrt.strcmp>                      ; |\strcmp
004013AE                 |.  8945 D4         MOV [LOCAL.11],EAX                             ; |
004013B1                 |.  837D D4 00      CMP [LOCAL.11],0                               ; |
004013B5                 |.  75 0E           JNZ SHORT level3.004013C5                      ; |
004013B7                 |.  C70424 22304000 MOV DWORD PTR SS:[ESP],level3.00403022         ; |ASCII "Well done."
004013BE                 |.  E8 8D050000     CALL <JMP.&msvcrt.printf>                      ; \printf
004013C3                 |.  EB 0C           JMP SHORT level3.004013D1
004013C5                 |>  C70424 2D304000 MOV DWORD PTR SS:[ESP],level3.0040302D         ; |ASCII "Wrong. \n"
004013CC                 |.  E8 7F050000     CALL <JMP.&msvcrt.printf>                      ; \printf
004013D1                 |>  C70424 36304000 MOV DWORD PTR SS:[ESP],level3.00403036         ; |ASCII "PAUSE"
004013D8                 |.  E8 43050000     CALL <JMP.&msvcrt.system>                      ; \system
004013DD                 |.  B8 00000000     MOV EAX,0
004013E2                 |.  8B5D FC         MOV EBX,[LOCAL.1]                              
004013E5                 |.  C9              LEAVE
004013E6                 \.  C3              RETN
--------
004012A4                 |> /8B45 08         /MOV EAX,[ARG.1]                               ; |
004012A7                 |. |890424          |MOV DWORD PTR SS:[ESP],EAX                    ; |
004012AA                 |. |E8 B1060000     |CALL <JMP.&msvcrt.strlen>                     ; \strlen
004012AF                 |. |3945 FC         |CMP [LOCAL.1],EAX
004012B2                 |. |73 1C           |JNB SHORT level3.004012D0
004012B4                 |. |8B45 08         |MOV EAX,[ARG.1]
004012B7                 |. |8B55 FC         |MOV EDX,[LOCAL.1]
004012BA                 |. |01C2            |ADD EDX,EAX
004012BC                 |. |8B45 08         |MOV EAX,[ARG.1]
004012BF                 |. |0345 FC         |ADD EAX,[LOCAL.1]
004012C2                 |. |0FB600          |MOVZX EAX,BYTE PTR DS:[EAX]
004012C5                 |. |04 0D           |ADD AL,0D					    ; char + 0xD
004012C7                 |. |8802            |MOV BYTE PTR DS:[EDX],AL
004012C9                 |. |8D45 FC         |LEA EAX,[LOCAL.1]
004012CC                 |. |FF00            |INC DWORD PTR DS:[EAX]
004012CE                 |.^\EB D4           \JMP SHORT level3.004012A4
--------
756296A0 msvcrt.strcmp     8B5424 04         MOV EDX,DWORD PTR SS:[ESP+4]
756296A4                   8B4C24 08         MOV ECX,DWORD PTR SS:[ESP+8]
756296A8                   F7C2 03000000     TEST EDX,3
756296AE                   75 3C             JNZ SHORT msvcrt.756296EC
756296B0                   8B02              MOV EAX,DWORD PTR DS:[EDX]
756296B2                   3A01              CMP AL,BYTE PTR DS:[ECX]
756296B4                   75 2E             JNZ SHORT msvcrt.756296E4
756296B6                   0AC0              OR AL,AL
756296B8                   74 26             JE SHORT msvcrt.756296E0
756296BA                   3A61 01           CMP AH,BYTE PTR DS:[ECX+1]
756296BD                   75 25             JNZ SHORT msvcrt.756296E4
756296BF                   0AE4              OR AH,AH
756296C1                   74 1D             JE SHORT msvcrt.756296E0
756296C3                   C1E8 10           SHR EAX,10
756296C6                   3A41 02           CMP AL,BYTE PTR DS:[ECX+2]
756296C9                   75 19             JNZ SHORT msvcrt.756296E4
756296CB                   0AC0              OR AL,AL
756296CD                   74 11             JE SHORT msvcrt.756296E0
756296CF                   3A61 03           CMP AH,BYTE PTR DS:[ECX+3]
756296D2                   75 10             JNZ SHORT msvcrt.756296E4
756296D4                   83C1 04           ADD ECX,4
756296D7                   83C2 04           ADD EDX,4
756296DA                   0AE4              OR AH,AH
756296DC                 ^ 75 D2             JNZ SHORT msvcrt.756296B0
756296DE                   8BFF              MOV EDI,EDI
756296E0                   33C0              XOR EAX,EAX
756296E2                   C3                RETN
756296E3                   90                NOP
756296E4                   1BC0              SBB EAX,EAX
756296E6                   D1E0              SHL EAX,1
756296E8                   83C0 01           ADD EAX,1
756296EB                   C3                RETN

En la comparación vemos que el serial bueno es AvrQQsXjDk25Jrh por lo que si restamos 0xD (13 en decimal) a cada carácter obtendremos el serial bueno.

0060FF10  41 76 72 51 51 73 58 6A 44 6B 32 35 4A 72 68 00  AvrQQsXjDk25Jrh.

		  41 76 72 51 51 73 58 6A 44 6B 32 35 4A 72 68
	                                                      - D
		  34 69 65 44 44 66 4B 5D 37 5E 25 28 3D 65 5B
		  4  i  e  D  D  f  K  ]  7  ^  %  (  =  e  [
		  
		  Serial bueno: 4ieDDfK]7^%(=e[

Level 4

La comprobación del serial es igual que la anterior pero sustituyendo la función que sumaba un valor a cada dígito del serial por una que genera un hash con nuestro serial y después lo compara con otro hash almacenado en memoria. Si no nos viene a la mente el tipo de hash que puede ser PEiD ya nos avisaba de que efectivamente el crackme incorpora la función MD5.

La función MD5 hace tiempo que no se considera segura debido a la existencia de numerosos «diccionarios» de hashes que hacen que encontremos la solución en segundos. Yo he utilizado la web MD5 online pero existen muchas más.

0060FE5C   004013BF  RETURN to level4.004013BF from <JMP.&msvcrt.strcmp>
0060FE60   0060FEA0  ASCII "e807f1fcf82d132f9bb018ca6738a19f"
0060FE64   0060FEE0  ASCII "fe01d67a002dfa0f3ac084298142eccd"


e807f1fcf82d132f9bb018ca6738a19f == 1234567890
fe01d67a002dfa0f3ac084298142eccd == orange

Level 5

La carta de presentación de este crackme es la imagen que veis arriba. Al explorarlo unos minutos enseguida nos damos cuenta de que no realiza ninguna comprobación y que nos está haciendo perder el tiempo. Ahí es cuando empezamos a revisar el ejecutable más a fondo y enseguida encontramos la solución con nuestro amigo el editor hexadecimal.

Level 6

Misma carta de presentación que el anterior y misma ausencia de comprobación del serial. En esta ocasión echando un vistazo a los recursos encontramos la solución rápidamente.

Enlaces

challenge challengeland challengeland.co crackme Ollydbg reto

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.

Arnold btm Grant Hammond Jurassic Park Lex MPW Nedry Quadra Satler System7 Tim Wu

AperiSolve (Zsteg)

9 diciembre, 2025 por deurus·Sin comentarios

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

Zsteg es una herramienta especializada en la detección y extracción de información oculta en imágenes, especialmente en formatos PNG y BMP. Está orientada a la esteganografía basada en bit-planes y es muy popular en entornos CTF y análisis forense, gracias a su capacidad para automatizar búsquedas exhaustivas de datos escondidos en los bits menos significativos (LSB) y en configuraciones de color poco habituales. Su principal fortaleza es que no se limita a examinar un único plano: prueba sistemáticamente combinaciones de canales (R, G, B, A), número de bits, orden de lectura y posicionamiento, detectando patrones que podrían pasar inadvertidos en una revisión manual.

Entre sus características más destacadas se encuentran la identificación automática de firmas de archivos (ZIP, PNG, texto ASCII, GZIP, etc.), la extracción directa de bitstreams reconstruidos y el soporte para diferentes rutas de exploración, como b1,rgb,lsb,xy, que describen exactamente cómo se han recuperado los datos. Esta capacidad de correlacionar parámetros técnicos con resultados concretos convierte a zsteg en una herramienta muy eficiente tanto para localizar contenido oculto como para entender la técnica esteganográfica aplicada.

En AperiSolve se utiliza únicamente la parte de Zsteg encargada de ejecutar el análisis automático y devolver todas las detecciones posibles de esteganografía LSB en imágenes PNG y BMP. Concretamente, AperiSolve llama al comando zsteg <imagen> tal como está implementado en el módulo analyze_zsteg , y captura la salida completa línea por línea. Esta salida incluye todas las combinaciones probadas de bit-planes (b1, b2…), canales (r, g, b, a), orden de bits (lsb/msb) y métodos de recorrido (xy), junto con cualquier coincidencia que zsteg reconozca como firma de archivo o texto. Es decir, AperiSolve no aplica filtros ni interpretación adicional: muestra exactamente lo que zsteg detecta y lo organiza para que el usuario pueda identificar rápidamente si existe un archivo embebido, contenido ASCII, o algún patrón de interés.

En AperiSolve veremos algo como esto:

... 
b1,a,lsb,xy         .. 
b1,a,msb,xy         .. 
b1,rgb,lsb,xy       .. file: Zip archive data, at least v1.0 to extract, compression method=store
b1,rgb,msb,xy       .. 
b1,bgr,lsb,xy       .. 
b1,bgr,msb,xy       .. 
b1,rgba,lsb,xy      .. 
b1,rgba,msb,xy      .. file: OpenPGP Public Key
b1,abgr,lsb,xy      .. 
b1,abgr,msb,xy      .. file: OpenPGP Secret Key
b2,r,lsb,xy         .. 
b2,r,msb,xy         .. text: "P@UPUUPAAUU@"
b2,g,lsb,xy         .. text: "(ahOFyIS!"
...

Para entender mejor a que se refiere todo esto vamos a repasar lo básico.

¿Qué es LSB y qué es MSB?

Cuando hablamos de esteganografía en imágenes PNG/BMP, nos referimos a manipular bits dentro de los canales de color (R, G, B, A). Cada canal tiene un valor de 0–255, es decir, 8 bits:

R = 11001010
G = 00110101
B = 11100001

LSB — Least Significant Bit (bit menos significativo). Es el bit más débil, el de la derecha:

1100101[0]   ← LSB

Modificarlo cambia muy poco el color, por eso se usa en esteganografía.
Ejemplo: cambiar 11001010 ↦ 11001011 no cambia el color perceptible.

MSB — Most Significant Bit (bit más significativo). Es el bit más importante, el de la izquierda:

[1]1001010   ← MSB

Modificarlo sí altera mucho el color. A veces se usa pero suele ser detectable.

Cuando Zsteg muestra una línea del estilo b1,rgb,lsb,xy .. file: Zip archive data, está indicando que ha analizado la imagen extrayendo bits según la ruta especificada —en este caso, 1 bit por píxel (b1), combinando los canales rojo, verde y azul (rgb), utilizando el bit menos significativo (lsb) y recorriendo los píxeles en orden normal de lectura (xy)— y que, tras recomponer esos bits, el resultado coincide con la cabecera reconocible de un tipo de archivo real. Por eso aparece “file: Zip archive data”: significa que los bits ocultos forman un flujo válido cuya firma corresponde a un archivo ZIP. En otras ocasiones puede detectar texto ASCII, PNG, JPEG u otros formatos. En resumen, cuando Zsteg muestra esta línea no solo indica dónde se ocultan los datos, sino que confirma que lo recuperado es un archivo auténtico y probablemente extraíble, ya que la estructura binaria coincide con un formato conocido.

Si vemos que Zsteg nos ofrece algo interesante, podemos extraerlo mediante el comando:

zsteg -E b1,rgb,lsb,xy imagen.png > dump.bin

También es habitual usar herramientas como StegSolve. En este caso debemos dirigirnos a Analyse > Data extract para comprobar lo encontrado por zsteg y extraerlo mediante Save Bin.

Zsteg	> Significado <	StegSolve
b1	Extrae 1 bit por canal (bit plano 0, el menos significativo).	En Bit Planes, marca Red 0, Green 0, Blue 0. Solo esos.
rgb	Usa R + G + B en ese orden para reconstruir los bytes.	En Bit Plane Order, selecciona RGB.
lsb	Lee los bits empezando por el LSB (bit 0) antes que el MSB.	En Bit Order, selecciona LSB First.
xy	Recorre la imagen por filas (izquierda → derecha, arriba → abajo).	En Extract By, elige Row.

Más allá de este caso concreto, conviene recordar que la esteganografía no se limita a los LSB: existen métodos basados en paletas, metadatos, manipulación de PNG chunks, secuencias alfa, audio incrustado o capas completas en formatos no comprimidos. Por ello, un análisis completo debería combinar la búsqueda clásica de LSB con herramientas complementarias como binwalk, foremost, exiftool, strings, o incluso análisis manual de cabeceras hexadecimales.

AperiSolve