Navigateur multi-comptes : identites isolees

Introduction

Exécuter plusieurs comptes ou identités au sein d'un seul navigateur est l'une des exigences de confidentialité les plus courantes. Que vous gériez des comptes de réseaux sociaux, testiez du contenu localisé dans différentes régions ou meniez des sessions de recherche parallèles, chaque identité doit être véritablement indépendante. Les cookies partagés, les signaux d'empreinte ou les chemins réseau entre les identités compromettent l'isolation.

BotBrowser fournit une véritable isolation par contexte où chaque contexte de navigateur possède ses propres signaux d'empreinte, proxy, paramètres géographiques, cookies et stockage. Cet article couvre l'architecture du modèle d'isolation de BotBrowser, les approches de configuration pour Playwright et Puppeteer, et les bonnes pratiques pour maintenir une séparation d'identité propre.

Impact sur la vie privée

Lorsque plusieurs identités partagent un aspect de leur environnement de navigateur, la corrélation devient possible. Les risques incluent :

• Adresses IP partagées : si deux comptes utilisent le même proxy, leur trafic peut être lié par IP
• Chevauchement d'empreintes : si deux contextes partagent les valeurs Canvas, WebGL ou d'empreinte audio, ils peuvent être identifiés comme provenant du même navigateur
• Fuites de cookies et de stockage : les cookies ou localStorage partagés entre les contextes lient directement les identités
• Incohérence géographique : un compte prétendant être en Allemagne mais partageant un fuseau horaire avec un compte américain révèle l'environnement partagé
• Corrélation temporelle : les comptes qui sont toujours actifs aux mêmes heures depuis la même instance de navigateur peuvent être liés par les schémas d'activité

Une véritable isolation nécessite l'indépendance sur toutes ces dimensions. L'isolation par contexte de BotBrowser traite chacune d'entre elles.

Contexte technique

Contextes de navigateur et frontières d'isolation

Dans les navigateurs basés sur Chromium, un contexte de navigateur est un environnement de navigation isolé. Chaque contexte possède ses propres :

• Jar de cookies
• localStorage et sessionStorage
• IndexedDB
• Stockage de cache
• Service workers
• Identifiants d'authentification HTTP

Le Chromium standard fournit cette isolation de stockage nativement. Cependant, de nombreux signaux d'empreinte sont partagés entre les contextes parce qu'ils proviennent du matériel et du système d'exploitation : le rendu Canvas, les chaînes vendeur/renderer WebGL, les caractéristiques de traitement audio, les dimensions de l'écran et les propriétés du navigator sont identiques dans tous les contextes d'un navigateur standard.

L'isolation étendue de BotBrowser

BotBrowser étend la frontière d'isolation au-delà du stockage pour inclure les signaux d'empreinte. Lorsque BotBrowser charge un profil, il configure les signaux d'empreinte au niveau du moteur. Combiné avec le support de proxy par contexte, chaque contexte peut présenter :

• Des signaux d'empreinte uniques : différents hash Canvas, chaînes de renderer WebGL, empreintes audio et propriétés du navigator
• Une identité réseau indépendante : une IP de proxy différente, avec un alignement géographique automatique
• Un stockage isolé : l'isolation de contexte standard de Chromium pour les cookies, localStorage et IndexedDB
• Des métadonnées géographiques correspondantes : fuseau horaire, locale et langue alignés avec le proxy du contexte

Instance unique vs. instances multiples

Il existe deux approches pour le fonctionnement multi-identités :

Une seule instance de navigateur avec plusieurs contextes (Playwright) : un processus navigateur exécute plusieurs contextes. Chaque contexte peut avoir son propre proxy. BotBrowser fournit une isolation d'empreinte par contexte au sein de cette instance unique.

Plusieurs instances de navigateur (Playwright ou Puppeteer) : chaque instance est un processus navigateur séparé avec son propre profil, proxy et répertoire de données utilisateur. Cela fournit l'isolation la plus forte car les instances ne partagent rien au niveau processus.

Les deux approches sont valides. Le multi-contexte sur instance unique est plus efficace en ressources. Les instances multiples fournissent une isolation plus forte au prix d'une utilisation de ressources plus élevée.

Approches courantes et leurs limites

Répertoires de profils de navigateur

Les navigateurs standard utilisent des répertoires de profils pour séparer les identités. Chaque profil a ses propres cookies et signets mais partage la même empreinte de navigateur. Les signaux Canvas, WebGL, audio et navigator sont identiques entre les profils car ils proviennent du même matériel.

Onglets conteneurs (Firefox)

Les Multi-Account Containers de Firefox isolent les cookies et le stockage par conteneur. Cependant, les signaux d'empreinte sont partagés. Tous les conteneurs rapportent le même hash Canvas, le même renderer WebGL et la même empreinte audio.

Installations de navigateur séparées

Exécuter des installations de navigateur complètement séparées (différents chemins de binaires, différents répertoires de données utilisateur) fournit une isolation forte mais est coûteux opérationnellement. Chaque installation nécessite son propre cycle de mise à jour, et il n'y a pas de gestion centralisée.

Machines virtuelles

Les VM fournissent l'isolation la plus forte : système d'exploitation séparé, profil matériel séparé, pile réseau séparée. Mais les VM sont gourmandes en ressources. Exécuter 10 identités signifie exécuter 10 VM, chacune consommant des gigaoctets de RAM et un CPU significatif.

L'approche de BotBrowser

Isolation d'empreinte par contexte

BotBrowser fournit l'isolation d'empreinte par contexte via son système de profils. Chaque instance de navigateur charge un profil qui définit l'empreinte. Pour les configurations multi-instances, chaque instance peut charger un profil différent :

# Instance 1 : identité US avec Profil A
chrome --bot-profile="/profiles/profile-a.enc" \
       --proxy-server="socks5://us-proxy:1080" \
       --user-data-dir="/tmp/session-us"

# Instance 2 : identité DE avec Profil B
chrome --bot-profile="/profiles/profile-b.enc" \
       --proxy-server="socks5://de-proxy:1080" \
       --user-data-dir="/tmp/session-de"

Chaque instance rapporte des hash Canvas, des chaînes de renderer WebGL, des empreintes audio, des propriétés du navigator, des dimensions d'écran et une disponibilité de polices différents.

Configuration multi-contexte Playwright

Pour l'isolation par contexte au sein d'une seule instance de navigateur :

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

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

// Contexte 1 : identité US
const usContext = await browser.newContext({
  proxy: { server: 'socks5://us-proxy:1080', username: 'user', password: 'pass' },
  locale: 'en-US',
  timezoneId: 'America/New_York',
});

// Contexte 2 : identité UK
const ukContext = await browser.newContext({
  proxy: { server: 'socks5://uk-proxy:1080', username: 'user', password: 'pass' },
  locale: 'en-GB',
  timezoneId: 'Europe/London',
});

// Contexte 3 : identité Japon
const jpContext = await browser.newContext({
  proxy: { server: 'socks5://jp-proxy:1080', username: 'user', password: 'pass' },
  locale: 'ja-JP',
  timezoneId: 'Asia/Tokyo',
});

const page1 = await usContext.newPage();
const page2 = await ukContext.newPage();
const page3 = await jpContext.newPage();

Configuration multi-instances Puppeteer

Puppeteer fonctionne mieux avec des instances de navigateur séparées pour une isolation complète des empreintes :

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

async function createIdentity(profile, proxy, timezone, locale, languages) {
  const userDataDir = '/tmp/session-' + Math.random().toString(36).slice(2);
  return puppeteer.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      `--bot-profile=${profile}`,
      `--proxy-server=${proxy}`,
      `--bot-config-timezone=${timezone}`,
      `--bot-config-locale=${locale}`,
      `--bot-config-languages=${languages}`,
      `--user-data-dir=${userDataDir}`,
      '--bot-local-dns',
      '--bot-webrtc-ice=google',
    ],
    headless: true,
    defaultViewport: null,
  });
}

const usBrowser = await createIdentity(
  '/profiles/us.enc', 'socks5://us-proxy:1080',
  'America/New_York', 'en-US', 'en-US,en'
);

const deBrowser = await createIdentity(
  '/profiles/de.enc', 'socks5://de-proxy:1080',
  'Europe/Berlin', 'de-DE', 'de-DE,de,en'
);

Graines de bruit déterministes pour la cohérence

Utilisez des valeurs --bot-noise-seed différentes par identité pour produire un bruit d'empreinte cohérent mais unique :

# Identité A
chrome --bot-profile="/profiles/profile.enc" \
       --bot-noise-seed=12345 \
       --proxy-server="socks5://proxy-a:1080"

# Identité B (même profil, graine de bruit différente = bruit d'empreinte différent)
chrome --bot-profile="/profiles/profile.enc" \
       --bot-noise-seed=67890 \
       --proxy-server="socks5://proxy-b:1080"

Chaque graine produit un motif de bruit unique et stable. La même graine produit toujours le même bruit, rendant les identités reproductibles entre les sessions.

Configuration et utilisation

Configuration multi-identité complète (CLI)

# Identité 1 : utilisateur Chrome US
chrome --bot-profile="/profiles/us-chrome.enc" \
       --proxy-server="socks5://user:pass@us-proxy:1080" \
       --bot-config-timezone="America/New_York" \
       --bot-config-locale="en-US" \
       --bot-config-languages="en-US,en" \
       --bot-noise-seed=11111 \
       --bot-local-dns \
       --bot-webrtc-ice=google \
       --bot-port-protection \
       --user-data-dir="/data/session-us"

# Identité 2 : utilisateur Edge allemand
chrome --bot-profile="/profiles/de-edge.enc" \
       --bot-config-browser-brand=edge \
       --proxy-server="socks5://user:pass@de-proxy:1080" \
       --bot-config-timezone="Europe/Berlin" \
       --bot-config-locale="de-DE" \
       --bot-config-languages="de-DE,de,en" \
       --bot-noise-seed=22222 \
       --bot-local-dns \
       --bot-webrtc-ice=google \
       --bot-port-protection \
       --user-data-dir="/data/session-de"

Multi-identité à grande échelle avec Playwright

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

const identities = [
  {
    name: 'us-user',
    proxy: 'socks5://us-proxy:1080',
    locale: 'en-US',
    timezone: 'America/New_York',
  },
  {
    name: 'uk-user',
    proxy: 'socks5://uk-proxy:1080',
    locale: 'en-GB',
    timezone: 'Europe/London',
  },
  {
    name: 'jp-user',
    proxy: 'socks5://jp-proxy:1080',
    locale: 'ja-JP',
    timezone: 'Asia/Tokyo',
  },
];

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

for (const identity of identities) {
  const context = await browser.newContext({
    proxy: { server: identity.proxy, username: 'user', password: 'pass' },
    locale: identity.locale,
    timezoneId: identity.timezone,
  });

  const page = await context.newPage();
  await page.goto('https://example.com');
  console.log(`${identity.name}: loaded`);
  // Effectuer les tâches spécifiques à l'identité...
}

Vérification

Après la configuration de plusieurs identités, vérifiez l'isolation sur toutes les dimensions :

async function verifyIdentity(context, label) {
  const page = await context.newPage();

  // Vérifier l'IP
  await page.goto('https://httpbin.org/ip');
  const ip = JSON.parse(await page.textContent('body'));
  console.log(`${label} IP:`, ip.origin);

  // Vérifier le fuseau horaire
  const tz = await page.evaluate(() =>
    Intl.DateTimeFormat().resolvedOptions().timeZone
  );
  console.log(`${label} Timezone:`, tz);

  // Vérifier le hash Canvas
  const canvasHash = await page.evaluate(() => {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    ctx.fillText('test', 10, 10);
    return canvas.toDataURL().slice(-20);
  });
  console.log(`${label} Canvas:`, canvasHash);

  // Vérifier le renderer WebGL
  const renderer = await page.evaluate(() => {
    const canvas = document.createElement('canvas');
    const gl = canvas.getContext('webgl');
    const ext = gl.getExtension('WEBGL_debug_renderer_info');
    return ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : 'N/A';
  });
  console.log(`${label} WebGL:`, renderer);

  await page.close();
}

await verifyIdentity(usContext, 'US');
await verifyIdentity(ukContext, 'UK');
await verifyIdentity(jpContext, 'JP');

Confirmez que chaque identité montre :

1. Une adresse IP différente
2. Un fuseau horaire différent correspondant à sa région de proxy
3. Des hash Canvas différents (lors de l'utilisation de profils ou graines de bruit différents)
4. Des chaînes de renderer WebGL différentes (lors de l'utilisation de profils différents)
5. Aucun cookie ou stockage partagé entre les contextes

Bonnes pratiques

1. Utilisez des profils séparés pour des identités séparées. Bien que les graines de bruit créent de la variation au sein d'un profil, des profils séparés fournissent l'isolation d'empreinte la plus forte.

2. Faites toujours correspondre la géographie du proxy avec la locale. Une locale japonaise avec un proxy américain crée une incohérence évidente.

3. Utilisez des répertoires de données utilisateur séparés. Chaque instance nécessite son propre --user-data-dir pour éviter les conflits de données de profil.

4. Activez la protection DNS et WebRTC globalement. Définissez --bot-local-dns et --bot-webrtc-ice sur chaque instance pour fermer les chemins de fuite réseau.

5. Fermez les contextes quand ils ne sont plus nécessaires. Les contextes ouverts consomment de la mémoire. Fermez-les pour libérer les ressources.

6. Ne partagez pas les cookies entre les identités. Chaque identité devrait avoir son propre état de cookies. Ne transférez jamais les cookies d'un contexte à un autre.

Questions fréquentes

Combien d'identités puis-je exécuter simultanément ? Il n'y a pas de limite stricte. L'isolation par contexte au sein d'une seule instance de navigateur est efficace en mémoire. En pratique, la limite dépend de la RAM disponible et de la complexité des pages chargées dans chaque contexte.

Puis-je utiliser le même profil pour plusieurs identités ? Oui, en combinant avec des valeurs --bot-noise-seed différentes. La graine de bruit modifie le bruit d'empreinte Canvas, WebGL et audio, créant des identités distinctes à partir du même profil de base.

Les contextes partagent-ils le cache du navigateur ? Non. Chaque contexte a son propre cache, cookies, localStorage et IndexedDB. Il n'y a aucun partage de données entre les contextes.

Dois-je utiliser Playwright ou Puppeteer pour les configurations multi-identités ? Playwright fournit un support natif de proxy par contexte, ce qui en fait le meilleur choix pour les configurations multi-contextes au sein d'une seule instance de navigateur. Puppeteer fonctionne mieux avec des instances de navigateur séparées par identité.

Puis-je conserver l'état de l'identité entre les sessions ? Oui. Utilisez --user-data-dir avec un répertoire persistant pour conserver les cookies, le cache et le stockage entre les sessions. Chaque identité devrait utiliser un répertoire séparé.

Comment gérer différentes marques de navigateur entre les identités ? Utilisez --bot-config-browser-brand pour définir différentes marques par instance. Voir Browser Brand Switching pour les détails.

L'isolation par contexte protège-t-elle contre le fingerprinting GPU ? BotBrowser contrôle les signaux WebGL et WebGPU via les profils. Chaque profil rapporte des valeurs différentes liées au GPU. L'isolation par contexte garantit que ces valeurs sont cohérentes au sein de chaque contexte.

Résumé

L'isolation multi-comptes du navigateur nécessite l'indépendance sur les signaux d'empreinte, l'identité réseau, les métadonnées géographiques et le stockage. BotBrowser fournit tout cela via son système de profils, le support de proxy par contexte et le contrôle d'empreinte au niveau du moteur. Que vous utilisiez l'approche multi-contexte de Playwright ou l'approche multi-instances de Puppeteer, chaque identité présente un environnement de navigateur complet et indépendant.

Pour la configuration du proxy, voir Proxy Configuration et Dynamic Proxy Switching. Pour la configuration géographique, voir Timezone, Locale, and Language Configuration. Pour l'identité de marque, voir Browser Brand Switching.