Categoría: Keygen

Cruehead’s Crackme 2.0 Serial [2/3]

8 septiembre, 2014 por deurus·2 comentarios

Introducción

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

El algoritmo

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

A continuación llegamos aquí:

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

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

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

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

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

Estado del DUMP después del XOR.

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

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

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

Nota**

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

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

Serial: RIDERSOFTHESTORM

Links

AperiSolve en tu Raspi

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he

Digi Logic Challenge

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece. El reto en cuestión nos presenta

List of file signatures for file carving

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

Keygen para el CrackMe #1 de ECloZion

Intro Hoy nos enfrentamos a un crackme realizado en Delphi con un algoritmo bastante sencillo. Está empacado con UPX pero

« Previous 1 … 22 23 24 25 26 … 30 Next »

AperiSolve en tu Raspi

8 diciembre, 2025 por deurus·Sin comentarios

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

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

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

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

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

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

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

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

y pega este contenido:

FROM python:3.11-slim

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

COPY aperisolve/ /aperisolve/

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

WORKDIR /aperisolve

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

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

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

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

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

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

volumes:
  postgres_data:

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

y pega este contenido:

from pathlib import Path

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

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

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

6. Modificación de aperisolve/app.py

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

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

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

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

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

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

Digi Logic Challenge

4 septiembre, 2018 por deurus·Sin comentarios

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

El reto en cuestión nos presenta un esquema de puertas lógicas y una secuencia binaria que al pasarla por las puertas nos devolverá la solución al reto.

La secuencia binaria es ésta:

110111000001110010010011101100011000001101111110000001011101110011101100011000001101011011111000011010100110111000001010100111111111000101110001010

Lo primero que necesitamos saber es que función realiza cada puerta. Si indagamos un poco enseguida llegamos a la conclusión de que el esquema lo componen 3 puertas NOT, cuatro puertas AND y una puerta OR.

El funcionamiento es muy sencillo, la puerta NOT simplemente invierte el dígito de entrada convirtiendo los unos en ceros y los ceros en unos. La puerta AND siempre dará como resultado cero excepto cuando todos dígitos de entrada sean unos, que dará como resultado uno. La puerta OR es contraria a la AND y siempre dará como resultado uno excepto cuando todos los dígitos de entrada sean ceros, que en este caso dará como resultado cero.

Nota: Aunque lo más normal es encontrarse puertas de dos entradas y una salida, cuando tenemos múltiples entradas el funcionamiento es el mismo pudiendo resolverlo de manera secuencial. Por ejemplo, a la primera puerta AND le entran la pista cuatro, la dos y la tres. La solución es hacer cuatro AND dos y el resultado AND tres -> (cuatro AND dos) AND tres.

Teniendo en cuenta el funcionamiento de las puertas y con la ayuda del esquema anterior podemos automatizar el proceso fácilmente. A continuación os dejo el código en .Net.

Dim encoded As String = "110111000001110010010011101100011000001101111110000001011101110011101100011000001101011011111000011010100110111000001010100111111111000101110001010"

        Dim uno, dos, tres, cuatro, cinco, seis As String
        Dim w, x, y, z, tmp As Integer
        For i = 0 To encoded.Length - 1 Step 3
            uno = Mid(encoded, i + 1, 1)
            dos = Mid(encoded, i + 2, 1)
            tres = Mid(encoded, i + 3, 1)

            If uno = "1" Then cuatro = "0"
            If uno = "0" Then cuatro = "1"
            If dos = "1" Then cinco = "0"
            If dos = "0" Then cinco = "1"
            If tres = "1" Then seis = "0"
            If tres = "0" Then seis = "1"

            w = CInt(cuatro And dos) And CInt(tres)
            x = CInt(uno And cinco) And CInt(tres)
            y = CInt(uno And dos) And CInt(seis)
            z = CInt(uno And dos) And CInt(tres)

            tmp = (w Or x) Or (y Or z)
            txt_s.Text &= tmp.ToString
        Next

Obtenemos como resultado: 1100100110100111001111101001111010011000011101100

Si intentamos decodificar la secuencia resultante en bloque no obtenemos ningún resultado pero si tenemos en cuenta que cada letra en binario ocupa siete dígitos enseguida encontramos la solución.

1100100 1101001 1100111 1101001 1110100 1100001 1101100
   d       i       g       i       t       a       l

Enlaces

List of file signatures for file carving

10 octubre, 2017 por deurus·Sin comentarios

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

«File carving», literalmente tallado de archivos aunque lo traduciremos como extracción, es el proceso de re-ensamblado de archivos extraídos de un conjunto de mayor tamaño.

Table of Contents

List of headers and tails / Lista de cabeceras y pies

Header = Cabecera

Footer or tail = Pie

Image files / Archivos de imagen

JPEG
- Header: FFD8
- Footer: FFD9
GIF87a
- Header: 47 49 46 38 37 61
- Footer: 00 3B
GIF89a
- Header: 47 49 46 38 39 61
- Footer: 00 3B
BMP
- Header: 42 4D
- Footer: Don’t have footer, but size is in bytes 2,3,4,5 in little-endian order (low byte first).
  - Example: 00 00 C0 38 == 49208 bytes

PNG
- Header: 89 50 4E 47 0D 0A 1A 0A
- Footer: 49 45 4E 44 AE 42 60 82

Microsoft Office >2007

All this documents have the same header and footer, because of this, we need search the middle bytes. This type uses a ZIP file package.

Los documentos de Microsoft Office >2007 tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.

DOCX
- Header: 50 4B 03 04 14 00 06 00
  - Middle: 77 6F 72 64 (word)
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
XLSX
- Header: 50 4B 03 04 14 00 06 00
  - Middle: 77 6F 72 6B 73 68 65 65 74 73 (worksheets)
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
PPTX
- Header: 50 4B 03 04 14 00 06 00
  - Middle: 70 72 65 73 65 6E 74 61 74 69 6F 6E (presentation)
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
MDB / ACCDB
- Header: 00 01 00 00 53 74 61 6E 64 61 72 64 20 4A 65 74 20 44 42 (….Standard Jet DB)
- Footer: Don’t have footer.

Open Office

All this documents have the same header and footer, because of this, we need some bytes to differentiate them. In this case we can do this jumping 73 bytes from header. This type uses a ZIP file package.

Los documentos de OpenOffice tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.

ODS
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 73 70 72 65 (spre)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODT
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 74 65 78 64 (text)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODB
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 62 61 73 65 (base)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODG
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 67 72 61 70 (grap)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODF
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 66 6F 72 6D (form)
- Tail: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODP
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 70 72 65 73 (pres)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.

Autocad

DWG (R11/R12 versions)
- Header: 41 43 31 30 30 39
- Footer: CD 06 B2 F5 1F E6
DWG (R14 version)
- Header: 41 43 31 30 31 34
- Footer: 62 A8 35 C0 62 BB EF D4
DWG (2000 version)
- Header: 41 43 31 30 31 34
- Footer: DB BF F6 ED C3 55 FE
DWG (>2007 versions)
- Header: 41 43 31 30 XX XX
- Footer: Don’t have

Note: >2007 versions have two patterns and the key is the position 0x80. If in this position we get the bytes «68 40 F8 F7 92», we need to search again for this bytes and displace 107 bytes to find the end of the file. If in the position 0x80 we get another different bytes, we need to search again this bytes and displace 1024 bytes to find the end of the file.

Nota: Las versiones >2007 siguen dos patrones y la clave está en la posición 0x80. Si en la posicion 0x80 obtenemos los bytes «68 40 F8 F7 92», los buscamos una segunda vez y ha 107 bytes encontramos el final del archivo. Si en la posición 0x80 obtenemos otros bytes diferentes a los del primer caso, los volvemos a buscar y a 1024 bytes hallaremos el final del archivo.

Others / Otros

PDF
- Header: 25 50 44 46 (%PDF)
- Footers:
  - 0A 25 25 45 4F 46 (.%%EOF) or
  - 0A 25 25 45 4F 46 0A (.%%EOF.) or
  - 0D 0A 25 25 45 4F 46 0D 0A (..%%EOF..) or
  - 0D 25 25 45 4F 46 0D (.%%EOF.)
ZIP
- Header: 50 4B 03 04
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
RAR (< 4.x version)
- Header: 52 61 72 21 1A 07 00
- Tail: C4 3D 7B 00 40 07 00
7ZIP
- Header: 37 7A BC AF 27 1C 00 03 (7z¼¯’…)
- Footer: 01 15 06 01 00 20 followed by 5 additional bytes at the end of the file.
RTF
- Header: 7B 5C 72 74 66 31
- Footer: 5C 70 61 72 20 7D

Links / Enlaces

Keygen para el CrackMe #1 de ECloZion

18 septiembre, 2014 por deurus·1 comentario

Intro

Hoy nos enfrentamos a un crackme realizado en Delphi con un algoritmo bastante sencillo. Está empacado con UPX pero aquí no vamos a explicar como desempacarlo ya que UPX es un reductor de tamaño más que un empacador, incluso con el propio empacador podemos desempacarlo.

Nota: Si queréis ver el proceso completo de desempacado ver el siguiente video (http://youtu.be/c4CNY902SAE).

El algoritmo

Abrimos Olly y vamos a las string references, localizamos los mensajes de error y éxito y pulsamos sobre cualquiera.

Encima de los mensajes tenemos la rutina de comprobación del serial. En la primera imagen vemos que comprueba que no dejemos ningún campo vacío y a continuación se mete de lleno con el serial.

Analicemos la rutina del serial.

00454882       |> /8B15 4C6C4500          /MOV EDX,DWORD PTR DS:[456C4C]      ; Concatena name + ECloZion + pronom   <---
00454888       |. |8B0D 506C4500          |MOV ECX,DWORD PTR DS:[456C50]
0045488E       |. |0FB6540A FF            |MOVZX EDX,BYTE PTR DS:[EDX+ECX-1]  ; Coje el dígito que toque
00454893       |. |8916                   |MOV DWORD PTR DS:[ESI],EDX         ; Mueve EDX a TEMP (inicialmente vale FFFFFFFF)
00454895       |. |833E 5F                |CMP DWORD PTR DS:[ESI],5F
00454898       |. |75 06                  |JNZ SHORT ECloZion.004548A0
0045489A       |. |C706 20000000          |MOV DWORD PTR DS:[ESI],20
004548A0       |> |8B17                   |MOV EDX,DWORD PTR DS:[EDI]
004548A2       |. |3116                   |XOR DWORD PTR DS:[ESI],EDX         ;  TEMP = TEMP xor digito
004548A4       |. |8136 CE9A5614          |XOR DWORD PTR DS:[ESI],14569ACE    ;  TEMP = TEMP xor 14569ACE
004548AA       |. |8B16                   |MOV EDX,DWORD PTR DS:[ESI]
004548AC       |. |8917                   |MOV DWORD PTR DS:[EDI],EDX
004548AE       |. |FF05 506C4500          |INC DWORD PTR DS:[456C50]
004548B4       |. |48                     |DEC EAX                            ; EAX = longitud del concatenado = contador del bucle.
004548B5       |.^\75 CB                  \JNZ SHORT ECloZion.00454882        ; Bucle --->
004548B7       |>  8137 F0BD6434          XOR DWORD PTR DS:[EDI],3464BDF0     ; TEMP 0 TEMP xor 3464BDF0

Ejemplo:

Nom: deurus
Prenom: any

d  e  u  r  u  s  E  C  l  o  Z  i  o  n  a  n  y
64 65 75 72 75 73 45 43 6C 6F 5A 69 6F 6E 61 6E 79

FFFFFFFF xor 64 = FFFFFF9B xor 14569ACE = EBA96555
EBA96555 xor 65 = EBA96530 xor 14569ACE = FFFFFFFE
FFFFFFFE xor 75 = FFFFFF8B xor 14569ACE = EBA96545
EBA96545 xor 72 = EBA96537 xor 14569ACE = FFFFFFF9
FFFFFFF9 xor 75 = FFFFFF8C xor 14569ACE = EBA96542
EBA96542 xor 73 = EBA96531 xor 14569ACE = FFFFFFFF
FFFFFFFF xor 45 = FFFFFFBA xor 14569ACE = EBA96574
EBA96574 xor 43 = EBA96537 xor 14569ACE = FFFFFFF9
FFFFFFF9 xor 6C = FFFFFF95 xor 14569ACE = EBA9655B
EBA9655B xor 6F = EBA96534 xor 14569ACE = FFFFFFFA
FFFFFFFA xor 5A = FFFFFFA0 xor 14569ACE = EBA9656E
EBA9656E xor 69 = EBA96507 xor 14569ACE = FFFFFFC9
FFFFFFC9 xor 6F = FFFFFFA6 xor 14569ACE = EBA96568
EBA96568 xor 6E = EBA96506 xor 14569ACE = FFFFFFC8
FFFFFFC8 xor 61 = FFFFFFA9 xor 14569ACE = EBA96567
EBA96567 xor 6E = EBA96509 xor 14569ACE = FFFFFFC7
FFFFFFC7 xor 79 = FFFFFFBE xor 14569ACE = EBA96570
--------------------------------------------------
Resultado = EBA96570
EBA96570 xor 3464BDF0 = DFCDD880 = 3754809472 --> nuestra serial

KeyGen en C++

            char Nombre[20];
            GetWindowText(hwndEdit1, Nombre, 20);
            char prenom[20];
            GetWindowText(hwndEdit2, prenom, 20);
            char Serial[20];
            char concatenado[48];
            wsprintf(concatenado,"%sECloZion%s",Nombre,prenom);
            int len = strlen(concatenado);
            unsigned int suma = 0xFFFFFFFF;
                for(int i = 0; i < len; i = i + 1)
                {
                        suma = suma ^ concatenado[i];
                        suma = suma ^ 0x14569ACE;
                }
            suma = suma ^ 0x3464BDF0;
            wsprintf(Serial,"%u",suma);
            SetWindowText(hwndEdit3, TEXT(Serial));

Links

Blooper Tech Movie V – Algo huele a podrido en Hawkins

He de iniciar esta entrada diciendo que la segunda temporada de Stranger Things es sencillamente genial. Son 9 horas intensas

5 Retos Stego sencillos

Computer Password Security Hacker En el primer vistazo con el editor hexadecimal ya vemos la solución al reto: Pho Al

Stego XVI - Bytes

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

Solución al Crackme Zebra 1.1 de aLoNg3x

Introducción Hoy tenemos aquí un crackme de los que te hacen temblar las conexiones neuronales. Estamos acostumbrados al típico serial

« Previous 1 … 22 23 24 25 26 … 30 Next »

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

5 Retos Stego sencillos

12 agosto, 2024 por deurus·Sin comentarios

Table of Contents

Computer Password Security Hacker

En el primer vistazo con el editor hexadecimal ya vemos la solución al reto:

Pho

Al igual que el caso anterior con el editor hexadecimal tenemos más que suficiente para resolver el reto.

Minions

En el análisis inicial no destaca prácticamente nada excepto la palabra myadmin que podemos ver con un editor hexadecimal.

La palabra myadmin es una buena candidata a ser contraseña ante una decodificación. Probamos con lo estándar y conseguimos resultados con steghide. La decodificación nos devuelve la cadena AEMAVABGAGwAZQBhAHIAbgB7AHQAaABpAHMAXwBpAHMAXwBmAHU***** que rápidamente catalogamos como base64 para resolver el reto.

Unopenable

Se nos entrega una imagen GIF aparentemente corrupta. Estudiando un poco la cabecera de los archivos GIF llegamos rápidamente a la conclusión de que faltan los cuatro primeros bytes del archivo.

Bytes originales
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F

00000000  39 61 F4 01 F4 01 F4 00 00 00 00 00 3A 00 00 00  9aô.ô.ô.....:...
00000010  00 3A 3A 00 3A 66 00 00 66 00 3A 00 00 66 90 3A  .::.:f..f.:..f.:
00000020  00 90 3A 3A B6 66 00 B6 66 3A 90 90 3A DB 90 3A  ..::¶f.¶f:..:Û.:
00000030  FF B6 66 00 3A 90 66 3A 90 00 66 90 00 66 B6 3A  ÿ¶f.:.f:..f..f¶:

Después de insertar los bytes que faltan
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F

00000000  47 49 46 38 39 61 F4 01 F4 01 F4 00 00 00 00 00  GIF89aô.ô.ô.....
00000010  3A 00 00 00 00 3A 3A 00 3A 66 00 00 66 00 3A 00  :....::.:f..f.:.
00000020  00 66 90 3A 00 90 3A 3A B6 66 00 B6 66 3A 90 90  .f.:..::¶f.¶f:..
00000030  3A DB 90 3A FF B6 66 00 3A 90 66 3A 90 00 66 90  :Û.:ÿ¶f.:.f:..f.

Una vez insertados los bytes podemos ver una animación que contiene una cadena de texto fácilmente reconocible como base64. La decodificamos y ya tenemos la solución.

Oreo

Mirando con un editor hexadecimal no encontramos nada excepto la frase This is not the flag you are looking for para intentar disuadirnos.

Cargamos la imagen en Aperi’Solve y enseguida nos llama la atención la sección Binwalk y un suculento Rar.

Descargamos el archivo Rar y al descomprimir nos encontramos con un archivo de texto con la misma frase desalentadora del inicio y una imagen JPG, esta vez con dos oreos. Inspeccionando la imagen damos con la solución.

Stego XVI – Bytes

6 noviembre, 2022 por deurus·Sin comentarios

Table of Contents

Intro

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

Procesando a la víctima

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

La víctima

imagen original del reto

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

Bytes

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

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

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

Enlaces

Nota: si algo os pide clave es deurus.info

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

Solución al Crackme Zebra 1.1 de aLoNg3x

12 octubre, 2014 por deurus·1 comentario

Introducción

Hoy tenemos aquí un crackme de los que te hacen temblar las conexiones neuronales. Estamos acostumbrados al típico serial asociado a un nombre y a veces nos sorprenden.

El crackme data del año 2000, está realizado por aLoNg3x y lo tenéis colgado en crackmes.de. En crackmes.de también disponéis de una solución muy elegante realizada por cronos, pero que no acaba de saciar nuestro afán de descubrir todas las soluciones posibles.

El algoritmo

Abrimos el crackme con Olly y enseguida encontramos la rutina de comprobación junto con los mensajes de éxito y error. Os dejo la rutina comentada como siempre.

004012D7   |.  83C4 08             ADD ESP,8                                 ;  
004012DA   |.  09C0                OR EAX,EAX                                ;  
004012DC   |. /74 16               JE SHORT Zebrone.004012F4                 ;  Salta a Bad boy
004012DE   |. |6A 00               PUSH 0                                    ; /Style = MB_OK|MB_APPLMODAL
004012E0   |. |68 26324000         PUSH Zebrone.00403226                     ; |Title = "Great !!!"
004012E5   |. |68 30324000         PUSH Zebrone.00403230                     ; |Text = "Congratulations, you have cracked the Zebra Crackme ver 1.1"
004012EA   |. |FF75 08             PUSH [ARG.1]                              ; |hOwner = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
004012ED   |. |E8 C6010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
004012F2   |. |EB 14               JMP SHORT Zebrone.00401308
004012F4   |> \6A 00               PUSH 0                                    ; /Style = MB_OK|MB_APPLMODAL
004012F6   |.  68 F8314000         PUSH Zebrone.004031F8                     ; |Title = "Hmmmm :P"
004012FB   |.  68 01324000         PUSH Zebrone.00403201                     ; |Text = "Sorry... The Serial isn't correct :Þ"
00401300   |.  FF75 08             PUSH [ARG.1]                              ; |hOwner = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
00401303   |.  E8 B0010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401308   |>  31C0                XOR EAX,EAX
0040130A   |.  40                  INC EAX
0040130B   |.  EB 39               JMP SHORT Zebrone.00401346
0040130D   |>  6A 00               PUSH 0                                    ; /Result = 0
0040130F   |.  FF75 08             PUSH [ARG.1]                              ; |hWnd = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
00401312   |.  E8 89010000         CALL <JMP.&USER32.EndDialog>              ; \EndDialog
00401317   |.  31C0                XOR EAX,EAX
00401319   |.  40                  INC EAX
0040131A   |.  EB 2A               JMP SHORT Zebrone.00401346
0040131C   |>  6A 00               PUSH 0                                    ; /Style = MB_OK|MB_APPLMODAL
0040131E   |.  68 40304000         PUSH Zebrone.00403040                     ; |Title = "Zebra ver. 1.1"
00401323   |.  68 4F304000         PUSH Zebrone.0040304F                     ; |Text = "This is the 1.1 Zebra Crackme, Thanks to Quequero and Koma, to have said me a bug of the previous version. (It was due to an orrible cpu appoximation). As usually you cannot patch this .EXE, you've to find one of the many correct solut"...
00401328   |.  FF75 08             PUSH [ARG.1]                              ; |hOwner = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
0040132B   |.  E8 88010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401330   |.  31C0                XOR EAX,EAX
00401332   |.  40                  INC EAX
00401333   |.  EB 11               JMP SHORT Zebrone.00401346
00401335   |>  6A 00               PUSH 0                                    ; /Result = 0
00401337   |.  FF75 08             PUSH [ARG.1]                              ; |hWnd = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
0040133A   |.  E8 61010000         CALL <JMP.&USER32.EndDialog>              ; \EndDialog
0040133F   |.  31C0                XOR EAX,EAX
00401341   |.  40                  INC EAX
00401342   |.  EB 02               JMP SHORT Zebrone.00401346
00401344   |>  31C0                XOR EAX,EAX
00401346   |>  C9                  LEAVE
00401347   \.  C2 1000             RETN 10
================================================================
0040134A   /$  55                  PUSH EBP
0040134B   |.  89E5                MOV EBP,ESP
0040134D   |.  83EC 68             SUB ESP,68
00401350   |.  FF75 08             PUSH [ARG.1]                              ; /x1
00401353   |.  E8 78010000         CALL <JMP.&CRTDLL.atof>                   ; \atof
00401358   |.  DD55 E8             FST QWORD PTR SS:[EBP-18]
0040135B   |.  83EC 08             SUB ESP,8
0040135E   |.  DD1C24              FSTP QWORD PTR SS:[ESP]
00401361   |.  E8 82010000         CALL <JMP.&CRTDLL.floor>
00401366   |.  DD5D F8             FSTP QWORD PTR SS:[EBP-8]
00401369   |.  FF75 0C             PUSH [ARG.2]                              ; /x2
0040136C   |.  E8 5F010000         CALL <JMP.&CRTDLL.atof>                   ; \atof
00401371   |.  DD55 D8             FST QWORD PTR SS:[EBP-28]
00401374   |.  83EC 08             SUB ESP,8
00401377   |.  DD1C24              FSTP QWORD PTR SS:[ESP]
0040137A   |.  E8 69010000         CALL <JMP.&CRTDLL.floor>
0040137F   |.  83C4 18             ADD ESP,18
00401382   |.  DD55 F0             FST QWORD PTR SS:[EBP-10]
00401385   |.  DC4D F8             FMUL QWORD PTR SS:[EBP-8]
00401388   |.  D9EE                FLDZ
0040138A   |.  DED9                FCOMPP                                    ;  floor(x1)*floor(x2)=0 ???
0040138C   |.  DFE0                FSTSW AX                                  ;  <<Store status word
0040138E   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
0040138F   |.  75 07               JNZ SHORT Zebrone.00401398                ;  Si salta todo OK
00401391   |.  31C0                XOR EAX,EAX
00401393   |.  E9 96000000         JMP Zebrone.0040142E                      ;  Bad boy
00401398   |>  DD45 F8             FLD QWORD PTR SS:[EBP-8]                  ;  <<Floating point load
0040139B   |.  DC5D F0             FCOMP QWORD PTR SS:[EBP-10]               ;  x1 = x2 ???
0040139E   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013A0   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013A1   |.  75 07               JNZ SHORT Zebrone.004013AA                ;  Si salta todo OK
004013A3   |.  31C0                XOR EAX,EAX
004013A5   |.  E9 84000000         JMP Zebrone.0040142E                      ;  Bad boy
004013AA   |>  DD45 F8             FLD QWORD PTR SS:[EBP-8]                  ;  <<Floating point load
004013AD   |.  DD5D C8             FSTP QWORD PTR SS:[EBP-38]
004013B0   |.  D9E8                FLD1                                      ;  Carga 1 en el stack
004013B2   |.  DD55 C0             FST QWORD PTR SS:[EBP-40]                 ;  <<Floating point store
004013B5   |.  DC5D C8             FCOMP QWORD PTR SS:[EBP-38]               ;  x1 > 1 ???
004013B8   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013BA   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013BB   |.  77 2D               JA SHORT Zebrone.004013EA                 ;  Si salta bad boy
004013BD   |.  DF2D 38304000       FILD QWORD PTR DS:[403038]                ;  <<Load integer>> 2540BE400 = 10^10
004013C3   |.  DD55 B8             FST QWORD PTR SS:[EBP-48]                 ;  <<Floating point store
004013C6   |.  DC5D C8             FCOMP QWORD PTR SS:[EBP-38]               ;  x1 < 10^10 ???
004013C9   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013CB   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013CC   |.  72 1C               JB SHORT Zebrone.004013EA                 ;  Si salta bad boy
004013CE   |.  DD45 F0             FLD QWORD PTR SS:[EBP-10]                 ;  <<Floating point load
004013D1   |.  DD5D B0             FSTP QWORD PTR SS:[EBP-50]                ;  <<Store and pop
004013D4   |.  DD45 C0             FLD QWORD PTR SS:[EBP-40]                 ;  <<Floating point load
004013D7   |.  DC5D B0             FCOMP QWORD PTR SS:[EBP-50]               ;  x2 > 1 ???
004013DA   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013DC   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013DD   |.  77 0B               JA SHORT Zebrone.004013EA                 ;  Si salta bad boy
004013DF   |.  DD45 B8             FLD QWORD PTR SS:[EBP-48]                 ;  <<Floating point load>> carga 10^10
004013E2   |.  DC5D B0             FCOMP QWORD PTR SS:[EBP-50]               ;  x2 < 10^10 ???
004013E5   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013E7   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013E8   |.  73 04               JNB SHORT Zebrone.004013EE                ;  Salta si menor
004013EA   |>  31C0                XOR EAX,EAX
004013EC   |.  EB 40               JMP SHORT Zebrone.0040142E                ;  Bad boy
004013EE   |>  DD45 F8             FLD QWORD PTR SS:[EBP-8]                  ;  <<Floating point load>> carga x1
004013F1   |.  D9FE                FSIN                                      ;  Sin(x1)
004013F3   |.  DD5D A8             FSTP QWORD PTR SS:[EBP-58]                ;  <<Store and pop
004013F6   |.  DD45 F0             FLD QWORD PTR SS:[EBP-10]                 ;  <<Floating point load>> carga x2
004013F9   |.  D9FE                FSIN                                      ;  Sin(x2)
004013FB   |.  DD5D A0             FSTP QWORD PTR SS:[EBP-60]                ;  <<Store and pop
004013FE   |.  DD45 A8             FLD QWORD PTR SS:[EBP-58]                 ;  <<Floating point load
00401401   |.  DC4D A0             FMUL QWORD PTR SS:[EBP-60]                ;  Sin(x1) * Sin(x2)
00401404   |.  DF2D 30304000       FILD QWORD PTR DS:[403030]                ;  <<Load integer>> 2386F26FC10000 = 10^16
0040140A   |.  DEC9                FMULP ST(1),ST                            ;  10^16 * (Sin(x1) * Sin(x2))
0040140C   |.  83EC 08             SUB ESP,8
0040140F   |.  DD1C24              FSTP QWORD PTR SS:[ESP]                   ;  <<Store and pop
00401412   |.  E8 D1000000         CALL <JMP.&CRTDLL.floor>
00401417   |.  83C4 08             ADD ESP,8
0040141A   |.  DD5D 98             FSTP QWORD PTR SS:[EBP-68]
0040141D   |.  D9EE                FLDZ                                      ;  <<Load 0.0 onto stack
0040141F   |.  DC5D 98             FCOMP QWORD PTR SS:[EBP-68]               ;  10^16 * (Sin(x1) * Sin(x2)) = 0 ???
00401422   |.  DFE0                FSTSW AX
00401424   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
00401425   |.  75 05               JNZ SHORT Zebrone.0040142C                ;  Si NO salta todo OK
00401427   |.  31C0                XOR EAX,EAX
00401429   |.  40                  INC EAX
0040142A   |.  EB 02               JMP SHORT Zebrone.0040142E
0040142C   |>  31C0                XOR EAX,EAX
0040142E   |>  C9                  LEAVE
0040142F   \.  C3                  RETN

La primera dificultad que podemos encontrar es que utiliza instrucciones FPU y coma flotante, ya que si no tenemos la vista entrenada nos puede resultar un engorro. Superado esto, la rutina de comprobación se puede resumir así:

x1 * x2 != 0
x1 != x2
x1 > 1 y < 10^10
x2 > 1 y < 10^10
Floor[10^16 * sin(x1) * sin(x2)] = 0

A priori no parece que tenga mucha dificultad, pero vamos a analizarlo más concienzudamente. Necesitamos que la parte entera del resultado de la multiplicación sea 0, algo que parece sencillo, pero fíjate que la constante 10^16 nos obliga a su vez, a que el resultado del seno sea muy pequeño, cosa que como comprobaréis limita mucho los resultados satisfactorios.

Repasando trigonometría

Cuando nos enseñó nuestro profesor la función del seno nos hizo el siguiente dibujo:

Partiendo de la circunferencia unitaria, podemos concluir que el seno de alpha es igual a la altura x. Como lo que nos interesa a nosotros es que el seno sea muy pequeño, en realidad estamos buscando que la x sea lo más pequeña posible. Llegamos entonces a la conclusión de que las soluciones para enteros entre 1 y 10^10 van a ser muy reducidas. Además nos percatamos que el ángulo alpha va a tener que estar muy proximo a 0º – 360 (0 – 2π) y a 180º (π). En el siguiente gráfico queda claro el estrecho margen en el que nos movemos.

Si habéis leído la solución de cronos ahora le encontraréis algo más de sentido a por que él utilizó fracciones continuas de π y cogió como resultado los numeradores más cercanos a 10^10, en su caso 245850922 y 411557987.

Análisis operacional

Vamos a analizar un ejemplo operacional.

sin( x rad)
sin(245850922) = 6,1180653830011163142712109862972e-9
sin(411557987) = 2,536716051963676479648989773448e-9

sin(245850922)*sin(411557987) = 1,5519794664022230015882605365808e-17

10^16 * 1,5519794664022230015882605365808e-17 = 0,15519794664022230015882605365808

Floor(0,15519794664022230015882605365808) = 0

Como veis, el exponente negativo (^-17) debe ser mayor que el positivo (^16) para tener éxito.

Fuerza bruta

Lo que vamos a hacer a continuación es buscar todos los senos con exponente negativo ^-8 ó ^-9 de enteros entre 1 y 10^10, y vamos a cruzar los resultados para determinar todos los resultados válidos.

Preparamos el programa y le dejamos trabajar. En principio vamos a filtrar todos los resultados que tengan exponente negativo y luego ya aislaremos los que nos interesan. Esto lo hago por curiosidad.

La fuerza bruta nos arroja 63663 resultados con exponente negativo entre ^-5 y ^-9, de los cuales solamente nos quedamos con 65, que son los comprendidos a exponentes de entre ^-8 y ^-9. Los números mágicos son los siguientes:

Los rojos son exponentes ^-9, el resto ^-8.

La mayoría de estos números solo valen con ciertas combinaciones, de hecho, ninguno vale para todos. Esto se debe, a parte del propio exponente, a que hay senos positivos y negativos y para hacer válido a un seno negativo hay que combinarlo con otro negativo. Esto último se debe únicamente a la interpretación que hace el crackme.

Finalmente cruzamos los resultados y obtenemos 44 combinaciones de seriales válidos que si obviamos repeticiones se reducen a la mitad.

Combinaciones válidas:

Conclusiones

Podemos concluir que para cada 10^10 enteros hay 22 soluciones posibles. Finalmente comentar que si aLoNg3x no hubiera puesto el límite en 10^10, habría soluciones infinitas.

Links

Wechall Training LSB Challenge (Esteganografía)

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

List of file signatures for file carving

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

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

Solución al CrackMe Matrix de ZemoZ

Introducción Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie

« Previous 1 … 22 23 24 25 26 … 30 Next »

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.

List of file signatures for file carving

10 octubre, 2017 por deurus·Sin comentarios

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

«File carving», literalmente tallado de archivos aunque lo traduciremos como extracción, es el proceso de re-ensamblado de archivos extraídos de un conjunto de mayor tamaño.

Table of Contents

Índice

Image files / Archivos de imagen
Microsoft Office >2007
Open Office
Autocad
Others / Otros
Links / Enlaces

List of headers and tails / Lista de cabeceras y pies

Header = Cabecera

Footer or tail = Pie

Image files / Archivos de imagen

JPEG
- Header: FFD8
- Footer: FFD9
GIF87a
- Header: 47 49 46 38 37 61
- Footer: 00 3B
GIF89a
- Header: 47 49 46 38 39 61
- Footer: 00 3B
BMP
- Header: 42 4D
- Footer: Don’t have footer, but size is in bytes 2,3,4,5 in little-endian order (low byte first).
  - Example: 00 00 C0 38 == 49208 bytes

PNG
- Header: 89 50 4E 47 0D 0A 1A 0A
- Footer: 49 45 4E 44 AE 42 60 82

Microsoft Office >2007

All this documents have the same header and footer, because of this, we need search the middle bytes. This type uses a ZIP file package.

Los documentos de Microsoft Office >2007 tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.

DOCX
- Header: 50 4B 03 04 14 00 06 00
  - Middle: 77 6F 72 64 (word)
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
XLSX
- Header: 50 4B 03 04 14 00 06 00
  - Middle: 77 6F 72 6B 73 68 65 65 74 73 (worksheets)
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
PPTX
- Header: 50 4B 03 04 14 00 06 00
  - Middle: 70 72 65 73 65 6E 74 61 74 69 6F 6E (presentation)
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
MDB / ACCDB
- Header: 00 01 00 00 53 74 61 6E 64 61 72 64 20 4A 65 74 20 44 42 (….Standard Jet DB)
- Footer: Don’t have footer.

Open Office

Los documentos de OpenOffice tienen la misma cabecera y pie, por lo que necesitamos bytes intermedios para distinguirlos. Usan encapsulado ZIP.

ODS
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 73 70 72 65 (spre)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODT
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 74 65 78 64 (text)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODB
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 62 61 73 65 (base)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODG
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 67 72 61 70 (grap)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODF
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 66 6F 72 6D (form)
- Tail: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.
ODP
- Header: 50 4B 03 04 14 (PK..) jump +73 (0x49) bytes and 70 72 65 73 (pres)
- Footer: 6D 61 6E 69 66 65 73 74 2E 78 6D 6C 50 4B 05 06 (manifest.xmlPK) followed by 18 additional bytes.

Autocad

DWG (R11/R12 versions)
- Header: 41 43 31 30 30 39
- Footer: CD 06 B2 F5 1F E6
DWG (R14 version)
- Header: 41 43 31 30 31 34
- Footer: 62 A8 35 C0 62 BB EF D4
DWG (2000 version)
- Header: 41 43 31 30 31 34
- Footer: DB BF F6 ED C3 55 FE
DWG (>2007 versions)
- Header: 41 43 31 30 XX XX
- Footer: Don’t have

Others / Otros

PDF
- Header: 25 50 44 46 (%PDF)
- Footers:
  - 0A 25 25 45 4F 46 (.%%EOF) or
  - 0A 25 25 45 4F 46 0A (.%%EOF.) or
  - 0D 0A 25 25 45 4F 46 0D 0A (..%%EOF..) or
  - 0D 25 25 45 4F 46 0D (.%%EOF.)
ZIP
- Header: 50 4B 03 04
- Footer: 50 4B 05 06 (PK..) followed by 18 additional bytes at the end of the file.
RAR (< 4.x version)
- Header: 52 61 72 21 1A 07 00
- Tail: C4 3D 7B 00 40 07 00
7ZIP
- Header: 37 7A BC AF 27 1C 00 03 (7z¼¯’…)
- Footer: 01 15 06 01 00 20 followed by 5 additional bytes at the end of the file.
RTF
- Header: 7B 5C 72 74 66 31
- Footer: 5C 70 61 72 20 7D

Links / Enlaces

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.

Solución al CrackMe Matrix de ZemoZ

19 agosto, 2020 por deurus·Sin comentarios

Table of Contents

Introducción

Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie asociado a un nombre la comprobación se realiza mediante checkboxes con una matriz de 7×3. El CrackMe está realizado en Visual C++ lo que facilita en parte encontrar rápidamente la rutina de comprobación.

Comprobación

004013C5   > /8B7424 10     MOV     ESI,[DWORD SS:ESP+10]						;
004013C9   . |33FF          XOR     EDI,EDI
004013CB   > |8B86 74304000 MOV     EAX,[DWORD DS:ESI+403074]                   ;
004013D1   . |8BCB          MOV     ECX,EBX
004013D3   . |50            PUSH    EAX
004013D4   . |E8 6F020000   CALL    <JMP.&MFC42.#3092_CWnd::GetDlgItem>			; Lee el estado del checkbox
004013D9   . |8B48 20       MOV     ECX,[DWORD DS:EAX+20]
004013DC   . |6A 00         PUSH    0
004013DE   . |6A 00         PUSH    0
004013E0   . |68 F0000000   PUSH    0F0
004013E5   . |51            PUSH    ECX                                         ; 
004013E6   . |FFD5          CALL    NEAR EBP
004013E8   . |3B86 20304000 CMP     EAX,[DWORD DS:ESI+403020]					; Comprueba el estado del checkbox (1 activado 0 desactivado)
004013EE   . |75 20         JNZ     SHORT Matrix_C.00401410						; Salto a chico malo
004013F0   . |47            INC     EDI											; Incrementa contador
004013F1   . |83C6 04       ADD     ESI,4
004013F4   . |83FF 07       CMP     EDI,7										; ¿Hemos terminado de leer las columnas? ¿contador = 7?
004013F7   .^|7C D2         JL      SHORT Matrix_C.004013CB                     ; si terminan las columnas deja pasar
004013F9   . |8B4424 10     MOV     EAX,[DWORD SS:ESP+10]
004013FD   . |83C0 1C       ADD     EAX,1C										; contador de filas
00401400   . |83F8 54       CMP     EAX,54										; 3 filas = 1C+1C+1C=54
00401403   . |894424 10     MOV     [DWORD SS:ESP+10],EAX
00401407   .^\7C BC         JL      SHORT Matrix_C.004013C5						; ¿Hemos terminado de leer la fila? ¿contador = 54?
00401409   .  68 D8304000   PUSH    Matrix_C.004030D8                           ;  ASCII "Registration successful!"
0040140E   .  EB 05         JMP     SHORT Matrix_C.00401415
00401410   >  68 C8304000   PUSH    Matrix_C.004030C8                           ;  ASCII "Not registered!"

En la rutina de comprobación se ve fácil un CMP EDI,7 por lo que podemos deducir que si el creador no se ha molestado mucho la comprobación se realiza de izquierda a derecha y de arriba hacia abajo.

Tal es así que si ponemos un breakpoint en 4013E8, podemos ir sacando el estado correcto de los checkboxes sin mucha molestia.

Enlaces

CrackMe