Back to skill

Security audit

Flowise

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent Flowise API integration, but it needs review because it can send prompts, files, session data, and API keys to user-configured Flowise servers with weak transport and secret-handling guidance.

Install only if you trust the configured Flowise server and understand that prompts, uploaded files, flow metadata, session identifiers, and API credentials may leave your machine. Prefer HTTPS for any non-local Flowise endpoint, avoid putting live API keys in shared project files or shell history, use least-privilege credentials, and do not use script/device form flows unless you intentionally want the Flowise workflow to perform actions on another system.

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

Error
Location
scripts/flowise.py:28
Finding
Bearer credentials and sensitive request data can be transmitted over plaintext HTTP## Vulnerability Details **File Location**: `scripts/flowise.py:28-38` **Supporting Documentation Location**: `SKILL.md:14-15`, `SKILL.md:35-39` **Vulnerability Type**: Transmission of sensitive information over an unencrypted channel **Risk Level**: High **Vulnerable Code**: ```python def make_request(url: str, method: str = "GET", data: dict = None, api_key: str = None) -> dict: """Make HTTP request to Flowise API""" headers = {"Content-Type": "application/json"} if api_key: headers["Authorization"] = f"Bearer {api_key}" 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: ``` **Relevant documented configuration**: ```markdown ### Flowise - Server: http://localhost:3000 - API Key: your-api-key-here ``` ```bash curl -X POST "${FLOWISE_URL}/api/v1/prediction/${FLOW_ID}" \ -H "Authorization: Bearer ${API_KEY}" \ -H "Content-Type: application/json" \ -d '{"question": "Hello, how are you?"}' ``` ### Technical Analysis The client accepts an unrestricted user-supplied server URL and adds the Flowise API key to the `Authorization` header. It does not validate the URL scheme or prevent bearer credentials from being sent to a non-loopback endpoint over plaintext HTTP. Plaintext HTTP does not provide transport confidentiality, integrity, or server authentication. If a remote Flowise deployment is configured with an `http://` URL, an on-path party may observe the bearer credential, user questions, session identifiers, and server responses. An active network attacker may also modify requests or responses. HTTP access to a service bound exclusively to a trusted loopback interface can be a reasonable deployment choice. The vulnerability arises because the implementation does not restrict plaintext HTTP to loopb ...[truncated 1382 chars]
Remediation
## Remediation Suggestions 1. Require `https://` for all non-loopback Flowise endpoints. 2. Reject remote plaintext HTTP URLs before constructing or sending a request. 3. If local HTTP support is required, limit it to verified loopback hosts such as `localhost`, `127.0.0.1`, and `::1`; document this as a local-development exception. 4. Do not silently downgrade from HTTPS to HTTP, and review redirect behavior so credentials cannot be forwarded to an untrusted origin. 5. Preserve normal TLS certificate and hostname validation. Do not add an unverified SSL context as a workaround for private certificates. 6. Recommend a trusted private certificate authority or reverse proxy with TLS for internal and remote deployments. 7. Warn users before sending prompts, files, session identifiers, or credentials to a newly configured external host. 8. Update all examples involving authenticated remote access to use HTTPS.

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:10
Finding
API key handling through plaintext configuration and command-line arguments creates local credential exposure## Vulnerability Details **File Location**: `SKILL.md:10-16` **Additional Code Location**: `scripts/flowise.py:85-86` **Vulnerability Type**: Insecure secret storage and command-line credential exposure **Risk Level**: Medium **Vulnerable Documentation**: ```markdown ## Configuration Store Flowise settings in `TOOLS.md`: ```markdown ### Flowise - Server: http://localhost:3000 - API Key: your-api-key-here ``` **Relevant command-line handling**: ```python parser = argparse.ArgumentParser(description="Flowise API Client") parser.add_argument("--url", "-u", required=True, help="Flowise server URL") parser.add_argument("--api-key", "-k", help="API key for authentication") ``` ### Technical Analysis The Skill instructs operators to store the Flowise API key directly in a Markdown configuration file. It also accepts the credential as a command-line argument. Neither mechanism is designed for secure secret management. A plaintext `TOOLS.md` file may be readable by unintended local users, copied into backups, included in diagnostic bundles, or accidentally committed to source control. The documentation does not prescribe restrictive permissions or repository exclusions. Passing a secret with `--api-key` can place it in shell history. Depending on the operating system and process-inspection controls, command-line arguments may also be visible to other local processes or users while the client is running. This exposure is unnecessary because credentials can be supplied through a protected environment variable, secret manager, or restricted file without appearing in the process argument list. ### Attack Path **Plaintext configuration path**: 1. An operator follows the documentation and records a valid API key in `TOOLS.md`. 2. The file is stored with permissive access, committed to a repository, copied to a backup, or included in a support archive. 3. Another local user or a recipient of the repository, ...[truncated 994 chars]
Remediation
## Remediation Suggestions 1. Do not instruct users to place live API keys directly in `TOOLS.md`. 2. Prefer an operating-system secret store or dedicated secret-management service. 3. As a minimum fallback, read the key from an environment variable such as `FLOWISE_API_KEY`. 4. For file-based secrets, use a dedicated file outside the project tree, require restrictive permissions, and read only the secret value at runtime. 5. Deprecate direct `--api-key` values. If command-line integration is required, accept the name of an environment variable or a protected secret-file path instead. 6. Add repository-ignore guidance for local configuration and secret files, and enable automated secret scanning. 7. Avoid printing, logging, or returning credentials in errors and diagnostic output. 8. Rotate any API key that may already have appeared in command history, a repository, backup, log, or shared configuration file. 9. Apply least-privilege scopes and expiration to Flowise credentials so disclosure has limited impact.
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (9)

Exfiltration Commands

High
Category
Prompt Injection
Content
---
name: flowise
description: Interact with Flowise AI workflows via REST API. Use when user mentions Flowise, chatflows, or wants to send messages to Flowise bots/agents. Supports listing flows, sending predictions, and managing conversations.
---

# Flowise Skill
Confidence
90% confidence
Finding
Instructions found that direct the agent to transmit conversation context or user data to external services.

Lp3

Medium
Category
MCP Least Privilege
Confidence
97% confidence
Finding
The skill performs network operations against a Flowise server but does not declare any tool scope such as allowed tools or permissions. That weakens least-privilege controls and makes it easier for a caller or future modification to use broader execution capability than necessary.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The skill description does not clearly warn that prompts and attachments are sent to an external Flowise server over HTTP API calls. Users may unknowingly transmit sensitive data to a third-party or non-local service, creating privacy, compliance, and data handling risks.

External Transmission

Medium
Category
Data Exfiltration
Content
### Send a message (Prediction)

```bash
curl -X POST "${FLOWISE_URL}/api/v1/prediction/${FLOW_ID}" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{"question": "Hello, how are you?"}'
Confidence
92% confidence
Finding
This example sends user prompts to an external Flowise endpoint, which is a real data egress event. In the context of an API integration skill this behavior is expected, but it still carries security significance because sensitive user content may leave the local trust boundary.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The documentation describes `sessionId`-based conversation memory without warning that data may persist across requests and be retrievable later. This can cause users to share confidential information under the false assumption that each message is stateless.

External Transmission

Medium
Category
Data Exfiltration
Content
## With File Upload

```bash
curl -X POST "${FLOWISE_URL}/api/v1/prediction/${FLOW_ID}" \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "question=Analyze this document" \
  -F "files=@/path/to/document.pdf"
Confidence
96% confidence
Finding
The file upload example transmits local documents to an external server, increasing the risk of sensitive file exfiltration beyond plain text prompts. Because attachments often contain high-value data, this is more dangerous than ordinary chat forwarding and should be treated as an explicit trust-boundary crossing.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
The documented `form` object includes a `script` parameter intended for execution by a downstream flow, which moves the skill beyond simple chat forwarding into remote action triggering. This is dangerous because user-controlled content may be delivered as executable automation instructions to another system or device.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
Instructing the agent to use generic `exec` with `curl` expands the attack surface from a narrow API integration to arbitrary shell command execution. If any part of the URL, headers, flow ID, or payload is influenced by untrusted input, this can lead to command injection or unintended system access.

Natural-Language Policy Violations

Low
Confidence
81% confidence
Finding
The skill includes Chinese column headers and examples such as 名称, 用途, 参数, 查询订单状态, and 小红书, which imposes a partial locale expectation in the instructions. There is no indication that the skill is region-specific or that users may choose another language, so this is a natural-language locale policy issue.

Static analysis

No suspicious patterns detected.