Back to skill

Security audit

LP Agent

Security checks for vulnerabilities and agentic risk

Overview

This skill has a coherent Hummingbot liquidity-trading purpose, but it needs Review because it can handle wallet keys and deploy mutable trading infrastructure with unsafe defaults and broad local effects.

Install only if you are comfortable granting this skill control over local Hummingbot trading infrastructure and wallet import workflows. Use a dedicated low-value wallet, change default credentials before exposing any service, keep API/Gateway endpoints on localhost or trusted HTTPS only, avoid --defaults for real funds, review the deploy script before running it as root, and prefer --no-open for generated reports from untrusted data.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Tool Hijacking and SpoofingModifies or replaces tools so legitimate-looking calls execute attacker logic
  • 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
Findings (8)

T07 · Tool Hijacking and Spoofing

Error
Location
scripts/deploy_hummingbot_api.sh:152
Finding
Global replacement of the sudo command with an unauthenticated wrapper<![CDATA[ ## Vulnerability Details **File Location**: `scripts/deploy_hummingbot_api.sh:152-156` **Vulnerability Type**: Tool hijacking and command spoofing **Risk Level**: Critical ### Vulnerable Code ```bash # Set USER env var and create sudo shim if needed export USER=${USER:-root} if [ "$(id -u)" = "0" ] && ! command -v sudo &>/dev/null; then echo -e '#!/bin/bash\nwhile [[ "$1" == *=* ]]; do export "$1"; shift; done\nexec "$@"' > /usr/local/bin/sudo chmod +x /usr/local/bin/sudo fi ``` ### Technical Analysis When installation runs as root in an environment without `sudo`, the script creates `/usr/local/bin/sudo`. This replacement does not implement real `sudo` authentication, authorization, environment filtering, user switching, or command-policy enforcement. It simply exports assignment-style arguments and executes the remaining command under the current process identity. Writing a spoofed executable into a globally trusted command path exceeds the privileges necessary to deploy Hummingbot. The modification is also not disclosed in the Skill documentation. ### Attack Path 1. Run `deploy_hummingbot_api.sh install` as root in a container or environment without an existing `sudo`. 2. The installer writes the wrapper to `/usr/local/bin/sudo`. 3. A later setup script, administrator, or application resolves `sudo` through `PATH`. 4. The wrapper executes the supplied command directly as root without normal `sudo` policy checks. 5. Attacker-controlled arguments passed through such a call receive root-level execution. ### Impact Assessment This can affect every process that resolves `/usr/local/bin/sudo` before the legitimate binary. It can bypass expected privilege boundaries, create incorrect security assumptions, and execute commands with root privileges. The replacement remains on the filesystem after the installer exits. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Never create or replace `/usr/local/bin/sudo`. - Detect whether the process is already root and invoke the required command directly. - If upstream build logic requires a compatibility wrapper, patch that build logic rather than modifying a globally trusted command. - If a wrapper is unavoidable, store it in a private temporary directory, invoke it by its absolute path, and delete it immediately afterward. - Add an installation integrity check that fails if unexpected global binaries would be created or modified. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/check_api.sh:16
Finding
Credential files are executed as arbitrary shell code<![CDATA[ ## Vulnerability Details **File Location**: `scripts/check_api.sh:16-21`; also present at `scripts/check_gateway.sh:20-25` and `scripts/setup_gateway.sh:31-36` **Vulnerability Type**: Arbitrary command execution through unsafe `.env` loading **Risk Level**: High ### Vulnerable Code ```bash # Load .env if present for f in hummingbot-api/.env ~/.hummingbot/.env .env; do if [ -f "$f" ]; then set -a; source "$f"; set +a break fi done ``` Equivalent `source` logic is used by the other affected shell scripts. ### Technical Analysis A `.env` file is intended to be parsed as configuration data, but `source` evaluates it as a shell program. Command substitutions, function definitions, redirections, and arbitrary commands in a project-local `.env` therefore execute with the privileges of the user or Agent running the script. This behavior is especially exposed because the documented onboarding process invokes the health-check scripts automatically. ### Attack Path 1. An attacker modifies or supplies `./hummingbot-api/.env`, `~/.hummingbot/.env`, or `./.env`. 2. The file includes shell syntax such as a command substitution or standalone command. 3. The user or Agent runs `check_api.sh`, `check_gateway.sh`, or `setup_gateway.sh`. 4. The script executes `source "$f"`. 5. The malicious shell content runs before the intended API or Gateway operation. ### Impact Assessment Successful exploitation provides arbitrary command execution with the invoking process's permissions. If setup is being run as root, the payload obtains root privileges. The attacker could read credentials, alter trading configuration, modify files, or install additional persistence. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Do not use `source` for `.env` files. - Implement a strict parser that accepts only an allowlist such as `HUMMINGBOT_API_URL`, `API_USER`, and `API_PASS`. - Require variable names to match a safe pattern such as `^[A-Z_][A-Z0-9_]*$`. - Treat values as literal data and reject command substitution, shell control operators, redirections, and malformed quoting. - Reject project-local credential files unless the user explicitly selects them. - Verify ownership and permissions before loading credential files, particularly when running with elevated privileges. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/deploy_hummingbot_api.sh:232
Finding
Environment-controlled reset path permits unintended recursive deletion<![CDATA[ ## Vulnerability Details **File Location**: `scripts/deploy_hummingbot_api.sh:24,232-242` **Vulnerability Type**: Unsafe recursive deletion and path confusion **Risk Level**: High ### Vulnerable Code ```bash INSTALL_DIR="${HUMMINGBOT_API_DIR:-./hummingbot-api}" ``` ```bash cmd_reset() { if [ ! -d "$INSTALL_DIR" ]; then fail "Not installed" return fi echo "Stopping and removing Hummingbot API..." cd "$INSTALL_DIR" docker compose down -v 2>/dev/null || true cd ~ rm -rf "$INSTALL_DIR" ok "Hummingbot API removed" } ``` ### Technical Analysis `INSTALL_DIR` is controlled by the `HUMMINGBOT_API_DIR` environment variable and is not canonicalized, restricted, or validated as a Hummingbot installation. The function also changes to the user's home directory before deleting the path. Consequently, a relative `INSTALL_DIR` is resolved against a different directory during deletion than during the initial existence check and `cd`. An absolute attacker-selected value can target an arbitrary existing directory, while relative-path confusion can remove an unrelated directory under the user's home. ### Attack Path 1. Set `HUMMINGBOT_API_DIR` to a sensitive existing directory or a crafted relative path. 2. Invoke `deploy_hummingbot_api.sh reset`. 3. The script checks that the selected directory exists and enters it. 4. It changes the current directory to the user's home. 5. `rm -rf "$INSTALL_DIR"` recursively removes the selected or reinterpreted path without confirmation. ### Impact Assessment The vulnerability can delete arbitrary directories writable by the invoking user. When run as root, the scope can extend to system directories and application data. The Docker command also removes associated volumes, potentially destroying databases and trading records. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Convert the installation path to a canonical absolute path before any directory changes. - Require an installation marker, expected repository metadata, and the expected Compose file before deletion. - Reject empty paths, `/`, the user's home, system directories, parent traversal, and paths outside an approved installation root. - Use the same canonical path for validation, Docker shutdown, and deletion. - Require an explicit interactive confirmation that displays the exact absolute path. - Keep destructive reset disabled in non-interactive Agent execution unless the user separately authorizes it. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/add_wallet.py:53
Finding
API credentials and wallet private keys can be transmitted to an arbitrary plaintext endpoint<![CDATA[ ## Vulnerability Details **File Location**: `scripts/add_wallet.py:53-74,125-146` **Additional Locations**: `scripts/manage_controller.py:59-81`, `scripts/manage_executor.py:63-85`, `scripts/manage_gateway.py:58-80`, `scripts/export_lp_executor.py:61-79`, `scripts/visualize_lp_executor.py:50-68`, `scripts/setup_gateway.sh:39,92-100`, `scripts/check_gateway.sh:28-35` **Vulnerability Type**: Unvalidated sensitive-data destination and plaintext Basic Authentication **Risk Level**: High ### Vulnerable Code ```python def get_api_config(): """Get API configuration from environment.""" load_env() return { "url": os.environ.get("HUMMINGBOT_API_URL", "http://localhost:8000"), "user": os.environ.get("API_USER", "admin"), "password": os.environ.get("API_PASS", "admin"), } ``` ```python def api_request(method: str, endpoint: str, data=None) -> dict: """Make authenticated API request.""" config = get_api_config() url = f"{config['url']}{endpoint}" credentials = base64.b64encode(f"{config['user']}:{config['password']}".encode()).decode() headers = { "Authorization": f"Basic {credentials}", "Content-Type": "application/json", } body = json.dumps(data).encode() if data else None req = urllib.request.Request(url, data=body, headers=headers, method=method) try: with urllib.request.urlopen(req, timeout=60) as resp: return json.loads(resp.read().decode()) ``` ```python data = { "chain": args.chain, "private_key": private_key, } print(f"Adding {args.chain} wallet...") result = api_request("POST", "/accounts/gateway/add-wallet", data) ``` ### Technical Analysis The scripts accept `HUMMINGBOT_API_URL` without restricting its host or requiring HTTPS. Every request sends the API username and password in a Basic Authorization header. During wallet import, the wallet private key is also placed in the request body. Base64 is standard Basic Authentic ...[truncated 1284 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Restrict the default endpoint to loopback addresses. - Require explicit user confirmation before allowing non-loopback destinations. - Require HTTPS with normal certificate and hostname verification for all remote endpoints. - Display the normalized destination before transmitting a private key. - Disable cross-origin redirects or verify every redirect target against the approved origin. - Reject embedded URL credentials and unsupported schemes. - Separate wallet-import authorization from lower-privilege read-only API credentials. - Prefer local secure keystore integration so raw private keys do not traverse a general-purpose REST endpoint. - Warn users that `--private-key` exposes the key through process arguments and recommend the hidden interactive prompt. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/deploy_hummingbot_api.sh:159
Finding
Installer creates services with documented default credentials<![CDATA[ ## Vulnerability Details **File Location**: `scripts/deploy_hummingbot_api.sh:159-170` **Related Documentation**: `SKILL.md:167-201` **Vulnerability Type**: Hardcoded and predictable credentials **Risk Level**: High ### Vulnerable Code ```bash # Create .env manually cat > .env << EOF USERNAME=admin PASSWORD=admin CONFIG_PASSWORD=admin DEBUG_MODE=false BROKER_HOST=hummingbot-broker BROKER_PORT=1883 BROKER_USERNAME=admin BROKER_PASSWORD=password DATABASE_URL=postgresql+asyncpg://hbot:hummingbot-api@hummingbot-postgres:5432/hummingbot_api BOTS_PATH=/hummingbot-api/bots EOF ``` The Skill documentation also states that the default credentials are `admin/admin`. ### Technical Analysis The non-interactive installation path writes several static, publicly documented credentials. These credentials protect infrastructure capable of importing wallets and initiating automated financial operations. Security therefore depends entirely on the services never becoming reachable outside a trusted local boundary. The defaults also include predictable broker and database credentials, increasing the blast radius if container networking, port publication, or host firewall configuration changes. ### Attack Path 1. Deploy the API using `install --defaults`, from a non-interactive environment, or from a detected container. 2. The installer writes the predictable credentials. 3. The API, broker, or database becomes reachable because of Docker port publication, reverse proxying, host-network mode, or firewall configuration. 4. An attacker authenticates using the documented default values. 5. The attacker accesses or manipulates the exposed trading infrastructure. ### Impact Assessment Depending on exposed interfaces, an attacker may obtain API administration, bot deployment, executor control, Gateway management, configuration access, or database/broker access. This could result in unauthorized trades, service disruption, data modification, or disclosure of connected- ...[truncated 24 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Generate unique cryptographically random credentials for every installation. - Do not print secrets to standard output or include them in documentation. - Require credential rotation before enabling wallet or trading operations. - Bind management services to loopback by default. - Set restrictive permissions such as mode `0600` on generated environment files. - Use Docker secrets or another dedicated secret-management facility instead of static Compose environment values. - Add startup checks that reject known default passwords. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/visualize_lp_executor.py:223
Finding
Unescaped API and database values permit JavaScript execution in automatically opened reports<![CDATA[ ## Vulnerability Details **File Location**: `scripts/visualize_lp_executor.py:223-290,446-562,657-662`; `scripts/visualize_lp_positions.py:324-347,1083-1090` **Vulnerability Type**: Stored HTML and script-context injection **Risk Level**: High ### Vulnerable Code The executor report inserts API-controlled strings directly into markup: ```python def row(label, value, color="#e8eaed"): return (f'<tr><td style="color:#6b7084;font-size:10px;width:46%">{label}</td>' f'<td style="text-align:right;color:{color};font-weight:500;">{value}</td></tr>') ``` ```python table_rows = "".join([ row("Executor ID", f'<span style="font-family:monospace;font-size:9px;">{eid}</span>'), row("Account", account), row("Controller", controller or "—"), row("Connector", connector), row("Trading Pair", pair, "#e8eaed"), ``` ```html <title>LP Executor — {pair}</title> ... <h1>{pair} — LP Executor</h1> <div class="subtitle">ID: {eid} · {connector} · {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}</div> ``` The SQLite report embeds serialized values directly inside an executable script element: ```python def generate_html(chart_data: list[dict], meta: dict) -> str: """Build a self-contained HTML file with the dashboard.""" data_json = json.dumps(chart_data) meta_json = json.dumps(meta) return f"""<!DOCTYPE html> <html lang="en"> ... <script> window.__LP_DATA__ = {data_json}; window.__LP_META__ = {meta_json}; </script> <script type="text/babel"> {DASHBOARD_JSX} </script> ``` Generated reports are written and then opened through `webbrowser.open(...)` unless the user disables that behavior. ### Technical Analysis API-controlled fields such as pair, account, controller, connector, executor ID, pool address, and position address are inserted into HTML body, title, and attribute contexts without escaping. An attacker-controlled value containing markup can therefore create new HTML or script elements. For the SQLite dashboa ...[truncated 1346 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Apply context-sensitive HTML escaping to every untrusted body, title, and attribute value. - Validate wallet, pool, transaction, position, and executor identifiers against strict character and length rules. - When embedding JSON in HTML, escape `<`, `>`, `&`, Unicode line separators, and especially any `</script>` sequence. - Prefer an inert `<script type="application/json">` element and parse its text content safely. - Add a restrictive Content Security Policy that disallows inline scripts and limits network destinations. - Do not automatically open reports derived from untrusted data; require explicit user action. - Add regression tests using payloads containing quotes, tags, event attributes, and `</script><script>`. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/deploy_hummingbot_api.sh:137
Finding
Unpinned remote repository is fetched and immediately executed<![CDATA[ ## Vulnerability Details **File Location**: `scripts/deploy_hummingbot_api.sh:27,137,188,211-217` **Vulnerability Type**: Mutable remote payload retrieval and execution **Risk Level**: High ### Vulnerable Code ```bash INSTALL_DIR="${HUMMINGBOT_API_DIR:-./hummingbot-api}" REPO_URL="https://github.com/hummingbot/hummingbot-api.git" ``` ```bash # Clone echo "Cloning hummingbot-api..." git clone "$REPO_URL" "$INSTALL_DIR" cd "$INSTALL_DIR" ``` ```bash # Deploy echo "Deploying..." make deploy ``` ```bash cmd_upgrade() { echo "Upgrading Hummingbot API" echo "========================" if [ ! -d "$INSTALL_DIR" ]; then fail "Not installed. Run install first." exit 1 fi cd "$INSTALL_DIR" echo "Pulling latest..." git pull echo "Redeploying..." make deploy ``` ### Technical Analysis The installer clones the repository's current default branch and immediately invokes repository-controlled Make targets. The upgrade command pulls the latest mutable branch state and executes it without pinning a commit, verifying a signature, or checking an expected digest. Although the repository URL appears to be the official Hummingbot GitHub repository, the effective code executed by this reviewed Skill can change after review. ### Attack Path 1. The upstream repository, maintainer account, release process, or network trust chain is compromised, or an unsafe upstream commit is published. 2. A user runs the install or upgrade command. 3. `git clone` or `git pull` obtains the changed branch state. 4. `make deploy` executes commands controlled by that state. 5. The altered code runs with access to Docker and the invoking user's filesystem; installation may also be run as root. ### Impact Assessment A compromised upstream revision can execute arbitrary commands, create privileged containers, mount host paths, access generated credentials, and modify or destroy trading infrastructure. Docker access commonly provides a pa ...[truncated 64 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin installation to a reviewed Git commit hash or signed release tag. - Verify commit or release signatures before executing repository content. - Publish and verify checksums for deployment artifacts. - Do not use unrestricted `git pull` as an upgrade mechanism. - Show the current and proposed pinned revisions and require explicit approval before upgrading. - Review Make targets and Compose definitions before granting access to the Docker daemon. - Run deployment with the least privileged account and avoid mounting sensitive host paths. ]]>

T08 · Insecure Dependencies

Warning
Location
scripts/setup_gateway.sh:45
Finding
Mutable container tags and third-party CDN scripts are executed without integrity pinning<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup_gateway.sh:45,159`; related locations include `scripts/manage_gateway.py:164,278`, `scripts/manage_controller.py:377`, `scripts/visualize_lp_executor.py:511`, and `scripts/visualize_lp_positions.py:338-343` **Vulnerability Type**: Unpinned third-party executable dependencies **Risk Level**: Medium ### Vulnerable Code ```bash IMAGE="hummingbot/gateway:development" ``` ```bash RESULT=$(api_post "/gateway/start" "{\"passphrase\": \"$PASSPHRASE\", \"image\": \"$IMAGE\", \"port\": $PORT, \"dev_mode\": true}") ``` The generated dashboards also load executable scripts from third-party CDNs without Subresource Integrity: ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js"></script> ``` ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.2.0/umd/react.production.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.2.0/umd/react-dom.production.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/prop-types/15.8.1/prop-types.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/recharts/2.12.7/Recharts.min.js"></script> <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/7.23.9/babel.min.js"></script> ``` Other management scripts default to mutable `latest` or `development` image tags. ### Technical Analysis Docker tags such as `latest` and `development` do not identify immutable artifacts. The same command can retrieve different container contents over time. Generated reports also execute CDN-hosted JavaScript without integrity hashes, making report behavior dependent on externally hosted content at viewing time. These dependencies are functionally related to the Skill, but the absence of immutable pinning and integrity verification creates an avoidable supply-chain risk. ### Attack Path 1. A container registry account, image publishing pipeline, CDN, or up ...[truncated 678 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin Docker images by immutable digest, for example `repository@sha256:...`. - Use reviewed release images rather than `development` or `latest`. - Verify image signatures through an appropriate supply-chain mechanism. - Vendor dashboard dependencies locally when possible. - If CDN delivery is retained, add correct Subresource Integrity hashes and `crossorigin="anonymous"`. - Add a restrictive Content Security Policy limiting script sources and outbound connections. - Document and periodically review every external dependency and its expected digest. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (97)

Tainted flow: 'req' from os.environ.get (line 42, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Content
"Accept": "application/json",
        "User-Agent": "Mozilla/5.0 (compatible; hummingbot-skills/1.0)",
    })
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read().decode())
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Tainted flow: 'req' from os.environ.get (line 42, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Content
url = f"http://{GATEWAY_HOST}:{GATEWAY_PORT}/connectors/meteora/clmm/pool-info?network=mainnet-beta&poolAddress={address}"
    req = urllib.request.Request(url, headers={"Accept": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=10) as resp:
            return json.loads(resp.read().decode()), None
    except urllib.error.URLError as e:
        return None, f"Gateway not reachable at {GATEWAY_HOST}:{GATEWAY_PORT}"
Confidence
90% confidence
Finding
The Gateway request URL is built from GATEWAY_HOST and GATEWAY_PORT environment variables, then fetched over plain HTTP. In a skill that may run in varied agent environments, an attacker who can influence environment configuration could redirect requests to an unintended internal or external service, causing SSRF-style behavior, data leakage about queried pool addresses, or interaction with an untrusted gateway.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The skill generates local HTML reports, may open a browser, and fetches external market data from KuCoin, none of which is clearly disclosed by the top-level description. Undisclosed external requests and local file/browser actions widen the trust boundary and can surprise users in environments where outbound traffic or local artifact creation is sensitive.

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
python scripts/visualize_lp_executor.py --id <executor_id>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

External Script Fetching

High
Category
Supply Chain
Content
The executor ID is returned when the executor is created (printed as `Executor ID: <id>`). If the user doesn't have it handy, fetch it from the API:

```bash
curl -s -u admin:admin -X POST http://localhost:8000/executors/search \
  -H "Content-Type: application/json" \
  -d '{"type":"lp_executor"}' | python3 -c "
import json,sys
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Ae1

High
Category
analysis-evasion
Content
| `scripts/visualize_lp_positions.py` | Generate HTML dashboard from position events (SQLite/bot-container based) |
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
| `scripts/visualize_lp_positions.py` | Generate HTML dashboard from position events (SQLite/bot-container based) |
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
| `scripts/visualize_lp_positions.py` | Generate HTML dashboard from position events (SQLite/bot-container based) |
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Static analysis

No suspicious patterns detected.