Retour au Centre de connaissances
Comparaison

Cœur du navigateur et scripts JavaScript pour les empreintes

Comparez extensions, scripts injectés et modifications du navigateur selon la couche qu'ils contrôlent, puis vérifiez vous-même la cohérence de l'empreinte.

BotBrowser Team

Documentation

Vous voulez la documentation structurée pour Documentation ?

Cet article fait partie de la bibliothèque éditoriale. Pour les étapes de configuration, la référence et les mises à jour continues, passez directement à la section docs.

BotBrowser peut appliquer un profil choisi dans un contexte de navigateur contrôlé, mais ne détermine pas comment un site tiers évalue une session et ne remplace pas la validation de la configuration retenue.

TL;DR

  • Les extensions et les scripts injectés modifient surtout les valeurs visibles depuis JavaScript.
  • Un profil appliqué dans le navigateur peut coordonner les valeurs entre requêtes, rendu et contextes d'exécution.
  • Comparez le même signal dans une page, un worker, le rendu et la première requête avant de conclure.

Sommaire

Quelle couche contrôle un outil de protection

Les outils de protection contre le fingerprinting se distinguent moins par ce qu'ils promettent que par l'endroit où ils s'exécutent. Un navigateur comporte plusieurs couches : le code réseau qui envoie la première requête, les chaînes de rendu et d'audio qui produisent pixels et échantillons, la surface d'API JavaScript que lisent les pages, et les contextes d'exécution distincts (cadres, workers dédiés, workers partagés et service workers) qui reçoivent chacun leur propre copie de cette surface. Un outil ne peut rendre cohérent que ce qui se trouve à la couche qu'il contrôle ou en dessous. BotBrowser peut appliquer un profil choisi dans le navigateur avant l'exécution des scripts de page dans un contexte contrôlé ; il ne peut pas modifier le comportement d'un site, d'un standard web ou d'un autre navigateur.

Trois architectures sont courantes aujourd'hui :

  1. Des extensions de navigateur qui exécutent un content script dans la page et remplacent des propriétés JavaScript une fois que la page a commencé à se charger
  2. Des scripts injectés, souvent fournis sous forme de plugins pour des frameworks d'automatisation comme Puppeteer ou Playwright, qui s'exécutent avant les scripts de la page dans chaque nouveau document
  3. Des modifications dans le code compilé du navigateur lui-même, où un profil chargé définit les valeurs avant qu'un script de page n'existe

Ce ne sont pas trois versions d'une même idée. Chacune a une portée différente, et cette portée détermine trois résultats concrets : si les valeurs concordent entre le cadre principal, les iframes et les workers ; si le résultat du rendu et les en-têtes de requête concordent avec les valeurs JavaScript ; et la quantité de maintenance que vous coûtent chaque nouvelle version du navigateur ou chaque nouvelle technique de fingerprinting.

Matrice de trois approches numérotées comme dans la liste ci-dessus (extension de navigateur, script injecté et profil appliqué dans le navigateur) face à quatre lignes : valeurs JavaScript, résultat du rendu, en-têtes de requête, et workers avec nouveaux cadres. Les extensions et les scripts injectés ne modifient que les valeurs JavaScript et, pour les scripts injectés, certains cadres ou workers, alors que le profil définit chaque ligne.

Les colonnes 1 à 3 suivent la liste numérotée ci-dessus. Un cercle vert plein signifie que la valeur provient du profil, un cercle ambre à moitié rempli signifie qu'un script modifie la valeur, et un anneau en pointillés signifie que la valeur réelle de l'appareil est conservée tant que rien d'autre ne la modifie. Dans la dernière ligne, le demi-cercle des scripts injectés indique que les cadres sont couverts alors que les workers varient. Un anneau en pointillés ne signifie pas que l'approche est inutile, et les sections suivantes expliquent pourquoi chaque ligne compte.

Un cas concret aide à le voir. Supposons qu'une page lise la valeur de la plateforme dans le cadre principal, puis ouvre une iframe et un worker dédié et y lise la même valeur, pendant que le serveur enregistre aussi l'indice de plateforme de la première requête. Il existe alors quatre lectures d'un même fait. Un outil qui ne contrôle que la couche JavaScript peut en faire concorder certaines, mais il ne fera concorder les quatre que si chacun de ces chemins reçoit bien son remplacement. Un outil qui définit la valeur une seule fois, à partir d'un seul profil et avant que ces chemins n'existent, évite d'avoir à corriger chacun séparément.

Pourquoi une protection partielle devient un signal à part entière

Une protection incomplète peut rendre un visiteur plus facile à distinguer qu'une absence de protection. Cette logique explique aussi pourquoi un pipeline hébergé est un autre instrument et non un meilleur : un débloqueur face à un navigateur que vous possédez garde la question de la protection partielle de votre côté de la ligne. Lorsque certaines valeurs sont modifiées et d'autres non, le résultat contient des contradictions. Un navigateur qui annonce un système d'exploitation dans sa chaîne de plateforme alors que ses polices et son rendu de texte correspondent à un autre est plus inhabituel qu'un navigateur non modifié, car très peu d'appareils réels présentent cette combinaison. Un contrôle peut lire Object.getOwnPropertyDescriptor(Navigator.prototype, "platform") et comparer séparément le résultat des polices rendues.

Il en va de même pour les traces laissées par l'outil lui-même. Une propriété remplacée par un getter défini dans un script affiche un corps de fonction différent de celui du getter intégré du navigateur lorsqu'on lit son texte source. Une méthode de prototype enveloppée peut montrer la même différence.

Le guide du W3C sur l'atténuation du fingerprinting dans les spécifications web explique pourquoi une empreinte est difficile à effacer ou à réinitialiser, et c'est précisément pourquoi la cohérence compte plus que le nombre de valeurs que vous changez. Pour un ingénieur en confidentialité ou en automatisation, la question pratique n'est pas de savoir si un outil modifie une valeur. C'est de savoir si tous les endroits où cette valeur peut être lue concordent ensuite, y compris ceux que l'outil ne voit peut-être jamais.

Jusqu'où vont les extensions et les scripts injectés

Les deux approches par script passent par la couche JavaScript, si bien que leurs forces et leurs limites ont la même origine. Les points suivants décrivent ce que cette couche peut et ne peut pas modifier.

Extensions de navigateur. Une extension utilise l'API WebExtensions, qui permet d'exécuter un content script dans la page dès le début du document. Une extension d'empreinte typique remplace les définitions de propriétés comme hardwareConcurrency et les dimensions d'écran, et enveloppe les méthodes qui lisent les données de Canvas et d'audio afin que leurs résultats changent.

Descripteurs de propriété. Remplacer une propriété intégrée par un getter défini dans un script modifie son descripteur de propriété. L'affichage du texte source du getter montre du JavaScript ordinaire au lieu de [native code], et n'importe quel script exécuté dans la page peut effectuer cette vérification.

Chaîne de prototypes. Les méthodes de prototype enveloppées sont elles aussi des fonctions ordinaires. On peut les distinguer du code intégré du navigateur par le même type de comparaison du texte source, si bien que l'enveloppe ne masque la fonction d'origine que dans la mesure où elle l'imite bien.

Nouveaux contextes. Une extension peut ne pas exécuter ses remplacements dans tous les contextes d'exécution. Les iframes créées par la page, les workers dédiés, les workers partagés et les service workers ont chacun leur propre objet global, que MDN documente comme des portées distinctes. Si un remplacement atteint le cadre principal mais pas un worker, la même propriété renvoie deux valeurs différentes dans la même session, et cet écart est visible par la page.

Résultat du rendu. Une extension peut envelopper les méthodes qui lisent les pixels de Canvas ou les échantillons audio, mais ces pixels et ces échantillons sont produits par les chaînes graphiques et audio du navigateur. Tout code qui lit la sortie réelle par un chemin que l'enveloppe ne couvre pas voit les valeurs de l'appareil, et une enveloppe qui se contente d'ajouter du bruit aux résultats de l'API laisse la sortie sous-jacente inchangée.

Couche réseau. Les scripts d'une extension s'exécutent une fois la première requête envoyée. Les en-têtes Client Hints, comme l'indice de plateforme, sont joints aux requêtes avant qu'un content script puisse agir, et les paramètres TLS échappent à ce que n'importe quel script de page peut modifier.

Scripts injectés. Les plugins pour frameworks d'automatisation ont amélioré ce que faisaient les extensions. Le framework enregistre un script qui s'exécute dans chaque nouveau document avant les scripts de la page, ce qui referme l'écart de timing et couvre les cadres créés par la page. Ces plugins remplacent aussi davantage de valeurs et modifient toString() pour que les fonctions remplacées s'affichent comme du code intégré.

Ce qui reste. Les limites qui subsistent sont structurelles. Les workers dépendent de la capacité du framework à injecter dans leurs portées. Les couches de rendu et de réseau restent intactes. Chaque valeur est un correctif indépendant, si bien que les garder cohérentes entre elles, par exemple un GPU annoncé face à la sortie réelle de rastérisation, dépend du soin manuel de l'auteur. Un toString() modifié est en outre un remplacement de plus que l'on peut inspecter.

Les service workers ajoutent une difficulté supplémentaire. Ils persistent d'un chargement de page à l'autre et peuvent survivre à la page qui les a enregistrés, de sorte qu'un remplacement installé pour une navigation peut être absent lorsqu'un service worker démarre plus tard. Une approche par script doit repérer et corriger chacune de ces portées à mesure qu'elles apparaissent, et une portée oubliée se manifeste par deux valeurs pour une même propriété.

De meilleurs scripts réduisent ces limites sans les supprimer, car les scripts s'exécutent au-dessus des couches concernées. C'est une propriété de l'architecture, pas une lacune qu'un code plus soigné comblerait. La maintenance croît aussi avec le nombre de valeurs que vous corrigez : chaque nouvelle version du navigateur ou technique de fingerprinting peut exiger un nouveau correctif, et chaque correctif est une fonction de plus qui doit sembler intégrée.

Ce qui change quand le profil est appliqué dans le navigateur

Quand les valeurs sont définies dans le code du navigateur lui-même au lieu d'être corrigées après coup sur une page déjà construite, il n'y a aucun remplacement à trouver. BotBrowser charge un profil capturé depuis une vraie session de navigateur et l'applique avant l'exécution des scripts de la page. Sa documentation sur navigator décrit le résultat : les valeurs de navigator restent cohérentes entre JavaScript, les en-têtes HTTP et les contextes Worker.

Getters natifs. La lecture d'une propriété passe par le chemin de code normal du navigateur, si bien qu'aucun getter défini dans un script ne se place devant la valeur. La vérification des descripteurs de la section suivante doit montrer du code intégré.

Résultat du rendu. Pour Canvas 2D, WebGL et l'audio, BotBrowser applique un bruit déterministe dans la chaîne de rendu plutôt que par injection JavaScript. L'article sur Canvas montre comment ce bruit reste stable pour une graine donnée.

En-têtes de requête. La documentation décrit les valeurs Client Hints et les en-têtes de requête correspondants comme générés à partir du même profil, de sorte qu'ils restent alignés avec les valeurs JavaScript et avec les workers.

Héritage dans les workers. Les workers dédiés, les workers partagés et les service workers créés dans un contexte héritent de l'empreinte de ce contexte (voir la documentation sur l'empreinte par contexte), si bien qu'il n'existe aucune étape d'injection qui pourrait s'exécuter trop tard ou oublier un contexte.

Le tableau résume en quoi les trois approches diffèrent sur les dimensions qui comptent pour la cohérence. Il compare des architectures, pas des produits précis.

DimensionExtension de navigateurScript injectéProfil appliqué dans le navigateur
Valeurs des propriétés JavaScriptRemplacement par scriptRemplacement par script, exécuté plus tôtValeur du profil via le getter normal
Vérification du descripteurGetter de script visibleGetter de script visible, toString() modifiéGetter intégré attendu
Sortie de Canvas, WebGL et audioMéthodes de lecture enveloppées seulementMéthodes de lecture enveloppées seulementBruit piloté par le profil dans la chaîne de rendu
Disponibilité des policesNon contrôléeNon contrôléeListe de polices issue du profil
En-têtes de requêteEnvoyés avant l'exécution du content scriptNon modifiés par les scripts de la pageValeurs conformes au profil
Client HintsNon atteintsNon atteintsCohérents avec le profil
iframes et workersPeuvent être manquésCadres couverts, workers variablesMêmes valeurs du profil
Cohérence entre signauxCorrectifs indépendantsCorrectifs indépendantsUn profil définit toutes les valeurs

Un profil contient les signaux de l'appareil capturés depuis une vraie session de navigateur : valeurs de navigator, dimensions d'écran, informations sur le GPU, polices, et caractéristiques de rendu et d'audio. Le charger configure l'ensemble en une fois, c'est ainsi qu'ils restent cohérents entre eux. La commande de lancement est courte :

chromium-browser \
  --bot-profile="path/to/profile.enc" \
  --bot-noise-seed=42

Graine de bruit déterministe. Pour les tests de régression et les expériences contrôlées, la graine de bruit rend la sortie reproductible. La documentation indique que le même profil avec la même graine produit la même sortie Canvas, WebGL et audio d'une session à l'autre, et qu'une autre graine donne un résultat différent mais tout aussi stable. L'option --bot-noise-seed est indiquée comme une fonctionnalité ENT Tier2 ; vérifiez donc que votre offre l'inclut avant de vous appuyer sur la commande de lancement ci-dessus.

Empreintes par contexte. L'empreinte par contexte, documentée comme une fonctionnalité ENT Tier3, permet à chaque contexte de navigateur de porter son propre profil et sa propre graine de bruit au sein d'une même instance. Le benchmark de BotBrowser rapporte une consommation de mémoire plus faible et moins de processus du système d'exploitation qu'avec des instances de navigateur séparées à grande échelle. Ce sont des mesures de BotBrowser sur son propre matériel, mesurez donc votre propre charge avant de planifier la capacité.

Rendu multiplateforme. La documentation de Canvas indique qu'un profil Windows exécuté sur un hôte Linux produit la même sortie Canvas que sur du matériel Windows. L'article sur les profils multiplateformes explique quoi vérifier lorsque le système de l'hôte et celui du profil diffèrent.

Performances. Dans l'exécution Speedometer 3.0 en mode headless menée par BotBrowser, BotBrowser a obtenu 42.7 et Chrome standard 42.8. La documentation du benchmark traite cet écart comme relevant de la variation d'une exécution à l'autre. Il n'y a pas de script par page à injecter, donc pas de coût d'injection par page, mais les résultats sur votre matériel peuvent différer.

Vérifier vous-même la cohérence

La vérification s'applique à toutes les approches et contrôle seulement si les valeurs exposées par un navigateur concordent entre elles. Un résultat favorable prouve une cohérence interne. Il ne montre pas comment un site tiers classera une session.

Vérification 1, descripteurs de propriété et workers. Ouvrez la console de développement sur une page du navigateur que vous testez et exécutez ce qui suit. La première ligne lit le getter d'une propriété et affiche son texte source. Les lignes suivantes démarrent un worker et comparent sa valeur à celle du cadre principal.

const d = Object.getOwnPropertyDescriptor(Navigator.prototype, 'hardwareConcurrency');
console.log(Function.prototype.toString.call(d.get));
const w = new Worker(URL.createObjectURL(new Blob(['postMessage(navigator.hardwareConcurrency)'])));
w.onmessage = e => console.log('worker:', e.data, 'main:', navigator.hardwareConcurrency);

Un getter intégré affiche un corps de fonction contenant [native code]. Un getter défini par un script affiche du code source JavaScript. La valeur du worker et celle du cadre principal doivent concorder. Si elles diffèrent, un remplacement a atteint un contexte mais pas l'autre.

Vérification 2, autres contextes. Répétez la comparaison pour une iframe de même origine et, si votre flux de travail en utilise un, pour un service worker. Des valeurs identiques constituent une preuve de cohérence. Un écart désigne une couche ou un contexte que l'outil n'atteint pas.

Vérification 3, en-têtes face aux scripts. Comparez les valeurs de plateforme et de marque que rapportent les scripts avec les en-têtes User-Agent et Client Hints que reçoit un serveur. Une page qui renvoie la requête reçue et que vous maîtrisez suffit. Les deux sources doivent décrire le même appareil.

Vérification 4, stabilité du rendu. Rechargez la page et redémarrez le navigateur avec le même profil et la même graine, puis comparez la sortie de Canvas. Changez la graine et confirmez que la sortie change de manière stable. Une sortie qui change à chaque lecture, sans graine en jeu, est plus inhabituelle qu'une sortie qui se répète, car les appareils réels renvoient le même résultat pour le même dessin.

Les pages publiques d'inspection peuvent offrir un second regard, et l'article sur la vérification explique comment les lire. Considérez leurs avertissements comme des indices d'incohérence interne, pas comme des scores utilisés par un site.

Quand une vérification échoue, l'échec désigne une couche. Un getter défini par un script à la vérification 1 signifie que la valeur est remplacée au-dessus du code propre du navigateur. Un worker qui diffère du cadre principal signifie que le remplacement n'a pas atteint cette portée. Un en-tête qui diffère d'une valeur de script signifie que la requête a été construite avant l'exécution du script. Un résultat de rendu qui change à chaque lecture signifie que le bruit est appliqué à chaque appel plutôt que par graine. Chacun de ces constats vous indique ce qu'il faut corriger ou quelle architecture reconsidérer, ce qui est plus utile qu'un simple réussi ou échoué. Pour comprendre comment les en-têtes et la couche réseau interviennent dans la cohérence, voir Cohérence réseau du navigateur pour protéger la vie privée. Le guide de comparaison associé exécute ces quatre vérifications sur une compilation où la protection est appliquée par le navigateur lui-même et sur une compilation où elle vient d’une couche d’API, puis consigne les sorties côte à côte : Protection appliquée par le navigateur ou par une couche d’API.

Notez la configuration à côté de chaque résultat : la version de BotBrowser, le fichier de profil, la graine, le système d'exploitation de l'hôte et si l'exécution était headless ou avec fenêtre. Sans cette trace, une différence entre deux exécutions ne peut pas être attribuée à une cause.

Choisir une approche et connaître ses limites

Choisissez en fonction de l'échec que vous ne pouvez pas accepter. Une extension peut convenir pour une protection simple contre des traqueurs rudimentaires, à condition d'accepter que les nouveaux contextes et la sortie de rendu puissent conserver des valeurs réelles. Les scripts injectés conviennent aux tests où vous maîtrisez le framework d'automatisation et n'avez besoin de modifier que quelques valeurs. Un profil appliqué dans le navigateur convient lorsque l'exigence est la concordance entre contextes et entre couches. Les différences entre un noyau axé confidentialité et un navigateur anti-détection sont décrites dans Noyau axé confidentialité vs navigateur anti-détection.

Quelle que soit l'approche retenue, décidez à l'avance quels signaux comptent pour votre scénario et testez-les. Un examen de confidentialité d'un seul navigateur peut se limiter à la concordance des descripteurs et des workers. Une suite de tests qui exécute de nombreuses sessions doit en plus conserver la graine et le profil de chaque exécution, afin de pouvoir reproduire une différence plus tard. Une équipe qui compare des systèmes d'exploitation d'hôte a aussi besoin des vérifications multiplateformes. Pour piloter un navigateur avec des scripts légers, voir Automatisation légère du navigateur avec le Chrome DevTools Protocol.

Ai-je encore besoin de scripts injectés si j'utilise BotBrowser ? Un profil couvre déjà les valeurs que ces scripts corrigent. Superposer des remplacements par script peut réintroduire des getters définis par des scripts et des écarts ; commencez donc avec le profil seul et n'ajoutez que ce qu'une vérification documentée montre comme nécessaire.

Que penser des extensions qui rendent aléatoire la sortie de Canvas ? Un bruit aléatoire qui change à chaque lecture est en soi inhabituel, car un appareil réel renvoie la même sortie pour le même dessin. Le bruit à graine reste stable pour une graine donnée, ce qui le rend utilisable pour des tests reproductibles.

La configuration est-elle plus difficile que l'ajout d'un plugin ? Elle est généralement plus courte. Vous pointez votre framework d'automatisation vers le binaire de BotBrowser et choisissez un profil. Le guide Playwright détaille la connexion pas à pas.

BotBrowser peut maintenir les valeurs de navigator cohérentes entre JavaScript, les en-têtes HTTP et les contextes Worker en appliquant un profil chargé dans le navigateur, ce qui vous permet de vérifier vous-même la concordance entre contextes au lieu de vous fier à des remplacements injectés. BotBrowser ne peut pas garantir comment un site ou un détecteur tiers classe une session, et ne remplace ni la qualité du proxy, ni le réalisme du comportement, ni votre propre vérification de la configuration finale.

Conclusion pratique

Choisissez le point de contrôle selon les surfaces que la charge autorisée doit aligner. Consignez le même signal séparément dans le cadre principal, un worker, le rendu et la première requête ; une lecture JavaScript ne prouve pas la cohérence entre ces couches.

Sources publiques

#protection des empreintes#moteur du navigateur#extension de navigateur#confidentialité#comparaison d’architecture#cohérence#Puppeteer#Playwright

Exécutez la même vérification dans BotBrowser

Chargez un profil, gardez dans le navigateur les signaux que vous venez de lire, puis confirmez le résultat sur votre propre machine avant le déploiement.