Un motor de navegador para gobernarlos a todos

Motor Chromium sigiloso

Fortress es un motor Chromium sigiloso que evita que tus scrapers y agentes de navegador sean bloqueados, con solo una línea de cambio de código. Los detectores de bots marcan la automatización leyendo la huella digital del navegador; Fortress corrige esa huella dentro del C++ de Chromium, de modo que el navegador se presenta como una instalación normal de Chrome. Los scrapers terminan sus ejecuciones, los agentes llegan a las páginas a las que fueron enviados, y CreepJS, Sannysoft, BrowserScan y Cloudflare Turnstile en vivo lo leen como humano. Apunta tu Playwright o Puppeteer existente a Fortress a través de CDP, y nada más en tu código cambia.

_{Blink · V8 · BoringSSL parcheados en el árbol · WebGL respaldado por ANGLE / D3D11 · TLS coherente JA3/JA4 · actualización mensual aguas arriba · versiones reproducibles, controladas por el gauntlet}

Fortress superando un desafío de Cloudflare en vivo, luego pasando sannysoft y BrowserScan

_{Captura sin editar del binario de Fortress en una ventana real: supera un desafío de Cloudflare en vivo, pone bot.sannysoft.com todo verde, luego lee BrowserScan “Normal”. Reproduce con tools/gauntlet.py.}

🆕 Novedades — 151.0.7908.0 · Refresco del motor

Lanzado. Personas coherentes por lanzamiento, endurecidas.

Teclado por localización (QWERTY / QWERTZ / AZERTY) · dispositivos multimedia por persona · un pase de coherencia de paridad de entrega completo.
Plataforma ↔ GPU ↔ zona horaria ↔ idioma ↔ voces ↔ teclado se mueven como un dispositivo real coherente — en cada inicio, desde un solo binario.
Paridad de código nativo (toString() sigue siendo [native code]), invariable en reinos (main / worker / iframe) — coherencia compilada en el navegador, no parcheada en JavaScript.```bash pip install -U tilion-fortress # or: docker run --rm -p 9222:9222 tilion/fortress:latest

**[→ notas completas de la versión](https://github.com/tiliondev/fortress/releases/tag/v151.0.7908.0)**


## Contenido

| | |
|---|---|
| **[Qué es](#what-it-is)** · **[Inicio rápido](#quick-start)** | qué es, instalación, primer script, configuración del agente de IA |
| **[Fortress MCP](#the-fortress-mcp--stealth-browsing-as-agent-tools)** | 29 herramientas de navegación sigilosa para agentes de IA (Beta) |
| **[Por qué parchear el motor, no la página](#why-patch-the-engine-not-the-page)** | la tesis de JS autorrevelador + las tres capas de detección |
| **[Cómo se compara Fortress](#how-fortress-compares)** | vs puppeteer-stealth · Camoufox · CloakBrowser · proveedores cerrados |
| **[Prueba: resultados de detectores en vivo](#proof-live-detector-results)** | CreepJS / Sannysoft / BrowserScan / Cloudflare, con capturas de pantalla |
| **[Configurar la personalidad](#configure-the-persona)** | la superficie de huella digital `--uxr-*` |
| **[Funciona con tu stack](#works-with-your-stack)** | browser-use · Crawl4AI · Stagehand · LangChain |
| **[Compilar y verificar](#build--verify)** | reproducir desde el código fuente, verificar procedencia |
| **[Referencia](#reference)** | solución de problemas · Preguntas frecuentes · hoja de ruta · diseño del repositorio |

---

## Qué es

Fortress es un fork de Chromium que falsifica la huella digital del navegador desde el interior del motor. Las superficies que leen los detectores de bots (canvas, WebGL, audio, fuentes, navigator y unas treinta más) se corrigen en **C++** de Chromium, sin una capa de parche de JavaScript en la parte superior que una página pueda detectar.

Se distribuye como un binario de navegador común que expone un endpoint CDP. Apunte Playwright, Puppeteer o cualquier cliente CDP hacia él y su automatización existente se ejecuta sin cambios.

Un parche de JavaScript sigiloso deja una capa extra que la página puede encontrar: `.toString()` muestra el código fuente de la sobrescritura, y volver a obtener la misma primitiva desde un iframe o worker la elude. Fortress corrige la superficie en el motor en su lugar, por lo que `navigator.vendor` se resuelve al getter real de C++, informa `[native code]` y se lee igual desde todos los ámbitos. Una página que se inspecciona a sí misma ve un Chromium estándar. Por eso su automatización pasa donde antes era detectada, y cualquier bloqueo restante se debe a sus proxies y comportamiento, no al navegador. [Por qué parchear el motor, no la página](#why-patch-the-engine-not-the-page) cubre la mecánica de detección en su totalidad.```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();

El tour de 12 segundos

Fortress en 12 segundos: pasa CreepJS, Sannysoft, BrowserScan y rebrowser, extrae sitios reales y supera Akamai en aa.com, lowes.com, macys.com y kohls.com.

_{Un solo bucle, todas las capturas reales: pasa CreepJS / Sannysoft / BrowserScan / rebrowser → extrae datos estructurados a través de CDP → supera Akamai en aa.com · lowes · macys · kohls (misma IP residencial).}

Extracción real, completamente headless

_{Capturas sin editar del motor Fortress ejecutado a través de CDP. Sin plugins de ocultación, sin parches JS: la huella digital se corrige en el binario. Reproduzca cualquiera de estos con examples/scrape_demos.py.}

Fortress extrayendo books.toscrape.com en registros JSON tipificados en vivo a través de CDP

_{Extracción estructurada: los registros se construyen en JSON tipificado a medida que se lee cada elemento.}

Supera Akamai real — antes / después

Antes: un navegador estándar es bloqueado por Akamai en aa.com con Acceso Denegado. Después: Fortress carga la página real y el sensor de Akamai la acepta.

_{Misma IP residencial, mismo sitio (aa.com · Akamai Bot Manager). Un navegador estándar/headless obtiene Acceso Denegado (Reference #); Fortress carga la página real y Akamai emite su cookie de sensor _abck — el Bot Manager lo acepta como un navegador real. La variable es la huella digital, no la IP.}

Inicio 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]
> El SDK incluye la versión compilada además de `patches/`, para que puedas reconstruir el motor tú mismo y verificar cada corrección superficial contra el código fuente. Las descargas se verifican mediante SHA-256 contra los `SHA256SUMS` de la versión automáticamente.

### Versiones

Fortress se distribuye sobre **dos bases de Chromium** — elige tu equilibrio entre pasar desapercibido y actualidad:

| Canal | Chromium | Cuándo usarlo |
|---|---|---|
| **`stable`** *(default)* | **149** | Recomendado — coincide con la versión de Chrome que ejecuta la mayoría de los usuarios reales, por lo que pasa desapercibido mejor |
| **`latest`** | **151** | Motor más nuevo (informa una versión ligeramente por delante de la estable) |```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

Binarios nativos: Linux x64 (ambas versiones) + Windows x64 (151); Windows-149 y macOS se ejecutan mediante la imagen Docker.

Incorpóralo en tu agente de IA

Fortress es el navegador que maneja tu agente: CDP puro en :9222, sin plugins de sigilo que conectar. Hay dos formas de acceder.

Opción 1: ábrelo precargado en un asistente de chat. Un clic; lee nuestro AGENTS.md y te guía a través de la configuración completa:

Opción 2: Copiar para el agente (todo, a tu portapapeles). Haz clic en el icono de copiar en la esquina superior derecha del recuadro de abajo. Coloca el contexto completo de configuración en tu portapapeles: qué es, instalación, conexión, persona y reglas, todo AGENTS.md condensado. Pégalo en Cursor, Claude Code, Copilot, ChatGPT, o cualquier agente y él se encargará del resto:```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

---

## The Fortress MCP — navegación sigilosa como herramientas de agente &nbsp;<sub>Beta</sub>

El CDP sin procesar es para el código que escribes. El **Fortress MCP** es para agentes que llaman a **herramientas**: un servidor [Model Context Protocol](https://modelcontextprotocol.io) que ofrece a Claude, Cursor o cualquier cliente MCP un navegador sigiloso, de modo que en cuanto una petición es bloqueada, simplemente llama a una herramienta y obtiene la página. **29 herramientas, locales y gratuitas** — `fetch_protected_page`, `extract_page`, `crawl_site`, `recon_site_apis`, `search_web`, `run_browser_task`, `save_profile`, `get_stealth_cdp_endpoint`, y más.

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/795/8f328e2498b09d7433208c5b4a9002450643537f2ee6b0519ac10420ef581bf3.gif" alt="Mismo sitio, mismo prompt: un navegador estándar es bloqueado por PerimeterX mientras que un agente con el Fortress MCP devuelve JSON limpio" width="760"/></p>

<sub><i>Ejecución real y fechada contra <b>stockx.com</b> (PerimeterX). Un navegador estándar recibe <b>HTTP 403 — “Acceso denegado”</b>; un agente con el Fortress MCP devuelve JSON limpio — mismo sitio, mismo prompt. Reprodúzcalo desde el repositorio del framework.</i></sub>

### Configúralo en 30 segundos

Dos ejecutores — elige uno. `npx` necesita Python en el PATH; `pip` lo instala directamente:```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 — Configuración → Desarrollador → Editar configuración (claude_desktop_config.json):```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

<sub>¿Prefieres npx? Usa <code>"command": "npx", "args": ["-y", "tilion-mcp"]</code>. Reinicia Claude, y las herramientas <b>fortress</b> aparecen.</sub>

**Claude Code** (CLI) — una línea:```bash
claude mcp add fortress -- tilion-mcp          # or:  claude mcp add fortress -- npx -y tilion-mcp

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

Entonces solo dile a tu agente — *“obtén el precio de esta página de StockX”* — y él mismo llama a `fetch_protected_page`.

### Lo que obtiene el agente

| | tools |
|---|---|
| **Obtener páginas bloqueadas** | `fetch_protected_page` · `read_page` · `get_page_html` · `search_web` |
| **Datos estructurados** | `extract_page` (schema-aware) · `extract_document` (PDF/DOCX/XLSX) |
| **Sitios completos** | `crawl_site` (auto-SPA) · `recon_site_apis` (find the private JSON API) |
| **Interactuar con una página** | `page_elements` · `click_button` · `fill_field` · `press_key` · `wait_for` · `evaluate_js` |
| **Flujos de varios pasos** | `run_browser_task` (login, paginate, infinite-scroll, checkout, …) |
| **Captura / autenticación** | `screenshot_page` · `save_page` · `download_file` · `save_profile` / `load_profile` |
| **Trae tu propio** | `get_stealth_cdp_endpoint` → a CDP url for Playwright / Puppeteer / browser-use |

Las herramientas están anotadas (lecturas auto-aprobadas, escrituras con puerta), **precalentadas** al inicio (~100 ms la primera llamada), seguras para concurrencia, y protegidas contra tiempos de espera y SSRF. Próximamente un endpoint alojado con **egreso residencial**.

→ Tabla completa de 29 herramientas, benchmarks y la habilidad del agente: **[`mcp/`](https://github.com/tiliondev/fortress/blob/HEAD/mcp/README.md)**

---

## Por qué parchear el motor, no la página

El enfoque habitual parchea `navigator.webdriver`, falsifica el proveedor de WebGL y sobrescribe `navigator.plugins` desde el script. CreepJS y detectores similares aún lo detectan, y la razón es **estructural**, no una propiedad más sin cubrir. Una suplantación de JavaScript es una función donde debería haber una nativa. Los detectores apartan el valor devuelto e interrogan si la cosa que lo devuelve es nativa:

| El indicio | Por qué detecta una suplantación de JS |
|---|---|
| `toString` self-reveal | Un método nativo se serializa como `function get vendor() { [native code] }`; una sobrescritura se serializa con su propio código fuente, así que un `.toString()` lo detecta. |
| Descriptor and `hasOwnProperty` | `getOwnPropertyDescriptor` expone propiedades redefinidas, y `hasOwnProperty('toString')` devuelve `true` en una función alterada donde una nativa devuelve `false`. |
| `failsTypeError` | Los getters nativos lanzan un `TypeError` específico con el `this` incorrecto; un shim ingenuo permanece en silencio, y el silencio es la señal. |

La readquisición de realm es la que derrota cualquier parche en el mundo principal. Un detector toma una primitiva limpia de otro realm y la usa contra tu función:```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.

Your main-world patch lives in a different realm from that iframe. The same trap fires from a Web Worker, a thread your main-thread shim runs beside rather than inside.

Fortress has no such layer. The getter for navigator.vendor is the C++ getter: it reports [native code] because it is native code, identical across every realm. Camoufox puts it well: “no hay secuestro de JavaScript que detectar.” Fortress applies the same idea to V8 and Blink in place of Gecko.

The three layers of bot detection, and where Fortress fits

Modern anti-bots (Cloudflare, DataDome, Kasada, HUMAN, Akamai) read three structurally different surfaces, in three separate places. One tool rarely fixes all three:

Fortress is the Layer-C engine, built to be driven so A and B hold too. The binary alone leaves the CDP channel open. That part is on the control layer, and pretending otherwise is how you get caught.

How Fortress compares

Fortress builds on real prior art: fingerprint-chromium, ChromiumFish, and CloakBrowser came first, and commercial vendors (Multilogin, Kameleo, GoLogin, AdsPower, Browserbase, Surfsky) recompile Chromium behind closed source. Most of that work stays closed: the paywalled forks hand you a binary and ask you to trust it, and the vendors keep their patches in-house.

Fortress goes the other way, because a stealth engine only stays useful when the people relying on it can see how it works. Every surface correction lives in patches/ as a small, single-purpose diff you can read in a minute, and the whole engine rebuilds from source with one script. When a detector finds a new tell, you trace the fix, patch it, and send it back. That feedback loop is the point, and it only works while the engine stays open enough to read, extend, and rebuild.

Proof: live-detector results

Reproduce any row with tools/gauntlet.py --bundle ./tilion-fortress. Verified against live detectors; re-run dated in docs/GAUNTLET_RESULTS.md.

Proof: real, unedited screenshots

BrowserScan	CreepJS	Cloudflare

Configure the persona

The binary carries zero brand strings; the launcher applies a coherent default Windows persona. Override any surface with --uxr-* switches, or set TILION_NO_DEFAULTS=1 for a bare launch.``` --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

| `TILION_NO_DEFAULTS=1` | Omitir el perfil predeterminado (inicio sin personalidad) |
|---|---|
| `TILION_TZ` / `TILION_LANG` | Sobrescritura rápida de zona horaria / idioma |

> [!NOTE]
> **Hoy en día, la personalidad viaja en la línea de comandos.** Los modificadores `--uxr-*` son legibles mundialmente a través de `/proc/<pid>/cmdline`, por lo que es una personalidad por lanzamiento y visible para otros procesos en el host. El entorno `MaskConfig` llegará a continuación: entrega la personalidad a través de IPC y elimina el límite de un proceso por lanzamiento (consulte [próximos pasos](#próximos-pasos)).

---

## Funciona con tu stack

Fortress expone CDP sin procesar en `:9222`, por lo que se integra con cualquier cosa que hable Playwright, Puppeteer o CDP.

| Framework | Conectar mediante |
|---|---|
| [**browser-use**](https://github.com/browser-use/browser-use) (~70k estrellas) | `cdp_url="http://localhost:9222"` |
| [**Crawl4AI**](https://github.com/unclecode/crawl4ai) (~58k estrellas) | Punto de conexión CDP |
| [**Stagehand**](https://github.com/browserbase/stagehand) (~21k estrellas) | `connectOverCDP` |
| [**LangChain**](https://github.com/langchain-ai/langchain) Playwright toolkit | Playwright CDP |
| **Playwright / Puppeteer** (Python y 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

Construir y verificar

Reproducir desde el código fuente```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

Salida: `out/Fortress/chrome`. El fork consta de 34 pequeños parches de superficie única (`patches/`), por lo que la mayoría se reaplican limpiamente en las versiones upstream; el gauntlet luego controla la liberación ante cualquier regresión.

| Plataforma | Estado |
|---|---|
| Linux x64 (nativo) · **Windows x64 (nativo)** · cualquier SO a través de Docker | <img src="https://raw.githubusercontent.com/tiliondev/fortress/HEAD/docs/assets/icons/check.svg" width="15" alt="yes"> **en producción** |
| Instaladores con firma de código · macOS `.app` · `linux/arm64` | en progreso |

### Verifica que sea realmente nuestro

Fortress se distribuye a través de cuatro canales oficiales. Considera cualquier otra cosa como no confiable:

| | Fuente oficial |
|---|---|
| **Código fuente** | [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) |

**Verificar una descarga.** Cada versión incluye `SHA256SUMS`, y los SDKs de `pip`/`npm` lo ejecutan por ti durante la instalación:```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

Verifica la imagen de Docker mediante el digest (no solo la etiqueta):```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

**O no confíes en nada y reconstruye.** Toda la bifurcación consta de 34 parches legibles en `patches/`; `build/build.sh` reproduce el binario a partir del código fuente de Chromium, para que puedas comparar lo que compilaste con lo que distribuimos.

---

## Referencia

<details><summary><b>Solución de problemas</b></summary>

<br/>

**Todavía bloqueado por Cloudflare, DataDome o Kasada.** La mayoría de las veces esto se debe a tu **IP**, no a tu huella digital: un rango de datacenter se marca antes de que se ejecute cualquier script de la página. Enruta la salida a través de proxies residenciales o móviles y vuelve a intentar; si se desbloquea, la huella digital era correcta.

**La huella se ve mal en un host Linux.** La personalidad predeterminada es Windows, pero la forma TLS y algunas señales orientadas al sistema operativo siguen a la máquina subyacente. Ajusta la personalidad a tu sistema operativo de salida, o configura las banderas `--uxr-*` relevantes para que la historia del SO coincida con el lugar por donde sale el tráfico.

**macOS obtiene una imagen Docker.** Los binarios nativos para Linux y Windows se distribuyen hoy; macOS aún ejecuta Fortress a través de la imagen oficial de Docker (`tilion/fortress`). Instala Docker Desktop, o ejecuta en Linux/Windows x64 para el binario nativo.

**La personalidad aparece en `/proc/<pid>/cmdline`.** Las banderas `--uxr-*` son legibles por otros procesos en el host, una personalidad por ejecución. Hasta que llegue el `MaskConfig` en tiempo de ejecución, mantén una personalidad por proceso y evita compartir el host con código no confiable.

**Un detector marca algo que el gauntlet pasa.** La detección se mueve. Confirma que estás en la versión actual de Chromium rebase, luego abre un issue con la página de prueba. Esa página se convierte en el próximo parche.

</details>

<details><summary><b>Preguntas frecuentes</b></summary>

<br/>

**¿Es esto legal?** Fortress es un proyecto de ingeniería de navegador para automatización, pruebas y scraping legítimos de datos disponibles públicamente. Respeta los Términos de Servicio de cada sitio y la ley de tu jurisdicción.

**¿Es realmente gratuito?** Sí. BSD-3, completamente abierto y autoalojable. La serie de parches está publicada, por lo que puedes compilar el motor actual desde el código fuente tú mismo.

**¿Por qué no usar simplemente puppeteer-stealth o undetected-chromedriver?** Parchean la capa JS/CDP *después* de que la página puede inspeccionar el navegador, por lo que se auto-revelan mediante `toString` y re-adquisición de ámbito. Fortress mueve el engaño a C++, donde la página encuentra código nativo. (Ver "Por qué parchear el motor, no la página".)

**¿En qué se diferencia de Camoufox?** Misma idea de intercepción en C++. Camoufox bifurca Firefox (~3% del tráfico, una anomalía persistente) mientras que Fortress bifurca Chromium y V8 (el motor mayoritario), por lo que un user-agent de Chrome es coherente por construcción.

**¿Pasará todo para siempre?** No. La detección sigue moviéndose, así que ofrecemos un gauntlet fechado y reproducible, y un rebase mensual de Chromium; siempre puedes ver exactamente qué pasa hoy.

</details>

<details><summary><b>Hoja de ruta</b></summary>

<br/>

- [ ] Config JSON en tiempo de ejecución a un `MaskConfig` en C++ (un binario, muchas huellas coherentes, nada en la línea de comandos)
- [ ] Servidor MCP de primera parte más SDKs de Puppeteer / raw-CDP (compatible para agentes de IA)
- [ ] Ejecutable `.exe` firmado para Windows y `.app` para macOS
- [ ] Imagen Docker `linux/arm64`
- [ ] Migrar `patches/` a anulaciones tipo Brave `chromium_src/`
- [ ] Publicar filas de referencia de reCAPTCHA v3 / DataDome / Kasada (con fecha, reproducibles)

</details>

<details><summary><b>Estructura del repositorio</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

Contribuciones

¿Encontraste un vector de detección o una fuga que pasamos por alto? Abre un issue con una página de prueba reproducible. Una página que marque Fortress de forma fiable es lo más valioso que puedes enviar. Se convierte en el siguiente parche. Dos reglas de la casa: cada afirmación de capacidad incluye un comando que la reproduce, y cada límite está documentado. La palabra "indetectable" se mantiene fuera del repositorio.

Licencia

BSD-3-Clause para los parches y herramientas de Fortress (coincidiendo con Chromium). Chromium y las fuentes incluidas conservan sus propias licencias; consulta LICENSE y NOTICE. La serie de parches está publicada, para que puedas auditar y reconstruir el motor por ti mismo.

¿Qué sigue?

[!IMPORTANT] v2: Personas en tiempo de ejecución de MaskConfig. Un grafo de personas basado en semillas y entregado por IPC que alimenta un singleton global de C++ MaskConfig: miles de huellas digitales invariantes de coherencia desde un único binario, aislamiento de identidad por BrowserContext y huella cero en línea de comandos. El resto está en la hoja de ruta.

Mantente al día

La detección sigue avanzando, por lo que un motor sigiloso solo es tan bueno como su último rebase. Fortress sigue el Chromium mensual más reciente, vuelve a ejecutar toda la batería de pruebas y envía un parche cada vez que un detector encuentra un nuevo indicador, para que lo que ejecutes siga coincidiendo con lo que parece una instalación real de Chrome. Mira los lanzamientos para seguir el trabajo de v2 MaskConfig, o dale una estrella al repositorio si te resulta útil.

Sigilo que puedes leer, reconstruir y ejecutar tú mismo.

A: driver / binary artifacts	`cdc_` ChromeDriver vars, WebDriver protocol surface	Drive raw CDP, skip chromedriver	built to be driven this way
B: CDP side-effects	`Runtime.enable` leaks via sourceURL + init-script footprints, however clean the binary is	The control / CDP-client layer: hold back `Runtime.enable`, use `Runtime.addBinding` + isolated worlds	no leak (verified)
C: fingerprint surface	canvas, WebGL, audio, fonts, navigator, across main frame, iframes, workers	The engine (C++), because JS overrides self-reveal	this is Fortress

Spoof layer	none	JS injection	CDP/config patch	C++ engine	C++ engine	C++ engine
`toString` yields `[native code]`	n/a		n/a
Survives realm re-acquisition (iframe/worker)
No `Runtime.enable` leak
Engine = Chrome / V8 (majority traffic)				Firefox
Coherent Chromium TLS shape				Firefox
Fully open-source engine					latest major paywalled
Published, auditable patch series	n/a	n/a	n/a		binary only
Reproducible from-source build	n/a	n/a	n/a
States its own limits	n/a	n/a	n/a

CreepJS	flagged headless	0% headless · 0% stealth, worker signals coherent
bot.sannysoft.com	red rows	0 failed · WebDriver Advanced passed · WebGL = NVIDIA RTX 3060 / ANGLE D3D11
browserscan.net	bot detected	“No bots detected, could be a human”
rebrowser bot-detector	`Runtime.enable` LEAK	no leak · `webdriver=false` · clean init-scripts (raw CDP)
Cloudflare Turnstile	blocked	bypassed: a human click cleared a live challenge (headed, datacenter IP)

fortress

Más Populares

34

0%

`[native code]`

BSD-3

Paridad de código nativo

CDP integrable

Supera el desafío

Parches auditables

Coherente por construcción

Persona ajustable