Back to skill

Security audit

queue-aiops

Security checks for vulnerabilities and agentic risk

Overview

The skill is transparent about its Redis/RabbitMQ administration role, but it exposes destructive broker actions without an enforceable approval or read-only gate.

Install only with least-privilege, preferably read-only broker accounts first. Pin the reviewed package version, avoid putting the master password in shared config, enable TLS for non-local brokers, and expose write/destructive tools only in sessions where a human operator is intentionally supervising them.

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

T09 · Insecure Skill Coding Practices

Warning
Location
references/setup-guide.md:49
Finding
Broker Credentials and Administrative Traffic May Be Transmitted Without TLS## Vulnerability Details **File Location**: `references/setup-guide.md:49-66` **Vulnerability Type**: Plaintext transmission of credentials and sensitive operational data **Risk Level**: Medium ### Vulnerable Code Snippet ```yaml targets: - name: cache1 platform: redis host: 10.0.0.10 port: 6379 username: "" db: 0 use_tls: false verify_ssl: true - name: broker1 platform: rabbitmq host: 10.0.0.20 port: 15672 username: queueops db: 0 use_tls: false verify_ssl: true ``` The capability reference also documents Redis authentication over RESP and RabbitMQ HTTP Basic authentication, while TLS remains optional. ### Technical Analysis The example configuration disables TLS for both supported platforms. With Redis, authentication material and commands may consequently be sent over an unencrypted RESP connection. With RabbitMQ, port 15672 normally provides HTTP, so HTTP Basic credentials and management API requests may travel without transport encryption. Setting `verify_ssl: true` does not provide protection when `use_tls` is false because there is no TLS certificate to verify. Sensitive data handled by the Skill includes broker passwords, Redis slow-log commands, client addresses, configuration values, queue metadata, and administrative commands. Connecting to configured brokers is necessary for the declared functionality and no unrelated exfiltration destination was identified. The security issue is that the documented defaults do not protect that necessary network traffic. ### Attack Path 1. An operator follows the documented example and configures a remote broker with `use_tls: false`. 2. The Skill authenticates to Redis or RabbitMQ across a network accessible to an attacker. 3. An attacker with an on-path position, compromised network device, or access to the same insecure network captures or modifies the plaintext traffic. 4. The att ...[truncated 730 chars]
Remediation
## Remediation Suggestions - Enable TLS by default for both Redis and RabbitMQ targets. - Use the appropriate TLS endpoints and ports, such as RabbitMQ port 15671 where configured. - Require certificate verification by default and reject invalid or untrusted certificates. - Restrict `use_tls: false` and disabled certificate verification to an explicit local-lab mode. - Display a prominent warning or refuse authentication when credentials would be sent over plaintext transport. - Document secure certificate deployment, private certificate-authority configuration, and certificate rotation procedures. - Use read-only, least-privilege broker accounts even when TLS is enabled.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:211
Finding
Destructive MCP Operations Lack an Enforced Authorization or Approval Gate## Vulnerability Details **File Location**: `SKILL.md:211-229` **Vulnerability Type**: Missing authorization controls for destructive administrative operations **Risk Level**: High ### Vulnerable Code Snippet ```text 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 Redis ACL user restricted to read commands, a RabbitMQ management user with only the monitoring tag — writes then fail at the broker). There is no read-only switch, policy file, or approval gate. - Audit is the guarantee, and it is not bypassable. Every operation — MCP and CLI alike — is logged to ~/.queue-aiops/audit.db - QUEUE_AUDIT_APPROVED_BY / QUEUE_AUDIT_RATIONALE are optional annotations recorded on the audit row (who/why); they are never required and never block. - Runaway guard — a safety backstop, not authorization - Writes support --dry-run / dry_run=True and double confirmation at the CLI ``` The capability reference documents that `purge_queue` irrecoverably destroys messages and that `delete_queue` cannot restore deleted messages. It also distinguishes optional MCP `dry_run` behavior from CLI double confirmation. ### Technical Analysis The Skill intentionally delegates authorization to the Agent or broker account. It has no default read-only mode, enforceable policy file, mandatory approval mechanism, or required approver identity. Audit logging is detective rather than preventive: it records an operation after or during execution but does not determine whether the operation should be allowed. CLI commands receive double confirmation, but the documented MCP tools only expose an optional `dry_run` argument. Consequently, an Agent can directly invoke write-capable tools without a mandatory preview or independent human approval. Relevant operations include: - Irrecoverable RabbitMQ message purg ...[truncated 1793 chars]
Remediation
## Remediation Suggestions - Make the MCP server read-only by default and require explicit configuration to expose write tools. - Use separate read-only and write-capable broker identities. - Require a short-lived, out-of-band approval token for every state-changing operation. - Require high-risk operations to reference a recent server-generated dry-run identifier that binds the target, parameters, prior state, and expiration time. - Require an independently supplied approver identity and rationale for destructive calls instead of treating them as optional audit annotations. - Add role-based policies that can allow individual operations while denying purge, deletion, client termination, or configuration changes. - Require explicit user confirmation through the host Agent environment before MCP high-risk calls. - Prevent undo operations from broadening privileges or applying an inverse action to a different target. - Retain broker-side least privilege as a mandatory defense rather than a recommendation. - Ensure the runaway guard cannot be disabled for destructive operations.

T08 · Insecure Dependencies

Warning
Location
references/setup-guide.md:87
Finding
Unpinned Package Resolution Allows Reviewed MCP Code to Change at Installation or Startup## Vulnerability Details **File Location**: `references/setup-guide.md:87-96` **Vulnerability Type**: Unpinned third-party dependency and runtime package retrieval **Risk Level**: Medium ### Vulnerable Code Snippet ```json { "mcpServers": { "queue-aiops": { "command": "uvx", "args": ["--from", "queue-aiops", "queue-aiops-mcp"], "env": { "QUEUE_AIOPS_MASTER_PASSWORD": "your-master-password" } } } } ``` The installation instructions also use unversioned package commands: ```bash uv tool install queue-aiops ``` The setup guide additionally permits unpinned `pipx install queue-aiops` and `pip install queue-aiops`. ### Technical Analysis The documented installation and MCP startup commands identify the package only by name. They do not provide an exact version, artifact hash, lockfile, or signature. Therefore, the package resolved by `uv`, `uvx`, `pipx`, or `pip` can change after this Skill has been reviewed. This is especially sensitive for MCP startup because the resolved package executes while the process environment contains `QUEUE_AIOPS_MASTER_PASSWORD`. The resulting process is also expected to have broker network access and access to local configuration, encrypted secrets, audit records, and undo state. The main Skill text states that the server is pinned to the release, but the reviewed command examples do not contain a version constraint that enforces this assertion. No malicious dependency was identified in the supplied project; the vulnerability is the mutable and unverified dependency resolution process. ### Attack Path 1. An attacker compromises the package registry account, publishing pipeline, or a future package release. 2. A user runs the documented unversioned installation command, or an MCP client starts `uvx` with the unversioned `--from queue-aiops` argument. 3. The package manager resolves and executes the attacker-controlled releas ...[truncated 985 chars]
Remediation
## Remediation Suggestions - Pin the package to an exact reviewed version in every installation and MCP startup example. - Use a lockfile and verify cryptographic hashes for all direct and transitive dependencies. - Prefer a preinstalled, verified executable instead of resolving packages dynamically whenever the MCP server starts. - Verify package signatures, registry provenance, and trusted-publisher metadata where supported. - Publish checksums for release artifacts and validate them during installation. - Prevent silent upgrades; require a separate review and explicit operator action before changing versions. - Run the MCP server under a dedicated, restricted operating-system account. - Minimize the process environment and use a secret manager or protected descriptor instead of embedding the master password directly in MCP configuration. - Restrict outbound network access to the explicitly configured broker endpoints.
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 (9)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
queue-aiops init                 # onboarding wizard (targets + encrypted secrets)
queue-aiops doctor [--skip-auth] # config/secret/connectivity check (PING / /api/overview)
queue-aiops overview [-t T]      # one-shot health summary (platform-dispatched)
queue-aiops mcp                  # run the MCP server (stdio)
```
Confidence
86% confidence
Finding
The documented --skip-auth option indicates the tool can perform connectivity checks without authentication, which can normalize or enable unauthenticated access patterns. In an AIOps skill for Redis and RabbitMQ administration, even a 'doctor' path can leak service presence, topology, or health details and may encourage unsafe operator behavior if reused outside tightly controlled diagnostics.

Credential Access

High
Category
Privilege Escalation
Content
queue-aiops secret set <target>    # add/update an encrypted secret
queue-aiops secret list            # names only — values are never printed
queue-aiops secret rm <target>
queue-aiops secret migrate         # legacy .env / env vars → encrypted store
queue-aiops secret rotate-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
metadata: {"openclaw":{"requires":{"anyBins":["queue-aiops","uvx"]},"optional":{"env":["QUEUE_AIOPS_CONFIG","QUEUE_AIOPS_MASTER_PASSWORD"]},"homepage":"https://github.com/AIops-tools/Queue-AIops","emoji":"📬","os":["macos","linux"]}}
compatibility: >
  Standalone, self-governed broker operations across redis (RESP wire protocol via the redis Python client; password optional — auth-less lab instances are supported — TLS optional) and rabbitmq (management HTTP API /api/..., HTTP Basic auth with a monitoring/management-tagged user). Each target in the config names its own platform, and a name-keyed platform registry selects the protocol shape, so one config can span a mixed estate. 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 ~/.queue-aiops/ (relocatable via QUEUE_AIOPS_HOME).
  Credentials: the redis password (optional) or the rabbitmq management password is stored ENCRYPTED in ~/.queue-aiops/secrets.enc (Fernet/AES-128 + scrypt-derived key) — never plaintext on disk. Run 'queue-aiops init' to onboard (it asks for the platform), or 'queue-aiops secret set <target>' to add one. The store is unlocked by a master password from QUEUE_AIOPS_MASTER_PASSWORD (non-interactive/MCP/CI) or an interactive prompt (CLI on a TTY). A legacy plaintext env var QUEUE_<TARGET_NAME_UPPER>_SECRET is still honoured as a fallback with a deprecation warning (migrate with 'queue-aiops secret migrate'). The secret is presented as AUTH at connect time (redis) or HTTP Basic auth (rabbitmq) and held only in memory; secrets are never logged or echoed.
  State-changing operations pass through the @governed_tool decorator (budget guard + audit + risk-tier labelling). purge_queue and delete_queue are risk=high with dry_run + double confirmation at the CLI; purge is irreversible (priorState = the message count about to be destroyed), and delete
...[truncated 25 chars]
Confidence
85% confidence
Finding
The skill explicitly persists operational history to a local SQLite audit database and stores broker credentials in a locally encrypted secrets file, with an environment-variable fallback for plaintext secrets. Even though the design includes encryption and redaction claims, this is still sensitive session/credential persistence on disk; compromise of the local host, weak file permissions, or use of the legacy plaintext env fallback could expose broker access and operational metadata.

Session Persistence

Medium
Category
Rogue Agent
Content
3. `queue-aiops rabbitmq policies` → check no policy still targets its name pattern, so
   you are not leaving a dangling rule behind.
4. `queue-aiops rabbitmq delete-queue <name> --vhost / --dry-run` → preview.
5. Re-run without `--dry-run` (double-confirm, risk=high) — the write
   captures the queue's definition first, so the undo descriptor **re-declares exactly
   that queue** (durability and auto-delete flags included).
6. `queue-aiops rabbitmq queues` → confirm it is gone and nothing else changed.
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.

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 Redis connection an ACL user
Confidence
93% confidence
Finding
The document explicitly states that the tool does not gate write operations and has no read-only switch or approval prompt, relying instead on external account permissions or prompting. In an agentic context, this is dangerous because prompt-only restrictions are not enforceable and a misconfigured or overprivileged account would allow the model to perform destructive broker actions such as purging or deleting queues or changing broker configuration.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The capability reference explicitly exposes destructive broker operations such as queue purge and queue deletion, and documents that the only guardrail for the highest-risk actions is dry-run preview plus double confirmation. In an agent skill context, this is dangerous because an LLM or downstream automation can still be socially engineered or mis-prompted into executing irreversible actions that destroy live messages, and the documented undo path cannot restore purged or deleted message contents.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
```bash
queue-aiops init                 # onboarding wizard (targets + encrypted secrets)
queue-aiops doctor [--skip-auth] # config/secret/connectivity check (PING / /api/overview)
queue-aiops overview [-t T]      # one-shot health summary (platform-dispatched)
queue-aiops mcp                  # run the MCP server (stdio)
```
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.

Session Persistence

Medium
Category
Rogue Agent
Content
### rabbitmq

Enable the management plugin and create (or reuse) a user with at least the
`monitoring` tag (reads) — the `management`/`policymaker` tag is needed for
policy writes, and queue purge/delete needs configure permission on the vhost:
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.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The guide instructs users to place the master password directly in the MCP `env` block as a plaintext value. Even if this is only an example, documentation like this normalizes secret-in-config handling and may lead to credentials being stored in editor configs, shell history, backups, logs, or shared repositories, increasing the chance of credential disclosure.

Static analysis

Detected: suspicious.prompt_injection_instructions

Prompt-injection style instruction pattern detected.

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