Un motore del browser per domarli tutti

Motore Chromium stealth

Fortress è un motore Chromium stealth che impedisce ai tuoi scraper e agenti del browser di essere bloccati, con una sola riga di codice di modifica. I rilevatori di bot individuano l'automazione leggendo l'impronta digitale del browser; Fortress corregge quell'impronta all'interno del C++ di Chromium, in modo che il browser si presenti come una normale installazione di Chrome. Gli scraper completano le loro esecuzioni, gli agenti raggiungono le pagine a cui erano stati inviati e CreepJS, Sannysoft, BrowserScan e Cloudflare Turnstile live lo leggono come umano. Punta il tuo attuale Playwright o Puppeteer su Fortress tramite CDP e nient'altro nel tuo codice cambia.

_{Blink · V8 · BoringSSL patch inline nell'albero · WebGL basato su ANGLE / D3D11 · TLS JA3/JA4-coerente · rebase mensile a monte · versioni riproducibili e verificate dalla gauntlet}

Fortress supera una sfida live di Cloudflare, poi passa sannysoft e BrowserScan

_{Cattura non modificata del binario Fortress in una finestra reale: supera una sfida live di Cloudflare, mostra bot.sannysoft.com completamente verde, poi legge BrowserScan “Normal”. Riproducibile con tools/gauntlet.py.}

🆕 Novità — 151.0.7908.0 · Aggiornamento del motore

Rilasciato. Persone coerenti per avvio, rafforzate.

Tastiera per locale (QWERTY / QWERTZ / AZERTY) · dispositivi multimediali per persona · un passaggio completo di coerenza a parità di distribuzione.
Piattaforma ↔ GPU ↔ fuso orario ↔ lingua ↔ voci ↔ tastiera si muovono come un unico dispositivo reale coerente — ad ogni avvio, da un singolo binario.
Parità con codice nativo (toString() rimane [native code]), invariante per realm (main / worker / iframe) — coerenza compilata nel browser, non applicata in JavaScript.```bash pip install -U tilion-fortress # or: docker run --rm -p 9222:9222 tilion/fortress:latest

**[→ note di rilascio complete](https://github.com/tiliondev/fortress/releases/tag/v151.0.7908.0)**


## Indice

| | |
|---|---|
| **[Cos'è](#what-it-is)** · **[Avvio rapido](#quick-start)** | cos'è, installazione, primo script, configurazione dell'agente AI |
| **[The Fortress MCP – navigazione invisibile come strumenti per agenti](#the-fortress-mcp--stealth-browsing-as-agent-tools)** | 29 strumenti stealth-browser per agenti AI (Beta) |
| **[Perché patchare il motore, non la pagina](#why-patch-the-engine-not-the-page)** | la tesi del JS auto-rivelante + i tre livelli di rilevamento |
| **[Come si confronta Fortress](#how-fortress-compares)** | vs puppeteer-stealth · Camoufox · CloakBrowser · fornitori chiusi |
| **[Prova: risultati dei rilevatori live](#proof-live-detector-results)** | CreepJS / Sannysoft / BrowserScan / Cloudflare, con screenshot |
| **[Configura la persona](#configure-the-persona)** | la superficie delle impronte digitali `--uxr-*` |
| **[Funziona con il tuo stack](#works-with-your-stack)** | browser-use · Crawl4AI · Stagehand · LangChain |
| **[Compila e verifica](#build--verify)** | riproduci dal sorgente, verifica la provenienza |
| **[Riferimenti](#reference)** | risoluzione problemi · FAQ · roadmap · struttura del repository |

---

## Cos'è

Fortress è un fork di Chromium che falsifica l'impronta digitale del browser dall'interno del motore. Le superfici che i rilevatori di bot leggono (canvas, WebGL, audio, font, navigator e circa trenta altre) vengono corrette in **C++** di Chromium, senza uno strato di patch JavaScript in superficie che una pagina possa intercettare.

Viene distribuito come un normale binario del browser che espone un endpoint CDP. Punta Playwright, Puppeteer o qualsiasi client CDP verso di esso e la tua automazione esistente funziona senza modifiche.

Una patch JavaScript furtiva lascia uno strato aggiuntivo che la pagina può trovare: `.toString()` mostra il sorgente dell'override, e riprendere la stessa primitiva da un iframe o worker la supera. Fortress corregge la superficie nel motore invece, quindi `navigator.vendor` risolve al vero getter C++, riporta `[native code]` e legge lo stesso da ogni contesto. Una pagina che si ispeziona vede Chromium normale. Questo è il motivo per cui la tua automazione passa dove prima veniva segnalata, e qualsiasi blocco rimasto risale ai tuoi proxy e al comportamento piuttosto che al browser. [Perché patchare il motore, non la pagina](#why-patch-the-engine-not-the-page) copre i meccanismi di rilevamento in dettaglio.```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();

Il tour di 12 secondi

Fortress in 12 secondi: supera CreepJS, Sannysoft, BrowserScan e rebrowser, esegue scraping su siti reali e supera Akamai su aa.com, lowes.com, macys.com e kohls.com.

_{Un unico loop, tutte catture reali: supera CreepJS / Sannysoft / BrowserScan / rebrowser → estrae dati strutturati via CDP → supera Akamai su aa.com · lowes · macys · kohls (stesso IP residenziale).}

Scraping reale, completamente headless

_{Catture non modificate del motore Fortress pilotato via CDP. Nessun plugin furtivo, nessuna patch JS: l'impronta è corretta nel binario. Riproduci uno qualsiasi di questi con examples/scrape_demos.py.}

Fortress estrae books.toscrape.com in record JSON tipizzati in tempo reale via CDP

_{Estrazione strutturata: i record vengono costruiti in JSON tipizzati man mano che ogni elemento viene letto.}

Supera Akamai reale — prima / dopo

Prima: un browser standard è bloccato da Akamai su aa.com con Access Denied. Dopo: Fortress carica la pagina reale e il sensore di Akamai la accetta.

_{Stesso IP residenziale, stesso sito (aa.com · Akamai Bot Manager). Un browser standard/headless riceve Access Denied (Reference #); Fortress carica la pagina reale e Akamai emette il suo cookie sensore _abck — il Bot Manager lo accetta come browser reale. La variabile è l'impronta, non l'IP.}

Avvio rapido```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]
> L'SDK include il build compilato **più `patches/`**, così puoi ricostruire il motore da solo e verificare ogni correzione superficiale rispetto alla fonte. I download sono verificati tramite SHA-256 rispetto al file `SHA256SUMS` della release automaticamente.

### Versioni

Fortress è disponibile su **due basi Chromium** — scegli il tuo compromesso tra mimetizzazione e aggiornamento:

| Canale | Chromium | Quando usare |
|---|---|---|
| **`stable`** *(predefinito)* | **149** | Consigliato — corrisponde alla versione di Chrome eseguita dalla maggior parte degli utenti reali, quindi si mimetizza meglio |
| **`latest`** | **151** | Motore più recente (segnala una versione leggermente superiore a 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

Binari nativi: Linux x64 (entrambe le versioni) + Windows x64 (151); Windows-149 e macOS vengono eseguiti tramite l'immagine Docker.

Inseriscilo nel tuo agente AI

Fortress è il browser che il tuo agente guida: CDP puro su :9222, nessun plugin stealth da configurare. Ci sono due modi per accedervi.

Opzione 1: aprilo pre-caricato in un assistente chat. Un clic; legge il nostro AGENTS.md e ti guida attraverso l'intera configurazione:

Opzione 2: Copia per agente (tutto, negli appunti). Fai clic sull'icona di copia nell'angolo in alto a destra del riquadro sottostante. Mette tutto il contesto di configurazione negli appunti: cos'è, installazione, connessione, persona e regole, tutto condensato da AGENTS.md. Incollalo in Cursor, Claude Code, Copilot, ChatGPT o qualsiasi agente e lui proseguirà da lì:```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

---

## Il Fortress MCP — navigazione furtiva come strumenti per agenti &nbsp;<sub>Beta</sub>

Il CDP grezzo è per il codice che scrivi. Il **Fortress MCP** è per gli agenti che chiamano **strumenti**: un server [Model Context Protocol](https://modelcontextprotocol.io) che fornisce a Claude, Cursor o qualsiasi client MCP un browser furtivo, così nel momento in cui un fetch viene bloccato, chiama semplicemente uno strumento e ottiene la pagina. **29 strumenti, locali e gratuiti** — `fetch_protected_page`, `extract_page`, `crawl_site`, `recon_site_apis`, `search_web`, `run_browser_task`, `save_profile`, `get_stealth_cdp_endpoint`, e altro.

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/795/8f328e2498b09d7433208c5b4a9002450643537f2ee6b0519ac10420ef581bf3.gif" alt="Stesso sito, stesso prompt: un browser standard viene bloccato da PerimeterX mentre un agente con Fortress MCP restituisce JSON pulito" width="760"/></p>

<sub><i>Esecuzione reale e datata contro <b>stockx.com</b> (PerimeterX). Un browser standard ottiene <b>HTTP 403 — “Accesso negato”</b>; un agente con Fortress MCP restituisce JSON pulito — stesso sito, stesso prompt. Riproducilo dal repository del framework.</i></sub>

### Configuralo in 30 secondi

Due esecutori — scegli uno. `npx` richiede Python nel PATH; `pip` lo installa direttamente:```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 — Impostazioni → Sviluppatore → Modifica Configurazione (claude_desktop_config.json):```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

<sub>Preferisci npx? Usa <code>"command": "npx", "args": ["-y", "tilion-mcp"]</code>. Riavvia Claude e gli strumenti <b>fortress</b> appariranno.</sub>

**Claude Code** (CLI) — una riga:```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) — stesso blocco:```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

Poi basta chiedere al tuo agente — *"prendi il prezzo da questa pagina StockX"* — e chiama autonomamente `fetch_protected_page`.

### Cosa ottiene l'agente

| | strumenti |
|---|---|
| **Ottieni pagine bloccate** | `fetch_protected_page` · `read_page` · `get_page_html` · `search_web` |
| **Dati strutturati** | `extract_page` (consapevole dello schema) · `extract_document` (PDF/DOCX/XLSX) |
| **Siti interi** | `crawl_site` (SPA automatico) · `recon_site_apis` (trova le API JSON private) |
| **Guidare una pagina** | `page_elements` · `click_button` · `fill_field` · `press_key` · `wait_for` · `evaluate_js` |
| **Flussi multi-step** | `run_browser_task` (login, paginazione, scroll infinito, checkout, …) |
| **Cattura / autenticazione** | `screenshot_page` · `save_page` · `download_file` · `save_profile` / `load_profile` |
| **Porta il tuo** | `get_stealth_cdp_endpoint` → un URL CDP per Playwright / Puppeteer / browser-use |

Gli strumenti sono annotati (letture auto-approvate, scritture controllate), **pre-riscaldati** all'avvio (prima chiamata ~100 ms), sicuri per la concorrenza, e protetti da timeout e SSRF. Un endpoint ospitato con **uscita residenziale è in arrivo**.

→ Tabella completa dei 29 strumenti, benchmark e la skill dell'agente: **[`mcp/`](https://github.com/tiliondev/fortress/blob/HEAD/mcp/README.md)**

---

## Perché modificare il motore, non la pagina

L'approccio usuale modifica `navigator.webdriver`, falsifica il vendor WebGL e sovrascrive `navigator.plugins` dallo script. CreepJS e rilevatori simili lo individuano comunque, e il motivo è **strutturale**, non una proprietà in più lasciata scoperta. Una spoof JavaScript è una funzione che sta dove dovrebbe essercene una nativa. I rilevatori mettono da parte il valore restituito e interrogano se ciò che lo restituisce è nativo:

| L'indizio | Perché cattura uno spoof JS |
|---|---|
| `toString` si rivela da solo | Un metodo nativo si stringifica in `function get vendor() { [native code] }`; una sovrascrittura si stringifica nel proprio sorgente, quindi un `.toString()` lo becca. |
| Descrittore e `hasOwnProperty` | `getOwnPropertyDescriptor` espone le proprietà ridefinite, e `hasOwnProperty('toString')` restituisce `true` su una funzione manomessa mentre una nativa restituisce `false`. |
| `failsTypeError` | I getter nativi lanciano uno specifico `TypeError` sul `this` sbagliato; uno shim ingenuo resta in silenzio, e il silenzio è il segnale. |

La riacquisizione del realm è quella che sconfigge ogni patch del mondo principale. Un rilevatore prende un primitivo vergine da un altro realm e lo rivolge contro la tua funzione:```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.

Il tuo patch del mondo principale vive in un realm diverso da quell'iframe. La stessa trappola scatta da un Web Worker, un thread in cui il tuo shim del thread principale viene eseguito accanto piuttosto che all'interno.

Fortress non ha un tale livello. Il getter per navigator.vendor è il getter C++: riporta [native code] perché è codice nativo, identico in ogni realm. Camoufox lo spiega bene: "non c'è hijacking JavaScript da rilevare." Fortress applica la stessa idea a V8 e Blink al posto di Gecko.

I tre livelli del rilevamento bot, e dove si colloca Fortress

Gli anti-bot moderni (Cloudflare, DataDome, Kasada, HUMAN, Akamai) leggono tre superfici strutturalmente diverse, in tre posti separati. Un singolo strumento raramente risolve tutti e tre:

Fortress è il motore di Livello-C, costruito per essere guidato in modo che anche A e B siano validi. Il binary da solo lascia aperto il canale CDP. Quella parte è a carico del livello di controllo, e fingere il contrario è come ti fanno beccare.

Confronto con Fortress

Fortress si basa su lavori precedenti reali: fingerprint-chromium, ChromiumFish e CloakBrowser sono arrivati prima, e i fornitori commerciali (Multilogin, Kameleo, GoLogin, AdsPower, Browserbase, Surfsky) ricompilano Chromium a porte chiuse. La maggior parte di quel lavoro rimane chiuso: i fork a pagamento ti danno un binary e ti chiedono di fidarti, e i fornitori tengono le loro patch internamente.

Fortress va nella direzione opposta, perché un motore stealth rimane utile solo quando le persone che ci fanno affidamento possono vedere come funziona. Ogni correzione di superficie vive in patches/ come una piccola diff monouso che puoi leggere in un minuto, e l'intero motore si ricostruisce dal sorgente con un singolo script. Quando un rilevatore trova un nuovo segnale, tracci la correzione, la patch e la invii indietro. Questo ciclo di feedback è il punto, e funziona solo finché il motore rimane abbastanza aperto da essere letto, esteso e ricostruito.

Prova: risultati dei rilevatori live

Riproduci qualsiasi riga con tools/gauntlet.py --bundle ./tilion-fortress. Verificato contro rilevatori live; riesecuzione datata in docs/GAUNTLET_RESULTS.md.

Prova: screenshot reali, non editati

BrowserScan	CreepJS	Cloudflare

Configura la persona

Il binary trasporta zero stringhe di marca; il launcher applica una persona predefinita coerente di Windows. Sostituisci qualsiasi superficie con i flag --uxr-*, o imposta TILION_NO_DEFAULTS=1 per un avvio senza configurazioni.``` --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` | Salta la persona predefinita (avvio minimo) |
| `TILION_TZ` / `TILION_LANG` | Sovrascrittura rapida di fuso orario / lingua |

> [!NOTE]
> **La persona viaggia oggi sulla riga di comando.** Gli switch `--uxr-*` sono leggibili a livello mondiale tramite `/proc/<pid>/cmdline`, quindi una persona per avvio e visibile ad altri processi sull'host. Il runtime `MaskConfig` arriva dopo: consegna la persona tramite IPC e rimuove il limite di un processo per sessione (vedi [prossime novità](#prossime-novita)).

---

## Funziona con il tuo stack

Fortress espone CDP grezzo su `:9222`, quindi si integra con qualsiasi strumento che parli Playwright, Puppeteer o CDP.

| Framework | Collegamento |
|---|---|
| [**browser-use**](https://github.com/browser-use/browser-use) (~70k stelle) | `cdp_url="http://localhost:9222"` |
| [**Crawl4AI**](https://github.com/unclecode/crawl4ai) (~58k stelle) | Endpoint CDP |
| [**Stagehand**](https://github.com/browserbase/stagehand) (~21k stelle) | `connectOverCDP` |
| [**LangChain**](https://github.com/langchain-ai/langchain) toolkit Playwright | Playwright CDP |
| **Playwright / Puppeteer** (Python e 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

Build e verifica

Riproduci dal sorgente```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

Risultato: `out/Fortress/chrome`. Il fork consiste in 34 piccole patch a superficie singola (`patches/`), quindi la maggior parte si applicano senza problemi sugli aggiornamenti upstream; il gauntlet blocca poi il rilascio in caso di regressione.

| Piattaforma | Stato |
|---|---|
| Linux x64 (native) · **Windows x64 (native)** · qualsiasi OS via Docker | <img src="https://raw.githubusercontent.com/tiliondev/fortress/HEAD/docs/assets/icons/check.svg" width="15" alt="yes"> **disponibile** |
| Installer con firma digitale · macOS `.app` · `linux/arm64` | in corso |

### Verifica che sia davvero il nostro

Fortress viene distribuito attraverso quattro canali ufficiali. Considera qualsiasi altra fonte come non attendibile:

| | Fonte ufficiale |
|---|---|
| **Sorgente** | [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) |

**Verifica un download.** Ogni release include `SHA256SUMS`, e gli SDK `pip`/`npm` lo eseguono per te durante l'installazione:```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 l'immagine Docker tramite digest (non solo il 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

**O non fidarti di nulla e ricostruiscilo.** L'intero fork è composto da 34 patch leggibili in `patches/`; `build/build.sh` riproduce il binario dal sorgente Chromium, così puoi confrontare ciò che hai costruito con ciò che distribuiamo.

---

## Riferimenti

<details><summary><b>Risoluzione dei problemi</b></summary>

<br/>

**Ancora bloccato su Cloudflare, DataDome o Kasada.** La maggior parte delle volte è il tuo **IP**, non la tua impronta digitale: un intervallo di datacenter viene segnalato prima che qualsiasi script della pagina venga eseguito. Instrada l'uscita attraverso proxy residenziali o mobili e riprova; se si risolve, l'impronta era corretta.

**L'impronta sembra errata su un host Linux.** La persona predefinita è Windows, ma la forma TLS e alcuni segnali rivolti al sistema operativo seguono la macchina sottostante. Abbina la persona al sistema operativo di uscita, o imposta i flag `--uxr-*` pertinenti in modo che la storia del sistema operativo concordi con da dove esce il traffico.

**macOS tira un'immagine Docker.** I binari nativi Linux + Windows sono distribuiti oggi; macOS esegue ancora Fortress tramite l'immagine Docker ufficiale (`tilion/fortress`). Installa Docker Desktop, o esegui su Linux/Windows x64 per il binario nativo.

**La persona appare in `/proc/<pid>/cmdline`.** I flag `--uxr-*` sono leggibili da altri processi sull'host, una persona per avvio. Fino a quando `MaskConfig` runtime non sarà disponibile, tieni una persona per processo ed evita di condividere l'host con codice non fidato.

**Un rilevatore segnala qualcosa che il gauntlet supera.** Il rilevamento si evolve. Conferma di essere sul rebase Chromium attuale, poi apri un ticket con la pagina di test. Quella pagina diventa la prossima patch.

</details>

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

<br/>

**È legale?** Fortress è un progetto di ingegneria browser per automazione, test e scraping legittimi di dati pubblicamente disponibili. Rispetta i ToS di ogni sito e la legge nella tua giurisdizione.

**È davvero gratuito?** Sì. BSD-3, completamente aperto e auto-ospitabile. La serie di patch è pubblicata, quindi puoi costruire il motore attuale dal sorgente da solo.

**Perché non usare semplicemente puppeteer-stealth o undetected-chromedriver?** Patchano il layer JS/CDP *dopo* che la pagina può ispezionare il browser, quindi si rivelano tramite `toString` e riacquisizione del realm. Fortress sposta il falso in C++, dove la pagina trova codice nativo. (Vedi "Perché patchare il motore, non la pagina.")

**In cosa è diverso da Camoufox?** Stessa idea di intercettazione C++. Camoufox fork di Firefox (~3% del traffico, un'anomalia persistente) mentre Fortress fork di Chromium e V8 (il motore di maggioranza), quindi un user-agent Chrome è coerente per costruzione.

**Supererà tutto per sempre?** No. Il rilevamento continua a muoversi, quindi distribuiamo un gauntlet datato e riproducibile e un rebase Chromium mensile; puoi sempre vedere esattamente cosa supera oggi.

</details>

<details><summary><b>Roadmap</b></summary>

<br/>

- [ ] Configurazione JSON runtime in un `MaskConfig` C++ (un binario, molte impronte coerenti, nulla sulla riga di comando)
- [ ] Server MCP first-party più SDK Puppeteer / raw-CDP (sostituzione drop-in per agenti AI)
- [ ] `.exe` Windows con firma codice e `.app` macOS
- [ ] Immagine Docker `linux/arm64`
- [ ] Migrare `patches/` a override `chromium_src/` stile Brave
- [ ] Righe di benchmark pubblicate reCAPTCHA v3 / DataDome / Kasada (datate, riproducibili)

</details>

<details><summary><b>Struttura del repository</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

Contribuire

Trovato un vettore di rilevamento o una falla che ci è sfuggita? Apri un ticket con una pagina di test riproducibile. Una pagina che segnala in modo affidabile Fortress è la cosa più preziosa che puoi inviare. Diventa la prossima patch. Due regole interne: ogni affermazione di capacità è accompagnata da un comando che la riproduce, e ogni limite è documentato. La parola "indetectabile" resta fuori dal repository.

Licenza

BSD-3-Clause per le patch e gli strumenti di Fortress (in linea con Chromium). Chromium e i font inclusi mantengono le proprie licenze; consulta LICENSE e NOTICE. La serie di patch è pubblicata, così puoi verificare e ricostruire il motore da solo.

Cosa c'è dopo

[!IMPORTANT] v2: Profili di runtime MaskConfig. Un grafo di profili basato su seed e consegnato via IPC che alimenta un singleton MaskConfig C++ a livello di processo: migliaia di impronte digitali invarianti per coerenza da un singolo binario, isolamento dell'identità per BrowserContext, e impronta zero sulla riga di comando. Il resto è sulla roadmap.

Rimanere aggiornati

Il rilevamento si evolve, quindi un motore stealth è valido solo quanto il suo ultimo rebase. Fortress segue l'ultimo Chromium mensilmente, riesegue l'intera batteria di test e rilascia una patch ogni volta che un rilevatore trova un nuovo indicatore, in modo che ciò che esegui continui a corrispondere a ciò che sembra una vera installazione di Chrome. Segui i rilasci per seguire il lavoro su v2 MaskConfig, o metti una stella al repository se ti è utile.

Stealth che puoi leggere, ricostruire ed eseguire da solo.

A: artefatti driver/binary	Variabili `cdc_` di ChromeDriver, superficie del protocollo WebDriver	Guida con CDP grezzo, salta chromedriver	costruito per essere guidato in questo modo
B: Effetti collaterali CDP	`Runtime.enable` perde tramite sourceURL + impronte degli script di inizializzazione, per quanto pulito sia il binary	Il livello di controllo / CDP: trattenere `Runtime.enable`, usare `Runtime.addBinding` + mondi isolati	nessuna perdita (verificato)
C: Superficie delle impronte digitali	canvas, WebGL, audio, font, navigator, su frame principale, iframe, worker	Il motore (C++), perché gli override JS si rivelano da soli	questo è Fortress

Livello di spoofing	nessuno	Iniezione JS	Patch CDP/config	Motore C++	Motore C++	Motore C++
`toString` restituisce `[native code]`	n/d		n/d
Sopravvive alla riacquisizione del realm (iframe/worker)
Nessuna perdita di `Runtime.enable`
Motore = Chrome / V8 (maggioranza del traffico)				Firefox
Forma TLS Chromium coerente				Firefox
Motore completamente open-source					ultima major a pagamento
Serie di patch pubblicate e verificabili	n/d	n/d	n/d		solo binary
Build riproducibile dal codice sorgente	n/d	n/d	n/d
Dichiara i propri limiti	n/d	n/d	n/d

CreepJS	headless segnalato	0% headless · 0% stealth, segnali worker coerenti
bot.sannysoft.com	righe rosse	0 falliti · WebDriver Advanced superato · WebGL = NVIDIA RTX 3060 / ANGLE D3D11
browserscan.net	bot rilevato	“Nessun bot rilevato, potrebbe essere un umano”
rebrowser bot-detector	Perdita `Runtime.enable`	nessuna perdita · `webdriver=false` · script di init puliti (CDP grezzo)
Cloudflare Turnstile	bloccato	bypassato: un clic umano ha superato una challenge live (headed, IP datacenter)

fortress

Più Popolari

34

0%

`[native code]`

BSD-3

Parità con codice nativo

CDP drop-in

Supera la gauntlet

Patch verificabili

Coerente per costruzione

Persona regolabile