Programma Lezione 46 di 156 · Costruisci un blocker
Costruisci un blocker

Come funzionano le blocklist

Perché è importante Quasi tutto il blocco dei tracker nel mondo oggi, nelle estensioni e nei browser, parte da un semplice file di testo pieno di regole. Quando sai leggere quel file, puoi vedere esattamente che cosa un blocker fermerà e che cosa no, e perché a volte un sito si rompe.

Un buttafuori con un elenco

Immagina un buttafuori alla porta di un locale con un elenco stampato: "non far entrare queste persone", più una breve nota: "tranne questi clienti abituali". Il buttafuori non giudica nessuno; controlla solo i nomi sull'elenco.

Un blocker funziona allo stesso modo. Ogni volta che una pagina chiede qualcosa (uno script, un'immagine, un pixel), il blocker controlla l'indirizzo contro il suo elenco e dice permetti o blocca.

Elenco di filtri: un file di testo con regole, una per riga, che dice a un blocker quali richieste fermare. La famiglia più nota è EasyList, scritta nella sintassi di Adblock Plus che quasi tutti i blocker capiscono.

Richiesta: una domanda del tuo browser a un server, come "mandami https://adco.example/tag.js". Una pagina di solito fa molte richieste.

La sintassi, un piccolo sottoinsieme di esercitazione

Gli elenchi veri hanno decine di migliaia di righe e molte funzioni extra. Noi usiamo un piccolo elenco di esercitazione inventato con la stessa sintassi di base. Eccolo (si trova in watched.leg2b_blocker.PRACTICE_LIST):

[Adblock Plus 2.0]
! Title: Watched Practice List (made up for the course)

||adco.example^
||metrics.example^$third-party
||trackmore.example^
/p.gif?
*/collect?*cid=
/beacon/*/hit$third-party

! Exceptions: things that look like trackers but are needed
@@||cdn.example^
@@/assets/p.gif?

! Cosmetic rules (hide page parts). A network blocker ignores these.
##.ad-banner
shopc.example##.sponsored
La riga è cosìSignificato
! ... o [...]Un commento o un'intestazione. Saltala.
||adco.example^Una regola di dominio: blocca adco.example e ogni sottodominio, come img.adco.example. Il ^ segna la fine del nome dell'host.
/p.gif?Una regola di pattern: blocca ogni indirizzo che contiene questo testo. Un * all'interno significa "qualsiasi carattere qui".
@@...Un'eccezione: permettilo, anche se corrisponde anche una regola di blocco.
...$third-partyUn'opzione: applica questa regola solo quando la richiesta va a un sito diverso dalla pagina su cui sei.
##.ad-bannerUna regola cosmetica: nasconde una parte della pagina. Non ferma mai una richiesta, quindi un blocker di rete la salta.

Terza parte: una richiesta verso un sito diverso da quello nella tua barra degli indirizzi. Su shopa.example, una richiesta a adco.example è di terza parte; una a shopa.example stesso è di prima parte.

Trasformare una riga in dati

I programmi non vogliono rileggere il testo per ogni richiesta. Quindi il primo lavoro è il parsing: trasformare ogni riga in un piccolo dict una volta sola, all'avvio.

Parsing: leggere un testo e trasformarlo in dati strutturati che un programma può usare direttamente, come trasformare una lista della spesa scritta in caselle spuntate su un modulo.

Il nostro dict di regola ha quattro chiavi:

parse_rule("||metrics.example^$third-party")
# {'exception': False, 'kind': 'domain',
#  'value': 'metrics.example', 'third_party': True}

parse_rule("@@/assets/p.gif?")
# {'exception': True, 'kind': 'pattern',
#  'value': '/assets/p.gif?', 'third_party': False}

parse_rule("! just a comment")
# None

Due strumenti di Python per le stringhe fanno quasi tutto il lavoro. line.startswith("@@") controlla come inizia una riga. line.rsplit("$", 1) divide una volta all'ultimo $, dando il testo della regola e le opzioni, quindi "a$b".rsplit("$", 1) è ["a", "b"].

Un equivoco comune

"Le blocklist bloccano le pubblicità." Molte lo fanno, ma gli elenchi che contano per la privacy (come EasyPrivacy) mirano ai tracker: pixel, beacon e script di statistiche, che non vedi mai sullo schermo. Una pagina può non mostrare nessuna pubblicità e inviare comunque la tua visita a cinque aziende.

Provalo In un browser desktop con un'estensione blocker installata, apri le impostazioni dell'estensione e trova i suoi elenchi di filtri. La maggior parte ti permette di vedere un elenco come testo semplice. Cerca le righe che iniziano con || e @@: sono esattamente le regole che stai per analizzare.

In altri linguaggi

JavaScript:

function parseRule(line) {
  line = line.trim();
  if (!line || line.startsWith("!") || line.startsWith("[")) return null;
  if (line.includes("##") || line.includes("#@#")) return null;
  const exception = line.startsWith("@@");
  if (exception) line = line.slice(2);
  let thirdParty = false;
  const at = line.lastIndexOf("$");
  if (at >= 0) {
    thirdParty = line.slice(at + 1).split(",").includes("third-party");
    line = line.slice(0, at);
  }
  const isDomain = line.startsWith("||");
  const value = isDomain ? line.slice(2).replace(/\^$/, "") : line;
  return { exception, kind: isDomain ? "domain" : "pattern",
           value: value.toLowerCase(), thirdParty };
}

Rust:

struct Rule { exception: bool, domain: bool, value: String, third_party: bool }

fn parse_rule(line: &str) -> Option<Rule> {
    let mut l = line.trim();
    if l.is_empty() || l.starts_with('!') || l.starts_with('[') || l.contains("##") {
        return None;
    }
    let exception = l.starts_with("@@");
    if exception { l = &l[2..]; }
    let mut third_party = false;
    if let Some((rule, opts)) = l.rsplit_once('$') {
        third_party = opts.split(',').any(|o| o == "third-party");
        l = rule;
    }
    let domain = l.starts_with("||");
    let v = if domain { l[2..].trim_end_matches('^') } else { l };
    Some(Rule { exception, domain, value: v.to_lowercase(), third_party })
}

Riepilogo

  • Un elenco di filtri è testo semplice: regole di dominio (||host^), regole di pattern, eccezioni (@@) e opzioni ($third-party).
  • Le regole cosmetiche (##) nascondono parti della pagina e non fermano mai una richiesta.
  • Fai il parsing una volta sola in dict semplici, così il confronto dopo è veloce e chiaro.
Tocca a te

Scrivi parse_rule(line) che restituisce None per le righe vuote, di commento (!), di intestazione ([) e cosmetiche (## o #@#), e altrimenti un dict con le chiavi exception, kind ("domain" o "pattern"), value (in minuscolo, senza ||, il ^ finale, @@ o le $options) e third_party. Poi scrivi parse_list(text) che restituisce la lista delle regole per ogni riga, in ordine, tralasciando i risultati None. Non importare il parser del corso.

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.