Back to skill

Security audit

Screen Monitor

Security checks for vulnerabilities and agentic risk

Overview

This screen-sharing skill is purpose-aligned, but it exposes and stores sensitive screen frames with weak access controls and incomplete disclosure.

Review before installing. Only use this on trusted networks and with non-sensitive screens unless the skill is changed to bind locally or require authentication, limit uploads, clearly disclose capture cadence and retention, remove or confirm OS screenshot fallback, and clean up protected per-session frame files.

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

T05 · Unauthorized Access and Privilege Escalation

Error
Location
references/backend-endpoint.js:10
Finding

Unauthenticated Network-Accessible Screen Frame Injection

Content
View full analysis
{ body += chunk; }); req.on('end', () => { try { const { frame, timestamp, width, height } = JSON.parse(body); const buffer = Buffer.from(frame, 'base64'); fs.writeFileSync(FRAME_PATH, buffer); fs.writeFileSync(META_PATH, JSON.stringify({ timestamp, width, height, active: true, updated: new Date().toISOString() })); res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ status: 'ok' })); } catch (err) { res.writeHead(400); res.end(JSON.stringify({ error: err.message })); } }); return; } ``` ```javascript server.listen(PORT, () => { console.log('Screen share server: http://localhost:' + PORT + '/screen-share'); }); ``` ### Technical Analysis The screen-frame upload endpoint has no authentication or session authorization. Any client able to reach TCP port 18795 can submit arbitrary Base64 data and replace the frame used by the analysis workflow. Calling `server.listen(PORT)` without specifying a hostname normally binds Node.js to an unspecified address, potentially exposing the service through available network interfaces rather than limiting it to loopback. The log message claims a localhost URL but does not enforce a localhost-only binding. The wildcard `Access-Control-Allow-Origin: *` ...[truncated 2044 chars]
Remediation
View remediation
{ console.log(`Screen share server: http://127.0.0.1:${PORT}/screen-share`); }); ``` 2. Generate a cryptographically random, per-session token and require it for both the portal and frame-upload endpoint. 3. Reject uploads when the token is missing, expired, or does not belong to the active sharing session. 4. Replace wildcard CORS with an exact allowlist. If the portal is served from the same origin, omit CORS entirely. 5. Validate the `Origin` header as defense in depth, while not treating it as the sole authentication mechanism. 6. End the authenticated session when screen sharing stops and delete the corresponding stored frame. 7. Clearly document any intentional non-loopback exposure and recommend host firewall restrictions. 8. Treat screen images as untrusted Agent input and prevent visual content from overriding system or developer instructions. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
references/backend-endpoint.js:34
Finding

Unbounded Request Buffering Enables Memory and Disk Resource Exhaustion

Content
View full analysis
{ body += chunk; }); req.on('end', () => { try { const { frame, timestamp, width, height } = JSON.parse(body); const buffer = Buffer.from(frame, 'base64'); fs.writeFileSync(FRAME_PATH, buffer); fs.writeFileSync(META_PATH, JSON.stringify({ timestamp, width, height, active: true, updated: new Date().toISOString() })); res.writeHead(200, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ status: 'ok' })); } catch (err) { res.writeHead(400); res.end(JSON.stringify({ error: err.message })); } }); return; } ``` ### Technical Analysis The endpoint appends every received chunk to a JavaScript string without enforcing a maximum request size. The full request is retained in memory, parsed as JSON, converted from Base64 into another allocation, and then written synchronously. A large request can therefore require multiple simultaneous memory representations: - The accumulated request string. - The parsed JSON string value. - The decoded binary buffer. - Internal temporary allocations used by JSON and Base64 processing. The synchronous `writeFileSync` operations block Node.js's event loop. Repeated requests can consume memory, occupy disk space through oversized frame writes, and prevent the single-process HTTP server from serving legitimate clients. Authentication is absent, making the condition remotely triggerable wherever the port is reachable. ### Attack Path 1. The attacker establishes a connection to port 18795. 2. The attacker sends a ...[truncated 1217 chars]
Remediation
View remediation
{ received += chunk.length; if (received > MAX_BODY_BYTES) { res.writeHead(413); res.end('Payload Too Large'); req.destroy(); return; } body += chunk; }); ``` 4. Validate that `frame` is a string and place strict limits on its encoded and decoded lengths. 5. Decode and inspect the actual image format rather than trusting supplied `width` and `height` metadata. 6. Enforce maximum pixel dimensions to prevent decompression-bomb-style image processing downstream. 7. Replace synchronous file operations with asynchronous writes. 8. Add request timeouts, per-client rate limits, concurrency limits, and authentication. 9. Monitor disk usage and remove stale files when a session ends. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/backend-endpoint.js:5
Finding

Predictable Shared Temporary Files Permit Local Frame Poisoning and Symlink Attacks

Content
View full analysis
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • 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 (7)

Tp4

High
Category
MCP Tool Poisoning
Confidence
89% confidence
Finding

The documented behavior understates sensitive functionality: the skill describes screen sharing/analysis, but the associated behavior includes a local network endpoint and persistence of screen frames/metadata that are not disclosed in the description. This mismatch is dangerous because reviewers and users may consent to visual assistance without realizing screen contents may be stored locally or exposed through a backend service.

Content

No source excerpt is available for this finding.

Missing User Warnings

High
Category
Not specified by scanner
Confidence
97% confidence
Finding

The page captures the user's screen and automatically uploads full-resolution frames to the backend every 3 seconds, but the UI only says the agent can analyze the screen and does not clearly disclose the ongoing server-side transmission or its frequency. Because screen content often contains sensitive material such as credentials, messages, internal documents, or other applications, this creates a meaningful privacy and data-exposure risk even though the initial screen-share permission is user-granted.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The README promotes browser-based screen sharing and vision analysis by a multimodal LLM without warning that sensitive on-screen data may be exposed to the local sharing service, browser session, or external model provider. Users may unknowingly share credentials, personal data, internal documents, or regulated information, making this a real privacy and security documentation gap.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding

The skill invokes shell commands to launch helper scripts but does not declare any tool scope such as permissions or allowed-tools. That omission weakens reviewability and containment because an agent may be able to execute local code paths without the user being clearly warned about the required shell capability.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill enables screen sharing, screenshot capture, browser clicking, and typing, yet it provides no explicit privacy or system-impact warning. These capabilities can expose secrets on screen, transmit sensitive data, and perform actions in authenticated browser sessions, so omission of a prominent warning materially increases the risk of unsafe use.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The endpoint accepts unauthenticated screen-frame uploads from any origin and writes both the image and metadata to predictable files in /tmp, creating a covert local screen-capture sink with no access control, consent check, or user disclosure. In the context of a screen-monitoring skill, this is especially dangerous because sensitive on-screen data may be captured and persisted where other local processes or users could access it.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

When no WebRTC portal frame is present, the script silently falls back to taking a full OS-level screenshot of the user's desktop. This expands the skill's effective access from an expected shared-frame analysis workflow into capture of unrelated local content, which can expose sensitive information such as messages, credentials, documents, or other applications visible on screen.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.