Programma Lezione 114 di 156 · Come decide un browser
Come decide un browser

Siti, origini e "stesso sito"

Perché è importante Ogni regola sulla privacy dentro un browser parte da una domanda: "quale sito è questo?" Cookie, partizioni, SameSite, elenchi di tracker e rilevamento dei rimbalzi archiviano tutto sotto un sito. Se un motore sbaglia questa risposta, un tracker può infilarsi tra due barattoli, o i blog di due sconosciuti possono finire a condividerne uno. In questa lezione scrivi tu la risposta.

Pensa a un condominio. Il nome della via (example) è condiviso da tutti, quindi non ti dice niente su chi abita dove. Il numero dell'appartamento più la via (shopa.example) è una famiglia. Le stanze dentro l'appartamento (cdn.shopa.example, www.shopa.example) appartengono tutte alla stessa famiglia. Un browser vuole la famiglia.

Tre parole che ti servono

Host: la parte con il nome di un URL, come cdn.shopa.example in https://cdn.shopa.example:8443/lib.js. È fatto di etichette separate da punti: cdn, shopa, example.

Origine: schema, host e porta insieme, come https://cdn.shopa.example:8443. È il confine più rigido: https://www.shopa.example e https://shopa.example sono origini diverse.

Sito: la parte dell'host che un proprietario ha registrato, chiamata anche dominio registrabile: shopa.example per tutti gli host qui sopra. Le funzioni per la privacy come il partizionamento e SameSite lavorano sui siti, perché un proprietario controlla comunque ogni host sotto di esso.

La public suffix list

"Prendi le ultime due etichette" funziona per shopa.example, ma fallisce per practice-shop.co.uk: le ultime due etichette sono co.uk, che migliaia di aziende senza legami tra loro condividono. Per questo i browser portano con sé una public suffix list, un lungo file di finali sotto cui chiunque può registrare un nome.

Suffisso pubblico: un finale che nessuno possiede per intero, come com, co.uk o github.io. Il sito è il suffisso pubblico più un'altra etichetta alla sua sinistra.

L'elenco contiene anche suffissi "privati" aggiunti dai servizi di hosting. github.io è nell'elenco, quindi alice.github.io e bob.github.io sono due siti diversi, anche se una sola azienda gestisce i server. Senza quella voce, il blog di Alice potrebbe impostare un cookie che riceve il blog di Bob. Nel nostro mondo di esercitazione, pages.example ha lo stesso ruolo.

Le regole, come le applica il browser:

  1. Metti l'host in minuscolo, togli la porta, e togli un punto finale (shopa.example. è un modo valido di scrivere shopa.example).
  2. Trova il finale più lungo dell'host che è nell'elenco. Per a.b.practice-charity.org.uk, sia uk sia org.uk sono nell'elenco; vince org.uk.
  3. Il sito è quel finale più un'etichetta alla sua sinistra.
  4. Se l'host è un suffisso pubblico (come github.io da solo), il sito è l'host stesso.
  5. Se nessun finale dell'elenco corrisponde, considera l'ultima etichetta come suffisso. Quindi dev.app.zz ha come sito app.zz.

Gli elenchi veri hanno anche alcune regole con caratteri jolly ed eccezioni, e un indirizzo IP è un sito a sé. Anche quelli li gestiscono i motori; qui puoi tralasciarli.

Same-site con lo schema

I browser più vecchi confrontavano solo il dominio registrabile, quindi http://shopa.example e https://shopa.example erano "stesso sito". Gli standard web di oggi definiscono lo stesso sito come schemeful: lo schema fa parte del sito, quindi la pagina in semplice http conta come un sito diverso e non affidabile. Conta perché chiunque sul Wi-Fi del bar può manomettere una pagina http, e quella non dovrebbe poter prendere in prestito i cookie SameSite del sito https.

ABStessa origine?Stesso sito?
https://www.shopa.examplehttps://shopa.exampleNoSì
https://alice.github.iohttps://bob.github.ioNoNo
http://shopa.examplehttps://shopa.exampleNoNo (con lo schema)
https://shopa.example:8443https://shopa.exampleNoSì (le porte non contano)

Il Python che ti serve

Oltre a variabili, if, liste e funzioni, ti servono quattro piccoli strumenti. Ognuno è mostrato qui con ciò che stampa.

from urllib.parse import urlsplit       # part of Python's standard library

parts = urlsplit("https://CDN.ShopA.example:8443/lib.js")
print(parts.scheme)      # https
print(parts.hostname)    # cdn.shopa.example   (already lower case, port removed)

labels = "cdn.shopa.example".split(".")   # cut a string at every dot
print(labels)            # ['cdn', 'shopa', 'example']
print(labels[1:])        # ['shopa', 'example']   (a slice: from position 1 to the end)
print(".".join(labels[1:]))   # shopa.example     (glue a list back together with dots)

print("shopa.example.".rstrip("."))   # shopa.example   (remove dots from the right end)
print("co.uk" in {"co.uk", "uk"})     # True   (a set answers "is this in it?" quickly)

for i in range(3):       # i takes the values 0, 1, 2
    print(i)

Un bel trucco: se provi i finali dal più lungo (labels[0:]) al più corto, il primo che trovi nell'elenco è automaticamente la corrispondenza più lunga.

Provalo Prima di scrivere codice, risolvine tre a mano: www.alice.pages.example, news.practice-paper.co.uk e zz. Dovresti ottenere alice.pages.example, practice-paper.co.uk e zz.

In altri linguaggi

I progetti veri usano una copia mantenuta della public suffix list invece di una propria:

// JavaScript (the tldts package)
import { getDomain } from "tldts";
getDomain("https://cdn.shopa.co.uk/lib.js");   // "shopa.co.uk"
getDomain("alice.github.io", { allowPrivateDomains: true });   // "alice.github.io" (private suffixes are off by default)
new URL("https://CDN.ShopA.example:8443/").hostname;   // "cdn.shopa.example"

// Go (golang.org/x/net/publicsuffix)
site, err := publicsuffix.EffectiveTLDPlusOne("alice.github.io")   // "alice.github.io", nil

// Rust (the psl crate)
let site = psl::domain_str("www.shopa.co.uk");   // Some("shopa.co.uk")

// C# (built in: host only; use a public-suffix package such as Nager.PublicSuffix for the site)
var host = new Uri("https://CDN.ShopA.example:8443/").Host;   // "cdn.shopa.example"

Un equivoco comune

"Stesso sito significa stessa origine, detto in modo più vago." Sono confini diversi. L'origine è ciò che JavaScript usa per tenere separate le pagine (chi può leggere i dati di chi). Il sito è ciò che le funzioni per la privacy usano per decidere che cosa conta come una sola parte (quali cookie viaggiano, quale barattolo riceve un contenuto incorporato). www.shopa.example e shopa.example sono origini diverse ma un solo sito.

Riepilogo

  • Un sito è il suffisso pubblico più un'etichetta; la public suffix list dice dove finiscono i suffissi.
  • Vince il suffisso più lungo dell'elenco, e i suffissi privati come github.io fanno di ogni sotto-sito di un utente un sito a sé.
  • Lo stesso sito con lo schema conta lo schema, quindi le versioni http e https di un dominio sono siti diversi.
  • Le origini tengono separate le pagine; i siti decidono quale parte è quale.
Tocca a te

Scrivi quattro funzioni, poi usale sui 30 URL di esercitazione.

  1. host_from_url(url): l'host di url, in minuscolo, senza porta e senza punto finale.
  2. site_for(url, suffixes): il sito di url, usando il set suffixes come public suffix list e le cinque regole della lezione (il suffisso più lungo dell'elenco più un'etichetta; un host che è esso stesso un suffisso è un sito a sé; se niente corrisponde, l'ultima etichetta è il suffisso).
  3. schemeful_site(url, suffixes): lo schema, poi ://, poi il sito, per esempio "https://shopa.example".
  4. is_same_site(a, b, suffixes): True quando i due URL hanno lo stesso sito con lo schema.
Infine imposta SITES a una lista con il sito di ogni URL in PRACTICE_URLS, in ordine, usando PRACTICE_SUFFIXES. Scrivi tu la logica: non usare site_of o same_site da watched.

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.