T03 · Remote Payload Retrieval and Execution
- Location
scripts/webbridge-crawl.ts:74- Finding
Automatic Execution of an Unverified Remote Installer
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is a real Xiaohongshu scraping and reporting tool, but it combines logged-in browser automation, unverified remote installer execution, plaintext credential storage, external uploads, and silent sibling-project credential reuse.
Review before installing. Use only an isolated browser profile and non-critical Xiaohongshu account, avoid running the remote installer pipeline unless you independently trust and verify it, do not sync sensitive or private scraped data, and remove or fix the sibling credential fallback and plaintext secret storage before using Howtone/Zion sync.
scripts/webbridge-crawl.ts:74Automatic Execution of an Unverified Remote Installer
scripts/generate-report.ts:225Stored Cross-Site Scripting in Generated HTML Reports
scripts/sync.ts:37Arbitrary URL Fetching Followed by Public Re-Upload
scripts/sync.ts:141Silent Reuse of Administrative Credentials from a Sibling Project
scripts/zion-login.ts:57Browser Cookies and Administrative Tokens Stored in Plaintext
The skill description omits that it accepts sync tokens, parses JWTs, creates local credential files, and configures external authentication state. That mismatch is security-relevant because token and identity handling requires a much higher trust level than ordinary content collection and reporting.
The skill description omits that it accepts sync tokens, parses JWTs, creates local credential files, and configures external authentication state. That mismatch is security-relevant because token and identity handling requires a much higher trust level than ordinary content collection and reporting.
The skill description omits that it accepts sync tokens, parses JWTs, creates local credential files, and configures external authentication state. That mismatch is security-relevant because token and identity handling requires a much higher trust level than ordinary content collection and reporting.
The documentation tells users to fetch and immediately execute a remote shell script via curl ... | bash. This is a classic arbitrary code execution and supply-chain risk: if the remote server, CDN, DNS path, or script content is compromised, the operator will run attacker-controlled code on their machine with their user privileges.
curl -fsSL https://cdn.kimi.com/webbridge/install.sh | bash
The | bash pattern explicitly chains network retrieval into immediate execution, removing any review or integrity-verification step. In a skill that already requests browser control and authenticated sessions, this materially heightens the chance of full host compromise and subsequent theft of cookies, tokens, and local data.
curl -fsSL https://cdn.kimi.com/webbridge/install.sh | bash
Referenced artifact was not completely inspected
| `webbridge-crawl.ts` | 通过 WebBridge 控制用户真实浏览器采集 |
Referenced artifact was not completely inspected
| `zion-login.ts` | 保存「好痛 Howtone」项目同步 Token |
The skill instructs users to save a synchronization token and upload collected data, including images, to an external platform. This is high risk because it combines credential handling with bulk exfiltration of harvested content to a third party, and the documentation does not clearly define trust, storage, retention, or access controls.
Referenced artifact was not completely inspected
| `sync.ts` | 将采集数据同步到「好痛 Howtone」项目(含图片上传) |
The optional Howtone workflow asks the user to provide a sync token and send output files for external analysis, creating a clear channel for credential use and outbound data transfer. In the context of scraped, possibly account-derived content, this materially increases data leakage, compliance, and unauthorized-sharing risk.
The code probes a predictable local path for .zion/credentials.yaml, indicating credential access behavior. In an agent skill, accessing stored credentials for a separate service materially increases risk because it can leverage existing admin tokens to perform authenticated actions beyond the user's expectation for a note-collection tool.
}
function loadConfig(): ZionConfig {
const zionCredPath = path.resolve(process.cwd(), '.zion', 'credentials.yaml');
const siblingZionCredPath = path.resolve(process.cwd(), '..', 'pain-catcher', '.zion', 'credentials.yaml');
let credPath = fs.existsSync(zionCredPath) ? zionCredPath : (fs.existsSync(siblingZionCredPath) ? siblingZionCredPath : null);
The code also searches a sibling project directory (../pain-catcher/.zion/credentials.yaml) for credentials, broadening secret discovery beyond the current workspace. This increases the likelihood of unauthorized credential use and resembles lateral secret harvesting from adjacent projects.
function loadConfig(): ZionConfig {
const zionCredPath = path.resolve(process.cwd(), '.zion', 'credentials.yaml');
const siblingZionCredPath = path.resolve(process.cwd(), '..', 'pain-catcher', '.zion', 'credentials.yaml');
let credPath = fs.existsSync(zionCredPath) ? zionCredPath : (fs.existsSync(siblingZionCredPath) ? siblingZionCredPath : null);
Although this line is only an error message, it confirms to users and reviewers that the script expects and targets .zion/credentials.yaml for credential access. That reinforces the credential-access behavior but is not independently as severe as the actual file reads on lines 141-142.
}
}
throw new Error('未找到有效 Zion 配置,请检查 .zion/credentials.yaml');
}
function buildInsertMutation(tableName: string, note: XHSNote, imageIds: string[], userId?: string): { query: string; variables: Record<string, any> } {
The crawler performs remote installation automatically and without prior user approval, violating the principle of least surprise and removing an important safety checkpoint before executing privileged code. In a skill that already interacts with a real logged-in browser, silent installation substantially increases the chance of unwanted persistence or host compromise.
Piping a remote script directly into bash/PowerShell executes unverified code from the network with the user's privileges, enabling full system compromise if the CDN, DNS, TLS path, or upstream publisher is compromised. This is especially severe here because the skill also expects access to a logged-in browser session, so compromise could expose local data, browser context, and authenticated accounts.
Fetching an installer script over the network and piping it directly to bash is a classic remote code execution pattern with no integrity validation. Within this skill's context, it is especially dangerous because the resulting installed component can control the user's browser and access authenticated browsing activity.
if (isWin) {
execSync('powershell -Command "irm https://cdn.kimi.com/webbridge/install.ps1 | iex"', { stdio: 'inherit' });
} else {
execSync('curl -fsSL https://cdn.kimi.com/webbridge/install.sh | bash', { stdio: 'inherit' });
}
console.log('✅ Kimi WebBridge 安装成功!');
} catch (err) {
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.
if (isWin) {
console.error(' irm https://cdn.kimi.com/webbridge/install.ps1 | iex');
} else {
console.error(' curl -fsSL https://cdn.kimi.com/webbridge/install.sh | bash');
}
return false;
}
The script explicitly instructs the user to provide a synchronization token and persists it as credential material, which is direct credential handling. In the context of a scraping skill, this is more sensitive because the token is unrelated to basic collection and may grant access to an external analysis platform if stolen.
/**
* Zion 凭证保存脚本
* 直接接收用户提供的「好痛 Howtone」同步 Token,并保存到 .zion/credentials.yaml
*
* 用法:
* npx ts-node zion-login.ts --token="你的同步Token"
The code defines a fixed path for credentials.yaml under the current working directory and later stores the token there in plaintext-like form, creating a stable target for theft. A predictable credential file in a workspace increases the chance of accidental exposure through local compromise, repository inclusion, shared directories, or support bundles.
import * as path from 'path';
const PROJECT_EX_ID = 'rmLyJ0ZJXK8';
const CRED_PATH = path.resolve(process.cwd(), '.zion', 'credentials.yaml');
function decodeJwt(token: string): any {
try {
The skill declares powerful capabilities such as shell, network, and environment access but does not restrict or document tool scope. In a skill that automates browser actions, installs software, stores tokens, and uploads data externally, missing explicit permission boundaries increases the chance of overreach, unintended execution, or abuse by downstream prompts.
The trigger phrases are broad enough to activate during ordinary discussion about Xiaohongshu, research, or content topics. Over-broad activation is risky for a skill with shell, network, login, scraping, and upload behaviors because it can cause the agent to enter a sensitive workflow without sufficiently explicit user intent.
The description does not prominently disclose the privacy, account, and third-party transmission implications of scraping logged-in content and synchronizing outputs to an external platform. In this context, omission is dangerous because the workflow handles user/account-derived data and may expose it outside the original platform.
The skill directly instructs collection of account-derived browsing data and comments, then offers synchronization to a third-party analysis platform. This is sensitive because logged-in browsing context and user-generated content may include personal data, and the transfer broadens exposure beyond the original source platform.
The instructions require the operator to remain logged into a real platform account while automation drives the browser to collect data. That raises both account-security and privacy risk because session-backed access is more sensitive than public browsing, and automation against a live session can expose private state, cookies, and platform-enforcement consequences.
Using npx ts-node without pinning exact package versions makes execution dependent on whatever version resolves at runtime. That creates supply-chain and reproducibility risk, especially in a skill that handles authenticated sessions and may access local files or external services.