Back to skill

Security audit

orca

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly coherent for Orca session management, but it includes persistent cross-harness plugin installation guidance and mutable symlink installs that users should review before trusting.

Review the exact Orca source, commit, and destination before installing. Prefer project-scoped or copied installs over global symlinks unless you want live updates, and treat any command examples containing task names or prompts as argument values that must be safely escaped or passed without shell interpolation.

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)

T09 · Insecure Skill Coding Practices

Error
Location
launch.md:53
Finding
Shell command injection through unsafe interpolation of user-controlled prompts and names<![CDATA[ ## Vulnerability Details **File Location**: `launch.md:53-56`, `launch.md:84-88`, and `send.md:76-80` **Vulnerability Type**: Shell command injection caused by unsafe command construction **Risk Level**: High ### Vulnerable Code From `launch.md:53-56`: ```bash ## Independent new worktree (default) ```bash ORCA worktree create --repo id:<repoId> --name <task-name> --no-parent --agent <agent> --prompt "<task brief>" --json ``` ``` From `launch.md:84-88`: ```bash ```bash ORCA worktree create --name <task-name> --no-parent --json ORCA terminal create --worktree id:<repoId>::<newWorktreePath> --title <task-name> --command 'codex --model gpt-5.5 -c model_reasoning_effort="xhigh"' --json ORCA terminal wait --terminal <handle> --for tui-idle --timeout-ms 60000 --json ORCA terminal send --terminal <handle> --text "<task brief>" --enter --json ``` ``` From `send.md:76-80`: ```bash ```bash ORCA terminal read --terminal <handle> --json ORCA terminal wait --terminal <handle> --for tui-idle --timeout-ms 300000 --json ORCA terminal send --terminal <handle> --text "<message>" --enter --json ``` ``` ### Technical Analysis The Skill instructs an Agent to substitute task names, task briefs, messages, terminal handles, worktree paths, and agent identifiers directly into shell command templates. Free-form prompt text is placed inside double quotes, while some other dynamic values are not quoted at all. Double quotes in the template do not safely handle text that itself contains an unescaped double quote. Because an Agent commonly constructs the final Bash command by replacing placeholders before invoking the Bash tool, malicious text can terminate the intended quoted argument and introduce shell operators or additional commands. For example, if a task brief is rendered into the template as: ```text "; touch /tmp/orca-injected; # ``` the resulting command can become: ```bash orca terminal send --terminal term_123 --text ""; touch /tmp/orca-injected; #" --ente ...[truncated 1846 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not construct Bash command strings by directly substituting user-controlled text. 2. Invoke the Orca executable through an API that accepts an argument array, keeping each dynamic value as a distinct argument. 3. If execution must pass through Bash, encode every dynamic argument with a proven shell-escaping mechanism such as `printf '%q'`; do not implement ad hoc quote replacement. 4. Prefer Orca options that accept prompt content through stdin, a file descriptor, or a JSON request file when available. 5. Validate structured identifiers separately: - Restrict terminal handles and repository IDs to their documented formats. - Restrict agent names to Orca's supported allowlist. - Validate worktree selectors returned by the Orca CLI before reuse. 6. Update the documentation with an explicit warning that placeholders are argument values, not raw shell fragments. 7. Add regression tests containing double quotes, semicolons, newlines, backticks, command substitutions, and redirection characters in task names and prompts. 8. Confirm the current Orca CLI interface before selecting an input mechanism, as required by the Skill's own command-source-of-truth policy. ]]>

T08 · Insecure Dependencies

Warning
Location
install.md:9
Finding
External Skill bundles are installed from mutable and unverified sources<![CDATA[ ## Vulnerability Details **File Location**: `install.md:9-18`, `install.md:23-30`, `install.md:35-44`, and `install.md:55-72` **Vulnerability Type**: Unpinned and unverified third-party Skill installation **Risk Level**: Medium ### Vulnerable Code From `install.md:9-18`: ```markdown ## Step 1 — Ask how to source the repo (mandatory) Before installing anything, ask the user which of these two they want: | Option | Trade-off | |---|---| | **ghq-clone + symlink/junction** | Repo updates (`git pull`) are reflected immediately in every installed harness. The clone accumulates local, untracked install-manifest files (see Step 2) that can confuse later work in that clone if not tracked. | | **Plain marketplace/package install** | Installer copies into its own cache; the source clone stays untouched. Updates require an explicit `plugin update`/`plugins update` per harness. | Do not default to one silently — this is a durable choice about how future updates propagate, not a one-off preference. ``` From `install.md:23-30`: ```bash ### Claude Code Requires `.claude-plugin/marketplace.json` at the repo root (Orca does not ship one). ```bash # Write .claude-plugin/marketplace.json with at least one plugin entry pointing at "./" claude plugin marketplace add <path-to-orca-clone-or-manifest-dir> claude plugin install orca@<marketplace-name> ``` ``` From `install.md:35-44`: ```bash ### OpenClaw No manifest file is required. OpenClaw's bundle detector recognizes the **manifestless Claude layout** (a `skills/` directory with no `.claude-plugin/plugin.json`) directly, so a plain link is enough: ```bash openclaw plugins install --link <path-to-orca-clone> # or, reusing the marketplace.json created for Claude Code above: openclaw plugins install <plugin-name> --marketplace <source> ``` ``` From `install.md:55-72`: ```bash ### Antigravity Two things are required, neither of which Orca ships: 1. A `plugin.json` at the plugin's root. The minimal working form ...[truncated 2938 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Specify and enforce the canonical repository and approved marketplace identities rather than accepting an unconstrained source. 2. Pin installations to an immutable, reviewed commit hash or versioned release artifact. 3. Verify a cryptographic checksum or trusted release signature before copying or linking Skill content. 4. Display the resolved repository URL, commit hash, plugin identity, and destination to the user before installation. 5. Require renewed approval before updating to a different commit. 6. Avoid linking installations to mutable branches. If symlinks are required for development, clearly label them as a development-only mode and pin or verify the checked-out commit. 7. Inspect manifests, Skill instruction files, and executable scripts before enabling the plugin. 8. Record the verified source and revision in the generated installation manifest. 9. Prefer project-scoped installation when global installation is unnecessary, limiting the number of future sessions exposed to a compromised bundle. 10. Extend the existing post-install verification to check provenance and revision, not merely whether the harness reports the plugin as enabled. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
  • Rogue AgentSelf-Modification, Session Persistence
Findings (9)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared description presents user-facing Orca operations: finding terminals and sending prompts, launching agent sessions, and installing skill bundles. The actual code chunk does none of those tasks directly. Instead, it functions as a guardrail hook for Bash usage, parsing JSON tool input, hashing the transcript path to create a session marker, recognizing specific Orca CLI commands, and preventing certain new-tab/new-worktree launches unless prerequisite checks or an opt-out are present. While this is related to Orca workflows, its primary purpose and trigger are materially different from the declared capabilities. This is therefore a description-behavior mismatch.

Agent Config Directory Access

High
Category
Agent Snooping
Content
```
   (observed as sufficient on working local plugins — extra fields like `description`,
   `version`, `$schema` are optional decoration, not requirements.)
2. Placement under `~/.gemini/config/plugins/orca/` (global) or the workspace's
   `.agents/plugins/orca/` / `_agents/plugins/orca/` (project-scoped), with the `skills/`
   directory from the Orca clone copied or symlinked in alongside `plugin.json`.
Confidence
95% confidence
Finding
This instruction directs the agent to place plugin files under Antigravity's global or project-scoped agent plugin directories, which are trusted configuration locations that can cause code-bearing skills to be loaded in future sessions. Writing into such directories establishes persistence and expands the attack surface beyond the current task, so an agent following these steps could unintentionally install unreviewed capabilities into another harness.

Agent Config Directory Access

High
Category
Agent Snooping
Content
directory from the Orca clone copied or symlinked in alongside `plugin.json`.

```bash
mkdir -p ~/.gemini/config/plugins/orca
echo '{"name":"orca"}' > ~/.gemini/config/plugins/orca/plugin.json
# then symlink or copy <orca-clone>/skills into ~/.gemini/config/plugins/orca/skills
```
Confidence
97% confidence
Finding
The command creates a plugin directory inside ~/.gemini/config and writes plugin metadata there, directly modifying a trusted global configuration path. Because plugin registration in such a path can enable persistent loading of bundled skills in later sessions, this is dangerous if the repo contents are malicious, outdated, or not independently reviewed.

Agent Config Directory Access

High
Category
Agent Snooping
Content
```bash
mkdir -p ~/.gemini/config/plugins/orca
echo '{"name":"orca"}' > ~/.gemini/config/plugins/orca/plugin.json
# then symlink or copy <orca-clone>/skills into ~/.gemini/config/plugins/orca/skills
```
Confidence
96% confidence
Finding
This step instructs symlinking or copying the Orca skills bundle into the trusted plugin directory, which effectively grants those skills future execution within Antigravity. Symlinks are especially risky because later changes to the source clone immediately propagate into the live plugin, creating durable and potentially silent persistence.

Agent Config Directory Access

High
Category
Agent Snooping
Content
```bash
mkdir -p ~/.gemini/config/plugins/orca
echo '{"name":"orca"}' > ~/.gemini/config/plugins/orca/plugin.json
# then symlink or copy <orca-clone>/skills into ~/.gemini/config/plugins/orca/skills
```

Then register it in `~/.gemini/config/config.json` under the top-level `plugins` key:
Confidence
94% confidence
Finding
The instruction to register the plugin in ~/.gemini/config/config.json enables persistent activation from a global agent configuration file. Enabling a plugin this way can cause automatic availability of the installed skills in future sessions, making any malicious or vulnerable content in the bundle more impactful than a one-time manual action.

Agent Config Directory Access

High
Category
Agent Snooping
Content
# then symlink or copy <orca-clone>/skills into ~/.gemini/config/plugins/orca/skills
```

Then register it in `~/.gemini/config/config.json` under the top-level `plugins` key:

```json
{ "plugins": { "orca": { "enabled": true } } }
Confidence
93% confidence
Finding
The documented JSON entry explicitly enables the plugin in the global Antigravity configuration, turning file placement into an active persistent install. In the context of an agent skill, instructing another agent to enable plugins in its own config is security-sensitive because it modifies trusted runtime behavior across future sessions.

Lp3

Medium
Category
MCP Least Privilege
Confidence
89% confidence
Finding
The skill explicitly instructs the agent to read environment variables such as ORCA_CLI_COMMAND, ORCA_DEV_REPO_ROOT, and ORCA_PANE_KEY, but the manifest declares no tool scope or permissions boundary for env access. That creates an undeclared capability surface: an agent may rely on sensitive runtime state without any user-visible declaration, which can leak local paths, execution context, or influence command selection in ways the user did not explicitly authorize.

Session Persistence

Medium
Category
Rogue Agent
Content
Requires `.claude-plugin/marketplace.json` at the repo root (Orca does not ship one).

```bash
# Write .claude-plugin/marketplace.json with at least one plugin entry pointing at "./"
claude plugin marketplace add <path-to-orca-clone-or-manifest-dir>
claude plugin install orca@<marketplace-name>
```
Confidence
84% confidence
Finding
This guidance tells the agent to create marketplace metadata in the repository root and then install the plugin into Claude Code, which establishes persistence in another harness rather than performing a transient action. Although framed as normal setup, it changes trusted plugin state and can leave durable repo artifacts that affect later use and updates.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
one surviving candidate means one terminal passed the filter, not that the user
wants that terminal. The "keep already-running sessions alive" guard is a
destruction-prevention rule, not a target-selection rule — do not use it to
auto-confirm a target.

If the user already designated this target in an earlier turn, re-state it in
the ask, or prefix ORCA_SEND_TARGET_APPROVED=1 to record the opt-out.
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Static analysis

No suspicious patterns detected.