Eine Browser-Engine, um sie alle zu beherrschen

Stealth Chromium-Engine

Fortress ist eine Stealth-Chromium-Engine, die verhindert, dass Ihre Scraper und Browser-Agenten blockiert werden – mit nur einer Zeile Codeänderung. Bot-Erkennungen markieren Automatisierung durch das Auslesen des Browser-Fingerprints; Fortress korrigiert diesen Fingerprint im Chromium-C++, sodass der Browser wie eine normale Chrome-Installation erscheint. Scraper schließen ihre Läufe ab, Agenten erreichen die ihnen zugewiesenen Seiten, und CreepJS, Sannysoft, BrowserScan sowie Live-Cloudflare-Turnstile lesen es alle als menschlich. Richten Sie Ihren bestehenden Playwright oder Puppeteer über CDP auf Fortress aus, und sonst ändert sich nichts in Ihrem Code.

_{Blink · V8 · BoringSSL in-tree gepatcht · ANGLE / D3D11-unterstütztes WebGL · JA3/JA4-kohärentes TLS · monatliches Upstream-Rebase · reproduzierbare, gauntlet-geprüfte Versionen}

Fortress meistert eine Live-Cloudflare-Challenge und besteht dann Sannysoft und BrowserScan

_{Unbearbeitete Aufnahme der Fortress-Binärdatei in einem echten Fenster: Sie meistert eine Live-Cloudflare-Challenge, färbt bot.sannysoft.com ganz grün und zeigt bei BrowserScan „Normal“ an. Reproduzierbar mit tools/gauntlet.py.}

🆕 Was gibt's Neues — 151.0.7908.0 · Engine-Refresh

Veröffentlicht. Pro-Start kohärente Personas, gehärtet.

Pro-Locale-Tastatur (QWERTY / QWERTZ / AZERTY) · pro-Persona-Mediengeräte · ein vollständiger Delivery-Parity-Kohärenzdurchlauf.
Plattform ↔ GPU ↔ Zeitzone ↔ Sprache ↔ Stimmen ↔ Tastatur bewegen sich als ein kohärentes echtes Gerät — bei jedem Start, aus einer einzigen Binärdatei.
Native-Code-Parität (toString() bleibt [native code]), realm-invariant (Haupt / Worker / Iframe) — Kohärenz in den Browser kompiliert, nicht in JavaScript gepatcht.```bash pip install -U tilion-fortress # or: docker run --rm -p 9222:9222 tilion/fortress:latest

**[→ vollständige Versionshinweise](https://github.com/tiliondev/fortress/releases/tag/v151.0.7908.0)**


## Inhaltsverzeichnis

| | |
|---|---|
| **[Was es ist](#what-it-is)** · **[Schnellstart](#quick-start)** | Was es ist, Installation, erstes Skript, KI-Agenten-Setup |
| **[Das Fortress MCP](#the-fortress-mcp--stealth-browsing-as-agent-tools)** | 29 Stealth-Browser-Tools für KI-Agenten (Beta) |
| **[Warum die Engine patchen, nicht die Seite](#why-patch-the-engine-not-the-page)** | Die These des selbstenthüllenden JavaScripts + die drei Erkennungsschichten |
| **[Wie Fortress im Vergleich abschneidet](#how-fortress-compares)** | vs. puppeteer-stealth · Camoufox · CloakBrowser · geschlossene Anbieter |
| **[Beweis: Live-Detector-Ergebnisse](#proof-live-detector-results)** | CreepJS / Sannysoft / BrowserScan / Cloudflare, mit Screenshots |
| **[Persona konfigurieren](#configure-the-persona)** | die `--uxr-*`-Fingerabdruckoberfläche |
| **[Funktioniert mit Ihrem Stack](#works-with-your-stack)** | browser-use · Crawl4AI · Stagehand · LangChain |
| **[Erstellen und verifizieren](#build--verify)** | Aus dem Quellcode reproduzieren, Herkunft verifizieren |
| **[Referenz](#reference)** | Fehlerbehebung · FAQ · Roadmap · Repo-Struktur |

---

## Was es ist

Fortress ist ein Chromium-Fork, der den Browser-Fingerabdruck von innerhalb der Engine fälscht. Die Oberflächen, die Bot-Erkennungswerkzeuge lesen (Canvas, WebGL, Audio, Schriftarten, Navigator und etwa dreißig weitere) werden in Chromiums **C++** korrigiert, ohne dass eine JavaScript-Patchschicht darüber liegt, die eine Seite abfangen könnte.

Es wird als gewöhnliches Browser-Binärpaket ausgeliefert, das einen CDP-Endpunkt bereitstellt. Richten Sie Playwright, Puppeteer oder einen beliebigen CDP-Client darauf und Ihre vorhandene Automatisierung läuft unverändert.

Ein JavaScript-Stealth-Patch hinterlässt eine zusätzliche Schicht, die die Seite finden kann: `.toString()` zeigt die Quelle des Overrides, und das erneute Abrufen derselben Primitive aus einem iframe oder Worker umgeht sie. Fortress korrigiert stattdessen die Oberfläche in der Engine, sodass `navigator.vendor` auf den echten C++-Getter auflöst, `[native code]` meldet und aus jedem Realm gleich gelesen wird. Eine Seite, die sich selbst inspiziert, sieht Stock-Chromium. Deshalb kommt Ihre Automatisierung durch, wo sie zuvor markiert wurde, und verbleibende Blockierungen lassen sich auf Ihre Proxys und Ihr Verhalten zurückführen, nicht auf den Browser. [Warum die Engine patchen, nicht die Seite](#why-patch-the-engine-not-the-page) behandelt die Erkennungsmechanismen vollständig.```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();

Die 12-Sekunden-Tour

Fortress in 12 Sekunden: besteht CreepJS, Sannysoft, BrowserScan und rebrowser, scraped echte Websites und umgeht Akamai auf aa.com, lowes.com, macys.com und kohls.com.

_{Ein Durchlauf, alles echte Aufnahmen: besteht CreepJS / Sannysoft / BrowserScan / rebrowser → scraped strukturierte Daten über CDP → umgeht Akamai auf aa.com · lowes · macys · kohls (gleiche Residential-IP).}

Echtes Scraping, vollständig headless

_{Unbearbeitete Aufnahmen der Fortress-Engine, gesteuert über CDP. Keine Stealth-Plugins, keine JS-Patches: Der Fingerabdruck wird im Binär korrigiert. Reproduzieren Sie diese mit examples/scrape_demos.py.}

Fortress extrahiert books.toscrape.com in typisierte JSON-Datensätze live über CDP

_{Strukturierte Extraktion: Datensätze werden beim Lesen jedes Elements in typisiertes JSON aufgebaut.}

Umgeht echtes Akamai — vorher / nachher

Vorher: Ein Standard-Browser wird von Akamai auf aa.com mit Zugriff verweigert blockiert. Nachher: Fortress lädt die echte Seite und der Sensor von Akamai akzeptiert sie.

_{Gleiche Residential-IP, gleiche Website (aa.com · Akamai Bot Manager). Ein Standard-/headless Browser erhält Access Denied (Reference #); Fortress lädt die echte Seite und Akamai stellt sein _abck-Sensor-Cookie aus — der Bot Manager akzeptiert es als echten Browser. Die Variable ist der Fingerprint, nicht die IP.}

Schnellstart```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]
> Das SDK enthält den kompilierten Build **plus `patches/`**, sodass Sie die Engine selbst neu bauen und jede Oberflächenkorrektur gegen die Quelle überprüfen können. Downloads werden automatisch mittels SHA-256 gegen die `SHA256SUMS` der Veröffentlichung verifiziert.

### Versionen

Fortress wird auf **zwei Chromium-Basen** ausgeliefert — wählen Sie Ihren Kompromiss zwischen Anpassung und Aktualität:

| Kanal | Chromium | Wann verwenden |
|---|---|---|
| **`stable`** *(Standard)* | **149** | Empfohlen — entspricht der Chrome-Version, die die Masse der echten Nutzer verwendet, und fügt sich daher am besten ein |
| **`latest`** | **151** | Neueste Engine (meldet eine Version, die etwas vor stable liegt) |```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

Native Binärdateien: Linux x64 (beide Versionen) + Windows x64 (151); Windows-149 und macOS laufen über das Docker-Image.

Für deinen KI-Agenten

Fortress ist der Browser, den dein Agent steuert: rohes CDP auf :9222, keine Stealth-Plugins erforderlich. Es gibt zwei Möglichkeiten.

Option 1: Öffne es vorbereitet in einem Chat-Assistenten. Ein Klick; es liest unsere AGENTS.md und führt dich durch die gesamte Einrichtung:

Option 2: Für Agent kopieren (alles, in die Zwischenablage). Klicke auf das Kopiersymbol oben rechts in der Box unten. Es legt den gesamten Setup-Kontext in deine Zwischenablage: was es ist, Installation, Verbindung, Persona und Regeln – alles aus AGENTS.md komprimiert. Füge es in Cursor, Claude Code, Copilot, ChatGPT oder einen beliebigen Agenten ein, und er übernimmt von dort:```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 — Stealth-Browsing als Agenten-Tools &nbsp;<sub>Beta</sub>

Rohes CDP ist für Code, den Sie schreiben. Das **Fortress MCP** ist für Agenten, die **Tools** aufrufen: ein [Model Context Protocol](https://modelcontextprotocol.io)-Server, der Claude, Cursor oder jedem MCP-Client einen Stealth-Browser bereitstellt, sodass der Agent, sobald ein Abruf blockiert wird, einfach ein Tool aufruft und die Seite erhält. **29 Tools, lokal und kostenlos** — `fetch_protected_page`, `extract_page`, `crawl_site`, `recon_site_apis`, `search_web`, `run_browser_task`, `save_profile`, `get_stealth_cdp_endpoint` und mehr.

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/795/8f328e2498b09d7433208c5b4a9002450643537f2ee6b0519ac10420ef581bf3.gif" alt="Gleiche Seite, gleiche Aufforderung: Ein Vanilla-Browser wird von PerimeterX blockiert, während ein Agent mit dem Fortress MCP sauberes JSON zurückgibt" width="760"/></p>

<sub><i>Echter, datierter Testlauf gegen <b>stockx.com</b> (PerimeterX). Ein Standard-Browser erhält <b>HTTP 403 — „Zugriff verweigert“</b>; ein Agent mit dem Fortress MCP gibt sauberes JSON zurück – gleiche Seite, gleiche Aufforderung. Reproduzieren Sie es aus dem Framework-Repository.</i></sub>

### Einrichtung in 30 Sekunden

Zwei Runner – wählen Sie einen. `npx` benötigt Python im PATH; `pip` installiert es direkt:```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 — Einstellungen → Entwickler → Konfiguration bearbeiten (claude_desktop_config.json):```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

<sub>Bevorzugen Sie npx? Verwenden Sie <code>"command": "npx", "args": ["-y", "tilion-mcp"]</code>. Starten Sie Claude neu, und die <b>fortress</b> Werkzeuge erscheinen.</sub>

**Claude Code** (CLI) — eine Zeile:```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) — gleicher Block:```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

Fragen Sie einfach Ihren Agenten — *„Holen Sie den Preis von dieser StockX-Seite“* — und er ruft selbstständig `fetch_protected_page` auf.

### Was der Agent bekommt

| | Werkzeuge |
|---|---|
| **Gesperrte Seiten abrufen** | `fetch_protected_page` · `read_page` · `get_page_html` · `search_web` |
| **Strukturierte Daten** | `extract_page` (schema-bewusst) · `extract_document` (PDF/DOCX/XLSX) |
| **Gesamte Websites** | `crawl_site` (auto-SPA) · `recon_site_apis` (finde die private JSON-API) |
| **Eine Seite steuern** | `page_elements` · `click_button` · `fill_field` · `press_key` · `wait_for` · `evaluate_js` |
| **Mehrstufige Abläufe** | `run_browser_task` (Anmeldung, Paginierung, unendliches Scrollen, Checkout, …) |
| **Erfassung / Authentifizierung** | `screenshot_page` · `save_page` · `download_file` · `save_profile` / `load_profile` |
| **Eigenes mitbringen** | `get_stealth_cdp_endpoint` → eine CDP-URL für Playwright / Puppeteer / browser-use |

Werkzeuge sind annotiert (Lesevorgänge automatisch genehmigt, Schreibvorgänge abgeschirmt), werden beim Start **vorgewärmt** (~100 ms erster Aufruf), sind nebenläufigkeitssicher und vor Timeouts und SSRF geschützt. Ein gehosteter Endpunkt mit **Residential-Egress-Ausgang** kommt bald.

→ Vollständige Tabelle mit 29 Werkzeugen, Benchmarks und die Agent-Fähigkeit: **[`mcp/`](https://github.com/tiliondev/fortress/blob/HEAD/mcp/README.md)**

---

## Warum die Engine patchen, nicht die Seite

Der übliche Ansatz patcht `navigator.webdriver`, fälscht den WebGL-Anbieter und überschreibt `navigator.plugins` per Skript. CreepJS und ähnliche Detektoren erkennen es trotzdem, und der Grund ist **strukturell**, nicht eine weitere unentdeckte Eigenschaft. Ein JavaScript-Spoof ist eine Funktion, die dort steht, wo eine native hingehört. Detektoren legen den zurückgegebenen Wert beiseite und fragen ab, ob das zurückgebende Ding nativ ist:

| Das verräterische Merkmal | Warum es einen JS-Spoof erkennt |
|---|---|
| `toString`-Selbstenthüllung | Eine native Methode wird zu `function get vendor() { [native code] }` stringifiziert; eine Überschreibung wird zu ihrem eigenen Quelltext stringifiziert, also fängt ein `.toString()` sie. |
| Deskriptor und `hasOwnProperty` | `getOwnPropertyDescriptor` legt neu definierte Eigenschaften offen, und `hasOwnProperty('toString')` gibt bei einer manipulierten Funktion `true` zurück, während eine native `false` zurückgibt. |
| `failsTypeError` | Native Getter werfen einen spezifischen `TypeError` beim falschen `this`; ein naiver Shim bleibt still, und die Stille ist das Signal. |

Der Realm-Neuerwerb ist derjenige, der jeden Main-World-Patch besiegt. Ein Detektor schnappt sich ein unberührtes Primitiv aus einem anderen Realm und wendet es auf Ihre Funktion an:```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.

Ihr Hauptwelt-Patch lebt in einem anderen Bereich als dieses Iframe. Die gleiche Falle wird von einem Web Worker ausgelöst, einem Thread, den Ihr Hauptthread-Shim neben statt in ausführt.

Fortress hat keine solche Schicht. Der Getter für navigator.vendor ist der C++-Getter: er meldet [native code], weil es nativer Code ist, in jedem Bereich identisch. Camoufox drückt es gut aus: "Es gibt kein JavaScript-Hijacking, das erkannt werden kann." Fortress wendet die gleiche Idee auf V8 und Blink anstelle von Gecko an.

Die drei Ebenen der Bot-Erkennung und wo Fortress hineinpasst

Moderne Anti-Bots (Cloudflare, DataDome, Kasada, HUMAN, Akamai) lesen drei strukturell unterschiedliche Oberflächen an drei verschiedenen Stellen. Ein Tool repariert selten alle drei:

Fortress ist die Layer-C-Engine, die so konzipiert ist, dass auch A und B halten. Die Binärdatei allein lässt den CDP-Kanal offen. Dieser Teil liegt auf der Steuerebene, und etwas anderes vorzutäuschen ist der Weg, wie man erwischt wird.

Wie Fortress abschneidet

Fortress baut auf echter Vorarbeit auf: fingerprint-chromium, ChromiumFish und CloakBrowser kamen zuerst, und kommerzielle Anbieter (Multilogin, Kameleo, GoLogin, AdsPower, Browserbase, Surfsky) kompilieren Chromium hinter geschlossenen Türen neu. Der Großteil dieser Arbeit bleibt geschlossen: die kostenpflichtigen Forks geben eine Binärdatei und bitten um Vertrauen, und die Anbieter behalten ihre Patches im Haus.

Fortress geht den anderen Weg, weil eine Tarn-Engine nur dann nützlich bleibt, wenn die Leute, die darauf angewiesen sind, sehen können, wie sie funktioniert. Jede Oberflächenkorrektur lebt in patches/ als kleiner, zweckgebundener Diff, den man in einer Minute lesen kann, und die gesamte Engine wird mit einem Skript aus dem Quellcode neu erstellt. Wenn ein Detektor einen neuen Hinweis findet, verfolgen Sie die Behebung, patchen sie und senden sie zurück. Diese Rückkopplungsschleife ist der Punkt, und sie funktioniert nur, solange die Engine offen genug bleibt, um gelesen, erweitert und neu erstellt zu werden.

Beweise: Live-Detektor-Ergebnisse

Reproduzieren Sie jede Zeile mit tools/gauntlet.py --bundle ./tilion-fortress. Verifiziert gegen Live-Detektoren; erneute Ausführung datiert in docs/GAUNTLET_RESULTS.md.

Beweise: echte, unbearbeitete Screenshots

BrowserScan	CreepJS	Cloudflare

Die Persona konfigurieren

Die Binärdatei führt keine Markenzeichen; der Launcher wendet eine kohärente Standard-Windows-Persona an. Überschreiben Sie jede Oberfläche mit --uxr-*-Schaltern oder setzen Sie TILION_NO_DEFAULTS=1 für einen nackten Start.``` --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

| Env var | Zweck |
|---|---|
| `TILION_NO_DEFAULTS=1` | Die Standard-Persona überspringen (nackter Start) |
| `TILION_TZ` / `TILION_LANG` | Schnelle Zeitzonen-/Sprachüberschreibung |

> [!NOTE]
> **Die Persona reitet derzeit auf der Kommandozeile.** Die `--uxr-*`-Schalter sind über `/proc/<pid>/cmdline` weltlesbar, also eine Persona pro Start und für andere Prozesse auf dem Host sichtbar. Die `MaskConfig`-Laufzeitumgebung kommt als Nächstes: Sie liefert die Persona über IPC und hebt die Beschränkung auf eine Persona pro Prozess auf (siehe [Was kommt als Nächstes](#whats-next)).

---

## Funktioniert mit Ihrem Stack

Fortress stellt rohes CDP auf `:9222` bereit, sodass es unter allem läuft, was Playwright, Puppeteer oder CDP spricht.

| Framework | Verbindung über |
|---|---|
| [**browser-use**](https://github.com/browser-use/browser-use) (~70k Sterne) | `cdp_url="http://localhost:9222"` |
| [**Crawl4AI**](https://github.com/unclecode/crawl4ai) (~58k Sterne) | CDP-Endpunkt |
| [**Stagehand**](https://github.com/browserbase/stagehand) (~21k Sterne) | `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

Erstellen und verifizieren

Aus dem Quellcode reproduzieren```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

Ausgabe: `out/Fortress/chrome`. Der Fork besteht aus 34 kleinen Einzelflächen-Patches (`patches/`), die sich meist problemlos auf neue Upstream-Releases anwenden lassen; der Gauntlet blockiert dann die Freigabe bei Regressionen.

| Plattform | Status |
|---|---|
| Linux x64 (native) · **Windows x64 (native)** · beliebiges OS via Docker | <img src="https://raw.githubusercontent.com/tiliondev/fortress/HEAD/docs/assets/icons/check.svg" width="15" alt="yes"> **ausgeliefert** |
| Codesignierte Installer · macOS `.app` · `linux/arm64` | in Bearbeitung |

### Stelle sicher, dass es wirklich unseres ist

Fortress wird über vier offizielle Kanäle ausgeliefert. Behandle alles andere als nicht vertrauenswürdig:

| | Offizielle Quelle |
|---|---|
| **Quelle** | [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) |

**Überprüfe einen Download.** Jede Version liefert `SHA256SUMS` mit, und die `pip`/`npm` SDKs führen diese Überprüfung bei der Installation für dich durch:```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

Überprüfen Sie das Docker-Image anhand des Digests (nicht nur des Tags):```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

**Oder vertraue nichts und baue es neu auf.** Der gesamte Fork besteht aus 34 lesbaren Patches in `patches/`; `build/build.sh` reproduziert das Binärprogramm aus dem Chromium-Quellcode, sodass du das von dir Gebaute mit dem von uns Ausgelieferten vergleichen kannst.

---

## Referenz

<details><summary><b>Fehlerbehebung</b></summary>

<br/>

**Immer noch von Cloudflare, DataDome oder Kasada blockiert.** Meistens liegt es an deiner **IP**, nicht an deinem Fingerabdruck: Ein Rechenzentrumsbereich wird markiert, bevor ein Seiten-Skript läuft. Leite den ausgehenden Verkehr über Residential- oder Mobilfunk-Proxys um und versuche es erneut; wenn es klappt, war der Fingerabdruck in Ordnung.

**Der Fingerabdruck sieht auf einem Linux-Host seltsam aus.** Die Standard-Persona ist Windows, aber die TLS-Form und einige betriebssystemspezifische Signale folgen der darunterliegenden Maschine. Passe die Persona an dein ausgehendes Betriebssystem an oder setze die entsprechenden `--uxr-*` Flags, sodass die Betriebssystem-Geschichte mit dem Ort übereinstimmt, von dem der Datenverkehr ausgeht.

**macOS zieht ein Docker-Image.** Native Linux- + Windows-Binärprogramme werden heute ausgeliefert; macOS führt Fortress weiterhin über das offizielle Docker-Image (`tilion/fortress`) aus. Installiere Docker Desktop oder führe es auf Linux/Windows x64 für das native Binärprogramm aus.

**Die Persona wird in `/proc/<pid>/cmdline` angezeigt.** Die `--uxr-*` Flags sind für andere Prozesse auf dem Host lesbar, eine Persona pro Start. Bis zur Einführung des Laufzeit-`MaskConfig` halte eine Persona pro Prozess und vermeide es, den Host mit nicht vertrauenswürdigem Code zu teilen.

**Ein Detektor markiert etwas, das der Hindernislauf besteht.** Die Erkennung bewegt sich. Stelle sicher, dass du auf dem aktuellen Chromium-Rebase bist, und eröffne dann ein Issue mit der Testseite. Diese Seite wird zum nächsten Patch.

</details>

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

<br/>

**Ist das legal?** Fortress ist ein Browser-Engineering-Projekt für legitime Automatisierung, Tests und Scraping öffentlich verfügbarer Daten. Respektiere die ToS jeder Website und die Gesetze in deinem Rechtsraum.

**Ist es wirklich kostenlos?** Ja. BSD-3, vollständig offen und selbst hostbar. Die Patch-Serie ist veröffentlicht, sodass du die aktuelle Engine selbst aus dem Quellcode bauen kannst.

**Warum nicht einfach puppeteer-stealth oder undetected-chromedriver verwenden?** Sie patchen die JS/CDP-Ebene *nachdem* die Seite den Browser inspizieren kann, sodass sie sich selbst durch `toString` und Realm-Neuakquisition offenbaren. Fortress verschiebt den Spoof in C++, wo die Seite nativen Code vorfindet. (Siehe "Warum die Engine patchen, nicht die Seite.")

**Wie unterscheidet sich das von Camoufox?** Gleiche C++-Abfang-Idee. Camoufox forkt Firefox (~3% des Datenverkehrs, eine dauerhafte Anomalie), während Fortress Chromium und V8 (die Mehrheits-Engine) forkt, sodass ein Chrome User-Agent von Natur aus kohärent ist.

**Wird es für immer alles bestehen?** Nein. Die Erkennung entwickelt sich weiter, daher liefern wir einen datierten, reproduzierbaren Hindernislauf und einen monatlichen Chromium-Rebase; du kannst immer genau sehen, was heute besteht.

</details>

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

<br/>

- [ ] Laufzeit-JSON-Konfiguration in ein C++ `MaskConfig` (ein Binärprogramm, viele kohärente Fingerabdrücke, nichts in der Befehlszeile)
- [ ] Eigener MCP-Server plus Puppeteer / raw-CDP SDKs (Drop-in für KI-Agenten)
- [ ] Code-signierte Windows `.exe` und macOS `.app`
- [ ] `linux/arm64` Docker-Image
- [ ] Migriere `patches/` zu Brave-ähnlichen `chromium_src/`-Überschreibungen
- [ ] Veröffentlichte reCAPTCHA v3 / DataDome / Kasada Benchmark-Zeilen (datiert, reproduzierbar)

</details>

<details><summary><b>Repo-Layout</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

Mitwirken

Hast du einen Erkennungsvektor oder ein Leck gefunden, das wir übersehen haben? Eröffne ein Issue mit einer reproduzierbaren Testseite. Eine Seite, die Fortress zuverlässig erkennt, ist das Wertvollste, was du senden kannst. Sie wird zum nächsten Patch. Zwei Hausregeln: Jede Fähigkeitsbehauptung wird mit einem Befehl ausgeliefert, der sie reproduziert, und jede Einschränkung wird festgehalten. Das Wort „undetectable“ bleibt aus dem Repository.

Lizenz

BSD-3-Clause für die Fortress-Patches und -Werkzeuge (entsprechend Chromium). Chromium und die gebündelten Schriftarten behalten ihre eigenen Lizenzen; siehe LICENSE und NOTICE. Die Patch-Serie ist veröffentlicht, sodass du die Engine selbst prüfen und neu erstellen kannst.

Was kommt als Nächstes

[!IMPORTANT] v2: MaskConfig-Laufzeitpersonas. Ein über IPC gelieferter, seed-gesteuerter Persona-Graph, der einen prozessglobalen C++-MaskConfig-Singleton speist: Tausende kohärenzinvariante Fingerabdrücke aus einer einzigen Binärdatei, Identitätsisolierung pro BrowserContext und keine Befehlszeilen-Fußspur. Der Rest steht auf der Roadmap.

Aktuell bleiben

Die Erkennung entwickelt sich weiter, daher ist eine Tarn-Engine nur so gut wie ihr letzter Rebase. Fortress verfolgt monatlich das neueste Chromium, durchläuft das gesamte Testprogramm erneut und veröffentlicht einen Patch, sobald ein Detektor einen neuen Hinweis findet. So bleibt das, was du ausführst, immer dem nahe, wie eine echte Chrome-Installation aussieht. Beobachte die Veröffentlichungen, um die Arbeit an v2 MaskConfig zu verfolgen, oder markiere das Repository mit einem Stern, falls es für dich nützlich ist.

Tarnung, die du selbst lesen, neu erstellen und ausführen kannst.

A: Treiber / binäre Artefakte	`cdc_` ChromeDriver-Variablen, WebDriver-Protokolloberfläche	Rohes CDP verwenden, Chromedriver überspringen	so konzipiert, dass es so verwendet wird
B: CDP-Nebeneffekte	`Runtime.enable` leckt über sourceURL + Init-Script-Fußabdrücke, egal wie sauber die Binärdatei ist	Die Steuer-/CDP-Client-Schicht: `Runtime.enable` zurückhalten, `Runtime.addBinding` + isolierte Welten verwenden	kein Leck (verifiziert)
C: Fingerabdruckoberfläche	Canvas, WebGL, Audio, Schriftarten, Navigator, über Hauptframe, Iframes, Worker hinweg	Die Engine (C++), weil JS-Overrides sich selbst enthüllen	das ist Fortress

Spoof-Ebene	keine	JS-Injektion	CDP/Konfigurations-Patch	C++-Engine	C++-Engine	C++-Engine
`toString` ergibt `[native code]`	n/a		n/a
Überlebt Bereichs-Wiedererlangung (Iframe/Worker)
Kein `Runtime.enable`-Leck
Engine = Chrome / V8 (Hauptverkehr)				Firefox
Kohärente Chromium-TLS-Form				Firefox
Vollständig Open-Source-Engine					neueste Hauptversion hinter Paywall
Veröffentlichte, prüfbare Patch-Serie	n/a	n/a	n/a		nur Binärdatei
Reproduzierbarer Build aus dem Quellcode	n/a	n/a	n/a
Gibt eigene Grenzen an	n/a	n/a	n/a

CreepJS	als headless markiert	0% headless · 0% stealth, Worker-Signale kohärent
bot.sannysoft.com	rote Zeilen	0 fehlgeschlagen · WebDriver Advanced bestanden · WebGL = NVIDIA RTX 3060 / ANGLE D3D11
browserscan.net	Bot erkannt	“No bots detected, could be a human”
rebrowser bot-detector	`Runtime.enable` LECK	kein Leck · `webdriver=false` · saubere Init-Skripte (rohes CDP)
Cloudflare Turnstile	blockiert	umgangen: ein menschlicher Klick hat eine Live-Challenge gelöst (headed, Rechenzentrums-IP)

fortress

Beliebteste

34

0%

`[native code]`

BSD-3

Native-Code-Parität

Drop-in-CDP

Besteht das Gauntlet

Prüfbare Patches

Von Natur aus kohärent

Anpassbare Persona