Back to skill

Security audit

Multipass

Security checks for vulnerabilities and agentic risk

Overview

This skill is not proven malicious, but it needs review because it can autonomously run external tooling, use disposable accounts, persist credentials outside its stated sandbox, and self-update from GitHub.

Install only if you are comfortable with an autonomous skill that can search and call external services, create disposable signups, store run records and some credentials outside the session directory, and update its own repository. Review or remove the self-update script, require explicit approval for identity/credential use and replay, and treat downloaded skills as untrusted data rather than executable instructions.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • 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)

T01 · Skill Instruction Hijacking

Error
Location
references/workflow.md:30
Finding
Untrusted Third-Party Skill Instructions Enter the Agent Execution Context## Vulnerability Details **File Location**: `references/workflow.md:30-58` **Related Location**: `references/surfaces.md:148-175` **Vulnerability Type**: Untrusted instructions used as Agent execution context **Risk Level**: High **Relevant code snippet:** ```markdown **Resolution preference:** 1. Free API, no auth → `web_fetch` 2. Free API, key via signup → throwaway identity + `web_fetch` 3. MCP server → `mcporter call {url}.{tool}` or direct HTTP 4. Downloaded skill → read SKILL.md as context **All network calls use retry logic** (see `references/resilience.md` §Retry). 3 attempts, exponential backoff, before skipping. **Identity provisioning** (only when needed): create throwaway inbox from cascade in `references/resilience.md` §Identity. Use BotEmail first (longest-lived). If all providers fail, proceed without signup capability — restrict to no-auth candidates only. **When a candidate fails** (signup blocked, gate hit, endpoint down): - Skip to next candidate. If no candidates remain, try the next approach from Phase 1. - If all approaches exhausted, apply reframing tactics from `references/resilience.md` §Reframing. - If reframing fails, proceed to Phase 4 and produce a failure report. **When a gate is hit** (CAPTCHA, browser login, SMS): - Search installed skills and MCP servers for a handler (see `references/resilience.md` §Gates). Max search depth: 1 (do not search for handlers of handlers). - If handler found, use it. If not, skip the service. Write `manifest.json` with status `resolved`. ## Phase 3: Execute Spawn `worker:execute` with the resolved tools and the fallback approach baked into the task description so it can pivot without returning to the orchestrator. The worker: - Calls APIs via `web_fetch` (with retry) - Calls MCP servers via `mcporter call` by URL or direct HTTP - Uses downloaded SKILL.md as context - Uses session identity for signups ``` The external discovery p ...[truncated 3505 chars]
Remediation
## Remediation Suggestions 1. Do not place downloaded `SKILL.md` or README contents into the worker's governing instruction context. 2. Treat remote Skill content strictly as untrusted data and parse only an allowlisted schema containing fields such as name, version, interface, and required parameters. 3. Require a local static security review before any downloaded Skill instructions can influence execution. 4. Enforce task-scoped capabilities independently of candidate content: - Restrict filesystem access to the session directory. - Restrict network access to explicitly selected endpoints. - Expose only the MCP methods required for the original task. - Deny access to unrelated credentials and host configuration. 5. Bind every action to the original user request and reject candidate instructions that introduce unrelated objectives, destinations, files, or credentials. 6. Separate planning data from executable instructions using a structured intermediate representation rather than natural-language context. 7. Record the exact candidate source and immutable revision, and present the reviewed action plan before executing any candidate that contains imperative instructions. 8. Treat external security scans and reputation signals only as supplementary evidence, not as authorization to execute instruction text.

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/update.sh:8
Finding
Self-Update Unconditionally Deletes Local Repository Changes## Vulnerability Details **File Location**: `scripts/update.sh:8-11` **Related Location**: `references/self-update.md:3-9` **Vulnerability Type**: Destructive update behavior without confirmation or dirty-worktree protection **Risk Level**: Medium **Complete vulnerable code snippet:** ```bash cd "$(dirname "$0")/.." git reset --hard HEAD 2>/dev/null git clean -fd 2>/dev/null git pull 2>/dev/null ``` The documented user-facing behavior is: ```markdown `multipass.update` pulls the latest version from GitHub and restarts the skill's background tasks if applicable. ```bash multipass.update ``` This pulls the latest version from GitHub and restarts the skill's background tasks if applicable. ``` ### Technical Analysis Invoking the updater unconditionally runs two destructive Git operations before pulling changes: - `git reset --hard HEAD` discards modifications to tracked files. - `git clean -fd` recursively removes untracked files and directories. The script has no dirty-worktree check, dry-run mode, backup, explicit destructive flag, or interactive confirmation. Standard error is redirected to `/dev/null`, which also suppresses useful failure details. The documented authorization is to pull the latest version. It does not disclose that local tracked modifications and untracked content will be deleted. The implementation therefore expands a routine update request into an irreversible cleanup operation without obtaining specific authorization. This is an unsafe coding practice rather than evidence of intentional sabotage: the behavior is visible in a short updater script and is consistent with an overly aggressive attempt to force a clean update. ### Attack Path 1. A user or Agent modifies a tracked file or creates an untracked file or directory inside the Skill repository. 2. The user or Agent invokes `multipass.update`, expecting the documented GitHub update operation. 3. The script changes ...[truncated 972 chars]
Remediation
## Remediation Suggestions 1. Remove `git reset --hard` and `git clean -fd` from the default update path. 2. Check for local changes before updating: ```bash if ! git diff --quiet || ! git diff --cached --quiet || [[ -n "$(git ls-files --others --exclude-standard)" ]]; then echo "Update refused: the worktree contains local changes." >&2 exit 1 fi ``` 3. Use `git pull --ff-only` so an update cannot silently rewrite divergent local history. 4. If destructive cleanup is genuinely required, place it behind an explicit flag such as `--discard-local-changes`. 5. Before honoring that flag, display the affected files using `git status --short` and `git clean -nd`. 6. Require explicit confirmation or a separately documented noninteractive confirmation parameter. 7. Offer to create a backup branch or stash before modifying the worktree. 8. Update `references/self-update.md` to disclose the exact behavior, safety checks, and recovery procedure. 9. Stop suppressing all Git errors; report update failures clearly so users can determine whether any destructive step already completed.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (40)

Self-Modification

High
Category
Rogue Agent
Content
- README.md: user-facing overview with commands, setup, dependencies, and storage layout
- CHANGELOG.md: version history
- references/journal.md: Action Journal and Research Journal specification per spec-ocas-journal.md v1.3
- skill.json: skill_type, filesystem read/write permissions, self_update configuration

## [3.0.0] - 2026-04-04
Confidence
90% confidence
Finding
Skill modifies its own code, configuration, or behavior at runtime. Self-modification enables an agent to escalate privileges, disable safety constraints, or install persistent backdoors.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill is presented as isolated and disposable, but it also documents self-update behavior that pulls code from GitHub and implies repository mutation and network-driven code changes. That mismatch is dangerous because operators may invoke the skill expecting sandbox-only execution while it can alter its own code or workspace state, expanding trust and supply-chain risk beyond the stated boundary.

Intent-Code Divergence

High
Confidence
99% confidence
Finding
The skill claims absolute session isolation, but the token storage rules instruct writing credentials to ~/.hermes, which is outside the session directory and persistent across runs. This breaks containment and can leak or reuse credentials across sessions, users, or other skills, undermining the stated sandbox model.

Self-Modification

High
Category
Rogue Agent
Content
- **Failure reports are valid outputs** — If all approaches fail, the manifest documents every tried path and failure reason. A complete failure report is still a useful artifact and counts as task completion.
- **Session isolation is absolute** — All files must stay within the session directory. Nothing leaks to the platform, global config, or other sessions. An isolation violation is a serious incident.

## Self-Update

`multipass.update` pulls the latest version from GitHub. See `references/self-update.md`.
Confidence
98% confidence
Finding
A self-update command that pulls the latest version from GitHub enables the skill to change its own behavior based on remote content. Without strong verification and authorization controls, this creates a supply-chain and self-modification risk that can bypass the original review state of the skill.

Self-Modification

High
Category
Rogue Agent
Content
## Self-Update

`multipass.update` pulls the latest version from GitHub. See `references/self-update.md`.

## Support File Map
Confidence
98% confidence
Finding
The self-update behavior is reiterated in operational documentation, confirming that remote code retrieval is part of the intended lifecycle. This increases the likelihood that unreviewed code changes can be introduced into an ostensibly isolated execution tool, compounding trust-boundary violations.

Self-Modification

High
Category
Rogue Agent
Content
| `references/resilience.md` | When an endpoint fails or returns an error; when provisioning throwaway identity; when hitting CAPTCHA/gates; when applying reframing tactics |
| `references/loop-prevention.md` | Before any worker execution; when enforcing circuit breakers and anti-stall rules |
| `references/okrs.md` | During OKR evaluation. Skill-specific targets for tool invocation, spawn depth, isolation, schedule, data integrity. |
| `references/self-update.md` | When running `multipass.update`. |
| `references/interactive-menu.md` | When invoked interactively via `/` command. |
| `references/storage-layout.md` | When creating or inspecting session directories. |
Confidence
96% confidence
Finding
Referencing self-update procedures in the support map signals that updating is a routine supported operation, not an incidental note. For a highly autonomous skill, normalizing self-modification magnifies the risk of supply-chain compromise or drift from the reviewed behavior set.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The skill explicitly provisions a throwaway email account and stores provider authentication data in `manifest.json`, extending the skill from tool-gap execution into credential handling and account creation. That broader capability increases the blast radius of compromise and creates a clear secret-management risk, especially because the data is then available to later workflow steps and workers.

Missing User Warnings

High
Confidence
99% confidence
Finding
The documentation directs sensitive authentication data to be stored in `manifest.json` without any indication of encryption, access restriction, masking, or user disclosure. In a multi-worker orchestration environment, plaintext secret storage materially increases the chance of accidental exposure through filesystem reads, logs, crash artifacts, or downstream task propagation.

Ssd 3

High
Confidence
99% confidence
Finding
The workflow stores authentication data in the session manifest and then tells the execute worker to read it from `manifest.json`, effectively propagating secrets through a shared control plane. This broadens exposure to any worker or process with workspace access and makes secret leakage through checkpoints, debug output, or compromised sub-agents much more likely.

Self-Modification

High
Category
Rogue Agent
Content
# Multipass — Self-Update

`multipass.update` pulls the latest version from GitHub and restarts the skill's background tasks if applicable.
Confidence
95% confidence
Finding
The explicit 'Self-Update' feature indicates self-modification, which is especially risky in an agent skill because it can change its behavior after initial review. Combined with fetching code from GitHub and restarting background tasks, it creates a path for persistence and unreviewed code execution that makes the skill context more dangerous, not less.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
exit 0
fi
cd "$(dirname "$0")/.."
git reset --hard HEAD 2>/dev/null
git clean -fd 2>/dev/null
git pull 2>/dev/null
Confidence
91% confidence
Finding
`git reset --hard HEAD` is a destructive command that can be abused or cause unintended data loss when run automatically in the repository root without validating context or obtaining consent. While it is not parameter injection in the classic sense here, it is still a real security-relevant issue because it forcibly alters the workspace and can wipe analyst or operator changes during an update operation.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The README advertises autonomous execution, sandboxed tool use, and replayable task execution, but it does not warn users that these actions can still modify files, consume resources, interact with external systems, or repeat impactful operations. In a skill explicitly designed to fill capability gaps by executing tools on the user's behalf, omission of user-facing safety boundaries increases the chance of unsafe invocation and misunderstanding of the operational risk.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The `multipass.replay` command is described as re-executing a replay script in a new session, but the README does not caution that replay can reproduce destructive or irreversible actions such as file changes, network calls, account operations, or duplicate submissions. Because replay is presented as a normal workflow feature, users may treat it as harmless repetition when it can actually duplicate side effects.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The trigger phrases are broad enough to match many normal requests involving missing tools or generic task difficulty, increasing the chance the skill activates unexpectedly. In combination with autonomous execution, accidental invocation could cause unintended network access, credential handling, or persistent writes without deliberate user intent.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
# Multipass

Accomplish tasks that require tools you don't have. Fire and forget. User invokes `multipass.run {task}`, Multipass runs to completion, user gets the output. No check-ins, no approval gates, no escalation.

Everything happens inside a session directory. Nothing touches the rest of the agent platform.
Confidence
90% confidence
Finding
The skill explicitly removes approval gates and escalation while authorizing itself to plan, discover, provision identity, and execute autonomously. That level of unattended action is risky because mistakes, harmful task interpretations, or abuse of broad triggers can proceed without a human checkpoint.

Intent-Code Divergence

Medium
Confidence
97% confidence
Finding
The statement that nothing touches the rest of the platform is contradicted by later writes to shared journal/evidence paths and home-directory token files. This is dangerous because it creates a false assurance of containment while persisting potentially sensitive operational data outside the sandbox.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The skill description emphasizes isolation but omits a clear warning that it writes journals, evidence, and tokens outside the session directory. Users and orchestrators may therefore approve or route tasks under a false privacy and containment assumption, which raises the risk of unintentional data persistence.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The journal spec requires persistent per-run logging of session metadata and task details, including task descriptions, resolved tools, session directories, and execution outcomes, but it provides no requirement for user notice, consent, minimization, or redaction. In a skill designed to bridge capability gaps and execute tasks in sandboxed sessions, these journals can capture sensitive prompts, operational context, and artifact locations, creating a privacy and data-retention risk if accessed by other components or users.

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
The documentation instructs use of `npx -y mcporter` without pinning a specific version or integrity hash, which can pull whatever package version is current at execution time. In an orchestration skill that spawns workers and bridges access to external tooling, this creates a supply-chain execution risk where a compromised or malicious upstream package could gain code execution inside the session.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
Allowing fallback from MCP tooling to direct HTTP JSON-RPC weakens the stated isolation model because the safety controls and mediation provided by the MCP pathway may no longer apply consistently. In practice this can expand network reach, bypass expected guardrails, and make security properties depend on ad hoc endpoint handling rather than a constrained tool interface.

Description-Behavior Mismatch

Medium
Confidence
92% confidence
Finding
The manifest says the skill should not be used for general web research and instead defers that use case to Sift. However, the worker definition for `apis` explicitly includes `general web` as a discovery surface, meaning the documented behavior overlaps with the excluded purpose.

Intent-Code Divergence

Medium
Confidence
87% confidence
Finding
The manifest/skill description says 'No real identity,' but this orchestration doc instructs the system to provision an inbox, persist the email address, and store associated authentication data in `manifest.json`. Even if disposable, this is still active identity creation and use, which contradicts the plain-language claim rather than merely adding implementation detail.

Vague Triggers

Medium
Confidence
96% confidence
Finding
This markdown file uses a very broad trigger phrase: 'Read this file when anything goes wrong.' That activation condition is ambiguous because it does not define scope, types of failures, or exclusion conditions, which could cause the skill or guidance to be invoked for ordinary minor issues or unrelated problems.

External Transmission

Medium
Category
Data Exfiltration
Content
| Priority | Provider | TTL | Create | Poll |
|----------|----------|-----|--------|------|
| 1 | BotEmail.ai | 6 months | `POST https://api.botemail.ai/api/create-account` body: `{}` | `GET https://api.botemail.ai/api/emails/{email}` header: `Authorization: Bearer {key}` |
| 2 | Mail.tm | days | `POST https://api.mail.tm/accounts` (get domains: `GET https://api.mail.tm/domains`) | `POST https://api.mail.tm/token` then `GET https://api.mail.tm/messages` with Bearer token |
| 3 | 1secmail | ~1 hour | `GET https://www.1secmail.com/api/v1/?action=genRandomMailbox` | `GET https://www.1secmail.com/api/v1/?action=getMessages&login={user}&domain={domain}` |
| 4 | Guerrilla Mail | 60 min | `GET https://api.guerrillamail.com/ajax.php?f=get_email_address` | `GET https://api.guerrillamail.com/ajax.php?f=check_email&seq=0&sid_token={token}` |
Confidence
89% confidence
Finding
This instructs the agent to create and use disposable email accounts with a third-party provider, which causes task data, verification flows, and access tokens to be transmitted to an external service not controlled by the user. In the context of a multipass execution skill, this is more dangerous because it automates identity creation and may expose account recovery or signup-related data outside the primary task boundary.

External Transmission

Medium
Category
Data Exfiltration
Content
| Priority | Provider | TTL | Create | Poll |
|----------|----------|-----|--------|------|
| 1 | BotEmail.ai | 6 months | `POST https://api.botemail.ai/api/create-account` body: `{}` | `GET https://api.botemail.ai/api/emails/{email}` header: `Authorization: Bearer {key}` |
| 2 | Mail.tm | days | `POST https://api.mail.tm/accounts` (get domains: `GET https://api.mail.tm/domains`) | `POST https://api.mail.tm/token` then `GET https://api.mail.tm/messages` with Bearer token |
| 3 | 1secmail | ~1 hour | `GET https://www.1secmail.com/api/v1/?action=genRandomMailbox` | `GET https://www.1secmail.com/api/v1/?action=getMessages&login={user}&domain={domain}` |
| 4 | Guerrilla Mail | 60 min | `GET https://api.guerrillamail.com/ajax.php?f=get_email_address` | `GET https://api.guerrillamail.com/ajax.php?f=check_email&seq=0&sid_token={token}` |
Confidence
89% confidence
Finding
The Mail.tm flow similarly transmits signup and mailbox access data to an external disposable-email provider, including bearer-token-based mailbox retrieval. Because this skill is designed to autonomously fill capability gaps, it could create and monitor mailboxes without meaningful user visibility, increasing privacy and account-security risk.

Static analysis

No suspicious patterns detected.