Detection de protocoles : detecter les apps installees

Introduction

Les systèmes d'exploitation permettent aux applications d'enregistrer des schémas d'URL personnalisés, aussi appelés gestionnaires de protocole. Lorsqu'une application comme Slack, VS Code, Zoom ou Steam est installée, elle enregistre un protocole (comme slack://, vscode://, zoommtg:// ou steam://) qui permet à d'autres applications et sites web de la lancer directement via une URL. Ce système alimente les liens profonds, permettant à un site web d'ouvrir une vue spécifique d'une application, de rejoindre une réunion ou de lancer un jeu via un simple clic sur un lien.

Cependant, le mécanisme qui rend les gestionnaires de protocole utiles en fait aussi une surface de fingerprinting. Les sites web peuvent tenter de naviguer vers des URL de protocole personnalisé et observer la réponse du navigateur. Le comportement diffère selon que l'application associée au protocole est installée : le navigateur peut afficher une invite pour ouvrir l'application, rediriger silencieusement, afficher une erreur, ou simplement ne rien faire. En testant une liste de schémas de protocole connus, un site web peut construire un profil des applications installées sur l'appareil du visiteur, créant une empreinte hautement distinctive.

Impact sur la vie privée

La détection d'applications basée sur les protocoles est l'une des techniques de fingerprinting les plus invasives pour la vie privée car elle révèle des informations sur l'environnement logiciel de l'utilisateur plutôt que sur son matériel. Alors que les empreintes matérielles identifient l'appareil, les empreintes d'applications identifient la personne et ses activités.

Les implications pour la vie privée sont significatives :

• Inventaire logiciel : en testant les gestionnaires de protocole courants (Spotify, Discord, Telegram, WhatsApp, Steam, Epic Games, Zoom, Teams, VS Code, Sublime Text, et des dizaines d'autres), un site web peut déterminer quelles applications sont installées.
• Profilage comportemental : les applications installées révèlent les intérêts, la profession et les schémas de comportement. Un développeur avec vscode://, iterm2:// et docker:// présente un profil différent d'un joueur avec steam://, epicgames:// et discord://.
• Unicité de l'appareil : la combinaison spécifique d'applications installées est hautement unique. Même parmi les appareils avec un matériel identique, l'ensemble logiciel installé varie dramatiquement entre les utilisateurs.
• Pistage inter-navigateurs : les gestionnaires de protocole sont enregistrés au niveau du système d'exploitation, pas au niveau du navigateur. Cela signifie que la même empreinte d'application persiste à travers tous les navigateurs sur l'appareil.

Une étude marquante de 2021 par FingerprintJS a démontré que le fingerprinting basé sur les protocoles pouvait tester 32 applications populaires en quelques secondes, produisant une empreinte qui identifiait uniquement 95% des sujets de test.

La technique est particulièrement préoccupante car elle ne nécessite aucune permission et peut être effectuée silencieusement. Il n'y a aucune notification à l'utilisateur que ses applications installées sont sondées.

Contexte technique

Comment fonctionne la détection de protocole

La détection de protocole exploite le comportement du navigateur lors de la navigation vers une URL avec un schéma personnalisé inconnu ou enregistré. Plusieurs techniques ont été développées :

Méthode de navigation par iframe : un site web crée un iframe caché et définit son src vers une URL de protocole personnalisé (par ex. slack://open). Si Slack est installé, le navigateur tente de gérer la navigation. Sinon, l'iframe reçoit une erreur.

Méthode de fenêtre popup : ouvrir un window.open() vers une URL de protocole personnalisé produit un comportement différent selon l'enregistrement du gestionnaire.

Détection focus/blur : lorsqu'un gestionnaire de protocole lance une application externe, la fenêtre du navigateur perd le focus. En surveillant les événements blur et focus, un site web peut détecter si une application a été lancée avec succès.

Détection basée sur le timing : le temps pris par le navigateur pour traiter une navigation de protocole varie selon qu'un gestionnaire existe. Les gestionnaires installés produisent une réponse plus rapide ou plus lente (selon le navigateur) que les protocoles non enregistrés, et cette différence de timing est mesurable.

Le problème de l'inondation de schémas

En 2021, des chercheurs ont démontré une technique appelée "scheme flooding" qui exploitait les gestionnaires de protocole pour identifier de manière fiable les utilisateurs à travers plusieurs navigateurs sur le même appareil. La technique impliquait de tester des dizaines de schémas de protocole en succession rapide et de mesurer le motif de réponse.

Approches de protection courantes et leurs limites

VPN et serveurs proxy

Les VPN n'ont aucun effet sur la détection des gestionnaires de protocole. L'enregistrement de protocole est une propriété locale du système d'exploitation, et la détection se produit entièrement dans le navigateur.

Navigation privée et mode incognito

Les modes de navigation privée n'altèrent pas l'enregistrement des gestionnaires de protocole. Les mêmes applications sont installées en mode privé qu'en fenêtre normale, car les gestionnaires de protocole sont enregistrés au niveau du système d'exploitation.

Extensions de navigateur

Les extensions peuvent tenter d'intercepter la navigation de protocole, mais bloquer la navigation crée un comportement lui-même observable, et le délai de l'interception de l'extension est lui-même détectable.

Mitigations des navigateurs

Les navigateurs modernes ont implémenté certaines protections : Chrome a ajouté la limitation du taux pour les vérifications de gestionnaires de protocole, Safari a implémenté des politiques de même origine plus strictes, et Firefox a ajouté des exigences de geste utilisateur.

L'approche de BotBrowser au niveau du moteur

BotBrowser contrôle le comportement des gestionnaires de protocole au niveau du moteur du navigateur, garantissant que toutes les tentatives de navigation de protocole produisent des réponses uniformes indépendamment des applications réellement installées sur le système hôte.

Normalisation du timing

BotBrowser normalise le timing du traitement de la navigation de protocole de sorte que les protocoles enregistrés et non enregistrés produisent des signatures de timing indistinguables :

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

Réponse comportementale uniforme

Au-delà du timing, BotBrowser garantit que le comportement observable (états d'erreur, événements focus/blur, statut de l'iframe) est cohérent pour toutes les tentatives de navigation de protocole. Le navigateur ne révèle pas si un gestionnaire existe par un canal comportemental quelconque.

Pas de fuite de l'environnement hôte

La garantie clé est que les applications installées de la machine hôte ne fuient pas à travers les requêtes de gestionnaires de protocole. Que l'hôte ait Slack, Steam, VS Code, ou aucune application personnalisée installée, le comportement des gestionnaires de protocole est contrôlé par le profil, pas par l'environnement hôte.

Configuration et utilisation

Utilisation CLI de base

La protection des gestionnaires de protocole est automatique lors du chargement d'un profil :

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

Intégration Playwright

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

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

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

  await page.goto('https://example.com');
  // Les requêtes de gestionnaires de protocole produiront des réponses uniformes
  // indépendamment des applications installées de la machine hôte
  await browser.close();
})();

Intégration Puppeteer

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

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

  const page = await browser.newPage();
  await page.goto('https://example.com');
  // Les signaux de gestionnaires de protocole sont contrôlés par le profil
  await browser.close();
})();

Vérification

Points de vérification :

1. Les différences de timing entre les protocoles connus et inconnus sont minimales (dans la plage de bruit)
2. Aucun événement focus/blur n'est déclenché par les sondes de protocole
3. Les pages de test de détection de protocole (comme SchemeFlood.com) montrent des résultats uniformes
4. Les applications installées de la machine hôte ne sont pas détectables via les requêtes de protocole

Bonnes pratiques

1. Utilisez des profils complets. La protection des gestionnaires de protocole fonctionne mieux dans le cadre d'un profil complet qui contrôle toutes les surfaces d'empreinte de manière cohérente.

2. Testez contre les méthodes de détection connues. Visitez les pages de test de fingerprinting par protocole pour vérifier que votre configuration ne divulgue pas d'informations sur les applications installées.

3. Combinez avec d'autres protections. La détection de gestionnaires de protocole est souvent utilisée aux côtés du fingerprinting Canvas, WebGL et polices. Utilisez un profil complet pour garantir que tous les vecteurs sont couverts.

4. Gardez les profils à jour. À mesure que les navigateurs implémentent de nouvelles mitigations et que les techniques de détection évoluent, des profils mis à jour garantissent une protection continue.

Questions fréquentes

La détection de protocole peut-elle identifier des versions spécifiques d'application ?

Généralement non. La détection de gestionnaires de protocole révèle si une application est installée, pas quelle version. Cependant, certaines applications enregistrent des schémas de protocole spécifiques à la version.

La détection de protocole fonctionne-t-elle sur tous les systèmes d'exploitation ?

La technique fonctionne sous Windows, macOS et Linux, mais le comportement spécifique varie par système d'exploitation. Les gestionnaires de protocole Windows sont enregistrés dans le Registre Windows. macOS utilise les déclarations Info.plist dans les bundles d'applications. Linux utilise les fichiers .desktop. BotBrowser normalise le comportement indépendamment du système d'exploitation hôte.

Les sites web peuvent-ils détecter la protection des gestionnaires de protocole ?

Si la protection est appliquée au niveau JavaScript (interception des événements de navigation), l'interception elle-même peut être détectée. BotBrowser applique la protection au niveau du moteur, rendant la normalisation invisible pour les scripts de page.

Cela casse-t-il les liens de protocole légitimes ?

Non. La protection de BotBrowser cible le comportement de sondage utilisé pour le fingerprinting, pas la navigation de protocole légitime. Lorsqu'un utilisateur ou un script suit explicitement un lien de protocole dans le cadre d'un workflow normal, la navigation fonctionne normalement.

Combien de protocoles peuvent être testés dans un script de fingerprinting ?

Les scripts de fingerprinting modernes testent 20-40 gestionnaires de protocole courants. Chaque test prend approximativement 100-500ms selon la méthode, donc un scan complet peut se terminer en 5-20 secondes. La normalisation du timing de BotBrowser rend tous les tests indistinguables.

Résumé

Les gestionnaires de protocole URL personnalisés exposent l'inventaire d'applications installées de l'utilisateur, créant l'une des surfaces de fingerprinting les plus distinctives disponibles. La technique fonctionne entre les navigateurs, survit aux modes de navigation privée et révèle des informations personnelles sur les activités et intérêts de l'utilisateur. BotBrowser contrôle le comportement des gestionnaires de protocole au niveau du moteur du navigateur, normalisant les réponses de timing et de comportement de sorte que les applications installées ne puissent pas être détectées par le sondage de protocole. Pour une protection connexe, voir navigator properties protection, font fingerprinting control, et comprehensive profile management.