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:
- Metti l'host in minuscolo, togli la porta, e togli un punto finale (
shopa.example.è un modo valido di scrivereshopa.example). - Trova il finale più lungo dell'host che è nell'elenco. Per
a.b.practice-charity.org.uk, siauksiaorg.uksono nell'elenco; vinceorg.uk. - Il sito è quel finale più un'etichetta alla sua sinistra.
- Se l'host è un suffisso pubblico (come
github.ioda solo), il sito è l'host stesso. - Se nessun finale dell'elenco corrisponde, considera l'ultima etichetta come suffisso. Quindi
dev.app.zzha come sitoapp.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.
| A | B | Stessa origine? | Stesso sito? |
|---|---|---|---|
https://www.shopa.example | https://shopa.example | No | Sì |
https://alice.github.io | https://bob.github.io | No | No |
http://shopa.example | https://shopa.example | No | No (con lo schema) |
https://shopa.example:8443 | https://shopa.example | No | Sì (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.iofanno di ogni sotto-sito di un utente un sito a sé. - Lo stesso sito con lo schema conta lo schema, quindi le versioni
httpehttpsdi un dominio sono siti diversi. - Le origini tengono separate le pagine; i siti decidono quale parte è quale.
Scrivi quattro funzioni, poi usale sui 30 URL di esercitazione.
host_from_url(url): l'host diurl, in minuscolo, senza porta e senza punto finale.site_for(url, suffixes): il sito diurl, usando il setsuffixescome 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).schemeful_site(url, suffixes): lo schema, poi://, poi il sito, per esempio"https://shopa.example".is_same_site(a, b, suffixes):Truequando i due URL hanno lo stesso sito con lo schema.
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.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.