Cache Poisoning and Cache Deception
Utilisez Trickest pour construire et automatiser facilement des workflows alimentés par les outils communautaires les plus avancés au monde. Accédez dès aujourd'hui :
La différence
Quelle est la différence entre l'empoisonnement de cache web et la tromperie de cache web ?
Dans l'empoisonnement de cache web, l'attaquant fait en sorte que l'application stocke un contenu malveillant dans le cache, et ce contenu est servi à partir du cache à d'autres utilisateurs de l'application.
Dans la tromperie de cache web, l'attaquant fait en sorte que l'application stocke un contenu sensible appartenant à un autre utilisateur dans le cache, puis l'attaquant récupère ce contenu à partir du cache.
Empoisonnement de cache
L'empoisonnement de cache vise à manipuler le cache côté client pour forcer les clients à charger des ressources inattendues, partielles ou sous le contrôle d'un attaquant. L'ampleur de l'impact dépend de la popularité de la page affectée, car la réponse contaminée est servie exclusivement aux utilisateurs visitant la page pendant la période de contamination du cache.
L'exécution d'une attaque d'empoisonnement de cache implique plusieurs étapes :
Identification des entrées non clés : Il s'agit de paramètres qui, bien qu'ils ne soient pas nécessaires pour qu'une requête soit mise en cache, peuvent modifier la réponse renvoyée par le serveur. L'identification de ces entrées est cruciale car elles peuvent être exploitées pour manipuler le cache.
Exploitation des entrées non clés : Après avoir identifié les entrées non clés, l'étape suivante consiste à comprendre comment exploiter ces paramètres pour modifier la réponse du serveur de manière à bénéficier à l'attaquant.
S'assurer que la réponse empoisonnée est mise en cache : La dernière étape consiste à s'assurer que la réponse manipulée est stockée dans le cache. De cette manière, tout utilisateur accédant à la page affectée pendant que le cache est empoisonné recevra la réponse contaminée.
Découverte : Vérifier les en-têtes HTTP
Généralement, lorsqu'une réponse a été stockée dans le cache, il y aura un en-tête l'indiquant, vous pouvez vérifier quels en-têtes vous devriez surveiller dans ce post : En-têtes de cache HTTP.
Découverte : Mise en cache du code 400
Si vous pensez que la réponse est mise en cache, vous pourriez essayer d'envoyer des requêtes avec un mauvais en-tête, qui devrait être répondu par un code d'état 400. Ensuite, essayez d'accéder à la requête normalement et si la réponse est un code d'état 400, vous saurez qu'elle est vulnérable (et vous pourriez même effectuer un DoS).
Un en-tête mal configuré pourrait être simplement \: en tant qu'en-tête.
Notez que parfois ce type de codes d'état n'est pas mis en cache, donc ce test sera inutile.
Découverte : Identifier et évaluer les entrées non clés
Vous pourriez utiliser Param Miner pour brute-force les paramètres et les en-têtes qui pourraient modifier la réponse de la page. Par exemple, une page peut utiliser l'en-tête X-Forwarded-For pour indiquer au client de charger le script à partir de là :
Obtenir une réponse nuisible du serveur back-end
Avec le paramètre/l'en-tête identifié, vérifiez comment il est sanitisé et où il est reflété ou affecte la réponse de l'en-tête. Pouvez-vous l'exploiter de toute façon (effectuer un XSS ou charger un code JS contrôlé par vous ? effectuer un DoS ?...)
Obtenir la réponse mise en cache
Une fois que vous avez identifié la page qui peut être exploitée, quel paramètre/en-tête utiliser et comment l'exploiter, vous devez mettre en cache la page. Selon la ressource que vous essayez de mettre en cache, cela pourrait prendre du temps, vous pourriez devoir essayer pendant plusieurs secondes.
L'en-tête X-Cache dans la réponse pourrait être très utile car il peut avoir la valeur miss lorsque la requête n'était pas mise en cache et la valeur hit lorsqu'elle est mise en cache.
L'en-tête Cache-Control est également intéressant pour savoir si une ressource est mise en cache et quand la prochaine fois la ressource sera mise en cache à nouveau : Cache-Control: public, max-age=1800
Un autre en-tête intéressant est Vary. Cet en-tête est souvent utilisé pour indiquer des en-têtes supplémentaires qui sont traités comme partie de la clé de cache même s'ils ne sont normalement pas clés. Par conséquent, si l'utilisateur connaît le User-Agent de la victime qu'il cible, il peut empoisonner le cache pour les utilisateurs utilisant ce User-Agent spécifique.
Un autre en-tête lié au cache est Age. Il définit le temps en secondes pendant lequel l'objet a été dans le cache proxy.
Lors de la mise en cache d'une requête, soyez prudent avec les en-têtes que vous utilisez car certains d'entre eux pourraient être utilisés de manière inattendue comme clés et la victime devra utiliser le même en-tête. Testez toujours un empoisonnement de cache avec différents navigateurs pour vérifier s'il fonctionne.
Exemples d'exploitation
Exemple le plus simple
Un en-tête comme X-Forwarded-For est reflété dans la réponse non sanitisé.
Vous pouvez envoyer une charge utile XSS de base et empoisonner le cache afin que tout le monde qui accède à la page soit victime d'un XSS :
Utilisation du détournement de cache web pour exploiter les vulnérabilités de gestion des cookies
Les cookies pourraient également être reflétés dans la réponse d'une page. Si vous pouvez en abuser pour provoquer une XSS par exemple, vous pourriez être en mesure d'exploiter la XSS dans plusieurs clients qui chargent la réponse de cache malveillante.
Empoisonnement du cache avec traversée de chemin pour voler la clé API
Ce compte rendu explique comment il était possible de voler une clé API OpenAI avec une URL comme https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123 car tout ce qui correspond à /share/* sera mis en cache sans que Cloudflare ne normalise l'URL, ce qui a été fait lorsque la requête est arrivée au serveur web.
Utilisation de plusieurs en-têtes pour exploiter les vulnérabilités d'empoisonnement du cache web
Parfois, vous devrez exploiter plusieurs entrées non clés pour pouvoir abuser d'un cache. Par exemple, vous pouvez trouver une redirection ouverte si vous définissez X-Forwarded-Host sur un domaine que vous contrôlez et X-Forwarded-Scheme sur http. Si le serveur redirige toutes les requêtes HTTP vers HTTPS et utilise l'en-tête X-Forwarded-Scheme comme nom de domaine pour la redirection. Vous pouvez contrôler vers où la page est redirigée.
Exploiter avec l'en-tête Vary limité
Vary limitéSi vous découvrez que l'en-tête X-Host est utilisé comme nom de domaine pour charger une ressource JS mais que l'en-tête Vary dans la réponse indique User-Agent. Ensuite, vous devez trouver un moyen d'exfiltrer l'User-Agent de la victime et empoisonner le cache en utilisant cet user agent:
Exploiter la falsification du cache HTTP en abusant du détournement de requête HTTP
Apprenez ici comment effectuer des attaques de falsification du cache en abusant du détournement de requête HTTP.
Test automatisé pour la falsification du cache Web
Le Scanner de Vulnérabilité du Cache Web peut être utilisé pour tester automatiquement la falsification du cache web. Il prend en charge de nombreuses techniques différentes et est hautement personnalisable.
Exemple d'utilisation : wcvs -u example.com
Utilisez Trickest pour construire et automatiser des workflows alimentés par les outils communautaires les plus avancés au monde. Accédez dès aujourd'hui :
Exemples Vulnérables
Serveur de Trafic Apache (CVE-2021-27577)
ATS a transmis le fragment à l'intérieur de l'URL sans le supprimer et a généré la clé de cache en utilisant uniquement l'hôte, le chemin et la requête (en ignorant le fragment). Ainsi, la requête /#/../?r=javascript:alert(1) a été envoyée au backend en tant que /#/../?r=javascript:alert(1) et la clé de cache n'avait pas le payload à l'intérieur, seulement l'hôte, le chemin et la requête.
GitHub CP-DoS
L'envoi d'une mauvaise valeur dans l'en-tête de type de contenu a déclenché une réponse mise en cache 405. La clé de cache contenait le cookie, il était donc possible d'attaquer uniquement les utilisateurs non authentifiés.
GitLab + GCP CP-DoS
GitLab utilise des compartiments GCP pour stocker du contenu statique. Les compartiments GCP prennent en charge l'en-tête x-http-method-override. Il était donc possible d'envoyer l'en-tête x-http-method-override: HEAD et de falsifier le cache pour renvoyer un corps de réponse vide. Il pouvait également prendre en charge la méthode PURGE.
Middleware Rack (Ruby on Rails)
Dans les applications Ruby on Rails, le middleware Rack est souvent utilisé. Le but du code Rack est de prendre la valeur de l'en-tête x-forwarded-scheme et de la définir comme schéma de la requête. Lorsque l'en-tête x-forwarded-scheme: http est envoyé, une redirection 301 vers le même emplacement se produit, entraînant potentiellement un déni de service (DoS) pour cette ressource. De plus, l'application pourrait reconnaître l'en-tête X-forwarded-host et rediriger les utilisateurs vers l'hôte spécifié. Ce comportement peut entraîner le chargement de fichiers JavaScript à partir du serveur d'un attaquant, posant un risque de sécurité.
403 et Compartiments de Stockage
Cloudflare mettait précédemment en cache les réponses 403. Tenter d'accéder à des objets S3 ou des blobs de stockage Azure avec des en-têtes d'autorisation incorrects entraînerait une réponse 403 mise en cache. Bien que Cloudflare ait cessé de mettre en cache les réponses 403, ce comportement pourrait encore être présent dans d'autres services proxy.
Injection de Paramètres Clés
Les caches incluent souvent des paramètres GET spécifiques dans la clé de cache. Par exemple, Varnish de Fastly mettait en cache le paramètre size dans les requêtes. Cependant, si une version encodée en URL du paramètre (par exemple, siz%65) était également envoyée avec une valeur erronée, la clé de cache serait construite en utilisant le paramètre size correct. Cependant, le backend traiterait la valeur du paramètre encodé en URL. L'encodage en URL du deuxième paramètre size entraînait son omission par le cache mais son utilisation par le backend. Assigner une valeur de 0 à ce paramètre entraînait une erreur 400 Bad Request mise en cache.
Règles de l'Agent Utilisateur
Certains développeurs bloquent les requêtes avec des agents utilisateurs correspondant à ceux des outils à fort trafic comme FFUF ou Nuclei pour gérer la charge du serveur. Ironiquement, cette approche peut introduire des vulnérabilités telles que la falsification du cache et le DoS.
Champs d'En-tête Illégaux
Le RFC7230 spécifie les caractères acceptables dans les noms d'en-tête. Les en-têtes contenant des caractères en dehors de la plage spécifiée tchar devraient idéalement déclencher une réponse 400 Bad Request. En pratique, les serveurs ne respectent pas toujours cette norme. Un exemple notable est Akamai, qui transmet les en-têtes avec des caractères invalides et met en cache toute erreur 400, tant que l'en-tête cache-control n'est pas présent. Un schéma exploitable a été identifié où l'envoi d'un en-tête avec un caractère illégal, tel que \, entraînerait une erreur 400 Bad Request mise en cache.
Trouver de nouveaux en-têtes
https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6
Falsification du Cache
L'objectif de la falsification du cache est de faire en sorte que les clients chargent des ressources qui vont être enregistrées par le cache avec leurs informations sensibles.
Tout d'abord, notez que les extensions telles que .css, .js, .png, etc. sont généralement configurées pour être enregistrées dans le cache. Par conséquent, si vous accédez à www.example.com/profile.php/nonexistent.js, le cache stockera probablement la réponse car il voit l'extension .js. Cependant, si l'application rejoue avec le contenu sensible de l'utilisateur stocké dans www.example.com/profile.php, vous pouvez voler ces contenus à d'autres utilisateurs.
Autres choses à tester :
www.example.com/profile.php/.js
www.example.com/profile.php/.css
www.example.com/profile.php/test.js
www.example.com/profile.php/../test.js
www.example.com/profile.php/%2e%2e/test.js
Utilisez des extensions moins connues telles que
.avif
Un autre exemple très clair peut être trouvé dans ce compte rendu : https://hackerone.com/reports/593712. Dans l'exemple, il est expliqué que si vous chargez une page inexistante comme http://www.example.com/home.php/non-existent.css, le contenu de http://www.example.com/home.php (avec les informations sensibles de l'utilisateur) va être renvoyé et le serveur de cache va enregistrer le résultat. Ensuite, l'attaquant peut accéder à http://www.example.com/home.php/non-existent.css dans son propre navigateur et observer les informations confidentielles des utilisateurs qui ont accédé auparavant.
Notez que le proxy de cache doit être configuré pour mettre en cache les fichiers en fonction de l'extension du fichier (.css) et non en fonction du type de contenu. Dans l'exemple http://www.example.com/home.php/non-existent.css aura un type de contenu text/html au lieu d'un type MIME text/css (qui est attendu pour un fichier .css).
Apprenez ici comment effectuer des attaques de falsification du cache en abusant du détournement de requête HTTP.
Outils Automatiques
toxicache : Scanner Golang pour trouver des vulnérabilités de falsification du cache web dans une liste d'URL et tester plusieurs techniques d'injection.
Références
Utilisez Trickest pour construire et automatiser des workflows alimentés par les outils communautaires les plus avancés au monde. Accédez dès aujourd'hui :
Dernière mise à jour
