Présentation du HTB Sink : Contrebande de requêtes HTTP et élévation de privilèges AWS

Compte rendu de Hack The Box Sink : Contrebande de requêtes HTTP, CVE-2019-18277, HAProxy, Gunicorn, Gitea, Ligolo-ng, AWS LocalStack, KMS et Secrets Manager.
- Publié le 2026-09-08
- Temps de lecture : 15 min
Présentation détaillée du HTB Sink : contrebande de requêtes HTTP et élévation de privilèges #
Dans ce tutoriel réalisé par HTB Sink, nous voyons comment exploiter une vulnérabilité de contrebande de requêtes HTTP liée à HAProxy et Gunicorn pour obtenir la session d'administrateur, se connecter à Gitea et progresser jusqu'à l'accès root via AWS LocalStack, Secrets Manager et KMS.
Sink est une machine classée « Insane » sur HackTheBox, soit le niveau de difficulté le plus élevé de la plateforme. De ce fait, elle s'est avérée être une excellente occasion d'explorer en profondeur le mécanisme de contrebande de requêtes HTTP : non pas une vulnérabilité exploitable avec un outil automatisé, mais un mécanisme qu'il faut comprendre étape par étape, octet par octet, avant de pouvoir le rendre fiable. Ce guide suit précisément ce cheminement, y compris les erreurs et les tentatives infructueuses rencontrées, car elles ont été essentielles à la découverte de la faille.
Informations sur la machine #
| Terrain | Valeur |
|---|---|
| Plateforme | Pirater la boîte |
| Prénom | Lavabo |
| OS | Linux |
| problèmes | Fou |
| Focus | Contrebande de requêtes HTTP |
| CVE | CVE-2019-18277 |
| Principales prestations | HAProxy, Gunicorn, Flask, Gitea, LocalStack |
1. Reconnaissance initiale #
Analyse des ports avec mynmap (une surcouche logicielle de nmap, conçue pour les CTF : elle effectue automatiquement et en séquence la découverte rapide des ports TCP, la détection des services et du système d'exploitation, la vérification des vulnérabilités et l'analyse des ports UDP). Une instance Gitea est en cours d'exécution sur le port 3000 , mais sans identifiants, peu de choses sont visibles dans l'immédiat : des dépôts privés, et peu d'autres ressources accessibles. Nous passons ensuite au port 5000 , où une application web est exécutée.
Une première vérification rapide des en-têtes de réponse :
curl -sI http://sink.htb:5000/ | grep -iE "server|via|x-served|x-cache|cf-ray|x-amz"Server: gunicorn/20.0.0
Via: haproxy
X-Served-By: c8361846ea2cDeux informations utiles d'emblée : le serveur d'applications est Gunicorn (un serveur Python qui héberge l'application Flask), et le frontend utilise HAProxy comme proxy inverse. Lorsqu'on rencontre cette configuration (un frontend et un backend distincts échangeant la même requête), il est pertinent de vérifier si l'interprétation de la longueur du corps de la requête diffère entre les deux.
Une recherche rapide de vulnérabilités connues dans Gunicorn 20.0.0 ne donne aucun résultat exploitable : les CVE mentionnées sont trop récentes pour être compatibles avec l’âge de cette machine. Il est préférable de se concentrer sur HAProxy , dont le numéro de version n’est indiqué nulle part au premier abord.
Astuce pour la faire sortir de sa cachette : en envoyant une requête délibérément tronquée/malformée à Burp Repeater (par exemple, une GET /notes (sans en-têtes complets, coupés en deux), HAProxy ne parvient pas à acheminer correctement la requête vers le serveur et renvoie une page d'erreur. 400 Bad Request — et cette page d'erreur, générée directement par HAProxy, inclut toujours l'en-tête Server: haproxy X.Y.Z avec la version exacte. Une méthode propre pour prendre l'empreinte digitale de la face avant sans même toucher à la face arrière.
L'application expose également certaines fonctionnalités utiles comme point de départ pour l'attaque : un système de notes (/notes) et commentaires (/comment), tous deux liés à la session de l'utilisateur connecté.
2. Contrebande de requêtes HTTP #
Avant d'exécuter toute charge utile, il était essentiel de comprendre l' origine de la faille, et non de simplement reproduire une exploitation. Le raisonnement a été reconstitué étape par étape. Pour un guide de référence plus général sur la manipulation de requêtes HTTP (CL.TE, TE.CL, empoisonnement du cache, vol de cookies), voir également « Manipulation de requêtes HTTP : désynchronisation, empoisonnement du cache et vol de cookies » sur Hackita.
2.1 Longueur du contenu vs Encodage de transfert #
Un serveur HTTP/1.1 peut déterminer où se termine le corps d'une requête de deux manières différentes :
Content-Length— indique le nombre exact d'octets dans le corps. Exemple simple : si j'envoie le mot « hackita » (7 lettres), j'écrisContent-Length: 7et le serveur lit exactement 7 octets et s'arrête là.Transfer-Encoding: chunked— Le corps du message arrive « par morceaux » plutôt qu'en une seule fois. Chaque morceau commence par un nombre qui indique le nombre d'octets de données qu'il contient. cette pièce en particulier, puis les données arrivent. Vous pouvez envoyer1suivi d'un seul octet, puis d'un autre1suivi d'un autre octet, et ainsi de suite. La pièce spéciale0Il n'y a plus de données ensuite ; c'est le signal « J'ai terminé, je n'enverrai plus rien ». Ce comportement (y compris la signification du segment)0) est défini dans la spécification officielle HTTP/1.1, le RFC 7230.
La RFC 7230 est, en résumé, le document officiel qui définit le fonctionnement du protocole HTTP/1.1, y compris les règles Content-Length et Transfer-Encoding dont nous parlons ici.
Pourquoi chunked existe-t-il, en résumé ? Content-Length Cela ne fonctionne bien que si vous savez comment à l'avance Quelle est la taille des données à envoyer ? Ce n’est pas toujours le cas : pensez à un flux en direct, un fichier généré à la volée ou une réponse que le serveur est en train de rédiger au moment de l’envoi. Dans ces cas-là, le serveur ignore la quantité d’octets à envoyer jusqu’à la fin de l’opération. Le découpage en segments résout précisément ce problème : il envoie les données disponibles, un segment à la fois, sans avoir besoin de connaître le volume total à l’avance. Le destinataire ne sait que l’envoi est terminé qu’à la réception du segment. 0.
Si une requête contient à la fois en-têtes, RFC 7230 exige qu'il gagne déjà Transfer-Encoding, en ignorant Content-LengthCette règle est fondamentale : c’est précisément parce que TE prime toujours sur CL (lorsqu’il est reconnu) que, par la suite, Gunicorn finit par suivre TE tandis que HAProxy suit CL – la même règle appliquée par deux serveurs rencontrant deux versions différentes du même en-tête. Ce comportement est correct et attendu, mais il est aussi à l’origine du bogue : si deux serveurs différents (front-end et back-end) n’appliquent pas cette règle exactement de la même manière sur une même requête, un désaccord survient quant à la limite entre deux messages.
2.2 CVE-2019-18277 et HAProxy #
En recherchant sur Google des informations plus spécifiques sur HAProxy liées à ce type de conflit CL/TE, l'article qui décrit exactement le bug en question apparaît : nathandavison.com/blog/haproxy-http-request-smuggling (CVE-2019-18277).
HAProxy, dans ses versions vulnérables (y compris celles utilisées sur Sink), gère correctement les conflits CL/TE. lorsque l'en-tête Transfer-Encoding C'est clairement écrit.Mais si vous entrez un caractère de contrôle — plus précisément \x0b (tableau vertical) ou \x0c (saut de page) — immédiatement après les deux points dans l'en-tête, avant le mot chunked:
Transfer-Encoding:[\x0b]chunkedHAProxy il ne reconnaît plus ceci comme un Transfer-Encoding valide. Par conséquent :
- Cessez de considérer l'encodage par blocs.
- Repliez-vous sur
Content-Lengthdécider où s'arrête la requête. - Cela ne supprime pas l'en-tête
Transfer-Encodinginterrompu par la requête qu'il transmet au serveur d'arrière-plan — il la laisse écrite telle quelle et la transmet.
Cela ne suffit pas à lui seul pour créer de la contrebande : même si le serveur ignorait cet en-tête malformé (comportement correct selon la RFC 7230), les deux serveurs seraient toujours d'accord (tous deux utiliseraient Content-Length) et il n'y aurait pas de désaccord.
Comment insérer l'octet \x0b dans Burp. Saisissez directement un caractère non imprimable comme \x0b Ce n'est pas pratique dans l'éditeur Burp : de nombreux éditeurs l'ignorent ou le transforment. Voici comment le générer et l'insérer correctement :
echo "\x0b" | base64Cela produit une chaîne base64 représentant cet octet. Copiez cette chaîne et utilisez la fonction Décoder Dans Burp (onglet Décodeur, ou en sélectionnant le texte dans l'éditeur et en choisissant « Décodage Base64 » dans le menu contextuel), vous obtenez l'octet brut. \x0b collé directement au bon endroit de la requête, entre les deux points de Transfer-Encoding: et le mot chunked — évitant ainsi le problème de l'écriture manuscrite.
2.3 Le comportement de Gunicorn #
Gunicorn (dans ses versions/configurations vulnérables, comme celle utilisée par Sink) il ne refuse pas l'en-tête Transfer-Encoding malformée. Au lieu de cela, elle la « nettoie » en interne (supprime le caractère de contrôle) et l'accepte telle quelle. chunked valide.
Dans le cas de Sink, HAProxy et Gunicorn interprètent différemment la même requête HTTP. Autrement dit : HAProxy détecte un octet inhabituel. \x0bIl ne le comprend pas, mais il ne le supprime pas ; il le laisse écrit et poursuit sa demande telle quelle, en l’utilisant. Content-Length pour décider où s'arrêter. Gunicorn le relit depuis le début et constate la même chose. Transfer-Encoding (toujours présent, non supprimé par HAProxy) et, au lieu de le rejeter comme il le devrait, l'accepte — et comme entre les deux en-têtes, il l'emporte toujours Transfer-Encoding Une fois reconnue, Gunicorn l'utilise. Résultat : deux serveurs, la même requête, deux lectures différentes. C'est précisément cette différence qui permet d'insérer une seconde requête cachée dans la connexion au serveur.
2.4 Réutilisation et maintien en vie de la connexion — le « tuyau » partagé #
Pour des raisons d'efficacité, HAProxy n'ouvre pas une nouvelle connexion TCP vers le serveur pour chaque requête ; il en garde quelques-unes ouvertes et les réutilise pour traiter les requêtes de plusieurs utilisateurs différents en séquence (mise en commun des connexions).
Pour simplifier, imaginez un unique canal reliant HAProxy à Gunicorn, par lequel transitent les requêtes de nombreux utilisateurs, les unes après les autres. Il n'y a pas un canal par personne, mais un seul partagé par tous. C'est précisément ce qui rend la contrebande dangereuse : si un attaquant envoie une requête qui laisse le serveur en attente de données supplémentaires, et qu'immédiatement après, sur le même canal, une requête d'un autre utilisateur légitime transite, ces données supplémentaires (ligne de requête, en-tête et cookie inclus) sont interprétées comme une continuation de la requête de l'attaquant, et non comme une requête distincte.
Il n'existe aucun contrôle sur le tube précis qui sera utilisé ni sur la personne qui l'utilisera immédiatement après – c'est pourquoi l'attaque doit souvent être répétée plusieurs fois avant de trouver le bon moment.
3. Vérification de la vulnérabilité #
3.1 Test diagnostique #
Le premier réflexe a été de construire une requête avec un corps découpé en morceaux intentionnellement incomplet (sans le segment final) 0\r\n\r\n) et un Content-Length court:
POST /notes HTTP/1.1
Host: <target>:5000
Content-Length: 4
Transfer-Encoding: chunked
Cookie: session=...
1
ZCette opération expire effectivement, mais cela ne prouve rien , car un corps de requête incomplet bloque tout serveur qui parvient à lire ce corps, qu'il soit vulnérable ou non. Cela ne permet pas d'isoler le bogue précis.
3.2 Comparaison avec/sans \x0b #
Pour vraiment isoler le bug, vous devez utiliser exactement le même corps découpé en morceaux (un seul morceau d'un octet : 1\r\nZ, sans le morceau terminal 0\r\n\r\n final) et comparer le comportement avec et sans l'octet \x0b dans l'en-tête :
- Senza
\x0bHAProxy lit correctementTransfer-Encoding, ignorez leContent-LengthEn bref, transférer le message entier → réponse normale, sans délai d'attente. - Avec
\x0b: HAProxy utilise une solution de repliContent-Length, coupe la requête en deux (juste avant le segment de fin que le corps devrait contenir), le backend (qui lit TE) attend un segment final qui n'arrivera jamais → véritable délai d'attente (visible comme une requête « en attente » pendant longtemps ou une erreur explicite, et non pas seulement une lenteur perçue).
Seulement le différence Entre ces deux comportements, testez le bug proprement. Sur Sink, avoir un point de contact direct (/notes, qui affiche le contenu enregistré), le test de diagnostic devient secondaire : vous pouvez passer directement à l'exploit réel et observer le résultat concret.
Avertissement important : même le test « propre » présente une limite pratique, apparue lors des tests en conditions réelles. Des points d’extrémité tels que /notes o /comment Cependant, une certaine latence normale (écriture sur disque/base de données) peut apparaître, pouvant être perçue comme un délai « suspect » même en l'absence de désaccord CL/TE. Une attente d'une ou deux secondes est perceptible visuellement, sans erreur Burp explicite (ni délai d'attente réel, ni erreur 504 Gateway Timeout renvoyée par HAProxy). Ce n'est pas une confirmation fiable —Il est facile de le confondre avec un faux positif. La technique de chronométrage reste un indice probabiliste, et non une preuve définitive comme l'examen direct des données capturées en clair.
4. Exploitation : Capture de la session d'administration #
4.1 Structure de la charge utile #
L'idée est d'envoyer une seule requête HTTP que HAProxy perçoit comme un bloc unique et complet, mais que Gunicorn interprète comme deux requêtes distinctes :
- Une première demande (par exemple,
POST /oPOST /home), avecContent-LengtheTransfer-Encodingconflit (bug HAProxy). - Un morceau
0ce qui clôt — du point de vue de Gunicorn (qui lit TE) — cette première requête. - Peu après, le début d'un deuxième requête HTTP cachée (
POST /notes), avec unContent-Lengthintentionnellement plus grand du contenu effectivement envoyé — Gunicorn le considère donc incomplet et attend davantage d'octets pour le compléter.
POST / HTTP/1.1
Host: <target>:5000
Content-Length: <N>
Transfer-Encoding:[\x0b]chunked
Cookie: session=<sessione attaccante>
0
POST /notes HTTP/1.1
Host: <target>:5000
Content-Length: 290
Cookie: session=<sessione attaccante>
note=Parce que ça 0 c'est fondamental. En quelques lignes, sans détour :
- La première ligne de la requête (
POST /) utilise des morceaux.0appartient à elle: est le fragment qui indique « le corps de cette première requête se termine ici », rien de plus. - Immédiatement après que
0Gunicorn recommence à lire à partir de zéro — et ce qu'il trouve (POST /notes ...) l'interprète comme le début d'une requête complètement nouveau et séparé, et non comme une suite du premier. - Cette deuxième demande (
POST /notes) n'utilise plus le découpage par blocs — utilisez-en un normalContent-LengthCette valeur est délibérément déclarée supérieure (par exemple, 290) à la valeur réellement envoyée. Gunicorn la considère donc comme incomplète et attend l'arrivée des autres octets pour la « compléter » jusqu'à 290.
Sans cela 0Gunicorn n'aurait jamais de moment où il pourrait considérer la première requête comme close — il continuerait à tout lire comme un bloc confus, et POST /notes ne serait jamais reconnue comme une requête en soi (le résultat pratique, observé lors des tests, est une erreur d'analyse syntaxique du type Invalid Request Line). Avec le 0 Au bon endroit, cependant, tout fonctionne : la première requête est fermée, la seconde est ouverte et en attente — exactement le comportement nécessaire à l'attaque.
Le sens de Content-Length: 290 dans la requête cachée. Ici, un nombre plus élevé (290) est déclaré que celui qui est réellement envoyé (note=(quelques octets). Gunicorn lit ces quelques octets, constate qu'ils ne suffisent pas pour atteindre 290, et reste attente —pensez : « Il manque encore des éléments pour compléter cette requête. » Cet élément manquant est précisément l’espace qui, un instant plus tard, est rempli par la requête suivante arrivant sur la même connexion partagée : s’il s’agit d’une requête provenant d’un autre utilisateur réel, ses octets (en-tête, y compris les cookies) se retrouvent bloqués là, jusqu’à ce qu’ils atteignent les 290 octets déclarés.
Autre point critique, mis en évidence par une erreur concrète lors des tests : il Content-Length de la première requête doit couvrir exactement tous les octets qui suivent la ligne vide, jusqu'à la fin de note= inclus — morceau 0, ligne vide, requête complète POST /notes avec ses en-têtes, ligne vide, note=Une valeur incorrecte (trop courte) tronque en deux une ligne d'en-tête de requête cachée, ce qui perturbe Gunicorn lors des tentatives suivantes sur la même connexion (erreurs comme Invalid HTTP request line: 'Length: 290', un symptôme d'une coupure survenue juste à l'intérieur du mot Content-Length).
Laissez Burp recalculer automatiquement le Content-Length La première requête (fonction « Mettre à jour la longueur du contenu » activée) s’est avérée plus fiable que le calcul manuel — tandis que Content-Length: 290 La valeur de la requête cachée doit être définie manuellement, volontairement à une valeur supérieure à celle nécessaire.
4.2 Le point de support / notes #
Le smuggling à lui seul permet de capturer des octets bruts sur la connexion ; il vous faut encore un moyen de les visualiser . Voici quelques options courantes :
- Un point final qui enregistrer et afficher ce qui lui est envoyé (ici :
/notes) — la requête volée finit par être enregistrée sous forme de texte, qui peut être lu ultérieurement. - Un « gadget de réflexion » — une page qui reflète dans sa réponse HTTP ce qui lui est envoyé dans le corps de la requête, vous permettant ainsi de voir le résultat immédiatement.
- Empoisonnement de la file d'attente de réponse — une technique plus avancée pour recevoir directement la réponse destinée à la victime, lorsque ni l'une ni l'autre des deux précédentes n'est disponible.
Sur l'évier, /notes C'est exactement à cela que ça sert : chaque note créée est affichée intégralement dans l'interface web de l'utilisateur connecté.
4.3 Pool de connexions et requête de la victime #
- La requête malformée de l'attaquant est envoyée. HAProxy, trompé par l'octet
\x0b, la considère comme une seule requête complète et la transmet à Gunicorn via la connexion persistante (keep-alive) au serveur. - Gunicorn, lisant en mode segmenté, trouve le segment
0et considérons la première demande comme close. - Pour en savoir plus sur ce lien, consultez le début de
POST /noteshautement qualifiés dédiés à la conception, à laContent-Length: 290déclaré mais seulement quelques octets (note=) effectivement reçu — il reste donc attente il faut davantage d'octets pour considérer cette deuxième requête comme terminée. - Si, avant l'expiration du délai de connexion, un un autre utilisateur réel (Idéalement un compte privilégié — sur Sink, l'administrateur) envoie une requête qui finit par être acheminée vers le serveur via la même connexion réutilisée ; Gunicorn l'interprète comme la continuation du corps de
POST /notes— pas seulement le texte, mais la requête brute complète : la ligne de requête, l’en-tête et, surtout, le cookies de session. - Le résultat est enregistré sous forme de note dans le compte de l'attaquant, jusqu'à ce que les octets manquants déclarés par ce dernier soient complétés.
Content-Lengthinterne.
Comme vous n'avez aucun contrôle sur la connexion du pool qui devient « corrompue » ni sur la personne qui la réutilisera immédiatement après, l'attaque doit souvent être répétée plusieurs fois pour réussir — il s'agit d'un mécanisme probabiliste, et non déterministe à 100 %.
4.4 Détournement de session #
Après avoir répété plusieurs fois la requête malformée, une des notes créées est apparue, contenant le début d'une véritable requête générée par l'administrateur :
GET /notes/delete/1234 HTTP/1.1
Host: <target>:5000
User-Agent: Mozilla/5.0 ...
Cookie: session=eyJlbWFpbCI6ImFkbWluQHNpbmsuaHRiIn0.XXXXXX.XXXXXXXXXXXXXXXXXXXXXXXXXXXX
X-Forwa...Le cookie session contient, décodé, l'email admin@sink.htb — la session administrateur, volée par détournement de requête. En remplaçant votre cookie de session par celui-ci dans le navigateur (ou dans Burp), vous obtenez un accès administrateur à l'application.
5. De l'administrateur à Marcus via Gitea #
5.1 Historique Git #
Avec la session d'administration, vous pouvez vous connecter à l' instance Gitea (port 3000) en tant qu'utilisateur disposant de privilèges élevés. En explorant les dépôts disponibles, l'un d'eux, Key_Management , contient, dans son historique de commits, une clé privée SSH qui a été ajoutée puis supprimée lors d'un commit de « nettoyage » (visible en comparant les lignes supprimées en rouge avec les lignes ajoutées en vert dans le diff des commits).
5.2 Récupération de la clé SSH #
La clé appartient à l'utilisateur marcus (Il est l'auteur du commit de suppression.) Copie du contenu de l'ancienne révision (visible dans le diff du commit, la partie rouge) dans un fichier local :
vim id_rsa_marcus
# incollare il contenuto della chiave privata, salvare
chmod 600 id_rsa_marcus
ssh -i id_rsa_marcus marcus@sink.htbCoquille obtenue comme marcus — et avec lui, user.txt.
Le même dépôt contient également un fichier ec2.php qui fait référence, entre autres, à un ARN d'une clé KMS (arn:aws:kms:eu:...:key/...) — premier indice concernant l'infrastructure AWS/LocalStack utilisée en interne par la machine, qui s'avérera utile plus tard.
6. Pivoter avec Ligolo-ng #
6.1 Problème de routage #
Pour accéder aux services internes de la machine (en particulier, un point de terminaison AWS local lié uniquement à 127.0.0.1), un tunnel était nécessaire. Avec Ligolo-ng:
- Sur le proxy (Kali) : démarrage de l'écouteur et chargement de l'interface TUN.
- Sur l'agent (Sink, exécuter en tant que
marcus): connexion à l'opérateur d'écoute. - Démarrage de la session tunnel (
start).
Erreur rencontrée et cause : ajout d'une route vers l'adresse IP réelle de la machine cible (ip route add <IP-di-Sink>/32 dev ligolo), le tunnel s'est effondré à plusieurs reprises immédiatement après son démarrage (Agent dropped(Reconnexions continues). La raison : cette adresse IP est la même que celle utilisée par la connexion de contrôle entre l’agent et le proxy. Le routage de ce trafic via le tunnel lui-même crée une boucle : le trafic de la connexion de contrôle est finalement redirigé vers le tunnel, qui dépend de l’existence de cette même connexion.
Solution : Les routes ne doivent être ajoutées que pour les nouveaux réseaux , situés derrière le pivot (hôtes non directement accessibles) — jamais pour l'adresse IP de la machine hébergeant l'agent lui-même.
6.2 Accès à localhost via 240.0.0.1 #
Pour atteindre un service limité uniquement à 127.0.0.1 sur la machine cible elle-même (et non pas hébergée sur un autre serveur), Ligolo-ng propose une adresse « magique » dédiée :
sudo ip route add 240.0.0.1/32 dev ligoloInterrogatoire 240.0.0.1 Au lieu de l'adresse IP réelle, le trafic est automatiquement redirigé vers 127.0.0.1 du point de vue de l'agent — vous permettant d'atteindre les portes intérieures sans créer la boucle visible ci-dessus.
Épreuve pratique :
nc -zv 240.0.0.1 4566
# 4566 open — il servizio interno risponde attraverso il tunnel7. Énumération AWS LocalStack #
La machine disposait de l'interface de ligne de commande AWS installée et, écoutant uniquement sur localhost, d'une instance de LocalStack (une simulation AWS locale, utilisée ici pour les tests/le développement — et non le véritable AWS sur Internet).
Configuration de l'interface de ligne de commande pour pointer vers le point de terminaison local (via un tunnel) :
alias aws='aws --endpoint-url=http://240.0.0.1:4566'
aws configure # richiede comunque una region, es. us-east-1, e le chiavi trovate nei repo GiteaEssai des commandes de base (aws sts get-caller-identity, aws iam list-users, aws organizations list-accounts) toutes ont renvoyé des erreurs — non pas à cause d'un manque d'autorisations, mais parce que ces services n'étaient pas du tout actifs sur cette instance LocalStack. Seuls deux services fonctionnaient réellement : KMS e Gestionnaire de secrets.
Pour les nouveaux utilisateurs d'AWS, voici un bref rappel : compte = le conteneur complet des utilisateurs, autorisations et ressources ; région = le centre de données physique où résident les ressources ; IAM = gère les utilisateurs et les rôles (un rôle est une identité temporaire, obtenue via STS ) ; Secrets Manager = conteneur des informations d'identification provenant de services externes ; KMS = gère les clés de chiffrement (chiffrement/déchiffrement ou signature numérique).
7.1 Gestionnaire de secrets #
aws secretsmanager list-secrets --region us-east-1Trois secrets à découvrir : Sink Panel, Jenkins Login, Jira SupportLecture de la valeur de chacun :
aws secretsmanager get-secret-value --secret-id "Sink Panel" --region us-east-1
aws secretsmanager get-secret-value --secret-id "Jenkins Login" --region us-east-1
aws secretsmanager get-secret-value --secret-id "Jira Support" --region us-east-1Identifiants en clair récupérés pour trois utilisateurs différents (nom d'utilisateur + mot de passe), y compris celui de l'utilisateur lui-même david — mot de passe dérivé du secret Jira Support.
7.2 Récupération des identifiants de David #
Da marcus, modification par l'utilisateur :
su davidDans la maison de david, Dans Projects/Prod_Deployment/, un fichier servers.enc — des données binaires, et non du texte lisible, clairement chiffrées.
7.3 XNUMX KMS #
aws kms list-keys --region us-east-1Onze clés sont listées (identifiant/ARN uniquement, aucune donnée cryptographique n'est directement exposée – intentionnellement). Consultation de la politique et des détails pour chacune :
for keyid in $(cat lista_key_id); do
echo "--- $keyid ---"
aws kms describe-key --key-id "$keyid" --region us-east-1
doneLa plupart partagent la même politique par défaut permissive ("Action": "kms:*" (accordé à la racine du compte). Parmi les clés, une en particulier — 804125db-bdf1-465a-a058-07fc87c0fad0 — il s'avère activé, de type RSA_4096, conçue explicitement pour les opérations de chiffrement/déchiffrement (contrairement aux autres clés de l'ensemble, qui sont plutôt orientées vers les signatures numériques).
7.4 Déchiffrement des serveurs.enc #
aws kms decrypt \
--ciphertext-blob fileb://servers.enc \
--key-id 804125db-bdf1-465a-a058-07fc87c0fad0 \
--region us-east-1 \
--encryption-algorithm RSAES_OAEP_SHA_256Le résultat contient un champ Plaintext en base64. Décodage :
echo "<Plaintext>" | base64 -dLe résultat n'est pas un texte directement lisible — les premiers octets (H4sI en base64, correspondant à 1f 8b 08 (en hexadécimal) constituent la signature typique d'une archive gzipMais cela ne suffit pas. gunzip: ce qui se trouve à l'intérieur est en fait un goudron Compressé — lors de la décompression, l’en-tête classique d’un fichier tar (nom du fichier, permissions, horodatage) précède le contenu. La méthode la plus simple pour tout extraire en une seule étape :
echo "<Plaintext>" | base64 -d | tar -xzO7.5 Récupération des identifiants racine #
Le goudron extrait contient servers.yml, contenant les informations d'identification d'un utilisateur administrateur du service (hôte) vault.sink.htb), puis utilisé pour arriver à racine sur la voiture.
Analyse approfondie des outils de test d'intrusion AWS. Non utilisés directement sur cette machine, ils font partie du paysage offensif d'AWS : Pacu (exploitation active de l'élévation de privilèges IAM), ScoutSuite et Prowler (audit et cartographie des erreurs de configuration), PMapper (l'équivalent de « BloodHound » pour AWS, un graphe des chemins d'élévation de privilèges), cloud_enum (découverte des compartiments et ressources publics par nom d'entreprise). Guides pratiques complets : Tests d'intrusion AWS : IAM, S3, EC2, IMDS et élévation de privilèges, et Élévation de privilèges AWS sur Hackita.
8. racine #
Une fois les identifiants récupérés du fichier déchiffré, connectez-vous en tant que root (Via su root ou SSH direct), et la lecture root.txt pour fermer la machine.
9. Résumé de l'itinéraire #
Recon (HAProxy + Gunicorn dietro Flask, Gitea esposto)
↓
Studio del bug CVE-2019-18277 (CL/TE mismatch, byte \x0b)
↓
Costruzione ed esecuzione dell'exploit di smuggling
(richiesta con CL/TE in conflitto + chunk 0 + POST /notes nascosta)
↓
Cattura della sessione admin (tramite riuso della connessione keep-alive)
↓
Accesso a Gitea come admin → chiave SSH di marcus nella cronologia commit
↓
Shell come marcus (user.txt)
↓
Tunneling con Ligolo-ng (attenzione al loop di routing, uso di 240.0.0.1)
↓
Enumerazione LocalStack: solo KMS e Secrets Manager attivi
↓
Credenziali di david da Secrets Manager → su david
↓
File servers.enc cifrato → chiave KMS RSA corretta → decrypt → estrazione tar
↓
Credenziali nel file estratto (servers.yml) → root → root.txt10. Vulnérabilités et techniques utilisées #
| Technique | utilisation |
|---|---|
| Contrebande de requêtes HTTP | Désynchronisation de l'analyse entre HAProxy et Gunicorn |
| CVE-2019-18277 | Déclencheur de contrebande (octet) \x0b (en codage de transfert) |
| Séance de détournement | Vol de session d'administrateur par réutilisation de connexion |
| Historique Gitea Git | Récupération de la clé SSH de Marcus |
| Ligolo-ng | Pivotez vers le service interne LocalStack |
| AWS Secrets Manager | Récupération des identifiants de David |
| AWSKMS | Décryptage de servers.enc |
| Pile locale | Liste des services AWS locaux |
11. Que retenir de HTB Sink #
- Le conflit relatif à la contrebande de la demande survient déjà suite à un désaccord entre deux serveurs sur la même requête : l'un suit Content-Length, l'autre Transfer-Encoding (ou les deux TE, mais l'un des deux est trompé et ne le reconnaît pas).
- Un personnage de contrôle apparemment inoffensif (
\x0b,\x0cL'insertion d'un élément ) à un point précis dans un en-tête peut suffire à interrompre l'analyse d'un seul côté de la chaîne, sans que l'autre côté ne s'en aperçoive. - Le bug côté client ne suffit pas : il faut également un bug complémentaire côté serveur (qui accepte ce qu'il devrait rejeter selon la RFC 7230).
- La réutilisation de la connexion persistante entre le front-end et le back-end transforme une simple erreur d'analyse en un vecteur de vol de données appartenant à d'autres utilisateurs.
- La vérification de la vulnérabilité nécessite un test « propre » qui isole uniquement la variable du bug (avec ou sans le caractère qui la déclenche) — un délai d'attente obtenu avec une charge utile déjà malformée ne prouve rien, et même le test propre reste une indication probabiliste, et non une certitude absolue.
- Disposer d'un point de référence affichant le résultat (un champ texte enregistré et visible) facilite grandement la vérification de l'ensemble du processus par rapport à une attaque purement « à l'aveugle ».
QFP #
Qu'est-ce que HTB Sink ? Sink est une machine Linux de Hack The Box, classée comme étant extrêmement difficile, qui met en place une véritable infrastructure avec un proxy inverse (HAProxy), un serveur d'applications Python (Gunicorn), une instance Gitea et un environnement AWS simulé avec LocalStack.
Quelle vulnérabilité est exploitée dans HTB Sink ?
Le chemin principal exploite une vulnérabilité de type « HTTP Request Smuggling » liée à la CVE-2019-18277 : un octet de contrôle caché dans l’en-tête. Transfer-Encoding Cela provoque une interprétation différente de la même requête par HAProxy et Gunicorn.
Comment obtenir une session d'administrateur sur Sink ? Par le biais de la contrebande de requêtes : une requête cachée est laissée « en attente » sur la connexion partagée entre HAProxy et Gunicorn, et la requête suivante d'un autre utilisateur (idéalement l'administrateur) est capturée et enregistrée comme une note.
Comment passer du compte administrateur au compte Marcus ? En se connectant à Gitea avec une session administrateur volée et en récupérant une clé SSH privée à partir de l’historique des commits d’un dépôt.
Comment obtenir les droits root ? Via Secrets Manager (les identifiants de David) et KMS (déchiffrement d'un fichier de configuration contenant les identifiants root), sur une instance LocalStack accessible via un tunnel Ligolo-ng.








