Un moteur de navigateur pour les gouverner tous

Moteur Chromium furtif

Fortress est un moteur Chromium furtif qui empêche vos scrappers et agents navigateurs de se faire bloquer, avec une seule ligne de code modifiée. Les détecteurs de bots identifient l'automatisation en lisant l'empreinte numérique du navigateur ; Fortress corrige cette empreinte dans le C++ de Chromium, de sorte que le navigateur se présente comme une installation Chrome ordinaire. Les scrappers terminent leurs exécutions, les agents atteignent les pages qui leur sont assignées, et CreepJS, Sannysoft, BrowserScan ainsi que le Cloudflare Turnstile en direct le lisent tous comme un humain. Pointez votre Playwright ou Puppeteer existant vers Fortress via CDP, et rien d'autre dans votre code ne change.

_{Blink · V8 · BoringSSL patchés dans l'arbre · WebGL basé sur ANGLE / D3D11 · TLS cohérent JA3/JA4 · rebaseline mensuel en amont · versions reproductibles et validées par le gauntlet}

Fortress contourne un défi Cloudflare en direct, puis réussit sannysoft et BrowserScan

_{Capture non éditée du binaire Fortress dans une fenêtre réelle : il contourne un défi Cloudflare en direct, passe bot.sannysoft.com entièrement en vert, puis affiche « Normal » sur BrowserScan. Reproduisez avec tools/gauntlet.py.}

🆕 Nouveautés — 151.0.7908.0 · Rafraîchissement du moteur

Publié. Personas cohérents par lancement, renforcés.

Clavier par locale (QWERTY / QWERTZ / AZERTY) · périphériques média par persona · une passe de cohérence complète de parité de livraison.
La plateforme ↔ GPU ↔ fuseau horaire ↔ langue ↔ voix ↔ clavier se déplacent comme un seul appareil réel cohérent — à chaque lancement, depuis un unique binaire.
Parité de code natif (toString() reste [native code]), invariant par realm (main / worker / iframe) — cohérence compilée dans le navigateur, pas patchée en JavaScript.```bash pip install -U tilion-fortress # or: docker run --rm -p 9222:9222 tilion/fortress:latest

**[→ notes de version complètes](https://github.com/tiliondev/fortress/releases/tag/v151.0.7908.0)**


## Table des matières

| | |
|---|---|
| **[Ce que c'est](#what-it-is)** · **[Démarrage rapide](#quick-start)** | ce que c'est, installation, premier script, configuration d'agent IA |
| **[Le MCP Fortress](#the-fortress-mcp--stealth-browsing-as-agent-tools)** | 29 outils de navigateur furtif pour agents IA (Bêta) |
| **[Pourquoi patcher le moteur, pas la page](#why-patch-the-engine-not-the-page)** | la thèse de l'auto-révélation JS + les trois couches de détection |
| **[Comment Fortress se compare](#how-fortress-compares)** | vs puppeteer-stealth · Camoufox · CloakBrowser · vendeurs fermés |
| **[Preuve : résultats des détecteurs en direct](#proof-live-detector-results)** | CreepJS / Sannysoft / BrowserScan / Cloudflare, avec captures d'écran |
| **[Configurer le persona](#configure-the-persona)** | la surface d'empreinte `--uxr-*` |
| **[Fonctionne avec votre stack](#works-with-your-stack)** | browser-use · Crawl4AI · Stagehand · LangChain |
| **[Construire et vérifier](#build--verify)** | reproduire à partir des sources, vérifier la provenance |
| **[Référence](#reference)** | dépannage · FAQ · feuille de route · disposition du dépôt |

---

## Ce que c'est

Fortress est un fork de Chromium qui usurpe l'empreinte du navigateur depuis l'intérieur du moteur. Les surfaces que lisent les détecteurs de bots (canvas, WebGL, audio, polices, navigator, et une trentaine d'autres) sont corrigées dans le **C++** de Chromium, sans couche de correctif JavaScript au-dessus qu'une page puisse détecter.

Il est livré comme un binaire de navigateur ordinaire qui expose un endpoint CDP. Pointez Playwright, Puppeteer ou tout client CDP vers lui et votre automatisation existante s'exécute inchangée.

Un correctif furtif JavaScript laisse une couche supplémentaire que la page peut trouver : `.toString()` montre la source de la surcharge, et récupérer la même primitive depuis une iframe ou un worker contourne cette couche. Fortress corrige la surface dans le moteur à la place, de sorte que `navigator.vendor` se résout au véritable getter C++, rapporte `[native code]`, et se lit de la même manière depuis chaque contexte (realm). Une page qui s'inspecte elle-même voit du Chromium standard. C'est pourquoi votre automatisation passe là où elle était auparavant signalée, et tout blocage restant est attribué à vos proxies et à votre comportement plutôt qu'au navigateur. [Pourquoi patcher le moteur, pas la page](#why-patch-the-engine-not-the-page) couvre en détail les mécanismes de détection.```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();

Le tour en 12 secondes

Fortress en 12 secondes : réussit CreepJS, Sannysoft, BrowserScan et rebrowser, scrape des sites réels et contourne Akamai sur aa.com, lowes.com, macys.com et kohls.com.

_{Une boucle, toutes les captures réelles : réussit CreepJS / Sannysoft / BrowserScan / rebrowser → extrait des données structurées via CDP → contourne Akamai sur aa.com · lowes · macys · kohls (même IP résidentielle).}

Vrai scraping, entièrement headless

_{Captures non éditées du moteur Fortress piloté via CDP. Pas de plugins furtifs, pas de correctifs JS : l'empreinte est corrigée dans le binaire. Reproduisez ces démos avec examples/scrape_demos.py.}

Fortress extrayant books.toscrape.com en JSON typé en direct via CDP

_{Extraction structurée : les enregistrements se construisent en JSON typé au fur et à mesure que chaque élément est lu.}

Contourne Akamai réel — avant / après

Avant : un navigateur standard est bloqué par Akamai sur aa.com avec Access Denied. Après : Fortress charge la vraie page et le capteur d'Akamai l'accepte.

_{Même IP résidentielle, même site (aa.com · Akamai Bot Manager). Un navigateur standard/sans tête obtient Access Denied (Reference #) ; Fortress charge la vraie page et Akamai délivre son cookie capteur _abck — le Bot Manager l'accepte comme un vrai navigateur. La variable est l'empreinte, pas l'IP.}

Démarrage rapide```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]
> Le SDK fournit la version compilée **ainsi que `patches/`**, vous permettant de reconstruire le moteur vous-même et de vérifier chaque correction de surface par rapport à la source. Les téléchargements sont automatiquement vérifiés par SHA-256 par rapport au fichier `SHA256SUMS` de la version.

### Versions

Fortress est livré sur **deux bases Chromium** — choisissez votre compromis entre discrétion et actualité :

| Canal | Chromium | Quand l'utiliser |
|---|---|---|
| **`stable`** *(par défaut)* | **149** | Recommandé — correspond à la version de Chrome que la majorité des utilisateurs réels utilisent, donc il se fond le mieux |
| **`latest`** | **151** | Moteur le plus récent (signale une version légèrement en avance sur la 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

Binaires natifs : Linux x64 (les deux versions) + Windows x64 (151) ; Windows-149 et macOS s'exécutent via l'image Docker.

Intégrez-le à votre agent IA

Fortress est le navigateur que votre agent pilote : CDP brut sur :9222, aucun plugin furtif à configurer. Deux options s'offrent à vous.

Option 1 : ouvrez-le préchargé dans un assistant de chat. Un clic ; il lit notre AGENTS.md et vous guide tout au long de la configuration :

Option 2 : Copier pour l'agent (tout, dans votre presse-papiers). Cliquez sur l'icône de copie en haut à droite de la zone ci-dessous. Il place le contexte complet de la configuration dans votre presse-papiers : ce que c'est, installation, connexion, personnalité et règles, tout condensé depuis AGENTS.md. Collez-le dans Cursor, Claude Code, Copilot, ChatGPT ou n'importe quel agent, et il prend le relais :```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

---

## Le Fortress MCP — navigation furtive en tant qu'outils d'agent &nbsp;<sub>Beta</sub>

Le CDP brut est pour le code que vous écrivez. Le **Fortress MCP** est pour les agents qui appellent des **outils** : un serveur [Model Context Protocol](https://modelcontextprotocol.io) qui fournit à Claude, Cursor, ou tout client MCP un navigateur furtif, de sorte que dès qu'une requête est bloquée, il appelle simplement un outil et récupère la page. **29 outils, locaux et gratuits** — `fetch_protected_page`, `extract_page`, `crawl_site`, `recon_site_apis`, `search_web`, `run_browser_task`, `save_profile`, `get_stealth_cdp_endpoint`, et plus encore.

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/795/8f328e2498b09d7433208c5b4a9002450643537f2ee6b0519ac10420ef581bf3.gif" alt="Même site, même invite : un navigateur classique est bloqué par PerimeterX tandis qu'un agent avec le Fortress MCP renvoie du JSON propre" width="760"/></p>

<sub><i>Exécution réelle et datée contre <b>stockx.com</b> (PerimeterX). Un navigateur standard reçoit <b>HTTP 403 — « Accès refusé »</b> ; un agent avec le Fortress MCP renvoie du JSON propre — même site, même invite. Reproduisez-le à partir du dépôt du framework.</i></sub>

### Configurez-le en 30 secondes

Deux exécuteurs — choisissez-en un. `npx` nécessite Python dans le PATH ; `pip` l'installe directement :```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 — Paramètres → Développeur → Modifier la configuration (claude_desktop_config.json):```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

<sub>Vous préférez npx ? Utilisez <code>"command": "npx", "args": ["-y", "tilion-mcp"]</code>. Redémarrez Claude, et les outils <b>fortress</b> apparaissent.</sub>

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

Cursor (~/.cursor/mcp.json) · Cline / Windsurf (VS Code → serveurs MCP) — même bloc:```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

Ensuite, demandez simplement à votre agent — *« récupère le prix de cette page StockX »* — et il appelle `fetch_protected_page` tout seul.

### Ce que l'agent obtient

| | outils |
|---|---|
| **Obtenir des pages bloquées** | `fetch_protected_page` · `read_page` · `get_page_html` · `search_web` |
| **Données structurées** | `extract_page` (conscient du schéma) · `extract_document` (PDF/DOCX/XLSX) |
| **Sites entiers** | `crawl_site` (SPA automatique) · `recon_site_apis` (trouver l'API JSON privée) |
| **Piloter une page** | `page_elements` · `click_button` · `fill_field` · `press_key` · `wait_for` · `evaluate_js` |
| **Flux multi-étapes** | `run_browser_task` (connexion, pagination, défilement infini, paiement, …) |
| **Capture / authentification** | `screenshot_page` · `save_page` · `download_file` · `save_profile` / `load_profile` |
| **Apportez le vôtre** | `get_stealth_cdp_endpoint` → une URL CDP pour Playwright / Puppeteer / browser-use |

Les outils sont annotés (lectures auto-approuvées, écritures contrôlées), **préchauffés** au démarrage (~100 ms premier appel), sécurisés pour la concurrence, et protégés contre les timeouts et les SSRF. Un point de terminaison hébergé avec **sortie résidentielle arrive bientôt**.

→ Tableau complet des 29 outils, benchmarks et la compétence de l'agent : **[`mcp/`](https://github.com/tiliondev/fortress/blob/HEAD/mcp/README.md)**

---

## Pourquoi corriger le moteur, pas la page

L'approche habituelle corrige `navigator.webdriver`, usurpe le fournisseur WebGL et remplace `navigator.plugins` depuis un script. CreepJS et les détecteurs similaires le signalent toujours, et la raison est **structurelle**, pas une propriété de plus laissée découverte. Une usurpation JavaScript est une fonction occupant la place d'une fonction native. Les détecteurs mettent de côté la valeur retournée et interrogent si la chose qui la retourne est native :

| L'indice | Pourquoi cela détecte une usurpation JS |
|---|---|
| `toString` auto-révélation | Une méthode native se transforme en `function get vendor() { [native code] }` ; une redéfinition se transforme en son propre code source, donc un seul `.toString()` l'attrape. |
| Descripteur et `hasOwnProperty` | `getOwnPropertyDescriptor` expose les propriétés redéfinies, et `hasOwnProperty('toString')` retourne `true` sur une fonction falsifiée alors qu'une native retourne `false`. |
| `failsTypeError` | Les getters natifs lèvent une `TypeError` spécifique sur le mauvais `this` ; un shim naïf reste silencieux, et le silence est le signal. |

La réacquisition de realm est celle qui bat tous les correctifs du monde principal. Un détecteur attrape une primitive vierge d'un autre realm et l'utilise sur votre fonction :```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.

Votre patch du monde principal vit dans un domaine différent de cet iframe. Le même piège se déclenche depuis un Web Worker, un thread que votre shim du thread principal exécute à côté plutôt qu'à l'intérieur.

Fortress n'a pas une telle couche. Le getter pour navigator.vendor est le getter C++ : il renvoie [native code] car c'est du code natif, identique dans tous les domaines. Camoufox le dit bien : "il n'y a pas de détournement JavaScript à détecter." Fortress applique la même idée à V8 et Blink à la place de Gecko.

Les trois couches de détection des bots, et où Fortress se situe

Les anti-bots modernes (Cloudflare, DataDome, Kasada, HUMAN, Akamai) lisent trois surfaces structurellement différentes, à trois endroits distincts. Un seul outil corrige rarement les trois :

Fortress est le moteur de la couche C, conçu pour être piloté de sorte que A et B tiennent aussi. Le binaire seul laisse le canal CDP ouvert. Cette partie relève de la couche de contrôle, et prétendre le contraire est la façon dont vous vous faites prendre.

Comparaison de Fortress

Fortress s'appuie sur de véritables travaux antérieurs : fingerprint-chromium, ChromiumFish, et CloakBrowser sont venus en premier, et les fournisseurs commerciaux (Multilogin, Kameleo, GoLogin, AdsPower, Browserbase, Surfsky) recompilent Chromium en source fermée. La majeure partie de ce travail reste fermée : les forks payants vous remettent un binaire et vous demandent de lui faire confiance, et les fournisseurs gardent leurs patches en interne.

Fortress fait le chemin inverse, car un moteur furtif ne reste utile que lorsque les personnes qui l'utilisent peuvent voir comment il fonctionne. Chaque correction de surface vit dans patches/ sous forme d'un petit diff à usage unique que vous pouvez lire en une minute, et l'ensemble du moteur se reconstruit à partir des sources avec un seul script. Lorsqu'un détecteur trouve un nouvel indice, vous tracez le correctif, l'appliquez et le renvoyez. Cette boucle de rétroaction est le point central, et elle ne fonctionne que si le moteur reste suffisamment ouvert pour être lu, étendu et reconstruit.

Preuve : résultats des détecteurs en direct

Reproduisez n'importe quelle ligne avec tools/gauntlet.py --bundle ./tilion-fortress. Vérifié contre des détecteurs en direct ; les dates de réexécution se trouvent dans docs/GAUNTLET_RESULTS.md.

Preuve : captures d'écran réelles, non modifiées

BrowserScan	CreepJS	Cloudflare

Configurer le persona

Le binaire ne contient aucune chaîne de marque ; le lanceur applique un persona Windows par défaut cohérent. Remplacez n'importe quelle surface avec les commutateurs --uxr-*, ou définissez TILION_NO_DEFAULTS=1 pour un lancement nu.``` --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

| Variable d'env | Objectif |
|---|---|
| `TILION_NO_DEFAULTS=1` | Ignorer le personnage par défaut (lancement nu) |
| `TILION_TZ` / `TILION_LANG` | Remplacement rapide du fuseau horaire / de la langue |

> [!NOTE]
> **Le persona réside sur la ligne de commande aujourd'hui.** Les options `--uxr-*` sont lisibles par tous via `/proc/<pid>/cmdline`, donc c'est un persona par lancement et visible pour les autres processus sur l'hôte. L'environnement d'exécution `MaskConfig` arrive ensuite : il distribue le persona via IPC et supprime la limite d'un par processus (voir [suite](#whats-next)).

---

## Fonctionne avec votre stack

Fortress expose le CDP brut sur `:9222`, donc il s'intègre sous tout ce qui parle Playwright, Puppeteer, ou CDP.

| Framework | Connexion via |
|---|---|
| [**browser-use**](https://github.com/browser-use/browser-use) (~70k stars) | `cdp_url="http://localhost:9222"` |
| [**Crawl4AI**](https://github.com/unclecode/crawl4ai) (~58k stars) | point de terminaison CDP |
| [**Stagehand**](https://github.com/browserbase/stagehand) (~21k stars) | `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

Compiler & vérifier

Reproduire à partir des sources```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

Sortie : `out/Fortress/chrome`. Le fork est composé de 34 petits correctifs mono-surface (`patches/`), donc la plupart se réappliquent proprement d'une version amont à l'autre ; le gant bloque alors la sortie en cas de régression.

| Plateforme | Statut |
|---|---|
| Linux x64 (natif) · **Windows x64 (natif)** · tout OS via Docker | <img src="https://raw.githubusercontent.com/tiliondev/fortress/HEAD/docs/assets/icons/check.svg" width="15" alt="oui"> **expédié** |
| Installeurs signés numériquement · macOS `.app` · `linux/arm64` | en cours |

### Vérifier qu'il s'agit bien du nôtre

Fortress est distribué depuis quatre canaux officiels. Considérez toute autre source comme non fiable :

| | Source officielle |
|---|---|
| **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) |

**Vérifier un téléchargement.** Chaque version fournit `SHA256SUMS`, et les SDK `pip`/`npm` exécutent cette vérification pour vous lors de l'installation :```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

Vérifiez l'image Docker par digest (pas seulement le 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 ne faites confiance à rien et reconstruisez-le.** L'ensemble du fork est constitué de 34 patches lisibles dans `patches/` ; `build/build.sh` reproduit le binaire à partir des sources Chromium, afin que vous puissiez comparer ce que vous avez construit avec ce que nous distribuons.

---

## Référence

<details><summary><b>Dépannage</b></summary>

<br/>

**Toujours bloqué par Cloudflare, DataDome ou Kasada.** La plupart du temps, c'est votre **IP**, pas votre empreinte numérique : une plage de datacenter est signalée avant même que tout script de page ne s'exécute. Acheminez le trafic sortant via des proxies résidentiels ou mobiles et réessayez ; si cela se débloque, l'empreinte était correcte.

**L'empreinte semble incorrecte sur un hôte Linux.** Le persona par défaut est Windows, mais la forme TLS et certains signaux liés au système d'exploitation suivent la machine sous-jacente. Faites correspondre le persona à votre OS de sortie, ou définissez les indicateurs `--uxr-*` appropriés pour que l'OS soit cohérent avec l'origine du trafic.

**macOS tire une image Docker.** Les binaires natifs Linux et Windows sont livrés aujourd'hui ; macOS exécute encore Fortress via l'image Docker officielle (`tilion/fortress`). Installez Docker Desktop, ou exécutez sur Linux/Windows x64 pour le binaire natif.

**Le persona apparaît dans `/proc/<pid>/cmdline`.** Les indicateurs `--uxr-*` sont lisibles par les autres processus sur l'hôte, un persona par lancement. En attendant la mise en œuvre de `MaskConfig` au moment de l'exécution, gardez un persona par processus et évitez de partager l'hôte avec du code non fiable.

**Un détecteur signale quelque chose que le parcours de tests réussit.** La détection évolue. Confirmez que vous êtes sur le rebase Chromium actuel, puis ouvrez un problème avec la page de test. Cette page deviendra le prochain patch.

</details>

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

<br/>

**Est-ce légal ?** Fortress est un projet d'ingénierie de navigateur pour l'automatisation légitime, les tests et l'extraction de données publiquement disponibles. Respectez les conditions d'utilisation de chaque site et la loi de votre juridiction.

**Est-ce vraiment gratuit ?** Oui. BSD-3, entièrement ouvert et auto-hébergeable. La série de patches est publiée, vous pouvez donc construire vous-même le moteur actuel à partir des sources.

**Pourquoi ne pas simplement utiliser puppeteer-stealth ou undetected-chromedriver ?** Ils patch la couche JS/CDP *après* que la page a pu inspecter le navigateur, donc ils se révèlent via `toString` et la réacquisition de realm. Fortress déplace le leurre en C++, là où la page trouve du code natif. (Voir « Pourquoi patcher le moteur, pas la page ».)

**En quoi cela diffère-t-il de Camoufox ?** Même idée d'interception en C++. Camoufox fork Firefox (~3% du trafic, une anomalie persistante) tandis que Fortress fork Chromium et V8 (le moteur majoritaire), donc un user-agent Chrome est cohérent par construction.

**Va-t-il tout passer pour toujours ?** Non. La détection continue d'évoluer, donc nous livrons un parcours de tests daté et reproductible ainsi qu'un rebase Chromium mensuel ; vous pouvez toujours voir exactement ce qui passe aujourd'hui.

</details>

<details><summary><b>Feuille de route</b></summary>

<br/>

- [ ] Configuration JSON en runtime dans un `MaskConfig` C++ (un binaire, plusieurs empreintes cohérentes, rien en ligne de commande)
- [ ] Serveur MCP propriétaire plus SDK Puppeteer / raw-CDP (plug-and-play pour agents IA)
- [ ] `.exe` Windows et `.app` macOS signés avec code
- [ ] Image Docker `linux/arm64`
- [ ] Migrer `patches/` vers des surcharges `chromium_src/` style Brave
- [ ] Lignes de référence publiées pour reCAPTCHA v3 / DataDome / Kasada (datées, reproductibles)

</details>

<details><summary><b>Structure du dépôt</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

Contribuer

Vous avez trouvé un vecteur de détection ou une fuite que nous avons manquée ? Ouvrez un ticket avec une page de test reproductible. Une page qui détecte Fortress de manière fiable est ce que vous pouvez envoyer de plus précieux. Elle deviendra le prochain correctif. Deux règles de maison : chaque capacité annoncée est accompagnée d'une commande qui la reproduit, et chaque limite est notifiée. Le mot « indétectable » reste en dehors du dépôt.

Licence

BSD-3-Clause pour les correctifs et outils Fortress (en accord avec Chromium). Chromium et les polices regroupées conservent leurs propres licences ; voir LICENSE et NOTICE. La série de correctifs est publiée, afin que vous puissiez auditer et reconstruire le moteur vous-même.

Prochaine étape

[!IMPORTANT] v2 : Personas d'exécution MaskConfig. Un graphe de personnalités piloté par seed et distribué par IPC alimentant un singleton MaskConfig C++ global au processus : des milliers d'empreintes cohérentes en invariants à partir d'un seul binaire, un isolement d'identité par BrowserContext, et une empreinte de ligne de commande nulle. Le reste se trouve sur la feuille de route.

Rester à jour

La détection évolue constamment, donc un moteur furtif n'est aussi bon que son dernier rebasage. Fortress suit le dernier Chromium mensuel, relance la batterie de tests complète et publie un correctif dès qu'un détecteur trouve un nouvel indicateur, afin que ce que vous exécutez corresponde toujours à ce à quoi ressemble une véritable installation Chrome. Surveillez les versions pour suivre les travaux sur v2 MaskConfig, ou mettez une étoile au dépôt s'il vous est utile.

Une furtivité que vous pouvez lire, reconstruire et exécuter vous-même.

A: artefacts du pilote / binaires	variables `cdc_` de ChromeDriver, surface du protocole WebDriver	Piloter le CDP brut, sauter chromedriver	conçu pour être piloté de cette façon
B: effets secondaires du CDP	les fuites de `Runtime.enable` via les empreintes sourceURL + init-script, même si le binaire est propre	La couche de contrôle / client CDP : retenir `Runtime.enable`, utiliser `Runtime.addBinding` + mondes isolés	pas de fuite (vérifié)
C: surface d'empreinte	canvas, WebGL, audio, polices, navigator, dans le cadre principal, les iframes, les workers	Le moteur (C++), car les surcharges JS se révèlent	c'est Fortress

Couche de spoofing	none	JS injection	CDP/config patch	moteur C++	moteur C++	moteur C++
`toString` produit `[native code]`	n/a		n/a
Survit à la réacquisition de domaine (iframe/worker)
Pas de fuite `Runtime.enable`
Moteur = Chrome / V8 (trafic majoritaire)				Firefox
Forme TLS Chromium cohérente				Firefox
Moteur entièrement open-source					dernière version majeure payante
Série de patches publiée et vérifiable	n/a	n/a	n/a		binaire uniquement
Construction reproductible à partir des sources	n/a	n/a	n/a
Déclare ses propres limites	n/a	n/a	n/a

CreepJS	signalé comme headless	0% headless · 0% furtif, signaux worker cohérents
bot.sannysoft.com	lignes rouges	0 échec · WebDriver Advanced réussi · WebGL = NVIDIA RTX 3060 / ANGLE D3D11
browserscan.net	bot détecté	“Aucun bot détecté, pourrait être un humain”
rebrowser bot-detector	Fuite `Runtime.enable`	pas de fuite · `webdriver=false` · scripts d'initialisation propres (CDP brut)
Cloudflare Turnstile	bloqué	contourné: un clic humain a résolu un défi en direct (headed, IP de datacenter)

fortress

Populaires

34

0%

`[native code]`

BSD-3

Parité de code natif

CDP prêt à l'emploi

Passe le gauntlet

Correctifs auditatables

Cohérent par construction

Persona ajustable