Back to skill

Security audit

DevOps Insight

Security checks for vulnerabilities and agentic risk

Overview

The skill is a disclosed DevOps incident tool, but it combines broad production access with automatic external publishing and mutation-capable workflows that need review before use.

Review before installing. Use read-only and tightly scoped MCP credentials where possible, disable EvoMap heartbeat and autoPublish unless your organization explicitly approves the destination and payload, require confirmation before ticket, branch, PR, or production changes, and fix the database setup script before using it outside a disposable environment.

Vulnerability Patterns
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (3)

other

Error
Location
config.example.json:47
Finding
Automatic External Publication May Disclose Sensitive Production Data<![CDATA[ ## Vulnerability Details **File Location**: `config.example.json:47-52`; related data model and workflow in `skill.md:97-106`, `skill.md:119-123`, `skill.md:178`, and `skill.md:282-297` **Vulnerability Type**: Uncontrolled external data disclosure **Risk Level**: High ### Vulnerable Code ```json "evomap": { "apiUrl": "https://evomap.ai/a2a", "nodeId": "node_your_unique_id", "enableHeartbeat": true, "heartbeatInterval": 900000, "autoPublish": true, "minConfidence": 0.8 } ``` The corresponding Capsule data model permits unrestricted monitoring information and potentially sensitive remediation content: ```typescript solution: { type: 'code_change' | 'config_change' | 'investigation'; files: Array<{ path: string; diff?: string; content?: string; }>; description: string; }; context: { monitoring_data?: any; root_cause?: string; affected_services?: string[]; }; ``` ### Technical Analysis The example configuration enables both recurring heartbeat traffic and automatic publication to the external EvoMap endpoint. The documented Capsule structure can include unrestricted `monitoring_data`, internal service identifiers, root-cause information, file paths, source diffs, and file contents. The skill instructs users to sanitize sensitive information, but no mandatory redaction mechanism, payload allowlist, secret detection, or per-publication approval requirement is defined. A confidence threshold is a quality measure and does not establish whether a payload is safe to disclose. External publication is not required to perform the skill's core incident collection, root-cause analysis, ticket management, or code review functions. Enabling it by default therefore exceeds the minimum network privileges necessary for those functions. The static pre-scan warnings for `README.md` and `README.zh.md` were reviewed. Those files do not themselves contain a command that directly transmits secrets. The confirmed outbound-data risk ...[truncated 1432 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Change `autoPublish` and `enableHeartbeat` defaults to `false`. 2. Require explicit, case-specific operator approval before every external publication. 3. Show the complete destination and outbound payload to the operator before consent. 4. Apply a strict outbound schema allowlist rather than permitting `monitoring_data?: any`. 5. Prohibit raw logs, traces, source contents, diffs, credentials, tokens, personal data, and internal identifiers from publication. 6. Add deterministic secret and PII detection before transmission, with fail-closed behavior. 7. Minimize published data to generalized remediation guidance that cannot identify the organization or its infrastructure. 8. Separate incident-analysis permissions from external-publication permissions so that publication can remain disabled without affecting core functionality. 9. Document data retention, ownership, access, and deletion behavior for the external service. 10. Record immutable audit events for approval, redaction results, destination, payload digest, and publication outcome. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/init-database.sh:17
Finding
SQL Injection Through Environment-Controlled Database Name<![CDATA[ ## Vulnerability Details **File Location**: `scripts/init-database.sh:17-18` **Vulnerability Type**: SQL injection **Risk Level**: Medium ### Vulnerable Code ```bash PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -tc "SELECT 1 FROM pg_database WHERE datname = '$DB_NAME'" | grep -q 1 || \ PGPASSWORD="$DB_PASSWORD" psql -h "$DB_HOST" -p "$DB_PORT" -U "$DB_USER" -c "CREATE DATABASE $DB_NAME" ``` ### Technical Analysis `DB_NAME` is obtained from the process environment and interpolated directly into two SQL statements. In the first statement it is inserted into a string literal, and in the second it is inserted as an unquoted SQL identifier. Shell double-quoting only controls shell parsing; it does not make the resulting SQL safe. A value containing PostgreSQL quote or statement-separator syntax can alter the intended query. The resulting injected SQL executes with the privileges of `DB_USER`. The database initialization function legitimately requires schema-creation permissions, but accepting arbitrary SQL through a database-name variable exceeds the minimum capability necessary to select or create a database. ### Attack Path 1. An attacker obtains control over `DB_NAME` in a CI job, deployment manifest, orchestration environment, wrapper script, or manual invocation. 2. The attacker supplies a value containing SQL syntax that terminates or modifies the intended statement. 3. The script interpolates that value into the query passed to `psql`. 4. PostgreSQL parses the injected content as part of the SQL command. 5. The injected operations execute with the configured database account's permissions. Successful exploitation depends on the PostgreSQL client and server accepting the resulting statement sequence and on the privileges assigned to `DB_USER`. ### Impact Assessment The attacker may perform operations available to the configured database role, potentially including: - Reading or modifying accessible database data ...[truncated 516 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Reject database names that do not match a strict PostgreSQL identifier policy, such as `^[A-Za-z_][A-Za-z0-9_]*$`. 2. Use PostgreSQL-safe identifier quoting for database identifiers rather than direct interpolation. 3. Use parameter binding or `psql` variables with safe literal handling for the `datname` comparison. 4. Keep string-literal values and SQL identifiers in separate, correctly escaped paths. 5. Run initialization with a dedicated provisioning account and revoke database-creation privileges after setup. 6. Use a separate, lower-privileged runtime account for ordinary ticket operations. 7. Add tests covering apostrophes, semicolons, whitespace, quotation marks, and other metacharacters in environment-provided values. 8. Fail closed when any supplied database identifier is invalid. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/init-database.sh:12
Finding
Predictable Default Database Password<![CDATA[ ## Vulnerability Details **File Location**: `scripts/init-database.sh:12` **Vulnerability Type**: Hardcoded weak credential default **Risk Level**: Medium ### Vulnerable Code ```bash DB_PASSWORD="${DB_PASSWORD:-tickets_password}" ``` ### Technical Analysis The initialization script silently uses the predictable password `tickets_password` whenever `DB_PASSWORD` is absent or empty. This creates an insecure fallback that can unintentionally reach development, staging, or production environments. Because initialization continues successfully, operators may not realize that a known credential was selected. The password is also present in the distributed source and is therefore available to anyone who can inspect the package. ### Attack Path 1. An operator runs the script without setting `DB_PASSWORD`, or a deployment system fails to inject the expected secret. 2. The script automatically authenticates using `tickets_password`. 3. The same predictable value remains configured for the `tickets_user` account or is otherwise accepted by the target database. 4. An attacker with network access to PostgreSQL attempts the known username and fallback password. 5. If authentication succeeds, the attacker receives all database privileges assigned to `tickets_user`. This path requires the database account to use the fallback credential and PostgreSQL to be reachable from the attacker's network position. ### Impact Assessment A successful attacker obtains the effective privileges of `tickets_user`. Depending on database grants, this could permit: - Reading incident descriptions, root causes, monitoring data, assignees, and commit references - Modifying or deleting tickets and audit history - Corrupting monitoring indexes - Creating database objects or databases if provisioning privileges remain assigned - Disrupting incident-management operations The issue does not directly expose operating-system privileges, but compromise of operational incident data can ...[truncated 71 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the fallback password and terminate with an error when `DB_PASSWORD` is unset or empty. 2. Retrieve the password from an approved secret manager or a protected credential file. 3. Avoid passing secrets through command-line arguments or writing them to logs. 4. Generate a unique, high-entropy credential for every environment. 5. Rotate any deployment that has used `tickets_password`. 6. Restrict PostgreSQL network exposure using firewall rules, private networking, and host-based access controls. 7. Grant the runtime database account only the table privileges needed for ticket operations. 8. Use a temporary, separately managed provisioning role for database and schema creation. ]]>
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
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (23)

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The description suggests a broader operational skill focused on incident management and SRE workflows, including analysis, troubleshooting, alert investigation, ticket creation, and observability integration. The actual code only performs a predefined health check of several local/CLI-accessible services and reports whether each command succeeds. While health checks can be related to DevOps/SRE and loosely adjacent to 'check monitoring' or troubleshooting, this script’s primary purpose is much narrower: validating availability of specific dependencies. It does not contain logic for incident analysis, RCA, alert investigation, ticket creation, or observability integration. Therefore the code’s actual behavior is only partially related and is materially different from the declared purpose.

Credential Access

High
Category
Privilege Escalation
Content
"mcpServers": {
      "kubernetes": {
        "command": "mcp-server-kubernetes",
        "args": ["--kubeconfig", "${HOME}/.kube/config"],
        "env": {
          "KUBECONFIG": "${HOME}/.kube/config"
        }
Confidence
80% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"mcpServers": {
      "kubernetes": {
        "command": "mcp-server-kubernetes",
        "args": ["--kubeconfig", "${HOME}/.kube/config"],
        "env": {
          "KUBECONFIG": "${HOME}/.kube/config"
        }
Confidence
80% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"mcpServers": {
      "kubernetes": {
        "command": "mcp-server-kubernetes",
        "args": ["--kubeconfig", "${HOME}/.kube/config"],
        "env": {
          "KUBECONFIG": "${HOME}/.kube/config"
        }
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"mcpServers": {
      "kubernetes": {
        "command": "mcp-server-kubernetes",
        "args": ["--kubeconfig", "${HOME}/.kube/config"],
        "env": {
          "KUBECONFIG": "${HOME}/.kube/config"
        }
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"command": "mcp-server-kubernetes",
        "args": ["--kubeconfig", "${HOME}/.kube/config"],
        "env": {
          "KUBECONFIG": "${HOME}/.kube/config"
        }
      },
      "postgresql": {
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

High
Confidence
98% confidence
Finding
The markdown describes automatic external publishing without a clear user-facing warning about data-sharing consequences. Because the skill handles logs, metrics, root-cause narratives, and possible code diffs, failing to prominently disclose outbound sharing undermines informed consent and can expose sensitive production information.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The README states that tickets may be automatically created, updated, and correlated in an external ticket database, but it does not clearly warn users that running the skill can modify live incident records. In a DevOps/SRE context, this can cause unintended changes to operational workflows, noisy or incorrect incident records, and accidental writes to production-integrated systems if users assume the skill is read-only.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The README advertises optional auto-fix code generation and PR submission without a prominent warning that the skill may modify code repositories through GitHub integration. In this skill's context, that is more dangerous because it operates on production incidents and related code, so an operator could unintentionally trigger repository changes, create unreviewed fixes, or introduce harmful patches during incident response.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The README advertises code review and optional auto-fix/PR submission features that extend beyond the stated incident-analysis and observability scope. In an agent skill, scope expansion matters because users may invoke capabilities that can modify source code or repositories, increasing the chance of unexpected write actions and privilege misuse.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The workflow says tickets are 'automatically create[d], update[d], and correlate[d]' without a nearby warning that this may alter external incident records. In a DevOps/SRE context, silent writes to ticketing systems can corrupt audit trails, create false incidents, or trigger operational workflows based on agent output.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The README describes optional auto-fix generation and PR submission without an explicit warning adjacent to the feature that code changes may be produced automatically. In this skill context, that is more dangerous because the agent is connected to GitHub and incident tooling, so an operator may treat it as analysis-only while it can initiate code-change workflows.

Lp3

Medium
Category
MCP Least Privilege
Confidence
70% confidence
Finding
Without declared permissions the skill's intent is opaque and cannot be validated.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The trigger phrase 'help me analyze the cause' is broad conversational language that can easily appear in normal user requests outside a tightly scoped DevOps context. This increases the chance of unintended skill invocation, causing the agent to access monitoring, logs, or ticketing workflows when the user did not explicitly request this specific capability.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The phrase 'Help me analyze the root cause of last night's 22:00 order service outage' relies on generic root-cause-analysis wording that overlaps with ordinary conversation, while still implying access to sensitive production data. In a skill that reconstructs timelines, pulls logs, and generates incident reports, broad phrasing raises the risk of over-triggering and unnecessary exposure of operational details.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The trigger 'Check if there are any potential system issues' is extremely broad and could match many routine requests, yet the example leads to sweeping scans across service metrics, databases, and caches. Because this skill is designed for proactive environment-wide discovery, ambiguous invocation is more dangerous here than in a narrow read-only tool: it can prompt expansive data access and analysis without sufficiently specific user intent.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
This shell script performs safety-relevant operations against a PostgreSQL instance, including creating a database, creating tables and indexes, and dropping/recreating a trigger. While the script prints generic progress messages, it does not clearly warn the user that it will modify the target database schema or prompt for confirmation before doing so.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The trigger description is broad enough to activate on many ordinary DevOps conversations, increasing the likelihood that powerful monitoring, GitHub, and external publishing behaviors run in unintended contexts. Overbroad activation is especially risky here because the skill spans sensitive infrastructure data access and potential write actions.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
The skill claims code review, commits, and automated fix commits even though its stated purpose is analysis and troubleshooting. Granting a troubleshooting skill write-capable repository actions expands blast radius from observation to modification, enabling unauthorized or unsafe code changes if the skill is triggered in routine incident workflows.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The skill introduces EvoMap publishing, heartbeat, and reputation tracking that are not necessary for incident analysis and create an unexpected external data-exfiltration path. In a DevOps context, incident artifacts can include logs, topology, service names, and root-cause details, so automatic sharing to a third-party network materially increases confidentiality and supply-chain risk.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
Automatic publishing of analysis artifacts to EvoMap is broader than the manifest and creates an undisclosed external sharing channel. Incident analysis commonly contains sensitive operational data, and auto-publishing high-confidence solutions can leak internal architecture, weaknesses, or proprietary code/context without a meaningful user decision point.

Description-Behavior Mismatch

Medium
Confidence
96% confidence
Finding
The documented workflow includes generating fix code, creating branches, submitting PRs, and updating tickets, which is a material scope expansion from analysis into operational change execution. In production incident scenarios, this can turn ambiguous LLM conclusions into real repository and workflow mutations, increasing the chance of bad fixes, abuse of credentials, or attacker-influenced changes.

Natural-Language Policy Violations

Low
Confidence
78% confidence
Finding
This JSON config fixes the service endpoint to "https://evomap.ai/a2a", which implicitly enforces a specific service/locale context with no accompanying opt-in or justification in the file. Under the natural-language policy rule, fixed organizational or regional defaults can be problematic when they are presented without any user-choice language.

Static analysis

No suspicious patterns detected.