Programme Leçon 46 sur 156 · Construire un bloqueur
Construire un bloqueur

Comment marchent les listes de blocage

Pourquoi c'est important La plupart du blocage de traqueurs dans le monde aujourd'hui, dans les extensions comme dans les navigateurs, part d'un simple fichier texte de règles. Une fois que tu sais lire ce fichier, tu vois exactement ce qu'un bloqueur arrêtera ou non, et pourquoi un site casse parfois.

Un videur avec une liste

Imagine un videur à l'entrée d'une boîte de nuit, avec une liste imprimée : « ne pas laisser entrer ces personnes », plus une petite note : « sauf ces habitués ». Le videur ne juge personne ; il vérifie juste les noms sur la liste.

Un bloqueur marche de la même façon. Chaque fois qu'une page demande quelque chose (un script, une image, un pixel), le bloqueur compare l'adresse à sa liste et dit autoriser ou bloquer.

Liste de filtres : un fichier texte de règles, une par ligne, qui dit à un bloqueur quelles requêtes arrêter. La famille la plus connue est EasyList, écrite dans la syntaxe Adblock Plus que comprennent la plupart des bloqueurs.

Requête : une demande de ton navigateur à un serveur, comme « envoie-moi https://adco.example/tag.js ». Une page fait en général beaucoup de requêtes.

La syntaxe, un petit sous-ensemble d'entraînement

Les vraies listes ont des dizaines de milliers de lignes et beaucoup de fonctions en plus. On utilise une petite liste d'entraînement inventée avec la même syntaxe de base. La voici (elle se trouve dans 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 ligne ressemble àSens
! ... ou [...]Un commentaire ou un en-tête. Saute-le.
||adco.example^Une règle de domaine : bloque adco.example et chaque sous-domaine, comme img.adco.example. Le ^ marque la fin du nom d'hôte.
/p.gif?Une règle de motif : bloque toute adresse qui contient ce texte. Un * à l'intérieur veut dire « n'importe quels caractères ici ».
@@...Une exception : autorise, même si une règle de blocage correspond aussi.
...$third-partyUne option : n'applique cette règle que quand la requête va vers un autre site que la page où tu es.
##.ad-bannerUne règle cosmétique : cache une partie de la page. Elle n'arrête jamais de requête, donc un bloqueur réseau la saute.

Tiers : une requête vers un autre site que celui de ta barre d'adresse. Sur shopa.example, une requête vers adco.example est tierce ; une requête vers shopa.example lui-même est première.

Transformer une ligne en données

Les programmes ne veulent pas relire le texte à chaque requête. Donc le premier travail est l'analyse : transformer chaque ligne en un petit dict une seule fois, au démarrage.

Analyse (parsing) : lire un texte et le transformer en données structurées qu'un programme peut utiliser directement, comme transformer une liste de courses écrite en cases cochées sur un formulaire.

Notre dict de règle a quatre clés :

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

Deux outils Python sur les chaînes font l'essentiel du travail. line.startswith("@@") vérifie par quoi commence une ligne. line.rsplit("$", 1) coupe une fois au dernier $, ce qui donne le texte de la règle et les options, donc "a$b".rsplit("$", 1) vaut ["a", "b"].

Une idée reçue

« Les listes de blocage bloquent les publicités. » Beaucoup le font, mais les listes qui comptent pour la vie privée (comme EasyPrivacy) visent les traqueurs : pixels, balises et scripts de statistiques, que tu ne vois jamais à l'écran. Une page peut n'afficher aucune publicité et quand même envoyer ta visite à cinq entreprises.

Essaie Dans un navigateur de bureau avec une extension de blocage installée, ouvre les réglages de l'extension et trouve ses listes de filtres. La plupart permettent de voir une liste en texte brut. Cherche les lignes qui commencent par || et @@ : ce sont exactement les règles que tu vas analyser.

Dans d'autres langages

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 })
}

Récap

  • Une liste de filtres est du texte brut : règles de domaine (||host^), règles de motif, exceptions (@@) et options ($third-party).
  • Les règles cosmétiques (##) cachent des parties de page et n'arrêtent jamais de requête.
  • Analyse une fois en dicts simples pour que la correspondance soit ensuite rapide et claire.
À ton tour

Écris parse_rule(line) qui renvoie None pour les lignes vides, de commentaire (!), d'en-tête ([) et cosmétiques (## ou #@#), et sinon un dict avec les clés exception, kind ("domain" ou "pattern"), value (en minuscules, sans ||, le ^ final, @@ ni les $options) et third_party. Puis écris parse_list(text) qui renvoie la liste des règles de chaque ligne, dans l'ordre, sans les résultats None. N'importe pas l'analyseur du cours.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.