Back to skill

Security audit

Side Peace

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent secret-handoff tool, but it exposes a credential entry server too broadly and without enough protective controls.

Review before installing or using this skill with real credentials. Prefer a version that binds to localhost by default, uses a one-time secret URL or other authentication, limits request size, escapes the label, creates output files exclusively with verified 0600 permissions, and avoids passing tokens through unpinned npx commands or command-line arguments.

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

T09 · Insecure Skill Coding Practices

Error
Location
drop.js:66
Finding

Plaintext Unauthenticated Secret Receiver Exposed on All Network Interfaces

Content
View full analysis
{ if (req.method === 'GET') { res.writeHead(200, { 'Content-Type': 'text/html' }); res.end(html); } else if (req.method === 'POST') { let body = ''; req.on('data', c => body += c); req.on('end', () => { res.writeHead(200); res.end('ok'); // Write secret to file (NOT stdout!) fs.writeFileSync(OUTPUT, body.trim(), { mode: 0o600 }); console.log(`\n✓ Secret received and saved.`); console.log(` File: ${OUTPUT}`); console.log(` (Secret is NOT printed to stdout for security)`); server.close(() => process.exit(0)); }); } }); // Start server.listen(PORT, '0.0.0.0', () => { const ips = getLocalIPs(); console.log(`🍒 Side_Peace waiting...`); console.log(` Label: ${LABEL}`); console.log(` Output: ${OUTPUT}\n`); console.log(` Local: http://localhost:${PORT}`); ips.forEach(ip => console.log(` Network: http://${ip}:${PORT}`)); console.log(`\nWaiting for secret...`); }); ``` ### Technical Analysis The server binds to `0.0.0.0`, making the secret receiver accessible through every available network interface. It uses unencrypted HTTP and accepts any POST request without authentication, a one-time capability token, source restrictions, or request-origin validation. Although receiving a secret over the network is part of the declared functionality, exposure to the entire local network exceeds the minimum privilege needed for a same-device browser handoff. The implementation also treats the first POST request as authoritative and shuts down after processing it. The detected network transmission is therefore functional rather than concealed external exfiltration, but it lacks the controls ...[truncated 1246 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
drop.js:51
Finding

HTML and Script Injection Through the User-Controlled Label

Content
View full analysis
${LABEL} ``` ### Technical Analysis The value supplied through the `--label` command-line argument is interpolated directly into the generated HTML document without HTML escaping or contextual output encoding. A crafted label can terminate the existing paragraph element and inject arbitrary HTML or JavaScript. Injected JavaScript executes in the same page that contains the secret textarea. It can register input or submission handlers, read the entered secret, alter the destination of the submission, or send the value to an attacker-controlled service. Exploitation requires an attacker to influence the command-line label or persuade an agent or operator to invoke the documented command with a malicious label. The vulnerability becomes especially significant in agent-controlled environments where arguments may originate from untrusted task content. ### Attack Path 1. An attacker supplies or recommends a malicious label such as one containing a closing HTML tag and a script element. 2. The agent invokes `drop.js` with that value in the `--label` argument. 3. The Skill inserts the label into the generated page without escaping it. 4. The victim opens the secret-entry URL. 5. The injected script executes in the page. 6. When the victim enters or submits the secret, the script reads and transmits it to an attacker-controlled endpoint. ### Impact Assessment Successful exploitation compromises the confidentiality and integrity of the secret handoff. An attacker can steal the submitted credential, change the displayed instructions, forge success messages, or manipulate the submitted value. The script runs in the temporary application's browser origin and does not inherently obtain operating-system p ...[truncated 104 chars]
Remediation
View remediation
`, `"`, and `'`. - Prefer generating a fixed page and assigning the label through the DOM `textContent` property. - Validate the label against a conservative length and character allowlist. - Add a restrictive Content Security Policy that disallows inline scripts and unauthorized network destinations. - Move the existing inline JavaScript into a fixed local script if a strict Content Security Policy is adopted. - Treat every command-line value as untrusted when invocations may be assembled from agent or user-provided content. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
drop.js:71
Finding

Unbounded POST Body Accumulation Enables Resource Exhaustion

Content
View full analysis
body += c); req.on('end', () => { res.writeHead(200); res.end('ok'); // Write secret to file (NOT stdout!) fs.writeFileSync(OUTPUT, body.trim(), { mode: 0o600 }); ``` ### Technical Analysis The server appends every received chunk to an in-memory string without enforcing a maximum request size. After reception, it synchronously writes the complete value to disk. Because the service is exposed on all interfaces, any reachable client can stream a very large body or keep the request open. Repeated string concatenation can consume substantial memory, while synchronous file output blocks the Node.js event loop. The implementation also does not validate `Content-Length`, impose a request timeout, or stop processing after an acceptable secret-size threshold. ### Attack Path 1. An attacker connects to the exposed HTTP service. 2. The attacker begins a POST request and sends a very large body or continuously streams chunks. 3. The process appends every chunk to `body`. 4. Memory usage increases until the process slows, crashes, or is terminated by the operating system. 5. If reception completes, the server attempts to synchronously write the oversized value, potentially consuming disk space and blocking other work. ### Impact Assessment An unauthenticated network client can deny availability of the handoff service and may affect other processes on the host through memory or disk exhaustion. This vulnerability does not directly grant additional privileges or code execution, but its resource impact can extend beyond the Skill process when system resources are constrained. ]]>
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
drop.js:78
Finding

Unsafe Output Path Handling Can Overwrite Files or Weaken Secret Permissions

Content
View full analysis
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
SKILL.md:38
Finding

Documentation Recommends Mutable Runtime Package Execution and Argument-Based Token Passing

Content
View full analysis
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (11)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The skill is presented as a minimal local secret handoff, but the documented behavior includes binding on all interfaces, advertising LAN URLs, and allowing arbitrary output paths. This mismatch is dangerous because users may trust it as local-only while it actually broadens attack surface and can place secrets in locations or contexts they did not intend.

Content

No source excerpt is available for this finding.

Credential Access

High
Category
Privilege Escalation
Confidence
70% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · SKILL.md (reported line 28)May include surrounding context.

md
node skills/side-peace/drop.js --label "CLAWHUB_TOKEN"

# Custom output path
node skills/side-peace/drop.js --label "API_KEY" --output /tmp/my-secret.txt

# Custom port
node skills/side-peace/drop.js --port 4000 --label "TOKEN"

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · SKILL.md (reported line 42)May include surrounding context.

Read and use (example with clawhub)

SECRET=$(cat /tmp/side-peace-xxx.secret) npx clawhub login --token "$SECRET" --no-browser rm /tmp/side-peace-xxx.secret

text

Or one-liner:

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

The one-liner pipes secret file contents through xargs into a command line, which can mis-handle secrets containing whitespace, shell-significant characters, or leading dashes and may expose them via process listings. Combining secret ingestion, external tool execution, and deletion in one shell chain reduces safety and makes failure handling opaque.

Content

Scanner excerpt · SKILL.md (reported line 47)May include surrounding context.

Or one-liner:

bash
cat /tmp/side-peace-xxx.secret | xargs -I{} npx clawhub login --token {} --no-browser; rm /tmp/side-peace-xxx.secret

Security

Chaining Abuse

High
Category
Tool Misuse
Confidence
83% confidence
Finding

The chained one-liner combines reading a secret, sending it to an unpinned externally fetched tool, and deleting the evidence file in a single command. This is dangerous because it magnifies the blast radius of any compromise or failure: a malicious or compromised tool can capture the secret, and immediate deletion hinders audit and recovery while the token has already been disclosed.

Content

Scanner excerpt · SKILL.md (reported line 47)May include surrounding context.

Or one-liner:

bash
cat /tmp/side-peace-xxx.secret | xargs -I{} npx clawhub login --token {} --no-browser; rm /tmp/side-peace-xxx.secret

Security

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The server explicitly binds to 0.0.0.0 and advertises reachable network URLs, which exposes the secret submission endpoint to any host that can reach the machine. Because there is no authentication, origin check, one-time token, or transport protection, an attacker on the same network can submit a secret first, overwrite or poison the expected value, or trick the operator into sending sensitive data to an untrusted listener.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding

The skill documentation describes network behavior but does not declare any tool scope or permissions, which weakens reviewability and allows broader-than-explicitly-declared capability use. In an agent setting, undeclared network exposure is security-relevant because operators may assume the skill is local-only when it is not.

Content

No source excerpt is available for this finding.

Rp1

Medium
Category
MCP Rug Pull
Confidence
86% confidence
Finding

Using npx clawhub without pinning a specific version allows retrieval and execution of whatever package version is current at runtime. This creates a supply-chain risk where a malicious or compromised upstream release could receive the secret token passed on the command line.

Content

No source excerpt is available for this finding.

Rp1

Medium
Category
MCP Rug Pull
Confidence
86% confidence
Finding

The one-liner again invokes npx clawhub without version pinning, so the command may execute an unexpected package version fetched at runtime. Because this invocation directly feeds a secret into the tool, any supply-chain compromise could expose credentials immediately.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The documentation omits a clear warning that the secret entry form is reachable on a non-local network address, despite showing a LAN-accessible URL. This increases the chance that operators expose a credential intake endpoint to other devices on the network without understanding the risk of interception or unauthorized submission.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The security-focused description is misleading because the implementation accepts unauthenticated POSTs from any reachable host, so the claimed 'secure' and 'fully auditable' handoff can cause users to place undue trust in an unsafe mechanism. In this skill context, that is especially dangerous because the tool is specifically designed to collect secrets, increasing the likelihood that high-value credentials will be exposed, replaced, or intercepted operationally.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.