Back to skill

Security audit

meta-self-play-coevolution

Security checks for vulnerabilities and agentic risk

Overview

The skill is not clearly malicious, but it overstates advanced autonomous capabilities and includes unbounded local cross-session note storage that could influence later agent behavior without clear controls.

Review this skill carefully before installing. It does not show evidence of network exfiltration, credential access, or destructive behavior, but it stores arbitrary notes locally for future reuse and its documentation promises broader autonomous capabilities than the artifact actually implements. Install only if you are comfortable with local cross-session learning state, and prefer adding explicit limits, review controls, and clear documentation before using it in shared or sensitive environments.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • 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
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
Findings (1)

T02 · Agent Memory Poisoning

Warning
Location
scripts/learner.py:12
Finding

Unvalidated Attacker-Controlled Notes Stored in Persistent Agent State

Content
View full analysis

Vulnerability Details

File Location: scripts/learner.py:12-18; persistence and cross-session reuse are described in SKILL.md:25-28
Vulnerability Type: T02: Agent Memory Poisoning
Risk Level: Medium

Vulnerable Code

python
def record(op_ok=True, note=""):
    d = load(); d["total_ops"] += 1
    if not op_ok:
        d["total_fails"] += 1
    if note:
        d.setdefault("patterns", []).append(note)
    json.dump(d, open(MEM, "w", encoding="utf-8"), ensure_ascii=False, indent=2)
    return d

The command-line entry point allows the note to originate directly from an argument:

python
if __name__ == "__main__":
    ok = (sys.argv[1] != "fail") if len(sys.argv) > 1 else True
    rec = (sys.argv[2] if len(sys.argv) > 2 else "")
    print(json.dumps(record(ok, rec), ensure_ascii=False))

The intended persistent-learning behavior is documented in SKILL.md:

text
2. **自我反思闭环**:执行后写入 `self-reflection-loop`,沉淀失败模式到 learner。
5. **持续自进化**:注入 learner,纳入 meta-evolver 的 sense/plan/record 闭环,跨会话越用越强。

Technical Analysis

The learner accepts an arbitrary string from sys.argv[2] and appends it to the persistent patterns array in scripts/learned_patterns.json. It performs no schema validation, provenance verification, instruction filtering, sensitivity checks, size restriction, retention control, or separation between users and tasks.

The Skill documentation states that these records are intended to support reflection, continued evolution, and learning across sessions. Consequently, attacker-controlled task content could be saved as a learned pattern and later influence Agent behavior if a downstream meta-evolver or reflection component treats stored patterns as trusted guidance.

The repository does not contain the downstream consumer that would apply these patterns. Therefore, direct future instruction execution is not demonstrated by the audited code itself; th ...[truncated 1795 chars]

Remediation
View remediation

Remediation Suggestions

  1. Require explicit user authorization before persisting reflection or task-derived content.
  2. Treat stored notes strictly as untrusted data and never concatenate them into system or developer instructions.
  3. Define a restrictive schema containing structured failure categories rather than arbitrary free-form instructions.
  4. Enforce length limits, character restrictions, entry-count quotas, and total file-size limits.
  5. Detect and reject secrets, credentials, prompt-like directives, tool commands, and other sensitive or executable content.
  6. Record provenance, timestamp, user or task identity, trust level, and review status for every entry.
  7. Isolate storage by user, tenant, and task to prevent cross-context poisoning.
  8. Require review or trusted validation before any stored pattern can affect future planning or behavior.
  9. Provide listing, correction, expiration, and deletion controls for persisted records.
  10. Use atomic writes and restrictive filesystem permissions to reduce corruption and unauthorized local modification.
  11. Document the exact downstream trust boundary and add tests proving that persisted text cannot override higher-priority instructions.
Vulnerability Patterns
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • 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
Findings (4)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill claims advanced self-verification, reflection, orchestration, and continuous self-evolution features that are not actually implemented, while its apparent real behavior is local persistence/logging. This mismatch is dangerous because users or higher-level agents may grant trust, autonomy, or privileges based on false assurances, causing insecure deployment and hiding the true effects of the skill.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
86% confidence
Finding

The skill advertises capabilities implying persistence and evolution, and the static finding indicates file-write behavior exists without any declared tool scope or permission boundary. In an agent ecosystem, undocumented write access is risky because it can enable unauthorized local state changes, hidden logging, or persistence beyond what operators expect.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The entire report is written in Chinese, including headings and operational descriptions, with no indication that language choice is optional or that the skill is region-specific. Under the policy rule for natural-language violations, this constitutes a language/locale constraint without user opt-in or documented justification.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
84% confidence
Finding

The module docstring is written entirely in Chinese and describes the skill behavior only in that language. Under the stated policy, forcing or assuming a specific language without offering user choice or documenting a justified locale constraint is a natural-language policy violation.

Content

No source excerpt is available for this finding.