Os dados de configuração não definidos pelo usuário serão preenchidos automaticamente usando impressões digitais do [BrowserForge](https://github.com/daijro/browserforge), que imitam a distribuição estatística das características dos dispositivos no tráfego do mundo real.

[[Ver propriedades implementadas](https://camoufox.com/fingerprint/)]

---

## Uso em Python

Camoufox é compatível com seu código Playwright existente. Você só precisa alterar a inicialização do seu navegador.

**API Síncrona**```python
from camoufox.sync_api import Camoufox

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

[[Instalação e uso](https://camoufox.com/python/)]

### Aproveitando ao Máximo a Falsificação de Hardware

Para versões estáveis, você deve usar sempre o pacote pip principal [`camoufox`](https://pypi.org/project/camoufox/). No entanto, se você quiser aproveitar as impressões digitais por contexto e a falsificação de hardware, use o pacote [`cloverlabs-camoufox`](https://pypi.org/project/cloverlabs-camoufox/). Este pacote é atualizado a cada lançamento, enquanto o pacote oficial é lançado com atraso.

Certifique-se de estar usando um ambiente virtual para evitar conflitos entre os dois pacotes.

**Instalação**```bash
pip install cloverlabs-camoufox

**Uso** — a API é idêntica ao pacote upstream:```python
from camoufox.sync_api import Camoufox

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

A biblioteca roteia automaticamente pela versão do binário: Firefox ≥ 149 carrega `fingerprint-presets-v150.json` (312 presets cobrindo v149–v152, 67 macOS / 180 Windows / 65 Linux); binários mais antigos recorrem ao pacote original. As strings de UA são reescritas para corresponder ao binário ativo, então ativar isso é seguro entre versões. Passe um dicionário de preset em vez de `True` para fixar uma fingerprint específica.

---

## Capacidades

Abaixo está uma lista de patches e recursos implementados no Camoufox.

### Spoofing de impressões digitais

- Spoofing de propriedades do Navigator (dispositivo, navegador, locale, etc.)
- Suporte para emulação de tamanho de tela, resolução, etc.
- Spoofing de parâmetros WebGL, extensões suportadas, atributos de contexto e formatos de precisão de shader.
- Spoofing dos tamanhos de viewport interna e externa da janela
- Spoofing da taxa de amostragem do AudioContext, latência de saída e número máximo de canais
- Spoofing de vozes de dispositivos e taxas de reprodução
- Spoofing da quantidade de microfones, webcams e alto-falantes disponíveis.
- Os cabeçalhos de rede (Accept-Languages e User-Agent) são falsificados para corresponder às propriedades do navigator
- Spoofing de IP WebRTC no nível do protocolo
- Spoofing de geolocalização, fuso horário e locale
- Spoofing da API de bateria
- etc.

### Patches de stealth

- Evita vazamentos de execução no mundo principal. Todo o javascript do agente de página é isolado em sandbox
- Evita vazamentos de contexto de execução de frames
- Corrige a detecção de `navigator.webdriver`
- Corrige a detecção do Firefox headless via tipo de ponteiro ([#26](https://github.com/daijro/camoufox/issues/26))
- Removidos patches potencialmente vazadores de anti-zoom/manipulação de meta viewport
- Usa tamanhos de tela e janela não padrão
- Reativa o isolamento de conteúdo do Fission
- Reativa o PDF.js
- Outras propriedades de configuração que vazavam informações foram alteradas
- Movimento de cursor semelhante ao humano

### Anti fingerprinting de fontes

- Usa automaticamente as fontes de sistema corretas para o seu User Agent
- Inclui fontes de sistema Windows, Mac e Linux
- Impede o fingerprinting de métricas de fontes deslocando aleatoriamente o espaçamento entre letras

### Suporte ao Playwright

- Implementação personalizada do Playwright para o Firefox mais recente
- Vários patches de configuração para evadir a detecção de bots

### Debloat/Otimizações

- Removeu/desativou _muitos, muitos_ serviços da Mozilla. Roda mais rápido que o Mozilla Firefox original e usa menos memória (200mb)
- Patches do LibreWolf e Ghostery para ajudar a remover telemetria e inchaço
- Configuração de debloat do PeskyFox, LibreWolf e outros
- Otimizações de velocidade e rede do FastFox
- Removeu todas as animações CSS
- Tema minimalista
- etc.

### Addons

- Carrega addons do Firefox sem um servidor de depuração, passando uma lista de caminhos para a propriedade `addons`
- Adicionado uBlock Origin com filtros de privacidade personalizados
- Addons não têm permissão para abrir abas
- Addons são ativados automaticamente no modo de Navegação Privada
- Addons são fixados automaticamente na barra de ferramentas
- Corrige vazamentos de DNS com o pré-carregamento do uBO

### Interface Python

- Gera e injeta automaticamente características exclusivas de dispositivos no Camoufox com base na distribuição do mundo real
- Injeção e rotação de fingerprint WebGL
- Usa as fontes de sistema corretas e antialiasing subpixel e hinting com base no seu sistema operacional alvo
- Evita a detecção de proxy calculando sua geolocalização, fuso horário e locale alvo a partir da região alvo do seu proxy
- Calcula e falsifica o idioma do navegador com base na distribuição de falantes do idioma na região alvo do proxy
- Hospedagem em servidor remoto para usar o Camoufox com outras linguagens que suportam Playwright
- Buffer de exibição virtual integrado para executar o Camoufox com interface gráfica em um servidor headless
- Alternar carregamento de imagens, WebRTC e WebGL
- etc.

> [!NOTE]
> O Camoufox **não** suporta totalmente a injeção de fingerprints do Chromium. Alguns WAFs (como o [Interstitial](https://nopecha.com/demo/cloudflare)) testam o comportamento do mecanismo SpiderMonkey, o que é impossível de falsificar.

---

# Visão Geral do Stealth

## Como o Camoufox esconde sua biblioteca de automação

> [!WARNING]
> **Status atual em 2026**:
> Houve uma lacuna de um ano na manutenção devido a uma situação pessoal. O Camoufox teve uma queda de desempenho devido à versão base do Firefox e a inconsistências de fingerprint recém-descobertas. **O Camoufox está atualmente em desenvolvimento ativo.**

No Camoufox, todo o código do Page Agent interno do Playwright é isolado em sandbox e separado. Isso torna impossível para uma página detectar a presença do Playwright por meio de inspeção de Javascript.

Normalmente, o Playwright injeta algum JavaScript na página, como `window.__playwright__binding__`, e para executar ações como consultar elementos, avaliar javascript ou executar scripts de inicialização, o que pode ser detectado por sites. No Camoufox, essas ações são tratadas em um escopo isolado fora da página. Em outras palavras, os sites não conseguem mais "ver" qualquer JavaScript que o Playwright normalmente injetaria. Isso impede completamente a existência de vestígios do Playwright.

No entanto, mesmo escondendo sua biblioteca de automação, o Camoufox não é imune a inconsistências na rotação de impressões digitais. Isso ainda requer manutenção para detectar e corrigir.

### Interações com a página

Os sistemas anti-bot também executam scripts no lado do cliente para monitorar seu comportamento. Por exemplo, eles procuram padrões em movimentos do mouse, cliques, rolagem e no tempo entre ações.

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

O Camoufox faz o seu melhor com seu algoritmo de movimento de mouse semelhante ao humano. O algoritmo de movimento natural veio originalmente do [HumanCursor do riflosnake](https://github.com/riflosnake/HumanCursor) e foi reescrito em C++ e modificado para trajetórias mais sensíveis à distância.

No entanto, isso não é perfeito. Ainda pode ser detectado com uma análise suficientemente sofisticada. (WIP para o futuro)

---

## Como o Camoufox rotaciona identidades

Agentes de IA precisam operar em muitas sessões sem serem sinalizados ou terem sua taxa limitada. Rotacionar seu endereço IP não é suficiente — cada sessão de navegador carrega milhares de sinais que criam uma **impressão digital (fingerprint)** única. Um site pode ver seu SO, GPU, resolução de tela, fontes, fuso horário e muito mais. Se esses sinais forem inconsistentes ou incomuns, você é bloqueado.

### Distribuição de participação de mercado

Mesmo que você esteja rotacionando seu IP para cada instância de bot em execução, os firewalls de acesso à web ainda podem usar aprendizado de máquina para analisar o tráfego de entrada e detectar se é anormal. Se a participação de mercado do Linux fosse de 5% e, de repente, passasse a ser de 20%, é um sinal de alerta. Eles exigirão incondicionalmente que todos os usuários de Linux concluam um captcha.

O Camoufox usa o gerador de fingerprints do [BrowserForge](https://github.com/daijro/browserforge) para imitar a distribuição estatística dos dados de dispositivos no tráfego do mundo real. Por exemplo, o Camoufox fará seu navegador parecer um usuário Linux 5% das vezes. Dentro desses 5%, ele vai falsificar uma resolução de tela 2560x1440 em 9,5% das vezes e uma GPU Intel HD em 27,5% das vezes.

### Como o Camoufox pode ser detectado?

O Camoufox consegue falsificar fingerprints com uma participação de mercado correta. No entanto, **as fingerprints também devem ser internamente consistentes.** Um user agent do Windows com uma GPU Apple M1, um user agent do macOS com um renderizador DirectX do Windows e um dispositivo móvel com resolução de tela de desktop são todos impossíveis e serão sinalizados como suspeitos.

Entre os milhares de pontos de dados possíveis que precisam ser alterados para criar uma fingerprint falsificada crível, em que cada alteração deve ser consistente com as demais, o Camoufox nem sempre consegue. Provedores anti-bot testam o Camoufox repetidamente para encontrar até mesmo 1 inconsistência única e, em seguida, atualizam imediatamente seus scripts em segundo plano para testá-la.

---

## Como o Camoufox se compara a outras soluções?

### Soluções baseadas em JavaScript

No passado, os desenvolvedores tentaram injetar JavaScript para falsificar esses valores, mas isso não funciona de forma confiável, pois o JavaScript não consegue falsificar tudo. A cobertura incompleta causa fingerprints inconsistentes. Por exemplo, um sistema anti-bot sinalizará você se o User Agent da sua solicitação de rede não corresponder ao User Agent do seu navigator.

Além disso, todo JavaScript injetado é detectável de alguma forma. Os sistemas anti-bot podem verificar se `Object.getOwnPropertyDescriptor` revela uma propriedade sobrescrita, se o `toString()` de uma função não retorna mais `[native code]` (revelando que foi sequestrada), ou se os dados no contexto da janela não correspondem ao contexto da thread do worker. Soluções alternativas só levam você até certo ponto, mas sempre haverá uma maneira de detectar a injeção de JS se você procurar com profundidade suficiente.

#### Abordagem do Camoufox

Como o Camoufox intercepta chamadas no nível de implementação em C++ do navegador, todos os objetos e propriedades sequestrados parecem nativos. Não há sequestro de JavaScript a ser detectado.

O Camoufox também tenta gerar fingerprints consistentes e críveis com o Browserforge. No entanto, isso ainda pode ser detectado por métodos complexos de detecção de fingerprint, como dados incompatíveis (conforme descrito anteriormente).

<hr width=50>

### Bibliotecas baseadas em CDP

O CDP (Chrome DevTools Protocol) é um protocolo de automação integrado ao Chromium e ao Firefox. No entanto, o CDP não faz nenhum esforço para esconder o fato de que é um protocolo de automação e expõe grande parte de sua funcionalidade no escopo da página. Alguns métodos comuns são verificar se `navigator.webdriver` é verdadeiro, pegá-lo lendo o debugger da stack, verificar variáveis que o ChromeDriver injeta no objeto document para comunicação interna, e muito mais.

#### Abordagem do Camoufox

Enquanto o Playwright usa CDP para controlar o Chromium, ele usa _Juggler_ para o Firefox. Juggler é um protocolo personalizado desenvolvido antes de o Firefox suportar CDP ([repositório original](https://github.com/puppeteer/juggler)). É um módulo distinto dentro do Firefox, e não faz parte do núcleo do navegador. Isso torna mais fácil editar e controlar o que é revelado à página.

O Camoufox aplica patches ao Juggler para dar a ele sua própria "cópia" isolada da página para trabalhar. O Playwright pode ler e editar livremente sua própria versão da página. Tudo parece funcionar normalmente para ele, mas a página real não é afetada de forma alguma por essas mudanças. A página também não consegue detectar quando coisas estão sendo lidas (por meio de truques como sequestrar getters) ou listeners sendo adicionados para observar elementos.

Além disso, o Juggler envia suas entradas diretamente através dos manipuladores de entrada de usuário originais do Firefox, o que significa que elas são tratadas exatamente da mesma forma que se você estivesse usando o navegador normalmente. O Camoufox também aplica patches ao modo headless do Firefox para que ele pareça o mesmo que se estivesse sendo executado em uma janela normal. Mas, como fallback, a biblioteca Python pode executar o Camoufox em um [display virtual](https://camoufox.com/python/virtual-display/) se o modo headless vazar alguma informação.

---

<h1 align="center">Sistema de Build</h1>

> [!WARNING]
> O conteúdo abaixo é destinado àqueles interessados em compilar e depurar o Camoufox. Para instruções de uso do Playwright, veja [aqui](https://github.com/daijro/camoufox/tree/main/pythonlib#camoufox-python-interface).

### Visão geral

Aqui está um diagrama do sistema de build e seus comandos make associados:```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

A seguir, compile o código-fonte do Camoufox com o seguinte comando:```bash
make dir

> [!NOTE]
> O instalador de dependências até agora só foi testado no macOS.

Depois disso, você precisa inicializar seu sistema para poder compilar o Camoufox. Você só precisa fazer isso uma vez. Isso é feito executando o seguinte comando:```bash
make bootstrap

Para novos builds, `i686` é suportado apenas para Windows. Combinações de alvo/arquitetura não suportadas são ignoradas.

<details>
<summary>
Parâmetros da 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. Compile patches do Camoufox para uma plataforma e arquitetura de destino:```bash
docker run -v "$(pwd)/dist:/app/dist" camoufox-builder --target <os> --arch <arch>

Os patches podem ser editados, criados, removidos e gerenciados por aqui.

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

### Como criar um patch

1. Na interface de desenvolvedor, clique em **Reset workspace**.
2. Faça as alterações necessárias na pasta `camoufox-*/`. Você pode testar suas alterações com `make build` e `make run`.
3. Depois de terminar as alterações, clique em **Write workspace to patch** e salve o arquivo do patch.

### Como trabalhar em um patch existente

1. Na interface de desenvolvedor, clique em **Edit a patch**.
2. Selecione o patch que deseja editar. Seu workspace será redefinido para o estado do patch selecionado.
3. Depois de terminar as alterações, clique em **Write workspace to patch** e substitua o arquivo do patch existente.

---

## Depuração de Vazamentos

Este é um fluxograma que demonstra meu processo para determinar vazamentos sem desofuscar o Javascript do WAF. O método reintroduz incrementalmente os recursos do Camoufox no código-fonte do Firefox até que o site de teste levante um alerta.

Este processo requer um sistema Linux e pressupõe que você tenha as ferramentas de compilação do Firefox instaladas (veja [aqui](https://github.com/daijro/camoufox?tab=readme-ov-file#build-cli)).

<details>
<summary>
Ver fluxograma...
</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