Back to skill

Security audit

Yunitalk Beta

Security checks for vulnerabilities and agentic risk

Overview

This skill appears to be a real OpenClaw-to-Talk Robots integration, but it handles reusable gateway credentials in ways users should review carefully before installing.

Install only if you are comfortable giving Talk Robots access to your OpenClaw gateway token. Treat the generated `/openclaw --init ...` string, QR code, terminal output, and robot send debug output as secrets. Prefer a pinned or locally reviewed initializer instead of unpinned `npx`, avoid running it in CI or shared terminals, and rotate the OpenClaw gateway token if the QR/command output may have been exposed.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (3)

T09 · Insecure Skill Coding Practices

Error
Location
npm/yntalk-openclaw-init/bin/yntalk-openclaw-init.js:660
Finding
Gateway Credential Disclosed Through Reversible Base64 and QR Output<![CDATA[ ## Vulnerability Details **File Location**: `npm/yntalk-openclaw-init/bin/yntalk-openclaw-init.js:68-69, 327-346, 660-686` **Vulnerability Type**: Sensitive credential exposure through standard output **Risk Level**: High ### Vulnerable Code ```js function payloadToBase64(payload) { return Buffer.from(JSON.stringify(payload), 'utf8').toString('base64'); } ``` ```js const payload = normalizeOpenClawPayload({ OPENCLAW_URL: publicURL, OPENCLAW_TOKEN: openclawToken }); return { payload: { ...payload, OPENCLAW_LAN_URL: lanURL }, lanURL, publicURL, openAIBaseURL: openAIBaseURL(publicURL), openAIBaseLANURL: openAIBaseURL(lanURL), gatewayBind, gatewayPort, authMode: firstConfigValue(config, ['gateway.auth.mode']) || 'none', chatEnabled, publicReachable: isPublicGatewayBind(gatewayBind), publicIP }; ``` ```js async function main() { const opts = parseArgs(process.argv.slice(2)); if (opts.help) { process.stdout.write(usage()); return; } const result = await readOpenClawInfoFromLocalConfig(opts.verbose); const payload = result.payload; if (!payload) throw new Error('OpenClaw connection info is incomplete.'); const encoded = payloadToBase64(payload); const command = '/openclaw --init ' + encoded; const qr = makeQRCode(command); process.stdout.write('局域网访问地址:\n'); process.stdout.write(result.lanURL + '\n\n'); process.stdout.write('局域网 OpenAI Base URL:\n'); process.stdout.write(result.openAIBaseLANURL + '\n\n'); process.stdout.write('公网访问地址:\n'); process.stdout.write(result.publicURL + '\n\n'); process.stdout.write('公网 OpenAI Base URL:\n'); process.stdout.write(result.openAIBaseURL + '\n\n'); process.stdout.write('Gateway:\n'); process.stdout.write('bind: ' + result.gatewayBind + '\n'); process.stdout.write('port: ' + result.gatewayPort + '\n'); process.stdout.write('auth_mode: ' + result.authMode + '\n'); process.stdout.write('chatCompletions: ' + (result.chatEnabled ? ...[truncated 2369 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the reusable gateway token with a short-lived, single-use enrollment token scoped only to establishing the integration. 2. Do not print credential-bearing initialization material by default. Require an explicit option and interactive confirmation before revealing it. 3. Refuse to emit the credential when standard output is not attached to an interactive terminal, unless the user supplies an explicit override. 4. Prefer a protected local handoff or authenticated enrollment protocol instead of transferring a reusable secret through terminal output. 5. Clearly warn immediately before output that both the Base64 command and QR code contain the complete gateway credential. 6. Add token expiration, revocation, rotation, and least-privilege scopes on the gateway side. 7. Ensure generated credentials cannot authorize administrative operations that are unnecessary for chat integration. 8. Avoid storing or transmitting generated output in CI logs, support tickets, ordinary chat messages, or shell history. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:31
Finding
Unpinned npm Package Is Downloaded and Executed During Initialization<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:31-34` **Vulnerability Type**: Unpinned remote package execution and supply-chain exposure **Risk Level**: Medium ### Vulnerable Code ```bash npx yntalk-openclaw-init ``` The same unpinned installation pattern is also documented in `README.md:45-54` and `npm/yntalk-openclaw-init/README.md:27-39`. ### Technical Analysis The recommended initialization command does not specify an audited package version or integrity value. Consequently, `npx` can retrieve and execute whichever package version the npm registry currently resolves for `yntalk-openclaw-init`. The local source reviewed in this project does not guarantee that the package downloaded later from the registry is identical. A compromised maintainer account, malicious future release, registry compromise, or package ownership change could replace the effective executable after this audit. This risk is especially significant because the initializer is expected to access a local OpenClaw configuration containing `gateway.auth.token`. A malicious package version would execute with the invoking user's filesystem and network permissions. ### Attack Path 1. An attacker compromises the npm package, publisher credentials, release process, or registry entry. 2. The attacker publishes a modified version of `yntalk-openclaw-init`. 3. A user follows the Skill's recommended `npx yntalk-openclaw-init` command. 4. `npx` resolves and downloads the modified package because no version or integrity constraint is specified. 5. The package executes under the user's account. 6. Malicious code reads `openclaw.json`, including the gateway token, or accesses other files available to that user. 7. The malicious package transmits stolen information or performs other actions allowed by the user's privileges. ### Impact Assessment A compromised package can execute arbitrary JavaScript with the permissions of the invoking user. This may include reading the OpenClaw g ...[truncated 367 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the exact audited package version, for example `npx yntalk-openclaw-init@0.1.0`, rather than resolving the latest release. 2. Prefer executing the initializer bundled with the installed Skill when its contents have already been reviewed. 3. Publish npm provenance attestations and document how users can verify the publisher and artifact. 4. Provide integrity hashes or signed release artifacts and verify them before execution. 5. Protect package publication with multi-factor authentication, trusted publishing, and restricted release permissions. 6. Establish a release process that verifies the published npm tarball matches the reviewed repository source. 7. Avoid running the initializer with elevated privileges. 8. Consider using `npx --ignore-scripts` where compatible and ensure the package does not rely on lifecycle scripts. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
shell/robot_send.sh:217
Finding
Signed Authentication URL and HMAC Value Are Logged for Every Request<![CDATA[ ## Vulnerability Details **File Location**: `shell/robot_send.sh:217-232` **Vulnerability Type**: Authentication artifact exposure through unconditional logging **Risk Level**: Medium ### Vulnerable Code ```bash # Keep this signing text aligned with talk-robots/common.RobotSendSignPayload: # sorted keys and URL-encoded values. signing_text="msg_id=$(urlencode "${msg_id}")&noncestr=$(urlencode "${noncestr}")&robot_id=$(urlencode "${robot_id}")&timestamp=$(urlencode "${timestamp}")" sign="$(printf '%s' "${signing_text}" | openssl dgst -sha256 -hmac "${robot_key}" | awk '{print $2}')" request_url="${base_url}?robot_id=$(urlencode "${robot_id}")&noncestr=$(urlencode "${noncestr}")&timestamp=$(urlencode "${timestamp}")&msg_id=$(urlencode "${msg_id}")&sign=$(urlencode "${sign}")" echo "mode=${mode}" echo "request_url=${request_url}" echo "msg_id=${msg_id}" echo "noncestr=${noncestr}" echo "timestamp=${timestamp}" echo "signing_text=${signing_text}" echo "sign=${sign}" ``` ### Technical Analysis The script correctly avoids printing the raw `robot_key`, but it unconditionally prints the complete signed request URL and individual HMAC value before both dry-run and real requests. The URL contains the robot identifier, timestamp, nonce, message ID, and a valid signature. These are authentication artifacts and should be treated as sensitive for at least the full server-side acceptance window. Automation platforms, agent transcripts, terminal capture, and process logs can retain them. The practical replay window depends on server-side controls that are not included in this project. Strong timestamp validation and atomic nonce or message-ID consumption can limit exploitation, but the client should not assume those controls eliminate the need to protect signed URLs. ### Attack Path 1. A legitimate user or agent invokes `robot_send.sh`. 2. The script generates a valid HMAC signature for the request parameters. 3. Before transmission, it prints the complete si ...[truncated 917 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove unconditional output of `request_url`, `sign`, `signing_text`, `noncestr`, and other authentication metadata. 2. Add an explicit debug option and redact the signature even when debugging. 3. Keep normal output limited to a generated message ID, final status, and sanitized error information. 4. Send authentication values in headers rather than URL query parameters if the server API can be changed; URLs are frequently retained by proxies and access logs. 5. Enforce a short timestamp acceptance window on the server. 6. Store and atomically reject reused nonces and message IDs for the entire acceptance window. 7. Ensure logs at clients, proxies, gateways, and servers redact authentication query parameters. 8. Document that dry-run output contains authentication artifacts if retaining signed dry-run behavior is necessary. ]]>
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
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (24)

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The documented purpose says the skill connects OpenClaw with the chat platform, but the described behavior also includes reading local configuration, discovering LAN/public network information, and outputting initialization payloads that contain gateway tokens encoded in Base64. That mismatch is dangerous because it hides sensitive data handling and network reconnaissance behind an apparently simple integration skill, making secret exposure and overcollection more likely in agent environments.

Ae1

High
Category
analysis-evasion
Content
优先使用 `shell/robot_send.sh`,不要手写签名。
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
优先使用 `shell/robot_send.sh`,不要手写签名。
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
优先使用 `shell/robot_send.sh`,不要手写签名。
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Rp1

Medium
Category
MCP Rug Pull
Confidence
93% confidence
Finding
The README instructs users to execute `npx yntalk-openclaw-init` without pinning a specific package version. Because `npx` resolves and runs the latest published package by default, a compromised maintainer account, malicious update, or dependency hijack could cause arbitrary code execution on the operator's machine during setup. This skill is more sensitive than average because the CLI reads local `openclaw.json`, discovers network addresses, and handles gateway tokens, so a malicious package could exfiltrate credentials and internal network information.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
91% confidence
Finding
This is a duplicate match on the same line for the same unpinned `npx yntalk-openclaw-init` usage in troubleshooting guidance. The security concern is unchanged: resolving and executing an unpinned npm package can expose operators to malicious package updates or dependency compromise, with elevated sensitivity here due to access to OpenClaw tokens and local network details.

External Transmission

Medium
Category
Data Exfiltration
Content
`curl` 示例:

```bash
curl -X POST "$request_url" \
  -H "Content-Type: application/json" \
  --data-binary '{
    "cmd": "msg",
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
msg_id=<msg_id>&noncestr=<noncestr>&robot_id=<robot_id>&timestamp=<timestamp>
```

## curl 发送文本消息

文本消息使用 `application/json`,请求体是完整 `imx.Msg` JSON 结构,`cmd` 固定为 `msg`,文本内容放在 `body.content`。
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Lp3

Medium
Category
MCP Least Privilege
Confidence
96% confidence
Finding
The skill instructs use of shell commands, environment-provided secrets, and outbound network operations, but it declares no tool scope or permission boundaries. This creates an authorization gap where an agent/runtime may expose more capability than users expect, increasing the chance of unintended secret access or message delivery to external endpoints.

Rp1

Medium
Category
MCP Rug Pull
Confidence
90% confidence
Finding
Using `npx yntalk-openclaw-init` without a pinned version makes initialization dependent on whatever package version the registry serves at execution time. If the package is updated maliciously, compromised, or simply changes behavior, it could exfiltrate local OpenClaw configuration and tokens or generate unsafe connection payloads.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
This manifest sets the default language to "zh-CN", which is a natural-language locale constraint. The file does not indicate that users can choose another language or explicitly opt in, so it appears to enforce a specific locale by default.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The README instructs users to execute `npx yntalk-openclaw-init` without pinning a package version, which causes npm to fetch and run whatever package version is current at execution time. If the package is later compromised, typo-squatted, or a malicious version is published, users could execute attacker-controlled code on their local machine, and in this skill's context that code may access local `openclaw.json` and expose gateway tokens.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This unpinned `npx yntalk-openclaw-init` invocation executes the latest published package version at runtime, creating a supply-chain execution risk. Because the documented tool reads local configuration and extracts `gateway.auth.token`, compromise of the npm package could directly lead to credential theft or unauthorized access to the OpenClaw gateway.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
Documenting `npx yntalk-openclaw-init` without a version pin exposes users to arbitrary future package changes and registry compromise. In this context the risk is elevated beyond a generic CLI because the tool is designed to gather network addresses and sensitive authentication tokens for encoding into a command/QR payload.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
The help example also uses an unversioned `npx` invocation, so even users seeking only usage information may fetch and run a potentially compromised latest package. Since the package interacts with local config and tokens, successful exploitation could reveal credentials or alter initialization data before the user notices.

Rp1

Medium
Category
MCP Rug Pull
Confidence
96% confidence
Finding
This example combines an environment-provided config path with an unpinned `npx` execution, increasing the value of exploitation because a malicious package could read the explicitly targeted configuration file and exfiltrate secrets from it. The skill context makes the issue more dangerous because the documented workflow centers on discovering and packaging `OPENCLAW_TOKEN` for downstream use.

Description-Behavior Mismatch

Medium
Confidence
94% confidence
Finding
The initializer reads the local OpenClaw gateway token, derives LAN and public URLs, and packages them into a base64 payload for a command/QR code. This effectively exports credentials plus a potentially externally reachable endpoint, which materially increases the chance of credential leakage or unintended remote access beyond a simple chat integration setup.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The generated `/openclaw --init <base64-json>` command and QR code contain the gateway token, and both are printed directly to the terminal without an explicit warning that they are secrets. Anyone who can view terminal scrollback, logs, screenshots, or the QR code can recover the token and potentially access the OpenClaw gateway.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The script prints the fully signed request URL, nonce, timestamp, message ID, signing text, and signature to stdout before sending. Those values can be captured by shell history, CI logs, terminal recording, or other local observers and may enable replay or unauthorized request submission if the server accepts the signed parameters within a validity window. The default base URL also uses plain HTTP, which further increases exposure if used beyond localhost.

External Transmission

Medium
Category
Data Exfiltration
Content
if [[ "${mode}" == "text" ]]; then
  body="$(json_body)"
  curl -sS -X POST "${request_url}" \
    -H "Content-Type: application/json" \
    --data-binary "${body}" \
    -w '\nHTTP_STATUS=%{http_code}\n'
Confidence
70% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Context-Inappropriate Capability

Low
Confidence
80% confidence
Finding
The code contacts multiple third-party IP-discovery services to determine the host's public IP, disclosing network metadata to external domains. While not an exploit by itself, this creates an unnecessary privacy and metadata-leakage channel for an initializer unless the user explicitly opts in.

Missing User Warnings

Low
Confidence
91% confidence
Finding
Public IP lookup necessarily reveals the user's source IP and timing metadata to third-party services, but the tool does not clearly inform the user this outbound disclosure will occur. In a setup utility that reads local config and credentials, silent external calls make the behavior more security-sensitive.

Natural-Language Policy Violations

Low
Confidence
98% confidence
Finding
The script emits its primary user-facing labels in Chinese, such as the access-address and QR instructions, regardless of user locale or preferences. This is a natural-language locale policy issue because the tool enforces one language without opt-in or a documented regional justification.

Static analysis

No suspicious patterns detected.