Crypto Failures — THM Writeup

Executive summary — Crypto Failures is a Medium cryptography and web-exploitation room on TryHackMe. The server builds a secure_cookie by applying PHP's crypt() (DES variant) to 8-byte chunks of the string user:USER_AGENT:ENC_SECRET_KEY and concatenating the outputs. Because DES crypt() encrypts each 8-byte block independently with a mere 2-character salt, controlling the User-Agent length lets us isolate a single unknown byte of ENC_SECRET_KEY in its own block and brute-force it by comparing crypt() outputs. Once the key is recovered, we forge a secure_cookie for user=admin and read the web flag. A block oracle → recover key → forge cookie → flag journey.

Platform	TryHackMe
Operating system	Linux (PHP web application)
Difficulty	Medium
Room	Crypto Failures
Target IP	`10.10.122.185`

Attack map

[80/HTTP]  secure_cookie = concat( crypt(8B_block, salt) )  over
           user:USER_AGENT:ENC_SECRET_KEY
   |  DES crypt() -> independent 8-byte blocks + 2-char salt
   v
[ORACLE]  tune the User-Agent length to isolate
          1 unknown key byte in its own block
   |  brute-force printable ASCII, compare the crypt() block
   v
[KEY]  recover ENC_SECRET_KEY byte by byte  (THM{...} encryption key)
   |  forge secure_cookie for user=admin (same salt + same UA)
   v
[FLAG]  request as admin -> web flag  THM{...}

1. Reconnaissance — inspect the cookies

First, request the web root and inspect the Set-Cookie headers. We pin a known User-Agent because, as we will see, it is part of the encrypted plaintext:

curl -s -D - -A 'testUA' http://10.10.122.185/ -o /dev/null | grep -i '^Set-Cookie'

At least two cookies show up:

user — defaults to guest on the target.
secure_cookie — a concatenation of crypt() outputs; its first two characters are the 2-char salt.

We extract the secure_cookie string and the salt (first two characters):

SEC=$(curl -s -D - -A 'testUA' http://10.10.122.185/ -o /dev/null \
      | awk -F'Set-Cookie: ' '/secure_cookie/ {print $2}' \
      | sed 's/;.*//' | tr -d '\r\n')

echo "secure_cookie from server: $SEC"

# first two chars are the salt
SALT=${SEC:0:2}
echo "detected salt: $SALT"

Note: some servers URL-encode the cookie value in the header (you may see %2F, etc.). Work with the raw string returned above to extract the salt, and urldecode before comparing blocks.

Resumen ejecutivo — Crypto Failures es un room Medium de TryHackMe de criptografía y explotación web. El servidor construye una cookie secure_cookie aplicando crypt() de PHP (variante DES) a bloques de 8 bytes de la cadena user:USER_AGENT:ENC_SECRET_KEY y concatenando las salidas. Como DES crypt() cifra cada bloque de 8 bytes de forma independiente con un salt de solo 2 caracteres, controlando la longitud del User-Agent podemos aislar un único byte desconocido de ENC_SECRET_KEY en su propio bloque y romperlo por fuerza bruta comparando salidas de crypt(). Recuperada la clave, forjamos una secure_cookie para user=admin y leemos la flag web. Un recorrido oracle de bloques → recuperar clave → forjar cookie → flag.

Plataforma	TryHackMe
Sistema operativo	Linux (aplicación web PHP)
Dificultad	Medium
Room	Crypto Failures
IP objetivo	`10.10.122.185`

Mapa del ataque

[80/HTTP]  secure_cookie = concat( crypt(bloque_8B, salt) )  sobre
           user:USER_AGENT:ENC_SECRET_KEY
   |  DES crypt() -> bloques de 8 bytes independientes + salt de 2 chars
   v
[ORACLE]  ajustar la longitud del User-Agent para aislar
          1 byte desconocido de la clave en su propio bloque
   |  fuerza bruta sobre ASCII imprimible, comparar el bloque crypt()
   v
[KEY]  recuperar ENC_SECRET_KEY byte a byte  (flag de clave THM{...})
   |  forjar secure_cookie para user=admin (mismo salt + mismo UA)
   v
[FLAG]  petición como admin -> flag web  THM{...}

1. Reconocimiento — inspeccionar cookies

Lo primero es pedir la raíz del sitio e inspeccionar las cabeceras Set-Cookie. Fijamos un User-Agent conocido porque, como veremos, forma parte del texto que se cifra:

curl -s -D - -A 'testUA' http://10.10.122.185/ -o /dev/null | grep -i '^Set-Cookie'

Aparecen al menos dos cookies:

user — por defecto guest en el objetivo.
secure_cookie — una concatenación de salidas de crypt(); sus dos primeros caracteres son el salt de 2 caracteres.

Extraemos la cadena secure_cookie y el salt (los dos primeros caracteres):

SEC=$(curl -s -D - -A 'testUA' http://10.10.122.185/ -o /dev/null \
      | awk -F'Set-Cookie: ' '/secure_cookie/ {print $2}' \
      | sed 's/;.*//' | tr -d '\r\n')

echo "secure_cookie del servidor: $SEC"

# los dos primeros caracteres son el salt
SALT=${SEC:0:2}
echo "salt detectado: $SALT"

Nota: algunos servidores codifican en URL el valor de la cookie en la cabecera (verás %2F, etc.). Trabaja con la cadena cruda devuelta arriba para extraer el salt, y aplica urldecode antes de comparar bloques.

🔒 Clearance required

This content is Root Access only. Everything else on the site — the free tier, the whole public library — stays open.

See Root Access plans

No account? Create one free then upgrade from your console.