Fingerprinting par mesure de texte : les metriques de polices sous-pixel comme signal de suivi

Introduction

Lorsqu'un site web mesure la largeur d'une chaine de texte en utilisant la methode measureText() de l'API Canvas, le resultat est une valeur a virgule flottante avec une precision sous-pixel. Ces valeurs varient selon les systemes d'exploitation car chaque plateforme utilise un moteur de rendu integre different avec son propre modele arithmetique interne. Les differences sont infimes, invisibles a l'oeil nu, mais elles sont coherentes, reproductibles et mesurables via JavaScript.

Cette precision sous-pixel fait de measureText() l'un des signaux d'identification de plateforme les plus fiables disponibles pour les scripts de suivi. Contrairement au fingerprinting d'image Canvas, qui necessite le rendu de pixels et le hachage du resultat, le fingerprinting par mesure de texte est rapide, leger et produit une valeur numerique directe qui peut etre comparee instantanement. Un seul appel prend des microsecondes et renvoie une valeur qui identifie votre systeme d'exploitation. Lorsqu'un script de suivi mesure plusieurs chaines a plusieurs tailles de police, le resultat combine devient un signal de fingerprint puissant.

Cela fait de la mesure de texte un vecteur de suivi activement utilise par les systemes de fingerprinting commerciaux sur les sites web de reseaux sociaux, de banque, de traitement des paiements et de commerce electronique. Elle ne necessite aucune permission speciale, ne genere aucun comportement visible pour l'utilisateur et produit des resultats stables entre les sessions de navigateur. A mesure que les navigateurs ameliorent les protections pour d'autres vecteurs de fingerprinting, la mesure de texte recoit une attention croissante car il est difficile de la proteger au niveau de l'API sans degrader le comportement des applications web.

L'approche au niveau du moteur de BotBrowser

BotBrowser aborde le fingerprinting par mesure de texte au niveau du moteur du navigateur, pas par interception d'API ou post-traitement. C'est une distinction architecturale fondamentale qui permet une protection sans detection et sans casser la fonctionnalite web.

Chemin de rendu de polices unifie

BotBrowser modifie le pipeline de rendu de polices au sein de Chromium pour s'assurer que les calculs de metriques de polices utilisent une arithmetique coherente sur toutes les plateformes. Que BotBrowser s'execute sur macOS, Windows ou Linux, les mathematiques de mise a l'echelle des polices pour un profil donne produisent des resultats identiques.

Cela signifie que lorsqu'un profil de fingerprint specifie une configuration d'appareil particuliere, les resultats de measureText() correspondent exactement a cette configuration, jusqu'au dernier chiffre significatif. Le moteur de polices ne renvoie pas simplement les valeurs natives du systeme hote. Au lieu de cela, il calcule les metriques en utilisant le modele de rendu defini par le profil.

Coherence pilotee par le profil

Chaque profil de fingerprint BotBrowser encode les caracteristiques de metriques de texte de l'appareil profile. Lorsque le profil est charge, le moteur de rendu de polices produit des mesures qui correspondent a l'appareil original :

• La meme chaine de texte a la meme taille de police renvoie la meme valeur de largeur, quel que soit le systeme d'exploitation hote.
• Le meme profil charge sur macOS, Windows et Linux produit des resultats measureText() bit a bit identiques.
• Les resultats sont internement coherents avec d'autres signaux lies aux polices (liste de polices, rendu de texte Canvas, metriques de mise en page CSS).

Cette coherence s'etend a toutes les proprietes de l'objet TextMetrics, pas seulement a width. Les valeurs actualBoundingBoxAscent, actualBoundingBoxDescent, fontBoundingBoxAscent, fontBoundingBoxDescent et bounding box gauche/droite correspondent toutes au profil.

Resultats bit a bit identiques entre plateformes

La reussite technique cle est les resultats bit a bit identiques. Cela signifie que la representation en virgule flottante du resultat de measureText() est identique octet par octet entre les plateformes. Il n'y a pas de seuil "suffisamment proche". Les valeurs sont mathematiquement identiques.

Ce niveau de coherence n'est possible qu'avec un controle au niveau du moteur. Toute approche operant au-dessus du moteur de rendu, comme les extensions, les proxies d'API ou les wrappers JavaScript, ne peut pas atteindre des resultats bit a bit identiques car elle ne peut pas controler l'arithmetique reelle effectuee par le moteur de polices.

BotBrowser y parvient en s'assurant que les mathematiques de mise a l'echelle des polices utilisent le meme modele de precision quelle que soit la plateforme hote. Le profil definit le comportement attendu, et le moteur produit exactement ce comportement. Les preferences de rendu de polices natives du systeme hote n'affectent pas la sortie.

Aucun artefact detectable

Parce que la protection opere au sein du moteur de rendu :

• measureText() renvoie des valeurs JavaScript Number natives avec une precision complete en virgule flottante double precision, exactement comme le ferait un navigateur non modifie.
• Il n'y a pas de modifications de prototypes, pas de wrapping de fonctions, pas d'interception au niveau JavaScript.
• Les valeurs sont coherentes avec le rendu de pixels Canvas. Le texte dessine sur un Canvas puis mesure pixel par pixel correspond a la largeur rapportee par measureText().
• Il n'y a pas d'anomalies statistiques dans la distribution des valeurs entre differentes tailles de police et chaines de texte.

Coherence interne avec d'autres signaux

La protection des metriques de texte n'opere pas isolement. Le profil s'assure que les valeurs de measureText() sont coherentes avec tous les autres signaux de polices et de rendu observables. Si un script de suivi valide les metriques de texte par rapport a la sortie de pixels Canvas, aux resultats d'enumeration de polices ou aux mesures de mise en page CSS, tous les signaux s'alignent avec la meme identite d'appareil. Cette coherence interne est critique, car les systemes de fingerprinting recherchent de plus en plus les desaccords entre differents types de signaux comme indicateur de falsification.

Configuration et utilisation

Utilisation CLI

Lancez BotBrowser avec un profil de fingerprint pour activer la protection de mesure de texte :

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

Pour des resultats deterministes entre les executions, ajoutez une graine de bruit :

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

Combinez avec les parametres de fuseau horaire, de localisation et de proxy pour une coherence d'identite complete :

chrome --bot-profile="/path/to/profile.enc" \
       --bot-noise-seed=12345 \
       --proxy-server="socks5://user:pass@proxy:1080" \
       --bot-config-timezone="America/New_York" \
       --bot-config-locale="en-US" \
       --bot-config-languages="en-US,en"

Integration Playwright

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

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

  const context = await browser.newContext({ viewport: null });
  const page = await context.newPage();

  await page.goto('https://example.com');

  // measureText() results will be consistent with the loaded profile
  const metrics = await page.evaluate(() => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    ctx.font = '16px Arial';
    const measurement = ctx.measureText('Sample text for measurement');
    return {
      width: measurement.width,
      actualBoundingBoxAscent: measurement.actualBoundingBoxAscent,
      actualBoundingBoxDescent: measurement.actualBoundingBoxDescent,
    };
  });

  console.log('Text metrics:', metrics);

  await browser.close();
})();

Integration Puppeteer

const puppeteer = require('puppeteer-core');

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

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

  // Verify text measurement from the loaded profile
  const metrics = await page.evaluate(() => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    ctx.font = '16px Arial';
    const m = ctx.measureText('Sample text for measurement');
    return { width: m.width };
  });

  console.log('Text width:', metrics.width);

  await browser.close();
})();

Verification

Apres avoir lance BotBrowser avec un profil, verifiez que la protection de mesure de texte est active :

const width = await page.evaluate(() => {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  ctx.font = '16px Arial';
  return ctx.measureText('Verification string').width;
});
console.log('Text width:', width);

Points a verifier :

1. La valeur de largeur est un nombre a virgule flottante de precision complete, coherent avec ce qu'un appareil reel avec la plateforme cible du profil renverrait.
2. Recharger la page et repeter la mesure produit la meme valeur.
3. Redemarrer le navigateur avec le meme profil et la meme graine de bruit produit la meme valeur.
4. Visitez des sites de test de fingerprint comme BrowserLeaks ou CreepJS et confirmez qu'aucune incoherence inter-signaux n'est signalee.

Meilleures pratiques

Toujours utiliser un profil complet

La protection de mesure de texte fonctionne dans le cadre du profil complet de fingerprint de BotBrowser. Le profil s'assure que les metriques de texte sont coherentes avec tous les autres signaux du navigateur : rendu Canvas, listes de polices, parametres WebGL et informations systeme. Charger un profil est necessaire pour que la protection de mesure de texte soit active.

Combiner avec l'identite reseau

Les metriques de texte identifient la plateforme. Les signaux reseau identifient la localisation. Pour une identite coherente, combinez le profil de fingerprint avec les parametres de proxy et de localisation appropries :

chrome --bot-profile="/path/to/profile.enc" \
       --proxy-server="socks5://user:pass@proxy:1080" \
       --bot-config-timezone="Europe/London" \
       --bot-config-locale="en-GB" \
       --bot-config-languages="en-GB,en"

Utiliser le mode deterministe pour les tests

Lors de l'execution de tests automatises ou d'experiences de recherche, utilisez --bot-noise-seed pour garantir des resultats reproductibles. Cela vous permet de verifier que les metriques de texte restent stables entre les executions de test et de detecter toute regression dans la coherence des metriques.

Tester avec plusieurs configurations de polices

Lors de la verification de la protection, testez avec une variete de familles de polices et de tailles. Incluez a la fois les polices web courantes et les valeurs par defaut du systeme dans votre ensemble de tests. Cela garantit une couverture complete de la coherence des metriques de texte de votre profil dans la gamme de polices que les scripts de suivi sondent generalement.

Maintenir les profils et BotBrowser a jour

Le fingerprinting par mesure de texte continue d'evoluer. De nouvelles proprietes TextMetrics ont ete ajoutees dans les versions recentes du navigateur, et les scripts de suivi mettent a jour leur collecte pour inclure ces nouveaux signaux. Gardez votre installation BotBrowser et vos profils a jour pour assurer la couverture des proprietes nouvellement exploitables.

FAQ

Qu'est-ce que le fingerprinting par mesure de texte ?

Le fingerprinting par mesure de texte utilise l'API Canvas measureText() pour determiner sur quelle plateforme un navigateur s'execute. L'API renvoie des valeurs de largeur de texte avec une precision sous-pixel, et ces valeurs different entre les systemes d'exploitation car chaque OS utilise un moteur de rendu integre different avec son propre modele arithmetique interne. En mesurant des chaines de texte specifiques a des tailles specifiques, un script de suivi peut identifier le systeme d'exploitation et distinguer les appareils individuels.

En quoi est-ce different du fingerprinting Canvas ?

Le fingerprinting Canvas rend du contenu visuel (texte, formes, degrades) sur un element Canvas et hache les donnees de pixels resultantes. Le fingerprinting par mesure de texte utilise measureText() pour obtenir des valeurs de largeur numeriques sans rien rendre de visible. La mesure de texte est plus rapide, produit un resultat numerique direct et fournit un type de signal different. Les deux techniques reposent sur des differences de rendu specifiques a la plateforme, mais elles operent sur differentes sorties de l'API Canvas. Vous pouvez en apprendre plus sur le fingerprinting Canvas dans notre guide Canvas Fingerprinting.

BotBrowser produit-il des valeurs identiques sur toutes les plateformes ?

Oui. Lorsque le meme profil de fingerprint est charge, BotBrowser produit des resultats measureText() bit a bit identiques sur macOS, Windows et Linux. Ceci est realise grace au controle au niveau du moteur des mathematiques de rendu de polices, garantissant que le meme profil produit toujours les memes resultats numeriques quel que soit le systeme d'exploitation hote.

La protection de mesure de texte casse-t-elle les sites web ?

Non. BotBrowser ne bloque ni ne modifie l'API measureText(). L'API fonctionne normalement, renvoyant des valeurs de largeur de texte precises que les applications web peuvent utiliser pour la mise en page, la troncature de texte, le rendu de graphiques et tous les autres usages legitimes. Les valeurs sont simplement coherentes avec le profil charge plutot qu'avec le rendu natif du systeme hote.

Comment cela se rapporte-t-il au fingerprinting de polices ?

Le fingerprinting par mesure de texte est etroitement lie au fingerprinting de polices mais cible un signal different. Le fingerprinting de polices identifie quelles polices sont installees en verifiant si des familles de polices specifiques sont disponibles. Le fingerprinting par mesure de texte identifie comment le moteur de rendu traite ces polices en examinant les valeurs de metriques sous-pixel. Les deux signaux sont derives de la pile de rendu de polices, et les deux sont couverts par la protection au niveau du moteur de BotBrowser. Pour un apercu plus large, consultez notre article sur le fingerprinting de navigateur.

Puis-je utiliser la protection de mesure de texte de BotBrowser avec des frameworks d'automatisation existants ?

Oui. BotBrowser s'integre avec Playwright, Puppeteer, Selenium et d'autres frameworks d'automatisation. La protection de mesure de texte est automatiquement active lorsqu'un profil de fingerprint est charge. Aucune configuration supplementaire ni modification de code n'est necessaire au-dela du passage du flag --bot-profile. Consultez le guide de demarrage Playwright et le guide de demarrage Puppeteer pour les instructions de configuration.

Cette protection couvre-t-elle toutes les proprietes TextMetrics ?

Oui. La protection de BotBrowser couvre l'ensemble complet des proprietes TextMetrics, incluant width, actualBoundingBoxLeft, actualBoundingBoxRight, actualBoundingBoxAscent, actualBoundingBoxDescent, fontBoundingBoxAscent et fontBoundingBoxDescent. Toutes les valeurs sont coherentes avec le profil charge sur toutes les plateformes.

Resume

Le fingerprinting par mesure de texte utilise la precision sous-pixel de l'API Canvas measureText() pour identifier les navigateurs par leur moteur de rendu. Parce que chaque systeme d'exploitation utilise un moteur de rendu integre different avec son propre modele arithmetique interne, le meme texte a la meme taille de police produit des valeurs de largeur mesurablement differentes sur chaque plateforme. Ces differences sont coherentes, reproductibles et activement collectees par les systemes de suivi commerciaux.

BotBrowser aborde le fingerprinting par mesure de texte au niveau du moteur du navigateur en controlant les mathematiques de rendu de polices au sein de Chromium. Lorsqu'un profil de fingerprint est charge, les calculs de mise a l'echelle des polices produisent des resultats bit a bit identiques sur macOS, Windows et Linux. Il n'y a pas de hooks au niveau de l'API, pas de modifications de prototypes et pas d'anomalies statistiques. Les valeurs sont internement coherentes avec tous les autres signaux de polices et de Canvas dans le profil, garantissant que les verifications croisees par les scripts de fingerprinting ne trouvent aucune incoherence.

Combinee avec la protection de BotBrowser pour le rendu Canvas, l'enumeration de polices et la coherence des profils multiplateformes, la protection de mesure de texte ferme l'un des vecteurs de fingerprinting les plus precis disponibles pour les systemes de suivi aujourd'hui.