Svogliati
📡

HTTP e Web Serverper Svogliati

Ogni pagina, ogni API, ogni app sul telefono parla HTTP. Una domanda, una risposta, qualche riga di intestazioni. Sopra ci hanno costruito cookie, HTTPS, HTTP/2 e HTTP/3. Capita la domanda e la risposta, il resto si legge con curl -v.

"Sul mio computer funziona." — Detto con la cache del browser piena da tre settimane.

↓
01 / 15

Da una riga di testo a QUIC

Trent'anni per passare da "dammi questa pagina" a un protocollo che viaggia su UDP e cifra tutto, anche le intestazioni.

💡 Il problema da risolvere

Al CERN i fisici volevano leggere i documenti dei colleghi su computer diversi, con un clic su un collegamento. Serviva un modo semplicissimo per dire a un altro computer "mandami il documento che si chiama così". HTTP (HyperText Transfer Protocol) è nato per questo. Tutto il resto, dalle intestazioni ai cookie a HTTP/3, è stato aggiunto dopo, man mano che il web diventava negozi, banche, video e applicazioni.

1991

HTTP/0.9

Tim Berners-Lee scrive il primo server e il primo browser. Il protocollo è una riga: GET /pagina. Niente intestazioni, niente codici di errore, solo HTML.

1994

Netscape: cookie e SSL

Per fare il carrello di un negozio serve ricordarsi chi sei: Lou Montulli inventa i cookie. Per pagare serve cifrare: nasce SSL, il nonno di TLS.

1996-1997

HTTP/1.0 e HTTP/1.1

Arrivano intestazioni, codici di stato, tipi di contenuto. HTTP/1.1 aggiunge l'intestazione Host (tanti siti su un solo IP) e le connessioni che restano aperte. È ancora in uso oggi.

1999

Il problema C10K

Come si servono diecimila client insieme su un solo server? Un processo per connessione non regge. Da questa domanda nasceranno nginx (2004) e i server a eventi.

2009

SPDY

Google sperimenta in Chrome un protocollo binario con più richieste sulla stessa connessione. Funziona, e diventa la base di HTTP/2.

2015

HTTP/2

Stessi metodi e stesse intestazioni, ma trasporto nuovo: frame binari, multiplexing, intestazioni compresse. I browser lo usano solo con HTTPS.

2021-2022

QUIC e HTTP/3

QUIC diventa standard (RFC 9000): un trasporto nuovo su UDP con TLS 1.3 incorporato. HTTP/3 (RFC 9114) ci gira sopra. Nello stesso anno le specifiche di HTTP vengono riscritte e separate: la semantica (RFC 9110) è una sola, le versioni sono solo modi diversi di trasportarla.

02 / 15

Perché devi capirlo

Perché "il sito non va" è una frase che non vuol dire niente, e HTTP ti dice esattamente cosa non va. Basta leggerlo.

🔢

I codici parlano

502 non è 504, 401 non è 403. Il codice ti dice già se il problema è il client, il proxy o l'applicazione (sezione 14).

🔁

Il reverse proxy

Quasi ogni servizio oggi sta dietro a nginx, Caddy o Cloudflare. Se non sai cosa aggiunge e cosa toglie il proxy, impazzisci con IP, redirect e WebSocket.

🍪

Login e sessioni

"Mi butta fuori ogni cinque minuti", "da Chrome entra, da Safari no": quasi sempre sono attributi dei cookie.

🗄️

La cache

"Ho cambiato il file ma vedo quello vecchio." La cache del browser, del proxy o del CDN: sapere chi la controlla ti risparmia ore.

🛡️

La sicurezza

HSTS, CSP, CORS e gli attributi dei cookie sono intestazioni HTTP. Metà della sicurezza di un sito si configura in cinque righe del server.

⚡

La velocità

HTTP/2, HTTP/3, compressione e cache fanno più differenza di quasi ogni ottimizzazione del codice. E costano una riga di configurazione.

03 / 15

Le versioni, a confronto

Cambia il modo di trasportare le richieste, non le richieste. GET resta GET, 404 resta 404.

Cosa c'è sotto a ogni versione
HTTP/1.1 HTTP/2 HTTP/3 HTTP/1.1 testo leggibile TLS facoltativo (http://) TCP IP HTTP/2 frame binari · HPACK TLS di fatto obbligatorio TCP IP HTTP/3 frame binari · QPACK QUIC TLS 1.3 incorporato UDP IP QUIC rifà su UDP, nel programma, quello che TCP faceva nel kernel: ordine, ritrasmissioni, controllo della congestione.
VoceHTTP/1.1HTTP/2HTTP/3
TrasportoTCPTCPQUIC su UDP, porta 443
FormatoTestoFrame binariFrame binari
Richieste in paralleloUna alla volta per connessione; i browser aprono fino a 6 connessioni per sitoTante sulla stessa connessione (multiplexing)Tante, e indipendenti anche quando si perde un pacchetto
IntestazioniRipetute per intero a ogni richiestaCompresse (HPACK)Compresse (QPACK)
CifraturaFacoltativaNei browser sì, sempreSempre, non si può togliere
Va bene perTra proxy e applicazione, debug, client sempliciIl default di qualsiasi sito in HTTPSTelefoni, reti lente o che perdono pacchetti, chi cambia rete (Wi-Fi → 4G)
🧭 Come sceglie il browserParte sempre da TCP. Durante l'handshake TLS chiede "parli h2?" (si chiama ALPN): se il server dice sì, usa HTTP/2. Se nella risposta trova l'intestazione Alt-Svc: h3=":443", dalla volta dopo prova HTTP/3 su UDP. Se UDP è bloccato, torna a TCP senza dire niente a nessuno. Per questo HTTP/3 "rotto" di solito non si nota: si nota solo che non viene usato.
04 / 15

Il concetto chiave: una domanda, una risposta

Il client chiede, il server risponde, e poi si dimentica di te. Tutto HTTP sta qui.

🏪 Lo sportello delle poste

Arrivi allo sportello con un modulo: cosa vuoi (il metodo e l'indirizzo) e qualche casella compilata (le intestazioni). L'impiegato ti restituisce il modulo con un timbro (il codice di stato), qualche nota (le intestazioni di risposta) e, se c'è, il pacco (il corpo). Poi chiama il prossimo e non si ricorda di te. Se torni, devi farti riconoscere di nuovo: per questo esistono i cookie (sezione 7).

Una richiesta e la sua risposta, come viaggiano davvero
Browser o curl, o un'app Web server nginx, Apache, Caddy RICHIESTA GET /prodotti?pagina=2 HTTP/1.1 Host: shop.example.com Accept: text/html Cookie: sessione=a8f3 RISPOSTA HTTP/1.1 200 OK Content-Type: text/html Cache-Control: no-cache (riga vuota) <html>…la pagina…</html>
REGOLA 1

HTTP non ha memoria

Ogni richiesta è indipendente. Login, carrello, lingua scelta: tutto quello che deve "ricordarsi" viaggia di nuovo in ogni richiesta, quasi sempre in un cookie.

REGOLA 2

Le intestazioni comandano

Il corpo è il contenuto, le intestazioni sono le istruzioni: che tipo di file è, quanto tenerlo in cache, chi può leggerlo, dove andare dopo. Quando qualcosa si comporta in modo strano, guarda prima le intestazioni.

REGOLA 3

Il codice di stato non mente

Le pagine di errore possono essere belle, brutte o vuote. Il numero nella prima riga della risposta è quello che conta: è lì che inizi a cercare.

05 / 15

URL, metodi e codici di stato

Tre cose da sapere a memoria: com'è fatto un indirizzo, cosa vuole dire ogni verbo, cosa vuole dire ogni centinaio.

Un URL smontato
https :// shop.example.com :443 /prodotti/bici ?colore=rosso #recensioni schema host porta percorso query frammento va nell'intestazione Host di solito sottintesa resta nel browser: al server non arriva
MetodoCosa faSicuro / idempotenteNota
GETLegge una risorsaSì / sìNon deve mai modificare niente: i crawler e i prefetch dei browser lo chiamano da soli
HEADCome GET, ma solo le intestazioniSì / sìcurl -I. Comodo per vedere dimensione, tipo e cache senza scaricare
POSTManda dati: un modulo, un upload, un'azioneNo / noRipeterlo può creare due ordini. Per questo il browser chiede "inviare di nuovo il modulo?"
PUTSostituisce una risorsa interaNo / sìRipeterlo dà lo stesso risultato
PATCHModifica una parteNo / non sempreTipico delle API REST
DELETECancellaNo / sì
OPTIONSChiede cosa si può fareSì / sìIl browser lo usa da solo per il "preflight" CORS (sezione 13)
FamigliaVuol direI codici che vedrai
1xxInformazione, vai avanti101 cambio protocollo (WebSocket), 103 Early Hints
2xxTutto bene200 OK, 201 creato, 204 fatto, niente da mostrare, 206 un pezzo (video, download ripresi)
3xxVai da un'altra parte301/308 spostato per sempre, 302/307 per ora, 304 non cambiato, usa la tua copia
4xxHai sbagliato tu (il client)400, 401 chi sei?, 403 so chi sei ma no, 404, 413, 429 rallenta
5xxHa sbagliato il server500 l'applicazione è esplosa, 502/504 il proxy non ha avuto risposta dall'applicazione, 503 non disponibile
💡 301 contro 308, 302 contro 307Con 301 e 302 i browser trasformano un POST in GET quando seguono il redirect, e i dati del modulo si perdono. 307 e 308 conservano metodo e corpo. Per spostare una pagina va bene 301; per un'API che riceve POST usa 308.
06 / 15

Le intestazioni, quelle che contano

Ne esistono centinaia. Queste sono quelle che leggerai davvero, e curl è l'unico strumento che ti serve per vederle.

bash · guardare cosa succede
# tutto: richiesta (righe con >), risposta (righe con <), TLS e connessione (righe con *)
curl -v https://example.com -o /dev/null

# solo le intestazioni della risposta
curl -sI https://example.com

# seguire i redirect e vedere ogni passaggio
curl -sIL http://example.com | grep -iE '^(HTTP|location)'

# mandare un'intestazione a mano
curl -s -H 'Accept-Language: it' -H 'User-Agent: prova' https://example.com

# chiedere un sito a un IP preciso (prima di cambiare il DNS, o per un server dietro al bilanciatore)
curl -sI --resolve example.com:443:192.168.1.20 https://example.com
IntestazioneChi la mandaA cosa serve
HostClientQuale sito vuoi su quell'IP. Senza, i virtual host non esisterebbero
User-AgentClientChi sei: browser, curl, bot. Si può falsificare, non fidarti
Accept, Accept-Language, Accept-EncodingClientChe formati, lingue e compressioni capisci
AuthorizationClientCredenziali: Basic (utente e password in base64, solo con HTTPS) o Bearer (un token)
Cookie / Set-CookieClient / serverIl server consegna un cookie, il client lo rimanda (sezione 7)
Content-TypeEntrambiChe cos'è il corpo: text/html; charset=utf-8, application/json. Sbagliato = file scaricato invece che mostrato, o caratteri strani
Content-Length / Transfer-Encoding: chunkedEntrambiQuanto è lungo il corpo, o "arriva a pezzi, ti dico io quando è finito"
LocationServerDove andare dopo un 3xx o un 201
Cache-Control, ETag, Last-ModifiedServerPer quanto tenere la copia e come verificarla (sezione 12)
X-Forwarded-For, X-Forwarded-ProtoProxyL'IP vero del client e se era in HTTPS, aggiunti dal reverse proxy (sezione 11)
Strict-Transport-Security, Content-Security-PolicyServerSicurezza: solo HTTPS, cosa può caricare la pagina (sezione 13)
ServerServerNome e versione del server. Meglio senza versione: server_tokens off;
🔤 Maiuscole e minuscoleI nomi delle intestazioni non distinguono maiuscole e minuscole: Content-Type e content-type sono la stessa cosa. In HTTP/2 e HTTP/3 viaggiano sempre in minuscolo, e infatti curl -v te le mostra così. Non è un errore. I valori invece spesso le distinguono, i cookie per primi.
08 / 15

HTTPS: lo stesso HTTP, dentro TLS

HTTPS non è un altro protocollo. È HTTP che viaggia in un tubo cifrato, e il tubo si apre prima che parta la prima richiesta.

🔒 Cosa protegge

  • Riservatezza: chi sta in mezzo (Wi-Fi pubblico, provider) non legge percorso, intestazioni, cookie e contenuto
  • Integrità: nessuno può modificare la pagina per strada (una volta i provider ci infilavano pubblicità)
  • Identità: il certificato dimostra che stai parlando con quel nome (Certificati per Svogliati)

👀 Cosa resta visibile

  • L'IP del server, e quindi spesso chi lo ospita
  • Il nome del sito, perché il client lo manda in chiaro nell'handshake (SNI), salvo con ECH, ancora poco diffuso
  • Le query DNS, se non usi DNS cifrato (DNS per Svogliati)
  • Quanto scarichi e quando
PezzoCosa fa
SNI (Server Name Indication)Il client dice il nome del sito all'inizio dell'handshake, così il server sceglie il certificato giusto tra tanti sullo stesso IP
ALPNClient e server si accordano sul protocollo dentro TLS: h2 o http/1.1
TLS 1.3Handshake in un solo giro invece di due, solo algoritmi moderni. Con TLS 1.2 è l'unico da tenere attivo
HSTSIl server dice "da oggi solo HTTPS per un anno": il browser non prova più nemmeno http://, quindi nessuno può intercettare il primo redirect
nginx · tutto il traffico in HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name example.com www.example.com;

    # la sfida di Let's Encrypt deve restare raggiungibile in http
    location /.well-known/acme-challenge/ { root /var/www/html; }

    location / { return 301 https://$host$request_uri; }
}
bash · che protocollo parla il server?
# ALPN: se risponde "ALPN protocol: h2" il server parla HTTP/2
openssl s_client -connect example.com:443 -servername example.com -alpn h2,http/1.1 </dev/null 2>/dev/null | grep -i alpn

# versione HTTP usata e tempi di ogni fase, in secondi
curl -so /dev/null -w 'http/%{http_version}  dns %{time_namelookup}  tcp %{time_connect}  tls %{time_appconnect}  primo byte %{time_starttransfer}\n' https://example.com
09 / 15

HTTP/2, HTTP/3, QUIC e il push

Le pagine moderne sono fatte di cento file. Il problema non è la banda, sono le attese: ogni versione nuova ne toglie un po'.

Quanto si aspetta prima della risposta, con 50 ms di ritardo verso il server
0 50 ms 100 ms 150 ms 200 ms TCP + TLS 1.2 HTTP/1.1 o HTTP/2, vecchio TCP + TLS 1.3 HTTP/2 oggi QUIC HTTP/3, prima visita QUIC 0-RTT HTTP/3, sito già visitato la richiesta parte con l'handshake handshake TCP handshake TLS QUIC (insieme) richiesta e risposta
Tre file (A, B, C) e un pacchetto perso
HTTP/1.1 una connessione per file, fino a 6 tre handshake, tre code separate; il settimo file aspetta che se ne liberi una HTTP/2 una connessione TCP, file mescolati ✕ si perde un pezzo di A: TCP consegna in ordine, quindi B e C aspettano anche se sono già arrivati HTTP/3 QUIC: ogni file è uno stream a sé ✕ si ferma solo A, finché il pezzo perso non torna. B e C vanno avanti

📱 Cosa porta QUIC in più

  • Cambio di rete senza interruzioni: la connessione ha un suo identificativo, non dipende dall'IP. Esci di casa, passi dal Wi-Fi al 4G e il download continua
  • Tutto cifrato: anche i dati di controllo del trasporto, che con TCP viaggiano in chiaro
  • Aggiornabile: sta nel programma, non nel kernel. I browser lo migliorano a ogni versione

⚠️ I suoi difetti

  • Molte reti aziendali bloccano UDP 443: il browser torna a HTTP/2 e nessuno se ne accorge
  • Usa più CPU di TCP, che il kernel e le schede di rete accelerano da decenni
  • Il 0-RTT può essere ripetuto da chi intercetta: va accettato solo per richieste che non cambiano niente (GET)
  • I firewall e gli strumenti di analisi vedono molto meno
"Push"Cos'èStato
Server Push di HTTP/2Il server manda il CSS insieme alla pagina, prima che il browser lo chiedaMorto. Mandava spesso file già in cache. Chrome l'ha tolto nel 2022, nginx ha rimosso http2_push. Al suo posto: 103 Early Hints e <link rel="preload">
103 Early HintsIl server risponde subito "intanto inizia a scaricare questi file", mentre prepara la paginaSupportato da Chrome, Firefox, Safari e da Cloudflare
Web PushLe notifiche del browser e delle PWA, anche a sito chiuso, passando dal servizio del browser (Google, Mozilla, Apple) con chiavi VAPIDVivo. Su iPhone solo per siti aggiunti alla schermata Home
Server-Sent EventsIl server tiene aperta una risposta e manda eventi di testo man manoVivo e semplice: chat, avanzamento, notifiche dentro la pagina
WebSocketParte come HTTP (101 Switching Protocols) e diventa un canale nei due sensiVivo. Dietro a nginx servono due intestazioni in più (sezione 11)
10 / 15

Come funziona un web server

Ascolta su una porta, legge richieste, manda risposte. La differenza tra uno e l'altro è come aspetta.

Due modi di servire molti client
Un processo per connessione processo 1 processo 2 processo 3 processo 4 finiti: in coda ogni processo occupa memoria anche mentre aspetta Event loop worker 1 core 1 worker 2 core 2 un worker per core, migliaia di connessioni ciascuno
🍝 Il cameriere

Nel primo modello ogni tavolo ha il suo cameriere, che resta lì in piedi anche mentre i clienti leggono il menu: con cento tavoli servono cento camerieri. Nel secondo, un cameriere gira tra tutti i tavoli e si ferma solo da chi ha deciso. Il sistema operativo gli dice chi è pronto (epoll su Linux, kqueue su BSD e macOS). Funziona finché nessun tavolo lo tiene occupato a lungo: per questo il lavoro pesante (PHP, Python) si passa a un processo dietro.

ServerCom'è fattoQuando
nginxA eventi, in C, dal 2004. Configurazione a blocchi, ricaricabile senza interruzioniIl default per siti, reverse proxy e file statici
Apache httpdDal 1995. Moduli per tutto, file .htaccess nelle cartelle. Con l'MPM event è a eventi anche lui; prefork è il vecchio un processo per connessioneHosting condiviso, applicazioni che contano su .htaccess, chi lo conosce già
CaddyIn Go. Certificati Let's Encrypt automatici, HTTP/3 attivo di default, configurazione cortissimaIl più svogliato: un sito con HTTPS in tre righe
LiteSpeed / OpenLiteSpeedA eventi, legge le regole di Apache e i .htaccessHosting WordPress (molti provider lo usano)
HAProxy, TraefikNon servono file: smistano il trafficoBilanciamento tra più server; Traefik nei container, con configurazione presa dalle etichette Docker
Gunicorn, uvicorn, Node, PHP-FPMServer dell'applicazione, non server web completiSempre dietro a un reverse proxy, in ascolto su 127.0.0.1 o su un socket
🏘️ Virtual hostUn server, un IP, cento siti. In HTTP il server sceglie il sito dall'intestazione Host; in HTTPS ancora prima, dallo SNI, perché deve presentare il certificato giusto. Se nessun blocco corrisponde, risponde il sito di default: è per questo che aprire il server per IP mostra un sito a caso. Conviene un blocco default_server che risponde 444 (nginx chiude e basta).
11 / 15

nginx e il reverse proxy

Il reverse proxy è l'unico che parla con Internet. Dietro, le applicazioni parlano HTTP semplice con lui e basta.

Un ingresso solo, tante applicazioni dietro
Browser da Internet HTTPS :443 nginx • TLS e certificati • HTTP/2 e HTTP/3 • compressione e cache • file statici • limiti e intestazioni • aggiunge X-Forwarded-* HTTP app Python 127.0.0.1:8000 app Node 127.0.0.1:3000 PHP-FPM /run/php/php-fpm.sock le applicazioni ascoltano solo in locale: da fuori si arriva soltanto passando da nginx
nginx · /etc/nginx/sites-available/example.com
server {
    listen 443 ssl;
    listen [::]:443 ssl;
    listen 443 quic reuseport;             # HTTP/3 (reuseport una volta sola per porta)
    listen [::]:443 quic reuseport;
    http2 on;
    http3 on;
    server_name example.com;

    ssl_certificate     /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;

    add_header Alt-Svc 'h3=":443"; ma=86400' always;   # dice al browser che c'è HTTP/3
    client_max_body_size 20m;              # default 1m: upload più grandi = 413

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /ws/ {                        # WebSocket
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade    $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 1h;
    }

    location /static/ {                    # i file li serve nginx, l'applicazione non li vede
        alias /srv/app/static/;
        expires 30d;
    }
}
bash · prima di ricaricare, sempre
sudo nginx -t && sudo systemctl reload nginx   # reload: nessuna connessione interrotta
nginx -V 2>&1 | grep -o http_v3_module          # il tuo nginx sa fare HTTP/3? (serve la 1.25 o successiva)
sudo ufw allow 443/udp                             # HTTP/3 è UDP: senza, non arriva niente
curl -sI --http3 https://example.com               # solo se il tuo curl è compilato con HTTP/3
🕵️ Tutti i visitatori hanno lo stesso IPDietro a un proxy l'applicazione vede solo 127.0.0.1, o l'IP di Cloudflare. L'IP vero sta in X-Forwarded-For, ma l'applicazione deve fidarsi di quell'intestazione solo quando arriva dal proxy: altrimenti chiunque può scriverci un IP a caso. In nginx dietro Cloudflare si usa il modulo real_ip con l'elenco degli IP di Cloudflare; nelle applicazioni c'è un'impostazione "trusted proxies".
12 / 15

Cache e compressione

La richiesta più veloce è quella che non parte. La seconda più veloce è quella che risponde "non è cambiato niente".

Cosa fa il browser prima di scaricare un file
Serve /style.css Ce l'ho in cache, ed è ancora fresca? Cache-Control: max-age=… sì no, o scaduta Usa la copia zero rete, zero attesa Chiede al server se è cambiata If-None-Match: "etag" 304 Not Modified pochi byte, riusa la copia 200 OK scarica il file nuovo
Cache-ControlVuol direPer cosa
max-age=31536000, immutableTienilo un anno e non chiedere maiFile con l'impronta nel nome: app.3f9a2c.js. Se cambia, cambia il nome
no-cachePuoi tenerlo, ma chiedi sempre se è cambiato prima di usarloLe pagine HTML: sempre aggiornate, e con il 304 costano poco
no-storeNon salvarlo da nessuna parteDati personali, pagine dopo il login con dati sensibili
private / publicSolo il browser / anche proxy e CDNprivate per tutto ciò che cambia da utente a utente
s-maxage=…Durata solo per le cache condivise (CDN)Il CDN tiene la pagina 5 minuti, il browser la ricontrolla sempre

🗜️ Compressione

Il client dice cosa capisce (Accept-Encoding: gzip, br, zstd), il server sceglie e lo scrive in Content-Encoding. gzip va ovunque, brotli comprime meglio i testi, zstd è il più recente e veloce. HTML, CSS, JS, JSON e SVG si comprimono anche dell'80%; JPEG, PNG, video e zip sono già compressi: non toccarli.

🌍 CDN

Un CDN (Cloudflare, Bunny, Fastly) tiene copie dei tuoi file vicino agli utenti e assorbe il traffico. Rispetta il Cache-Control che mandi tu: se mandi intestazioni sbagliate, il CDN servirà in tutto il mondo la versione sbagliata, oppure la pagina di un utente a un altro. Per questo private su tutto ciò che dipende dal login.

nginx · cache e compressione
# in http { } o nel server
gzip on;
gzip_types text/css application/javascript application/json image/svg+xml;   # text/html è sempre incluso

location ~* \.(css|js|woff2|png|jpg|webp|svg)$ {
    add_header Cache-Control "public, max-age=31536000, immutable";
}
location / {
    add_header Cache-Control "no-cache";
}
13 / 15

Sicurezza: le intestazioni che difendono

Cinque righe nel server bloccano intere famiglie di attacchi. Il difficile è non rompere niente mentre le metti.

nginx · le intestazioni di sicurezza
server_tokens off;   # niente versione di nginx nelle risposte

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header X-Content-Type-Options    "nosniff" always;
add_header Referrer-Policy           "strict-origin-when-cross-origin" always;
add_header Permissions-Policy        "camera=(), microphone=(), geolocation=()" always;
add_header Content-Security-Policy   "default-src 'self'; frame-ancestors 'none'" always;
IntestazioneContro cosaAttenzione a
Strict-Transport-SecurityIl primo accesso in http intercettato e dirottatoDopo averla mandata, tornare a http è impossibile per la durata indicata. includeSubDomains vale anche per sottodomini che magari non hanno HTTPS
Content-Security-PolicyXSS: script iniettati che caricano o eseguono codiceLa più potente e la più facile da rompere. Inizia con Content-Security-Policy-Report-Only e guarda la console del browser
frame-ancestors (in CSP)Clickjacking: il tuo sito dentro un iframe invisibileSostituisce il vecchio X-Frame-Options
X-Content-Type-Options: nosniffIl browser che "indovina" il tipo e tratta un file caricato come scriptRichiede Content-Type giusti
Referrer-PolicyPercorsi e parametri che finiscono ad altri sitiQuasi nessuna
🚧 CORS, in una riga

Per default una pagina di sito-a.com non può leggere con JavaScript le risposte di api.sito-b.com. CORS è il modo in cui il server B dice "va bene, a sito-a lo permetto" con Access-Control-Allow-Origin: https://sito-a.com. Lo controlla il browser, non il server: per questo con curl funziona tutto. E l'errore CORS si risolve sul server che risponde, mai sulla pagina che chiede.

✅ Fai

  • HTTPS ovunque, redirect 301 da http, HSTS quando tutto funziona da un po'
  • Cookie di sessione con Secure; HttpOnly; SameSite=Lax
  • always sugli add_header, così valgono anche sulle pagine di errore
  • Limiti di dimensione e di frequenza (limit_req) sui login e sulle API
  • Applicazioni in ascolto solo su 127.0.0.1
  • Controllare le intestazioni dopo ogni modifica, con curl

❌ Non fare

  • Access-Control-Allow-Origin: * su API che usano cookie o token
  • Fidarsi di X-Forwarded-For che non arriva dal tuo proxy
  • Mettere un add_header in una location e aspettarsi che restino quelli del server: in nginx non si sommano, quelli di sopra spariscono
  • Token o password nella query string: finiscono nei log e nella cronologia
  • Pagine di errore con stack trace e versioni in produzione
🔍 Controllare un sitoIntestazioni, cookie, redirect e TLS si controllano con curl -sI, con la scheda Rete degli strumenti per sviluppatori del browser, o con l'analisi HTTP e SSL/TLS di NetForge. Per la configurazione TLS di partenza c'è ssl-config.mozilla.org.
14 / 15

Errori tipici, tradotti

Il codice ti dice di chi è la colpa. Il log di nginx (/var/log/nginx/error.log) ti dice il resto.

Cosa vediCosa vuol direCosa fare
502 Bad GatewayIl proxy non è riuscito a parlare con l'applicazione: è spenta, ascolta su un'altra porta, o il socket non ha i permessi giustisystemctl status dell'applicazione, ss -tlnp, e l'error.log di nginx dice "connection refused" o "permission denied"
504 Gateway TimeoutL'applicazione c'è ma ci mette troppo (in nginx 60 secondi di default)Trova la query lenta. Alzare proxy_read_timeout solo per le operazioni che sono lente di natura
500 Internal Server ErrorL'applicazione è andata in erroreIl log dell'applicazione, non quello di nginx
413 Request Entity Too LargeUpload più grande del limiteclient_max_body_size in nginx, e il limite dell'applicazione (in PHP upload_max_filesize e post_max_size)
400 Request Header Or Cookie Too LargeTroppi cookie o troppo grandiCancella i cookie del sito; lato server large_client_header_buffers, ma prima chiediti chi li ha gonfiati
401 contro 403401: non so chi sei. 403: so chi sei, ma non puoi; o, per i file statici, permessi Unix sbagliati401: credenziali. 403: permessi dell'utente, o ls -l sul file e sulle cartelle sopra
ERR_TOO_MANY_REDIRECTSUn redirect che rimanda a sé stesso. Classico: Cloudflare in modalità "Flexible" parla in http col server, il server rimanda a https, e così viaCloudflare in "Full (strict)". Dietro a un proxy, l'applicazione deve leggere X-Forwarded-Proto
CORS: No 'Access-Control-Allow-Origin' headerIl server dell'API non autorizza la pagina che chiamaAggiungi l'intestazione sul server dell'API, anche sulla risposta a OPTIONS
Mixed contentPagina in HTTPS che carica script o immagini in httpPercorsi in https o relativi; in WordPress l'URL del sito nelle impostazioni
ERR_HTTP2_PROTOCOL_ERRORLa risposta si è interrotta a metà o ha intestazioni non valideerror.log: spesso il disco è pieno (nginx scrive lì le risposte grandi) o l'applicazione manda intestazioni malformate
499 nei log di nginxIl client ha chiuso prima della rispostaSe sono tanti, l'applicazione è lenta e gli utenti si stufano
Il WebSocket si chiude subito o dopo 60 secondiMancano Upgrade e Connection, o il timeout del proxyLa location /ws/ della sezione 11
HTTP/3 configurato ma il browser usa HTTP/2UDP 443 chiuso, o manca Alt-Svcufw allow 443/udp, firewall del provider, e ricarica la pagina due volte: la prima visita è sempre HTTP/2
"Ho cambiato il file ma vedo il vecchio"Cache del browser, del CDN o dell'applicazionecurl -sI e guarda Age, Cache-Control, cf-cache-status. Poi svuota la cache giusta
15 / 15

Da dove continuare

HTTP non si studia, si guarda. Apri curl -v e la scheda Rete del browser, e leggi.

🗺️ Un percorso in quattro tappe

  1. Oggi: curl -sI sui tuoi siti. Codici, redirect, Server, cookie, cache: scoprirai almeno una cosa che non sapevi.
  2. Questa settimana: redirect da http, HTTP/2, intestazioni di sicurezza con always, server_tokens off.
  3. Poi: cache giusta per file statici e HTML, compressione, applicazioni solo in locale dietro al reverse proxy.
  4. Dopo: HTTP/3 con UDP 443 aperto, una CSP prima in Report-Only e poi vera, limiti sui login.
RisorsaCos'è
developer.mozilla.org/docs/Web/HTTPLa documentazione migliore su HTTP, intestazioni, cookie, CORS e cache, anche in italiano
RFC 9110, 9111, 9112, 9113, 9114Semantica, cache, HTTP/1.1, HTTP/2, HTTP/3: le specifiche, leggibili più di quanto sembri
everything.curl.devIl libro di curl, scritto da chi l'ha creato
nginx.org/en/docsTutte le direttive di nginx, con i valori di default
caddyserver.com/docsPer chi vuole HTTPS e HTTP/3 senza scrivere configurazione
ssl-config.mozilla.orgConfigurazioni TLS pronte per nginx, Apache, HAProxy, Caddy
Certificati · DNS · Networking · PHP per SvogliatiLe guide da leggere insieme a questa
📡 L'ultimo consiglio da svogliatoPrima di toccare la configurazione, guarda la risposta: curl -v ti dice protocollo, certificato, codice, intestazioni e redirect in un colpo solo. Nove volte su dieci il problema è scritto lì.