Back to skill

Security audit

JARVIS UI

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent OpenClaw dashboard, but it exposes powerful local-agent controls with weak network and credential safeguards that users should review before installing.

Install only for trusted local use unless you add your own protection. Do not expose port 9999 directly to a network, avoid enabling allowInsecureAuth for remote access, place any remote deployment behind VPN or authenticated TLS reverse proxy, protect .env and ~/.openclaw/identity files, and treat assistant-rendered content as potentially unsafe until Markdown sanitization and API authentication are fixed.

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

T05 · Unauthorized Access and Privilege Escalation

Error
Location
server/index.js:42
Finding
Unauthenticated Privileged API Exposed on Network Interfaces<![CDATA[ ## Vulnerability Details **File Location**: `server/index.js:42-71, 83-86`; `server/routes/chat.js:27-101`; `server/routes/schedule.js:28-79` **Vulnerability Type**: Missing authentication and authorization on privileged HTTP endpoints **Risk Level**: Critical ### Vulnerable Code ```js // server/index.js:42-71 const app = express(); app.use(express.json()); // Shared session key used by routes app.locals.sessionKey = SESSION_KEY; app.get('/api/events', (req, res) => { res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive', 'Access-Control-Allow-Origin': '*', }); res.write('data: {"type":"connected"}\n\n'); addClient(res); req.on('close', () => removeClient(res)); }); app.use('/api', chatRoutes); app.use('/api', statusRoutes(config, OC_CONFIG)); app.use('/api', ttsRoutes); app.use('/api', tasksRoutes); app.use('/api', skillsRoutes); app.use('/api', memoryRoutes); app.use('/api', scheduleRoutes); app.use('/api', voiceRoutes); // server/index.js:83-86 app.listen(PORT, () => { console.log(`[JARVIS] API server on http://localhost:${PORT}`); if (SERVE_STATIC) console.log(`[JARVIS] Serving static files from dist/`); }); ``` Representative privileged endpoints: ```js // server/routes/chat.js:63-101 router.post('/chat', async (req, res) => { const { message } = req.body; if (!message) return res.status(400).json({ error: 'message required' }); bumpMsgCount(); try { const idempotencyKey = `jarvis-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`; const result = await gwRequest('chat.send', { message, sessionKey: req.app.locals.sessionKey, idempotencyKey, deliver: false, }); res.json({ ok: true, ...result }); } catch (err) { res.status(502).json({ error: err.message || 'gateway error' }); } }); router.get('/history', async (req, res) => { try { const result = await gwRequest('chat.history', { sessionKey: req.app.l ...[truncated 3565 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Bind to loopback by default: ```js const HOST = process.env.HOST || '127.0.0.1'; app.listen(PORT, HOST, () => { /* ... */ }); ``` 2. Require authenticated sessions or a strong API credential on all `/api/*` routes, including `/api/events`. 3. Apply route-specific authorization. Read-only dashboard access must not automatically grant chat, upload, abort, task mutation, or schedule-control privileges. 4. Add CSRF protection for state-changing requests and validate `Origin` and `Host` against an explicit allowlist. 5. Remove wildcard CORS behavior and allow only the intended dashboard origin. 6. Add rate limits, request timeouts, upload quotas, and explicit JSON body-size limits. 7. For remote access, place the service behind TLS and an authenticated reverse proxy or VPN. Do not expose port 9999 directly. 8. Add automated tests proving that unauthenticated users cannot read private data or invoke mutating operations. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
server/gateway.js:13
Finding
Gateway Connection Requests Excessive Administrative Scopes and Persists Operator Credentials<![CDATA[ ## Vulnerability Details **File Location**: `server/gateway.js:13-16, 69-107, 145-169, 267-302, 351-359` **Vulnerability Type**: Excessive privileges and persistent high-value authentication material **Risk Level**: High ### Vulnerable Code ```js // server/gateway.js:13-16 const DEVICE_ROLE = 'operator'; const DEFAULT_SCOPES = ['operator.admin', 'operator.approvals', 'operator.pairing']; ``` ```js // server/gateway.js:69-107 function loadOrCreateDeviceIdentity(filePath = DEVICE_IDENTITY_PATH) { try { if (fs.existsSync(filePath)) { const raw = fs.readFileSync(filePath, 'utf8'); const parsed = JSON.parse(raw); if ( parsed?.version === 1 && typeof parsed.deviceId === 'string' && typeof parsed.publicKeyPem === 'string' && typeof parsed.privateKeyPem === 'string' ) { const derivedId = fingerprintPublicKey(parsed.publicKeyPem); if (derivedId && derivedId !== parsed.deviceId) { const updated = { ...parsed, deviceId: derivedId }; fs.writeFileSync(filePath, `${JSON.stringify(updated, null, 2)}\n`, { mode: 0o600 }); try { fs.chmodSync(filePath, 0o600); } catch {} return { deviceId: derivedId, publicKeyPem: parsed.publicKeyPem, privateKeyPem: parsed.privateKeyPem }; } return { deviceId: parsed.deviceId, publicKeyPem: parsed.publicKeyPem, privateKeyPem: parsed.privateKeyPem }; } } } catch {} const identity = generateIdentity(); ensureDir(filePath); const stored = { version: 1, deviceId: identity.deviceId, publicKeyPem: identity.publicKeyPem, privateKeyPem: identity.privateKeyPem, createdAtMs: Date.now(), }; fs.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}\n`, { mode: 0o600 }); try { fs.chmodSync(filePath, 0o600); } catch {} return identity; } ``` ```js // server/gateway.js:267-302 const role = DEVICE_ROLE; const scopes = [...DEFAULT_SCOPES]; const storedToken = deviceI ...[truncated 2949 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the administrative scope list with the narrowest documented scopes needed for each enabled feature. 2. Do not request `operator.admin`, `operator.approvals`, or `operator.pairing` unless a user explicitly enables a feature that requires each individual scope. 3. Separate read-only dashboard access from chat mutation and schedule administration. 4. Create distinct Gateway identities for read-only and mutating services where supported. 5. Store device tokens and private keys in an operating-system credential store rather than ordinary files. 6. Implement token expiration, rotation, revocation, and a documented credential-removal procedure. 7. Refuse to start if the Gateway grants unexpectedly broader scopes than requested. 8. Log privileged operations with actor identity, source address, action, and outcome without logging credentials. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
src/components/markdown.js:20
Finding
Stored and Remote Cross-Site Scripting in Markdown Rendering<![CDATA[ ## Vulnerability Details **File Location**: `src/components/markdown.js:20-32, 83-86, 121-140`; `src/components/chat.js:238-240, 444-450` **Vulnerability Type**: Unsanitized HTML generation assigned to `innerHTML` **Risk Level**: High ### Vulnerable Code ```js // src/components/markdown.js:20-32 function renderInline(text) { return text .replace(/`([^`]+)`/g, '<code>$1</code>') .replace(/\*\*\*(.+?)\*\*\*/g, '<strong><em>$1</em></strong>') .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>') .replace(/\*(.+?)\*/g, '<em>$1</em>') .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>'); } ``` ```js // src/components/markdown.js:121-140 const headingMatch = line.match(/^(#{1,3})\s+(.+)/); if (headingMatch) { const level = headingMatch[1].length; html.push(`<h${level + 2}>${renderInline(headingMatch[2])}</h${level + 2}>`); continue; } if (line.trim() === '') { continue; } html.push(`<p>${renderInline(line)}</p>`); ``` ```js // src/components/chat.js:238-240 if (msg.role === 'assistant') { msgText.innerHTML = renderMarkdown(msg.text); } else { msgText.textContent = msg.text; } ``` ```js // src/components/chat.js:444-450 if (currentReplyLine) { const msgBody = currentReplyLine.querySelector('.msg-body'); if (msgBody) { const timeEl = msgBody.querySelector('.msg-time'); msgBody.innerHTML = renderMarkdown(replyBuffer); if (timeEl) msgBody.appendChild(timeEl); } } ``` ### Technical Analysis Only fenced code blocks are passed through `escapeHtml`. Ordinary paragraphs, headings, list items, table cells, inline code, link labels, and link targets are inserted into generated markup without escaping or sanitization. The generated string is then assigned directly to `innerHTML`. Consequently, HTML supplied in an assistant response or existing Gateway history is interpreted by the browser instead of being displayed as text. Link targets are also not restricted to safe URL sch ...[truncated 1546 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the custom renderer with a maintained Markdown parser configured to reject or escape raw HTML. 2. Sanitize generated markup with a strict allowlist sanitizer before assigning it to `innerHTML`. 3. Escape source text before applying inline Markdown transformations, including text in headings, lists, tables, inline code, and link labels. 4. Parse and validate every link with `new URL()` and permit only approved schemes such as `https:`, `http:`, and optionally `mailto:`. 5. Reject dangerous schemes and malformed URLs, including `javascript:` and unsafe `data:` URLs. 6. Prefer DOM construction APIs and `textContent` where rich HTML is unnecessary. 7. Deploy a restrictive Content Security Policy that disallows inline script and inline event handlers and limits outbound connections. 8. Add regression tests using event-handler elements, malformed links, raw SVG/HTML, and payloads stored in conversation history. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:19
Finding
Remote Deployment Instructions Recommend Disabling Secure Gateway Authentication<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:19-25`; `setup.sh:81-83` **Vulnerability Type**: Security-weakening deployment guidance **Risk Level**: High ### Vulnerable Code ```md <!-- SKILL.md:19-25 --> > **⚠️ Remote/non-localhost access:** If JARVIS server is accessed from a different machine (not localhost), add this to your `~/.openclaw/openclaw.json`: > ```json > { "gateway": { "controlUi": { "allowInsecureAuth": true } } } > ``` > Then restart OpenClaw Gateway. ``` ```sh # setup.sh:81-83 echo -e "${DIM}⚠️ Remote access? Add to ~/.openclaw/openclaw.json:${NC}" echo -e "${DIM} { \"gateway\": { \"controlUi\": { \"allowInsecureAuth\": true } } }${NC}" ``` ### Technical Analysis The official installation guidance tells remote users to enable a setting explicitly named `allowInsecureAuth`. This weakens the Gateway's authentication posture precisely when the service is being made available beyond localhost. The recommendation is especially dangerous in combination with the backend's lack of API authentication and its unspecified-interface listener. It converts what might otherwise be a local dashboard into a remotely reachable, privileged control surface without introducing TLS, an authenticated reverse proxy, a VPN, or trusted-origin restrictions. ### Attack Path 1. An administrator follows the documented remote-access instructions. 2. The administrator sets `gateway.controlUi.allowInsecureAuth` to `true` and restarts the Gateway. 3. The JARVIS server remains bound without an explicit loopback host and exposes unauthenticated APIs. 4. A network attacker discovers port 9999 or obtains access through routing, port forwarding, or a reverse proxy. 5. The attacker directly reads private endpoints and invokes privileged operations through the dashboard's Gateway connection. ### Impact Assessment The guidance can produce a deployment in which private conversations, telemetry, uploads, task controls, schedule controls, and agent messaging ...[truncated 189 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the recommendation to enable `allowInsecureAuth`. 2. Document loopback-only operation as the secure default. 3. For remote access, require TLS and an authenticated reverse proxy, private VPN, or SSH tunnel. 4. Require a secure browser context and use the Gateway's supported device-authentication flow. 5. Document firewall restrictions, trusted-origin allowlists, and credential rotation. 6. Make remote binding an explicit opt-in that refuses to start unless authentication and TLS-proxy settings are configured. 7. Add a startup warning or hard failure when the server binds to a non-loopback address without application authentication. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
setup.sh:33
Finding
Gateway Token Copied to Plaintext Environment File Without Enforced Permissions<![CDATA[ ## Vulnerability Details **File Location**: `setup.sh:33-47` **Vulnerability Type**: Insecure storage of authentication credentials **Risk Level**: Medium ### Vulnerable Code ```sh # setup.sh:33-47 if [ ! -f ".env" ] || ! grep -q "GATEWAY_TOKEN" .env 2>/dev/null; then echo "" echo "Detecting Gateway token..." OPENCLAW_CONFIG="${HOME}/.openclaw/openclaw.json" TOKEN="" if [ -f "$OPENCLAW_CONFIG" ]; then TOKEN=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$OPENCLAW_CONFIG','utf8')).gateway?.token||'')}catch{}" 2>/dev/null) fi if [ -n "$TOKEN" ]; then echo "GATEWAY_TOKEN=$TOKEN" > .env echo -e "${GREEN}✅ Gateway token auto-detected and saved to .env${NC}" fi fi ``` ### Technical Analysis The setup process reads the Gateway token from OpenClaw's configuration and writes it into a project-local plaintext `.env` file. The write operation relies on the caller's ambient `umask` and does not explicitly enforce mode `0600`. The code also does not validate that `.env` is a regular, non-symlink file before overwriting it. Copying a high-value token into the project directory increases its exposure to local users, backups, support bundles, source-control mistakes, and other tools that recursively process the project. No evidence in the reviewed files establishes that `.env` is excluded from source control. ### Attack Path 1. A user runs `setup.sh`. 2. The script retrieves the Gateway token from `~/.openclaw/openclaw.json`. 3. The token is written to project-local `.env` with permissions determined by the current environment. 4. Another local account, backup process, archive, accidental commit, or project-scanning tool reads the file. 5. The exposed token is used to authenticate to the OpenClaw Gateway, subject to Gateway reachability and token permissions. A symlink placed at `.env` before setup could also redirect the write to another user-writable target, although practical impact depends on filesystem pe ...[truncated 363 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Set `umask 077` before creating any secret-bearing file. 2. Create the file atomically with explicit `0600` permissions, for example with `install -m 600`, and verify ownership afterward. 3. Refuse to write if `.env` is a symbolic link or is not a regular file owned by the current user. 4. Add `.env` to `.gitignore` and document that it must never be committed, archived, or included in support bundles. 5. Prefer an operating-system secret store or read the token directly from its existing protected configuration rather than duplicating it. 6. Provide token rotation and revocation instructions for users who suspect `.env` exposure. 7. Avoid passing secret values through command-line arguments or logs during setup. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (114)

Missing User Warnings

High
Confidence
98% confidence
Finding
The README explicitly instructs users to set `allowInsecureAuth: true` for remote access, which weakens a security control protecting Gateway authentication over insecure contexts. In a dashboard that exposes live chat, tasks, schedules, skills, memory, and system state, disabling secure auth materially increases the chance of credential interception or unauthorized remote control if the UI is exposed beyond localhost.

Credential Access

High
Category
Privilege Escalation
Content
`setup.sh` auto-detects your token from `~/.openclaw/openclaw.json`. If auto-detection fails, set it manually:

```bash
echo "GATEWAY_TOKEN=your_token" > .env
```

Find your token: run `openclaw status` or check `~/.openclaw/openclaw.json` → `gateway.token`.
Confidence
92% confidence
Finding
The README instructs users how to retrieve the Gateway token and place it into `.env`, normalizing direct handling of a privileged credential without sufficient security warning. In the context of an agent dashboard with control and visibility into chat, tasks, schedules, and memory, compromise of this token could enable unauthorized access to sensitive agent data and operations.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Audio upload and server-side transcription introduce meaningful attack surface including file handling, temporary storage, and command execution around local tooling. If these capabilities are not clearly disclosed, operators may expose a media-processing endpoint without understanding associated risks such as sensitive audio capture or abuse of upload functionality.

Missing User Warnings

High
Confidence
98% confidence
Finding
The skill explicitly instructs users to enable `allowInsecureAuth: true` for remote access, which weakens authentication protections for a network-exposed control interface. In the context of a UI that may access gateway, local files, tasks, schedules, and memory, this significantly raises the chance of unauthorized remote access and data or control compromise.

Hidden Instructions

High
Category
Prompt Injection
Content
<link rel="author" href="/humans.txt" />
  <title>JARVIS</title>

  <!-- Favicon -->
  <link rel="icon" type="image/png" href="/icons/icon-192.png" />

  <!-- PWA -->
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
</div>
  -->

  <!-- [DISABLED] SYSTEM MONITOR — 已合併至 SYSTEM STATUS
  <div class="data-panel system-monitor" style="position: absolute; top: 20px; right: 20px;">
    <div class="data-panel-title">
      <span>SYSTEM MONITOR</span>
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
</div>
  -->

  <!-- SYSTEM STATUS(合併 System Monitor + Model Status) -->
  <div class="data-panel system-status" style="position: absolute; top: 20px; left: 20px;">
    <div class="data-panel-title">
      <span>SYSTEM STATUS</span>
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
</div>
  -->

  <!-- SYSTEM STATUS(合併 System Monitor + Model Status) -->
  <div class="data-panel system-status" style="position: absolute; top: 20px; left: 20px;">
    <div class="data-panel-title">
      <span>SYSTEM STATUS</span>
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
</div>

    <div class="status-columns">
      <!-- 左側:系統資源 -->
      <div class="status-col status-col-system">
        <div class="waveform">
          <canvas id="cpu-canvas" class="waveform-canvas"></canvas>
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
</div>

    <div class="status-columns">
      <!-- 左側:系統資源 -->
      <div class="status-col status-col-system">
        <div class="waveform">
          <canvas id="cpu-canvas" class="waveform-canvas"></canvas>
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.