Um mecanismo de navegador para governar todos

Mecanismo Chromium furtivo

Fortress é um mecanismo Chromium furtivo que impede que seus scrapers e agentes de navegador sejam bloqueados, com apenas uma linha de alteração no código. Detectores de bot sinalizam automação ao ler a impressão digital do navegador; Fortress corrige essa impressão digital dentro do C++ do Chromium, de modo que o navegador se apresenta como uma instalação comum do Chrome. Scrapers concluem suas execuções, agentes alcançam as páginas para as quais foram enviados, e CreepJS, Sannysoft, BrowserScan e o Cloudflare Turnstile ao vivo o leem como humano. Aponte seu Playwright ou Puppeteer existente para Fortress via CDP, e nada mais no seu código muda.

_{Blink · V8 · BoringSSL corrigidos na árvore (in-tree) · ANGLE / D3D11 com suporte a WebGL · JA3/JA4 TLS coerente · rebase mensal do upstream · lançamentos reproduzíveis e controlados por gauntlet}

34

_{patches C++ de superfície única}

Fortress resolvendo um desafio ao vivo do Cloudflare, em seguida passando pelo sannysoft e BrowserScan

_{Captura não editada do binário Fortress em uma janela real: ele resolve um desafio ao vivo do Cloudflare, torna bot.sannysoft.com todo verde, e então lê BrowserScan como “Normal”. Reproduza com tools/gauntlet.py.}

🆕 O que há de novo — 151.0.7908.0 · Atualização do Mecanismo

Lançado. Personas coerentes por inicialização, reforçadas.

Teclado por localidade (QWERTY / QWERTZ / AZERTY) · dispositivos de mídia por persona · uma passagem de coerência completa de paridade de entrega (delivery-parity).
Plataforma ↔ GPU ↔ fuso horário ↔ idioma ↔ vozes ↔ teclado movem-se como um dispositivo real coerente — em cada inicialização, a partir de um único binário.
Paridade de código nativo (toString() permanece [native code]), invariante em relação ao domínio (realm) (principal / worker / iframe) — coerência compilada no navegador, não corrigida em JavaScript.```bash pip install -U tilion-fortress # or: docker run --rm -p 9222:9222 tilion/fortress:latest

**[→ notas de lançamento completas](https://github.com/tiliondev/fortress/releases/tag/v151.0.7908.0)**


## Conteúdo

| | |
|---|---|
| **[O que é](#what-it-is)** · **[Início rápido](#quick-start)** | o que é, instalação, primeiro script, configuração de agente de IA |
| **[O Fortress MCP](#the-fortress-mcp--stealth-browsing-as-agent-tools)** | 29 ferramentas de navegador stealth para agentes de IA (Beta) |
| **[Por que corrigir o motor, não a página](#why-patch-the-engine-not-the-page)** | a tese do JS auto-revelador + as três camadas de detecção |
| **[Como o Fortress se compara](#how-fortress-compares)** | vs puppeteer-stealth · Camoufox · CloakBrowser · fornecedores fechados |
| **[Prova: resultados de detectores ao vivo](#proof-live-detector-results)** | CreepJS / Sannysoft / BrowserScan / Cloudflare, com capturas de tela |
| **[Configure a persona](#configure-the-persona)** | a superfície de impressão digital `--uxr-*` |
| **[Funciona com sua stack](#works-with-your-stack)** | browser-use · Crawl4AI · Stagehand · LangChain |
| **[Construir e verificar](#build--verify)** | reproduzir a partir do código fonte, verificar procedência |
| **[Referência](#reference)** | solução de problemas · FAQ · roteiro · layout do repositório |

---

## O que é

O Fortress é um fork do Chromium que falsifica a impressão digital do navegador a partir do interior do motor. As superfícies que os detectores de bot leem (canvas, WebGL, áudio, fontes, navigator e cerca de trinta outras) são corrigidas no **C++** do Chromium, sem nenhuma camada de patch JavaScript sobreposta que uma página possa capturar.

Ele é distribuído como um binário de navegador comum que expõe um endpoint CDP. Aponte Playwright, Puppeteer ou qualquer cliente CDP para ele e sua automação existente roda inalterada.

Um patch JavaScript stealth deixa uma camada extra que a página pode encontrar: `.toString()` mostra a fonte da sobrescrita, e obter novamente a mesma primitiva de um iframe ou worker a contorna. O Fortress corrige a superfície no motor, então `navigator.vendor` resolve para o getter real em C++, reporta `[native code]` e lê o mesmo de todos os realms. Uma página inspecionando a si mesma vê o Chromium padrão. É por isso que sua automação passa onde costumava ser sinalizada, e qualquer bloqueio restante é atribuído aos seus proxies e comportamento, e não ao navegador. [Por que corrigir o motor, não a página](#why-patch-the-engine-not-the-page) cobre a mecânica de detecção na íntegra.```python
from tilion_fortress import Fortress
from playwright.sync_api import sync_playwright

with Fortress() as f:                                   # launches the stealth engine on a CDP endpoint
    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(f.cdp_url)
        page = browser.new_page()
        page.goto("https://bot.sannysoft.com")
        page.screenshot(path="all-green.png")

import { Fortress } from "tilion-fortress";
import { chromium } from "playwright";

const f = await Fortress.launch();                      // stealth engine on a CDP endpoint
const browser = await chromium.connectOverCDP(f.cdpUrl);
const page = await browser.newPage();
await page.goto("https://browserscan.net");
await browser.close();
await f.close();

O tour de 12 segundos

Fortress em 12 segundos: passa no CreepJS, Sannysoft, BrowserScan e rebrowser, coleta dados reais de sites e limpa Akamai em aa.com, lowes.com, macys.com e kohls.com.

_{Um laço, capturas reais: passa no CreepJS / Sannysoft / BrowserScan / rebrowser → coleta dados estruturados via CDP → limpa Akamai em aa.com · lowes · macys · kohls (mesmo IP residencial).}

Coleta real, totalmente headless

_{Capturas sem edição do motor Fortress acionado via CDP. Sem plugins de stealth, sem patches JS: a impressão digital é corrigida no binário. Reproduza qualquer um destes com examples/scrape_demos.py.}

Fortress extraindo books.toscrape.com em registros JSON tipados ao vivo via CDP

_{Extração estruturada: registros são montados em JSON tipados à medida que cada item é lido.}

Limpa Akamai real — antes / depois

Antes: um navegador comum é bloqueado pelo Akamai em aa.com com Access Denied. Depois: Fortress carrega a página real e o sensor do Akamai a aceita.

_{Mesmo IP residencial, mesmo site (aa.com · Akamai Bot Manager). Um navegador comum/headless obtém Access Denied (Reference #); Fortress carrega a página real e o Akamai emite seu cookie de sensor _abck — o Bot Manager o aceita como um navegador real. A variável é a impressão digital, não o IP.}

Início rápido```bash

Python / Node: prebuilt native binary auto-fetched (Linux x64 & Windows x64), SHA-256 verified

pip install tilion-fortress npm install tilion-fortress

Any OS via Docker: raw CDP on :9222 (~302 MB pull / 851 MB on disk, stripped single-layer)

docker run --rm -p 9222:9222 tilion/fortress:latest

Portable bundle (extract-and-run, like a Chromium snapshot)

tar xzf tilion-fortress-linux-x64.tar.gz # Linux ./tilion-fortress/tilion --headless=new --remote-debugging-port=9222 --user-data-dir=/tmp/p

Debian / Ubuntu

sudo apt install ./tilion-fortress_151.0.7908.0_amd64.deb && tilion https://example.com

> [!TIP]
> O SDK fornece a compilação **mais `patches/`**, para que você possa reconstruir o motor por conta própria e verificar cada correção de superfície em relação à fonte. Os downloads são verificados por SHA-256 em relação aos `SHA256SUMS` da versão automaticamente.

### Versões

O Fortress é lançado em **duas bases Chromium** — escolha o seu compromisso entre camuflagem e atualidade:

| Canal | Chromium | Quando usar |
|---|---|---|
| **`stable`** *(default)* | **149** | Recomendado — corresponde à versão do Chrome que a maioria dos usuários reais executa, portanto, se mistura melhor |
| **`latest`** | **151** | Motor mais recente (informa uma versão ligeiramente à frente do stable) |```python
Fortress().start()                     # Python: stable (149) by default
Fortress(channel="latest").start()     # opt into 151

await Fortress.launch();               // Node: stable (149) by default
await Fortress.launch({ channel: "latest" });

docker run --rm -p 9222:9222 tilion/fortress:149   # or :151
# or set FORTRESS_CHANNEL=latest for either SDK

Binários nativos: Linux x64 (ambas versões) + Windows x64 (151); Windows-149 e macOS executam via imagem Docker.

Coloque no seu agente de IA

Fortress é o navegador que seu agente utiliza: CDP bruto na porta :9222, sem plugins de stealth para configurar. Existem duas formas de acesso.

Opção 1: abra-o pré-carregado em um assistente de chat. Um clique; ele lê nosso AGENTS.md e guia você por toda a configuração:

Opção 2: Copiar para agente (tudo, para sua área de transferência). Clique no ícone de cópia no canto superior direito da caixa abaixo. Ele coloca o contexto completo de configuração na sua área de transferência: o que é, instalação, conexão, persona e regras, tudo condensado do AGENTS.md. Cole no Cursor, Claude Code, Copilot, ChatGPT ou qualquer agente e ele continuará a partir daí:```text You're setting up Fortress, an open-source STEALTH Chromium engine, for browser automation. It corrects the browser fingerprint (canvas, WebGL, audio, fonts, navigator, +30 more) in Chromium's C++ and exposes raw CDP on http://localhost:9222, a drop-in for Playwright/Puppeteer. Do NOT add puppeteer-stealth or any JS fingerprint patching (it self-reveals and undoes Fortress).

LAUNCH (pick one; all expose CDP on http://localhost:9222): Docker: docker run -d --rm -p 9222:9222 tilion/fortress:latest Python: pip install tilion-fortress then from tilion_fortress import Fortress; f=Fortress(); f.start() Node: npm install tilion-fortress then import {Fortress} from "tilion-fortress"; const f=await Fortress.launch()

CONNECT (keep my existing automation code): Playwright(py): browser = p.chromium.connect_over_cdp("http://localhost:9222") Playwright(js): const browser = await chromium.connectOverCDP("http://localhost:9222") Puppeteer(js): const browser = await puppeteer.connect({ browserURL: "http://localhost:9222" }) browser-use / Crawl4AI / Stagehand / LangChain: point their CDP endpoint at http://localhost:9222

PERSONA (optional; default is a coherent Windows identity). Override any surface with --uxr-* flags: --uxr-timezone=America/New_York --uxr-hw-concurrency=16 --uxr-languages=en-US,en

RULES:

Drive over raw CDP (:9222); don't spawn chromedriver.
Never pass --user-agent (use --uxr-ua-*); it desyncs UA vs UA-Client-Hints.
No puppeteer-stealth / undetected-chromedriver / JS fingerprint patches.
Blocked ~90% = my IP (datacenter), not the fingerprint. Use a residential/mobile proxy, then retry.

Now walk me through launching Fortress and wiring my automation to it. Full guide: https://github.com/tiliondev/fortress/blob/main/AGENTS.md

---

## O Fortress MCP — navegação furtiva como ferramentas de agente &nbsp;<sub>Beta</sub>

CDP bruto é para código que você escreve. O **Fortress MCP** é para agentes que chamam **ferramentas**: um servidor [Model Context Protocol](https://modelcontextprotocol.io) que entrega ao Claude, Cursor, ou qualquer cliente MCP um navegador furtivo, de modo que no momento em que um fetch é bloqueado, ele simplesmente chama uma ferramenta e obtém a página. **29 ferramentas, locais e gratuitas** — `fetch_protected_page`, `extract_page`, `crawl_site`, `recon_site_apis`, `search_web`, `run_browser_task`, `save_profile`, `get_stealth_cdp_endpoint`, e mais.

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/795/8f328e2498b09d7433208c5b4a9002450643537f2ee6b0519ac10420ef581bf3.gif" alt="Mesmo site, mesmo prompt: um navegador comum é bloqueado pelo PerimeterX enquanto um agente com o Fortress MCP retorna JSON limpo" width="760"/></p>

<sub><i>Execução real, datada, contra <b>stockx.com</b> (PerimeterX). Um navegador comum recebe <b>HTTP 403 — “Acesso negado”</b>; um agente com o Fortress MCP retorna JSON limpo — mesmo site, mesmo prompt. Reproduza a partir do repositório do framework.</i></sub>

### Configure em 30 segundos

Dois executores — escolha um. O `npx` precisa do Python no PATH; o `pip` instala diretamente:```bash
pip install "tilion[mcp]"      # command:  tilion-mcp
#   —or, zero-install—
npx -y tilion-mcp              # auto-runs the server via uv (no global install)

Claude Desktop — Configurações → Desenvolvedor → Editar Configuração (claude_desktop_config.json):```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

<sub>Prefere npx? Use <code>"command": "npx", "args": ["-y", "tilion-mcp"]</code>. Reinicie o Claude, e as ferramentas <b>fortress</b> aparecem.</sub>

**Claude Code** (CLI) — uma linha:```bash
claude mcp add fortress -- tilion-mcp          # or:  claude mcp add fortress -- npx -y tilion-mcp

Cursor (~/.cursor/mcp.json) · Cline / Windsurf (VS Code → MCP servers) — mesmo bloco:```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

Então basta perguntar ao seu agente — *“obtenha o preço desta página do StockX”* — e ele chama `fetch_protected_page` por conta própria.

### O que o agente obtém

| | ferramentas |
|---|---|
| **Obter páginas bloqueadas** | `fetch_protected_page` · `read_page` · `get_page_html` · `search_web` |
| **Dados estruturados** | `extract_page` (consciente de esquema) · `extract_document` (PDF/DOCX/XLSX) |
| **Sites completos** | `crawl_site` (auto-SPA) · `recon_site_apis` (encontrar a API JSON privada) |
| **Controlar uma página** | `page_elements` · `click_button` · `fill_field` · `press_key` · `wait_for` · `evaluate_js` |
| **Fluxos de múltiplas etapas** | `run_browser_task` (login, paginar, rolagem infinita, checkout, …) |
| **Capturar / autenticar** | `screenshot_page` · `save_page` · `download_file` · `save_profile` / `load_profile` |
| **Traga o seu próprio** | `get_stealth_cdp_endpoint` → uma URL CDP para Playwright / Puppeteer / browser-use |

As ferramentas são anotadas (leituras aprovam automaticamente, escritas bloqueiam), **pré-aquecidas** na inicialização (~100 ms primeira chamada), seguras para concorrência e protegidas contra timeout e SSRF. Um endpoint hospedado com **egresso residencial está chegando em breve**.

→ Tabela completa de 29 ferramentas, benchmarks e a habilidade do agente: **[`mcp/`](https://github.com/tiliondev/fortress/blob/HEAD/mcp/README.md)**

---

## Por que corrigir o motor, não a página

A abordagem usual corrige `navigator.webdriver`, falsifica o fornecedor WebGL e substitui `navigator.plugins` a partir do script. O CreepJS e detectores similares ainda o sinalizam, e a razão é **estrutural**, não mais uma propriedade deixada descoberta. Uma falsificação em JavaScript é uma função no lugar onde uma nativa deveria estar. Os detectores deixam de lado o valor retornado e interrogam se a coisa que o retorna é nativa:

| O indicador | Por que ele detecta uma falsificação JS |
|---|---|
| `toString` auto-revelação | Um método nativo é convertido em string para `function get vendor() { [native code] }`; uma sobrescrita é convertida em seu próprio código-fonte, então um `.toString()` a captura. |
| Descritor e `hasOwnProperty` | `getOwnPropertyDescriptor` expõe propriedades redefinidas, e `hasOwnProperty('toString')` retorna `true` em uma função adulterada onde uma nativa retorna `false`. |
| `failsTypeError` | Getters nativos lançam um `TypeError` específico no `this` errado; um shim ingênuo permanece em silêncio, e o silêncio é o sinal. |

A reaquisição de reino é a que derrota toda correção do mundo principal. Um detector pega uma primitiva pura de outro reino e a volta contra sua função:```js
const iframe = document.createElement('iframe'); document.body.appendChild(iframe);
const realToString = iframe.contentWindow.Function.prototype.toString;
realToString.call(navigator.__lookupGetter__('vendor')); // returns your source code. Caught.

O patch do seu mundo principal vive em um reino diferente desse iframe. A mesma armadilha dispara de um Web Worker, uma thread que seu shim da thread principal executa ao lado em vez de dentro.

Fortress não possui tal camada. O getter para navigator.vendor é o getter C++: ele reporta [native code] porque é código nativo, idêntico em todos os reinos. Camoufox coloca bem: "não há sequestro de JavaScript a ser detectado." Fortress aplica a mesma ideia ao V8 e Blink no lugar do Gecko.

As três camadas de detecção de bots, e onde Fortress se encaixa

Anti-bots modernos (Cloudflare, DataDome, Kasada, HUMAN, Akamai) leem três superfícies estruturalmente diferentes, em três lugares separados. Uma ferramenta raramente corrige todas as três:

Fortress é o motor da Camada-C, construído para ser dirigido de modo que A e B também se mantenham. O binário por si só deixa o canal CDP aberto. Essa parte fica na camada de controle, e fingir o contrário é como você é pego.

Como Fortress se compara

Fortress se baseia em trabalhos anteriores reais: fingerprint-chromium, ChromiumFish, e CloakBrowser vieram primeiro, e fornecedores comerciais (Multilogin, Kameleo, GoLogin, AdsPower, Browserbase, Surfsky) recompilam o Chromium por trás de fontes fechadas. A maior parte desse trabalho permanece fechada: os forks paywalled entregam um binário e pedem que você confie, e os fornecedores mantêm seus patches internamente.

Fortress vai pelo outro caminho, porque um motor stealth só permanece útil quando as pessoas que dependem dele podem ver como funciona. Cada correção de superfície reside em patches/ como um diff pequeno e de propósito único que você pode ler em um minuto, e todo o motor é reconstruído a partir da fonte com um script. Quando um detector encontra um novo indício, você rastreia a correção, aplica o patch e o envia de volta. Esse ciclo de feedback é o objetivo, e só funciona enquanto o motor permanece aberto o suficiente para ser lido, estendido e reconstruído.

Prova: resultados de detectores ao vivo

Reproduza qualquer linha com tools/gauntlet.py --bundle ./tilion-fortress. Verificado contra detectores ao vivo; reexecução datada em docs/GAUNTLET_RESULTS.md.

Prova: capturas de tela reais e não editadas

BrowserScan	CreepJS	Cloudflare

Configure a persona

O binário carrega zero strings de marca; o lançador aplica uma persona padrão coerente do Windows. Substitua qualquer superfície com as chaves --uxr-*, ou defina TILION_NO_DEFAULTS=1 para uma inicialização limpa.``` --uxr-platform / --uxr-ua-platform / --uxr-ua-os / --uxr-ua-arch / --uxr-ua-bitness --uxr-ua-platform-version / --uxr-ua-brand / --uxr-hw-concurrency / --uxr-device-memory --uxr-webgl-vendor / --uxr-webgl-renderer / --uxr-webgl-fullparams --uxr-canvas-seed / --uxr-audio-seed / --uxr-timezone / --uxr-languages --uxr-screen-width / --uxr-screen-height / --uxr-webrtc-policy=disable_non_proxied_udp

| Variável de ambiente | Finalidade |
|---|---|
| `TILION_NO_DEFAULTS=1` | Ignorar a persona padrão (inicialização básica) |
| `TILION_TZ` / `TILION_LANG` | Substituição rápida de fuso horário / idioma |

> [!NOTE]
> **A persona está na linha de comando atualmente.** As opções `--uxr-*` são legíveis por todos via `/proc/<pid>/cmdline`, portanto, é uma persona por inicialização e visível para outros processos no host. O runtime `MaskConfig` chega em seguida: ele entrega a persona via IPC e remove o limite de uma por processo (veja [o que vem a seguir](#whats-next)).

---

## Funciona com a sua stack

Fortress expõe CDP bruto em `:9222`, então se encaixa em qualquer coisa que fale Playwright, Puppeteer ou CDP.

| Framework | Conectar via |
|---|---|
| [**browser-use**](https://github.com/browser-use/browser-use) (~70 mil estrelas) | `cdp_url="http://localhost:9222"` |
| [**Crawl4AI**](https://github.com/unclecode/crawl4ai) (~58 mil estrelas) | Endpoint CDP |
| [**Stagehand**](https://github.com/browserbase/stagehand) (~21 mil estrelas) | `connectOverCDP` |
| [**LangChain**](https://github.com/langchain-ai/langchain) Playwright toolkit | Playwright CDP |
| **Playwright / Puppeteer** (Python & JS) | `connect_over_cdp` / `connect` |```python
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp("http://localhost:9222")   # Fortress under the hood

Compilar e verificar

Reproduzir a partir do código-fonte```bash

export CHROMIUM_VERSION=$(cat CHROMIUM_VERSION) build/build.sh # depot_tools, sync the tag, apply patches, gn gen, ninja build/rebase-monthly.sh 152.0.XXXX.0 # bump + 3-way apply + rebuild + gauntlet-gate

Saída: `out/Fortress/chrome`. O fork consiste em 34 pequenos patches de superfície única (`patches/`), de modo que a maioria se reaplica sem problemas em versões upstream; o gauntlet então bloqueia o lançamento em caso de qualquer regressão.

| Plataforma | Status |
|---|---|
| Linux x64 (nativo) · **Windows x64 (nativo)** · qualquer SO via Docker | <img src="https://raw.githubusercontent.com/tiliondev/fortress/HEAD/docs/assets/icons/check.svg" width="15" alt="yes"> **disponível** |
| Instaladores assinados digitalmente · `.app` macOS · `linux/arm64` | em andamento |

### Verifique se é realmente nosso

Fortress é distribuído por quatro canais oficiais. Trate qualquer outro como não confiável:

| | Fonte oficial |
|---|---|
| **Source** | [github.com/tiliondev/fortress](https://github.com/tiliondev/fortress) |
| **Docker** | [`tilion/fortress`](https://hub.docker.com/r/tilion/fortress) |
| **Python** | [`tilion-fortress`](https://pypi.org/project/tilion-fortress/) |
| **Node** | [`tilion-fortress`](https://www.npmjs.com/package/tilion-fortress) |

**Verifique um download.** Cada lançamento inclui `SHA256SUMS`, e os SDKs `pip`/`npm` executam isso para você na instalação:```bash
BASE=https://github.com/tiliondev/fortress/releases/download/v151.0.7908.0
curl -LO $BASE/tilion-fortress-linux-x64.tar.gz
curl -Ls $BASE/SHA256SUMS | sha256sum -c --ignore-missing     # -> OK

Verifique a imagem Docker pelo digest (não apenas pela tag):```bash docker pull tilion/fortress:151.0.7908.0 docker inspect --format '{{index .RepoDigests 0}}' tilion/fortress:151.0.7908.0

compare the printed sha256:... against the digest in the GitHub Release notes

**Ou não confie em nada e reconstrua-o.** Todo o fork são 34 patches legíveis em `patches/`; `build/build.sh` reproduz o binário a partir do código-fonte do Chromium, para que você possa comparar o que compilou com o que distribuímos.

---

## Referência

<details><summary><b>Solução de problemas</b></summary>

<br/>

**Ainda bloqueado no Cloudflare, DataDome ou Kasada.** Na maioria das vezes isso é seu **IP**, não sua impressão digital: uma faixa de datacenter é sinalizada antes de qualquer script de página ser executado. Roteie a saída por proxies residenciais ou móveis e tente novamente; se desbloquear, a impressão digital estava correta.

**A impressão digital parece estranha em um host Linux.** A persona padrão é Windows, mas a forma do TLS e alguns sinais voltados ao SO seguem a máquina subjacente. Combine a persona com o SO de saída, ou configure os flags `--uxr-*` relevantes para que a história do SO concorde com o local de onde o tráfego sai.

**macOS puxa uma imagem Docker.** Binários nativos para Linux + Windows são enviados hoje; o macOS ainda executa o Fortress através da imagem oficial do Docker (`tilion/fortress`). Instale o Docker Desktop, ou execute em Linux/Windows x64 para o binário nativo.

**A persona aparece em `/proc/<pid>/cmdline`.** Os flags `--uxr-*` são legíveis por outros processos no host, uma persona por inicialização. Até que o `MaskConfig` em tempo de execução chegue, mantenha uma persona por processo e evite compartilhar o host com código não confiável.

**Um detector sinaliza algo que o gauntlet passa.** A detecção evolui. Confirme que você está na base atual do Chromium e abra uma issue com a página de teste. Essa página se torna o próximo patch.

</details>

<details><summary><b>FAQ</b></summary>

<br/>

**Isso é legal?** O Fortress é um projeto de engenharia de navegador para automação legítima, testes e scraping de dados publicamente disponíveis. Respeite os Termos de Serviço de cada site e a lei da sua jurisdição.

**É realmente gratuito?** Sim. BSD-3, totalmente aberto e auto-hospedável. A série de patches é publicada, então você pode compilar o motor atual a partir do código-fonte.

**Por que não usar apenas puppeteer-stealth ou undetected-chromedriver?** Eles aplicam patches na camada JS/CDP *após* a página poder inspecionar o navegador, então se auto-revelam via `toString` e reaquisição de realm. O Fortress move a falsificação para o C++, onde a página encontra código nativo. (Veja "Por que aplicar patch no motor, não na página.")

**Qual a diferença para o Camoufox?** A mesma ideia de interceptação em C++. O Camoufox bifurca o Firefox (~3% do tráfego, uma anomalia permanente) enquanto o Fortress bifurca o Chromium e o V8 (o motor majoritário), então um user-agent Chrome é coerente por construção.

**Isso vai passar em tudo para sempre?** Não. A detecção continua evoluindo, então enviamos um gauntlet datado e reproduzível e uma recompilação mensal do Chromium; você pode ver exatamente o que passa hoje.

</details>

<details><summary><b>Roteiro</b></summary>

<br/>

- [ ] Config JSON em tempo de execução para um `MaskConfig` em C++ (um binário, muitas impressões digitais coerentes, nada na linha de comando)
- [ ] Servidor MCP próprio mais SDKs Puppeteer / raw-CDP (substitutos para agentes de IA)
- [ ] `.exe` Windows e `.app` macOS assinados com código
- [ ] Imagem Docker `linux/arm64`
- [ ] Migrar `patches/` para substituições estilo Brave `chromium_src/`
- [ ] Linhas de referência publicadas sobre reCAPTCHA v3 / DataDome / Kasada (datadas, reproduzíveis)

</details>

<details><summary><b>Layout do repositório</b></summary>```
patches/     34 per-surface C++ patches (+ series), the source of truth for the fork
build/       args.gn, build.sh, apply-patches.sh, rebase-monthly.sh, windows/, macos/
packaging/   tilion launcher, fonts.conf, Dockerfile, .deb + bundle builders
fonts/       33 metric-compatible Windows-named fonts (incl. color emoji)
sdk/         python + node (tilion-fortress) prebuilt-binary SDKs
tools/       gauntlet.py, the CreepJS / Sannysoft / BrowserScan CI gate
docs/        GAUNTLET_RESULTS, BUILD_NATIVE, BENCHMARK

Contribuindo

Encontrou um vetor de deteção ou uma fuga que nos escapou? Abra uma issue com uma página de teste reproduzível. Uma página que sinalize o Fortress de forma fiável é a coisa mais valiosa que pode enviar. Torna-se o próximo patch. Duas regras da casa: toda capacidade reivindicada vem acompanhada de um comando que a reproduz, e todo limite é registado. A palavra "indetetável" fica de fora do repositório.

Licença

BSD-3-Clause para os patches e ferramentas do Fortress (alinhado com o Chromium). O Chromium e os tipos de letra incluídos mantêm as suas próprias licenças; consulte LICENSE e NOTICE. A série de patches é publicada para que possa auditar e reconstruir o motor por si.

O que vem a seguir

[!IMPORTANT] v2: Personas em tempo real com MaskConfig. Um grafo de persona orientado por seed e entregue via IPC a alimentar um singleton MaskConfig global em C++ no processo: milhares de impressões digitais invariantes de coerência a partir de um único binário, isolamento de identidade por BrowserContext e zero pegada na linha de comandos. O resto está no roadmap.

Manter-se atualizado

A deteção continua a evoluir, pelo que um motor furtivo é tão bom quanto a sua última rebase. O Fortress acompanha o Chromium mensal mais recente, volta a percorrer toda a bateria de testes e lança um patch sempre que um detetor encontra um novo indicador, para que o que executa continue a corresponder ao aspeto de uma instalação Chrome real. Veja os lançamentos para acompanhar o trabalho do v2 MaskConfig, ou adicione o repositório às estrelas se lhe for útil.

Furtividade que pode ler, reconstruir e executar por si.

A: driver / artefatos binários	variáveis `cdc_` do ChromeDriver, superfície do protocolo WebDriver	Dirigir CDP bruto, pular chromedriver	construído para ser dirigido desta forma
B: efeitos colaterais do CDP	`Runtime.enable` vaza via sourceURL + pegadas de init-script, por mais limpo que o binário seja	A camada de controle / CDP-client: segurar `Runtime.enable`, usar `Runtime.addBinding` + mundos isolados	sem vazamento (verificado)
C: superfície de impressão digital	canvas, WebGL, áudio, fontes, navigator, na frame principal, iframes, workers	O motor (C++), porque sobrescritas JS se autorrevelam	este é o Fortress

Camada de falsificação	nenhuma	injeção JS	patch de CDP/config	motor C++	motor C++	motor C++
`toString` retorna `[native code]`	n/a		n/a
Sobrevive à readquisição de reino (iframe/worker)
Sem vazamento de `Runtime.enable`
Motor = Chrome / V8 (maioria do tráfego)				Firefox
Forma de TLS Chromium coerente				Firefox
Motor totalmente open-source					último major paywalled
Série de patches publicada e auditável	n/a	n/a	n/a		apenas binário
Compilação reproduzível a partir da fonte	n/a	n/a	n/a
Declara seus próprios limites	n/a	n/a	n/a

CreepJS	marcado como headless	0% headless · 0% stealth, sinais do worker coerentes
bot.sannysoft.com	linhas vermelhas	0 falhas · WebDriver Advanced passou · WebGL = NVIDIA RTX 3060 / ANGLE D3D11
browserscan.net	bot detectado	“Nenhum bot detectado, poderia ser um humano”
rebrowser bot-detector	VAZAMENTO de `Runtime.enable`	sem vazamento · `webdriver=false` · init-scripts limpos (CDP bruto)
Cloudflare Turnstile	bloqueado	contornado: um clique humano limpou um desafio ao vivo (headed, IP de datacenter)

fortress

Mais Populares

34

0%

`[native code]`

BSD-3

Paridade de código nativo

CDP plug-and-play

Supera o desafio (gauntlet)

Patches auditáveis

Coerente por construção

Persona ajustável