Back to skill

Security audit

Agent-team-manager

Security checks for vulnerabilities and agentic risk

Overview

This skill is mostly a local AI-team management helper, but it has real report-safety and quality-check reliability flaws that should be reviewed before installation.

Review this skill carefully before installing. It does not show evidence of stealing data, persistence, or destructive behavior, but the implementation is incomplete and overclaimed, asks for more environment access than the code appears to use, can generate unsafe HTML reports from untrusted task data, and has broken quality scoring that could make review gates unreliable.

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 (2)

T09 · Insecure Skill Coding Practices

Error
Location
progress-tracker.js:360
Finding
Stored HTML Injection in Generated Progress Reports<![CDATA[ ## Vulnerability Details **File Location**: `progress-tracker.js`, lines 360-365 **Vulnerability Type**: Stored HTML injection / cross-site scripting **Risk Level**: High ### Vulnerable Code ```javascript ${summary.tasks.map(task => ` <tr> <td>${task.name}</td> <td>${task.status}</td> <td>${task.progress}%</td> <td>${task.assignedAgent}</td> </tr> `).join('')} ``` ### Technical Analysis The HTML report generator directly interpolates task-controlled values into HTML markup without context-appropriate encoding. The affected fields include: - `task.name` - `task.status` - `task.progress` - `task.assignedAgent` These values can originate from task and agent metadata supplied to the progress tracker. Because characters such as `<`, `>`, `"`, `'`, and `&` are not escaped, an attacker can provide HTML containing executable event handlers or other active content. For example, a malicious task name could contain: ```html <img src="x" onerror="alert(document.domain)"> ``` When `generateProgressReport('html')` renders the report, this value becomes active markup rather than plain text. ### Attack Path 1. An attacker, compromised agent, or untrusted integration supplies malicious task metadata. 2. The application stores the value through task initialization or assignment operations. 3. A user requests an HTML report through `generateProgressReport('html')`. 4. `generateHtmlReport()` interpolates the malicious value directly into a table cell. 5. The generated report is opened in a browser or embedded in an HTML-capable interface. 6. The browser interprets the injected content as markup and may execute attacker-controlled JavaScript. ### Impact Assessment Successful exploitation permits script execution in the security context of the generated report. Depending on how the report is hosted or embedded, an attacker may be able to: - Read or alter report content visible to the browser. - Access data available to the report's origin. - ...[truncated 387 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. HTML-encode every untrusted value before inserting it into the report: ```javascript function escapeHtml(value) { return String(value) .replaceAll('&', '&amp;') .replaceAll('<', '&lt;') .replaceAll('>', '&gt;') .replaceAll('"', '&quot;') .replaceAll("'", '&#39;'); } ``` Apply the function to all dynamic fields: ```javascript <td>${escapeHtml(task.name)}</td> <td>${escapeHtml(task.status)}</td> <td>${escapeHtml(task.progress)}%</td> <td>${escapeHtml(task.assignedAgent)}</td> ``` 2. Prefer a template engine that enables automatic HTML escaping by default. 3. Validate task status and progress against strict schemas. For example, require status to be one of the supported values and progress to be a finite number from 0 through 100. 4. If reports are served over HTTP, apply a restrictive Content Security Policy that disallows inline scripts and event handlers. 5. Add regression tests using payloads in every rendered task field and verify that the output contains encoded text rather than executable markup. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
quality-controller.js:175
Finding
Broken Quality-Control Scoring Caused by Object-to-Number Arithmetic<![CDATA[ ## Vulnerability Details **File Location**: `quality-controller.js`, lines 175-181 and 442-450 **Vulnerability Type**: Quality-control validation failure **Risk Level**: Medium ### Vulnerable Code The assessment methods assign structured objects to the score map: ```javascript // Accuracy assessment scores.accuracy = await this.assessAccuracy(output, taskSpec); weights.accuracy = this.qualityStandards.output.accuracy.weight; // Completeness assessment scores.completeness = await this.assessCompleteness(output, taskSpec); weights.completeness = this.qualityStandards.output.completeness.weight; ``` Those objects are subsequently treated as numeric values: ```javascript calculateWeightedAverage(scores, weights) { let total = 0; let weightSum = 0; for (const [key, score] of Object.entries(scores)) { const weight = weights[key] || 0; total += score * weight; weightSum += weight; } return weightSum > 0 ? total / weightSum : 0; } ``` For example, `assessAccuracy()` returns an object rather than a number: ```javascript return { score, maxScore: 1.0, issues, confidence: this.calculateConfidence(issues.length) }; ``` ### Technical Analysis The entries in `scores` are assessment objects such as `{ score: 0.8, maxScore: 1.0 }`. Multiplying one of these objects by a numeric weight coerces the object to a primitive value and produces `NaN`. Consequently, `calculateWeightedAverage()` produces `NaN`, which propagates into the overall quality score. The same type mismatch affects issue detection, where structured assessment objects are compared directly with numeric thresholds: ```javascript if (output.accuracy < standards.accuracy.minScore) { ``` That comparison evaluates through invalid numeric coercion and does not reliably detect a low score. As a result, the issue list can remain empty even when an individual assessment's `.score` is below its required threshold. The final pass comparison against a `NaN` overall ...[truncated 1509 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Extract the numeric `.score` property during weighted calculations: ```javascript calculateWeightedAverage(scores, weights) { let total = 0; let weightSum = 0; for (const [key, assessment] of Object.entries(scores)) { const numericScore = typeof assessment === 'number' ? assessment : assessment?.score; const weight = weights[key] || 0; if (!Number.isFinite(numericScore)) { throw new TypeError(`Invalid score for quality category: ${key}`); } total += numericScore * weight; weightSum += weight; } return weightSum > 0 ? total / weightSum : 0; } ``` 2. Use `.score` explicitly in all threshold checks: ```javascript if (output.accuracy.score < standards.accuracy.minScore) { // Record the issue. } ``` Apply the same correction to completeness, clarity, relevance, and process-compliance comparisons. 3. Validate the final result before making a pass/fail decision: ```javascript if (!Number.isFinite(assessment.overallScore)) { throw new Error('Quality assessment produced an invalid overall score'); } ``` 4. Define and enforce a stable assessment schema so every assessment function returns the same structured shape. 5. Add unit tests covering: - Scores below and above every configured threshold. - Malformed or missing score properties. - `NaN`, `Infinity`, and nonnumeric input. - Correct generation of issues and recommendations. - Correct final pass and fail outcomes. ]]>
Vulnerability Patterns
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (18)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The declared description presents a functional multi-agent team management system with operational features for coordinating agents and tracking work quality/performance. The supplied code chunk does not implement any of those capabilities. Instead, it is a simple publishing script that checks for required files and prints instructions for publishing to ClawHub. This is a materially different primary purpose, so the description does not accurately represent the behavior of the provided code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
88% confidence
Finding
The code generally matches the high-level theme of agent team coordination: it supports agent registration, task assignment, progress/status updates, communication channels, and simple performance evaluation. However, parts of the description are more specific than what the code actually implements. There is no evidence of any 'proven Otter Camp methodology,' no concrete quality-control workflow beyond basic status tracking, and no OpenClaw-specific integration or behavior. So while the primary purpose is aligned, the declared description overstates specific capabilities and specialization not present in the code.

Tp4

High
Category
MCP Tool Poisoning
Confidence
88% confidence
Finding
The code is related to multi-agent workflow orchestration, so it partially aligns with the high-level theme of agent/team management. However, the declared description overstates the implemented functionality. The actual code is a generic workflow manager: it validates workflow step definitions, checks dependency cycles, executes steps in dependency order with retries, stores status, and supports import/export/list/delete operations. Its `callAgent` method is explicitly a mock/simulated implementation, so the claimed OpenClaw coordination is not actually present. Also, while there is minimal progress/state tracking via workflow status and per-step results, there is no implementation of quality control, performance evaluation, or any identifiable Otter Camp methodology. Therefore the description does not accurately represent what this code chunk actually does.

Natural-Language Policy Violations

Medium
Confidence
92% confidence
Finding
SQP-3 applies to all file types and includes language or locale policy violations. This README presents the skill description in Chinese only, with no opt-in, multilingual alternative, or explanation that the skill is region-specific, which may improperly force a specific language on users.

Natural-Language Policy Violations

Medium
Confidence
86% confidence
Finding
The usage example hard-codes analysis of emails from a 'QQ mailbox', which implies a specific provider/locale context in the natural-language instructions. The file does not offer an alternative provider choice or explain why this locale-specific example is required, which can violate language/locale neutrality expectations.

Natural-Language Policy Violations

Medium
Confidence
90% confidence
Finding
This JavaScript example uses Chinese in comments, names, descriptions, and console output, including the final user-facing messages. Under the policy, a skill should not force a specific language or locale unless it offers user opt-in or clearly documents a justified region-specific constraint, which is not present here.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The file includes user-facing descriptive and evaluative strings in Chinese, beginning with the top-level description and continuing throughout the generated strengths, weaknesses, insights, and recommendations. This imposes a specific language on downstream users or operators without any opt-in, fallback, or justification for a Chinese-only locale.

Natural-Language Policy Violations

Medium
Confidence
97% confidence
Finding
The evaluator populates strengths, weaknesses, and recommendations with hardcoded Chinese phrases, which means report recipients will receive Chinese-language output regardless of their preferences. The file does not provide any mechanism for user opt-in, translation, or locale configuration.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
The team report generation logic emits hardcoded Chinese insight and recommendation messages. Because these are natural-language outputs intended for users, the lack of locale choice or documented regional limitation creates a language policy issue.

Natural-Language Policy Violations

Medium
Confidence
92% confidence
Finding
This JavaScript file contains natural-language content in Chinese comments and generates reports with fixed English headings such as 'AI Agent Team Progress Report' and 'Team Performance'. Because the skill does not offer any language or locale selection, it hard-codes language behavior rather than letting the user opt in.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
This code contains natural-language documentation that is exclusively in Chinese, which can violate language/locale policy when no user choice or justification is provided. The file does not indicate that the skill is region-specific or that users may select another language.

Natural-Language Policy Violations

Medium
Confidence
93% confidence
Finding
The generated report includes recommendation text only in Chinese, which forces a specific language in user-visible output. There is no opt-in, locale selection, or documented regional justification in this file.

Intent-Code Divergence

Medium
Confidence
98% confidence
Finding
This is a real logic flaw: calculateWeightedAverage iterates over assessment result objects like {score, maxScore, ...} and multiplies the whole object by a numeric weight, which yields NaN in JavaScript. That breaks downstream quality scoring, causing overall assessments to be invalid or unreliable, which is dangerous in a team-management quality gate because poor or non-compliant agent outputs may be incorrectly passed, blocked, or mishandled.

Intent-Code Divergence

Medium
Confidence
98% confidence
Finding
This is also a true vulnerability in the quality-control logic: identifyIssues compares structured assessment objects such as output.accuracy and process.compliance directly against numeric thresholds and calls toFixed on them, which will not behave as intended and can throw or mis-evaluate in JavaScript. In this skill's context, the module is supposed to enforce review quality for multiple agents, so broken issue detection weakens oversight and can let low-quality or policy-violating work evade detection.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
This JavaScript file contains comments, error strings, and log messages in Chinese throughout, which effectively imposes a specific language on users or maintainers. The policy allows locale constraints only when they are optional, opt-in, or clearly justified, none of which is present here.

Missing User Warnings

Low
Confidence
78% confidence
Finding
This is a markdown file, so SQP-2 applies to missing user-facing warnings in the skill description. The feature list claims an 'automated deployment workflow', which can affect system integrity or production environments, but the document provides no caution, confirmation expectation, or scope limitation for that behavior.

Natural-Language Policy Violations

Low
Confidence
90% confidence
Finding
This JavaScript file contains user-facing and maintainer-facing natural-language documentation entirely or partly in Chinese, such as the module description and method docstrings. Because the skill does not indicate that Chinese is optional or required for a justified region-specific purpose, it can be read as imposing a language choice without user opt-in.

Natural-Language Policy Violations

Low
Confidence
89% confidence
Finding
This JavaScript file mixes English code identifiers with Chinese-only descriptive comments such as '管理复杂的多代理工作流和任务依赖关系'. Under the stated policy, forcing a specific language without opt-in can be a natural-language policy violation when no user choice or justification is provided.

Static analysis

No suspicious patterns detected.