> For the complete documentation index, see [llms.txt](https://blog.s1rn3tz.ovh/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://blog.s1rn3tz.ovh/pentest-web/web-cache-poisoning-deception.md).

# Web Cache Poisoning / Deception

## Méthodologie&#x20;

1. Identifier et évaluer les entrées sans clé
   1. En-tête / Cookie
   2. Paramètre
   3. Chaîne de caractère
2. Ajouter un cache buster à la requête (exp: cb=1)
3. Essayer de faire refléter un "canary" dans la requête avec une entrée sans clé.
4. Envoyer la requête jusqu'à ce qu'elle soit mise en cache.
5. Supprimer le cache buster puis renvoyer la requête.
6. Obtenir la réponse mise en cache

<figure><img src="https://3571537825-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FOIXudYEdnnE8JjXBrL0o%2Fuploads%2FFhdXsOY8F5Jo07fQIe2y%2Fimage.png?alt=media&amp;token=41eb5b5a-6891-4b73-8af6-ecbd7da939e6" alt=""><figcaption></figcaption></figure>

La mise en cache ou non d'une réponse peut dépendre de toutes sortes de facteurs, tels que l'extension de fichier (exp: .js), le type de contenu, la route, le code d'état (exp: 200 OK) et les en-têtes de réponse (exp: X-Forwarded-Host).

{% hint style="info" %}
Poisoning vs. Deception:

Poisoning vise mettre en cache une réponse contenant du code malveillant pour impacter les autres utilisateurs, Deception vise à mettre en cache une page contenant des informations sensibles d'un autre utilisateur pour pouvoir les récupérer.
{% endhint %}

## CPDoS (Cache Poisoning Denial of Services)

### HTTP Header Oversize (HHO)

La plupart des serveurs Web et des proxys fournissent une limite de taille d'en-tête de requête d'environ 8,192 bytes. Cependant, il existe certaines exceptions telles que les **CDN CloudFront** par exemple qui autorisent jusqu'à 20,480 bytes.

Les attaques **CPDoS HHO** fonctionnent dans des scénarios où une application Web utilise un cache qui **accepte une limite de taille d'en-tête supérieure à celle du serveur d'origine**. Pour attaquer une telle application Web, un client malveillant envoie une requête **HTTP GET** comprenant un **en-tête supérieur à la taille prise en charge par le serveur d'origine mais inférieur à la taille prise en charge par le cache.** Pour ce faire, un attaquant a deux options. Soit il utilise plusieurs en-têtes volumineux dans une même requête, soit il ne créer qu'une seule en-tête mais avec un contenu suffisamment volumineux pour générer l'erreur.

Exemple:

```
X-Oversized-Header-1: 000000000000000000000000000000000000...
X-Oversized-Header-2: 000000000000000000000000000000000000...
...
```

### HTTP Meta Character (HMC)

Le principe cette fois est de générer une erreur en envoyant des en-têtes contenant des méta-caractères tels que **\n**, **\r, \a...**

Exemple:&#x20;

```
X-Metachar-Header: \n
X-Metachar-Header: \r
...
```

### HTTP Method Overwrite (HMO)

De nombreux systèmes intermédiaires tels que les proxys, les équilibreurs de charge, les caches et les pare-feu ne prennent en charge que les méthodes **GET** et **POST**. Cela signifie que les requêtes HTTP utilisant **DELETE** , **PUT** etc sont simplement bloquées. Pour contourner cette restriction, de nombreuses API REST et frameworks fournissent des en-têtes tels que `X-HTTP-Method-Override`, `X-HTTP-Method` ou `X-Method-Override` pour les méthodes HTTP bloquées par tunnel. Une fois que la requête atteint le serveur, l'en-tête demande à l'application Web de remplacer la méthode HTTP dans la ligne de requête par celle de la valeur d'en-tête correspondante.

Le principe de cette variante est donc de tenter de générer une erreur 404 Not Found depuis une requête légitime (exp: GET /index.html) en remplaçant la méthode HTTP via une de ces en-têtes.

De ce fait, si GET /index.html est mise en cache, il sera possible de mettre en cache la réponse comme si il s'agissait d'un POST /index.html par exemple.

Exemple:

```
GET /index.html                                    404 Not Found
X-Method-Override: POST                            X-Cache: HIT
```

### Host Header Case Normalization (HHCN)

Selon la **RFC 4343**, les noms de domaine complets (FQDN) doivent toujours être insensibles à la casse. Cependant, pour une raison quelconque, cette règle n'est pas toujours respectée par les frameworks. Il est intéressant de noter que, comme la valeur de l'hôte doit être insensible à la casse, certains développeurs supposent qu'il est prudent de mettre en minuscules la valeur de l'en-tête de l'hôte lors de son introduction dans la clé de cache, sans modifier la requête réelle envoyée au serveur principal.

De ce fait, il est parfois possible de générer des erreurs 404 mises en cache en ajoutant une majuscule dans l'en-tête `Host` de la requête.

Exemple:

```
Host: Cdn.target.xyz au lieu de Host: cdn.target.xyz
```

### Hop By Hop (HBH)

Un en-tête hop-by-hop est un en-tête conçu pour être traité et consommé par le proxy qui gère la requête, par opposition à un en-tête end-to-end, qui est conçu pour être présent dans la requête jusqu'à la fin de la requête. Selon la RFC 2612, la spécification HTTP/1.1 traite les en-têtes suivants comme hop-by-hop par défaut : `Keep-Alive`, `Transfer-Encoding`, `TE`, `Connection`, `Trailer`, `Upgrade`, `Proxy-Authorization` et `Proxy-Authenticate`. Lorsqu'il rencontre ces en-têtes dans une requête, un proxy conforme doit traiter ou agir sur ce que ces en-têtes indiquent, et ne pas les transmettre au saut suivant.

Outre ces valeurs par défaut, une requête peut également définir un ensemble personnalisé d'en-têtes à traiter comme un en-tête hop-by-hop en les ajoutant à l'en-tête de connexion, comme ceci :

```
Connection : close, X-Foo, X-Bar
```

Dans cet exemple, nous demandons au proxy de traiter `X-Foo` et `X-Bar` comme une en-tête hop-by-hop, ce qui signifie que nous voulons qu'un proxy les supprime de la requête avant de la transmettre. C'est ce fonctionnement qui permet l'exploitation de cette variante de CPDoS.

## Spécificités

Certains frameworks et serveurs web utilisent des délimiteurs qui peuvent permettre de tromper les serveurs de cache.

Wordlist utile:

{% embed url="<https://github.com/mathis2001/Wordlists/blob/main/Cache/Delimiters.txt>" %}

### Spring

Par exemple, Spring permet d'utiliser des semicolon comme paramètres:

* /use&#x72;**;params**/home sera traité comme /user/home
* MyAccoun&#x74;**;a.js** sera traité comme /MyAccount

Or, si le serveur met en cache les ressources en .js, le contenu sensible de MyAccount sera mis en cache.

### Rails

De la même manière, Rails utilise le . (point) pour afficher les vues, mais toutes les extensions ne sont pas prises en charge par le framework.

Par exemple:

* /MyAccount affichera la vue myaccount.html.erb
* /MyAccoun&#x74;**.css** affichera la vue myaccoun&#x74;**.css**.erb

Cependant,

* /MyAccoun&#x74;**.aaa** ne sera pas reconnu et affichera la vue par défaut qui est myaccoun&#x74;**.html**.erb

Cela signifie que si le serveur de cache est configuré pour mettre en cache des extensions n'étant pas reconnues par le framework, il est possible de mettre en cache le contenu de /MyAccount.

Exemple: MyAccoun&#x74;**.ico** pourrait être mis en cache et afficher la vue myaccoun&#x74;**.html**.erb

### Nginx

même chose avec **%0A**:

* /MyAccoun&#x74;**%0A.js** => /MyAccount

#### Injection de clé de cache

La méthode de création de clé de cache par défaut de Nginx se base sur le shéma HTTP, le nom d'hôte et l'URI est ressemble à:

```
proxy_cache_key "$scheme$proxy_host$request_uri";
```

Les développeurs peuvent aussi choisir de personnaliser cela dépendamment de leurs besoins pour inclure:

* Le schéma HTTP : `http` ou `https`.
* Le nom d’hôte.
* Le chemin de la ressource et la chaîne de requête (query string).
* Certains en-têtes HTTP.
* Des cookies ou d’autres valeurs définies par l’application.

Exemple:

```
proxy_cache_key "$scheme$host$request_uri$cookie_language$http_accept";
```

Parfois, plusieurs serveurs de cache sont utilisés, principalement pour réduire la latence. Par exemple, Cloudflare peut faire office de serveur de cache périphérique, stockant le contenu mis en cache par région géographique. Nginx, quant à lui, peut faire office de serveur de cache d'origine, réduisant ainsi la charge inutile sur le serveur principal.

Considérons la clé suivante :

```
proxy_cache_key "$scheme$proxy_host$uri$is_args$args$http_accept";
```

Pour une requête légitime, Nginx peut concaténer les fragments ainsi :

```
"https" + "myapp" + "/" + "" + "" + "*/*"
= httpsmyapp/*/*
```

Une autre requête peut répartir les mêmes caractères entre le chemin et l’en-tête `Accept` :

```
"https" + "myapp" + "/*" + "" + "" + "/*"
= httpsmyapp/*/*
```

Les deux requêtes produisent donc la même clé finale, alors qu’elles ne demandent pas la même ressource.

Cela créer donc une collision volontaire qui peut être exploitée.

Les conditions d"exploitation sont les suivantes:

1. Le cache est partagé entre plusieurs requêtes ou utilisateurs.
2. L’attaquant peut influencer au moins deux fragments de la clé, directement ou indirectement.
3. Des requêtes distinctes peuvent générer la même clé.
4. Le cache peut stocker la réponse obtenue par l’une de ces requêtes.
5. La réponse stockée est ensuite accessible via une autre requête, sans qu’un contrôle supplémentaire bloque sa restitution.

L’impact dépend de la ressource ciblée, de l’ordre des requêtes, de la politique de mise en cache et des contrôles d’accès appliqués en amont ou en aval du cache.

#### Exemple de cache deception exploitant ce comportement

Configuration Nginx vulnérable:

```
proxy_cache_key "$scheme$proxy_host$uri$is_args$args$http_accept";
proxy_cache_valid any 30s;

location /admin {
    allow 127.0.0.1;
    deny all;
    proxy_pass http://server;
}
```

Dans ce scénario :

* L’accès direct à `/admin` est autorisé uniquement depuis localhost.
* Le cache est partagé et sa clé inclut le chemin ainsi que l’en-tête `Accept`.
* La réponse du tableau de bord d’administration est stockée dans le cache.

Un administrateur local demande `/admin` avec `Accept: */*`. La réponse est mise en cache sous la clé correspondant à cette requête.

Un attaquant externe tente ensuite d’accéder à `/admin`, mais la règle ACL bloque cette requête directe.

Le problème survient lorsqu’il est possible de répartir le chemin `/admin` entre l’URI et l’en-tête `Accept` :

```
GET /ad HTTP/1.1
Host: example.com
Accept: min*/*
```

La concaténation des fragments pertinents peut produire la même clé que celle créée pour la requête légitime vers `/admin` :

```
Requête légitime : /admin + */*
Requête alternative : /ad + min*/*
```

Si la clé obtenue correspond à l’entrée du tableau de bord déjà en cache, Nginx peut renvoyer cette réponse à l’attaquant, alors même que la requête `/ad` ne correspond pas au chemin protégé par l’ACL.

## Ressources

{% embed url="<https://hackerone.com/reports/394016>" %}

{% embed url="<https://www.yeswehack.com/fr/lab/research-cache-key-injection>" %}

## Outils

### Extension Burp Param Miner

Param Miner est une extension de Burp Suite permettant d'automatiser la recherche d'entrées sans clé.

{% hint style="info" %}
Utilisation: clic droit sur la requête > "Extensions" > "Param Miner" > ...

Résultats visible dans l'onglet "Extender" > "Extensions" > "Param Miner" > "Output"
{% endhint %}

### HExHTTP

Header Exploitation HTTP est un outil permettant de tester les vulnérabilités liées aux en-têtes HTTP qui comprend notamment des tests liés au cache.

Exemple d'utilisation:

`$ python3 hexhttp.py -u https://target.com/`

ressource: <https://github.com/c0dejump/HExHTTP>

### wcDetect

wcDetect est un outil spécialement conçu pour détecter les vulnérabilités de cache deception.

Exemple d'utilisation:

`$ python3 wcdetect.py -u https://target.com/`

ressource: <https://github.com/c0dejump/wcDetect>
