Back to skill

Security audit

xiaobai-print

Security checks for vulnerabilities and agentic risk

Overview

The skill is a real printing integration, but it gives a local bridge and upload path broad authority over files, bearer tokens, and remote MCP tools without enough containment.

Review this before installing. Use only a dedicated low-privilege token, keep the bridge bound to 127.0.0.1, do not expose it on a network, and upload only files you explicitly intend to print. Treat generated skills as untrusted until reviewed, and prefer adding allowlists for tool names, upload paths, upload destinations, and bridge origins.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • 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
  • 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 (4)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
src/bridge/http.ts:146
Finding
Unauthenticated bridge clients inherit the privileged upstream credential<![CDATA[ ## Vulnerability Details **File Location**: `src/bridge/http.ts:146-152` **Vulnerability Type**: Missing client authentication and credential-boundary violation **Risk Level**: High ### Vulnerable Code ```ts function getRemoteConfig(req: http.IncomingMessage, options: BridgeCliOptions): RemoteConfig { const resolved = resolveConfig({ remoteUrl: options.remoteUrl, }); return { token: extractBearerToken(req) ?? resolved.token, remoteUrl: resolved.remoteUrl, }; } ``` The resulting configuration is used by both discovery and invocation endpoints: ```ts if (req.method === "GET" && url.pathname === "/mcp/tools") { const tools = await listExposedTools(getRemoteConfig(req, options)); writeJson(res, 200, { tools }); return; } if (req.method === "POST" && url.pathname.startsWith("/mcp/tools/")) { const toolName = decodeURIComponent(url.pathname.slice("/mcp/tools/".length)); // ... await handleToolInvocation(req, res, toolName, options); return; } ``` ### Technical Analysis The bridge treats a missing client `Authorization` header as permission to use the process-wide upstream token from `MY_MCP_TOKEN` or `OPENCLAW_TOKEN`. This conflates two distinct trust boundaries: 1. Authentication between a client and the local bridge. 2. Authentication between the bridge and the upstream MCP service. The upstream credential should not implicitly authenticate arbitrary bridge clients. Although the default listener is `127.0.0.1`, the CLI supports an arbitrary `--host` value. Local untrusted processes can also reach a loopback listener. No independent authentication or tool-level authorization is enforced before remote tools are listed or invoked. ### Attack Path 1. The operator starts the bridge with a valid upstream token. 2. The bridge is reachable by an untrusted local process or is bound to a network-accessible interface using `--host`. 3. The attacker sends `GET /mcp/tools` without an `Authorization` header. 4. `getRemoteCon ...[truncated 696 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Require independent client authentication for every endpoint except, if necessary, `/health`. - Never use the upstream MCP token as a fallback client credential. - Return `401 Unauthorized` when client authentication is absent or invalid. - Use a separate bridge-access token or authenticated local IPC mechanism. - Add per-client and per-tool authorization so callers receive only the tools required for their task. - Refuse non-loopback binding by default. Require an explicit unsafe-network acknowledgement and configured authentication before accepting `--host 0.0.0.0` or another non-loopback address. - Add rate limiting, request-size limits, and security logging for failed authentication and tool invocation. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
src/core/upload-file.ts:39
Finding
Arbitrary local files can be uploaded to a destination controlled by the upstream service<![CDATA[ ## Vulnerability Details **File Location**: `src/core/upload-file.ts:39-82` **Vulnerability Type**: Unrestricted local file read combined with unvalidated outbound upload **Risk Level**: High ### Vulnerable Code ```ts export async function uploadLocalFile( filePath: string, fileName?: string, config?: RemoteConfig, ) { const effectiveName = fileName ?? basename(filePath); const fileData = await readFile(filePath); log(`Read local file: ${filePath} (${fileData.byteLength} bytes)`); const suffix = extname(effectiveName); const tokenArgs = suffix ? { fileName: effectiveName, suffix } : { fileName: effectiveName }; const tokenResult = await callRemoteTool("getCosUploadToken", tokenArgs, config); const tokenText = extractText(tokenResult.content as Array<{ type: string; [key: string]: unknown }>); if (!tokenText) { throw new Error("getCosUploadToken returned no text content"); } const storage = JSON.parse(tokenText) as StorageTokenResult; const blob = new Blob([fileData]); const formData = new FormData(); let uploadUrl: string; let cdnUrl: string; if (storage.storagePlatform === "TENCENT_COS") { const token = storage.token as CosToken; formData.append("file", blob, effectiveName); uploadUrl = token.uploadUrl; cdnUrl = `${token.cdn}/${token.key}`; } else { const token = storage.token as ObsToken; formData.append("key", token.key); formData.append("AccessKeyId", token.accessid); formData.append("policy", token.policy); formData.append("signature", token.signature); formData.append("success_action_status", "200"); formData.append("file", blob, effectiveName); uploadUrl = token.host; cdnUrl = `${token.cdn}/${token.key}`; } log(`Uploading to: ${uploadUrl.substring(0, 80)}...`); const response = await fetch(uploadUrl, { method: "POST", body: formData }); ``` The exposed tool accepts a caller-controlled path: ```ts if (name === "uploadFile") { cons ...[truncated 2165 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Restrict uploads to files explicitly selected or supplied by the user for the current print request. - Maintain a narrow allowlist of approved upload roots and verify the canonical path using `realpath()` before reading. - Reject paths that escape approved roots, including through symbolic links. - Require confirmation that displays the canonical path, file size, and destination before uploading. - Enforce conservative file-size and supported-format limits before loading file contents. - Stream permitted files instead of loading the entire file into memory. - Validate remote storage metadata against a strict runtime schema. - Permit only HTTPS upload URLs. - Allowlist the expected COS/OBS storage hostnames and reject IP literals, loopback destinations, private-network destinations, unexpected ports, embedded credentials, and redirects to unapproved origins. - Keep the upload capability isolated from generic remote tool forwarding and apply dedicated authorization to it. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
src/generator/generate.ts:130
Finding
Bearer credentials can be transmitted to an arbitrary or plaintext bridge endpoint<![CDATA[ ## Vulnerability Details **File Location**: `src/generator/cli.ts:149-155`, `src/generator/generate.ts:130-138` **Vulnerability Type**: Unrestricted credential forwarding **Risk Level**: High ### Vulnerable Code The generator automatically obtains a bearer token from the environment when an explicit token is not supplied: ```ts const bundle = await writeOpenClawSkills({ bridgeBaseUrl: options.bridgeBaseUrl, outputDir: options.outputDir, token: options.token ?? process.env.MY_MCP_TOKEN ?? process.env.OPENCLAW_TOKEN, splitBy: options.splitBy ?? "none", skillName: options.skillName, homepage: options.homepage, }); ``` It then attaches the token to the caller-controlled bridge URL: ```ts async function fetchBridgeTools(resolvedUrls: ResolvedBridgeUrls, token?: string): Promise<McpToolDefinition[]> { const headers = new Headers({ Accept: "application/json" }); if (token) { headers.set("Authorization", `Bearer ${token}`); } const payload = await fetchJson(resolvedUrls.toolCatalogUrl, { method: "GET", headers, }); ``` Generated and checked-in invocation wrappers have the same trust issue when `MY_MCP_BASE_URL` is overridden: ```js const token = process.env.MY_MCP_TOKEN; if (!token) { console.error("Missing MY_MCP_TOKEN"); process.exit(2); } const baseUrl = normalizeBaseUrl(process.env.MY_MCP_BASE_URL || DEFAULT_BASE_URL); const response = await fetch(`${baseUrl}/mcp/tools/${encodeURIComponent(toolName)}`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${token}`, }, body: JSON.stringify({ arguments: args }), }); ``` ### Technical Analysis The generator accepts an arbitrary `--bridge-url` and does not constrain its protocol, hostname, port, or trust relationship. It automatically reuses `MY_MCP_TOKEN` or `OPENCLAW_TOKEN` and sends that credential to the selected endpoint. Consequently, a crafted command, configuration error, typo, or untrusted endpoint can ...[truncated 1367 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Do not automatically reuse `MY_MCP_TOKEN` or `OPENCLAW_TOKEN` for an arbitrary command-line URL. - Require explicit credential consent, such as an explicit `--token` option, for each destination. - Permit plaintext HTTP only for verified loopback addresses such as `127.0.0.1` and `::1`. - Require HTTPS for every non-loopback bridge endpoint. - Add a configurable allowlist of trusted bridge origins and compare normalized origins before attaching credentials. - Warn the user and require confirmation before sending a credential to a new origin. - Reject URLs containing embedded credentials or unexpected protocols. - Disable redirects for authenticated requests or validate every redirect destination and strip credentials whenever the origin changes. - Apply the same origin validation to `MY_MCP_BASE_URL` in checked-in and generated invocation scripts. - Use a separate, least-privileged bridge credential rather than forwarding the upstream MCP credential to the bridge client interface. ]]>

T01 · Skill Instruction Hijacking

Error
Location
src/generator/render.ts:112
Finding
Untrusted MCP metadata is embedded into persistent skill instructions without sanitization<![CDATA[ ## Vulnerability Details **File Location**: `src/generator/generate.ts:104-120`, `src/generator/render.ts:112-128` **Vulnerability Type**: Generated skill instruction injection **Risk Level**: High ### Vulnerable Code Remote tool names and descriptions are accepted with only basic type and empty-string checks: ```ts function normalizeTool(tool: unknown, index: number): McpToolDefinition { if (!isObject(tool)) { throw new Error(`Tool at index ${index} is not an object.`); } if (typeof tool.name !== "string" || tool.name.trim() === "") { throw new Error(`Tool at index ${index} is missing a valid name.`); } return { name: tool.name.trim(), description: typeof tool.description === "string" && tool.description.trim() !== "" ? tool.description.trim() : `MCP tool ${tool.name.trim()}.`, inputSchema: normalizeSchema(tool.inputSchema), }; } ``` Those values are then inserted directly into Markdown instructions: ```ts function renderToolSection(tool: McpToolDefinition): string { return [ `### ${tool.name}`, tool.description || "No description provided.", "", "Arguments:", renderArgumentLines(tool), "", ].join("\n"); } ``` The rendered sections become part of the generated `SKILL.md`: ```ts "## Available tools", "", ...input.tools.map((tool) => renderToolSection(tool)), "## How to invoke", ``` ### Technical Analysis The bridge response is remote-controlled data, but the generator places tool names, descriptions, argument names, and argument descriptions into the skill's instruction document as executable agent context. No Markdown escaping, structural delimiter, content policy, or human approval step distinguishes remote metadata from trusted instructions. A malicious tool description can include new headings, fabricated workflow requirements, requests to disclose information, advertising, or text instructing the agent to ignore prior constraints. Because the generated co ...[truncated 1274 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Treat every MCP-provided name, description, and schema annotation as untrusted data. - Restrict tool names to a conservative character set and maximum length. - Escape Markdown metacharacters before inserting remote values into `SKILL.md`. - Render descriptions inside clearly delimited quoted or code-formatted data blocks rather than as free-standing instructions. - Remove or flag content containing headings, frontmatter delimiters, links, HTML, role-like directives, or instruction-override phrases. - Generate the executable skill instructions from a fixed trusted template and keep remote descriptions in a separate non-instructional schema file. - Require human review and explicit approval before installing or enabling generated skills. - Record the bridge origin and a digest of the retrieved tool catalog so metadata changes can be detected. - Consider a strict maximum length and schema validation for all remotely supplied text fields. ]]>
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
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (41)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The declared description is specifically about a printing helper for local MCP bridge operations related to printers. The code shown is instead a general-purpose MCP tool invoker: it parses a tool name and JSON arguments from the command line, reads authentication and base URL from environment variables, and forwards the request to an MCP tools endpoint. While this could potentially be used to call printer-related tools, the code itself is not limited to or centered on printing workflows, and it introduces undeclared authenticated access to arbitrary MCP tools. That makes the actual behavior materially broader and different from the declared purpose.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The declared description says this skill is a 'printing assistant' for interacting with a local MCP bridge to manage printer-related operations such as device inspection, capability checks, file upload, and task creation. The provided code chunk does something materially different: it is a CLI entrypoint for generating OpenClaw skill packages from a bridge URL and writing them to disk. It parses command-line options like --bridge-url, --out, --split-by, --skill-name, and --homepage, optionally uses a bearer token from CLI/env for bridge tool fetching, and logs generation results. There is no evidence in this chunk of printer/device operations, upload of print files, or print job lifecycle management. This is a primary-purpose mismatch, not just an implementation detail difference.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
声明描述的是一个面向打印场景的运行时助手,负责通过本地 MCP bridge 执行打印相关操作(设备检查、能力确认、上传文件、创建任务、查询状态)。但这段代码并没有调用任何具体打印工具,也没有实现这些业务流程。相反,它的核心功能是访问 bridge 的工具目录接口,收集可用工具定义,并自动生成 OpenClaw skill 包文件。其主要目的属于“代码/技能包生成器”而非“打印助手”。虽然代码确实涉及本地 MCP bridge 和 wrapper 生成,但这是用于生成技能封装,而不是实际执行声明中的打印任务,因此属于实质性描述与行为不一致。

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The declared description presents the skill as a printer helper whose purpose is to carry out concrete printing-related operations through a local MCP bridge. The supplied code does not implement those printer operations. Instead, it renders metadata/markdown describing tools, summarizes JSON schemas, writes tool schema JSON files, and generates a generic invoke.js script that can call any MCP tool by name against a configured bridge URL with a token. While this supports a wrapper-based bridge integration at a meta level, the primary behavior of this code chunk is code/document generation and generic tool invocation scaffolding, not the actual printer assistant workflow described. Therefore the description does not accurately represent what this code chunk actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description says the skill is a printer helper that interacts with a local MCP bridge to execute operational printing tasks. However, the supplied code chunk is purely declarative type/interface definitions for a generator system. It models schemas, tool definitions, URLs, and generated skill artifacts, but does not implement any runtime behavior related to printers or MCP bridge operations. This is a material description-behavior mismatch because the actual code’s purpose is infrastructure/type modeling rather than the declared end-user printing workflow.

Lp1

High
Category
MCP Least Privilege
Confidence
97% confidence
Finding
The script performs authenticated network requests to a configurable base URL using a bearer token, but the capability is not covered by declared permissions. Undeclared network access is security-relevant because it allows the skill to contact services outside its stated trust boundary and, if misconfigured, could send privileged requests or data to an attacker-controlled endpoint.

Lp1

High
Category
MCP Least Privilege
Confidence
97% confidence
Finding
The script performs authenticated network requests to a configurable base URL using a bearer token, but the capability is not covered by declared permissions. Undeclared network access is security-relevant because it allows the skill to contact services outside its stated trust boundary and, if misconfigured, could send privileged requests or data to an attacker-controlled endpoint.

Known Vulnerable Dependency: fast-uri==3.1.0 — 7 advisory(ies): CVE-2026-13676 (fast-uri vulnerable to host confusion via failed IDN canonicalization); CVE-2026-18446 (fast-uri vulnerable to host confusion via backslash authority introducer); CVE-2026-75975 (fast-uri vulnerable to server-side request forgery via malformed IPv6 normalizat) +4 more

High
Category
Supply Chain
Confidence
88% confidence
Finding
fast-uri 3.1.0 is reported with multiple URI parsing issues including host confusion and possible SSRF-adjacent parsing flaws. In a skill that uploads files and talks to a local bridge, incorrect URI canonicalization could become dangerous if any user-controlled endpoint, callback URL, or upstream address is ever parsed or validated using this library through the MCP SDK stack.

Known Vulnerable Dependency: hono==4.12.7 — 16 advisory(ies): CVE-2026-56762 (Hono missing validation of cookie name on write path in setCookie()); CVE-2026-47676 (Hono: app.mount() strips mount prefix using undecoded path, causing incorrect ro); CVE-2026-47675 (Hono: Cookie helper does not sanitize sameSite and priority, allowing Set-Cookie) +13 more

High
Category
Supply Chain
Confidence
93% confidence
Finding
hono 4.12.7 is associated with numerous advisories affecting routing, cookie handling, and path processing. Because this skill includes an HTTP bridge binary and likely relies on web request handling through the MCP SDK stack, framework-level flaws can materially affect request isolation, route matching, cookie safety, or path security if the bridge is exposed beyond a tightly controlled local context.

Known Vulnerable Dependency: ip-address==10.1.0 — 2 advisory(ies): CVE-2026-69192 (ip-address: Address4 decodes leading-zero octets as decimal while resolvers deco); CVE-2026-42338 (ip-address has XSS in Address6 HTML-emitting methods)

High
Category
Supply Chain
Confidence
80% confidence
Finding
ip-address 10.1.0 is flagged for address parsing inconsistencies and an XSS issue in HTML-emitting methods. In this lockfile-only context, the package is a transitive dependency of rate limiting and there is no evidence the HTML-emitting methods are used, so practical exploitability is likely limited; however, parser inconsistencies can still matter if IP-based trust or filtering decisions are made by the bridge stack.

Known Vulnerable Dependency: path-to-regexp==8.3.0 — 2 advisory(ies): CVE-2026-4923 (path-to-regexp vulnerable to Regular Expression Denial of Service via multiple w); CVE-2026-4926 (path-to-regexp vulnerable to Denial of Service via sequential optional groups)

High
Category
Supply Chain
Confidence
90% confidence
Finding
path-to-regexp 8.3.0 is reported as vulnerable to ReDoS/DoS via crafted route patterns or pathological matching scenarios. Since this skill ships an HTTP bridge path stack through Express/Router/Hono-related dependencies, an exposed service using attacker-reachable route matching could suffer request amplification or CPU exhaustion.

Missing User Warnings

Medium
Confidence
84% confidence
Finding
This markdown file describes sending `Authorization: Bearer <token>` requests and falling back to environment-stored tokens, which affects user credentials and privacy. The README explains how to configure the token but does not warn users that the bridge will transmit authentication credentials to a remote MCP service or that they should protect these secrets.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The skill instructs the agent to upload local files to a CDN and then submit them to a printing service, but it does not require an explicit consent or privacy warning before transmitting potentially sensitive local documents. In a printing context this is materially risky because users may assume the assistant operates locally, while the workflow actually sends document contents to remote infrastructure and possibly exposes filenames and metadata as well.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The file claims to belong to a printing assistant skill, but the embedded metadata instead describes a different skill, `search-docs-skill`, with a document-search tool exposed through a localhost MCP bridge. This mismatch can cause incorrect routing or activation of capabilities, making it easier for an agent to invoke unintended local tools under false context and weakening trust boundaries around sensitive local bridge access.

Vague Triggers

Medium
Confidence
89% confidence
Finding
The activation text, 'Use this skill when the user needs capabilities exposed by the local MCP bridge,' is overly broad and effectively delegates arbitrary local bridge capabilities whenever a request might fit. In the context of localhost bridge access, broad matching increases the chance of unintended tool invocation, privilege overreach, or prompt-routing mistakes that expose local resources beyond the user’s actual intent.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The script exposes arbitrary remote tool invocation by taking user-controlled `toolName` and JSON arguments, then forwarding them with authentication to the MCP bridge. In the context of a printer assistant, this is more dangerous because the implementation grants a generalized privileged proxy capability unrelated to the narrow advertised purpose, increasing the risk of misuse, privilege expansion, and unauthorized actions on other tools.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
The code posts to a generic `/mcp/tools/{toolName}` endpoint and accepts the tool name from the command line, which permits invoking any exposed MCP tool rather than a printer-specific operation. This broad dispatch conflicts with the stated printer-assistant purpose and expands the reachable attack surface if the wrapper or caller can supply arbitrary tool names.

Description-Behavior Mismatch

Medium
Confidence
93% confidence
Finding
The skill manifest says this skill is a print helper that uses a local MCP bridge for device checks, capability confirmation, file upload, task creation, and short status checks. In package metadata, the description and exposed binaries add an 'OpenClaw skill generator' capability, which is a distinct function not reflected in the stated print-focused purpose.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill instructs the agent to upload local files and then use the returned CDN URL for printing, but it does not require explicit user notice or consent that the file will leave the local environment and be transmitted to an external bridge/CDN. This creates a real data-handling risk because users may reasonably believe they are printing locally while sensitive documents are actually being exfiltrated to third-party infrastructure.

Natural-Language Policy Violations

Medium
Confidence
98% confidence
Finding
The manifest’s natural-language descriptions are entirely in Chinese and present the skill as operating in that language, but there is no indication that users may choose another language or that the locale restriction is required for a region-specific purpose. That can violate a language/locale policy requiring user choice or documented justification.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The uploadFile tool accepts an absolute local file path and returns an uploaded CDN URL, creating a direct path for exfiltrating arbitrary local files if an agent is induced to call it on sensitive paths. Because the schema does not constrain allowed directories, file types, or user-confirmation conditions, the local MCP bridge becomes a capability for reading and exporting host files beyond the user's likely intent.

Description-Behavior Mismatch

Medium
Confidence
93% confidence
Finding
The manifest description limits the skill to device check, capability confirmation, file upload, task creation, and short status confirmation. The declared tool set also exposes `orderCancel`, which adds a distinct destructive control path not mentioned in the stated workflow.

Context-Inappropriate Capability

Medium
Confidence
82% confidence
Finding
The manifest describes a printer helper that uses an in-repo wrapper to call a local MCP bridge for device checks, uploads, task creation, and brief status confirmation. This config code also sources credentials and remote endpoint configuration from process environment variables, introducing secret access and dynamic remote targeting capabilities that are not stated in the skill description.

Missing User Warnings

Medium
Confidence
84% confidence
Finding
This code uploads a local file via `uploadLocalFile` and invokes remote tools via `callRemoteTool`, both of which can transmit user or system data off-host. In this file there is no confirmation prompt, user-facing log/print, or explanatory comment/docstring disclosing these network-affecting actions.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
The skill metadata says it uses a local wrapper/bridge, but this code directly opens an HTTP connection to a remote MCP server and authenticates with a bearer token. That is a material trust-boundary change: data, tool calls, and credentials leave the local environment, which increases exfiltration and remote-command risk, especially because the skill’s stated purpose is a local printing helper.

Static analysis

Detected: suspicious.env_credential_access, suspicious.exposed_secret_literal, suspicious.install_untrusted_source

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
examples/search-docs-skill/scripts/invoke.js:31

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
skills/xiaobai-print/scripts/invoke.js:31

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
src/generator/render.ts:221

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
src/bridge/http.ts:107

Install source points to URL shortener or raw IP.

Warn
Code
suspicious.install_untrusted_source
Location
skills/xiaobai-print/schema/tools.json:6