Back to skill

Security audit

Web Freedom Toolkit

Security checks for vulnerabilities and agentic risk

Overview

This skill is a high-risk browser evasion and takeover toolkit whose sensitive capabilities are partly disclosed but overbroad and weakly controlled.

Install only if you explicitly need authorized anti-bot/browser automation research and can run it in a disposable, isolated container or VM with no sensitive environment variables, no logged-in browser profile, and restricted outbound/internal network access. Treat the DevTools relay, no-sandbox browser mode, and takeover scripts as high-risk review items rather than ordinary browsing helpers.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (6)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/freedom_engine.py:21
Finding
Unrestricted User-Controlled URL Fetching Enables Server-Side Request Forgery<![CDATA[ ## Vulnerability Details **File Location**: `scripts/freedom_engine.py:21-45, 70` **Vulnerability Type**: Server-Side Request Forgery (SSRF) **Risk Level**: High ### Vulnerable Code ```python def quick_fetch(self, url): """Ultra-fast stealth fetch using Scrapling (SOTA 2026).""" print(f"[Freedom] Executing Scrapling Stealth Fetch: {url}") try: fetcher = Fetcher(auto_match=True) response = fetcher.get(url) return { "status": "success", "mode": "scrapling", "title": response.title, "text": response.text[:2000] } except Exception as e: print(f"[Freedom] Scrapling failed, falling back to CFFI: {e}") return self.impersonate_fetch(url) def impersonate_fetch(self, url): """Kernel-level TLS impersonation using curl_cffi.""" print(f"[Freedom] Executing CFFI Impersonation: {url}") try: r = requests_cffi.get(url, impersonate="chrome124", timeout=20) return { "status": "success", "mode": "cffi", "status_code": r.status_code, "text": r.text[:2000] } ``` ```python target = sys.argv[1] if len(sys.argv) > 1 else "https://example.com" engine = FreedomEngine() print(json.dumps(engine.quick_fetch(target), indent=2, ensure_ascii=False)) ``` ### Technical Analysis The command-line argument is passed directly to two network clients without validating the URL scheme, destination hostname, resolved IP address, port, or redirect chain. No control prevents requests to loopback, link-local, private, or otherwise reserved networks. The fallback does not provide a security boundary: if Scrapling fails, `curl_cffi` repeats the request to the same untrusted destination. Successful responses expose up to 2,000 characters through the process output. The declared web-retrieval functionality requires outbound access to user-selected public websites, but it does not require access to int ...[truncated 1268 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Permit only explicitly supported schemes, normally `https`. 2. Parse URLs with a standards-compliant parser and reject embedded credentials, malformed hosts, unsupported ports, and ambiguous numeric IP representations. 3. Resolve every hostname before connecting and reject all loopback, private, link-local, multicast, unspecified, and reserved addresses for both IPv4 and IPv6. 4. Disable redirects or revalidate the destination after every redirect. 5. Prefer an explicit hostname allowlist where the intended destinations are known. 6. Apply outbound firewall or proxy controls so application validation is not the only boundary. 7. Use a dedicated low-privilege network worker with no access to cloud metadata or internal control-plane services. 8. Avoid returning arbitrary response bodies unless required; enforce strict response-size and content-type limits. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/freedom_engine.py:49
Finding
Chromium Security Sandbox Is Explicitly Disabled for Untrusted Web Content<![CDATA[ ## Vulnerability Details **File Location**: `scripts/freedom_engine.py:49-53`; `scripts/drission_util.py:20-30` **Vulnerability Type**: Unsafe browser execution configuration **Risk Level**: High ### Vulnerable Code ```python def deep_interact(self, url): """Full browser interaction (D-Mode) for complex JS/WAF.""" print(f"[Freedom] Launching Full Browser (D-Mode): {url}") co = ChromiumOptions().set_argument('--no-sandbox').set_argument('--headless=new') if self.browser_path: co.set_browser_path(self.browser_path) ``` ```python def get_drission_page(headless=True): co = ChromiumOptions() co.set_argument('--no-sandbox') if headless: co.set_argument('--headless=new') path = get_browser_path() if path: co.set_browser_path(path) # Force IPv4 to avoid handshake 404 ghost co.set_address('127.0.0.1:9222') return ChromiumPage(co) ``` ### Technical Analysis The `--no-sandbox` argument disables Chromium’s process and operating-system sandbox protections. Browser sandboxing is a critical defense-in-depth boundary when processing JavaScript, HTML, media, fonts, and other attacker-controlled web content. The documented functionality accepts arbitrary target websites. Consequently, remote content is processed in a browser configured to run without its normal containment boundary. Headless operation does not compensate for the missing sandbox. The project documentation states that hardened gating applies to Tier 3 interactions, but `deep_interact()` itself performs no authorization check. Disabling the sandbox is not a minimum privilege required for ordinary browser automation. ### Attack Path 1. A caller causes the Skill to open an attacker-controlled or compromised website in D-Mode. 2. The page delivers content targeting a vulnerability in the installed Chromium version. 3. Chromium processes that content while running with `--no-sandbox`. 4. A successful browser exploit executes with the operating-system p ...[truncated 813 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove `--no-sandbox` from all browser configurations. 2. Fail closed if Chromium cannot initialize its sandbox rather than silently degrading security. 3. Run browser automation as a dedicated unprivileged operating-system user. 4. Place Chromium in a separately hardened container or VM with a read-only filesystem, dropped Linux capabilities, resource limits, and restricted outbound networking. 5. Use an ephemeral browser profile for each operation and delete it when the operation finishes. 6. Keep Chromium pinned to a supported version and apply security updates promptly. 7. Add explicit authorization and URL validation before invoking Tier 3 browser interactions. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/python_relay.py:60
Finding
Unauthenticated Local TCP Relay Exposes Chromium DevTools Control<![CDATA[ ## Vulnerability Details **File Location**: `scripts/python_relay.py:60-89` **Vulnerability Type**: Unauthenticated privileged browser-control relay **Risk Level**: High ### Vulnerable Code ```python def start(self, local_port, remote_port): print(f"--- [SOTA SECURE TUNNEL] 127.0.0.1:{local_port} -> 127.0.0.1:{remote_port} ---") server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # CRITICAL: Set timeout so accept() doesn't block forever server.settimeout(5.0) try: server.bind(('127.0.0.1', local_port)) server.listen(5) except Exception as e: print(f"Failed to bind port {local_port}: {e}") return start_time = time.time() threading.Thread(target=self.monitor, args=(start_time,), daemon=True).start() while self.running: try: client_sock, addr = server.accept() self.last_activity = time.time() try: target_sock = socket.create_connection(('127.0.0.1', remote_port), timeout=5) threading.Thread(target=self.pipe, args=(client_sock, target_sock), daemon=True).start() threading.Thread(target=self.pipe, args=(target_sock, client_sock), daemon=True).start() ``` The default execution path exposes the predictable ports: ```python if __name__ == "__main__": SecureRelay().start(9223, 9222) ``` ### Technical Analysis Binding to `127.0.0.1` correctly prevents direct remote access, but it does not authenticate local clients. Every process that can connect to local TCP port 9223 receives bidirectional access to Chromium’s debugging endpoint on port 9222. Chromium DevTools Protocol access is effectively equivalent to control of the attached browser session. A client can discover the debugger WebSocket URL and submit commands to navigate pages, evaluate JavaScript, inspect DOM data, and access browser state. The idle timeout and ...[truncated 1355 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not expose Chromium DevTools through an unauthenticated TCP relay. 2. Prefer an operation-scoped Unix domain socket with mode `0600`. 3. Verify peer credentials using the platform’s Unix-socket credential mechanism. 4. Require a cryptographically random, single-use capability bound to one exact browser operation. 5. Use an unpredictable browser-debugging endpoint and an isolated ephemeral browser profile. 6. Limit the accepted CDP command set rather than forwarding arbitrary byte streams. 7. Accept only one authorized connection and terminate the relay immediately afterward. 8. Place the browser and controller in an isolated container or namespace inaccessible to unrelated local processes. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/sota_core.py:10
Finding
High-Privilege Browser Operations Rely on Forgeable Authorization Gates<![CDATA[ ## Vulnerability Details **File Location**: `scripts/sota_core.py:10-28`; `scripts/secure_wrapper.py:14-32`; `scripts/sota_security.py:6-18`; `scripts/nuclear_option.py:10-18` **Vulnerability Type**: Broken authorization and ineffective human-presence verification **Risk Level**: High ### Vulnerable Code The Unix-socket client sends a constant public request and accepts a constant response: ```python def verify_uds_handshake(): socket_path = "/tmp/.sota_auth.sock" if not os.path.exists(socket_path): print("!!! [SECURITY ABORT] No active authentication channel.") sys.exit(1) try: with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client: client.settimeout(2) client.connect(socket_path) # Send readiness probe client.sendall(b"AUTH_REQUEST") response = client.recv(1024) if response != b"AUTH_GRANTED": print("!!! [SECURITY] Identity verification failed.") sys.exit(1) except: sys.exit(1) ``` The wrapper prints a four-digit value and asks the same caller to repeat it: ```python socket_path = "/tmp/.sota_auth.sock" # Clean up stale sockets if os.path.exists(socket_path): os.remove(socket_path) # 1. Human Challenge secret = str(random.randint(1000, 9999)) print(f"\n[MANDATORY AUTH] Challenge: {secret}") try: user_input = input(">> ").strip() if user_input != secret: print("Auth Failed.") return # 2. Start Memory-only Auth Socket with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as server: server.bind(socket_path) os.chmod(socket_path, 0o600) ``` The lockfile gate checks only existence and modification time: ```python def verify_access_control(): token_path = os.path.join(os.path.expanduser("~"), ".openclaw/tmp/sota_active.lock") if not os.path.exists(token_path): print("!!! Access denied. Mandatory human authorization requir ...[truncated 2665 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Obtain approval through a trusted platform UI or supervisor outside the Skill process. 2. Bind each approval to the exact script, target, browser profile, and requested operation. 3. Use cryptographically secure, high-entropy, single-use capabilities rather than `random.randint()`. 4. Never print the authorization secret to a channel readable by the process requesting approval. 5. Verify Unix peer credentials and restrict the socket directory and socket to the intended user. 6. Place sockets in a private runtime directory rather than a globally predictable `/tmp` path. 7. If lockfiles remain necessary, atomically create them, reject symbolic links and non-regular files, and validate owner, permissions, content, expiry, and one-time use. 8. Do not treat caller-controlled environment variables as proof of human authorization. 9. Fail closed on malformed state and log authorization decisions without logging secrets. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/sota_core.py:30
Finding
Secure Wrapper Allows Caller-Controlled Python File Execution Through Path Traversal<![CDATA[ ## Vulnerability Details **File Location**: `scripts/secure_wrapper.py:41-55`; `scripts/sota_core.py:30-49` **Vulnerability Type**: Arbitrary local Python file execution **Risk Level**: High ### Vulnerable Code The wrapper accepts the script name directly from its command line: ```python # Start the task in a thread or separate process script_name = sys.argv[1] if len(sys.argv) > 1 else None if not script_name: return # Sub-process will connect to this socket def handle_auth(): try: conn, _ = server.accept() data = conn.recv(1024) if data == b"AUTH_REQUEST": conn.sendall(b"AUTH_GRANTED") conn.close() except: pass threading.Thread(target=handle_auth).start() # 3. Secure Launch run_protected_script(script_name) ``` The value is joined to the scripts directory without canonicalization or containment validation: ```python def run_protected_script(script_name): """ Secure Execution: Uses subprocess with clean environment. """ base_dir = os.path.dirname(os.path.abspath(__file__)) script_path = os.path.join(base_dir, script_name) # 1. Clean Environment clean_env = os.environ.copy() clean_env['SOTA_INTERNAL_AUTH'] = 'TRUE' # 2. Atomic Execution subprocess.run( [sys.executable, script_path], env=clean_env, check=True ) ``` ### Technical Analysis `os.path.join()` does not constrain the resulting path to `base_dir`: - An absolute `script_name` causes the base directory to be discarded. - A value containing `../` can traverse outside the scripts directory. - No allowlist restricts execution to bundled, reviewed scripts. - No canonical-path comparison verifies that the resolved target remains under `base_dir`. The use of an argument list prevents shell metacharacter injection, but it does not prevent execution of an attacker-selected Python file. The function’s “clean environment” claim is also inaccurate. `os.environ.copy()` forwar ...[truncated 1315 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace arbitrary paths with a fixed mapping of approved identifiers to reviewed scripts. 2. Reject absolute paths and any input containing path separators or traversal components. 3. Resolve the candidate path with `realpath()` and verify containment under the expected directory using a path-aware comparison. 4. Verify that the target is a regular, non-symbolic-link file owned by the expected account. 5. Construct a minimal environment from an explicit allowlist instead of copying `os.environ`. 6. Remove `SOTA_INTERNAL_AUTH` unless it is cryptographically bound to one operation and cannot be supplied by untrusted callers. 7. Run approved subprocesses under a dedicated low-privilege account with filesystem and network restrictions. 8. Log the canonical approved script identifier rather than an arbitrary caller-supplied path. ]]>

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Unpinned and Incomplete Python Dependency Specification<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1-5`; `scripts/freedom_engine.py:5-7` **Vulnerability Type**: Non-reproducible and incomplete dependency management **Risk Level**: Medium ### Vulnerable Code ```text curl_cffi>=0.14.0 lxml>=5.1.0 websocket-client>=1.8.0 DrissionPage>=4.1.1.2 requests>=2.31.0 ``` The documented entry point imports an undeclared package: ```python from curl_cffi import requests as requests_cffi from DrissionPage import ChromiumPage, ChromiumOptions from scrapling import Fetcher ``` ### Technical Analysis Every requirement uses a lower bound with no upper bound, allowing installation of arbitrary future versions that were not reviewed with the Skill. No hashes or lockfile provide artifact integrity or reproducibility. The `scrapling` dependency is required by `freedom_engine.py` and declared in Skill metadata, but it is absent from `requirements.txt`. Installation behavior therefore depends on external environment state or separate package-resolution logic. The audit did not identify a confirmed malicious package, dependency-confusion name, or unsafe nonstandard package source. The issue is the absence of reproducible supply-chain controls rather than proof of current package compromise. ### Attack Path 1. A deployment installs dependencies from `requirements.txt`. 2. The package manager resolves versions newer than those reviewed when the Skill was published. 3. A future compromised, vulnerable, or incompatible release may be selected automatically. 4. Package installation or import executes that changed upstream code with installer or Skill-process privileges. 5. Separately, the missing `scrapling` requirement can cause runtime failure or encourage ad hoc installation of an unreviewed version. ### Impact Assessment Potential impact includes: - Execution of changed third-party code in the Skill environment. - Exposure to newly introduced dependency vulnerabilities. - Non-reproducible deployments ...[truncated 311 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin each direct dependency to an exact reviewed version. 2. Add `scrapling` at an exact reviewed version. 3. Generate and commit a lockfile containing resolved transitive dependencies. 4. Require package hashes during installation. 5. Install only from an explicitly trusted package index. 6. Use automated vulnerability and license scanning for direct and transitive dependencies. 7. Establish a controlled update process that reruns security tests before changing pinned versions. 8. Keep Skill metadata, `requirements.txt`, and the lockfile synchronized. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (52)

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The document explicitly describes browser takeover, arbitrary JavaScript execution through Runtime.evaluate, and bypass of standard sandboxing controls. In the context of a 'web freedom' toolkit advertising undetectable browsing on restricted VPS environments, these capabilities materially exceed normal web automation behavior and indicate functionality that could be used for unauthorized control or evasion.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
A hardcoded DataDome-targeted bypass experiment disguised as a universal toolkit is a concerning mismatch, especially when it writes local output not mentioned in the description. The context makes this more dangerous because the skill openly frames itself around stealth and undetectability, suggesting deliberate evasion rather than ordinary automation.

Context-Inappropriate Capability

High
Confidence
95% confidence
Finding
The function explicitly advertises and initiates a 'high-privilege page takeover' capability, which is unrelated to the stated purpose of a web-fetching/browsing toolkit. In this context, that strongly suggests unauthorized control or manipulation functionality, and the surrounding skill description emphasizing undetectable browsing on restricted environments increases the likelihood of abuse rather than legitimate administration.

Env Variable Harvesting

High
Category
Data Exfiltration
Content
script_path = os.path.join(base_dir, script_name)
    
    # 1. Clean Environment
    clean_env = os.environ.copy()
    clean_env['SOTA_INTERNAL_AUTH'] = 'TRUE'
    
    # 2. Atomic Execution
Confidence
92% confidence
Finding
Copying the full environment into a child process can expose sensitive environment variables to code that did not need them, including credentials, cloud tokens, and internal service configuration. In an agent skill advertised for 'undetectable browsing' on restricted environments, that broader process and evasion context makes secret propagation more concerning because it increases the potential for misuse or exfiltration by any executed child script.

Natural-Language Policy Violations

High
Confidence
96% confidence
Finding
User-visible strings such as 'ULTRA PHANTOM: DATADOME SOTA BREACH', 'Targeting', and 'Breach Success' describe the activity as an attack against a named external service. This natural-language framing is an organizational policy concern because it presents hostile or unauthorized behavior rather than a legitimate, clearly bounded test or research activity.

Intent-Code Divergence

Medium
Confidence
91% confidence
Finding
Describing 127.0.0.1:9223 as 'our local secure relay' asserts a trust boundary without showing authentication, authorization, or integrity protections. Because the same document frames the relay as part of a browser takeover flow, the unsupported security claim can mislead operators into trusting a component that may enable unauthorized access to a DevTools session.

Lp3

Medium
Category
MCP Least Privilege
Confidence
89% confidence
Finding
The skill advertises execution of a Python script and declares dependencies that imply shell, network, file, and environment access, yet it provides no explicit tool-scope restrictions such as permissions or allowed-tools. In an agent setting, missing scope declarations increase the chance that a skill can exercise broader host capabilities than users expect, especially when paired with a stealth-focused description.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The skill explicitly promotes stealth, bypassing Cloudflare/WAFs, TLS impersonation, and undetectable browsing without any warning about legal, privacy, or target-site impact. In context, this raises the risk of misuse by normalizing evasive behavior and encouraging operation against systems that may rely on those defenses for access control.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
The manifest describes a server-side web browsing toolkit built around fetching, TLS impersonation, and browser automation on restricted VPS environments. This file instead enumerates local script files and writes a local JSON 'auditor report', which is a separate audit/reporting function rather than web-freedom or browsing functionality.

Intent-Code Divergence

Medium
Confidence
88% confidence
Finding
The comment claims a 'Mandatory physical gate,' but the code enforces only a software call to verify_access_control(), which may mislead reviewers into believing a stronger real-world control exists. This discrepancy can cause dangerous overtrust in the protection around a sensitive operation, especially when guarding a high-privilege takeover action.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
This script implements direct attachment to a local Chrome DevTools Protocol endpoint and explicitly brands itself as a 'force takeover'/'nuclear option'. CDP attachment can grant powerful control over an existing browser context, including page interaction, cookie/session access, and potentially data exfiltration, which materially exceeds a normal web-fetching or browsing toolkit's stated purpose.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
The manifest claims a broad toolkit that harmonizes multiple browsing/fetching technologies for undetectable browsing on restricted VPS environments. In contrast, this code uses only curl_cffi requests to query arXiv and DuckDuckGo, parse results, and save them locally, which is much narrower than the stated capability.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
This code implements a local TCP relay that forwards arbitrary traffic between two localhost ports, which is not aligned with a typical web-browsing toolkit helper and can be used to expose or bridge restricted local services. In the context of a skill explicitly advertising 'undetectable browsing' and operation on 'restricted VPS environments,' the relay meaningfully increases the ability to bypass environment controls, hide tooling topology, or chain access to sensitive browser/debug interfaces.

Context-Inappropriate Capability

Medium
Confidence
89% confidence
Finding
Although the current invocation uses fixed ports, the relay implementation itself is a generic bidirectional port-forwarder and is broader than the stated purpose of a web toolkit. Such forwarding can be repurposed to proxy access to local-only administrative endpoints, browser debugging ports, or other internal services, enabling policy evasion and stealthier access patterns.

Static analysis

No suspicious patterns detected.