Programma Lezione 33 di 156 · HTTP visto da dentro
HTTP visto da dentro

Analizza una richiesta HTTP grezza

Perché è importante Ogni pagina che carichi inizia come un breve pezzo di testo che il tuo browser invia a un server, e quel testo è dove viaggia la maggior parte delle informazioni di tracciamento: i tuoi cookie, la pagina da cui arrivi, la tua lingua. Quando sai leggerlo, niente lì dentro ti è nascosto, e ogni strumento di questa tappa (il tracker, il blocker, le misure) è costruito sopra di esso.

Pensa a una richiesta HTTP come a una lettera in un formato molto rigido. La prima riga dice che cosa vuoi, poi vengono le note con un'etichetta sulla busta, poi una riga vuota, poi (a volte) il contenuto. Una risposta è la lettera di risposta, nello stesso formato. Il tuo browser ne scrive e ne legge migliaia al giorno.

HTTP: HyperText Transfer Protocol, il formato concordato che browser e server usano per chiedere e inviare pagine, immagini e dati.

Richiesta: il messaggio che invia il browser: un metodo (che cosa fare, come GET per scaricare o POST per inviare un modulo), una destinazione (quale percorso sul server) e una versione.

Intestazione: una nota con un'etichetta nel messaggio, scritta Name: value su una riga a sé, come Accept-Language: en-GB.

Com'è una richiesta grezza

Ecco una richiesta che il browser di esercitazione ha inviato per la pagina della tenda di ShopA. Ogni riga finisce con due caratteri invisibili, ritorno a capo e nuova riga, scritti \r\n in Python. Una riga vuota (quindi \r\n\r\n di fila) segna la fine della testa.

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
  • Riga della richiesta: GET /p/tent HTTP/1.1, tre parti separate da spazi singoli.
  • Intestazioni: una per riga, il nome, due punti, poi il valore.
  • Riga vuota: la testa è finita.
  • Corpo: tutto ciò che segue. Una GET di solito non ne ha; una POST di un modulo porta i campi del modulo, come user=sam.

Una risposta ha la stessa forma, ma la sua prima riga è una riga di stato: HTTP/1.1 200 OK. La parte centrale è il codice di stato (200 significa tutto bene, 302 significa "vai altrove", 404 significa "non trovato") e il resto è la frase del motivo, un'etichetta per le persone che può contenere spazi (Moved Permanently) o mancare del tutto.

Codice di stato: un numero di tre cifre all'inizio di una risposta che dice com'è andata. 2xx successo, 3xx reindirizzamento, 4xx un problema con la richiesta, 5xx un problema sul server.

Tre strumenti di Python che ti servono

text.partition(sep) divide al primo sep e restituisce tre pezzi: prima, il separatore, dopo. text.split(sep, 2) divide al massimo due volte, così una frase del motivo con degli spazi resta in un pezzo solo. text.strip() toglie gli spazi da entrambe le estremità.

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

Un errore comune

Dividere una riga di intestazione a ogni due punti. Referer: https://shopa.example/ ha dei due punti dentro il suo valore, quindi line.split(":") taglia a metà l'indirizzo. Dividi sempre solo ai primi due punti. I browser veri l'hanno imparato a loro spese: i parser trasandati sono una fonte classica di bug di sicurezza, in cui due programmi leggono lo stesso messaggio in modo diverso.

Il web vero è ancora così?

Nello spirito, sì. I browser oggi di solito parlano HTTP/2 o HTTP/3, che inviano gli stessi metodi, intestazioni e corpi impacchettati in frame binari invece che in righe di testo. DevTools te li mostra comunque come testo, quindi i campi che impari qui sono esattamente quelli che vedrai lì (verificato a ottobre 2026). Il mondo di esercitazione scrive tutto come testo HTTP/1.1, che è ancora ciò che usano molti server e strumenti.

Provalo Apri DevTools (F12, o Cmd+Option+I su un Mac), scegli la scheda Network e ricarica una pagina qualsiasi. Fai clic sulla prima richiesta e guarda Request Headers. Molti browser offrono un interruttore "Raw" che mostra la testa esattamente in questo formato.

In altri linguaggi

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();

Riepilogo

  • Una richiesta è una riga della richiesta, intestazioni, una riga vuota, poi un corpo facoltativo; una risposta invece inizia con una riga di stato.
  • Separa la testa dal corpo al primo \r\n\r\n, e ogni intestazione ai suoi primi due punti.
  • La frase del motivo può contenere spazi o mancare, quindi dividi la riga di stato al massimo due volte.
  • HTTP/2 e HTTP/3 portano gli stessi campi in binario, quindi questo quadro vale ancora.
Tocca a te

Scrivi parse_request(raw) che restituisce un dict con "method", "target" (percorso più query), "version", "headers" (una lista di coppie (name, value) in ordine, divise ai primi due punti, entrambe senza spazi attorno) e "body" (tutto ciò che c'è dopo la prima riga vuota, "" se non c'è niente). Poi scrivi parse_response(raw) che restituisce allo stesso modo "version", "status" (un int), "reason" ("" se manca), "headers" e "body".

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.