Back to skill

Security audit

Cc Log Viewer

Security checks for vulnerabilities and agentic risk

Overview

This skill exposes a Claude Code terminal over the network with command control and no authentication, while also running Claude with permission checks skipped.

Only run this on a trusted, isolated machine and do not expose it to a LAN, VPN, or the public internet without adding authentication, localhost-only defaults, and removing Claude's permission-bypass flag. Treat everything shown in the terminal as potentially visible to anyone who can reach the port.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (6)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/log-streamer.js:36
Finding

Unauthenticated Remote Control of a Permission-Bypassed Claude Process

Content
View full analysis
body += c); req.on('end', () => { try { const { command } = JSON.parse(body); if (!command) { res.writeHead(400); res.end('{}'); return; } const ok = sendToCC(command); res.writeHead(ok ? 200 : 503, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ sent: ok })); } catch (e) { res.writeHead(400); res.end(JSON.stringify({ error: e.message })); } }); return; } ``` ```javascript ws.on('message', (data) => { const text = data.toString(); if (text === 'ping') { ws.send(JSON.stringify({ type: 'pong' })); } else if (text === 'sync') { const history = getHistory(); if (history) ws.send(JSON.stringify({ type: 'data', data: history })); } else if (text.startsWith('cmd:')) { const cmd = text.slice(4); const ok = sendToCC(cmd); ws.send(JSON.stringify({ type: 'cmd-status', ok })); } }); ``` ```javascript server.listen(PORT, '0.0.0.0', () => { console.log(`Log-Streamer v3 running on http://0.0.0.0:${PORT}`); if (NO_CC) { console.log('--no-cc mode: CC not started. Use POST /api/restart to start later.'); } else { console.log('Starting CC via node-pty...'); startCC(); } }); ``` ### Technical Analysis The service listens on every network interface and does not authenticate or authorize HTTP or WebSocket clients. Bot ...[truncated 1873 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/log-streamer.js:214
Finding

Unauthenticated Disclosure of Terminal History and Live Agent Output

Content
View full analysis
{ console.log(`WS client connected (${wssClients.size + 1} total)`); wssClients.add(ws); const history = getHistory(); if (history) { ws.send(JSON.stringify({ type: 'history', data: history })); } ``` ```javascript setInterval(() => { const data = flushOutput(); if (data) broadcast(JSON.stringify({ type: 'data', data })); }, 100); ``` ### Technical Analysis Every WebSocket client is accepted without credentials. Immediately after connecting, the client receives the retained terminal history. The client is then added to the broadcast set and receives all subsequent terminal output. The server listens on all interfaces, and the WebSocket upgrade handler does not authenticate the requester or validate its Origin. Terminal output can contain prompts, generated source code, filesystem paths, command output, error messages, configuration values, and secrets printed by tools. ### Attack Path 1. An operator starts the service on port 18798. 2. An attacker reaches that port over the local network, VPN, forwarded port, or another available route. 3. The attacker opens a WebSocket connection without providing credentials. 4. The connection handler sends the retained terminal history. 5. The attacker keeps the connection open and receives all live Claude terminal output every 100 milliseconds. ### Impact Assessment The attacker can passively monitor the active agent session and recover up to the configured terminal history plus all future output ...[truncated 243 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
scripts/log-streamer.js:181
Finding

Arbitrary Local File Read Through Static-File Path Traversal

Content
View full analysis
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/log-streamer.js:171
Finding

Unauthenticated Claude Process Restart and Activation

Content
View full analysis
startCC(), 1500); res.writeHead(200); res.end(JSON.stringify({ restarting: true })); return; } ``` ### Technical Analysis The `/api/restart` endpoint performs an administrative process-control operation without authenticating or authorizing the requester. A remote client can repeatedly stop and relaunch Claude. The endpoint also calls `startCC()` regardless of whether the server was initially launched with `--no-cc`. Therefore, a mode intended to start only the web service can subsequently be changed into a mode running Claude through an unauthenticated request. The newly started process uses the same permission-bypassing arguments defined in `startCC()`. ### Attack Path 1. The service becomes reachable on port 18798. 2. An attacker sends an unauthenticated `POST /api/restart`. 3. The server interrupts the active Claude process. 4. After 1.5 seconds, the server starts a new Claude process. 5. The attacker repeats the request to disrupt work, or uses it once to activate Claude when the service was started with `--no-cc`. ### Impact Assessment The attacker can disrupt active tasks, discard transient session state, and repeatedly consume process-startup resources. The attacker can also activate the permission-bypassed Claude process in a deployment that was started in web-only mode. Combined with the unauthenticated command interface, this provides a reliable way to ensure that an attacker-controllable agent process is running. ]]>
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/log-streamer.js:139
Finding

Unbounded Request Body Enables Remote Memory Exhaustion

Content
View full analysis
body += c); req.on('end', () => { try { const { command } = JSON.parse(body); if (!command) { res.writeHead(400); res.end('{}'); return; } const ok = sendToCC(command); res.writeHead(ok ? 200 : 503, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ sent: ok })); } catch (e) { res.writeHead(400); res.end(JSON.stringify({ error: e.message })); } }); return; } ``` ### Technical Analysis The request handler appends every received chunk to an in-memory string and imposes no maximum body size. JSON parsing occurs only after the client finishes transmitting the body. Because the endpoint is unauthenticated and exposed on all network interfaces, a remote client can transmit a very large body or maintain multiple concurrent oversized requests. Memory use grows with the submitted data and may trigger garbage-collection pressure, event-loop degradation, or process termination due to exhaustion. ### Attack Path 1. The attacker connects to the exposed HTTP service. 2. The attacker starts one or more `POST /api/send` requests. 3. Large volumes of request data are transmitted without ending the requests promptly. 4. Each chunk is appended to the in-memory `body` string. 5. Process memory grows until service performance degrades or Node.js terminates because of resource exhaustion. ### Impact Assessment A network-accessible attacker can degrade or terminate the log viewer and its associated Claude session. The direct impact is loss of availability under the privileges of the service process; this issue does not independently provide additional operating-system privileges. ]]>
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
assets/package.json:12
Finding

Unpinned Dependencies and Non-Reproducible Installation

Content
View full analysis
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Rogue AgentSelf-Modification, Session Persistence
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (24)

Context-Inappropriate Capability

Critical
Category
Not specified by scanner
Confidence
100% confidence
Finding

The service launches Claude with --dangerously-skip-permissions, explicitly bypassing safety checks for actions Claude may take. In combination with exposed remote input channels, this creates a high-likelihood path to unauthorized file access, command execution, or destructive actions through the agent, far beyond what a log-viewing tool requires.

Content

No source excerpt is available for this finding.

Missing User Warnings

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

This finding is substantiated by the combination of two design choices in the file: Claude is started with permission bypass, and remote clients can inject commands over HTTP/WebSocket with no confirmation or warning. The skill description frames the feature as remote monitoring, which makes the hidden elevation and control surface more dangerous because users may not expect they are exposing full interactive agent control.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The HTTP endpoints /api/send and /api/restart allow any network client to send arbitrary input to the Claude process or restart it, with no authentication, authorization, or origin checks. In this skill's context, that is especially dangerous because the managed process is an interactive Claude session that may have access to local files, secrets, and system capabilities, so remote users can drive agent behavior or interrupt tasks.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

Any WebSocket client that connects can issue cmd: messages which are forwarded directly to the Claude process without authentication. Because this service also broadcasts terminal output, an attacker can both observe the session and actively steer it, turning a passive log viewer into an unauthenticated remote-control interface.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The README describes command injection into Claude Code, process restart/control, and vault scanning, but provides no warning about system-state changes, remote control risk, or possible disclosure of local data. For a service exposed over HTTP/WebSocket and intended for remote/mobile viewing, missing security warnings can lead users to deploy it unsafely and expose sensitive capabilities to untrusted networks.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The README advertises a knowledge-graph API that scans an Obsidian vault, which materially expands the skill's access to local user data beyond log viewing and process monitoring. In a skill that already exposes browser and API surfaces, undocumented or weakly justified filesystem-scanning behavior increases the risk of unintended data collection or exposure.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The Obsidian vault scanning feature is not aligned with the declared role of a Claude Code log viewer/process monitor, making it an unnecessary privilege expansion. Such scope creep is dangerous because users may install the skill for monitoring purposes without realizing it can enumerate or extract structure from unrelated local notes and documents.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
81% confidence
Finding

The skill declares operational capabilities around process control and log streaming but does not define any explicit tool scope or permission boundaries. In practice this increases the chance that an agent or operator invokes the skill without understanding its access to environment-derived data, terminal output, and command channels, which can expose sensitive information or enable unintended actions.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The skill explicitly exposes Claude Code terminal output over HTTP/WebSocket and provides remote APIs to send commands and restart the process, but the documentation does not prominently warn about authentication, access control, or leakage of secrets shown in the terminal. In the stated remote/mobile and LAN use cases, this can allow unauthorized viewers to observe sensitive output or issue commands if the service is reachable beyond localhost.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The page sets lang="zh-CN", which establishes a specific language/locale for the skill UI. Under the stated policy, forcing a specific locale without user opt-in or documented justification is a natural-language policy violation.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The script unconditionally kills whatever process is listening on the requested port, with no validation, prompt, or ownership check. In this skill's context, the service is intended for remote monitoring and process management, so blindly terminating unrelated services on a chosen port can cause denial of service or disrupt other applications if the port is reused or user-supplied incorrectly.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
65% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · assets/start-all.sh (reported line 17)May include surrounding context.

sh
kill $(lsof -t -i:$PORT) 2>/dev/null || true

cd "$(dirname "$0")"
nohup node log-streamer.js --port=$PORT $NO_CC > /tmp/log-streamer.log 2>&1 &

sleep 2

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

On connection, the service sends buffered terminal history to any WebSocket client, exposing prior Claude output without authentication or privacy controls. Terminal output can contain prompts, filesystem paths, secrets, tokens, and task data, so this is an information disclosure issue, especially in a remote/mobile monitoring scenario.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
96% confidence
Finding

The user-facing README content is entirely in Chinese, with no indication that language is selectable or that the skill is intentionally region-specific. The policy calls for flagging language or locale constraints when a specific language is imposed without user opt-in or justification.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
92% confidence
Finding

The skill documentation is entirely in Chinese and does not indicate that the skill is intended only for Chinese-speaking users or provide an alternative language option. This can violate language/locale policy when users are not given a choice or clear justification for the locale restriction.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
90% confidence
Finding

This markdown file instructs users to run bash start-all.sh and notes that it includes the CC process, which affects the local system by launching processes and likely opening a local service. The description does not include any user-facing warning about this behavior or what system changes to expect.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
96% confidence
Finding

The dependency uses a caret range instead of an exact version, which makes builds non-reproducible and can pull in different transitive code over time. In a security-sensitive skill that exposes terminal output and process control, drifting dependency resolution increases supply-chain risk and makes it harder to verify whether known fixes or vulnerabilities are present.

Content

Scanner excerpt · assets/package.json (reported line 13)May include surrounding context.

json
"author": "",
  "license": "ISC",
  "dependencies": {
    "node-pty": "^1.1.0",
    "ws": "^8.21.0",
    "xterm": "^5.3.0",
    "xterm-addon-fit": "^0.8.0"

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
98% confidence
Finding

The ws package is specified with a caret range, so the installed version may vary across environments and time. Because this skill explicitly uses WebSockets to stream terminal data to browsers, lack of strict version pinning materially increases exposure to dependency regressions or known ws flaws affecting confidentiality or availability.

Content

Scanner excerpt · assets/package.json (reported line 14)May include surrounding context.

json
"license": "ISC",
  "dependencies": {
    "node-pty": "^1.1.0",
    "ws": "^8.21.0",
    "xterm": "^5.3.0",
    "xterm-addon-fit": "^0.8.0"
  }

Unverifiable Dependency: ws has 7 known advisory(ies) (CVE-2016-10518 (Remote Memory Disclosure in ws); CVE-2024-37890 (ws affected by a DoS when handling a request with many HTTP headers); CVE-2026-45736 (ws: Uninitialized memory disclosure) +4 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
95% confidence
Finding

The manifest does not pin ws, and ws has multiple known advisories across versions, so the security posture of the actual installed package cannot be verified from this file alone. In this skill, ws is central to exposing terminal output over the network, so uncertainty around the exact version is more dangerous than in a non-networked utility and could affect confidentiality or availability.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
90% confidence
Finding

Using a non-exact version for xterm permits version drift and reduces build reproducibility. Since this package renders remote terminal output in a browser, unpredictable dependency updates can introduce client-side security issues or reintroduce previously fixed bugs.

Content

Scanner excerpt · assets/package.json (reported line 15)May include surrounding context.

json
"dependencies": {
    "node-pty": "^1.1.0",
    "ws": "^8.21.0",
    "xterm": "^5.3.0",
    "xterm-addon-fit": "^0.8.0"
  }
}

Unverifiable Dependency: xterm has 1 known advisory(ies) (CVE-2019-0542 (xterm vulnerable to remote code execution )), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
83% confidence
Finding

The xterm dependency has a known advisory history, but the version is not pinned, so it is impossible to determine from the manifest whether a safe or vulnerable release will be installed. Because this skill displays terminal data in a browser, a client-side issue in xterm could impact connected viewers and potentially elevate the risk beyond a purely cosmetic frontend bug.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
87% confidence
Finding

The xterm-addon-fit dependency is not pinned exactly, creating the same supply-chain and reproducibility problem as the other frontend dependencies. While the addon itself is less inherently sensitive, it still becomes part of the browser-facing attack surface and should be controlled deterministically.

Content

Scanner excerpt · assets/package.json (reported line 16)May include surrounding context.

json
"node-pty": "^1.1.0",
    "ws": "^8.21.0",
    "xterm": "^5.3.0",
    "xterm-addon-fit": "^0.8.0"
  }
}

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
95% confidence
Finding

The script's comments and echoed status messages are written in Chinese throughout, forcing a specific language for user-visible interaction. The policy requires avoiding fixed language/locale behavior unless the user is given a choice or the locale limitation is explicitly justified.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
84% confidence
Finding

The file's descriptive comments and several user-visible status messages are written only in Chinese, which imposes a specific language/locale without offering an alternative or opt-in. Under the policy, forcing a language is a natural-language violation unless choice or justification is provided.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.