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.

Retos stego 1-4 de Challengeland.co

20 junio, 2016 por deurus·Sin comentarios

Table of Contents

Introducción

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

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

Stego 1

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

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

Características de la imagen original:

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

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

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

Stego 2

Lo primero es realizar de nuevo la comparación.

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

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

Stego 3

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

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

Actualización 21/08/2016

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

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

Greetings and Thanks

Stego 4

Lo primero es realizar de nuevo la comparación.

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

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

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

Enlaces

Challengeland (El dominio ya no existe) [Archive]

Herramientas utilizadas

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

challengeland challengeland.co deurus esteganografía stego

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

Dark_Prince’s crackme in Java Keygen

27 agosto, 2014 por deurus·Sin comentarios

Introducción

Aquí tenemos un crackme hecho en Java, lo que como comprobareis a continuación no es muy buena idea ya que conseguir el código fuente e incluso modificarlo no es muy dificil.

Decompilado

Abrimos la víctima con nuestro decompilador favorito y nos fijamos en su contenido.

Lo interesante está en la clase Main > doneActionPerformed(ActionEvent), ya que contiene el código al ejecutar el botón que chequea el serial.

Llegados a este punto podríamos hacer cualquier cosa, parchear, que el serial válido nos lo mostrara una MessageBox etc. Pero vamos a hacer algo mejor, vamos a modificar la victima para crear nuestro keygen personalizado.

Creando un Keygen a partir de la víctima

Solamente tendremos que modificar un poco la apariencia y modificar la rutina de comprobación del serial para que lo muestre en la caja de texto del serial. Finalmente abrá que recompilar.

Aquí resalto el texto a modificar para el aspecto.

Así queda la modificación para mostrar el serial correcto en la caja de texto.

El aspecto del keygen finalmente es así.

Y como podeis apreciar funciona correctamente.

Links

Solución al Time Trial de Detten

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

VideoTutorial - KeyGen para el Crackme#2 de AfKayAs

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

Solución al PGC Official KeygenMe

Introducción Siguiendo con los crackmes que contienen RSA, esta vez tenemos un Keygenme del grupo PGC (Pirates Gone Crazy) que

Blooper Tech Movie II – Hackers

En esta ocasión vamos a hablar de una película de culto de los años 90, Hackers - Piratas Informáticos. La

1 2 3 … 30 Next »

challenge dtmf marcación por tonos reto

Stego Ph0n3

27 abril, 2023 por deurus·Sin comentarios

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

Decodificar DTMF

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

El siguiente comando nos devuelve los números marcados.

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

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

challenge dtmf marcación por tonos reto

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.

Solución a los retos criptográficos de Rogerfm.net

8 septiembre, 2018 por deurus·Sin comentarios

Introducción
Cripto 1
Cripto 2
Cripto 3
Cripto 4
Cripto 5
Cripto 6
Cripto 7
Cripto 8
Cripto 9
Cripto 10
Enlaces

Table of Contents

Introducción

Los retos de encriptación son muy variados como hemos comentado anteriormente. Aquí tenemos unos buenos ejemplos de ello.

Cripto 1

En este primer nivel nos encontramos con un método de encriptación muy antíguo. Sólo diré como pista, que es de los más antiguos que se conocen.

ozhlofxrlmvhxzorulimrz

Lo primero que suelo hacer en este tipo de retos cuando son solamente letras, es comprobar las dos opciones más típicas, que son el cifrado César y Vigenere. En este caso necesitamos ahondar un poco más, aunque enseguida llegamos a la conclusión de que el cifrado usado es el afín. Un ataque por fuerza bruta nos devuelve la solución y los coeficientes utilizados.

Solución: A=25,B=25 – LASOLUCIONESCALIFORNIA

Fuente: http://www.dcode.fr/chiffre-affine

Cripto 2

En este segundo nivel recordaremos a un general romano muy conocido. Lo complicaremos un poco, sólo lo justo para que cueste algo más de cinco minutos encontrar la clave 🙂

oehoeahhjoexhkzqhfsvzhffhwrhotqk

Lo primero que nos viene a la cabeza es el cifrado César pero no va. Probando varios cifrados por sustitución al final damos con el correcto. De nuevo un ataque por fuerza bruta nos da frutos.

Solución: (3,4,5)/1 – LACLAVEDELASEGUNDAPRUEBAESMEKONG

Fuente: https://www.dcode.fr/chiffre-decalages

Cripto 3

Este nivel también va a ser sencillo. Estos caracteres, pertenecientes a un sistema bastante conocido de encriptado, esconden una palabra que, al introducirla (en minúsculas), nos permitirá superar el nivel.

Investigando un poco llegamos a la conclusión de que se trata del cifrado Francmasón o Pig Pen.

Solución: primates

Fuente: https://www.dcode.fr/chiffre-pig-pen-francs-macons

Cripto 4

Esta prueba es tan simple que la he dividido en dos partes que, aunque de apariencia similar, se resuelven de distinta manera. La clave es la unión de las dos palabras resultantes de descifrar las dos líneas de números y que, juntas, forman una tercera palabra.

0111001101110101011100000110010101110010
0001001110011000111110100100110010010001

La primera parte se puede convertir en bloque:

0111001101110101011100000110010101110010 = super

Fuente: https://www.rapidtables.com/convert/number/binary-to-ascii.html

Para la segunda debemos separar en grupos de 5 dígitos y listo:

00010 01110 01100 01111 10100 10011 00100 10001

C O M P U T E R

Fuente: www.lindau-nobel.org

Cripto 5

Para descubrir la palabra clave sólo se necesita una mínima capacidad de observación.

31 04 40 23 20 34 33 13 23 22

Se trata del cuadrado de Polibio.

Cripto 6

Aquí hay que hacer un poco de trabajo de investigación: Hay que descubrir la clave que empleó un escritor francés (Una pista: «Lagardère») en una de sus novelas, que es la empleada aquí para formar la palabra clave (en minúsculas) que, por cierto, es alemana.

RI³I²MIL²I²A³

POR RESOLVER

Cripto 7

Seguimos con cosas fáciles. Se trata de descifrar este texto escrito en inglés.

kgw qkoev ol 617 qthpreoz iwjpz sdkg kgw pdeyeplk rwqdjzwe ipezwq spbbdq sgo sgwz goqkdbdkdwq iwjpz spq rwkwecdzwr ko cpmw gdq uweqozpb yozkedihkdoz ko kgw spe wlloek

Una vez descifrado, nos será fácil descubrir la clave:

pzpyozrp

Se trata de un cifrado de sustitución mono alfabético.

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZLMIRVHUBGTFJKOASDWQPYEXCN

THE STORY OF 617 SQUADRON BEGAN WITH THE AIRCRAFT DESIGNER BARNES WALLIS WHO WHEN HOSTILITIES BEGAN WAS DETERMINED TO MAJE HIS PERSONAL CONTRIBUTION TO THE WAR EFFORT

Una vez descifrado el alfabeto la solución queda:

pzpyozrp = anaconda

Cripto 8

A veces, las cosas no son lo que parecen. Donde aparecen unos números, en realidad hay otros números distintos.

273664524572348321143738
853442616537643005319627

POR RESOLVER

Cripto 9

Para resolver algunos problemas, hay que tener una buena base. Este es un buen ejemplo de ello:

ZW50ZXJwcmlzZQ0K

¿Os suena base 64?

Solución: enterprise

Fuente: https://www.base64decode.org/

Cripto 10

Esto es más complicado. Para descifrar este texto que contiene la clave para superar el nivel, se necesita otra clave. Para que no sea demasiado difícil, he utilizado una palabra muy sencilla de sólo cuatro letras 🙂

myiemyuvbaeewcxweghkflxw

Mediante fuerza bruta matamos dos pájaros de un tiro.

lapalabraclaveesdiogenes

Fuente: https://www.guballa.de/vigenere-solver

Enlaces

- Web del reto

afín binario cesar criptografía francmasón pigpen rogerfm vigenere

LaFarge’s Crackme 2 – Keygen por Injerto

10 septiembre, 2014 por deurus·Sin comentarios

Intro

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

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

Injerto Light

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

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

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

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

Keygen a partir de la víctima

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

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

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

Ahora escribimos el injerto.

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

Links

ThisIsLegal.com - Realistic Challenge 1

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

Blooper Tech Movie IX – The Sinner 2×06

Este BTM va otra vez sobre IPs. Si amigos del séptimo arte, viendo un capítulo de mi querida "The Sinner"

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

Intro Hoy tenemos aquí un crackme del 2009 originario de crackmes.de. El Crackme está hecho en VB6, sin empacar y

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

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

1 2 3 … 30 Next »

challenge deurus hacking reto this is legal thisislegal

ThisIsLegal.com – Realistic Challenge 1

27 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

Realistic Challenge 1: Your friend tried to purchase some software off a company. But after he paid they decided to increase it’s price by a large amount. They are now refusing to send it him. Get them back by getting their most expensive software a lot cheaper than they intended you to.

Lo que nos dice el enunciado del reto a groso modo es que debemos cambiar el precio del software antes de comprarlo.

Firebug

Para resolver este reto basta con tener instalado el complemento para Firefox «Firebug«. Abrimos la web y echamos un vistazo con Firebug

Vemos un parámetro oculto que se llama «amount» y que tiene un valor de 100$. Basta con cambiarlo a 00,01$ y ya tenemos resuelto el reto.

Links

challenge deurus hacking reto this is legal thisislegal

Blooper Tech Movie IX – The Sinner 2×06

9 septiembre, 2018 por deurus·Sin comentarios

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

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

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

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

Enlaces

buscador ip ips ips públicas the sinner

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

3 octubre, 2014 por deurus·Sin comentarios

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

Los Pistoleros Solitarios

22 octubre, 2025 por deurus·Sin comentarios

En una entrada anterior sobre cómo Expediente X abordó la tecnología de vanguardia, comenté que dedicaría un espacio a esos tres personajes tan peculiares y entrañables que, desde el segundo plano, se ganaron un hueco en el corazón de los seguidores de la serie: los Pistoleros Solitarios. Pues bien, ha llegado el momento.

Estos tres tipos —John Fitzgerald Byers, Melvin Frohike y Richard “Ringo” Langly— no necesitaban armas ni placas del FBI. Su poder estaba en los teclados, los cables enredados y los monitores de tubo que parpadeaban en un sótano lleno de conspiraciones y café frío. Eran los outsiders de Expediente X, tres hackers con alma de periodistas que luchaban por algo tan simple y tan enorme como la verdad.

Su primera aparición fue en E.B.E. (temporada 1), casi como un alivio cómico: tres frikis que ayudaban a Mulder a rastrear información sobre ovnis. Pero pronto quedó claro que había algo especial en ellos. No solo eran fuente de datos, sino conciencia crítica en un mundo plagado de mentiras digitales y gobiernos con demasiados secretos. Con el tiempo se convirtieron en aliados imprescindibles de Mulder y Scully, y también en el reflejo más humano de lo que significa ser hacker: curiosos, testarudos, torpes a veces, pero con un sentido moral inquebrantable.

Byers era el idealista, el que aún creía en la decencia y en las instituciones (al menos en teoría). Frohike, el cínico veterano con corazón de oro, siempre dispuesto a arriesgarse por una buena causa… o por impresionar a Scully. Y Langly, el genio rebelde que parecía vivir en permanente conversación con su módem de 56 k. Juntos formaban un trío excéntrico, pero perfectamente equilibrado.

Mientras Mulder y Scully perseguían abducciones y virus extraterrestres, los pistoleros combatían en otra trinchera: la digital. Hackeaban redes gubernamentales, interceptaban comunicaciones cifradas y desmantelaban cortafuegos que, en los noventa, parecían pura ciencia ficción. Lo suyo no era la acción física, sino la resistencia informativa. Y aunque muchas veces eran el chiste del capítulo, también representaban algo muy real: la gente corriente que lucha contra el poder desde el conocimiento.

Su lema no declarado podría haber sido el clásico “la información quiere ser libre”, y en eso se mantuvieron firmes hasta el final. Si había que elegir entre la seguridad o la verdad, ellos siempre elegían la verdad, aunque les costara caro.

Temporada	Episodio	Título	Comentario
1	17	E.B.E.	Primera aparición de los pistoleros.
2	3	Blood	Manipulación de dispositivos y mensajes ocultos. También control mental a través de la tecnología.
2	25	Anasazi	Un hacker roba archivos clasificados. Se tratan temas como el cifrado y filtración de datos del gobierno.
3	15	Apocrypha	Acceso a bases de datos secretas y descifrado de archivos comprometidos.
3	23	Wetwired	Manipulación de señales televisivas.
4	14	Memento Mori	Infiltración digital en sistemas médicos y vigilancia biotecnológica.
5	1	Redux	Robo y manipulación de pruebas digitales.
5	3	Unusual Suspects	Orígenes de los pistoleros: intrusión, cifrado y espíritu hacker de los noventa.
5	11	Kill Switch	IA autónoma y malware inteligente.
6	20	Three of a Kind	Hacking social, suplantación y síntesis de voz para infiltración corporativa.
7	13	First Person Shooter	Hackeo de entornos virtuales y brechas de seguridad en sistemas de realidad aumentada.
9	15	Jump the Shark	Su sacrificio final: bloqueo de una amenaza biológica, ética hacker y altruismo extremo.
11	2	This	Langly como conciencia digital en un servidor. Debate sobre IA y trascendencia del código.

Morir por la verdad

El final de los pistoleros fue tan inesperado como heroico. En el episodio “Jump the Shark” de la novena temporada, descubren un complot bioterrorista que amenaza con liberar un virus mortal. No hay tiempo para avisar a nadie, ni margen para escapar. Así que, fieles a su estilo, deciden sacrificarse para salvar a otros. Sellan el laboratorio desde dentro, sabiendo que no volverán a salir.

Lo reconozco, este desenlace mi cogió completamente por sorpresa. No hay épica de Hollywood, ni música grandilocuente. Solo tres hombres anónimos haciendo lo correcto. Mueren juntos, sin reconocimiento, sin medallas, pero con la serenidad de quienes saben que su causa era justa. Y en ese silencio final, Expediente X nos recordó algo que las grandes historias suelen olvidar: que los verdaderos héroes a veces no llevan traje ni pistola, solo convicción.

Años después, Mulder vuelve a verlos —o cree verlos— en The Truth. Ya no están en este mundo, pero siguen a su lado, como fantasmas digitales de la conciencia hacker. Es un homenaje discreto a quienes siempre pelearon desde las sombras por liberar la verdad.

Para cerrar el círculo, Langly reaparece de forma inesperada en la temporada 11, dentro del episodio This. Su mente, o más bien su copia digital, sobrevive atrapada en un servidor, reclamando ser liberada. Es el epílogo perfecto: el hacker que muere físicamente, pero cuya conciencia sigue inmortal. Una vez más me volvió a sorprender Chris Carter con este homenaje.

Me gusta pensar que los pistoleros solitarios representaban algo más que tres hackers secundarios en una serie de los noventa. Fueron el reflejo de una época en la que creíamos que la tecnología podía liberar al ser humano, antes de que las redes sociales y la hiperconectividad lo diluyeran todo. Byers, Frohike y Langly no luchaban por fama ni por dinero: luchaban por entender el sistema para exponerlo, por esa curiosidad genuina que hoy apenas sobrevive entre líneas de código y algoritmos opacos. Quizá por eso seguimos recordándolos y mola tanto volver a ver los capítulos. Porque, de algún modo, todos los que amamos el conocimiento libre llevamos dentro un pequeño pistolero solitario, buscando la verdad entre los bits.

Expediente X Melvin Frohike mulder Pistoleros Solitarios scully x files

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

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

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

Reversing - Nosotros y ChatGPT contra un ELF desde Windows

Intro Antes que nada, es importante saber que un archivo ELF en Linux es equivalente a un archivo EXE en

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 »

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

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

26 agosto, 2014 por deurus·2 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

Intro

This crackme is for the challenge Mobile 2 of canyouhack.it.

This time you need to understand how the crackme works over the web.

Decompiling

The crackme is given again at Google Play, so the first step is to install and recover the APK for decompiling. The latter, I leave to you.

Open the victim with APK Studio and view the content of Mobile2.java

First we view one link:

http://canyouhack.it/Content/Challenges/Mobile/2/index.php

If we go to the link, we view one string like a hash: 68a571bcf7bc9f76d43bf931f413ab2c. Umm, it’s like MD5. Go to decrypt online and we get the pass: «canyouhack.it». But if we test this password in the crackme, surprise!, nothing happens. We need to continue analyzing the code. Later we view the next interesting link:

«http://canyouhack.it/Content/Challenges/Mobile/2/submit.php?Token=» + Mobile2.token + «&Attempts=»

The program submit one token and concatenate with the number of attempts. Ok but what is the token and what is the number of attempts?

In this point we have to try with the information we already have.

Testing with the link of bottom we get “Nice try!” message.

http://canyouhack.it/Content/Challenges/Mobile/2/submit.php?Token=68a571bcf7bc9f76d43bf931f413ab2c&&Attempts=0

Testing with the link of bottom we get “Very Good, the password is Top*****!” message.

http://canyouhack.it/Content/Challenges/Mobile/2/submit.php?Token=68a571bcf7bc9f76d43bf931f413ab2c&&Attempts=1

Reversing – Nosotros y ChatGPT contra un ELF desde Windows

23 noviembre, 2023 por deurus·Sin comentarios

Table of Contents

Intro

Antes que nada, es importante saber que un archivo ELF en Linux es equivalente a un archivo EXE en Windows. Dicho esto, es bastante común encontrarnos con ejecutables ELF en diversos CTFs (Capture The Flag), y a menudo representan un desafío para aquellos no familiarizados con el uso cotidiano de Linux. Sin embargo, tengo una buena noticia si no eres aficionado de Linux: existen herramientas que permiten realizar un análisis preliminar para determinar si es necesario abordar el problema desde Linux o si podemos resolverlo directamente desde Windows. Estas herramientas facilitan una transición más cómoda para los usuarios de Windows, permitiéndoles interactuar eficazmente con archivos ELF.

ELF

Un archivo ELF (Executable and Linkable Format) es un formato común de archivo para archivos ejecutables, código objeto, bibliotecas compartidas y volcados de memoria en sistemas basados en Unix, como Linux. Es el estándar de formato de archivo para programas compilados y enlazados en este tipo de sistemas operativos.

La cabecera de un archivo ELF es una estructura de datos al comienzo del archivo que proporciona información esencial sobre el contenido y la forma de procesar el archivo. Esta cabecera es fundamental para que el sistema operativo y otros programas puedan interpretar correctamente el archivo ELF. Aquí están los componentes clave de la cabecera de un archivo ELF:

Identificación (e_ident): Esta sección incluye la magia del archivo ELF, representada por los primeros cuatro bytes 0x7F 'E' 'L' 'F'. También incluye información como la clase del archivo (32 o 64 bits), la codificación de datos (endianness), y la versión del formato ELF.
Tipo (e_type): Indica el tipo de archivo ELF, como EXEC (ejecutable), DYN (biblioteca compartida), REL (relocalizable), entre otros.
Máquina (e_machine): Especifica la arquitectura de hardware para la cual se diseñó el archivo, por ejemplo, x86, ARM.
Versión (e_version): La versión del formato ELF, generalmente establecida en 1.
Punto de Entrada (e_entry): La dirección de memoria virtual donde comienza la ejecución del proceso.
Desplazamiento del Program Header (e_phoff): Indica dónde comienza el encabezado del programa en el archivo.
Desplazamiento del Section Header (e_shoff): Indica dónde comienza el encabezado de la sección en el archivo.
Flags (e_flags): Banderas específicas del procesador.
Tamaño de esta cabecera (e_ehsize): El tamaño de la cabecera ELF.
Tamaño del Program Header (e_phentsize): El tamaño de una entrada del encabezado del programa.
Número de entradas del Program Header (e_phnum): El número total de entradas en el encabezado del programa.
Tamaño del Section Header (e_shentsize): El tamaño de una entrada del encabezado de la sección.
Número de entradas del Section Header (e_shnum): El número total de entradas en el encabezado de la sección.
Índice del Section Header Table (e_shstrndx): El índice del encabezado de la sección que contiene los nombres de las secciones.

El reto

Se nos proporciona un fichero de 20KB que rápidamente catalogamos como ELF.

Para realizar un análisis preliminar siempre uso DogBolt, que no es más que un decompilador online con la ventaja de que usa varios motores y de esta forma casi siempre te da una decompilación aceptable. La versión actual tiene disponibles 11 motores y además es open source, ¿Qué más se puede pedir?

Echamos un vistazo y enseguida encontramos algo interesante.

La flag parece codificada de modo que vamos a indagar acerca de la función FUN_0010285d

Dentro de la función FUN_0010285d vemos que nuestra flag codificada la procesa la función FUN_00102752

Aquí os diría que depende de vuestra experiencia en programación veríais que se está procesando byte a byte la cadena de entrada (param_1) y haciendo a cada byte un XOR (^) con el param_3 (que es 1 según vemos en la llamada de la función FUN_00102752), pero en estos tiempos que corren vamos a preguntar a ChatGPT que opina.

ChatGPT

Le pido a ChapGPT que me analice el código y me responde:

Este código en C define una función llamada FUN_00102752 que realiza una operación de XOR (exclusivo OR) byte a byte sobre un bloque de memoria. La función toma tres parámetros:

long param_1: Este parámetro es tratado como una dirección de memoria. Se utiliza como la base de un bloque de memoria sobre el que se realizará la operación.

ulong param_2: Este parámetro especifica el tamaño del bloque de memoria que será afectado por la operación.

byte param_3: Este es el valor de un solo byte que se utilizará en la operación XOR.

El cuerpo de la función consiste en un bucle for que itera sobre el bloque de memoria:

int local_c se declara como una variable local y se inicializa en 0. Esta variable actúa como un contador para el bucle.

La condición del bucle (ulong)(long)local_c < param_2 asegura que el bucle se ejecute sobre el rango completo del bloque de memoria especificado por param_2.

Dentro del bucle, *(byte *)(param_1 + local_c) = *(byte *)(param_1 + local_c) ^ param_3; realiza la operación XOR. Aquí, *(byte *)(param_1 + local_c) accede al byte actual en el bloque de memoria. Este byte se modifica aplicándole un XOR con param_3. La operación XOR se realiza entre el byte actual en la memoria y el valor de param_3, y el resultado se escribe de nuevo en la misma ubicación de memoria.

En resumen, la función FUN_00102752 modifica un bloque de memoria aplicando una operación XOR con un valor dado (param_3) a cada byte dentro del rango de memoria especificado desde param_1 hasta param_1 + param_2. Este tipo de operación es común en tareas como la manipulación de datos para cifrado/descifrado o para la generación de patrones específicos en un bloque de datos.
by ChatGPT

Ahora imaginad que no sois muy dados a programar o simplemente estáis vagos de modo que volvemos a recurrir a ChatGPT con el promt «Haz un XOR 1 con javascript a la cadena: gmfzuihr^vr^o^drx^nod^shfiu|» a lo que responde:

function xorString(str) {
return Array.from(str).map(char => String.fromCharCode(char.charCodeAt(0) ^ 1)).join(»);
}

console.log(xorString(‘gmfzuihr^vr^o^drx^nod^shfiu|’));
by ChatGPT

Copiamos el código y lo pegamos en un entorno online como por ejemplo playcode.io.

Este es un ejemplo simple, pero ¿percibís su potencial?

La imagen de portada de esta entrada ha sido generada con ChatGPT.

challenge chatGPT dogbolt ELF Ghidra javascript lenguaje C reto xor

Retos de Criptografía

14 abril, 2017 por deurus·Sin comentarios

Los retos de criptografía pueden ser muy variados como he dicho anteriormente. El secreto suele estar en saber a que te enfrentas y posteriormente construir una herramienta para descifrarlo o usar una ya existente (la mayoría de los casos).

Una web con la que suelo resolver la mayoría de retos es dcode.fr. Si os fijáis en el enlace, la lista de categorías asciende a 48 y disponéis de unos 800 algoritmos para rebanaros los sesos.

A continuación veamos unos cuantos retos que podéis encontrar por la red. Cabe destacar que normalmente el título del reto dice mucho del algoritmo.

Enunciado: Not K9 But ?
Texto encriptado: 8430727796730470662453
Solución: ¿Te has fijado en el teclado de tu móvil alguna vez?

Enunciado: The grass is always greener on the other side
Texto encriptado: TSDLN ILHSY OGSRE WOOFR OPOUK OAAAR RIRID
Solución: César

Enunciado: Prove you’re not drunk?
Texto encriptado: gsv kzhh blfi ollprmt uli rh zoxlslo
Solución: Atbash

Enunciado: ¿?
Texto encriptado: 4C240DDAB17D1796AAD3B435B51404EE
Solución: Aquí nuestro primer impulso es utilizar fuerza bruta a MD5, pero cuando nos damos contra la pared el siguiente candidato es LAN Manager. Aquí la opción que más os guste, Cain, John The Ripper, etc.

Con John The Ripper tenemos que preparar un archivo de texto del estilo: deurus.info:1011:4C240DDAB17D1796AAD3B435B51404EE:4C240DDAB17D1796AAD3B435B51404EE:::

y ejecutar el comando: john –format=lm LM.txt

Enunciado: a lot harder than SMS
Texto encriptado: .- -. . .- … -.– — -. . – …. . .–. .- … … .– — .-. -.. .. … -.. — – -.. .- … …. -.. .- … …. -.. — –
Solución: Morse

Enunciado: Now I see!

Solución: Braille

Enunciado: Polly the parrot loves to square dance?
Texto encriptado: 442315 3511434352344214 2443 442432154411123115
Solución: Polybios

Enunciado: Aquí hay problemas de base.
Texto encriptado: VGhlIHBhc3N3b3JkIGlzIG9qZXRlIG1vcmVubw==
Solución: Base64

Enunciado: Conversión
Texto encriptado: 6c6120736f6c756369c3b36e2065733a20366533303664333137333734333337323739
Solución: Hexadecimal

Enunciado: Método de encriptación de los más antiguos que se conocen.
Texto encriptado: ozhlofxrlmvhxzorulimrz
Solución: Cifrado Afín

Enunciado: /_vti_pvt/administrators.pwd
Texto encriptado: admin:dut4HlQyu4dSA
Solución: Creamos un archivo de texto con el texto encriptado y ponemos a John The Ripper a trabajar con el comando john –show administrators.pwd

Enunciado: En ocasiones veo en binario
Texto encriptado:0111001101110101011100000110010101110010
0001001110011000111110100100110010010001
Solución: Para la primera parte la conversión es directa. Para la segunda, la dificultad reside en darse cuenta que hay que separar en grupos de cinco y decodificar por separado.

Enunciado: Un clásico
Texto encriptado: WLYGUKVAIIXAVGLRWCHVDRWC
Solución: Vigenere

Enunciado: Una antigua estirpe

Solución: Código Templario

Enunciado: eXORcism
Texto encriptado: 7d5313525e52475713544113414046025052
Solución: XOR. La clave la podéis obtener por fuerza bruta. Mira este artículo par saber como.

Enunciado: Edgar Allan Poe
Texto encriptado: 05-05¶88)8)-5(525,‡
Solución: Escarabajo de oro

Enunciado: MD encryption
Texto encriptado: 6FBCF7B5CE6637C28EEDC43988A9509B
Solución: MD5

Enunciado: American coding system used in the context of World War II
Texto encriptado: A-WOH LIN AH-JAH CLA-GI-AIH BE-LA-SANA KLESH DIBEH GLOE-IH NE-AHS-JAH GAH BE YEH-HES DIBEH A-CHIN WOL-LA-CHEE A-KEH-DI-GLINI TSE-NILL YIL-DOI A-KHA
Solución: Código Navajo

Enunciado: Run, run, run
Texto encriptado: T1H1E1P1A1S2W1O1R1D1I1S1R1U1N2I1N1G1
Solución: Run-length encoding

Conversiones, cifra clásica, hash, simétricos, asimétricos, combinaciones de varios algoritmos y un largo etcetera. Como veis los hay para todos los gustos, ten en cuenta que aquí os muestro una pequeñísima parte de lo que os encontrareis en las webs de retos, pero para despertar la curiosidad es suficiente.

¡Hala, a decodificar!