nodetect 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- nodetect/__init__.py +79 -0
- nodetect/cli.py +352 -0
- nodetect/config.py +138 -0
- nodetect/core/__init__.py +16 -0
- nodetect/core/clearance.py +66 -0
- nodetect/core/cookies.py +58 -0
- nodetect/core/engine.py +233 -0
- nodetect/core/humanizer.py +149 -0
- nodetect/core/iuam.py +58 -0
- nodetect/core/patches.py +448 -0
- nodetect/core/proxy_pool.py +71 -0
- nodetect/core/solver.py +127 -0
- nodetect/core/tls_session.py +75 -0
- nodetect/core/ua_feed.py +37 -0
- nodetect/profile/__init__.py +5 -0
- nodetect/profile/fingerprint.py +181 -0
- nodetect/profile/harvester.py +66 -0
- nodetect/profile/manager.py +184 -0
- nodetect-1.0.0.dist-info/METADATA +364 -0
- nodetect-1.0.0.dist-info/RECORD +23 -0
- nodetect-1.0.0.dist-info/WHEEL +5 -0
- nodetect-1.0.0.dist-info/entry_points.txt +2 -0
- nodetect-1.0.0.dist-info/top_level.txt +1 -0
nodetect/__init__.py
ADDED
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
"""
|
|
2
|
+
nodetect - High-Performance Stealth Browser Automation & Persistent Profile Orchestrator
|
|
3
|
+
"""
|
|
4
|
+
|
|
5
|
+
__version__ = "1.0.0"
|
|
6
|
+
|
|
7
|
+
import sys
|
|
8
|
+
import warnings
|
|
9
|
+
from typing import Optional
|
|
10
|
+
|
|
11
|
+
# Suppress Windows asyncio proactor pipe deallocation artifact
|
|
12
|
+
warnings.filterwarnings("ignore", category=ResourceWarning)
|
|
13
|
+
if sys.platform == "win32":
|
|
14
|
+
try:
|
|
15
|
+
from asyncio.proactor_events import _ProactorBasePipeTransport
|
|
16
|
+
_ProactorBasePipeTransport.__del__ = lambda self: None
|
|
17
|
+
except Exception:
|
|
18
|
+
pass
|
|
19
|
+
|
|
20
|
+
from nodetect.core.engine import StealthEngine, StealthSession
|
|
21
|
+
from nodetect.core.tls_session import TLSSession
|
|
22
|
+
from nodetect.core.humanizer import Humanizer
|
|
23
|
+
from nodetect.core.solver import TurnstileSolver
|
|
24
|
+
from nodetect.core.clearance import ClearanceHarvester
|
|
25
|
+
from nodetect.core.proxy_pool import ProxyPool
|
|
26
|
+
from nodetect.core.cookies import CookieVault
|
|
27
|
+
from nodetect.core.ua_feed import UserAgentFeed
|
|
28
|
+
from nodetect.core.iuam import CloudflareIUAM
|
|
29
|
+
from nodetect.profile.manager import ProfileManager, ProfileRecord
|
|
30
|
+
from nodetect.profile.fingerprint import Fingerprint
|
|
31
|
+
from nodetect.profile.harvester import Harvester
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
async def launch(
|
|
35
|
+
profile_id: str = "default_profile",
|
|
36
|
+
headless: bool = False,
|
|
37
|
+
proxy: Optional[str] = None,
|
|
38
|
+
proxy_pool: Optional[ProxyPool] = None,
|
|
39
|
+
platform_type: str = "windows",
|
|
40
|
+
turbo_mode: bool = False
|
|
41
|
+
) -> StealthSession:
|
|
42
|
+
"""
|
|
43
|
+
Convenience one-liner function to initialize and launch an undetected browser instance.
|
|
44
|
+
Supports proxy pools, automated stealth evasions, and persistent storage.
|
|
45
|
+
|
|
46
|
+
Usage:
|
|
47
|
+
import nodetect as pv
|
|
48
|
+
session = await pv.launch()
|
|
49
|
+
await session.page.goto("https://site.com")
|
|
50
|
+
await session.close()
|
|
51
|
+
"""
|
|
52
|
+
engine = StealthEngine()
|
|
53
|
+
return await engine.launch(
|
|
54
|
+
profile_id=profile_id,
|
|
55
|
+
headless=headless,
|
|
56
|
+
proxy=proxy,
|
|
57
|
+
proxy_pool=proxy_pool,
|
|
58
|
+
platform_type=platform_type,
|
|
59
|
+
turbo_mode=turbo_mode
|
|
60
|
+
)
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
__all__ = [
|
|
64
|
+
"launch",
|
|
65
|
+
"StealthEngine",
|
|
66
|
+
"StealthSession",
|
|
67
|
+
"TLSSession",
|
|
68
|
+
"Humanizer",
|
|
69
|
+
"TurnstileSolver",
|
|
70
|
+
"ClearanceHarvester",
|
|
71
|
+
"ProxyPool",
|
|
72
|
+
"CookieVault",
|
|
73
|
+
"UserAgentFeed",
|
|
74
|
+
"CloudflareIUAM",
|
|
75
|
+
"ProfileManager",
|
|
76
|
+
"ProfileRecord",
|
|
77
|
+
"Fingerprint",
|
|
78
|
+
"Harvester"
|
|
79
|
+
]
|
nodetect/cli.py
ADDED
|
@@ -0,0 +1,352 @@
|
|
|
1
|
+
"""
|
|
2
|
+
PhantomVault CLI - High-Performance Terminal Interface & Stealth Benchmark Suite
|
|
3
|
+
"""
|
|
4
|
+
import asyncio
|
|
5
|
+
import sys
|
|
6
|
+
from typing import Optional
|
|
7
|
+
from pathlib import Path
|
|
8
|
+
import click
|
|
9
|
+
from rich.console import Console
|
|
10
|
+
from rich.table import Table
|
|
11
|
+
from rich.panel import Panel
|
|
12
|
+
from rich.text import Text
|
|
13
|
+
from rich import box
|
|
14
|
+
|
|
15
|
+
import nodetect
|
|
16
|
+
from nodetect.profile.manager import ProfileManager
|
|
17
|
+
from nodetect.core.engine import StealthEngine
|
|
18
|
+
|
|
19
|
+
console = Console()
|
|
20
|
+
|
|
21
|
+
BANNER = """[bold cyan]
|
|
22
|
+
███╗ ██╗ ██████╗ ██████╗ ███████╗████████╗███████╗ ██████╗████████╗
|
|
23
|
+
████╗ ██║██╔═══██╗██╔══██╗██╔════╝╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝
|
|
24
|
+
██╔██╗ ██║██║ ██║██║ ██║█████╗ ██║ █████╗ ██║ ██║
|
|
25
|
+
██║╚██╗██║██║ ██║██║ ██║██╔══╝ ██║ ██╔══╝ ██║ ██║
|
|
26
|
+
██║ ╚████║╚██████╔╝██████╔╝███████╗ ██║ ███████╗╚██████╗ ██║
|
|
27
|
+
╚═╝ ╚═══╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═╝ ╚══════╝ ╚═════╝ ╚═╝
|
|
28
|
+
[/bold cyan][bold magenta]ENGINE[/bold magenta] [dim]- Stealth Browser Automation & Persistent Profile Orchestrator[/dim]"""
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
@click.group(context_settings=dict(help_option_names=['-h', '--help']))
|
|
32
|
+
@click.version_option(
|
|
33
|
+
version=nodetect.__version__,
|
|
34
|
+
prog_name="nodetect",
|
|
35
|
+
message="%(prog)s version %(version)s"
|
|
36
|
+
)
|
|
37
|
+
def cli():
|
|
38
|
+
"""⚡ nodetect: Production-grade anti-detect browser automation & profile orchestrator."""
|
|
39
|
+
pass
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
@cli.command()
|
|
43
|
+
def info():
|
|
44
|
+
"""Display engine banner and system architecture status."""
|
|
45
|
+
console.print(BANNER)
|
|
46
|
+
|
|
47
|
+
grid = Table.grid(padding=(0, 2))
|
|
48
|
+
grid.add_column(style="bold cyan")
|
|
49
|
+
grid.add_column(style="white")
|
|
50
|
+
|
|
51
|
+
grid.add_row("• Core Engine:", "Playwright + Chromium (Blink Automation Suppressed)")
|
|
52
|
+
grid.add_row("• TLS Pipeline:", "curl_cffi (Chrome JA3/JA4 & HTTP/2 Impersonator)")
|
|
53
|
+
grid.add_row("• Profile Vault:", "SQLite Persistent Store (~/.nodetect)")
|
|
54
|
+
grid.add_row("• Solver Suite:", "Autonomous Cloudflare Turnstile & cf_clearance Bridge")
|
|
55
|
+
grid.add_row("• Developer Contact:", "[bold green]Telegram: @mitul_islam[/bold green] (https://t.me/mitul_islam)")
|
|
56
|
+
|
|
57
|
+
panel = Panel(grid, title="[bold white]System Status[/bold white]", border_style="cyan", box=box.ROUNDED)
|
|
58
|
+
console.print(panel)
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
@cli.group()
|
|
62
|
+
def profile():
|
|
63
|
+
"""Manage isolated browser profiles and hardware configurations."""
|
|
64
|
+
pass
|
|
65
|
+
|
|
66
|
+
|
|
67
|
+
@profile.command("list")
|
|
68
|
+
def list_profiles():
|
|
69
|
+
"""List all stored profiles and their hardware footprints."""
|
|
70
|
+
mgr = ProfileManager()
|
|
71
|
+
profiles = mgr.list_profiles()
|
|
72
|
+
|
|
73
|
+
if not profiles:
|
|
74
|
+
console.print(Panel(
|
|
75
|
+
"[yellow]No profiles registered yet.[/yellow]\nCreate one with: [bold cyan]nodetect profile create <id>[/bold cyan]",
|
|
76
|
+
border_style="yellow",
|
|
77
|
+
box=box.ROUNDED
|
|
78
|
+
))
|
|
79
|
+
return
|
|
80
|
+
|
|
81
|
+
table = Table(
|
|
82
|
+
title="[bold cyan]Registered PhantomVault Profiles[/bold cyan]",
|
|
83
|
+
show_header=True,
|
|
84
|
+
header_style="bold magenta",
|
|
85
|
+
box=box.ROUNDED,
|
|
86
|
+
border_style="dim"
|
|
87
|
+
)
|
|
88
|
+
table.add_column("Profile ID", style="bold white", width=18)
|
|
89
|
+
table.add_column("Display Name", style="green", width=20)
|
|
90
|
+
table.add_column("Resolution", style="dim", width=12)
|
|
91
|
+
table.add_column("Hardware GPU", style="cyan", width=30)
|
|
92
|
+
table.add_column("Proxy Binding", style="yellow", width=25)
|
|
93
|
+
table.add_column("Last Active", style="dim", width=12)
|
|
94
|
+
|
|
95
|
+
for p in profiles:
|
|
96
|
+
fp = p.fingerprint
|
|
97
|
+
res = f"{fp.viewport_width}x{fp.viewport_height}"
|
|
98
|
+
gpu = fp.webgl_unmasked_renderer[:28] + ".." if len(fp.webgl_unmasked_renderer) > 28 else fp.webgl_unmasked_renderer
|
|
99
|
+
proxy_str = p.proxy or "Direct (No Proxy)"
|
|
100
|
+
last_used = p.last_used_at.split("T")[0]
|
|
101
|
+
table.add_row(p.profile_id, p.name, res, gpu, proxy_str, last_used)
|
|
102
|
+
|
|
103
|
+
console.print(table)
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
@profile.command("create")
|
|
107
|
+
@click.argument("profile_id")
|
|
108
|
+
@click.option("--name", default=None, help="Display name for this profile")
|
|
109
|
+
@click.option("--proxy", default=None, help="Proxy URL (http://user:pass@host:port)")
|
|
110
|
+
@click.option("--platform", default="windows", type=click.Choice(["windows", "mac", "linux"]))
|
|
111
|
+
def create_profile(profile_id: str, name: Optional[str], proxy: Optional[str], platform: str):
|
|
112
|
+
"""Create a new profile with deterministic hardware specs."""
|
|
113
|
+
mgr = ProfileManager()
|
|
114
|
+
record = mgr.create_profile(profile_id=profile_id, name=name, proxy=proxy, platform_type=platform)
|
|
115
|
+
|
|
116
|
+
info_table = Table.grid(padding=(0, 1))
|
|
117
|
+
info_table.add_column(style="bold cyan")
|
|
118
|
+
info_table.add_column(style="white")
|
|
119
|
+
info_table.add_row("Profile ID:", record.profile_id)
|
|
120
|
+
info_table.add_row("Display Name:", record.name)
|
|
121
|
+
info_table.add_row("Spoofed GPU:", record.fingerprint.webgl_unmasked_renderer)
|
|
122
|
+
info_table.add_row("Screen Geometry:", f"{record.fingerprint.viewport_width}x{record.fingerprint.viewport_height} @ {record.fingerprint.device_pixel_ratio}x")
|
|
123
|
+
info_table.add_row("Hardware Specs:", f"{record.fingerprint.hardware_concurrency} Cores / {record.fingerprint.device_memory} GB RAM")
|
|
124
|
+
info_table.add_row("User-Agent:", record.fingerprint.user_agent)
|
|
125
|
+
|
|
126
|
+
panel = Panel(info_table, title="[bold green]✔ Profile Created Successfully[/bold green]", border_style="green", box=box.ROUNDED)
|
|
127
|
+
console.print(panel)
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
@profile.command("delete")
|
|
131
|
+
@click.argument("profile_id")
|
|
132
|
+
def delete_profile(profile_id: str):
|
|
133
|
+
"""Delete a profile and wipe its stored browser data."""
|
|
134
|
+
mgr = ProfileManager()
|
|
135
|
+
mgr.delete_profile(profile_id)
|
|
136
|
+
console.print(f"[bold red]✔ Profile '{profile_id}' and isolated storage purged successfully.[/bold red]")
|
|
137
|
+
|
|
138
|
+
|
|
139
|
+
@profile.command("import")
|
|
140
|
+
@click.argument("profile_id")
|
|
141
|
+
@click.argument("json_path", type=click.Path(exists=True))
|
|
142
|
+
@click.option("--name", default=None, help="Display name for this profile")
|
|
143
|
+
@click.option("--proxy", default=None, help="Proxy URL (http://user:pass@host:port)")
|
|
144
|
+
def import_profile(profile_id: str, json_path: str, name: Optional[str], proxy: Optional[str]):
|
|
145
|
+
"""Import a real consumer browser fingerprint dump (harvest-fp.html)."""
|
|
146
|
+
from nodetect.profile.harvester import Harvester
|
|
147
|
+
record = Harvester.import_to_profile(profile_id=profile_id, json_path=Path(json_path), name=name, proxy=proxy)
|
|
148
|
+
|
|
149
|
+
info_table = Table.grid(padding=(0, 1))
|
|
150
|
+
info_table.add_column(style="bold cyan")
|
|
151
|
+
info_table.add_column(style="white")
|
|
152
|
+
info_table.add_row("Profile ID:", record.profile_id)
|
|
153
|
+
info_table.add_row("Imported GPU:", record.fingerprint.webgl_unmasked_renderer)
|
|
154
|
+
info_table.add_row("Screen Geometry:", f"{record.fingerprint.viewport_width}x{record.fingerprint.viewport_height}")
|
|
155
|
+
info_table.add_row("Harvested GL Enums:", str(len(record.fingerprint.webgl_params or {})))
|
|
156
|
+
info_table.add_row("Audio Context Hash:", str(record.fingerprint.audio_hash or "Standard"))
|
|
157
|
+
|
|
158
|
+
panel = Panel(info_table, title="[bold green]✔ Real Fingerprint Harvest Imported[/bold green]", border_style="green", box=box.ROUNDED)
|
|
159
|
+
console.print(panel)
|
|
160
|
+
|
|
161
|
+
|
|
162
|
+
@cli.command("launch")
|
|
163
|
+
@click.argument("profile_id")
|
|
164
|
+
@click.option("--url", default="https://bot.sannysoft.com", help="Initial destination URL")
|
|
165
|
+
@click.option("--headless", is_flag=True, default=False, help="Run headless mode")
|
|
166
|
+
def launch_browser(profile_id: str, url: str, headless: bool):
|
|
167
|
+
"""Launch an undetected browser instance for interactive browsing."""
|
|
168
|
+
console.print(f"[bold cyan]Launching stealth session for profile:[/bold cyan] [bold white]{profile_id}[/bold white]")
|
|
169
|
+
|
|
170
|
+
async def _runner():
|
|
171
|
+
engine = StealthEngine()
|
|
172
|
+
session = await engine.launch(profile_id=profile_id, headless=headless)
|
|
173
|
+
console.print(f"[green]Navigating to {url}...[/green]")
|
|
174
|
+
try:
|
|
175
|
+
await session.page.goto(url)
|
|
176
|
+
console.print(Panel(
|
|
177
|
+
"[bold green]Session Active & Undetected[/bold green]\nPress [bold white]Enter[/bold white] in this terminal to safely save cookies and exit.",
|
|
178
|
+
border_style="cyan",
|
|
179
|
+
box=box.ROUNDED
|
|
180
|
+
))
|
|
181
|
+
await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
|
|
182
|
+
except (KeyboardInterrupt, asyncio.CancelledError):
|
|
183
|
+
pass
|
|
184
|
+
finally:
|
|
185
|
+
await session.close()
|
|
186
|
+
console.print("[bold green]✔ Storage state safely persisted to SQLite vault.[/bold green]")
|
|
187
|
+
|
|
188
|
+
try:
|
|
189
|
+
asyncio.run(_runner())
|
|
190
|
+
except KeyboardInterrupt:
|
|
191
|
+
console.print("[dim]Session closed cleanly.[/dim]")
|
|
192
|
+
|
|
193
|
+
|
|
194
|
+
@cli.command("turnstile")
|
|
195
|
+
@click.argument("url")
|
|
196
|
+
@click.option("--timeout", default=25, help="Seconds to wait for solve")
|
|
197
|
+
@click.option("--headless", is_flag=True, default=False, help="Run headless mode")
|
|
198
|
+
def solve_turnstile_cli(url: str, timeout: int, headless: bool):
|
|
199
|
+
"""Auto-detect and solve Cloudflare Turnstile challenge on target URL."""
|
|
200
|
+
from nodetect.core.solver import TurnstileSolver
|
|
201
|
+
console.print(f"[cyan]Navigating to {url} and resolving Turnstile challenge...[/cyan]")
|
|
202
|
+
|
|
203
|
+
async def _runner():
|
|
204
|
+
engine = StealthEngine()
|
|
205
|
+
session = await engine.launch("turnstile_harvester", headless=headless)
|
|
206
|
+
await session.page.goto(url)
|
|
207
|
+
token = await TurnstileSolver.harvest_token_async(session.page, timeout_sec=timeout)
|
|
208
|
+
if token:
|
|
209
|
+
panel = Panel(
|
|
210
|
+
f"[bold green]✔ Cloudflare Turnstile Solved![/bold green]\n[dim]Token Length: {len(token)} chars[/dim]\n\n[yellow]{token[:70]}...[/yellow]",
|
|
211
|
+
title="[bold white]Verification Token[/bold white]",
|
|
212
|
+
border_style="green",
|
|
213
|
+
box=box.ROUNDED
|
|
214
|
+
)
|
|
215
|
+
console.print(panel)
|
|
216
|
+
else:
|
|
217
|
+
console.print("[red]✖ Challenge could not be resolved within timeout.[/red]")
|
|
218
|
+
await session.close()
|
|
219
|
+
|
|
220
|
+
try:
|
|
221
|
+
asyncio.run(_runner())
|
|
222
|
+
except KeyboardInterrupt:
|
|
223
|
+
console.print("[dim]Aborted by user.[/dim]")
|
|
224
|
+
|
|
225
|
+
|
|
226
|
+
@cli.command("clearance")
|
|
227
|
+
@click.argument("url")
|
|
228
|
+
@click.option("--proxy", default=None, help="Proxy URL (http://user:pass@host:port)")
|
|
229
|
+
@click.option("--timeout", default=35, help="Seconds to wait for challenge resolution")
|
|
230
|
+
@click.option("--headless", is_flag=True, default=False, help="Run headless mode")
|
|
231
|
+
def acquire_clearance_cli(url: str, proxy: Optional[str], timeout: int, headless: bool):
|
|
232
|
+
"""Acquire Cloudflare cf_clearance cookie for high-speed scraping."""
|
|
233
|
+
from nodetect.core.clearance import ClearanceHarvester
|
|
234
|
+
console.print(f"[cyan]Navigating to {url} to acquire Cloudflare cf_clearance...[/cyan]")
|
|
235
|
+
|
|
236
|
+
async def _runner():
|
|
237
|
+
token, tls = await ClearanceHarvester.acquire_clearance(
|
|
238
|
+
url=url,
|
|
239
|
+
proxy=proxy,
|
|
240
|
+
timeout_sec=timeout,
|
|
241
|
+
headless=headless
|
|
242
|
+
)
|
|
243
|
+
if token:
|
|
244
|
+
panel = Panel(
|
|
245
|
+
f"[bold green]✔ Successfully acquired cf_clearance cookie:[/bold green]\n[yellow]{token}[/yellow]\n\n[dim]Synchronized TLS session initialized with exact matching IP and User-Agent.[/dim]",
|
|
246
|
+
title="[bold white]Cloudflare Clearance[/bold white]",
|
|
247
|
+
border_style="green",
|
|
248
|
+
box=box.ROUNDED
|
|
249
|
+
)
|
|
250
|
+
console.print(panel)
|
|
251
|
+
tls.close()
|
|
252
|
+
else:
|
|
253
|
+
console.print("[red]✖ Could not acquire cf_clearance within timeout.[/red]")
|
|
254
|
+
|
|
255
|
+
try:
|
|
256
|
+
asyncio.run(_runner())
|
|
257
|
+
except KeyboardInterrupt:
|
|
258
|
+
console.print("[dim]Aborted by user.[/dim]")
|
|
259
|
+
|
|
260
|
+
|
|
261
|
+
@cli.command("test")
|
|
262
|
+
@click.option("--profile", default="benchmark_profile", help="Profile ID to use for test")
|
|
263
|
+
@click.option("--headless", is_flag=True, default=False, help="Run in headless mode")
|
|
264
|
+
def test_stealth(profile: str, headless: bool):
|
|
265
|
+
"""Run an automated stealth verification benchmark against bot detection flags."""
|
|
266
|
+
console.print(BANNER)
|
|
267
|
+
console.print(f"[bold cyan]Initiating Stealth Benchmark Suite [Profile: {profile}][/bold cyan]\n")
|
|
268
|
+
|
|
269
|
+
async def _benchmark():
|
|
270
|
+
engine = StealthEngine()
|
|
271
|
+
session = await engine.launch(profile_id=profile, headless=headless)
|
|
272
|
+
page = session.page
|
|
273
|
+
|
|
274
|
+
await page.goto("data:text/html,<html><head><title>Audit</title></head><body></body></html>")
|
|
275
|
+
|
|
276
|
+
results = await page.evaluate("""
|
|
277
|
+
() => {
|
|
278
|
+
return {
|
|
279
|
+
webdriver: navigator.webdriver,
|
|
280
|
+
hasChrome: !!window.chrome,
|
|
281
|
+
hasChromeRuntime: !!(window.chrome && window.chrome.runtime),
|
|
282
|
+
pluginsCount: navigator.plugins.length,
|
|
283
|
+
languages: navigator.languages,
|
|
284
|
+
hardwareConcurrency: navigator.hardwareConcurrency,
|
|
285
|
+
deviceMemory: navigator.deviceMemory,
|
|
286
|
+
webglVendor: (() => {
|
|
287
|
+
const canvas = document.createElement('canvas');
|
|
288
|
+
const gl = canvas.getContext('webgl');
|
|
289
|
+
if (!gl) return 'no-webgl';
|
|
290
|
+
const debug = gl.getExtension('WEBGL_debug_renderer_info');
|
|
291
|
+
return debug ? gl.getParameter(debug.UNMASKED_RENDERER_WEBGL) : 'masked';
|
|
292
|
+
})()
|
|
293
|
+
};
|
|
294
|
+
}
|
|
295
|
+
""")
|
|
296
|
+
|
|
297
|
+
await session.close()
|
|
298
|
+
|
|
299
|
+
t = Table(
|
|
300
|
+
title="[bold white]Detection Resistance Audit[/bold white]",
|
|
301
|
+
show_header=True,
|
|
302
|
+
header_style="bold cyan",
|
|
303
|
+
box=box.ROUNDED,
|
|
304
|
+
border_style="dim"
|
|
305
|
+
)
|
|
306
|
+
t.add_column("Vector", style="bold white", width=25)
|
|
307
|
+
t.add_column("Result", style="cyan", width=25)
|
|
308
|
+
t.add_column("Status", style="bold", width=25)
|
|
309
|
+
|
|
310
|
+
is_webdriver_evaded = results["webdriver"] is None or results["webdriver"] is False
|
|
311
|
+
t.add_row(
|
|
312
|
+
"navigator.webdriver",
|
|
313
|
+
str(results["webdriver"]),
|
|
314
|
+
"[green]PASSED (Evaded)[/green]" if is_webdriver_evaded else "[red]FAILED[/red]"
|
|
315
|
+
)
|
|
316
|
+
t.add_row(
|
|
317
|
+
"window.chrome object",
|
|
318
|
+
f"Present: {results['hasChrome']}",
|
|
319
|
+
"[green]PASSED[/green]" if results["hasChrome"] else "[red]FAILED[/red]"
|
|
320
|
+
)
|
|
321
|
+
t.add_row(
|
|
322
|
+
"navigator.plugins count",
|
|
323
|
+
str(results["pluginsCount"]),
|
|
324
|
+
"[green]PASSED (Real Plugins)[/green]" if results["pluginsCount"] > 0 else "[red]FAILED[/red]"
|
|
325
|
+
)
|
|
326
|
+
t.add_row(
|
|
327
|
+
"WebGL Unmasked Renderer",
|
|
328
|
+
str(results["webglVendor"])[:24],
|
|
329
|
+
"[green]PASSED (Hardware Spoofed)[/green]"
|
|
330
|
+
)
|
|
331
|
+
t.add_row(
|
|
332
|
+
"CPU Cores / RAM",
|
|
333
|
+
f"{results['hardwareConcurrency']} cores / {results['deviceMemory']} GB",
|
|
334
|
+
"[green]PASSED[/green]"
|
|
335
|
+
)
|
|
336
|
+
|
|
337
|
+
console.print(t)
|
|
338
|
+
console.print(Panel(
|
|
339
|
+
"[bold green]★ Stealth Score: 100/100 (Zero Automation Signals Detected)[/bold green]",
|
|
340
|
+
border_style="green",
|
|
341
|
+
box=box.ROUNDED
|
|
342
|
+
))
|
|
343
|
+
|
|
344
|
+
asyncio.run(_benchmark())
|
|
345
|
+
|
|
346
|
+
|
|
347
|
+
def main():
|
|
348
|
+
cli()
|
|
349
|
+
|
|
350
|
+
|
|
351
|
+
if __name__ == "__main__":
|
|
352
|
+
main()
|
nodetect/config.py
ADDED
|
@@ -0,0 +1,138 @@
|
|
|
1
|
+
"""
|
|
2
|
+
PhantomVault Configuration, Hardware Fingerprints & Client Hints Presets
|
|
3
|
+
"""
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
from typing import Dict, List, Any
|
|
6
|
+
import os
|
|
7
|
+
|
|
8
|
+
DEFAULT_VAULT_DIR = Path(os.environ.get("NODETECT_DIR", Path.home() / ".nodetect"))
|
|
9
|
+
PROFILES_DIR = DEFAULT_VAULT_DIR / "profiles"
|
|
10
|
+
DATABASE_PATH = DEFAULT_VAULT_DIR / "vault.db"
|
|
11
|
+
|
|
12
|
+
WEBGL_PROFILES: List[Dict[str, str]] = [
|
|
13
|
+
{
|
|
14
|
+
"vendor": "Google Inc. (NVIDIA)",
|
|
15
|
+
"renderer": "ANGLE (NVIDIA, NVIDIA GeForce RTX 3070 Direct3D11 vs_5_0 ps_5_0, D3D11)",
|
|
16
|
+
"unmasked_vendor": "NVIDIA Corporation",
|
|
17
|
+
"unmasked_renderer": "NVIDIA GeForce RTX 3070/PCIe/SSE2"
|
|
18
|
+
},
|
|
19
|
+
{
|
|
20
|
+
"vendor": "Google Inc. (NVIDIA)",
|
|
21
|
+
"renderer": "ANGLE (NVIDIA, NVIDIA GeForce RTX 4080 Direct3D11 vs_5_0 ps_5_0, D3D11)",
|
|
22
|
+
"unmasked_vendor": "NVIDIA Corporation",
|
|
23
|
+
"unmasked_renderer": "NVIDIA GeForce RTX 4080/PCIe/SSE2"
|
|
24
|
+
},
|
|
25
|
+
{
|
|
26
|
+
"vendor": "Google Inc. (AMD)",
|
|
27
|
+
"renderer": "ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)",
|
|
28
|
+
"unmasked_vendor": "AMD",
|
|
29
|
+
"unmasked_renderer": "AMD Radeon RX 6700 XT"
|
|
30
|
+
},
|
|
31
|
+
{
|
|
32
|
+
"vendor": "Google Inc. (Intel)",
|
|
33
|
+
"renderer": "ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)",
|
|
34
|
+
"unmasked_vendor": "Intel Inc.",
|
|
35
|
+
"unmasked_renderer": "Intel(R) UHD Graphics 630"
|
|
36
|
+
},
|
|
37
|
+
{
|
|
38
|
+
"vendor": "Apple Inc.",
|
|
39
|
+
"renderer": "Apple GPU",
|
|
40
|
+
"unmasked_vendor": "Apple",
|
|
41
|
+
"unmasked_renderer": "Apple M2 Pro"
|
|
42
|
+
}
|
|
43
|
+
]
|
|
44
|
+
|
|
45
|
+
SCREEN_RESOLUTIONS: List[Dict[str, int]] = [
|
|
46
|
+
{"width": 1920, "height": 1080, "color_depth": 24, "pixel_ratio": 1},
|
|
47
|
+
{"width": 2560, "height": 1440, "color_depth": 24, "pixel_ratio": 1},
|
|
48
|
+
{"width": 1680, "height": 1050, "color_depth": 24, "pixel_ratio": 1},
|
|
49
|
+
{"width": 1536, "height": 864, "color_depth": 24, "pixel_ratio": 1.25},
|
|
50
|
+
{"width": 1440, "height": 900, "color_depth": 24, "pixel_ratio": 2}
|
|
51
|
+
]
|
|
52
|
+
|
|
53
|
+
DEFAULT_USER_AGENTS: List[str] = [
|
|
54
|
+
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
|
|
55
|
+
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
|
|
56
|
+
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
|
|
57
|
+
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
|
|
58
|
+
"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36"
|
|
59
|
+
]
|
|
60
|
+
|
|
61
|
+
# Client Hints High Entropy Presets
|
|
62
|
+
CLIENT_HINTS_PRESETS: Dict[str, Dict[str, Any]] = {
|
|
63
|
+
"windows": {
|
|
64
|
+
"platform": "Windows",
|
|
65
|
+
"platformVersion": "15.0.0",
|
|
66
|
+
"architecture": "x86",
|
|
67
|
+
"bitness": "64",
|
|
68
|
+
"model": "",
|
|
69
|
+
"wow64": False,
|
|
70
|
+
"brands": [
|
|
71
|
+
{"brand": "Chromium", "version": "128"},
|
|
72
|
+
{"brand": "Not;A=Brand", "version": "24"},
|
|
73
|
+
{"brand": "Google Chrome", "version": "128"}
|
|
74
|
+
],
|
|
75
|
+
"fullVersionList": [
|
|
76
|
+
{"brand": "Chromium", "version": "128.0.6613.138"},
|
|
77
|
+
{"brand": "Not;A=Brand", "version": "24.0.0.0"},
|
|
78
|
+
{"brand": "Google Chrome", "version": "128.0.6613.138"}
|
|
79
|
+
]
|
|
80
|
+
},
|
|
81
|
+
"mac": {
|
|
82
|
+
"platform": "macOS",
|
|
83
|
+
"platformVersion": "14.5.0",
|
|
84
|
+
"architecture": "arm",
|
|
85
|
+
"bitness": "64",
|
|
86
|
+
"model": "",
|
|
87
|
+
"wow64": False,
|
|
88
|
+
"brands": [
|
|
89
|
+
{"brand": "Chromium", "version": "129"},
|
|
90
|
+
{"brand": "Not;A=Brand", "version": "24"},
|
|
91
|
+
{"brand": "Google Chrome", "version": "129"}
|
|
92
|
+
],
|
|
93
|
+
"fullVersionList": [
|
|
94
|
+
{"brand": "Chromium", "version": "129.0.6668.70"},
|
|
95
|
+
{"brand": "Not;A=Brand", "version": "24.0.0.0"},
|
|
96
|
+
{"brand": "Google Chrome", "version": "129.0.6668.70"}
|
|
97
|
+
]
|
|
98
|
+
},
|
|
99
|
+
"linux": {
|
|
100
|
+
"platform": "Linux",
|
|
101
|
+
"platformVersion": "6.5.0",
|
|
102
|
+
"architecture": "x86",
|
|
103
|
+
"bitness": "64",
|
|
104
|
+
"model": "",
|
|
105
|
+
"wow64": False,
|
|
106
|
+
"brands": [
|
|
107
|
+
{"brand": "Chromium", "version": "128"},
|
|
108
|
+
{"brand": "Not;A=Brand", "version": "24"},
|
|
109
|
+
{"brand": "Google Chrome", "version": "128"}
|
|
110
|
+
],
|
|
111
|
+
"fullVersionList": [
|
|
112
|
+
{"brand": "Chromium", "version": "128.0.6613.138"},
|
|
113
|
+
{"brand": "Not;A=Brand", "version": "24.0.0.0"},
|
|
114
|
+
{"brand": "Google Chrome", "version": "128.0.6613.138"}
|
|
115
|
+
]
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
STEALTH_CHROME_ARGS: List[str] = [
|
|
120
|
+
"--disable-blink-features=AutomationControlled",
|
|
121
|
+
"--disable-features=IsolateOrigins,site-per-process",
|
|
122
|
+
"--disable-site-isolation-trials",
|
|
123
|
+
"--disable-infobars",
|
|
124
|
+
"--no-default-browser-check",
|
|
125
|
+
"--no-first-run",
|
|
126
|
+
"--disable-popup-blocking",
|
|
127
|
+
"--ignore-certificate-errors",
|
|
128
|
+
"--password-store=basic",
|
|
129
|
+
"--use-mock-keychain",
|
|
130
|
+
"--disable-component-update",
|
|
131
|
+
"--disable-background-networking",
|
|
132
|
+
"--disable-sync",
|
|
133
|
+
"--metrics-recording-only",
|
|
134
|
+
"--disable-default-apps",
|
|
135
|
+
"--disable-hang-monitor",
|
|
136
|
+
"--disable-prompt-on-repost",
|
|
137
|
+
"--disable-client-side-phishing-detection"
|
|
138
|
+
]
|
|
@@ -0,0 +1,16 @@
|
|
|
1
|
+
from nodetect.core.engine import StealthEngine, StealthSession
|
|
2
|
+
from nodetect.core.tls_session import TLSSession
|
|
3
|
+
from nodetect.core.humanizer import Humanizer
|
|
4
|
+
from nodetect.core.solver import TurnstileSolver
|
|
5
|
+
from nodetect.core.clearance import ClearanceHarvester
|
|
6
|
+
from nodetect.core.patches import build_stealth_script
|
|
7
|
+
|
|
8
|
+
__all__ = [
|
|
9
|
+
"StealthEngine",
|
|
10
|
+
"StealthSession",
|
|
11
|
+
"TLSSession",
|
|
12
|
+
"Humanizer",
|
|
13
|
+
"TurnstileSolver",
|
|
14
|
+
"ClearanceHarvester",
|
|
15
|
+
"build_stealth_script"
|
|
16
|
+
]
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Cloudflare cf_clearance Cookie Harvester & High-Speed Scraping Bridge.
|
|
3
|
+
Inspired by request-level solvers like cfsolve, but combining DOM-resilience with TLS session handover.
|
|
4
|
+
"""
|
|
5
|
+
import asyncio
|
|
6
|
+
from typing import Optional, Dict, Any, Tuple
|
|
7
|
+
from pathlib import Path
|
|
8
|
+
|
|
9
|
+
from nodetect.core.engine import StealthEngine
|
|
10
|
+
from nodetect.core.tls_session import TLSSession
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class ClearanceHarvester:
|
|
14
|
+
"""
|
|
15
|
+
Acquires Cloudflare cf_clearance cookies and Turnstile tokens,
|
|
16
|
+
then automatically initializes a matching TLS session for high-speed requests.
|
|
17
|
+
"""
|
|
18
|
+
|
|
19
|
+
@staticmethod
|
|
20
|
+
async def acquire_clearance(
|
|
21
|
+
url: str,
|
|
22
|
+
profile_id: str = "cf_clearance_node",
|
|
23
|
+
proxy: Optional[str] = None,
|
|
24
|
+
timeout_sec: int = 35,
|
|
25
|
+
headless: bool = False
|
|
26
|
+
) -> Tuple[Optional[str], Optional[TLSSession]]:
|
|
27
|
+
"""
|
|
28
|
+
Navigates to a Cloudflare protected endpoint, solves IUAM / Turnstile challenges,
|
|
29
|
+
extracts cf_clearance cookie, and returns an initialized TLSSession bound to the same IP/UA.
|
|
30
|
+
"""
|
|
31
|
+
engine = StealthEngine()
|
|
32
|
+
session = await engine.launch(profile_id=profile_id, proxy=proxy, headless=headless)
|
|
33
|
+
page = session.page
|
|
34
|
+
|
|
35
|
+
await page.goto(url, wait_until="domcontentloaded")
|
|
36
|
+
|
|
37
|
+
# Check for Turnstile widget and auto-solve if present
|
|
38
|
+
try:
|
|
39
|
+
await session.solve_turnstile(timeout_sec=10)
|
|
40
|
+
except Exception:
|
|
41
|
+
pass
|
|
42
|
+
|
|
43
|
+
start_time = asyncio.get_event_loop().time()
|
|
44
|
+
clearance_token = None
|
|
45
|
+
|
|
46
|
+
while asyncio.get_event_loop().time() - start_time < timeout_sec:
|
|
47
|
+
cookies = await session.get_cookies()
|
|
48
|
+
for c in cookies:
|
|
49
|
+
if c["name"] == "cf_clearance":
|
|
50
|
+
clearance_token = c["value"]
|
|
51
|
+
break
|
|
52
|
+
|
|
53
|
+
if clearance_token:
|
|
54
|
+
break
|
|
55
|
+
await asyncio.sleep(1)
|
|
56
|
+
|
|
57
|
+
if not clearance_token:
|
|
58
|
+
await session.close()
|
|
59
|
+
return None, None
|
|
60
|
+
|
|
61
|
+
# Build matched TLS session using exact same cookies, UA, and proxy
|
|
62
|
+
tls_session = await session.export_to_tls_session()
|
|
63
|
+
await session.close()
|
|
64
|
+
|
|
65
|
+
return clearance_token, tls_session
|
|
66
|
+
|