Back to skill

Security audit

proxy-aiops

Security checks for vulnerabilities and agentic risk

Overview

This skill has a coherent proxy-operations purpose, but it combines live reverse-proxy write authority, persistent credentials, and an unpinned runtime package in a way that deserves Review before installation.

Install only after pinning the executable package to a reviewed version or digest, and run it with least-privilege proxy accounts. Prefer read-only credentials for routine diagnostics, avoid placing production master passwords directly in MCP JSON configuration, protect `~/.proxy-aiops/` with strict local permissions, and treat Caddy config replacement/delete and HAProxy drain/weight changes as production-impacting operations requiring external approval controls.

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)

T08 · Insecure Dependencies

Error
Location
SKILL.md:77
Finding
Unpinned Third-Party Package Is Retrieved and Executed at Runtime## Vulnerability Details **File Location**: `SKILL.md:77-91`; `references/setup-guide.md:17-23`; `references/setup-guide.md:45-55` **Vulnerability Type**: Unpinned runtime dependency and mutable supply-chain execution **Risk Level**: High ### Vulnerable Code From `SKILL.md:77-91`: ```bash uv tool install proxy-aiops proxy-aiops init # wizard: pick platform (traefik/caddy/haproxy) + optional encrypted secret proxy-aiops doctor ``` ```bash openclaw plugins install clawhub:@zw008/proxy-aiops openclaw skills info proxy-aiops # expect: Visible to model: yes ``` ```text Needs `uvx` on `PATH`: the MCP server is fetched with uv, pinned to this release. ``` From `references/setup-guide.md:45-55`: ```json { "mcpServers": { "proxy-aiops": { "command": "uvx", "args": ["--from", "proxy-aiops", "proxy-aiops-mcp"], "env": { "PROXY_AIOPS_MASTER_PASSWORD": "your-master-password" } } } } ``` ### Technical Analysis The installation commands and MCP configuration identify the package only as `proxy-aiops`; no exact version, package hash, lockfile, or immutable artifact reference is provided. The OpenClaw plugin command is similarly not pinned to an immutable release in the reviewed files. The statement that the MCP server is “pinned to this release” is not supported by the shown `uvx` command. The argument: ```text --from proxy-aiops ``` allows package resolution to select a registry version according to the package manager's current resolution behavior. Consequently, the effective executable can change after this Skill has been reviewed. This artifact contains documentation only and does not include the installed package's implementation. Claims concerning credential redaction, network destinations, TLS verification, auditing, undo behavior, and write safeguards therefore cannot be independently verified from the reviewed project. Because the fetch ...[truncated 1976 chars]
Remediation
## Remediation Suggestions 1. Pin the package to an exact reviewed version: ```json { "command": "uvx", "args": [ "--from", "proxy-aiops==X.Y.Z", "proxy-aiops-mcp" ] } ``` 2. Require cryptographic hashes for all resolved distributions and maintain a committed lockfile containing exact transitive dependency versions. 3. Pin the OpenClaw plugin to an immutable version or content digest instead of relying on a mutable package reference. 4. Include the executable package source in the review artifact, or link the Skill to a reproducible build whose source revision and package digest can be verified. 5. Verify package signatures or provenance attestations before installation. 6. Prevent automatic upgrades during MCP startup. Resolve and install an approved artifact separately, then execute the already-installed binary. 7. Run the MCP server under a dedicated, minimally privileged operating-system account with access only to the necessary configuration and proxy endpoints. 8. Restrict outbound network access to explicitly configured proxy API addresses and required certificate-probe destinations. 9. Add CI checks that reject unversioned dependency references and verify that documentation claims about pinning match the actual commands.

T09 · Insecure Skill Coding Practices

Warning
Location
references/setup-guide.md:45
Finding
Secret-Store Master Password Is Placed in Persistent MCP Configuration## Vulnerability Details **File Location**: `references/setup-guide.md:45-60` **Vulnerability Type**: Sensitive credential exposure through persistent configuration and process environment **Risk Level**: Medium ### Vulnerable Code ```json { "mcpServers": { "proxy-aiops": { "command": "uvx", "args": ["--from", "proxy-aiops", "proxy-aiops-mcp"], "env": { "PROXY_AIOPS_MASTER_PASSWORD": "your-master-password" } } } } ``` ```text MCP clients do not inherit your shell profile: set `PROXY_AIOPS_MASTER_PASSWORD` in the `env` block whenever any target has a stored secret, and `PROXY_AIOPS_CONFIG` / `PROXY_AIOPS_HOME` if you relocated state. ``` ### Technical Analysis The setup guide directs operators to place `PROXY_AIOPS_MASTER_PASSWORD` directly in the MCP client's configuration. Although the shown value is a placeholder, following this pattern with a real password creates a persistent plaintext copy of the secret used to unlock `~/.proxy-aiops/secrets.enc`. Encrypting proxy credentials at rest provides limited protection if the corresponding decryption password is stored in another routinely accessible configuration file on the same host. MCP client configuration may be exposed through: - Overly permissive file permissions. - Configuration backups or synchronization services. - Accidental source-control commits. - Diagnostic bundles and support logs. - Process-environment inspection by same-user or privileged processes. - Child processes that inherit the MCP server environment. The reviewed documentation does not require an operating-system keychain, secret manager, protected credential file, or other mechanism that separates the encryption key from ordinary application configuration. ### Attack Path 1. An attacker gains read access to the MCP client configuration through local account compromise, insecure permissions, a backup, synchronization, or an accidental ...[truncated 1416 chars]
Remediation
## Remediation Suggestions 1. Do not place the real master password directly in persistent MCP JSON configuration. 2. Retrieve the password at startup from an operating-system keychain, hardware-backed credential store, or managed secret service. 3. Where direct secret-manager integration is unavailable, use a narrowly permissioned credential helper that emits the password only to the MCP process. 4. Ensure MCP configuration and `~/.proxy-aiops/` are readable only by the dedicated service account. 5. Prevent the MCP process from passing its complete environment to unnecessary child processes. 6. Redact `PROXY_AIOPS_MASTER_PASSWORD` from diagnostics, crash reports, process listings, and support bundles. 7. Use distinct master passwords and credential stores for separate environments to reduce compromise scope. 8. Rotate the master password and all stored proxy credentials after suspected configuration or environment disclosure. 9. Prefer read-only, narrowly scoped proxy API accounts by default and grant write access only for explicitly authorized maintenance sessions. 10. Add a prominent warning that the JSON example is illustrative and must not contain production secrets in plaintext.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
Findings (12)

Ae1

High
Category
analysis-evasion
Content
- `references/setup-guide.md` — onboarding, credentials, and connectivity
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
proxy-aiops init                 # interactive wizard: platform, base_url, TLS verify, encrypted secret
proxy-aiops doctor               # config + secrets + connectivity (probe per platform)
proxy-aiops doctor --skip-auth   # skip the connectivity probe
proxy-aiops overview             # one-shot: version + routes/services + upstream health
```
Confidence
70% 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).

Credential Access

High
Category
Privilege Escalation
Content
proxy-aiops secret set <target>      # store encrypted (hidden prompt)
proxy-aiops secret list              # names only, never values
proxy-aiops secret rm <target>
proxy-aiops secret migrate           # import legacy plaintext .env
proxy-aiops secret rotate-password   # re-encrypt under a new master password
```
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Session Persistence

Medium
Category
Rogue Agent
Content
- Bash
metadata: {"openclaw":{"requires":{"anyBins":["proxy-aiops","uvx"]},"optional":{"env":["PROXY_AIOPS_CONFIG","PROXY_AIOPS_MASTER_PASSWORD"]},"homepage":"https://github.com/AIops-tools/Proxy-AIops","emoji":"🔀","os":["macos","linux"]}}
compatibility: >
  Standalone, self-governed reverse-proxy operations across Traefik (API /api/..., metrics-text counters via /metrics), Caddy (admin API, default localhost:2019 — carries the write surface) and HAProxy (Data Plane API v2 /v2/..., HTTP Basic auth). Each target in the config names its own platform, and a name-keyed platform registry selects the API shape; an explicit support matrix raises teaching errors for ops a platform cannot do (traefik writes → its providers; caddy error counters → access logs; haproxy certs → the .pem pipeline), never a silent no-op. The governance harness (audit, policy, token/runaway budget, undo, risk-tiers) is bundled in the package — no external skill-family dependency.
  All write operations are audited to a local SQLite DB under ~/.proxy-aiops/ (relocatable via PROXY_AIOPS_HOME).
  Credentials: the HAProxy Data Plane API password (required) or an optional Basic-auth credential for Traefik/Caddy is stored ENCRYPTED in ~/.proxy-aiops/secrets.enc (Fernet/AES-128 + scrypt-derived key) — never plaintext on disk. Traefik and Caddy usually run unauthenticated on localhost, so their secret is optional (no store entry = no auth header). Run 'proxy-aiops init' to onboard (it asks for the platform), or 'proxy-aiops secret set <target>'. The store is unlocked by a master password from PROXY_AIOPS_MASTER_PASSWORD (non-interactive/MCP/CI) or an interactive prompt (CLI on a TTY). A legacy plaintext env var PROXY_<TARGET_NAME_UPPER>_SECRET is still honoured as a fallback with a deprecation warning (migrate with 'proxy-aiops secret migrate'). Secrets are never logged or echoed.
  State-changing operations pass through the @governed_tool decorator (budget guard + audit + risk-tier labelling). delete_co
...[truncated 25 chars]
Confidence
80% confidence
Finding
The skill describes persistent storage of proxy API credentials in a local encrypted secrets file unlocked by a master password, and it also preserves a legacy plaintext environment-variable fallback. Even though encrypted-at-rest storage is better than plaintext files, session/credential persistence increases exposure if the host, environment, or master password handling is weak, especially because these credentials can modify live reverse-proxy configuration.

Intent-Code Divergence

Medium
Confidence
89% confidence
Finding
The document makes conflicting security claims: earlier it advertises a built-in governance harness with policy and risk-tier controls, while the Governance section later says there is no policy file or approval gate and that write authorization is left to the agent or server-side permissions. In a skill with direct write operations against reverse proxies, this mismatch can cause operators or upstream agents to overtrust nonexistent guardrails and permit risky state changes under false assumptions.

Session Persistence

Medium
Category
Rogue Agent
Content
## Governance & Safety

The skill delivers reads and writes and records them; it does **not** decide
whether a write is permitted. That is your agent's judgement, or the permission
of the account you connect it with (a read-only HAProxy Data Plane API role, a
scoped Traefik/Caddy admin API — writes then fail at the server). There is no
read-only switch, policy file, or approval gate.
Confidence
91% confidence
Finding
The Governance section explicitly states that the skill does not decide whether a write is permitted and that there is no read-only switch, policy file, or approval gate. In context, this is dangerous because the skill exposes write-capable operations for Caddy and HAProxy administration; relying only on whatever account permissions happen to exist creates a weak control boundary and makes accidental or unauthorized destructive changes more likely.

Intent-Code Divergence

Medium
Confidence
95% confidence
Finding
Lines L014-L015 say the tool 'does not gate' writes and that there is 'no read-only switch and no approval prompt to configure.' However, lines L035-L036 explicitly say destructive operations require a preview plus double confirmation at the CLI, which is an approval gate. This is an active contradiction in the file's own documentation about whether the tool enforces write approval.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## Authorization is not this tool's job — decide it where it belongs

Whether a write should happen is your decision, or the account's. The tool does
not gate it — there is no read-only switch and no approval prompt to configure.
The two right places to control read vs write:

- **The account you connect with.** Give the HAProxy Data Plane API a read-only
Confidence
84% confidence
Finding
The guardrail explicitly says the tool does not gate writes and has no read-only switch or approval prompt to configure, pushing all protection to external account permissions or the agent prompt. In a high-impact reverse-proxy administration skill, that means an agent with write-capable credentials can make disruptive config changes without an in-tool authorization control, increasing the chance of accidental or unauthorized service-impacting actions.

Intent-Code Divergence

Medium
Confidence
82% confidence
Finding
The prompt text tells the agent that on Traefik, config changes belong to the provider and 'do not offer to edit what the tool cannot write.' That directly conflicts with the broader documented skill purpose, which presents governed write capabilities for proxy operations and may imply editable proxy config. This creates intent ambiguity about supported write behavior versus prohibited edits.

Session Persistence

Medium
Category
Rogue Agent
Content
| `undo_list(limit?)` | recorded undo descriptors, newest first, with their `_undo_id` |
| `undo_apply(undo_id, dry_run?)` | replays the recorded inverse (governed like any other write) |

`undo_apply` is governed like any other write (audited, capturing a before-state
where the inverse is itself reversible). Undo descriptors are recorded to
`~/.proxy-aiops/undo.db`; their params match each tool's own signature
(replayable as-is).
Confidence
85% confidence
Finding
The skill documents persistent storage of undo descriptors in `~/.proxy-aiops/undo.db`, including replayable parameters matching each write tool's signature. In this proxy-operations context, those parameters can include sensitive infrastructure details and may enable unauthorized re-execution of privileged changes if the file is read or tampered with by another local user or process.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
```bash
proxy-aiops init                 # interactive wizard: platform, base_url, TLS verify, encrypted secret
proxy-aiops doctor               # config + secrets + connectivity (probe per platform)
proxy-aiops doctor --skip-auth   # skip the connectivity probe
proxy-aiops overview             # one-shot: version + routes/services + upstream health
```
Confidence
80% confidence
Finding
Tool defaults are unsafe or overly permissive (e.g. disabled TLS verification, no authentication, world-writable permissions). Unsafe defaults widen the attack surface.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The setup guide instructs users to place `PROXY_AIOPS_MASTER_PASSWORD` directly in an MCP client `env` block, but does not warn that environment-based secret injection can expose credentials through client config files, process listings, crash reports, logs, backups, or shared workstation profiles depending on the platform. In this skill's context, that password unlocks stored proxy credentials and potentially enables governed write operations against Traefik, Caddy, or HAProxy, so leakage could lead to unauthorized access to reverse-proxy administration and service disruption.

Static analysis

Detected: suspicious.prompt_injection_instructions

Prompt-injection style instruction pattern detected.

Warn
Code
suspicious.prompt_injection_instructions
Location
references/agent-guardrails.md:42