Mode deterministe : empreintes reproductibles

Introduction

Le fingerprinting du navigateur repose sur des signaux qui sont stables au sein d'une session mais qui varient entre les appareils. Le revers de ce probleme est la reproductibilite : lorsque vous avez besoin que plusieurs sessions de navigateur presentent la meme identite, ou lorsque vous devez verifier que votre protection de la vie privee fonctionne correctement, vous avez besoin d'un comportement deterministe. Un navigateur qui produit des hashes canvas legerement differents, des empreintes audio differentes ou un rendu WebGL different a chaque lancement rend impossible le maintien d'une identite stable ou le test fiable de votre configuration. Le mode deterministe de BotBrowser, active via le flag --bot-noise-seed, vous donne un controle complet sur toutes les sources de variation d'empreinte. La meme combinaison profil et graine produit toujours la meme empreinte, entre les sessions, entre les machines et entre les systemes d'exploitation.

Impact sur la vie privee

Le besoin d'un comportement deterministe du navigateur provient d'une tension fondamentale dans la protection d'empreinte. Le bruit est important pour la vie privee. Ajouter une variation controlee au rendu canvas, au traitement audio et au rendu WebGL empeche les empreintes d'etre trivialement liees a un seul profil. Mais un bruit non controle, ou chaque session produit une empreinte differente, cree un probleme different : chaque session apparait comme un utilisateur unique, ce qui est l'oppose de se fondre dans la masse.

Les recherches de l'equipe de vie privee de l'INRIA ont montre que l'instabilite des empreintes (des empreintes qui changent entre les sessions) est elle-meme un signal de suivi. Si une empreinte change a chaque visite mais que d'autres signaux (IP, etat de connexion, motifs comportementaux) restent stables, l'empreinte changeante devient un marqueur plutot qu'un bouclier.

Le mode deterministe resout ce probleme en vous donnant un controle explicite. Vous choisissez quand les empreintes doivent rester les memes (meme graine) et quand elles doivent differer (graine differente). Cela est particulierement important pour :

• Continuite de session. Revenir sur un site web entre plusieurs sessions avec la meme empreinte.
• Coordination multi-instances. Executer plusieurs instances de navigateur qui ont besoin d'identites distinctes mais stables.
• Tests et verification. Confirmer que votre protection d'empreinte produit les resultats attendus.
• Reproductibilite de recherche. Mener des experiences controlees ou la variation d'empreinte doit etre eliminee comme variable.

Contexte technique

Sources de variation d'empreinte

La protection d'empreinte moderne implique l'ajout de bruit controle a plusieurs pipelines de rendu et de traitement :

• Canvas 2D. Le rendu de texte, le dessin de formes et la manipulation d'images produisent un rendu specifique a l'appareil au niveau des pixels. Le bruit ajoute une variation sous-pixel pour empecher la correspondance exacte.
• WebGL/WebGPU. L'execution des shaders, l'echantillonnage de textures et la lecture du framebuffer produisent un rendu specifique au GPU. Le bruit modifie les valeurs des pixels dans le rendu produit.
• Audio. Le rendu OfflineAudioContext et les donnees de frequence AnalyserNode produisent des valeurs flottantes specifiques a la plateforme. Le bruit varie le traitement en sortie.
• Metriques de texte. measureText(), getBoundingClientRect() et getClientRects() retournent des dimensions qui dependent du rendu des polices. Le bruit ajoute une variation sous-pixel aux mesures.

Sans graine, chacune de ces sources de bruit genere une variation aleatoire fraiche a chaque lancement du navigateur. Avec une graine, le generateur de nombres aleatoires est initialise a un etat connu, produisant des motifs de variation identiques a chaque fois.

Comment fonctionnent les graines de bruit

Une graine de bruit est un entier unique qui initialise un generateur de nombres pseudo-aleatoires (PRNG) deterministe. Le PRNG produit une sequence de valeurs qui semble aleatoire mais qui est entierement determinee par la graine. Deux sessions avec la meme graine produisent la meme sequence, et donc le meme bruit applique a chaque surface d'empreinte.

La graine de bruit de BotBrowser (definie via --bot-noise-seed) controle :

• Le bruit d'image Canvas 2D
• Le bruit d'image WebGL
• Le bruit de rendu WebGPU
• La variation de traitement du contexte audio
• La variation des metriques de texte (client rects, text rects)
• La variation de mise en page du texte

La graine n'affecte pas les proprietes non liees au bruit comme navigator.hardwareConcurrency, screen.width ou les chaines user agent. Celles-ci proviennent directement du profil et sont toujours deterministes.

Determinisme du timing

Au-dela du bruit d'empreinte, BotBrowser offre des controles de timing supplementaires :

• --bot-time-seed - Controle la diversite du timing d'execution sur 27 operations du navigateur. Chaque graine produit un profil de performance unique et stable. Cela couvre les intervalles performance.now(), performance.getEntries(), le timing de navigation, et plus encore.
• --bot-time-scale - Reduit les intervalles performance.now() pour normaliser les differences de timing causees par des charges serveur variables.

Ensemble, les graines de bruit et les graines de timing fournissent un controle deterministe complet sur toutes les sorties variables du navigateur.

Approches de protection courantes et leurs limites

Pas de bruit du tout signifie que votre empreinte reflete directement les valeurs de base du profil. C'est deterministe mais cela supprime l'avantage de la variation pour la vie privee. Plusieurs sessions avec le meme profil ont toutes exactement la meme empreinte, ce qui signifie qu'elles sont liables par definition.

Bruit aleatoire sans graine fournit de la variation mais au prix de la reproductibilite. Chaque session a une empreinte unique. Vous ne pouvez pas maintenir une identite stable, vous ne pouvez pas verifier votre configuration de maniere fiable, et vous ne pouvez pas coordonner plusieurs instances.

Bruit base sur la session (generer une graine aleatoire par session et la stocker) est une solution de contournement manuelle qui ajoute de la complexite. Vous devez gerer les valeurs de graine, les associer aux sessions et vous assurer qu'elles sont appliquees de maniere coherente. BotBrowser elimine cette surcharge en acceptant la graine comme flag CLI.

Bruit base sur les extensions applique generalement du bruit aleatoire au niveau JavaScript sans mecanisme de graine. Chaque chargement de page produit des resultats differents. Le bruit n'est pas deterministe, pas controlable et pas coherent entre les surfaces d'API.

L'approche au niveau du moteur de BotBrowser

Le mode deterministe de BotBrowser opere au niveau du moteur de rendu, garantissant que le bruit est applique de maniere coherente sur toutes les surfaces d'API a partir d'une seule valeur de graine.

Une seule graine, couverture complete

Le flag --bot-noise-seed accepte un entier de 1 a 4294967295 (UINT32_MAX). Cette seule valeur controle toutes les sources de bruit simultanement :

• Canvas 2D toDataURL(), toBlob() et getImageData() produisent un rendu identique pour la meme graine.
• WebGL readPixels() retourne les memes donnees de framebuffer pour la meme scene dessinee et la meme graine.
• OfflineAudioContext rend le meme buffer pour le meme graphe audio et la meme graine.
• measureText() et getClientRects() retournent les memes mesures pour le meme contenu et la meme graine.

Reproductibilite entre machines

Parce que le bruit est derive de la graine et applique au niveau du moteur, la meme combinaison profil + graine produit la meme empreinte quel que soit le materiel sous-jacent, le systeme d'exploitation ou le GPU. Une session sur un serveur Linux avec un GPU NVIDIA et une session sur un Mac portable avec Apple Silicon produisent des empreintes identiques lorsqu'elles utilisent le meme profil et la meme graine.

La graine comme identite

En pratique, vous pouvez considerer chaque graine comme definissant une sous-identite unique au sein d'un profil. Le profil A avec la graine 42 est une identite stable et reproductible. Le profil A avec la graine 43 est une identite stable et reproductible differente. Le profil definit la classe d'appareil (OS, navigateur, materiel), et la graine definit l'individu au sein de cette classe.

Ce modele correspond naturellement aux workflows multi-comptes ou multi-sessions :

• Session 1 : profil A, graine 100
• Session 2 : profil A, graine 200
• Session 3 : profil B, graine 100

Les sessions 1 et 2 apparaissent comme des utilisateurs differents avec un materiel similaire. La session 3 apparait comme un utilisateur different sur un materiel different.

Determinisme du timing

Avec --bot-time-seed, le timing d'execution devient egalement reproductible. Les mesures de performance, le timing de navigation et le timing des ressources suivent tous un motif deterministe pour une graine donnee. Combine avec --bot-noise-seed, cela fournit un controle complet sur toutes les sorties variables du navigateur.

Configuration et utilisation

Mode deterministe de base

chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=42 \
       --user-data-dir="$(mktemp -d)"

Controle deterministe complet

chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=42 \
       --bot-time-seed=42 \
       --bot-stack-seed=profile \
       --user-data-dir="$(mktemp -d)"

Multi-instances avec graines distinctes

# Instance 1 - stable identity A
chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=1001 \
       --user-data-dir="/tmp/session-a" &

# Instance 2 - stable identity B
chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=1002 \
       --user-data-dir="/tmp/session-b" &

Integration Playwright

const { chromium } = require('playwright');

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-noise-seed=42',
    '--bot-time-seed=42'
  ]
});

const page = await browser.newPage();
await page.goto('https://example.com');

// This canvas fingerprint will be identical on every run
const hash = await page.evaluate(() => {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.fillText('deterministic test', 10, 10);
  return canvas.toDataURL();
});
console.log(hash);

Integration Puppeteer

const puppeteer = require('puppeteer');

const browser = await puppeteer.launch({
  executablePath: '/path/to/botbrowser/chrome',
  defaultViewport: null,
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-noise-seed=42',
    '--bot-time-seed=42'
  ]
});

const page = await browser.newPage();
await page.goto('https://example.com');

Desactivation de canaux de bruit specifiques

Si vous avez besoin d'un rendu deterministe pour certains signaux mais d'un rendu natif pour d'autres :

chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=42 \
       --bot-config-noise-canvas=false \
       --bot-config-noise-audio-context=false

Verification

Reproductibilite entre sessions. Executez le meme test d'empreinte dans deux sessions separees avec le meme profil et la meme graine. Comparez les hashes canvas, les empreintes audio, le rendu WebGL et les metriques de texte. Toutes les valeurs doivent etre identiques.

Reproductibilite entre machines. Executez le meme test sur une machine differente avec le meme profil et la meme graine. L'empreinte doit correspondre exactement.

Variation de graine. Changez la graine et executez le test a nouveau. L'empreinte doit etre differente, confirmant que la graine influence reellement le rendu.

Comportement avec la graine 0. Utiliser --bot-noise-seed=0 maintient le bruit actif avec les valeurs par defaut du profil mais sans semence deterministe. Verifiez que cela produit un rendu variable entre les sessions.

Bonnes pratiques

• Utilisez une graine unique par identite. Chaque graine definit une sous-identite stable. Ne reutilisez pas la meme graine pour des sessions qui doivent apparaitre comme des utilisateurs differents.
• Stockez les valeurs de graine. Si vous devez revenir a une session, vous avez besoin du meme profil et de la meme graine. Stockez l'association entre l'identite de session et la valeur de graine.
• Combinez --bot-noise-seed avec --bot-time-seed. La graine de bruit controle le rendu. La graine de timing controle le timing de performance. Les deux contribuent a une empreinte complete. Utilisez les deux pour un determinisme complet.
• Evitez la valeur de graine 0. Zero maintient le bruit actif avec une variation non deterministe. Utilisez n'importe quel entier positif pour un comportement deterministe.
• Testez vos attributions de graines. Avant le deploiement, verifiez que differentes graines produisent des empreintes differentes et que la meme graine produit des empreintes identiques.

FAQ

Q : Quelle est la plage valide pour --bot-noise-seed ? R : Tout entier de 1 a 4294967295 (UINT32_MAX). La valeur 0 maintient le bruit actif mais non deterministe.

Q : La graine de bruit affecte-t-elle les performances du navigateur ? R : Non. Les operations de bruit sont extremement legeres. Le calcul du PRNG ajoute une surcharge negligeable.

Q : Deux profils differents avec la meme graine peuvent-ils produire la meme empreinte ? R : Non. Le profil definit l'empreinte de base (GPU, ecran, navigator, etc.), et la graine definit la variation de bruit. Des profils differents avec la meme graine produisent des empreintes differentes car les valeurs de base different.

Q : Que se passe-t-il si je ne definis pas --bot-noise-seed ? R : Le bruit est applique avec une graine aleatoire a chaque lancement. Chaque session a une empreinte differente. Les proprietes de base du profil (navigator, ecran, etc.) restent les memes.

Q : Le mode deterministe affecte-t-il les cookies ou le stockage local ? R : Non. Le mode deterministe controle le rendu pertinent pour les empreintes. Le stockage, les cookies et l'etat de session sont geres via --user-data-dir et --bot-cookies.

Q : Puis-je utiliser la meme graine avec differentes versions de BotBrowser ? R : L'algorithme de bruit peut changer entre les versions majeures. Pour une reproductibilite exacte, utilisez la meme version de BotBrowser. Au sein d'une version, le comportement de la graine est garanti stable.

Q : En quoi --bot-time-seed differe-t-il de --bot-noise-seed ? R : --bot-noise-seed controle le bruit de rendu (canvas, WebGL, audio, metriques de texte). --bot-time-seed controle la diversite du timing d'execution (motifs performance.now(), timing de navigation). Ils sont independants et peuvent etre definis a des valeurs differentes.

Resume

Le comportement deterministe du navigateur est essentiel pour maintenir des identites d'empreinte stables, coordonner des workflows multi-sessions et verifier la protection de la vie privee. Le flag --bot-noise-seed de BotBrowser fournit un controle complet sur toutes les sources de variation d'empreinte, produisant un rendu identique pour la meme combinaison profil et graine quel que soit le materiel sous-jacent. Combine avec --bot-time-seed pour le determinisme du timing et --bot-stack-seed pour le controle de la profondeur de pile, BotBrowser offre un mode deterministe complet qui couvre chaque sortie variable du navigateur.

Pour des sujets connexes, consultez Qu'est-ce que le fingerprinting de navigateur, Protection d'empreinte audio, Fingerprinting Canvas, et Reproductibilite de la graine de bruit.