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:
- Coloque o host em minúsculas, tire a porta e tire um ponto final (
shopa.example.é um jeito válido de escrevershopa.example). - Encontre a terminação mais longa do host que está na lista. Para
a.b.practice-charity.org.uk, tantoukquantoorg.ukestão listados;org.ukvence. - O site é essa terminação mais um rótulo à esquerda dela.
- Se o host for um sufixo público (como
github.iosozinho), o site é o próprio host. - Se nenhuma terminação listada corresponder, trate o último rótulo como sufixo. Então
dev.app.zztem o siteapp.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.
| A | B | Mesma origem? | Mesmo site? |
|---|---|---|---|
https://www.shopa.example | https://shopa.example | Não | Sim |
https://alice.github.io | https://bob.github.io | Não | Não |
http://shopa.example | https://shopa.example | Não | Não (com esquema) |
https://shopa.example:8443 | https://shopa.example | Não | Sim (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.iofazem do subsite de cada usuário um site próprio. - O same-site com esquema conta o esquema, então as versões
httpehttpsde um domínio são sites diferentes. - As origens mantêm as páginas separadas; os sites decidem qual parte é qual.
Escreva quatro funções e depois use-as nas 30 URLs de prática.
host_from_url(url): o host deurl, em minúsculas, sem porta e sem ponto final.site_for(url, suffixes): o site deurl, usando o conjuntosuffixescomo 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).schemeful_site(url, suffixes): o esquema, depois://, depois o site, por exemplo"https://shopa.example".is_same_site(a, b, suffixes):Truequando as duas URLs têm o mesmo site com esquema.
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.
Este navegador está bloqueando cookies para learn.floati.life, então as lições que você terminou aqui não podem abrir em ordem. Permita cookies para este site e recarregue.