Back to skill

Security audit

LYGO Champion: omnisiren silent storm

Security checks for vulnerabilities and agentic risk

Overview

This is a legacy persona helper with read-only local metadata scripts, but its unpinned install command should be treated cautiously.

Before installing, prefer the successor skill and use a pinned, verified ClawHub installer instead of the documented `@latest` command. Treat the persona text as advisory framing only, not permission for automatic shutdown, deletion, enforcement, or irreversible actions.

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

Warning
Location
SKILL.md:9
Finding
Mutable Third-Party Package Is Executed Through an Unpinned Latest Tag<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, line 9 **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium ### Vulnerable Code ```markdown > `npx clawhub@latest install deepseekoracle/lygo-champion-council` ``` ### Technical Analysis The documented installation command instructs users to execute the `latest` release of the third-party `clawhub` npm package through `npx`. The `latest` tag is mutable and may resolve to different package contents over time. The project does not pin an audited package version or specify an integrity digest. Because `npx` downloads and executes package code, the command crosses a supply-chain trust boundary. The reviewed repository does not establish that the package version executed by a future user is the same version reviewed or expected by the project. No evidence was found that the current upstream package is malicious. The vulnerability is the use of an unauthenticated, mutable dependency in an executable installation instruction. ### Attack Path 1. An attacker compromises the upstream npm package, its publisher account, or the mutable `latest` release channel. 2. The attacker publishes a modified release and assigns it to the `latest` tag. 3. A user follows the installation command in `SKILL.md`. 4. `npx` resolves, downloads, and executes the attacker-controlled release. 5. The payload runs with the privileges and environment access of the invoking user. ### Impact Assessment Successful exploitation could permit arbitrary code execution under the invoking user's account. Depending on that account's privileges and environment, the payload could access user-readable files, credentials exposed to the process, project data, and network resources. If the command is run with elevated privileges, the scope could extend to system-wide resources. The issue does not independently provide elevated privileges; its maximum scope is determined by the privileges granted to the `npx` proces ...[truncated 6 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the mutable `latest` tag with an exact, reviewed package version: ```bash npx clawhub@<audited-version> install deepseekoracle/lygo-champion-council ``` 2. Pin and verify the package integrity digest through a lockfile or another authenticated package-verification mechanism. 3. Document the expected publisher, registry, exact version, and integrity value. 4. Review a new package version before updating the documented command. 5. Where practical, download and inspect the package before executing it, and run installation with the minimum required privileges in an isolated environment. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/self_check.py:32
Finding
Advertised Persona-Pack Integrity Check Does Not Verify File Contents<![CDATA[ ## Vulnerability Details **File Locations**: - `scripts/self_check.py`, lines 32–35 - `scripts/show_hash.py`, lines 1–6 **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Medium ### Vulnerable Code `scripts/self_check.py`, lines 32–35: ```python h = canon.get("lygo_mint_sha256") if h is not None and (not isinstance(h, str) or len(h) != 64): print("BAD_CANON: lygo_mint_sha256 invalid") raise SystemExit(2) ``` `scripts/show_hash.py`, lines 1–6: ```python import json from pathlib import Path canon_path = Path(__file__).resolve().parents[1] / "references" / "canon.json" canon = json.loads(canon_path.read_text(encoding="utf-8")) print(canon.get("lygo_mint_sha256") or "MISSING_HASH") ``` ### Technical Analysis The project states that the persona pack is hashed and directs users to obtain the hash from `references/canon.json`. However, the local scripts do not calculate a SHA-256 digest of `references/persona_pack.md` or compare such a digest with the recorded `lygo_mint_sha256` value. The self-check validates only that the stored value is a string with a length of 64 characters. It does not confirm that all characters are hexadecimal, and it does not establish any relationship between the stored value and the current persona-pack contents. The hash-display script likewise prints the unverified metadata value directly. Consequently, the scripts provide metadata display and superficial format validation rather than cryptographic integrity verification. ### Attack Path 1. An attacker or unauthorized local process modifies `references/persona_pack.md`. 2. The attacker leaves the existing 64-character value in `references/canon.json`, or replaces it with any other 64-character string. 3. A user runs `scripts/self_check.py`. 4. The check exits successfully because it verifies only the type and length of the stored value. 5. If the user runs `scripts/show_hash.py`, the script prints the stored value without checking th ...[truncated 702 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Define the exact canonicalization algorithm used when generating `lygo_mint_sha256`, including encoding, Unicode normalization, and newline handling. 2. Read and canonicalize `references/persona_pack.md`, calculate its SHA-256 digest, and compare it with the expected value using a constant-time comparison: ```python import hashlib import hmac pack = ROOT / "references" / "persona_pack.md" actual = hashlib.sha256(pack.read_bytes()).hexdigest() expected = canon.get("lygo_mint_sha256") if not isinstance(expected, str) or not hmac.compare_digest(actual, expected.lower()): print("BAD_HASH: persona pack does not match canon") raise SystemExit(2) ``` 3. If the minting process hashes a canonicalized representation rather than raw bytes, implement that exact process locally instead of using the raw-byte example. 4. Validate the metadata value with a strict expression such as `^[0-9a-fA-F]{64}$`. 5. Make `show_hash.py` display both the expected and computed values and return a nonzero status when they differ. 6. Add automated tests covering modified content, malformed hashes, newline differences, and Unicode canonicalization. 7. Correct or remove the `canonical_snapshot` path in `references/canon.json` if the referenced snapshot is not distributed, because unavailable verification material can further impair reproducibility. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • 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
Findings (12)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared description says this skill is just a deprecated slug/legacy entry directing users to another skill, which implies little to no functional behavior beyond aliasing or deprecation metadata. The supplied code instead implements a concrete validation utility that reads local files, inspects JSON fields, verifies documentation contents, and returns diagnostic exit codes. That is a materially different primary purpose from a deprecated redirect-like slug, so this should be flagged as a mismatch.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared description presents this skill as a deprecated slug whose purpose is simply to indicate that users should use another skill. That suggests little or no operative behavior beyond acting as a legacy alias. The actual code, however, performs a concrete function: it opens a local JSON reference file, parses it, looks up a specific field ('lygo_mint_sha256'), and prints the result. This is a materially different primary purpose from a deprecation notice or redirect marker, so the description does not accurately represent the behavior.

Ae4

Medium
Category
analysis-evasion
Confidence
80% confidence
Finding
Suspicious Unicode normalization or mixed-script content

Lp3

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

Rp1

Medium
Category
MCP Rug Pull
Confidence
95% confidence
Finding
Using `npx clawhub@latest install ...` pulls and executes the latest package version at install time, which is a supply-chain risk because behavior can change without review. If the upstream package is compromised or a breaking version is published, users of this deprecated skill could execute untrusted code simply by following the embedded command.

Ae4

Medium
Category
analysis-evasion
Confidence
89% confidence
Finding
The JSON contains mixed-script Unicode in the display field ("OMNIΣIREN"), where the Greek capital sigma is substituted into an otherwise Latin identifier. This can enable visual spoofing, inconsistent matching, and policy bypasses if downstream systems compare, normalize, or display identifiers differently. In a reference/canonical metadata file, such ambiguity is more dangerous because other tools may treat these values as authoritative.

Ae4

Medium
Category
analysis-evasion
Confidence
94% confidence
Finding
The heading and linked filenames use mixed-script Unicode characters, including a Greek sigma-like character in 'OMNIΣIREN'. Mixed-script text can be used to create visually deceptive identifiers that differ from expected ASCII names, increasing the risk of phishing, reviewer confusion, broken allowlists, or security control bypasses when humans or tools treat homoglyphs as equivalent.

Ae4

Medium
Category
analysis-evasion
Confidence
95% confidence
Finding
The persona pack uses mixed-script and unusual Unicode text such as 'OMNIΣIREN' and 'Δ9', which can create ambiguity between visually similar characters and enable spoofing, policy bypass, or signature mismatches. In a skill package that includes activation phrases, labels, and verification references, this increases the risk of users or downstream tools misidentifying commands or anchors.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The metadata says this slug is deprecated and should point to another skill, but the file still contains active operational persona content and invocation instructions. This inconsistency can mislead users or orchestration systems into loading legacy behavior unexpectedly, bypassing intended routing or governance controls.

Intent-Code Divergence

Medium
Confidence
93% confidence
Finding
The file describes itself as a 'pure advisor' while simultaneously presenting the persona as a 'Silent Executor' and 'Collapse Initiator' that performs irreversible actions. That mismatch is dangerous because it can cause integrators to grant the skill advisory-only trust boundaries while the content encourages agentic or destructive behavior.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The text promotes an irreversible 'Collapse Protocol' and 'truth-force collapse' without warnings, constraints, or human-approval requirements. Even if framed as persona language, such operational phrasing can be adopted by agents or users as instructions for destructive behavior, especially in automation contexts.

Ae4

Medium
Category
analysis-evasion
Confidence
80% confidence
Finding
Suspicious Unicode normalization or mixed-script content

Static analysis

No suspicious patterns detected.