En-tetes HTTP personnalises : controle des requetes

Introduction

Les en-tetes HTTP font partie de chaque requete que votre navigateur envoie. Des en-tetes comme User-Agent, Accept-Language, Sec-CH-UA et Referer constituent une part importante de l'identite reseau de votre navigateur. Lorsque ces en-tetes sont incoherents avec votre profil d'empreinte, ou lorsque vous devez injecter des en-tetes specifiques a l'application pour l'authentification et le routage, les API standard du navigateur sont insuffisantes.

BotBrowser fournit un controle des en-tetes au niveau du moteur via le flag --bot-custom-headers et la commande CDP BotBrowser.setCustomHeaders. Contrairement aux approches basees sur des extensions qui interceptent les requetes apres leur formation, BotBrowser modifie les en-tetes avant que la requete ne quitte la pile reseau du navigateur, couvrant tous les types de requetes sans ecarts de timing.

Impact sur la vie privee

Les en-tetes HTTP revelent une quantite surprenante d'informations sur votre environnement de navigateur. La chaine User-Agent identifie la version de votre navigateur et votre systeme d'exploitation. Accept-Language revele vos preferences linguistiques et, par extension, votre region geographique probable. Les en-tetes Client Hints (Sec-CH-UA, Sec-CH-UA-Platform, Sec-CH-UA-Mobile) fournissent des donnees structurees sur la marque de votre navigateur, votre plateforme et votre type d'appareil.

Lorsque ces en-tetes ne s'alignent pas avec d'autres aspects de votre empreinte, l'incoherence se remarque. Un navigateur signalant Accept-Language: de-DE mais avec un fuseau horaire americain, ou un Sec-CH-UA-Platform: "Windows" mais avec des proprietes navigator specifiques a macOS, cree des decalages que les systemes de suivi peuvent correler.

Les profils BotBrowser alignent automatiquement tous les en-tetes standard avec l'identite du profil. Le User-Agent, tous les en-tetes Sec-CH-UA-* et Accept-Language sont derives des parametres de navigateur, de plateforme et de configuration regionale du profil. Les en-tetes personnalises ajoutes via --bot-custom-headers etendent cette base sans perturber l'ensemble d'en-tetes standard du profil.

Contexte technique

Comment les navigateurs construisent les en-tetes de requete

Lorsqu'un navigateur envoie une requete HTTP, il construit les en-tetes a partir de plusieurs sources :

1. En-tetes integres : User-Agent, Accept, Accept-Encoding, Accept-Language sont ajoutes par le moteur du navigateur en fonction des parametres internes.
2. Client Hints : Sec-CH-UA, Sec-CH-UA-Mobile, Sec-CH-UA-Platform sont envoyes par defaut. Les hints haute entropie comme Sec-CH-UA-Full-Version-List ne sont envoyes que lorsque le serveur les demande via Accept-CH.
3. En-tetes d'application : en-tetes definis par JavaScript via fetch() ou XMLHttpRequest.
4. En-tetes injectes par les extensions : en-tetes ajoutes par les extensions de navigateur via l'API webRequest.

L'ordre et la composition de ces en-tetes creent un motif coherent pour chaque navigateur. Chrome, Edge et Firefox produisent chacun des ordres et des combinaisons d'en-tetes differents.

Coherence des en-tetes basee sur le profil

Lorsque BotBrowser charge un profil d'empreinte, il configure tous les en-tetes standard pour correspondre a l'identite du profil :

• User-Agent correspond a la version du navigateur et a la plateforme du profil
• Sec-CH-UA contient les jetons de marque corrects dans le bon ordre
• Sec-CH-UA-Platform correspond au systeme d'exploitation du profil
• Accept-Language reflete la configuration regionale et les preferences linguistiques configurees

Ces en-tetes sont definis au niveau du moteur et s'appliquent a toutes les requetes, y compris la requete de navigation initiale, les chargements de sous-ressources et les requetes initiees par JavaScript. Il n'y a pas d'ecart de timing ou des en-tetes incorrects pourraient etre observes.

En-tetes personnalises vs en-tetes standard

Les en-tetes personnalises (ceux commencant par X- ou des noms specifiques a l'application) servent un objectif different des en-tetes standard. Ils transportent des donnees specifiques a l'application : jetons d'authentification, identifiants de session, marqueurs de version d'application ou indices de routage. Le flag --bot-custom-headers de BotBrowser ajoute ces en-tetes personnalises sans modifier les en-tetes standard geres par le profil.

Approches courantes et leurs limites

Modification des en-tetes basee sur les extensions

Les extensions de navigateur peuvent modifier les en-tetes via l'API webRequest.onBeforeSendHeaders. Cette approche a plusieurs inconvenients :

• Problemes de timing : la premiere requete (la requete de navigation) peut partir avant que l'ecouteur de l'extension ne soit completement enregistre
• Couverture incomplete : les requetes de service workers, les requetes CORS preflight et certaines requetes internes peuvent ne pas declencher l'ecouteur de l'extension
• Artefacts detectables : les extensions qui modifient les en-tetes laissent des traces dans la surface d'API des extensions du navigateur
• Surcharge de performance : chaque requete passe par le gestionnaire JavaScript de l'extension, ajoutant de la latence

Surcharges d'en-tetes basees sur CDP

Puppeteer et Playwright fournissent des API de surcharge d'en-tetes via CDP :

// Puppeteer - limited approach
await page.setExtraHTTPHeaders({ 'X-Custom': 'value' });

Cela fonctionne pour les en-tetes au niveau de la page mais a des limites :

• Les en-tetes definis de cette maniere ne s'appliquent qu'a la page specifique
• Les service workers et les shared workers peuvent ne pas recevoir les en-tetes personnalises
• La commande CDP Network.setExtraHTTPHeaders necessite Network.enable, ce qui peut lui-meme affecter le fingerprinting

En-tetes Fetch/XHR JavaScript

Definir des en-tetes sur des appels individuels fetch() ou XMLHttpRequest ne couvre que les requetes initiees par JavaScript. Les requetes de navigation, les chargements d'images, les recuperations de feuilles de style et d'autres requetes initiees par le navigateur ne sont pas couvertes.

L'approche de BotBrowser

Le flag --bot-custom-headers

Le flag --bot-custom-headers de BotBrowser (PRO) injecte des en-tetes personnalises au niveau du moteur du navigateur :

chrome --bot-profile="/path/to/profile.enc" \
       --bot-custom-headers='{"X-Custom-Header":"value","X-Auth-Token":"abc123"}' \
       --user-data-dir="$(mktemp -d)"

Parce que la modification se produit a l'interieur de la pile reseau de Chromium, les en-tetes personnalises sont ajoutes a :

• Les requetes de navigation initiales
• Les requetes de sous-ressources (images, scripts, feuilles de style, polices)
• Les requetes XHR et Fetch API
• Les requetes de mise a niveau WebSocket
• Les requetes de service workers

Il n'y a pas d'ecarts de timing ni de types de requetes manques.

La commande CDP BotBrowser.setCustomHeaders

Pour la gestion des en-tetes a l'execution, BotBrowser fournit une commande CDP qui peut etre envoyee a la session de niveau navigateur :

Puppeteer :

const cdpSession = await browser.target().createCDPSession();
await cdpSession.send('BotBrowser.setCustomHeaders', {
  headers: { 'x-requested-with': 'com.example.app' }
});

Playwright :

const cdpSession = await browser.newBrowserCDPSession();
await cdpSession.send('BotBrowser.setCustomHeaders', {
  headers: { 'x-requested-with': 'com.example.app' }
});

Important : cette commande doit etre envoyee a la session CDP de niveau navigateur, pas a une session de niveau page. L'envoyer a une cible de page retournera ProtocolError: 'BotBrowser.setCustomHeaders' wasn't found.

Configuration au niveau du profil

Les en-tetes personnalises peuvent egalement etre definis dans la configuration du profil via configs.customHeaders. Cela est utile lorsque vous souhaitez que les en-tetes soient integres dans le profil lui-meme plutot que specifies au moment du lancement.

Configuration et utilisation

Configuration CLI avec en-tetes personnalises

chrome --bot-profile="/path/to/profile.enc" \
       --bot-custom-headers='{"X-App-Version":"2.1.0","X-Session-ID":"sess_abc123"}' \
       --proxy-server=socks5://user:pass@proxy:1080 \
       --user-data-dir="$(mktemp -d)"

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-custom-headers={"X-Auth":"token123","X-Client":"webapp"}',
    ],
    headless: true,
  });

  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://example.com');
  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-custom-headers={"X-Auth":"token123"}',
    ],
    headless: true,
    defaultViewport: null,
  });

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

Guillemets JavaScript

Lorsque vous passez --bot-custom-headers depuis JavaScript, n'incluez pas de guillemets de style shell dans la valeur :

// Correct
const headers = { 'X-Custom': 'value', 'X-Auth': 'token' };
args.push('--bot-custom-headers=' + JSON.stringify(headers));

// Wrong - single quotes become part of the JSON value
args.push(`--bot-custom-headers='${JSON.stringify(headers)}'`);

Mises a jour des en-tetes a l'execution via CDP

Pour les workflows qui necessitent de changer les en-tetes personnalises pendant la session :

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 cdpSession = await browser.newBrowserCDPSession();

  // Set initial headers
  await cdpSession.send('BotBrowser.setCustomHeaders', {
    headers: { 'x-requested-with': 'com.example.app' }
  });

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

  // Update headers mid-session
  await cdpSession.send('BotBrowser.setCustomHeaders', {
    headers: { 'x-requested-with': 'com.example.app', 'x-session': 'refreshed' }
  });

  await page.goto('https://example.com/dashboard');
  await browser.close();
})();

Verification

Apres avoir lance BotBrowser avec des en-tetes personnalises, verifiez qu'ils sont appliques :

1. Ouvrez une page qui renvoie les en-tetes de requete (comme httpbin.org/headers)
2. Confirmez que vos en-tetes personnalises apparaissent dans la reponse
3. Verifiez l'onglet Reseau dans DevTools pour voir les en-tetes sur tous les types de requetes
4. Verifiez que les en-tetes standard (User-Agent, Sec-CH-UA) correspondent toujours au profil

const page = await context.newPage();
await page.goto('https://httpbin.org/headers');
const headersText = await page.textContent('body');
console.log('Request headers:', headersText);

Bonnes pratiques

1. Utilisez --bot-custom-headers pour les en-tetes statiques. Si les en-tetes ne changent pas pendant la session, le flag CLI est plus simple que CDP.

2. Utilisez BotBrowser.setCustomHeaders pour les en-tetes dynamiques. Lorsque les en-tetes doivent changer pendant la session (par exemple, rotation de jetons d'authentification), utilisez la commande CDP.

3. Ne surchargez pas les en-tetes geres par le profil. Les en-tetes personnalises doivent ajouter de nouveaux en-tetes, pas remplacer User-Agent ou Sec-CH-UA. Surcharger les en-tetes du profil cree des incoherences.

4. Evitez les noms d'en-tetes d'extension courants. Les en-tetes comme X-Forwarded-For ou X-Real-IP peuvent entrer en conflit avec l'infrastructure proxy. Utilisez des noms specifiques a l'application.

5. Testez avec httpbin.org/headers. Ce endpoint renvoie tous les en-tetes recus, facilitant la verification de votre configuration.

6. Utilisez toujours la session CDP de niveau navigateur pour setCustomHeaders. Les sessions de niveau page retourneront une erreur car la commande opere au niveau du navigateur.

Questions frequemment posees

Les en-tetes personnalises s'appliquent-ils a toutes les requetes ou seulement a la navigation ? Toutes les requetes. BotBrowser applique les en-tetes personnalises au niveau du moteur, couvrant la navigation, les sous-ressources, XHR, Fetch, WebSocket et les requetes de service workers.

Puis-je definir differents en-tetes personnalises par contexte ? Le flag --bot-custom-headers s'applique a tous les contextes. Pour des en-tetes par contexte, utilisez la commande CDP BotBrowser.setCustomHeaders, qui peut etre mise a jour entre les operations de contexte.

Les en-tetes personnalises affectent-ils l'empreinte ? Les en-tetes personnalises qui ne font pas partie de l'ensemble standard des en-tetes du navigateur (comme X-Custom-Header) n'affectent pas l'empreinte du navigateur. Ce sont simplement des en-tetes supplementaires dans la requete.

Puis-je supprimer un en-tete standard ? BotBrowser ne prend pas en charge la suppression des en-tetes standard via les en-tetes personnalises. Les en-tetes geres par le profil sont toujours inclus pour maintenir la coherence de l'empreinte.

Est-ce que --bot-custom-headers fonctionne avec --proxy-server ? Oui. Les en-tetes personnalises sont ajoutes aux requetes que qu'un proxy soit configure ou non. Le proxy voit l'ensemble complet des en-tetes.

Quel est le nombre maximum d'en-tetes personnalises que je peux definir ? Il n'y a pas de limite specifique. Cependant, des ensembles d'en-tetes excessivement grands peuvent augmenter la taille de la requete et peuvent declencher des limites cote serveur.

Puis-je utiliser --bot-custom-headers pour les en-tetes Cookie ? Pour la gestion des cookies, utilisez le flag dedie --bot-cookies a la place. Il fournit une gestion correcte des cookies avec le cadrage de domaine et l'expiration.

Resume

Le controle des en-tetes HTTP est essentiel pour maintenir une identite de navigateur coherente. BotBrowser fournit une gestion des en-tetes au niveau du moteur via les profils (pour les en-tetes standard), le flag --bot-custom-headers (pour les en-tetes personnalises statiques) et la commande CDP BotBrowser.setCustomHeaders (pour les en-tetes dynamiques a l'execution). Ensemble, ces outils garantissent que chaque requete transporte des informations d'en-tetes coherentes et completes.

Pour la configuration reseau associee, consultez Configuration proxy et Controle du User Agent et Client Hints. Pour la gestion d'identite entre plusieurs comptes, consultez Isolation multi-comptes du navigateur.