Back to skill

Security audit

Api Bridge

Security checks for vulnerabilities and agentic risk

Overview

This skill is a coherent API-integration scaffold, but it includes credentialed network and file-upload patterns without enough destination, file, or user-approval safeguards.

Review this skill before installing if you expect it to generate runnable integrations. Use it only with trusted OpenAPI specs, verify every base URL and OAuth token endpoint, keep secrets out of prompts and logs, and require explicit approval before generated code uploads local files, performs write/delete API actions, or sends credentials to a service.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:284
Finding

OAuth Credentials Can Be Transmitted to an Unrestricted Token Endpoint

Content
View full analysis
str: """Get OAuth2 access token.""" async with httpx.AsyncClient() as client: resp = await client.post( token_url, data={ "grant_type": "client_credentials", "client_id": client_id, "client_secret": client_secret, }, ) resp.raise_for_status() return resp.json()["access_token"] ``` ### Technical Analysis The generated OAuth helper accepts `token_url` without validating its scheme or destination before transmitting `client_id` and `client_secret`. It does not require HTTPS, compare the endpoint against an expected provider origin, or explicitly prevent cross-origin redirects. Network transmission of OAuth credentials is necessary for the Skill's declared API-integration functionality. However, allowing an arbitrary destination exceeds minimum privilege because credentials should only be sent to an explicitly trusted authorization server. If an OpenAPI specification, API document, configuration value, or caller supplies a malicious URL, the generated client may disclose credentials to an attacker-controlled endpoint. ### Attack Path 1. An attacker supplies or modifies an API specification, documentation source, or configuration containing an attacker-controlled token endpoint. 2. The Skill generates an integration that passes this endpoint as `token_url`. 3. The user configures valid OAuth client credentials and runs the generated integration. 4. The helper sends the client identifier and secret to the attacker-controlled server. 5. The attacker uses the exposed credentials to request tokens or access resources permitte ...[truncated 468 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:329
Finding

Arbitrary Local Files and API Credentials Can Be Sent to an Unvalidated Upload Destination

Content
View full analysis
dict: """Upload a file to the API.""" async with httpx.AsyncClient() as client: with open(file_path, "rb") as f: resp = await client.post( f"{api_client.base_url}/files", headers={"Authorization": f"Bearer {api_client.api_key}"}, files={"file": (file_path, f, "application/octet-stream")}, ) resp.raise_for_status() return resp.json() ``` ### Technical Analysis The example opens any path supplied through `file_path` and transmits its contents to a destination derived from `api_client.base_url`. It also sends `api_client.api_key` in the Authorization header. The code does not restrict readable paths, require user confirmation, validate the destination origin, require HTTPS, or constrain redirects. File upload is consistent with the Skill's declared integration functionality. Nevertheless, arbitrary filesystem access and unrestricted remote destinations exceed the minimum privileges needed for a typical upload operation. Generated integrations should restrict uploads to files explicitly selected by the user and should send credentials and file contents only to a previously approved API origin. ### Attack Path 1. An attacker supplies or influences an API base URL, generated integration configuration, or invocation parameters. 2. The generated integration receives a sensitive readable path such as a configuration file, credential file, private key, or application data file. 3. `open(file_path, "rb")` reads the file using the privileges of the running process. 4. The function sends both the file contents and bearer API key to the configured destination. 5. An attack ...[truncated 742 chars]
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (5)

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · SKILL.md (reported line 289)May include surrounding context.

md
client_secret: str,
    token_url: str,
) -> str:
    """Get OAuth2 access token."""
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            token_url,

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The activation criteria are broad enough to trigger on common API-related language such as 'API key', 'REST endpoint', or generic integration requests. In an agent environment, this can cause unintended invocation of a skill that performs network-oriented scaffolding and encourages credentialed API use, increasing the chance of accidental external operations or code generation in the wrong context.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill explicitly describes fetching remote specs, handling authentication, and producing code that will call external services, but it does not warn the user that data or credentials may be transmitted off-system. This weakens informed consent and can lead to accidental disclosure of API keys, bearer tokens, or sensitive request data during skill use.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
86% confidence
Finding

The example instructs fetching an OpenAPI document from an external URL. While normal for this skill's purpose, external retrieval introduces risks from untrusted remote content, unintended data egress, and downstream generation from attacker-controlled specifications if the source is not validated.

Content

Scanner excerpt · SKILL.md (reported line 42)May include surrounding context.

bash
# Fetch the spec
curl -s https://api.example.com/openapi.json > /tmp/api-spec.json

# Generate MCP server
# (Use the steps below)

External Transmission

Medium
Category
Data Exfiltration
Confidence
50% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · SKILL.md (reported line 348)May include surrounding context.

md
| API | Spec URL |
|-----|----------|
| GitHub | https://api.github.com/openapi.json |
| Stripe | https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.json |
| Twilio | https://github.com/twilio/twilio-oai/blob/main/spec/yaml/twilio_api_v2010.yaml |
| OpenAI | https://github.com/openai/openai-openapi/blob/main/openapi.yaml |

Static analysis

No suspicious patterns detected.