Conteúdo do curso Lição 114 de 156 · Como um navegador decide
Como um navegador decide

Sites, origens e "mesmo site"

Por que isso importa Toda regra de privacidade dentro de um navegador começa com uma pergunta: "que site é este?" Cookies, partições, SameSite, listas de rastreadores e a detecção de redirecionamentos arquivam tudo sob um site. Se um motor errar essa resposta, um rastreador pode escapar entre dois potes, ou os blogs de dois desconhecidos podem acabar compartilhando um. Nesta lição você mesmo escreve a resposta.

Pense num prédio de apartamentos. O endereço da rua (example) é compartilhado por todo mundo, então não diz nada sobre quem mora onde. O número do apartamento mais a rua (shopa.example) é uma residência. Os cômodos dentro do apartamento (cdn.shopa.example, www.shopa.example) pertencem todos a essa mesma residência. Um navegador quer saber a residência.

Três palavras de que você precisa

Host: a parte do nome de uma URL, como cdn.shopa.example em https://cdn.shopa.example:8443/lib.js. Ele é feito de rótulos separados por pontos: cdn, shopa, example.

Origem: esquema, host e porta juntos, como https://cdn.shopa.example:8443. É a fronteira mais rígida: https://www.shopa.example e https://shopa.example são origens diferentes.

Site: a parte do host que um dono registrou, também chamada de domínio registrável: shopa.example para todos os hosts acima. Recursos de privacidade como o particionamento e o SameSite funcionam em sites, porque um único dono controla todos os hosts abaixo dele de qualquer jeito.

A lista de sufixos públicos

"Pegue os dois últimos rótulos" funciona para shopa.example, mas falha para practice-shop.co.uk: os dois últimos rótulos são co.uk, que milhares de empresas sem relação compartilham. Então os navegadores levam uma lista de sufixos públicos, um arquivo longo de terminações sob as quais qualquer um pode registrar um nome.

Sufixo público: uma terminação que ninguém possui por inteiro, como com, co.uk ou github.io. O site é o sufixo público mais um rótulo a mais à esquerda dele.

A lista também tem sufixos "privados" adicionados por serviços de hospedagem. github.io está nela, então alice.github.io e bob.github.io são dois sites diferentes, mesmo que uma única empresa rode os servidores. Sem essa entrada, o blog de Alice poderia definir um cookie que o blog de Bob receberia. No nosso mundo de prática, pages.example faz o mesmo papel.

As regras, como o navegador as aplica:

  1. Coloque o host em minúsculas, tire a porta e tire um ponto final (shopa.example. é um jeito válido de escrever shopa.example).
  2. Encontre a terminação mais longa do host que está na lista. Para a.b.practice-charity.org.uk, tanto uk quanto org.uk estão listados; org.uk vence.
  3. O site é essa terminação mais um rótulo à esquerda dela.
  4. Se o host for um sufixo público (como github.io sozinho), o site é o próprio host.
  5. Se nenhuma terminação listada corresponder, trate o último rótulo como sufixo. Então dev.app.zz tem o site app.zz.

As listas reais também têm algumas regras com curinga e de exceção, e um endereço IP é um site por si só. Os motores tratam isso também; você pode deixar de fora aqui.

Same-site com esquema

Navegadores mais antigos comparavam só o domínio registrável, então http://shopa.example e https://shopa.example eram "o mesmo site". Os padrões da web de hoje definem same-site como com esquema: o esquema faz parte do site, então a página em http simples conta como um site diferente e não confiável. Isso importa porque qualquer um no Wi-Fi do café consegue adulterar uma página http, e ela não deveria poder pegar emprestados os cookies SameSite do site https.

ABMesma origem?Mesmo site?
https://www.shopa.examplehttps://shopa.exampleNãoSim
https://alice.github.iohttps://bob.github.ioNãoNão
http://shopa.examplehttps://shopa.exampleNãoNão (com esquema)
https://shopa.example:8443https://shopa.exampleNãoSim (as portas não contam)

O Python de que você precisa

Além de variáveis, if, listas e funções, você precisa de quatro pequenas ferramentas. Cada uma aparece aqui com o que ela imprime.

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)

Um truque prático: se você testar as terminações da mais longa (labels[0:]) para a mais curta, a primeira que você encontrar na lista é automaticamente a correspondência mais longa.

Experimente Antes de escrever código, faça três à mão: www.alice.pages.example, news.practice-paper.co.uk e zz. Você deveria obter alice.pages.example, practice-paper.co.uk e zz.

Em outras linguagens

Projetos reais usam uma cópia mantida da lista de sufixos públicos em vez de uma própria:

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

Um equívoco comum

"Mesmo site significa mesma origem, só que dito de forma mais solta." São fronteiras diferentes. A origem é o que o JavaScript usa para manter as páginas separadas (quem pode ler os dados de quem). O site é o que os recursos de privacidade usam para decidir o que conta como uma parte (os cookies de quem viajam, qual pote um conteúdo incorporado recebe). www.shopa.example e shopa.example são origens diferentes, mas um só site.

Resumo

  • Um site é o sufixo público mais um rótulo; a lista de sufixos públicos diz onde os sufixos terminam.
  • O sufixo listado mais longo vence, e sufixos privados como github.io fazem do subsite de cada usuário um site próprio.
  • O same-site com esquema conta o esquema, então as versões http e https de um domínio são sites diferentes.
  • As origens mantêm as páginas separadas; os sites decidem qual parte é qual.
Sua vez

Escreva quatro funções e depois use-as nas 30 URLs de prática.

  1. host_from_url(url): o host de url, em minúsculas, sem porta e sem ponto final.
  2. site_for(url, suffixes): o site de url, usando o conjunto suffixes como lista de sufixos públicos e as cinco regras da lição (o sufixo listado mais longo mais um rótulo; um host que é ele mesmo um sufixo é o próprio site; se nada corresponder, o último rótulo é o sufixo).
  3. schemeful_site(url, suffixes): o esquema, depois ://, depois o site, por exemplo "https://shopa.example".
  4. is_same_site(a, b, suffixes): True quando as duas URLs têm o mesmo site com esquema.
Por fim, defina SITES como uma lista com o site de cada URL de PRACTICE_URLS, em ordem, usando PRACTICE_SUFFIXES. Escreva a lógica você mesmo: não use site_of nem same_site de watched.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.