Le regole di Storage Access
Perché è importante Il partizionamento ferma i tracker, ma ti fa anche uscire da contenuti incorporati che vuoi davvero: un riquadro dei commenti, un video per cui paghi, un pulsante di accesso. Se il motore non offre una strada per tornare indietro, le persone spengono la protezione. La Storage Access API è quella strada, e le sue regole decidono se aiuta te o un tracker. In questo laboratorio scrivi tu quelle regole.
Pensa a una tessera della biblioteca. Ti sei iscritto in biblioteca, quindi la tessera lì funziona. Ora sei a casa di un amico, e la regola di casa è che le tessere esterne non valgono dentro. Puoi comunque usare la tua tessera lì se sei tu a consegnarla apposta, la biblioteca è una a cui ti sei davvero iscritto, e il permesso vale solo per questa casa, per un po'.
Nel mondo di esercitazione, talk.example è un servizio di commenti. Sam fa l'accesso su talk.example stesso. Il suo widget è incorporato su news.example. Con il partizionamento attivo, il widget sul sito di notizie riceve un barattolo di cookie nuovo e vuoto, quindi mostra "accedi per pubblicare" anche se Sam ha fatto l'accesso.
Frame incorporato (iframe): una pagina mostrata dentro un'altra pagina, come una finestra in un muro. Il widget dei commenti è un frame di talk.example dentro news.example.
Gesto dell'utente: un vero clic, tocco o pressione di un tasto della persona, un attimo prima. I browser la chiamano user activation. Uno script che gira da solo non può fingerne una.
Permesso: la nota del browser secondo cui un sito incorporato può usare i propri cookie dentro un sito di primo livello, fino a una scadenza.
Com'è l'API vera
Dentro il frame, uno script può chiedere document.hasStorageAccess() (ho i miei cookie?) e, dopo un clic, document.requestStorageAccess() (per favore dammeli). Il browser controlla le sue regole, può mostrare una richiesta alla persona, e poi risponde sì o no. L'API è disponibile in Safari, Firefox e Chrome (Chrome dalla versione 119). In Chrome conta solo per chi blocca i cookie di terze parti, perché Chrome li invia ancora per impostazione predefinita, e la funzione Related Website Sets che un tempo concedeva l'accesso automaticamente è stata ritirata (verificato a ottobre 2026). La lezione "La Storage Access API" nel modulo precedente ha spiegato in che cosa differiscono i motori; qui costruisci le regole di base.
Le regole del nostro motore
I motori veri differiscono nei dettagli (richieste, limiti di tempo, controlli extra). Il nostro motore di esercitazione usa quattro regole semplici, controllate in ordine, che catturano le idee che hanno in comune:
- Se il sito del frame è il sito di primo livello, di' di sì: ha già il suo storage.
- Se non c'è stato un gesto dell'utente, di' di no. Un widget non può chiedere in silenzio mentre la pagina si carica.
- Se la persona non ha mai aperto direttamente il sito del frame (come pagina di primo livello), di' di no. Questo impedisce a un frame pubblicitario che non hai mai scelto di ottenere l'accesso solo perché ci hai fatto clic.
- Altrimenti di' di sì, e registra un permesso per esattamente questa coppia,
(frame_site, top_site), che scade traGRANT_SECONDS(30 giorni).
Controllare l'accesso dopo è più semplice: stesso sito significa sì; altrimenti cerca la coppia tra i permessi e di' di sì solo se c'è e non è ancora scaduta.
Pezzi di Python che userai
grants = {} # an empty dict
grants[("talk.example", "news.example")] = 5000 # key is a tuple, value an expiry time
expiry = grants.get(("talk.example", "blog.example"))
print(expiry) # None: .get gives None when the key is missing
print(expiry is not None and 4000 < 5000) # False, because expiry is Nonex is not None chiede "c'è un valore?". Metterlo per primo in un and conta: se è False, Python si ferma e non confronta mai None con un numero, il che sarebbe un errore.
Nel mondo di esercitazione il tempo è un conteggio di secondi (world.now), quindi "tra 30 giorni" è semplicemente now + 30 * 24 * 3600, che il modulo ti dà come GRANT_SECONDS.
La storia che le tue regole devono superare
widget_story(request_fn, access_fn) esegue sei passi sull'AccessBrowser di esercitazione e restituisce una lista di coppie (step, result):
| Passo | Il widget dovrebbe risultare con l'accesso fatto? |
|---|---|
| 1. Sam apre news.example (ha fatto l'accesso su talk.example in precedenza) | No: partizionato |
| 2. Il widget chiede mentre la pagina si carica, senza clic | No: nessun gesto |
| 3. Sam fa clic su "Accedi per commentare" | Sì: concesso per questa coppia |
| 4. Sam apre recipes.example con lo stesso widget | No: il permesso era solo per news.example |
| 5. Il frame pubblicitario di AdCo chiede dopo un clic sulla pubblicità | No: Sam non ha mai aperto adco.example |
| 6. 31 giorni dopo, di nuovo news.example | No: il permesso è scaduto |
Il modulo tiene anche EXPECTED_STORY, la lista delle risposte giuste, così puoi confrontare man mano.
Un equivoco comune
"Quando un widget ottiene l'accesso, può seguirmi ovunque." Non con queste regole. Il permesso vale per una coppia di siti. Lo stesso widget su un altro sito riparte con un barattolo vuoto, e il permesso scade. È questa regola della coppia che impedisce all'API di diventare un nuovo modo per tracciare.
In altri linguaggi
Il lato del widget, nel JavaScript che eseguirebbe un vero widget di commenti:
// Inside the talk.example frame, on news.example
signInButton.addEventListener("click", async () => { // a real click: a user gesture
if (!(await document.hasStorageAccess())) {
try {
await document.requestStorageAccess(); // the browser applies its rules
} catch {
showMessage("Open talk.example to sign in first"); // refused
return;
}
}
loadComments(); // requests now carry talk.example's own cookie
});Il lato del motore, il controllo dell'accesso, in Rust:
use std::collections::HashMap;
fn has_storage_access(grants: &HashMap<(String, String), u64>,
frame_site: &str, top_site: &str, now: u64) -> bool {
if frame_site == top_site { return true; }
match grants.get(&(frame_site.to_string(), top_site.to_string())) {
Some(expiry) => now < *expiry,
None => false,
}
}Riepilogo
- Il partizionamento dà ai frame incorporati un barattolo vuoto; la Storage Access API permette a un widget voluto di chiedere indietro i propri cookie.
- Le buone regole richiedono un clic vero, un sito che la persona ha davvero usato, e un permesso per una coppia di siti che scade.
- La regola della coppia è ciò che impedisce all'API di diventare uno strumento di tracciamento.
- L'API è disponibile in Safari, Firefox e Chrome (Chrome 119), verificato a ottobre 2026.
Scrivi request_storage_access(grants, frame_site, top_site, user_gesture, visited_before, now) usando le quattro regole in ordine: lo stesso sito restituisce True; senza user_gesture restituisce False; se non visited_before restituisce False; altrimenti imposta grants[(frame_site, top_site)] = now + GRANT_SECONDS e restituisci True. Scrivi has_storage_access(grants, frame_site, top_site, now): True per lo stesso sito, altrimenti True solo quando la coppia è in grants e now è prima della sua scadenza. Poi imposta story = widget_story(request_storage_access, has_storage_access).
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.