Programma Les 114 van 156 · Hoe een browser beslist
Hoe een browser beslist

Sites, oorsprong en "same site

Waarom dit ertoe doet Elke privacyregel in een browser begint met één vraag: "welke site is dit?" Cookies, partitions, SameSite, tracker lists en bounce detection plaatsen alles onder een site. Als een engine dit antwoord fout heeft, kan een tracker tussen twee potten glippen, of kunnen twee blogs van vreemden één delen. In deze les schrijf je het antwoord zelf.

Denk aan een appartementencomplex. Het straatadres (example) wordt door iedereen gedeeld, dus het vertelt je niets over wie waar woont. Het appartementnummer plus de straat (shopa.example) is één huishouden. Kamers in het appartement (cdn.shopa.example, www.shopa.example) behoren allemaal tot datzelfde huishouden. Een browser wil het huishouden.

Drie woorden die je nodig hebt

Host: het naamgedeelte van een URL, zoals cdn.shopa.example in https://cdn.shopa.example:8443/lib.js. Het bestaat uit labels gescheiden door punten: cdn, shopa, example.

Origin: scheme, host en port samen, zoals https://cdn.shopa.example:8443. Het is de strengste grens: https://www.shopa.example en https://shopa.example zijn verschillende origins.

Site: het deel van de host dat door één eigenaar is geregistreerd, ook wel de registrable domain genoemd: shopa.example voor alle hosts hierboven. Privacyfuncties zoals partitioning en SameSite werken op sites, omdat één eigenaar toch elke host daaronder beheert.

De publieke suffix lijst

"Take the last two labels" werkt voor shopa.example, maar faalt voor practice-shop.co.uk: de laatste twee labels zijn co.uk, die duizenden niet-gerelateerde bedrijven delen. Daarom hebben browsers een public suffix list, een lang bestand van eindingen waaronder iedereen een naam kan registreren.

Publiek suffix: een eindstuk dat niemand als geheel bezit, zoals com, co.uk of github.io. De site is het publieke suffix plus one meer label aan de linkerkant.

De lijst bevat ook "private" suffixen die door hostingdiensten zijn toegevoegd. github.io staat erop, dus alice.github.io en bob.github.io zijn two different sites, ook al draait één bedrijf de servers. Zonder die vermelding zou de blog van Alice een cookie kunnen instellen die de blog van Bob ontvangt. In onze praktijkwereld speelt pages.example dezelfde rol.

De regels, zoals de browser ze toepast:

  1. Maak de host kleine letters, verwijder de poort en verwijder een afsluitende punt (shopa.example. is een geldige manier om shopa.example te schrijven).
  2. Zoek de langsteeind van de host die op de lijst staat. Voor a.b.practice-charity.org.uk staan zowel uk als org.uk op de lijst; org.uk wint.
  3. De site is dat einde plus één label links ervan.
  4. Als de host is een publiek suffix (zoals plain github.io), dan is de site de host zelf.
  5. Als geen van de vermelde eindingen overeenkomt, behandel dan het laatste label als het achtervoegsel. Dus dev.app.zz heeft site app.zz.

Echte lijsten hebben ook een paar wildcard en uitzonderingsregels, en een IP-adres is zijn eigen site. Engines behandelen die ook; je kunt ze hier weglaten.

Schemeful same-site

Oudere browsers vergeleken alleen het registreerbare domein, dus waren http://shopa.example en https://shopa.example "same site". De huidige webstandaarden definiëren same-site als schemeful: het schema is onderdeel van de site, dus de gewone-http pagina telt als een andere, onbetrouwbare site. Waarom dit ertoe doet is dat iedereen op je café Wi-Fi een http pagina kan manipuleren, en deze zou de SameSite cookies van de https site niet mogen lenen.

ABZelfde herkomst?Zelfde site?
https://www.shopa.examplehttps://shopa.exampleNoJa
https://alice.github.iohttps://bob.github.ioNoNo
http://shopa.examplehttps://shopa.exampleNoNo (schemeful)
https://shopa.example:8443https://shopa.exampleNoJa (poorten tellen niet)

De Python die je nodig hebt

Naast variabelen, if, lijsten en functies heb je vier kleine hulpmiddelen nodig. Elk wordt hier getoond met wat het print.

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)

A slimme truc: als je de eindes van de longest (labels[0:]) naar de kortste probeert, is de eerste die je op de lijst vindt automatisch de langste match.

Probeer het Voordat je code schrijft, werk je drie keer met de hand: www.alice.pages.example, news.practice-paper.co.uk en zz. Je moet alice.pages.example, practice-paper.co.uk en zz krijgen.

In andere talen

Echte projecten gebruiken een bijgehouden kopie van de publieke suffix lijst in plaats van hun eigen:

// 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"

A veelvoorkomende misvatting

"Same site betekent same origin, maar met minder strenge woorden." Het zijn verschillende grenzen. Origin is wat JavaScript gebruikt om pagina's gescheiden te houden (wie mag de data van wie lezen). Site is wat privacyfuncties gebruiken om te beslissen wat als één partij telt (welke cookies reizen mee, bij welk potje een embed terechtkomt). www.shopa.example en shopa.example zijn verschillende origins maar één site.

Samenvatting

  • A site is het publieke suffix plus één label; de publieke suffix lijst zegt waar suffixen eindigen.
  • Het langste vermelde suffix wint, en private suffixes zoals github.io maken de subsite van elke gebruiker een eigen site.
  • Schemeful same-site telt het schema, dus http en https versies van een domein zijn verschillende sites.
  • Origins houden pagina's gescheiden; sites beslissen welke partij welke is.
Jij bent aan de beurt

Schrijf vier functies, gebruik ze dan op de 30 oefen-URL's.

  1. host_from_url(url): de host van url, kleine letters, zonder poort en zonder punt aan het einde.
  2. site_for(url, suffixes): de site van url, waarbij de set suffixes als de publieke suffixlijst wordt gebruikt en de vijf regels uit de les (het langste vermelde suffix plus één label; een host die zelf een suffix is, is zijn eigen site; als niets overeenkomt, is het laatste label de suffix).
  3. schemeful_site(url, suffixes): het schema, dan ://, dan de site, bijvoorbeeld "https://shopa.example".
  4. is_same_site(a, b, suffixes): True wanneer de twee URLs dezelfde schemeful site hebben.
Stel SITES ten slotte in op een lijst met de site van elke URL in PRACTICE_URLS, in volgorde, met gebruik van PRACTICE_SUFFIXES. Schrijf de logica zelf: gebruik geen site_of of same_site uit watched.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.