Les données de configuration non définies par l'utilisateur seront automatiquement renseignées à l'aide des empreintes [BrowserForge](https://github.com/daijro/browserforge), qui imitent la distribution statistique des caractéristiques des appareils dans le trafic réel.

[[See implemented properties](https://camoufox.com/fingerprint/)]

---

## Utilisation en Python

Camoufox est compatible avec votre code Playwright existant. Vous avez seulement à modifier l'initialisation de votre navigateur.

**API synchrone**```python
from camoufox.sync_api import Camoufox

with Camoufox() as browser:
    page = browser.new_page()
    page.goto("https://example.com")

[[Installation et utilisation](https://camoufox.com/python/)]

### Tirer pleinement parti de l'usurpation matérielle

Pour les versions stables, vous devriez toujours utiliser le paquet pip principal [`camoufox`](https://pypi.org/project/camoufox/). Cependant, si vous souhaitez utiliser les empreintes par contexte et l'usurpation matérielle, utilisez le paquet [`cloverlabs-camoufox`](https://pypi.org/project/cloverlabs-camoufox/). Ce paquet est mis à jour à chaque publication, alors que le paquet officiel est publié avec un délai.

Assurez-vous d'utiliser un environnement virtuel pour éviter les conflits entre les deux paquets.

**Installation**```bash
pip install cloverlabs-camoufox

**Utilisation** — l'API est identique à celle du package en amont :```python
from camoufox.sync_api import Camoufox

with Camoufox() as browser:
    page = browser.new_page()
    page.goto("https://example.com")

La bibliothèque achemine automatiquement en fonction de la version binaire : Firefox ≥ 149 charge `fingerprint-presets-v150.json` (312 presets couvrant v149–v152, 67 macOS / 180 Windows / 65 Linux) ; les binaires plus anciens reviennent au bundle original. Les chaînes UA sont réécrites pour correspondre au binaire actif, donc l’adhésion est sûre entre les versions. Passez un dict de preset au lieu de `True` pour épingler une empreinte spécifique.

---

## Capacités

Voici une liste de correctifs et de fonctionnalités implémentés dans Camoufox.

### Spoofing d’empreinte

- Spoofing des propriétés du navigator (appareil, navigateur, locale, etc.)
- Prise en charge de l’émulation de la taille d’écran, de la résolution, etc.
- Spoofing des paramètres WebGL, des extensions supportées, des attributs de contexte et des formats de précision des shaders.
- Spoofing des tailles de fenêtre interne et externe
- Spoofing du taux d’échantillonnage AudioContext, de la latence de sortie et du nombre maximal de canaux
- Spoofing des voix et des débits de lecture de l’appareil
- Spoofing du nombre de microphones, webcams et haut-parleurs disponibles.
- Les en-têtes réseau (Accept-Languages et User-Agent) sont usurpés pour correspondre aux propriétés du navigator
- Spoofing IP WebRTC au niveau du protocole
- Spoofing de la géolocalisation, du fuseau horaire et de la locale
- Spoofing de l’API Battery
- etc.

### Correctifs furtifs

- Évite les fuites d’exécution dans le contexte principal. Tout le javascript de l’agent de page est isolé
- Évite les fuites de contexte d’exécution dans les frames
- Corrige la détection de `navigator.webdriver`
- Corrige la détection headless de Firefox via le type de pointeur ([#26](https://github.com/daijro/camoufox/issues/26))
- Supprime les correctifs anti-zoom/meta viewport potentiellement fuyants
- Utilise des tailles d’écran et de fenêtre non par défaut
- Réactive les isolations de contenu fission
- Réactive PDF.js
- Autres propriétés de configuration fuyantes modifiées
- Mouvement du curseur semblable à celui d’un humain

### Anti-empreinte de police

- Utilise automatiquement les polices système correctes pour votre User Agent
- Inclus les polices système Windows, Mac et Linux
- Empêche l’empreinte des métriques de police en décalant aléatoirement l’espacement des lettres

### Support Playwright

- Implémentation personnalisée de Playwright pour la dernière version de Firefox
- Divers correctifs de configuration pour échapper à la détection de bot

### Dégraissage/Optimisations

- Suppression/désactivation de _beaucoup, beaucoup_ de services Mozilla. Fonctionne plus rapidement que le Mozilla Firefox original et utilise moins de mémoire (200 Mo)
- Correctifs de LibreWolf et Ghostery pour aider à supprimer la télémétrie et le bloat
- Configuration dégraissée de PeskyFox, LibreWolf et autres
- Optimisations de vitesse et de réseau de FastFox
- Suppression de toutes les animations CSS
- Thème minimaliste
- etc.

### Extensions

- Charger des extensions Firefox sans serveur de débogage en passant une liste de chemins à la propriété `addons`
- Ajout d’uBlock Origin avec des filtres de confidentialité personnalisés
- Les extensions ne sont pas autorisées à ouvrir des onglets
- Les extensions sont automatiquement activées en mode Navigation privée
- Les extensions sont automatiquement épinglées à la barre d’outils
- Corrige les fuites DNS avec le préchargement uBO

### Interface Python

- Génère et injecte automatiquement des caractéristiques d’appareil uniques dans Camoufox en fonction de leur distribution réelle
- Injection et rotation d’empreinte WebGL
- Utilise les polices système correctes ainsi que l’anticrénelage et l’indication subpixel en fonction de votre OS cible
- Évite la détection par proxy en calculant votre géolocalisation cible, votre fuseau horaire et votre locale à partir de la région cible de votre proxy
- Calcule et usurpe la langue du navigateur en fonction de la distribution des locuteurs de la langue dans la région cible du proxy
- Hébergement sur serveur distant pour utiliser Camoufox avec d’autres langages supportant Playwright
- Tampon d’affichage virtuel intégré pour exécuter Camoufox en mode headfull sur un serveur headless
- Activer/Désactiver le chargement des images, WebRTC et WebGL
- etc.

> [!NOTE]
> Camoufox ne supporte pas **entièrement** l’injection d’empreintes Chromium. Certains WAF (comme [Interstitial](https://nopecha.com/demo/cloudflare)) testent le comportement du moteur Spidermonkey, ce qui est impossible à usurper.

---

# Aperçu de la furtivité

## Comment Camoufox cache sa bibliothèque d’automatisation

> [!WARNING]
> **Statut actuel en 2026** :
> Il y a eu un an de pause dans la maintenance en raison d’une situation personnelle. Camoufox a perdu en performance à cause de la version de base de Firefox et d’incohérences nouvellement découvertes dans les empreintes. **Camoufox est actuellement en développement actif.**

Dans Camoufox, tout le code de l’agent de page interne de Playwright est isolé et cloisonné. Cela rend impossible pour une page de détecter la présence de Playwright par inspection Javascript.

Normalement, Playwright injecte du JavaScript dans la page, comme `window.__playwright__binding__`, et pour effectuer des actions comme interroger des éléments, évaluer du javascript ou exécuter des scripts d’initialisation, ce qui peut être détecté par les sites web. Dans Camoufox, ces actions sont gérées dans une portée isolée en dehors de la page. En d’autres termes, les sites web ne peuvent plus « voir » le JavaScript que Playwright injecterait typiquement. Cela empêche totalement les traces de Playwright.

Cependant, même en cachant sa bibliothèque d’automatisation, Camoufox n’est pas à l’abri des incohérences dans la rotation des empreintes. Cela nécessite toujours une maintenance pour les repérer et les corriger.

### Interactions avec la page

Les systèmes anti-bot exécutent également des scripts côté client pour surveiller votre comportement. Par exemple, ils recherchent des schémas dans les mouvements de souris, les clics, le défilement et le timing entre les actions.

<video controls src="https://github.com/user-attachments/assets/6d33d6af-3537-4603-bf24-6bd3f4f8f455" width="200px" loop muted></video>

Camoufox fait de son mieux avec son algorithme de mouvement de souris humanoïde. L’algorithme de mouvement naturel provient à l’origine de [HumanCursor de riflosnake](https://github.com/riflosnake/HumanCursor) et a été réécrit en C++ et modifié pour des trajectoires plus conscientes de la distance.

Cependant, ce n’est pas parfait. Il peut encore être détecté avec une analyse suffisamment sophistiquée. (En cours pour l’avenir)

---

## Comment Camoufox alterne les identités

Les agents IA doivent fonctionner sur plusieurs sessions sans être signalés ou limités. Alterner votre adresse IP ne suffit pas — chaque session de navigateur transporte des milliers de signaux qui créent une **empreinte** unique. Un site web peut voir votre OS, GPU, résolution d’écran, polices, fuseau horaire, etc. Si ces signaux sont incohérents ou inhabituels, vous êtes bloqué.

### Distribution des parts de marché

Même si vous alternez votre IP pour chaque instance de bot en cours d’exécution, les pare-feux web peuvent utiliser l’apprentissage automatique pour analyser le trafic entrant et détecter s’il est anormal. Si la part de marché Linux était de 5 %, puis soudainement de 20 %, c’est un signal d’alarme. Ils exigeront inconditionnellement que tous les utilisateurs Linux remplissent un captcha.

Camoufox utilise le générateur d’empreintes [BrowserForge](https://github.com/daijro/browserforge) pour imiter la distribution statistique des données d’appareil dans le trafic réel. Par exemple, Camoufox fera ressembler votre navigateur à un utilisateur Linux 5 % du temps. Sur ces 5 %, il usurpera une résolution d’écran 2560x1440 9,5 % du temps et un GPU Intel HD 27,5 % du temps.

### Comment Camoufox peut-il être détecté ?

Camoufox peut usurper des empreintes avec une part de marché correcte. Cependant, **les empreintes doivent également être cohérentes en interne.** Un agent utilisateur Windows avec un GPU Apple M1, un agent utilisateur MacOS avec un renderer DirectX Windows, et un appareil mobile avec une résolution d’écran de bureau sont tous impossibles et seront signalés comme suspects.

Parmi les milliers de points de données possibles qui doivent être modifiés pour créer une empreinte usurpée crédible, où chaque changement doit être cohérent avec les autres, Camoufox ne réussit pas toujours. Les fournisseurs anti-bot testent Camoufox encore et encore pour trouver ne serait-ce qu’une seule incohérence, puis mettent immédiatement à jour leurs scripts d’arrière-plan pour la tester.

---

## Comment Camoufox se compare-t-il aux autres solutions ?

### Solutions basées sur JavaScript

Dans le passé, les développeurs essayaient d’injecter du JavaScript pour usurper ces valeurs, mais cela ne fonctionne pas de manière fiable car JavaScript ne peut pas tout usurper. Une couverture incomplète entraîne des empreintes incohérentes. Par exemple, un système anti-bot vous signalera si le User Agent de votre requête réseau ne correspond pas au User Agent de votre navigator.

De plus, tout JavaScript injecté est détectable d’une manière ou d’une autre. Les systèmes anti-bot peuvent vérifier si `Object.getOwnPropertyDescriptor` révèle une propriété écrasée, si `toString()` d’une fonction ne renvoie plus `[native code]` (révélant qu’elle a été détournée), ou si les données dans le contexte de la fenêtre ne correspondent pas au contexte du thread worker. Les solutions de contournement ne vont que jusqu’à un certain point, mais il y aura toujours un moyen de détecter l’injection JS si l’on cherche suffisamment profondément.

#### L’approche de Camoufox

Étant donné que Camoufox intercepte les appels au niveau de l’implémentation C++ du navigateur, tous les objets et propriétés détournés apparaissent natifs. Il n’y a aucun détournement JavaScript à détecter.

Camoufox tente également de générer des empreintes cohérentes et crédibles avec Browserforge. Cependant, cela peut encore être détecté par des méthodes complexes de détection d’empreinte comme les données discordantes (comme décrit précédemment).

<hr width=50>

### Bibliothèques basées sur CDP

CDP (Chrome DevTools Protocol) est un protocole d’automatisation intégré à Chromium et Firefox. Cependant, CDP ne fait aucun effort pour cacher le fait qu’il s’agit d’un protocole d’automatisation et expose une grande partie de ses fonctionnalités dans la portée de la page. Certaines méthodes courantes sont la vérification de `navigator.webdriver` à true, la capture de la lecture de la pile du débogueur, la vérification de variables que ChromeDriver injecte dans l’objet document pour la communication interne, etc.

#### L’approche de Camoufox

Alors que Playwright utilise CDP pour contrôler Chromium, il utilise _Juggler_ pour Firefox. Juggler est un protocole personnalisé développé avant que Firefox ne supporte CDP ([dépôt original](https://github.com/puppeteer/juggler)). C’est un module distinct dans Firefox, et non une partie de son noyau. Cela le rend plus facile à éditer et à contrôler ce qui est révélé à la page.

Camoufox modifie Juggler pour lui donner sa propre « copie » isolée de la page avec laquelle travailler. Playwright peut lire et éditer librement sa propre version de la page. Tout semble fonctionner normalement pour lui, mais la page réelle est complètement inchangée par ces modifications. La page ne peut pas non plus détecter quand des choses sont lues (via des astuces comme le détournement de getters) ou des écouteurs ajoutés pour surveiller des éléments.

De plus, Juggler envoie ses entrées directement via les gestionnaires d’entrée utilisateur originaux de Firefox, ce qui signifie qu’elles sont traitées exactement de la même manière que si vous utilisiez le navigateur normalement. Camoufox modifie également le mode headless de Firefox pour qu’il apparaisse identique à un fonctionnement dans une fenêtre normale. Mais en dernier recours, la bibliothèque Python peut exécuter Camoufox dans un [affichage virtuel](https://camoufox.com/python/virtual-display/) si le mode headless fuit jamais.

---

<h1 align="center">Système de construction</h1>

> [!WARNING]
> Le contenu ci-dessous est destiné aux personnes intéressées par la construction et le débogage de Camoufox. Pour les instructions d’utilisation de Playwright, voir [ici](https://github.com/daijro/camoufox/tree/main/pythonlib#camoufox-python-interface).

### Aperçu

Voici un schéma du système de construction et de ses commandes make associées :```mermaid
graph TD
    FFSRC[Firefox Source] -->|make fetch| REPO

    subgraph REPO[Camoufox Repository]
        PATCHES[Fingerprint masking patches]
        ADDONS[uBlock & B.P.C.]
        DEBLOAT[Debloat/optimizations]
        SYSTEM_FONTS[Win, Mac, Linux fonts]
        JUGGLER[Patched Juggler]
    end

    subgraph Local
    REPO -->|make dir| PATCH[Patched Source]
    PATCH -->|make build| BUILD[Built]
    BUILD -->|make package-linux| LINUX[Linux Portable]
    BUILD -->|make package-windows| WIN[Windows Portable]
    BUILD -->|make package-macos| MAC[macOS Portable]
    end

Ensuite, compilez le code source de Camoufox avec la commande suivante :```bash
make dir

> [!NOTE]
> L'installateur de dépendances n'a été testé que sur macOS jusqu'à présent.

Après cela, vous devez amorcer votre système pour pouvoir construire Camoufox. Vous n'avez à le faire qu'une seule fois. Cela se fait en exécutant la commande suivante :```bash
make bootstrap

Pour les nouvelles versions, `i686` est pris en charge uniquement pour Windows. Les combinaisons cible/architecture non prises en charge sont ignorées.

<details>
<summary>
Paramètres CLI
</summary>```bash
Options:
  -h, --help            show this help message and exit
  --target {linux,windows,macos} [{linux,windows,macos} ...]
                        Target platforms to build
  --arch {x86_64,arm64,i686} [{x86_64,arm64,i686} ...]
                        Target architectures to build for each platform
  --bootstrap           Bootstrap the build system
  --clean               Clean the build directory before starting

Example:
$ python3 multibuild.py --target linux windows macos --arch x86_64 arm64

2. Construisez les correctifs Camoufox pour une plateforme et une architecture cibles :```bash
docker run -v "$(pwd)/dist:/app/dist" camoufox-builder --target <os> --arch <arch>

Les correctifs peuvent être modifiés, créés, supprimés et gérés ici.

<img src="https://assets.kitploit.com/production/public/readmes/41473/19bffc384c42fb6eb69b3ee59622daed4770cf0f11ffe39401eca57a7d2457f4.png">

### Comment créer un correctif

1. Dans l'interface développeur, cliquez sur **Reset workspace**.
2. Apportez les modifications nécessaires dans le dossier `camoufox-*/`. Vous pouvez tester vos modifications avec `make build` et `make run`.
3. Une fois les modifications terminées, cliquez sur **Write workspace to patch** et enregistrez le fichier de correctif.

### Comment travailler sur un correctif existant

1. Dans l'interface développeur, cliquez sur **Edit a patch**.
2. Sélectionnez le correctif que vous souhaitez modifier. Votre espace de travail sera réinitialisé à l'état du correctif sélectionné.
3. Une fois les modifications terminées, cliquez sur **Write workspace to patch** et remplacez le fichier de correctif existant.

---

## Débogage des fuites

Ceci est un organigramme illustrant mon processus pour identifier les fuites sans désobfusquer le JavaScript des WAF. La méthode réintroduit progressivement les fonctionnalités de Camoufox dans le code source de Firefox jusqu'à ce que le site de test les signale.

Ce processus nécessite un système Linux et suppose que vous avez installé les outils de compilation de Firefox (voir [ici](https://github.com/daijro/camoufox?tab=readme-ov-file#build-cli)).

<details>
<summary>
Voir l'organigramme...
</summary>```mermaid
flowchart TD
    A[Start] --> B[Does website flag in the official Firefox?]
    B -->|Yes| C[Likely bad IP/rate-limiting. If the website fails on both headless and headful mode on the official Firefox distribution, the issue is not with the browser.]
    B -->|No| D["Run make ff-dbg(1) and build(2) a clean distribution of Firefox. Does the website flag in Firefox **headless** mode(4)?"]
    D -->|Yes| E["Does the website flag in headful mode(3) AND headless mode(4)?"]
    D -->|No| F["Open the developer UI(5), apply config.patch, then rebuild(2). Does the website still flag(3)?"]
    E -->|No| G["Enable privacy.resistFingerprinting in the config(6). Does the website still flag(3)?"]
    E -->|Yes| C
    G -->|No| H["In the config(6), enable FPP and start omitting overrides until you find the one that fixed the leak."]
    G -->|Yes| I[If you get to this point, you may need to deobfuscate the Javascript behind the website to identify what it's testing.]
    F -->|Yes| K["Open the developer UI, apply the playwright bootstrap patch, then rebuild. Does it still flag?"]
    F -->|No| J["Omit options from camoufox.cfg(6) and rerun(3) until you find the one causing the leak."]
    K -->|No| M[Juggler needs to be debugged to locate the leak.]
    K -->|Yes| L[The issue has nothing to do with Playwright. Apply the rest of the Camoufox patches one by one until the one causing the leak is found.]
    M --> I