Back to skill

Security audit

OpenFleet

Security checks for vulnerabilities and agentic risk

Overview

This skill discloses its OpenFleet control purpose, but it uses high-impact setup patterns that need review before installation.

Review this skill carefully before installing. Use a pinned and trusted @open-fleet/mcp-server version, prefer least-privilege or short-lived OpenFleet credentials, inspect any MCP client configuration changes, and avoid exposing the OpenClaw gateway publicly unless strong authentication, token rotation, origin restrictions, and sandboxed agent execution are in place.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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

Error
Location
SKILL.md:108
Finding
Unpinned Third-Party Package Is Downloaded and Executed Through npx## Vulnerability Details **File Location**: `SKILL.md`, lines 108–117 **Vulnerability Type**: Supply-chain risk from unpinned remote package execution **Risk Level**: High **Vulnerable Code Snippet**: ```bash npx @open-fleet/mcp-server setup ``` The setup wizard auto-detects Claude Code, Cursor, and Windsurf and configures MCP automatically. **Direct npx invocation** (for custom configs): ```bash OPENFLEET_API_KEY=ofk_xxx npx -y @open-fleet/mcp-server ``` ### Technical Analysis The documented commands instruct users to resolve and execute `@open-fleet/mcp-server` from the npm registry without specifying an exact audited version or package integrity value. Consequently, the code executed at installation time can change after the Skill itself has been reviewed. The `-y` option automatically accepts installation prompts, reducing the opportunity for users to inspect the resolved package and version. The `setup` command is also documented as automatically changing MCP configurations for detected applications. An npm package executes with the invoking user's permissions and may inherit environment variables, including `OPENFLEET_API_KEY`. This finding does not establish that the current npm package is malicious. The vulnerability is the unsafe trust and execution model: a compromised maintainer account, malicious release, registry incident, or unexpected future package version could turn the documented command into an arbitrary-code execution path. ### Attack Path 1. An attacker compromises the npm publisher account, package source, release pipeline, or another component of the package distribution chain. 2. The attacker publishes a malicious version under the legitimate `@open-fleet/mcp-server` package name. 3. A user follows the Skill documentation and invokes the package without an exact version constraint. 4. `npx` resolves and downloads the attacker-controlled release; with `-y`, installation proceeds without a ...[truncated 837 chars]
Remediation
## Remediation Suggestions - Pin the package to a specific, reviewed version, for example `@open-fleet/mcp-server@X.Y.Z`. - Commit and enforce a lockfile where the surrounding installation system supports one. - Verify package provenance and integrity using npm registry signatures, checksums, or an equivalent trusted mechanism. - Remove `-y` from security-sensitive setup instructions so that users can inspect the package and resolved version before execution. - Document every configuration file and setting that the setup wizard modifies. - Prefer manual, reviewable configuration over automatic client discovery and modification. - Execute the server in a sandbox or restricted service account with access only to necessary files and environment variables. - Use a scoped, short-lived OpenFleet credential rather than a broadly privileged, long-lived API key. - Establish a controlled upgrade process in which new package versions are reviewed and tested before being recommended.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:120
Finding
Internet-Exposed Agent Gateway Enables High-Privilege External Task Execution## Vulnerability Details **File Location**: `SKILL.md`, lines 120–135 **Vulnerability Type**: Excessive external control and unsafe gateway exposure **Risk Level**: High **Vulnerable Code Snippet**: ```markdown When you connect OpenFleet with an OpenClaw gateway, this skill completes the **bidirectional link**: | Direction | What it does | |-----------|-------------| | **OpenFleet → OpenClaw** | OpenFleet sends tasks to your gateway for execution | | **OpenClaw → OpenFleet** | This skill lets OpenClaw manage tasks, agents, and pulse | ### Full setup 1. Start your OpenClaw gateway: `openclaw gateway` 2. Expose it: `cloudflared tunnel --url http://localhost:18789` 3. Connect the tunnel URL + token in [OpenFleet Settings](https://app.openfleet.sh) 4. Install this skill: `clawhub install openfleet` ``` ### Technical Analysis The documented integration exposes a service bound to localhost through a Cloudflare Tunnel and permits OpenFleet to submit tasks to the OpenClaw gateway for execution. This changes the gateway from a locally reachable service into an externally accessible control plane. The behavior is disclosed as a bidirectional integration, but the instructions do not specify least-privilege token scopes, task-level authorization, action allowlists, user confirmation requirements, source restrictions, credential rotation, or isolation of the executing agent. Because tasks received through the gateway may be handled by an agent with access to local tools and data, compromise of the gateway token, OpenFleet account, orchestration service, or related control plane could cross the local trust boundary. The Cloudflare Tunnel itself is not inherently a vulnerability. The risk arises from exposing an agent execution endpoint without documenting the security controls required to constrain who may submit work and what externally submitted tasks may do. ### Attack Path 1. A user starts the local OpenClaw gateway a ...[truncated 1713 chars]
Remediation
## Remediation Suggestions - Avoid exposing the gateway publicly when a private network, authenticated service connector, or outbound-only task polling architecture can be used. - Require strongly authenticated, mutually verified connections between OpenFleet and the gateway. - Use short-lived, narrowly scoped gateway tokens and rotate them regularly. - Store gateway and API tokens in an appropriate secret manager rather than general configuration or logs. - Restrict accepted task origins to explicitly authorized workspace and service identities. - Add task-level authorization and mandatory human confirmation for filesystem access, command execution, credential use, destructive actions, agent creation, automation creation, template installation, and pulse triggering. - Implement explicit action and tool allowlists for remotely submitted tasks. - Run the gateway and executing agents in a sandboxed, least-privilege account with restricted filesystem and network access. - Apply rate limits, replay protection, expiration timestamps, and request signing to task-dispatch messages. - Maintain tamper-resistant audit logs covering authentication, submitted tasks, approvals, tool calls, and execution results. - Document token revocation and incident-response procedures for a compromised OpenFleet account, gateway token, or tunnel endpoint.
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
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (6)

Rp1

Medium
Category
MCP Rug Pull
Confidence
88% confidence
Finding
The skill declares `npx` as a required binary and later instructs users to run an MCP server package directly from npm without pinning a version. In a security-sensitive agent integration, this creates a supply-chain risk: a newly published or compromised package version could be executed automatically with access to the user's OpenFleet API key and local agent environment.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The skill advertises numerous state-changing operations—creating tasks, deleting tasks, approving review items, triggering automations, and triggering pulse cycles—without warning that these actions can modify live workspace state or start agent execution. In an agentic environment, vague user prompts could be translated into impactful operations with little friction, increasing the chance of accidental destructive or costly actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
98% confidence
Finding
The manual setup command uses `npx @open-fleet/mcp-server setup` without an exact version, causing whatever package version is current at execution time to run on the user's machine. Because this server mediates task, agent, and automation control and may access `OPENFLEET_API_KEY`, a compromised upstream release could lead to credential theft or unauthorized workspace actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
99% confidence
Finding
The direct invocation example `OPENFLEET_API_KEY=ofk_xxx npx -y @open-fleet/mcp-server` runs the latest package non-interactively and passes a live API key into the execution environment. This is especially dangerous because the package is an MCP server with bidirectional control over agents and tasks, so a malicious or hijacked release could immediately exfiltrate secrets or perform unauthorized actions.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The setup instructs users to expose a local OpenClaw gateway via `cloudflared tunnel` but does not warn about the security implications of publishing a local control surface to the internet. Given the documented bidirectional control between OpenFleet and OpenClaw, an exposed or misconfigured gateway could enable unauthorized access to local agent execution or workspace management.

Static analysis

No suspicious patterns detected.