Programma Lezione 105 di 156 · Impronte di rete
Impronte di rete

HTTP/2 e impronte delle intestazioni

Perché è importante Anche con un'impronta TLS identica, i primissimi messaggi HTTP/2 che invia un browser, e l'ordine delle sue intestazioni, cambiano da un browser all'altro. I sistemi di rilevamento lo usano per controllare se un client è davvero il browser che il suo user agent dichiara. Distinguerai tre browser simulati, e smaschererai uno script che finge di esserne uno.

Due persone possono indossare la stessa divisa ed essere comunque distinte da come compilano un modulo: l'ordine in cui scrivono le cose, quali caselle spuntano per prime. Le aperture HTTP/2 sono un modulo che ogni browser compila a modo suo.

HTTP/2: una versione più recente di HTTP che i browser usano oggi per la maggior parte dei siti HTTPS, insieme al ancora più recente HTTP/3. Invia le richieste come piccoli messaggi binari chiamati frame su una sola connessione, e ha bisogno di ALPN h2 nell'handshake.

Frame: un messaggio HTTP/2. Un frame SETTINGS annuncia dei limiti, un frame WINDOW_UPDATE dice quanti dati il browser è pronto a ricevere, e un frame HEADERS porta le intestazioni di una richiesta.

Che cosa rivela l'apertura

  • SETTINGS. Un elenco di coppie (id, valore), come (1, 32768) per la dimensione di una tabella o (4, 4194304) per la dimensione di una finestra. Quali impostazioni compaiono, i loro valori e il loro ordine sono scelti dal codice del browser.
  • WINDOW_UPDATE. Un numero: quanti dati in più il browser è disposto a ricevere.
  • Priorità. Come il browser dice quali richieste contano di più. I browser lo fanno in modo diverso.
  • Ordine delle pseudo-intestazioni. Ogni richiesta HTTP/2 inizia con quattro intestazioni speciali: :method, :authority (il sito), :scheme e :path. Il protocollo non fissa il loro ordine, quindi ogni browser ne sceglie uno.
  • Ordine delle intestazioni. Anche le intestazioni normali, come user-agent e accept, arrivano in un ordine specifico del browser.

Una riga da confrontare

Un modo comune per annotarlo è una riga di testo con quattro parti separate da |:

1:32768;3:250;4:4194304;6:131072|10420225|0|m,s,a,p
 settings (id:value;...)         window  prio pseudo-header initials

Le iniziali sono la prima lettera dopo i due punti: :method diventa m.

Ordine e maiuscole delle intestazioni: nascosti in bella vista

In HTTP/2, i nomi delle intestazioni devono essere inviati in minuscolo. Nel più vecchio HTTP/1.1, le maiuscole dipendevano da chi inviava, quindi User-Agent contro user-agent poteva già da solo distinguere i client. L'ordine funziona in entrambi. Nel nostro mondo, Brook e Cobalt sono costruiti sullo stesso motore immaginario: la loro riga delle impostazioni HTTP/2 è identica, e cambia solo l'ordine delle intestazioni. Quindi ti servono entrambe per distinguerli.

Dichiarazione dello user agent: l'intestazione user-agent è solo testo che il client scrive su di sé. Qualsiasi programma può copiarlo. I dettagli dell'handshake e di HTTP/2 sono più difficili da falsificare per caso, quindi i rilevatori li confrontano con la dichiarazione.

Il mondo di esercitazione ti dà h2_connection(name, seed) per Brook, Cobalt e Fennel, più "Toolkit": uno script immaginario che copia lo user agent di Brook ma apre HTTP/2 a modo suo. Ogni connessione è un dict con settings, window_update, priority, pseudo_headers, headers (una lista di coppie (name, value)) e user_agent. Tutti i valori sono immaginari.

Per unire coppie in un testo: ";".join("%d:%d" % (k, v) for k, v in pairs). Per prendere il nome prima della barra in "Brook/31.0": ua.split("/")[0].

In altri linguaggi

Costruire la parte delle impostazioni della riga altrove:

// JavaScript
const settings = conn.settings.map(([k, v]) => `${k}:${v}`).join(";");
const pseudo = conn.pseudo_headers.map(h => h[1]).join(",");
const line = [settings, conn.window_update, conn.priority, pseudo].join("|");
// Go
parts := []string{}
for _, s := range conn.Settings {
    parts = append(parts, fmt.Sprintf("%d:%d", s.ID, s.Value))
}
settings := strings.Join(parts, ";")
// C#
var settings = string.Join(";", conn.Settings.Select(s => $"{s.Id}:{s.Value}"));

La difesa

Per gli utenti comuni, la protezione è la stessa del TLS: usa un browser comune e aggiornato, così la tua apertura HTTP/2 coincide con quella di milioni di altri. Per chi costruisce siti: se usi questi segnali per combattere le frodi, usali per aggiungere attrito (come un secondo controllo), mai come prova di chi è una persona, e mai per profilare le persone.

Riepilogo

  • L'apertura HTTP/2 di un browser (impostazioni, dimensione della finestra, priorità, ordine delle pseudo-intestazioni) è un'impronta.
  • L'ordine delle intestazioni, e in HTTP/1.1 le loro maiuscole, aggiungono altro.
  • Due browser sullo stesso motore possono condividere le impostazioni ed essere diversi solo nell'ordine delle intestazioni.
  • I rilevatori confrontano questi segnali con la dichiarazione dello user agent per scoprire i client che non sono ciò che dicono.
Tocca a te

Scrivi sei funzioni brevi:

  1. h2_fingerprint(conn): le impostazioni come id:value unite con ;, poi |, il window_update, |, la priority, |, e le iniziali delle pseudo-intestazioni (il carattere dopo i due punti) unite con ,.
  2. header_order(conn): i nomi delle intestazioni, in ordine, uniti con ,.
  3. full_fingerprint(conn): h2_fingerprint(conn) + "|" + header_order(conn).
  4. learn(training): da una lista di coppie (name, conn), restituisci un dict che associa ogni full_fingerprint al suo nome.
  5. identify(conn, known): il nome in known per l'impronta completa di questa connessione, oppure "unknown".
  6. claim_matches(conn, known): True se identify dà lo stesso nome dichiarato dallo user agent (il testo prima di / in conn["user_agent"]), altrimenti False.
Il rapporto in fondo è già scritto per te.

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.