Programme Leçon 33 sur 156 · HTTP vu de l'intérieur
HTTP vu de l'intérieur

Analyser une requête HTTP brute

Pourquoi c'est important Chaque page que tu charges commence par un petit texte que ton navigateur envoie à un serveur, et c'est dans ce texte que voyagent la plupart des informations de pistage : tes cookies, la page d'où tu viens, ta langue. Une fois que tu sais le lire, plus rien n'y est caché pour toi, et chaque outil de cette étape (le traqueur, le bloqueur, les mesures) est construit dessus.

Pense à une requête HTTP comme à une lettre au format très strict. La première ligne dit ce que tu veux, puis viennent des notes étiquetées sur l'enveloppe, puis une ligne vide, puis (parfois) le contenu. Une réponse est la lettre de réponse, au même format. Ton navigateur en écrit et en lit des milliers par jour.

HTTP : HyperText Transfer Protocol, le format convenu que les navigateurs et les serveurs utilisent pour demander et envoyer des pages, des images et des données.

Requête : le message qu'envoie le navigateur : une méthode (quoi faire, comme GET pour récupérer ou POST pour envoyer un formulaire), une cible (quel chemin sur le serveur) et une version.

En-tête : une note étiquetée du message, écrite Name: value sur sa propre ligne, comme Accept-Language: en-GB.

À quoi ressemble une requête brute

Voici une requête que le navigateur d'entraînement a envoyée pour la page tente de ShopA. Chaque ligne se termine par deux caractères invisibles, retour chariot et saut de ligne, écrits \r\n en Python. Une ligne vide (donc \r\n\r\n à la suite) marque la fin de l'en-tête du message.

GET /p/tent HTTP/1.1
Host: shopa.example
User-Agent: PracticeBrowser/1.0 (Linux) Practice Firefox 144
Accept-Language: en-ZA
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
  • Ligne de requête : GET /p/tent HTTP/1.1, trois parties séparées par des espaces simples.
  • En-têtes : un par ligne, le nom, deux-points, puis la valeur.
  • Ligne vide : la tête du message est terminée.
  • Corps : tout ce qui suit. Un GET n'en a en général pas ; un POST de formulaire porte les champs du formulaire, comme user=sam.

Une réponse a la même forme, mais sa première ligne est une ligne de statut : HTTP/1.1 200 OK. La partie du milieu est le code de statut (200 veut dire tout va bien, 302 veut dire « va ailleurs », 404 veut dire « introuvable ») et le reste est la phrase de raison, une étiquette pour les humains qui peut contenir des espaces (Moved Permanently) ou manquer complètement.

Code de statut : un nombre à trois chiffres au début d'une réponse qui dit comment ça s'est passé. 2xx réussite, 3xx redirection, 4xx un problème dans la requête, 5xx un problème sur le serveur.

Trois outils Python dont tu as besoin

text.partition(sep) coupe au premier sep et rend trois morceaux : avant, le séparateur, après. text.split(sep, 2) coupe au plus deux fois, donc une phrase de raison avec des espaces reste en un seul morceau. text.strip() retire les espaces aux deux bouts.

"Referer: https://shopa.example/".partition(":")
# ('Referer', ':', ' https://shopa.example/')
"HTTP/1.1 301 Moved Permanently".split(" ", 2)
# ['HTTP/1.1', '301', 'Moved Permanently']

Une erreur courante

Couper une ligne d'en-tête à chaque deux-points. Referer: https://shopa.example/ a un deux-points dans sa valeur, donc line.split(":") coupe l'adresse en deux. Coupe toujours au premier deux-points seulement. Les vrais navigateurs l'ont appris à leurs dépens : les analyseurs négligents sont une source classique de bogues de sécurité, où deux programmes lisent le même message différemment.

Le vrai web ressemble-t-il encore à ça ?

Surtout dans l'esprit. Les navigateurs parlent aujourd'hui en général HTTP/2 ou HTTP/3, qui envoient les mêmes méthodes, en-têtes et corps emballés dans des trames binaires au lieu de lignes de texte. DevTools te les montre quand même sous forme de texte, donc les champs que tu apprends ici sont exactement ceux que tu y verras (vérifié en octobre 2026). Le monde d'entraînement écrit tout en texte HTTP/1.1, ce qu'utilisent encore beaucoup de serveurs et d'outils.

Essaie Ouvre DevTools (F12, ou Cmd+Option+I sur un Mac), choisis l'onglet Network (Réseau) et recharge n'importe quelle page. Clique sur la première requête et regarde les Request Headers. Beaucoup de navigateurs proposent un bouton « Raw » qui montre la tête du message exactement dans ce format.

Dans d'autres langages

JavaScript :

function parseRequest(raw) {
  const [head, ...rest] = raw.split("\r\n\r\n");
  const lines = head.split("\r\n");
  const [method, target, version] = lines[0].split(" ");
  const headers = lines.slice(1).map(line => {
    const i = line.indexOf(":");            // first colon only
    return [line.slice(0, i).trim(), line.slice(i + 1).trim()];
  });
  return { method, target, version, headers, body: rest.join("\r\n\r\n") };
}

Go :

// the standard library has a real parser: net/http.ReadRequest
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(raw)))
if err == nil {
    fmt.Println(req.Method, req.URL.Path, req.Header.Get("User-Agent"))
}

Rust :

let (head, body) = raw.split_once("\r\n\r\n").unwrap_or((raw, ""));
let mut lines = head.split("\r\n");
let mut first = lines.next().unwrap().splitn(3, ' ');
let (method, target) = (first.next(), first.next());
let headers: Vec<(&str, &str)> = lines
    .filter_map(|l| l.split_once(':'))
    .map(|(n, v)| (n.trim(), v.trim()))
    .collect();

Récap

  • Une requête, c'est une ligne de requête, des en-têtes, une ligne vide, puis un corps facultatif ; une réponse commence par une ligne de statut à la place.
  • Sépare la tête du corps au premier \r\n\r\n, et chaque en-tête à son premier deux-points.
  • La phrase de raison peut contenir des espaces ou manquer, donc coupe la ligne de statut au plus deux fois.
  • HTTP/2 et HTTP/3 portent les mêmes champs en binaire, donc cette image tient toujours.
À ton tour

Écris parse_request(raw) qui renvoie un dict avec "method", "target" (chemin plus requête), "version", "headers" (une liste de paires (name, value) dans l'ordre, coupées au premier deux-points, les deux sans espaces autour) et "body" (tout ce qui suit la première ligne vide, "" s'il n'y a rien). Puis écris parse_response(raw) qui renvoie "version", "status" (un int), "reason" ("" si elle manque), "headers" et "body" de la même façon.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.