एक ब्राउज़र इंजन जो सब पर राज करता है

स्टील्थ क्रोमियम इंजन

Fortress एक स्टील्थ क्रोमियम इंजन है जो आपके स्क्रेपर्स और ब्राउज़र एजेंटों को ब्लॉक होने से रोकता है, कोड में सिर्फ एक लाइन बदलकर। बॉट डिटेक्टर ब्राउज़र फिंगरप्रिंट पढ़कर ऑटोमेशन को पहचानते हैं; Fortress उस फिंगरप्रिंट को Chromium के C++ के अंदर सही करता है, जिससे ब्राउज़र एक सामान्य Chrome इंस्टॉल की तरह प्रस्तुत होता है। स्क्रेपर्स अपने कार्य पूरे करते हैं, एजेंट उन पृष्ठों तक पहुँचते हैं जहाँ उन्हें भेजा गया था, और CreepJS, Sannysoft, BrowserScan, और लाइव Cloudflare Turnstile सभी इसे मानव के रूप में पढ़ते हैं। अपने मौजूदा Playwright या Puppeteer को Fortress पर CDP के माध्यम से इंगित करें, और आपके कोड में और कुछ नहीं बदलता।

_{Blink · V8 · BoringSSL पेड़ में पैच किया गया · ANGLE / D3D11-समर्थित WebGL · JA3/JA4-सुसंगत TLS · मासिक ऊपरी धारा रीबेज़ · पुनरुत्पादनीय, गौंटलेट-गेटेड रिलीज़}

Fortress एक लाइव Cloudflare चैलेंज को साफ कर रहा है, फिर sannysoft और BrowserScan को पास कर रहा है

_{वास्तविक विंडो में Fortress बाइनरी का असंपादित कैप्चर: यह एक लाइव Cloudflare चैलेंज को साफ करता है, bot.sannysoft.com को पूरी तरह हरा बनाता है, फिर BrowserScan को “Normal” पढ़ता है। tools/gauntlet.py के साथ पुनः प्रस्तुत करें।}

🆕 नया क्या है — 151.0.7908.0 · इंजन रिफ़्रेश

जारी किया गया। प्रति-लॉन्च सुसंगत व्यक्तित्व, कठोर किए गए।

प्रति-लोकेल कीबोर्ड (QWERTY / QWERTZ / AZERTY) · प्रति-व्यक्तित्व मीडिया डिवाइस · एक पूर्ण डिलीवरी-समता सुसंगति पास।
प्लेटफ़ॉर्म ↔ GPU ↔ टाइमज़ोन ↔ भाषा ↔ आवाज़ें ↔ कीबोर्ड एक सुसंगत वास्तविक डिवाइस के रूप में चलते हैं — हर लॉन्च पर, एक ही बाइनरी से।
नेटिव-कोड समता (toString() [native code] ही रहता है), क्षेत्र-अपरिवर्तनीय (मुख्य / वर्कर / आइफ्रेम) — सुसंगति ब्राउज़र में संकलित की गई है, जावास्क्रिप्ट में पैच नहीं की गई।```bash pip install -U tilion-fortress # or: docker run --rm -p 9222:9222 tilion/fortress:latest

**[→ पूर्ण रिलीज़ नोट्स](https://github.com/tiliondev/fortress/releases/tag/v151.0.7908.0)**


## सामग्री

| | |
|---|---|
| **[यह क्या है](#what-it-is)** · **[त्वरित आरंभ](#quick-start)** | यह क्या है, इंस्टॉल, पहली स्क्रिप्ट, AI-एजेंट सेटअप |
| **[Fortress MCP](#the-fortress-mcp--stealth-browsing-as-agent-tools)** | AI एजेंट्स के लिए 29 स्टील्थ-ब्राउज़र टूल (बीटा) |
| **[इंजन को पैच क्यों करें, पेज को नहीं](#why-patch-the-engine-not-the-page)** | स्व-प्रकटीकरण JS थीसिस + तीन डिटेक्शन लेयर्स |
| **[Fortress की तुलना कैसे होती है](#how-fortress-compares)** | बनाम puppeteer-stealth · Camoufox · CloakBrowser · बंद विक्रेता |
| **[प्रमाण: लाइव-डिटेक्टर परिणाम](#proof-live-detector-results)** | CreepJS / Sannysoft / BrowserScan / Cloudflare, स्क्रीनशॉट के साथ |
| **[व्यक्तित्व कॉन्फ़िगर करें](#configure-the-persona)** | `--uxr-*` फिंगरप्रिंट सतह |
| **[आपके स्टैक के साथ काम करता है](#works-with-your-stack)** | browser-use · Crawl4AI · Stagehand · LangChain |
| **[बिल्ड और सत्यापित करें](#build--verify)** | स्रोत से पुनरुत्पादन, प्रमाणिकता सत्यापित करें |
| **[संदर्भ](#reference)** | समस्या निवारण · FAQ · रोडमैप · रेपो लेआउट |

---

## यह क्या है

Fortress एक Chromium फोर्क है जो इंजन के अंदर से ब्राउज़र फिंगरप्रिंट को स्पूफ करता है। बॉट डिटेक्टर जिन सतहों को पढ़ते हैं (canvas, WebGL, ऑडियो, फ़ॉन्ट, navigator, और लगभग तीस और) उन्हें Chromium के **C++** में ठीक किया जाता है, जिसमें पकड़े जाने के लिए कोई JavaScript पैच लेयर ऊपर नहीं होती।

यह एक सामान्य ब्राउज़र बाइनरी के रूप में आता है जो CDP एंडपॉइंट को उजागर करता है। Playwright, Puppeteer, या किसी भी CDP क्लाइंट को इस पर इंगित करें और आपका मौजूदा ऑटोमेशन बिना बदलाव के चलता है।

एक JavaScript स्टील्थ पैच एक अतिरिक्त लेयर छोड़ता है जिसे पेज ढूंढ सकता है: `.toString()` ओवरराइड का स्रोत दिखाता है, और एक iframe या worker से उसी प्रिमिटिव को फिर से लेने पर यह उससे आगे पहुँच जाता है। Fortress इसके बजाय सतह को इंजन में ठीक करता है, इसलिए `navigator.vendor` वास्तविक C++ गेटर पर हल होता है, `[native code]` रिपोर्ट करता है, और हर रियल्म से समान पढ़ता है। एक पेज स्वयं का निरीक्षण करने पर स्टॉक Chromium देखता है। यही कारण है कि आपका ऑटोमेशन वहाँ काम करता है जहाँ पहले फ़्लैग होता था, और जो भी ब्लॉकिंग बची है वह आपके प्रॉक्सी और व्यवहार पर निर्भर करती है, ब्राउज़र पर नहीं। [इंजन को पैच क्यों करें, पेज को नहीं](#why-patch-the-engine-not-the-page) इस डिटेक्शन मैकेनिक्स को पूरी तरह से कवर करता है।```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();

12-सेकंड का टूर

Fortress 12 सेकंड में: CreepJS, Sannysoft, BrowserScan और rebrowser को पास करता है, वास्तविक साइटों को स्क्रैप करता है, और aa.com, lowes.com, macys.com और kohls.com पर Akamai को क्लियर करता है।

_{एक लूप, सभी वास्तविक कैप्चर: CreepJS / Sannysoft / BrowserScan / rebrowser को पास करता है → CDP पर संरचित डेटा स्क्रैप करता है → aa.com · lowes · macys · kohls पर Akamai को क्लियर करता है (समान रेज़िडेंशियल IP)।}

वास्तविक स्क्रैपिंग, पूरी तरह से हेडलेस

_{Fortress इंजन के असंपादित कैप्चर जो CDP पर संचालित हैं। कोई स्टील्थ प्लगइन नहीं, कोई JS पैच नहीं: फ़िंगरप्रिंट बाइनरी में सही किया गया है। इनमें से किसी को भी examples/scrape_demos.py से पुनरुत्पादित करें।}

Fortress books.toscrape.com से CDP पर लाइव टाइप किए गए JSON रिकॉर्ड निकाल रहा है

_{संरचित निष्कर्षण: प्रत्येक आइटम पढ़े जाने पर रिकॉर्ड टाइप किए गए JSON में बनते हैं।}

वास्तविक Akamai को क्लियर करता है — पहले / बाद में

पहले: एक स्टॉक ब्राउज़र aa.com पर Akamai द्वारा Access Denied के साथ अवरुद्ध है। बाद में: Fortress वास्तविक पृष्ठ लोड करता है और Akamai का सेंसर इसे स्वीकार करता है।

_{समान रेज़िडेंशियल IP, समान साइट (aa.com · Akamai Bot Manager)। एक स्टॉक/हेडलेस ब्राउज़र को Access Denied मिलता है (Reference #); Fortress वास्तविक पृष्ठ लोड करता है और Akamai अपनी _abck सेंसर कुकी जारी करता है — Bot Manager इसे एक वास्तविक ब्राउज़र के रूप में स्वीकार करता है। चर फ़िंगरप्रिंट है, IP नहीं।}

त्वरित आरंभ```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]
> SDK, संकलित बिल्ड **और `patches/`** के साथ आता है, ताकि आप इंजन को स्वयं पुनः बना सकें और स्रोत के विरुद्ध प्रत्येक सतह सुधार को सत्यापित कर सकें। डाउनलोड रिलीज़ `SHA256SUMS` के विरुद्ध स्वचालित रूप से SHA-256-सत्यापित होते हैं।

### संस्करण

Fortress **दो Chromium आधारों** पर आता है — मिश्रण और वर्तमानता के बीच अपनी समझौता चुनें:

| चैनल | Chromium | कब उपयोग करें |
|---|---|---|
| **`stable`** *(डिफ़ॉल्ट)* | **149** | अनुशंसित — Chrome के उस संस्करण से मेल खाता है जो अधिकांश वास्तविक उपयोगकर्ता चलाते हैं, इसलिए यह सबसे अच्छी तरह से मिश्रित होता है |
| **`latest`** | **151** | नवीनतम इंजन (स्थिर से थोड़ा आगे का संस्करण रिपोर्ट करता है) |```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 binaries: Linux x64 (both versions) + Windows x64 (151); Windows-149 and macOS run via the Docker image.

इसे अपने AI एजेंट में डालें

Fortress आपके एजेंट द्वारा चलाया जाने वाला ब्राउज़र है: :9222 पर रॉ CDP, कोई स्टील्थ प्लगइन जोड़ने की ज़रूरत नहीं। इसमें शामिल होने के दो तरीके हैं।

विकल्प 1: इसे चैट असिस्टेंट में प्रीलोडेड खोलें। एक क्लिक; यह हमारी AGENTS.md पढ़ता है और आपको पूरी सेटअप प्रक्रिया में ले जाता है:

विकल्प 2: एजेंट के लिए कॉपी करें (सब कुछ, आपके क्लिपबोर्ड पर)। नीचे दिए गए बॉक्स के ऊपर दाईं ओर कॉपी आइकन पर क्लिक करें। यह आपके क्लिपबोर्ड पर पूरा सेटअप संदर्भ रखता है: यह क्या है, स्थापना, कनेक्शन, व्यक्तित्व, और नियम, AGENTS.md का संक्षिप्त रूप। इसे Cursor, Claude Code, Copilot, ChatGPT, या किसी भी एजेंट में पेस्ट करें और यह वहाँ से संभाल लेगा:```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 — स्टील्थ ब्राउज़िंग एजेंट टूल्स के रूप में &nbsp;<sub>Beta</sub>

Raw CDP code लिखने के लिए है। **Fortress MCP** उन एजेंटों के लिए है जो **टूल्स** कॉल करते हैं: एक [Model Context Protocol](https://modelcontextprotocol.io) सर्वर जो Claude, Cursor, या किसी भी MCP क्लाइंट को एक स्टील्थ ब्राउज़र देता है, ताकि जैसे ही कोई फ़ेच ब्लॉक हो, वह सिर्फ़ एक टूल कॉल करे और पेज प्राप्त करे। **29 टूल्स, स्थानीय और मुफ़्त** — `fetch_protected_page`, `extract_page`, `crawl_site`, `recon_site_apis`, `search_web`, `run_browser_task`, `save_profile`, `get_stealth_cdp_endpoint`, और भी।

<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/795/8f328e2498b09d7433208c5b4a9002450643537f2ee6b0519ac10420ef581bf3.gif" alt="एक ही साइट, एक ही प्रॉम्प्ट: एक सामान्य ब्राउज़र PerimeterX द्वारा ब्लॉक कर दिया जाता है जबकि Fortress MCP वाला एजेंट साफ़ JSON लौटाता है" width="760"/></p>

<sub><i>वास्तविक, दिनांकित रन <b>stockx.com</b> (PerimeterX) के विरुद्ध। एक सामान्य ब्राउज़र को <b>HTTP 403 — “Access denied”</b> मिलता है; Fortress MCP वाला एजेंट साफ़ JSON लौटाता है — एक ही साइट, एक ही प्रॉम्प्ट। इसे फ्रेमवर्क रिपॉजिटरी से पुनः प्रस्तुत करें।</i></sub>

### इसे 30 सेकंड में सेट करें

दो रनर — कोई एक चुनें। `npx` को PATH पर Python की आवश्यकता है; `pip` इसे सीधे इंस्टॉल करता है:```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 — सेटिंग्स → डेवलपर → कॉन्फ़िग संपादित करें (claude_desktop_config.json):```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

<sub>npx पसंद है? Use <code>"command": "npx", "args": ["-y", "tilion-mcp"]</code>. Claude को पुनरारंभ करें, और <b>fortress</b> उपकरण दिखाई देंगे।</sub>

**Claude Code** (CLI) — एक पंक्ति:```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) — एक ही ब्लॉक:```json { "mcpServers": { "fortress": { "command": "tilion-mcp" } } }

फिर अपने एजेंट से बस पूछें — *"इस StockX पेज से कीमत लाओ"* — और वह अपने आप `fetch_protected_page` को कॉल करता है।

### एजेंट को क्या मिलता है

| | उपकरण |
|---|---|
| **ब्लॉक किए गए पेज प्राप्त करें** | `fetch_protected_page` · `read_page` · `get_page_html` · `search_web` |
| **संरचित डेटा** | `extract_page` (स्कीमा-जागरूक) · `extract_document` (PDF/DOCX/XLSX) |
| **पूरी साइटें** | `crawl_site` (ऑटो-SPA) · `recon_site_apis` (निजी JSON API खोजें) |
| **पेज चलाएं** | `page_elements` · `click_button` · `fill_field` · `press_key` · `wait_for` · `evaluate_js` |
| **बहु-चरणीय प्रवाह** | `run_browser_task` (लॉगिन, पेजिनेट, इनफ़िनिट-स्क्रॉल, चेकआउट, …) |
| **कैप्चर / प्रमाणीकरण** | `screenshot_page` · `save_page` · `download_file` · `save_profile` / `load_profile` |
| **अपना खुद का लाएं** | `get_stealth_cdp_endpoint` → Playwright / Puppeteer / browser-use के लिए एक CDP url |

उपकरण एनोटेटेड हैं (पढ़ना ऑटो-अप्रूव, लिखना गेटेड), स्टार्टअप पर **प्री-वार्म** (~100 ms पहली कॉल), कंकरेंसी-सेफ़, और टाइमआउट- और SSRF-संरक्षित। **रिज़िडेंशियल एग्रेस** वाला एक होस्टेड एंडपॉइंट **जल्द ही आ रहा है**।

→ **पूर्ण 29-टूल तालिका, बेंचमार्क, और एजेंट कौशल**: **[`mcp/`](https://github.com/tiliondev/fortress/blob/HEAD/mcp/README.md)**

---

## इंजन को पैच क्यों करें, पेज को नहीं

सामान्य दृष्टिकोण `navigator.webdriver` को पैच करता है, WebGL वेंडर को स्पूफ करता है, और स्क्रिप्ट से `navigator.plugins` को ओवरराइड करता है। CreepJS और इसी तरह के डिटेक्टर अभी भी इसे फ्लैग करते हैं, और इसका कारण **संरचनात्मक** है, न कि कोई एक और अनकवर की गई प्रॉपर्टी। एक JavaScript स्पूफ एक फंक्शन है जो वहाँ खड़ा होता है जहाँ एक नेटिव फंक्शन होना चाहिए। डिटेक्टर लौटाए गए मान को अलग रखते हैं और पूछताछ करते हैं कि क्या इसे लौटाने वाली चीज़ नेटिव है:

| संकेत | यह JS स्पूफ क्यों पकड़ता है |
|---|---|
| `toString` स्व-प्रकटीकरण | एक नेटिव मेथड `function get vendor() { [native code] }` पर स्ट्रिंगिफाई करता है; एक ओवरराइड अपने स्वयं के स्रोत पर स्ट्रिंगिफाई करता है, इसलिए एक `.toString()` इसे पकड़ लेता है। |
| डिस्क्रिप्टर और `hasOwnProperty` | `getOwnPropertyDescriptor` पुनर्परिभाषित प्रॉपर्टीज़ को उजागर करता है, और `hasOwnProperty('toString')` एक छेड़छाड़ किए गए फंक्शन पर `true` लौटाता है जहाँ एक नेटिव `false` लौटाता है। |
| `failsTypeError` | नेटिव गेटर गलत `this` पर एक विशिष्ट `TypeError` फेंकते हैं; एक भोली शिम चुप रहती है, और वह चुप्पी ही संकेत है। |

रीयल्म पुनः-अधिग्रहण वह है जो हर मुख्य-विश्व पैच को हरा देता है। एक डिटेक्टर किसी अन्य रीयल्म से एक प्रिस्टिन प्रिमिटिव पकड़ता है और इसे आपके फंक्शन पर लागू करता है:```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.

आपका मुख्य-दुनिया पैच उस iframe से अलग दायरे में रहता है। वही जाल एक Web Worker से चलता है, एक थ्रेड जो आपका मुख्य-थ्रेड शिम अंदर के बजाय बगल में चलता है।

Fortress में ऐसी कोई परत नहीं है। navigator.vendor के लिए गेटर C++ गेटर है: यह [native code] रिपोर्ट करता है क्योंकि यह नेटिव कोड है, जो हर दायरे में समान है। Camoufox इसे अच्छी तरह कहता है: "पकड़े जाने के लिए कोई JavaScript हाईजैकिंग नहीं है।" Fortress उसी विचार को Gecko के स्थान पर V8 और Blink पर लागू करता है।

बॉट डिटेक्शन की तीन परतें, और Fortress कहाँ फिट बैठता है

आधुनिक एंटी-बॉट्स (Cloudflare, DataDome, Kasada, HUMAN, Akamai) तीन संरचनात्मक रूप से भिन्न सतहों को पढ़ते हैं, तीन अलग-अलग स्थानों पर। एक उपकरण शायद ही तीनों को ठीक करता हो:

Fortress लेयर-C इंजन है, जिसे इस तरह चलाए जाने के लिए बनाया गया है कि A और B भी कायम रहें। बाइनरी अकेली CDP चैनल को खुला छोड़ देती है। वह हिस्सा नियंत्रण परत पर है, और अन्यथा दिखावा करना ही पकड़े जाने का तरीका है।

Fortress की तुलना कैसे करता है

Fortress वास्तविक पूर्व कला पर निर्मित है: fingerprint-chromium, ChromiumFish, और CloakBrowser पहले आए, और वाणिज्यिक विक्रेता (Multilogin, Kameleo, GoLogin, AdsPower, Browserbase, Surfsky) बंद स्रोत के पीछे Chromium को पुनर्संकलित करते हैं। उस काम का अधिकांश भाग बंद रहता है: पेवॉल्ड फोर्क्स आपको एक बाइनरी देते हैं और इसे विश्वसनीय मानने के लिए कहते हैं, और विक्रेता अपने पैच को इन-हाउस रखते हैं।

Fortress दूसरे रास्ते जाता है, क्योंकि एक स्टील्थ इंजन तभी उपयोगी रहता है जब उस पर निर्भर लोग देख सकें कि यह कैसे काम करता है। प्रत्येक सतह सुधार patches/ में एक छोटे, एकल-उद्देश्य वाले डिफ के रूप में रहता है जिसे आप एक मिनट में पढ़ सकते हैं, और पूरा इंजन एक स्क्रिप्ट के साथ स्रोत से पुनर्निर्माण करता है। जब कोई डिटेक्टर कोई नया संकेत ढूंढता है, तो आप फिक्स का पता लगाते हैं, उसे पैच करते हैं, और वापस भेजते हैं। वह फीडबैक लूप ही बात है, और यह तभी काम करता है जब इंजन पढ़ने, विस्तारित करने और पुनर्निर्माण करने के लिए पर्याप्त खुला रहे।

प्रमाण: लाइव-डिटेक्टर परिणाम

किसी भी पंक्ति को tools/gauntlet.py --bundle ./tilion-fortress से पुनः उत्पन्न करें। लाइव डिटेक्टर्स के विरुद्ध सत्यापित; पुनः चलाने की तिथि docs/GAUNTLET_RESULTS.md में।

प्रमाण: वास्तविक, असंपादित स्क्रीनशॉट

BrowserScan	CreepJS	Cloudflare

व्यक्तित्व कॉन्फ़िगर करें

बाइनरी शून्य ब्रांड स्ट्रिंग्स रखती है; लॉन्चर एक सुसंगत डिफ़ॉल्ट Windows व्यक्तित्व लागू करता है। --uxr-* स्विच के साथ किसी भी सतह को ओवरराइड करें, या बेयर लॉन्च के लिए TILION_NO_DEFAULTS=1 सेट करें।``` --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 | उद्देश्य |
|---|---|
| `TILION_NO_DEFAULTS=1` | डिफ़ॉल्ट व्यक्तित्व को छोड़ें (नंगे लॉन्च) |
| `TILION_TZ` / `TILION_LANG` | त्वरित समय क्षेत्र / भाषा ओवरराइड |

> [!NOTE]
> **आज के समय में व्यक्तित्व कमांड लाइन पर चलता है।** `--uxr-*` स्विच `/proc/<pid>/cmdline` के माध्यम से सभी प्रक्रियाओं के लिए पढ़ने योग्य होते हैं, इसलिए प्रति लॉन्च एक व्यक्तित्व होता है और होस्ट पर अन्य प्रक्रियाओं को दिखाई देता है। `MaskConfig` रनटाइम अगला आ रहा है: यह व्यक्तित्व को IPC के माध्यम से देता है और प्रति प्रक्रिया सीमा को हटा देता है (देखें [आगे क्या है](#whats-next))।

---

## आपके स्टैक के साथ काम करता है

Fortress `:9222` पर रॉ CDP प्रदान करता है, इसलिए यह Playwright, Puppeteer, या CDP बोलने वाली किसी भी चीज़ के अंतर्गत आ जाता है।

| फ्रेमवर्क | कनेक्ट करने का तरीका |
|---|---|
| [**browser-use**](https://github.com/browser-use/browser-use) (~70k स्टार्स) | `cdp_url="http://localhost:9222"` |
| [**Crawl4AI**](https://github.com/unclecode/crawl4ai) (~58k स्टार्स) | CDP एंडपॉइंट |
| [**Stagehand**](https://github.com/browserbase/stagehand) (~21k स्टार्स) | `connectOverCDP` |
| [**LangChain**](https://github.com/langchain-ai/langchain) Playwright टूलकिट | 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

निर्माण और सत्यापन

स्रोत से पुनरुत्पादन करें```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

आउटपुट: `out/Fortress/chrome`। फ़ोर्क में 34 छोटे एकल-सतह पैच (`patches/`) हैं, इसलिए अधिकांश अपस्ट्रीम रिलीज़ में साफ़-सुथरे लागू होते हैं; फिर गौंटलेट किसी भी रिग्रेशन पर रिलीज़ को रोक देता है।

| प्लेटफ़ॉर्म | स्थिति |
|---|---|
| Linux x64 (नेटिव) · **Windows x64 (नेटिव)** · डॉकर के माध्यम से कोई भी OS | <img src="https://raw.githubusercontent.com/tiliondev/fortress/HEAD/docs/assets/icons/check.svg" width="15" alt="yes"> **शिपिंग** |
| कोड-हस्ताक्षरित इंस्टॉलर · macOS `.app` · `linux/arm64` | प्रगति पर |

### सत्यापित करें कि यह वास्तव में हमारा है

Fortress चार आधिकारिक चैनलों से वितरित होता है। बाकी किसी भी चीज़ को अविश्वसनीय समझें:

| | आधिकारिक स्रोत |
|---|---|
| **स्रोत** | [github.com/tiliondev/fortress](https://github.com/tiliondev/fortress) |
| **डॉकर** | [`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) |

**डाउनलोड सत्यापित करें।** हर रिलीज़ `SHA256SUMS` शामिल करती है, और `pip`/`npm` SDK इंस्टॉल के दौरान आपके लिए इसे चलाते हैं:```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

Docker छवि को डाइजेस्ट (सिर्फ़ टैग नहीं) द्वारा सत्यापित करें:```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

**किसी पर भी भरोसा न करें और इसे फिर से बनाएं।** पूरा फोर्क `patches/` में 34 पठनीय पैच है; `build/build.sh` Chromium स्रोत से बाइनरी को पुन: उत्पन्न करता है, ताकि आप अपने बनाए गए और हमारे द्वारा भेजे गए बीच अंतर देख सकें।

---

## संदर्भ

<details><summary><b>समस्या निवारण</b></summary>

<br/>

**अभी भी Cloudflare, DataDome, या Kasada पर अवरुद्ध हैं।** अधिकांश समय यह आपका **IP** होता है, आपका फिंगरप्रिंट नहीं: डेटासेंटर रेंज किसी भी पेज स्क्रिप्ट चलने से पहले फ्लैग हो जाती है। आउटगोइंग ट्रैफिक को रेजिडेंशियल या मोबाइल प्रॉक्सी के माध्यम से रूट करें और पुन: प्रयास करें; यदि यह साफ हो जाता है, तो फिंगरप्रिंट ठीक था।

**Linux होस्ट पर फिंगरप्रिंट गलत लग रहा है।** डिफ़ॉल्ट व्यक्तित्व Windows है, लेकिन TLS आकार और कुछ OS-संबंधी सिग्नल अंतर्निहित मशीन का अनुसरण करते हैं। व्यक्तित्व को अपने आउटगोइंग OS से मिलाएं, या प्रासंगिक `--uxr-*` फ्लैग सेट करें ताकि OS कहानी ट्रैफिक के बाहर निकलने के स्थान से मेल खाए।

**macOS एक Docker इमेज खींचता है।** मूल Linux + Windows बाइनरी आज शिप होती हैं; macOS अभी भी आधिकारिक Docker इमेज (`tilion/fortress`) के माध्यम से Fortress चलाता है। Docker Desktop इंस्टॉल करें, या मूल बाइनरी के लिए Linux/Windows x64 पर चलाएं।

**व्यक्तित्व `/proc/<pid>/cmdline` में दिखाई देता है।** `--uxr-*` फ्लैग होस्ट पर अन्य प्रक्रियाओं द्वारा पढ़ने योग्य हैं, प्रति लॉन्च एक व्यक्तित्व। जब तक रनटाइम `MaskConfig` नहीं आता, प्रति प्रक्रिया एक व्यक्तित्व रखें और अविश्वसनीय कोड के साथ होस्ट साझा करने से बचें।

**एक डिटेक्टर किसी ऐसी चीज़ को फ्लैग करता है जिसे गॉन्टलेट पास करता है।** डिटेक्शन बदलता है। सुनिश्चित करें कि आप वर्तमान Chromium रीबेस पर हैं, फिर टेस्ट पेज के साथ एक इश्यू खोलें। वह पेज अगला पैच बन जाता है।

</details>

<details><summary><b>सामान्य प्रश्न</b></summary>

<br/>

**क्या यह कानूनी है?** Fortress एक ब्राउज़र इंजीनियरिंग प्रोजेक्ट है जो सार्वजनिक रूप से उपलब्ध डेटा के वैध ऑटोमेशन, परीक्षण और स्क्रैपिंग के लिए है। प्रत्येक साइट की सेवा की शर्तों और अपने अधिकार क्षेत्र के कानून का सम्मान करें।

**क्या यह वास्तव में मुफ्त है?** हाँ। BSD-3, पूरी तरह से खुला, और स्व-होस्ट करने योग्य। पैच श्रृंखला प्रकाशित है, ताकि आप वर्तमान इंजन को स्वयं स्रोत से बना सकें।

**क्यों न केवल puppeteer-stealth या undetected-chromedriver का उपयोग करें?** वे पेज के ब्राउज़र का निरीक्षण करने के बाद JS/CDP लेयर को पैच करते हैं, इसलिए वे `toString` और realm पुनः अधिग्रहण के माध्यम से स्वयं को प्रकट करते हैं। Fortress स्पूफ को C++ में ले जाता है, जहां पेज को नेटिव कोड मिलता है। (देखें "इंजन को क्यों पैच करें, पेज को नहीं।")

**यह Camoufox से कैसे अलग है?** वही C++-इंटरसेप्शन विचार। Camoufox Firefox (~3% ट्रैफिक, एक स्थायी विसंगति) को फोर्क करता है जबकि Fortress Chromium और V8 (बहुमत इंजन) को फोर्क करता है, इसलिए एक Chrome यूज़र-एजेंट निर्माण से सुसंगत है।

**क्या यह हमेशा सब कुछ पास करेगा?** नहीं। डिटेक्शन बदलता रहता है, इसलिए हम एक तिथि-निर्धारित, पुनरुत्पादनीय गौंटलेट और मासिक Chromium रीबेस शिप करते हैं; आप हमेशा देख सकते हैं कि आज क्या पास होता है।

</details>

<details><summary><b>रोडमैप</b></summary>

<br/>

- [ ] C++ `MaskConfig` में रनटाइम JSON कॉन्फ़िग (एक बाइनरी, कई सुसंगत फिंगरप्रिंट, कमांड लाइन पर कुछ नहीं)
- [ ] प्रथम-पक्ष MCP सर्वर और Puppeteer / raw-CDP SDK (AI एजेंटों के लिए ड्रॉप-इन)
- [ ] कोड-हस्ताक्षरित Windows `.exe` और macOS `.app`
- [ ] `linux/arm64` Docker इमेज
- [ ] `patches/` को Brave-शैली `chromium_src/` ओवरराइड में माइग्रेट करें
- [ ] प्रकाशित reCAPTCHA v3 / DataDome / Kasada बेंचमार्क पंक्तियाँ (दिनांकित, पुनरुत्पादनीय)

</details>

<details><summary><b>रिपॉजिटरी लेआउट</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

योगदान

कोई डिटेक्शन वेक्टर या लीक मिला जो हमसे छूट गया? एक प्रतिलिपि योग्य परीक्षण पृष्ठ के साथ एक मुद्दा खोलें। एक पृष्ठ जो विश्वसनीय रूप से फोर्ट्रेस को फ़्लैग करता है, वह सबसे मूल्यवान चीज़ है जो आप भेज सकते हैं। यह अगला पैच बन जाता है। दो घरेलू नियम: हर क्षमता का दावा एक कमांड के साथ आता है जो इसे पुन: उत्पन्न करता है, और हर सीमा लिख दी जाती है। शब्द "undetectable" रिपॉजिटरी से बाहर रहता है।

लाइसेंस

BSD-3-Clause फोर्ट्रेस पैच और टूलिंग के लिए (क्रोमियम से मेल खाता है)। क्रोमियम और बंडल किए गए फोंट अपने स्वयं के लाइसेंस बनाए रखते हैं; LICENSE और NOTICE देखें। पैच श्रृंखला प्रकाशित है, ताकि आप स्वयं इंजन का ऑडिट और पुनर्निर्माण कर सकें।

आगे क्या

[!IMPORTANT] v2: MaskConfig रनटाइम व्यक्तित्व। एक IPC-डिलीवर्ड, सीड-ड्रिवन व्यक्तित्व ग्राफ जो एक प्रक्रिया-ग्लोबल C++ MaskConfig सिंगलटन को फीड करता है: एकल बाइनरी से हजारों सुसंगति-अपरिवर्तनीय फिंगरप्रिंट, प्रति-BrowserContext पहचान अलगाव, और शून्य कमांड-लाइन फुटप्रिंट। बाकी रोडमैप पर है।

अपडेट रहना

डिटेक्शन चलता रहता है, इसलिए एक स्टील्थ इंजन अपने अंतिम रीबेज़ जितना ही अच्छा होता है। फोर्ट्रेस मासिक रूप से नवीनतम क्रोमियम को ट्रैक करता है, पूरी गौंटलेट को फिर से चलाता है, और जब भी कोई डिटेक्टर कोई नया संकेत ढूंढता है तो एक पैच जारी करता है, ताकि आप जो चलाते हैं वह वास्तविक क्रोम इंस्टॉल जैसा दिखता रहे। v2 MaskConfig कार्य का अनुसरण करने के लिए रिलीज़ देखें, या यदि यह आपके लिए उपयोगी हो तो रिपॉजिटरी को स्टार करें।

स्टील्थ जिसे आप पढ़, पुनर्निर्माण और स्वयं चला सकते हैं।

A: ड्राइवर / बाइनरी आर्टिफैक्ट्स	`cdc_` ChromeDriver वेरिएबल्स, WebDriver प्रोटोकॉल सतह	रॉ CDP चलाएं, chromedriver को छोड़ें	इस तरह चलाए जाने के लिए बनाया गया
B: CDP साइड-इफेक्ट्स	`Runtime.enable` sourceURL + init-script फुटप्रिंट्स के माध्यम से लीक करता है, चाहे बाइनरी कितनी भी साफ क्यों न हो	नियंत्रण / CDP-क्लाइंट परत: `Runtime.enable` को रोकें, `Runtime.addBinding` + पृथक दुनिया का उपयोग करें	कोई लीक नहीं (सत्यापित)
C: फिंगरप्रिंट सतह	canvas, WebGL, ऑडियो, फ़ॉन्ट्स, navigator, मुख्य फ्रेम, iframes, वर्कर्स में	इंजन (C++), क्योंकि JS ओवरराइड्स स्वयं को प्रकट करते हैं	यह Fortress है

स्पूफ़ परत	कोई नहीं	JS इंजेक्शन	CDP/कॉन्फ़िग पैच	C++ इंजन	C++ इंजन	C++ इंजन
`toString` देता है `[native code]`	n/a		n/a
रीएल्म पुनः-अधिग्रहण (iframe/worker) में जीवित रहता है
कोई `Runtime.enable` लीक नहीं
इंजन = Chrome / V8 (अधिकांश ट्रैफ़िक)				Firefox
सुसंगत Chromium TLS आकार				Firefox
पूरी तरह से ओपन-सोर्स इंजन					नवीनतम प्रमुख पेवॉल्ड
प्रकाशित, ऑडिट योग्य पैच श्रृंखला	n/a	n/a	n/a		केवल बाइनरी
स्रोत से पुनरुत्पादन योग्य बिल्ड	n/a	n/a	n/a
अपनी सीमाएँ बताता है	n/a	n/a	n/a

CreepJS	हेडलेस के रूप में फ़्लैग किया गया	0% हेडलेस · 0% स्टील्थ, वर्कर सिग्नल सुसंगत
bot.sannysoft.com	लाल पंक्तियाँ	0 विफल · WebDriver Advanced पास हुआ · WebGL = NVIDIA RTX 3060 / ANGLE D3D11
browserscan.net	बॉट का पता चला	“कोई बॉट नहीं पाया गया, मानव हो सकता है”
rebrowser bot-detector	`Runtime.enable` LEAK	कोई लीक नहीं · `webdriver=false` · साफ init-scripts (रॉ CDP)
Cloudflare Turnstile	ब्लॉक कर दिया गया	बाईपास: एक मानव क्लिक ने एक लाइव चैलेंज साफ़ किया (हेडेड, डेटासेंटर IP)

fortress

सबसे लोकप्रिय

34

0%

`[native code]`

BSD-3

नेटिव-कोड समता

ड्रॉप-इन CDP

गौंटलेट को साफ़ करता है

ऑडिटेबल पैचेज़

निर्माण से सुसंगत

ट्यूनेबल व्यक्तित्व