Back to skill

Security audit

Poe Chat

Security checks for vulnerabilities and agentic risk

Overview

This skill is a Poe chat helper whose network calls, API key use, model listing, and optional file uploads fit its stated purpose, though users should treat uploaded files and API keys carefully.

Install only if you are comfortable sending prompts and any --file attachments to Poe. Prefer POE_API_KEY over --api-key so the key is not stored in shell history, avoid uploading sensitive documents unless necessary, and consider pinning dependencies before production use.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T08 · Insecure Dependencies

Warning
Location
scripts/requirements.txt:1
Finding
Unpinned Third-Party Dependencies Create Supply-Chain Exposure<![CDATA[ ## Vulnerability Details **File Location**: `scripts/requirements.txt:1-2` **Vulnerability Type**: Unpinned dependencies **Risk Level**: Medium ### Vulnerable Code ```text fastapi-poe requests ``` ### Technical Analysis The project instructs users to install dependencies from this requirements file, but neither dependency has a fixed version or an integrity hash. Consequently, installation resolves to whichever compatible release the package index serves at that time. This prevents reproducible dependency resolution and expands the trust boundary to future package releases. If a dependency account, release process, package index, or dependency tree is compromised, installation could introduce attacker-controlled code without any change to this Skill's reviewed source. No evidence indicates that the currently named packages are malicious. The vulnerability is the absence of version and integrity controls, rather than confirmed malicious package content. ### Attack Path 1. An attacker compromises a dependency maintainer account, package release process, package-index response, or transitive dependency. 2. The attacker publishes or causes resolution to a malicious version of `fastapi-poe` or `requests`. 3. A user follows the documented installation command: ```bash pip install -r scripts/requirements.txt ``` 4. Because no version or hash is enforced, `pip` may download the malicious release. 5. Malicious package code executes during installation or when the Skill imports and uses the dependency. ### Impact Assessment Attacker-controlled dependency code would generally execute with the privileges of the user installing or invoking the Skill. Depending on that user's access, this could expose Poe API credentials, user messages, explicitly uploaded files, environment variables, local files accessible to the process, and network access. It could also alter responses or perform other actions available to the current operating-system accoun ...[truncated 6 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every direct dependency to a reviewed version, for example: ```text fastapi-poe==<reviewed-version> requests==<reviewed-version> ``` 2. Generate and retain a lock file that includes resolved transitive dependencies. 3. Record cryptographic hashes and install with `pip --require-hashes`. 4. Use a controlled package index or approved dependency mirror where practical. 5. Add automated vulnerability and dependency-update scanning. 6. Review dependency changes before updating pins, including transitive dependency changes and package provenance. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/poe_client.py:59
Finding
Poe API Key Can Be Exposed Through Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `scripts/poe_client.py:59-62` **Additional Documentation Locations**: `SKILL.md:27`, `SKILL.md:65` **Vulnerability Type**: Sensitive credential exposure through process arguments **Risk Level**: Medium ### Vulnerable Code ```python parser.add_argument( "--api-key", help="Poe API key (overrides POE_API_KEY env var)", ) ``` The documentation also demonstrates supplying the credential directly on the command line: ```bash python scripts/poe_client.py \ --message "请解释量子计算" \ --model-id "gemini-3-flash" \ --api-key "your_api_key" \ --file "/path/to/document.pdf" ``` ### Technical Analysis Command-line arguments are not an appropriate secret-input channel on many operating systems and execution environments. An API key supplied through `--api-key` may be recorded in shell history, exposed in process listings, captured by process-monitoring tools, included in CI/CD logs, or retained by automation and telemetry systems. The client intentionally sends the key to Poe as part of its declared operation; that network use is necessary and is not itself unauthorized exfiltration. The issue is the local credential-input mechanism and the documented encouragement to place the credential in command-line arguments. ### Attack Path 1. A user follows the documented example and invokes the client with a real Poe API key in `--api-key`. 2. The shell records the complete command in its history, or a local process monitor observes the process arguments while the command is running. 3. Another local user, administrator, support bundle, logging agent, CI/CD system, or compromised process obtains the recorded argument. 4. The observer extracts the Poe API key. 5. The exposed credential is used to access Poe APIs until it expires or is revoked. ### Impact Assessment An attacker obtaining the key could make Poe API requests under the victim's account and consume associated quotas or paid resources. The preci ...[truncated 252 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove or deprecate `--api-key` to prevent secrets from being supplied in process arguments. 2. Continue supporting `POE_API_KEY` for non-interactive use, while ensuring automation masks that environment variable in logs. 3. For interactive use, read the key without terminal echo: ```python from getpass import getpass api_key = os.getenv("POE_API_KEY") or getpass("Poe API key: ") ``` 4. Update `SKILL.md` so examples never place real credentials in command-line arguments. 5. Document secure secret-manager integration for CI/CD and production environments. 6. Advise users who previously used `--api-key` to remove affected shell-history entries and rotate potentially exposed keys. 7. Avoid printing, logging, serializing, or including the key in exception messages. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
Findings (16)

Tainted flow: 'api_key' from os.getenv (line 115, credential/environment) → requests.get (network output)

Critical
Category
Data Flow
Content
def _fetch_models_from_api(api_key: Optional[str]) -> List[ModelInfo]:
    response = requests.get(
        MODEL_LIST_URL,
        headers=_build_headers(api_key),
        timeout=30,
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill promises an @trigger-driven experience with automatic model selection, but the described invocation requires the user to pass --model-id explicitly through a CLI. This inconsistency can cause unsafe automation assumptions, where higher-level systems believe the skill will constrain behavior based on trigger words while the actual interface accepts direct model identifiers and bypasses those promised controls.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill promises an @trigger-driven experience with automatic model selection, but the described invocation requires the user to pass --model-id explicitly through a CLI. This inconsistency can cause unsafe automation assumptions, where higher-level systems believe the skill will constrain behavior based on trigger words while the actual interface accepts direct model identifiers and bypasses those promised controls.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The skill promises an @trigger-driven experience with automatic model selection, but the described invocation requires the user to pass --model-id explicitly through a CLI. This inconsistency can cause unsafe automation assumptions, where higher-level systems believe the skill will constrain behavior based on trigger words while the actual interface accepts direct model identifiers and bypasses those promised controls.

Vague Triggers

High
Confidence
97% confidence
Finding
Allowing any '@xxx' token as a trigger creates a very ambiguous activation condition and broadens the chance of accidental invocation. In a skill that can perform network calls and upload files, such ambiguity materially increases the risk of unintentional external data transmission or misuse through crafted prompts.

Lp3

Medium
Category
MCP Least Privilege
Confidence
84% confidence
Finding
The skill documentation describes capabilities that involve environment variables, local file access, writing cache files, and outbound network calls, but it declares no explicit tool scope or permission boundaries. This creates unnecessary ambiguity about what the skill may access and makes accidental overreach or unsafe execution more likely, especially when files and API keys are involved.

Vague Triggers

Medium
Confidence
92% confidence
Finding
The activation description is broad enough that the skill could be invoked in many contexts whenever a matching token appears, without clear boundaries on user intent. Ambiguous triggering is risky because it may send prompts or files to an external service unexpectedly, especially in mixed conversations where @tokens may appear incidentally.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill advertises local file upload support but does not clearly warn users that selected files will be transmitted to an external Poe service. This is a privacy and data-handling vulnerability because users may upload sensitive local documents without informed consent or understanding of where the data is sent.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The behavior section states that files are uploaded through an API but omits any privacy or external-transmission notice. When paired with broad triggers and unclear activation, this increases the chance of silent leakage of local data to a remote provider.

External Transmission

Medium
Category
Data Exfiltration
Content
import requests


MODEL_LIST_URL = "https://api.poe.com/v1/models"
MODEL_CACHE_TTL_SECONDS = 60 * 60
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Tainted flow: 'payload' from os.getenv (line 119, credential/environment) → pathlib.Path.write_text (file write)

Medium
Category
Data Flow
Content
output = _build_output(models, args.full)
    payload = json.dumps(output, ensure_ascii=False, indent=2)

    out_path.write_text(payload, encoding="utf-8")
    print(payload)
    return 0
Confidence
65% confidence
Finding
Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The script transmits the user message and any uploaded files to an external third-party service (Poe) without an explicit user-facing warning at runtime about off-host data transfer. Because the skill supports file upload and arbitrary prompts, users may unintentionally send sensitive local content or secrets to an external model provider, which is more concerning in an agent-skill context where tool invocation may feel implicit.

Context-Inappropriate Capability

Low
Confidence
85% confidence
Finding
The manifest describes a chat skill that routes prompts to Poe-backed models and supports file upload. Accessing credentials from the process environment is an additional capability not mentioned in that purpose statement, even though it is used to enable the remote API call.

Unpinned Dependencies

Low
Category
Supply Chain
Content
fastapi-poe
requests
Confidence
98% confidence
Finding
The dependency fastapi-poe is unpinned, so installs may pull different versions over time, including releases with breaking changes or newly introduced vulnerabilities. In a skill that brokers prompts/files to external model APIs, dependency drift increases supply-chain risk and makes builds non-reproducible.

Unpinned Dependencies

Low
Category
Supply Chain
Content
fastapi-poe
requests
Confidence
99% confidence
Finding
The requests package is unpinned, which allows installation of any available version and prevents assurance that a safe, tested release is used. Because this skill supports file upload and likely performs outbound HTTP calls, an unsafe or changed requests version could affect transport security, credential handling, or runtime behavior.

Unverifiable Dependency: requests has 16 known advisory(ies) (CVE-2014-1830 (Exposure of Sensitive Information to an Unauthorized Actor in Requests); CVE-2024-47081 (Requests vulnerable to .netrc credentials leak via malicious URLs); CVE-2024-35195 (Requests `Session` object does not verify requests after making first request wi) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
97% confidence
Finding
The manifest references requests without a version, and multiple known advisories exist for some requests releases, so it is impossible to verify whether deployment will use a vulnerable version. In this skill's context, which likely makes HTTP requests and may handle uploaded files or credentials when interacting with Poe/model services, a vulnerable requests release could expose secrets or weaken request verification.

Static analysis

No suspicious patterns detected.