Fingerprinting des polices : listes et metriques

Introduction

Chaque système d'exploitation est livré avec un ensemble différent de polices. Les utilisateurs installent des polices supplémentaires pour le travail, le design ou les préférences personnelles. Cette combinaison de polices installées crée un identifiant étonnamment unique. Les sites web peuvent sonder les polices disponibles en mesurant la façon dont le texte est rendu à des tailles spécifiques, et la liste résultante de polices détectées forme une empreinte de polices. Au-delà de la liste des polices elle-même, les métriques de texte comme les largeurs de glyphes, les hauteurs et les boîtes englobantes varient selon les plateformes et les moteurs de rendu de polices. Ensemble, l'énumération des polices et les métriques de texte donnent aux systèmes de suivi un signal stable et à haute entropie qui persiste entre les sessions. Cet article explique comment fonctionne le fingerprinting des polices et comment BotBrowser contrôle l'identité des polices au niveau du moteur.

Impact sur la vie privée

Le fingerprinting des polices est un vecteur de suivi fiable depuis plus d'une décennie. L'étude Panopticlick de l'EFF a constaté que l'ensemble des polices installées était l'un des attributs de navigateur à la plus haute entropie, capable d'identifier de manière unique plus de 80 % des navigateurs dans leur jeu de données. Une étude de 2016 de l'Université d'Adélaïde a confirmé que les listes de polices fournissent 8 à 10 bits d'informations identifiantes en moyenne, et significativement plus pour les utilisateurs avec des logiciels spécialisés (designers, développeurs, utilisateurs avec des packs de langues CJK).

Le problème s'est amplifié à mesure que les systèmes d'exploitation se sont diversifiés. Windows, macOS et Linux ont chacun des ensembles de polices par défaut différents, et chaque version du système d'exploitation modifie les défauts. Windows 11 inclut des polices que Windows 10 n'a pas. macOS Sonoma diffère de macOS Ventura. Ces différences signifient que le fingerprinting des polices peut souvent identifier votre version exacte du système d'exploitation, réduisant la population avant que tout autre signal ne soit considéré.

Les environnements d'entreprise ajoutent une autre dimension. Les licences de polices d'entreprise (Helvetica Neue, Futura, polices de marque propriétaires) créent des empreintes distinctives liées à des organisations spécifiques. Les professionnels créatifs avec Adobe Fonts ou Google Fonts installés ont des ensembles de polices uniquement grands.

Contexte technique

Le fingerprinting des polices repose sur deux techniques principales.

Énumération des polices par mesure

Les navigateurs n'exposent pas d'API directe pour lister les polices installées (l'approche dépréciée document.fonts.check() a une couverture limitée). Au lieu de cela, les scripts de suivi utilisent une technique basée sur la mesure :

1. Créer un élément HTML masqué avec une police de repli connue (monospace, serif ou sans-serif).
2. Mesurer sa largeur et sa hauteur rendues.
3. Changer le font-family en une police candidate plus la police de repli.
4. Mesurer à nouveau. Si les dimensions changent, la police candidate est installée.

En testant des centaines de noms de polices, un script peut construire un vecteur binaire de polices installées/non installées. Ce vecteur est l'empreinte de polices.

Fingerprinting par métriques de texte

Au-delà de la liste des polices, les mesures précises du rendu de texte varient selon la plateforme. Celles-ci incluent :

• Métriques de texte Canvas. L'utilisation de measureText() sur un contexte Canvas 2D retourne des propriétés comme width, actualBoundingBoxAscent, actualBoundingBoxDescent, fontBoundingBoxAscent et fontBoundingBoxDescent. Ces valeurs dépendent du moteur de rendu de polices (DirectWrite sur Windows, CoreText sur macOS, FreeType sur Linux), des paramètres de hinting et de la configuration du rendu sous-pixel.
• Boîtes englobantes d'éléments. getBoundingClientRect() et getClientRects() retournent des dimensions qui varient selon le façonnage des polices, les tables de crénage et le comportement du moteur de mise en page.
• Rendu de texte OffscreenCanvas. Le texte dessiné sur un OffscreenCanvas produit des données de pixels qui varient selon la plateforme, fournissant un autre vecteur de mesure.

La combinaison de la liste des polices et des métriques de texte crée une empreinte composée à très haute entropie.

Pourquoi la sortie varie

Le rendu de polices est un processus complexe impliquant plusieurs couches :

• Format de fichier de police. Les polices TrueType et OpenType contiennent des instructions de hinting différentes qui affectent le rendu à petites tailles.
• Moteur de rendu. DirectWrite (Windows), CoreText (macOS) et FreeType (Linux) implémentent chacun le façonnage du texte, le hinting et la rastérisation différemment.
• Rendu sous-pixel. ClearType (Windows), l'anticrénelage sous-pixel (macOS) et les diverses configurations FreeType produisent une sortie visiblement différente au niveau sous-pixel.
• DPI et mise à l'échelle. Les écrans à haute résolution affectent les métriques de texte via la mise à l'échelle du ratio de pixels de l'appareil.

Approches de protection courantes et leurs limitations

Bloquer l'énumération des polices est impraticable car la technique utilise des API standard CSS et de mesure DOM. Vous ne pouvez pas bloquer getBoundingClientRect() sans casser la mise en page web.

Installer plus de polices pour se fondre dans la masse se retourne en fait contre vous. Un système avec 500 polices est plus unique qu'un avec les polices par défaut du système d'exploitation. L'empreinte de polices devient plus distinctive, pas moins.

Les extensions de navigateur qui prétendent protéger les empreintes de polices fonctionnent typiquement en injectant des remplacements CSS ou en interceptant les API de mesure. Ces approches sont fragiles. Une extension peut remplacer measureText() mais manquer getClientRects(). Ou elle peut rapporter une liste de polices générique tandis que le rendu réel utilise les vraies polices, créant une incohérence détectable.

Randomiser les métriques de texte casse les applications web. De nombreux sites s'appuient sur des mesures de texte précises pour les calculs de mise en page, les éditeurs de texte et le design responsive. Des valeurs aléatoires causent des problèmes visuels et des mises en page cassées.

Utiliser un ensemble minimal de polices (comme le fait Tor Browser) réduit l'unicité mais crée un profil distinctif en soi. Un navigateur avec exactement l'ensemble de polices de Tor Browser est identifiable comme étant probablement Tor.

L'approche au niveau du moteur de BotBrowser

BotBrowser contrôle le fingerprinting des polices au niveau du moteur Chromium via deux mécanismes : la gestion de la liste des polices et le contrôle du rendu de texte.

Listes de polices contrôlées

Lorsqu'un profil d'empreinte est chargé, BotBrowser configure le sous-système de polices pour rapporter exactement les polices que l'appareil profilé aurait. Ce n'est pas un remplacement CSS ni une interception JavaScript. L'énumération interne des polices du navigateur retourne la liste de polices du profil. Lorsqu'un site web sonde une police spécifique, la réponse (installée ou non installée) correspond au système profilé.

Cela couvre :

• Les résultats d'énumération des polices système
• L'ordre de résolution CSS font-family
• Les réponses de l'API document.fonts
• Le comportement de la chaîne de repli des polices

Cohérence des métriques de texte

Le système de profils de BotBrowser inclut des données de métriques de texte pour la plateforme cible. Lorsque le texte est mesuré via n'importe quelle API, les résultats sont cohérents avec le moteur de rendu de polices de l'appareil profilé :

• measureText() retourne des métriques correspondant au façonnage de texte et au hinting de la plateforme profilée.
• getBoundingClientRect() et getClientRects() retournent des dimensions cohérentes avec le moteur de rendu profilé.
• Le rendu de texte Canvas produit une sortie pixel correspondant à la plateforme profilée.
• Le bruit des rects client (contrôlé via --bot-config-noise-client-rects et --bot-config-noise-text-rects) ajoute une variation déterministe lorsqu'il est activé.

Émulation de polices inter-plateformes

Un point fort clé de l'approche de BotBrowser est l'émulation de polices inter-plateformes. En fonctionnant sur Linux, vous pouvez charger un profil Windows et obtenir des listes de polices et des métriques de texte typiques de Windows. L'empreinte de polices correspond à un vrai système Windows, pas à un système Linux prétendant avoir des polices Windows.

C'est possible parce que BotBrowser contrôle le rendu des polices au niveau du moteur, pas via l'installation de fichiers de polices. Vous n'avez pas besoin d'installer des polices Windows sur votre système Linux.

Configuration et utilisation

Protection de base des polices

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

Options de configuration des polices

# Utiliser les paramètres de polices du profil (par défaut, recommandé)
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-fonts=profile

# Polices du profil plus polices système de repli
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-fonts=expand

# Utiliser les vraies polices système (pas de protection de polices)
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-fonts=real

Contrôle du bruit des métriques de texte

# Activer le bruit des rects client pour la variation de mesure
chrome --bot-profile="/path/to/profile.enc" \
       --bot-config-noise-client-rects=true \
       --bot-config-noise-text-rects=true \
       --bot-noise-seed=42

Intégration Playwright

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

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

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

Intégration 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-config-fonts=profile',
    '--bot-noise-seed=42'
  ]
});

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

Vérification

Vérification de la liste des polices. Utilisez un site de test d'empreinte pour voir quelles polices sont détectées. La liste devrait correspondre au système d'exploitation et à la configuration cibles du profil, pas à votre système réel.

Vérification des métriques de texte. Mesurez une chaîne standard (par ex., "Hello World" en 16px Arial) avec measureText() et comparez les résultats entre les sessions et les machines. Avec le même profil et la même graine de bruit, les valeurs devraient être identiques.

Vérification de cohérence de plateforme. Si vous chargez un profil Windows sur Linux, vérifiez que les polices détectées sont typiques de Windows (Segoe UI, Calibri, Consolas) plutôt que typiques de Linux (Liberation Sans, DejaVu Sans).

Vérification inter-API. Comparez les résultats de détection de polices de la mesure CSS, de measureText() Canvas et de getClientRects(). Tous devraient être cohérents avec le même ensemble de polices.

Bonnes pratiques

• Utilisez --bot-config-fonts=profile (par défaut). Cela fournit la protection de polices la plus complète. L'option expand ajoute des polices système comme repli, ce qui peut introduire une variation locale.
• Combinez la protection des polices avec le bruit canvas. Les métriques de texte et le rendu canvas sont étroitement liés. Activez les deux pour une protection complète.
• Utilisez des profils correspondant à votre région cible. Les ensembles de polices CJK, les polices RTL et les défauts spécifiques à la locale varient significativement. Utilisez un profil qui correspond à votre locale attendue.
• Testez avec plusieurs listes de sondage de polices. Différents systèmes de suivi sondent différentes listes de polices. Vérifiez votre protection contre plusieurs outils de test.
• Évitez d'installer des polices distinctives. Si vous utilisez --bot-config-fonts=expand ou real, les polices inhabituelles sur votre système seront détectables.

FAQ

Q : Combien de polices les scripts de suivi sondent-ils typiquement ? R : Les bibliothèques de fingerprinting courantes testent entre 50 et 500 noms de polices. Certains scripts complets sondent plus de 1 000 polices ciblant des plateformes et des installations logicielles spécifiques.

Q : BotBrowser intègre-t-il des fichiers de polices réels dans le profil ? R : Les profils de BotBrowser contiennent les informations nécessaires pour contrôler l'énumération des polices et le comportement des métriques de texte. Le moteur produit des mesures cohérentes avec la plateforme profilée sans nécessiter l'installation réelle de fichiers de polices.

Q : Le fingerprinting des polices peut-il identifier ma version exacte du système d'exploitation ? R : Oui. Les ensembles de polices par défaut changent entre les versions du système d'exploitation. Windows 11, Windows 10, macOS Sonoma et macOS Ventura ont chacun des polices par défaut différentes. Les systèmes de suivi maintiennent des bases de données associant les ensembles de polices aux versions du système d'exploitation.

Q : À quoi sert le mode de polices expand ? R : Le mode expand utilise la liste de polices du profil comme ensemble principal et ajoute les polices système comme repli. C'est utile si votre application nécessite des polices système spécifiques pour le rendu mais que vous souhaitez toujours une énumération de polices basée sur le profil.

Q : La protection des polices affecte-t-elle le chargement des polices web ? R : Non. Les polices web téléchargées depuis des serveurs (via @font-face) ne sont pas affectées par la protection de l'empreinte de polices. Seule la détection des polices locales/système est contrôlée.

Q : Les métriques de texte sont-elles cohérentes entre le mode headless et le mode avec fenêtre ? R : Oui. BotBrowser contrôle les métriques de texte au niveau du moteur indépendamment du mode d'affichage.

Résumé

Le fingerprinting des polices combine l'énumération des polices et les mesures de métriques de texte pour créer un signal de suivi à haute entropie qui varie selon les systèmes d'exploitation, les versions et les installations individuelles. BotBrowser contrôle à la fois la liste des polices rapportée et les métriques de rendu de texte au niveau du moteur, produisant des résultats cohérents avec le profil chargé indépendamment de vos polices système réelles. Avec --bot-config-fonts=profile et --bot-noise-seed, les empreintes de polices sont stables, cohérentes et authentiques.

Pour les sujets connexes, consultez Qu'est-ce que le Browser Fingerprinting, Cohérence des signaux CSS, Canvas Fingerprinting et Protection de l'écran et de la fenêtre.