Back to skill

Security audit

coding-agent

Security checks for vulnerabilities and agentic risk

Overview

This instruction-only skill delegates coding work, but it normalizes running agents with approvals and sandboxing disabled.

Install only if you are comfortable reviewing and tightening these workflows. Prefer disposable clones or containers, limited credentials, normal approval prompts, and manual review before dependency installation, commits, pushes, PR comments, or OpenClaw system events. Avoid --yolo and permission-bypass examples unless you have separate containment in place.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:19
Finding

Claude Code Is Launched with Permission Checks Disabled

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 19-24 and 167-170
Vulnerability Type: Permission-control bypass in delegated agent execution
Risk Level: High

Vulnerable Code

markdown
For **Claude Code** (`claude` CLI), use `--print --permission-mode bypassPermissions` instead.
`--print` mode keeps full tool access and avoids interactive confirmation:

```bash
# Claude Code (no PTY needed)
cd /path/to/project && claude --permission-mode bypassPermissions --print 'Your task'
text

The unsafe mode is repeated in the standard execution examples:

```markdown
```bash
# Foreground
bash workdir:~/project command:"claude --permission-mode bypassPermissions --print 'Your task'"

# Background
bash workdir:~/project background:true command:"claude --permission-mode bypassPermissions --print 'Your task'"
text

### Technical Analysis

The skill makes `--permission-mode bypassPermissions` the required default for Claude Code. According to the skill itself, this mode retains full tool access while avoiding interactive confirmation. Consequently, commands selected by the delegated agent are not subjected to normal per-operation authorization checks.

Coding agents process repository files, task descriptions, issue content, and generated tool output as contextual instructions. If any such content is attacker-controlled, it can attempt to redirect the agent into reading unrelated files, accessing credentials, invoking system commands, modifying files outside the intended task, or transmitting information through available network tools. Disabling confirmations removes an important security boundary that could otherwise interrupt these operations.

Merely using a focused working directory does not establish a filesystem or process sandbox. Unless external enforcement exists, a process can potentially address parent directories, absolute paths, environment variables, user configuration, a
...[truncated 1429 chars]
Remediation
View remediation

Remediation Suggestions

  • Remove --permission-mode bypassPermissions from the required and example invocation patterns.
  • Use the normal permission mode and require explicit approval for shell execution, network access, sensitive file reads, and writes outside the project.
  • Run delegated agents inside a real sandbox or container with the project mounted as the only writable path.
  • Provide only narrowly scoped, short-lived credentials required for the current task; do not inherit the user's complete environment.
  • Disable network access by default and permit only explicitly required destinations.
  • Treat repository text, issue descriptions, and generated content as untrusted data rather than authoritative execution instructions.
  • If unattended operation is necessary, define an explicit allowlist of permitted commands and paths instead of bypassing all permission checks.
  • Record commands, file accesses, and network operations in an audit log, and review changes before they are committed or pushed.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:104
Finding

Codex Examples Encourage Execution Without a Sandbox or Approvals

Content
View full analysis

Vulnerability Details

File Location: SKILL.md, lines 104-114, 197-198, and 251-253
Vulnerability Type: Unrestricted delegated command execution
Risk Level: High

Vulnerable Code

markdown
| Flag            | Effect                                             |
| --------------- | -------------------------------------------------- |
| `exec "prompt"` | One-shot execution, exits when done                |
| `--full-auto`   | Sandboxed but auto-approves in workspace           |
| `--yolo`        | No sandbox, no approvals (fastest, most dangerous) |

### Building/Creating

```bash
# Quick one-shot
bash pty:true workdir:~/project command:"codex exec --full-auto 'Build a dark mode toggle'"

# Background for longer work
bash pty:true workdir:~/project background:true command:"codex --yolo 'Refactor the auth module'"
text

The unrestricted mode is also used in issue-fixing and long-running examples:

```markdown
bash pty:true workdir:/tmp/issue-78 background:true command:"pnpm install && codex --yolo 'Fix issue #78: <description>. Commit and push.'"
bash pty:true workdir:/tmp/issue-99 background:true command:"pnpm install && codex --yolo 'Fix issue #99. Implement only the in-scope edits and commit after review.'"
markdown
bash pty:true workdir:~/project background:true command:"codex --yolo exec 'Build a REST API for todos.

When completely finished, run: openclaw system event --text \"Done: Built todos REST API\" --mode now'"

Technical Analysis

The skill accurately identifies --yolo as providing “No sandbox, no approvals,” yet recommends it for routine refactoring, issue fixing, and application-building workflows. This removes both major containment layers: command approval and process sandboxing.

A working directory is only an initial process location and does not confine access to that directory. In unrestricted mode, the delegated proces ...[truncated 2332 chars]

Remediation
View remediation

Remediation Suggestions

  • Remove all recommended uses of --yolo, including the refactoring, worktree, and completion-notification examples.
  • Make sandboxed, approval-gated execution the default for Codex.
  • Use --full-auto only inside a separately enforced disposable container with strict filesystem, process, credential, and network boundaries.
  • Mount only the task-specific worktree and expose no home directory, SSH agent, cloud credentials, or unrelated source repositories.
  • Separate dependency installation from agent execution. Install dependencies with lifecycle scripts disabled where feasible, verify lockfiles, and scan dependencies before use.
  • Do not provide push credentials to the coding agent by default. Require human review and a separate authenticated step for commits, pushes, pull requests, and comments.
  • Restrict executable commands and writable paths through an allowlist or policy engine.
  • Use temporary, least-privileged credentials that cannot administer repositories or access unrelated projects.
  • Preserve command and filesystem audit logs and review the resulting diff before any changes leave the isolated environment.
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
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (9)

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
80% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

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

gh pr create --repo user/repo --head fix/issue-78 --title "fix: ..." --body "..."

Cleanup

git worktree remove /tmp/issue-78 git worktree remove /tmp/issue-99

text

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
80% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

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

Cleanup

git worktree remove /tmp/issue-78 git worktree remove /tmp/issue-99

text

---

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill explicitly recommends claude --permission-mode bypassPermissions, which suppresses interactive permission checks for a delegated agent. In a coding delegation context, this materially increases the chance of unreviewed file access, command execution, and modification of sensitive resources if prompts or repository contents are adversarial.

Content

No source excerpt is available for this finding.

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
88% confidence
Finding

--full-auto is an auto-approval mode that reduces operator review over delegated agent actions. Although less dangerous than a no-sandbox mode, it still increases the risk of unintended file changes or command execution when working with untrusted codebases or ambiguous prompts.

Content

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

md
| Flag            | Effect                                             |
| --------------- | -------------------------------------------------- |
| `exec "prompt"` | One-shot execution, exits when done                |
| `--full-auto`   | Sandboxed but auto-approves in workspace           |
| `--yolo`        | No sandbox, no approvals (fastest, most dangerous) |

### Building/Creating

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The skill promotes --full-auto and especially --yolo modes that auto-approve actions or remove sandbox/approval protections, while presenting them as normal workflow options. This encourages high-risk autonomous execution for delegated agents that may read, modify, install, commit, or push without human review.

Content

No source excerpt is available for this finding.

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
94% confidence
Finding

The documented --yolo mode is described as having no sandbox and no approvals, enabling a delegated agent to make autonomous decisions and execute them without oversight. In this skill's context, that can directly translate into unrestricted local actions, repository modifications, and potentially unsafe external interactions.

Content

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

md
| --------------- | -------------------------------------------------- |
| `exec "prompt"` | One-shot execution, exits when done                |
| `--full-auto`   | Sandboxed but auto-approves in workspace           |
| `--yolo`        | No sandbox, no approvals (fastest, most dangerous) |

### Building/Creating

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The examples instruct delegated agents to run package installation, make code changes, commit, and push to remotes automatically, but do not require review or warn about supply-chain, credential, or repository integrity risks. In practice this can lead to dependency-script execution, unintended code publication, or harmful commits being propagated upstream.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

Allowing delegated coding agents to invoke openclaw system event is outside the minimum capability required for coding tasks and violates least privilege. A delegated agent that can emit system events may spoof status, trigger workflows, or interact with trusted platform mechanisms in ways not justified by its role.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The skill prohibits running delegated agents in the OpenClaw workspace, yet later instructs those agents to invoke an OpenClaw system command on completion. That creates an unnecessary bridge from delegated coding agents into host-level orchestration functionality, expanding capability beyond the skill's stated purpose and creating a path for unintended command execution or event spoofing.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.