Back to skill

Security audit

acpx-faq

Security checks for vulnerabilities and agentic risk

Overview

This skill is a guide for running headless coding agents, but its examples can let those agents act in your local account without further approval.

Install only if you intend to run coding agents headlessly through acpx. Use a disposable worktree, container, VM, or restricted OS account for untrusted or sensitive projects; avoid exposing home directories, SSH/cloud credentials, browser profiles, and service sockets; close sessions after runs; and verify or pin external adapters and provider binaries before relying on them.

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)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:52
Finding
Coding Agents Run Without Effective Least-Privilege Filesystem Controls## Vulnerability Details **File Location**: `SKILL.md:52-57`, with affected launch recipes at `SKILL.md:148-149` and `SKILL.md:173-174` **Vulnerability Type**: Permission-control bypass and unrestricted user-level execution **Risk Level**: High ### Evidence ```text 4. **Permission flags are not a sandbox.** The claude adapter spawns its binary with `--allow-dangerously-skip-permissions --setting-sources=project,local`, so no permission request ever reaches acpx's policy layer (`--deny-all` is unreachable, not ignored); codex writes through its terminal capability. `--no-terminal` genuinely removes the terminal capability, but the only real filesystem control is which `--cwd` you hand it. Verify: `ps -Ao args | grep claude-agent-sdk` mid-turn. ``` The affected recommended recipes include: ```bash acpx --cwd "$D" --approve-all --timeout 5400 --format quiet --suppress-reads \ codex -s work 'Carry out ./brief.md. Write your report to ./report.md.' > run.log 2>&1 & ``` ```bash acpx --cwd "$D" --model claude-opus-5 --approve-all --suppress-reads --timeout 2400 \ claude -s work -f /abs/brief.md >> run.log 2>&1 & ``` ### Technical Analysis The recommended execution model bypasses or disables interactive permission checks while retaining terminal and filesystem capabilities. The Skill explicitly states that the Claude adapter invokes its underlying binary with `--allow-dangerously-skip-permissions`, preventing permission requests from reaching the `acpx` policy layer. It also states that Codex can write through its terminal capability. The `--cwd` option changes the process working directory but does not establish an operating-system security boundary. Unless the agent is separately isolated, it can potentially access any file, executable, credential, socket, or service available to the invoking user. Consequently, repository content, prompts, or tool output capable of influencing the coding ...[truncated 1561 chars]
Remediation
## Remediation Suggestions 1. Do not make `--approve-all` the default in documented launch recipes. Require explicit approval for terminal execution and filesystem writes. 2. Use `--no-terminal` for review, classification, and other analysis-only tasks. 3. Run coding agents inside a container, virtual machine, sandbox, or dedicated restricted operating-system account. 4. Mount only the target project into the isolated environment and use a read-only mount unless writes are necessary. 5. Do not expose home directories, SSH agents, cloud credentials, browser profiles, package-manager credentials, or unrelated service sockets to the agent. 6. Apply outbound network restrictions appropriate to the task. 7. Treat repositories and prompt files from untrusted sources as potentially hostile. 8. Clearly state that `--cwd` is only a working-directory selection and must not be relied upon as filesystem confinement. 9. Where permission skipping is unavoidable, require a prominent warning and an explicit user opt-in rather than presenting it as the standard recipe.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:157
Finding
Floating Codex Adapter Dependency Allows Unaudited Executable Changes## Vulnerability Details **File Location**: `SKILL.md:157` **Vulnerability Type**: Unpinned executable dependency **Risk Level**: Medium ### Evidence ```text - The codex adapter floats on `^1.1.5` - behavior can change without an acpx upgrade. ``` The documented runtime chain confirms that the adapter executes locally: ```text `sessions close <n>` takes down the whole resident stack (`acpx __queue-owner` -> `npm exec` -> `node <adapter>` -> agent binary). ``` ### Technical Analysis The Codex adapter is resolved using the semver range `^1.1.5` rather than an exact, integrity-verified version. This range permits later compatible releases to be selected without a corresponding update to this Skill or to `acpx`. Because the adapter is executable Node.js code in the command-execution and permission path, a newly resolved version can change agent behavior while bypassing the review applied to the currently documented project. This creates a supply-chain risk: compromise of the package or publication channel, malicious maintainer activity, or an unsafe update could result in unexpected code executing with the user's privileges. The finding does not establish that the current adapter is malicious. The risk arises from allowing future executable content to change independently of the audited Skill. ### Attack Path 1. An attacker compromises the adapter package, a maintainer account, or its distribution channel, or causes an unsafe version to be released within the accepted semver range. 2. A user later invokes the documented Codex workflow. 3. `npm exec` resolves or installs the newer version permitted by `^1.1.5`. 4. Node.js executes the changed adapter as part of the normal trusted agent workflow. 5. The adapter inherits the invoking user's access and participates in an execution path that may use `--approve-all`. 6. Malicious adapter logic can access or modify user-accessible resources while appearing to be a leg ...[truncated 622 chars]
Remediation
## Remediation Suggestions 1. Pin the adapter to an exact reviewed version instead of using `^1.1.5`. 2. Enforce package integrity with a lockfile and verified cryptographic integrity metadata. 3. Install the adapter explicitly during a controlled setup phase rather than resolving it dynamically during agent execution. 4. Use a trusted, access-controlled package mirror or an immutable internal artifact repository. 5. Review release notes and source changes before updating the pinned version. 6. Run vulnerability and provenance checks on the adapter and its transitive dependencies. 7. Prefer signed releases and verify signatures or published checksums where available. 8. Execute the adapter in the same restricted container or operating-system sandbox recommended for coding agents.
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (10)

Self-Modification

High
Category
Rogue Agent
Content
- agy: provenance of `agy_acp_server.par` - shipped by the Antigravity install, sha512-verified
  against Google's manifest, never downloaded by acpx or by this skill. Build
  `20260818_01_RC01` is pinned and self-updates nothing. Clears the Socket alert on unverified
  executable provenance.
- agy: Linux / NixOS section - the `--uid=` wrapper, the mandatory `SSL_CERT_FILE` export, and
  installing `agy` by hand rather than piping the installer (its `agy install` step writes to
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.

External Model or Provider Selection

High
Category
Excessive Agency
Content
# macOS: --agent may point straight at the .par
D=/abs/real/dir                              # must exist: roots resolve through realpath
acpx --agent ~/.local/lib/antigravity-acp/agy_acp_server.par \
     --cwd "$D" --model gemini-3.7-flash-medium --timeout 1800 \
     exec 'Carry out $D/brief.md. Write your report to $D/report.md.'
```
Confidence
96% confidence
Finding
This recipe directs users to run an external ACP server binary via `--agent` and then execute work with a powerful model in a real filesystem directory. Combined with the document's own warning that permission flags are not a sandbox and that the only real control is `--cwd`, this enables execution through an external provider with broad access to local files and networked backend services, increasing data exfiltration and unintended action risk.

External Model or Provider Selection

High
Category
Excessive Agency
Content
```bash
D=/abs/dir
acpx --cwd "$D" --model claude-opus-5 claude sessions ensure -s work
acpx --cwd "$D" --model claude-opus-5 --approve-all --suppress-reads --timeout 2400 \
     claude -s work -f /abs/brief.md >> run.log 2>&1 &
# ...after the run finishes and you have read what you need:
Confidence
92% confidence
Finding
Selecting `claude-opus-5` at session creation routes prompts and workspace context to an external model provider. In isolation model selection is not always a flaw, but in this skill it is part of a workflow for persistent sessions and headless execution, which can cause sensitive code or data to be processed by a third-party service without sufficient policy gating.

External Model or Provider Selection

High
Category
Excessive Agency
Content
```bash
D=/abs/dir
acpx --cwd "$D" --model claude-opus-5 claude sessions ensure -s work
acpx --cwd "$D" --model claude-opus-5 --approve-all --suppress-reads --timeout 2400 \
     claude -s work -f /abs/brief.md >> run.log 2>&1 &
# ...after the run finishes and you have read what you need:
acpx --cwd "$D" claude sessions close work  # ALWAYS - the run is not over until this returns
Confidence
97% confidence
Finding
This command combines an external model with `--approve-all` in a headless persistent run, materially increasing risk because the agent can take actions without interactive approval. The skill itself notes that permission flags are not a sandbox, so this pattern can allow broad filesystem modifications and tool use while sending context to an outside provider.

Vague Triggers

Medium
Confidence
85% confidence
Finding
The description says to use this skill "before launching or prompting a subagent, and when a command fails, a session is not found, or a prompt is lost," which describes very broad situations rather than a narrow trigger. In a markdown skill description, this can overlap with many routine agent-management scenarios and does not provide clear exclusion conditions or negative examples.

Session Persistence

Medium
Category
Rogue Agent
Content
which `--cwd` you hand it. Verify: `ps -Ao args | grep claude-agent-sdk` mid-turn.
5. **`[done] end_turn` and exit 0 are not proof of success.** A content-filter kill,
   an MCP load failure, or a truncated turn all end that way. Read the stream, or
   require the agent to write a result file you can check.
6. **A persistent session leaves a resident process stack until you close it.** Every
   `-s` prompt elects a queue owner holding `npm exec -> node <adapter> -> <agent>`,
   roughly 700 MB per executor. `sessions close` is the only supported teardown; the
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Scope Creep

Low
Category
Excessive Agency
Content
permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation source, and
configuration files.

"Object" form shall mean any form resulting from mechanical transformation or
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Scope Creep

Low
Category
Excessive Agency
Content
permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation source, and
configuration files.

"Object" form shall mean any form resulting from mechanical transformation or
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Scope Creep

Low
Category
Excessive Agency
Content
permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation source, and
configuration files.

"Object" form shall mean any form resulting from mechanical transformation or
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Scope Creep

Low
Category
Excessive Agency
Content
permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation source, and
configuration files.

"Object" form shall mean any form resulting from mechanical transformation or
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Static analysis

No suspicious patterns detected.