Back to skill

Security audit

Wewe Rss Reader

Security checks for vulnerabilities and agentic risk

Overview

The skill is aimed at reading WeChat articles, but it also handles account login, group-shares login artifacts, and starts unpinned local services, so users should review it carefully before installing.

Install only if you are comfortable running and maintaining the referenced local WeWe RSS service yourself. Pin and review the external repository before running Docker or Python code, replace the documented AUTH_CODE with a unique secret, keep ports bound to localhost, and do not send WeChat Reading login QR codes or confirmation URLs to a shared group chat.

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

T08 · Insecure Dependencies

Error
Location
references/deployment.md:13
Finding
Unpinned Third-Party Repository Is Downloaded and Executed Locally<![CDATA[ ## Vulnerability Details **File Location**: `references/deployment.md:13-27`; related automatic startup instruction at `SKILL.md:108-109` **Vulnerability Type**: Untrusted and unpinned third-party dependency execution **Risk Level**: High ### Vulnerable Code ```bash ### 1. Clone the fork git clone https://github.com/AxelHu/wewe-rss.git cd wewe-rss ### 2. Start the wewe-rss container docker compose up -d ### 3. Start the REST API # Requires Python 3.8+ python3 api_server.py ``` The Skill also instructs the agent to start the deployment automatically if the service is unavailable: ```text - If the container is not running: run `docker compose up -d` in the `~/.openclaw/workspace/wewe-rss/` directory. ``` ### Technical Analysis The deployment procedure clones the current default branch of a personal GitHub fork and immediately executes both its Docker Compose configuration and its Python API server. No immutable commit, release tag, container image digest, checksum, or cryptographic signature is specified. The executable repository content is not included in the audited Skill package. Consequently, the effective code cannot be reviewed as part of this audit and can change after the Skill is published. Running Docker Compose is particularly sensitive because the remote configuration can define container images, host bind mounts, environment variables, networking behavior, privileged mode, and other host-facing capabilities. The automatic recovery instruction increases exposure by encouraging execution of the downloaded Compose configuration whenever the local service is unavailable. ### Attack Path 1. An attacker compromises the upstream GitHub account, repository, dependency pipeline, or a referenced mutable container image. 2. The attacker modifies `docker-compose.yml`, `api_server.py`, or another startup component on the default branch. 3. A user follows the documented deployment procedure and clones the latest repository content without i ...[truncated 981 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the repository to a reviewed immutable commit hash rather than cloning the current default branch. 2. Pin every container image by cryptographic digest, not by a mutable tag. 3. Vendor the reviewed Compose file and API server into the Skill package when licensing permits, so their behavior is included in the audit. 4. Publish and verify checksums or signed release artifacts before execution. 5. Review Compose settings and prohibit unnecessary privileged mode, Docker socket mounts, host networking, host filesystem mounts, and excessive Linux capabilities. 6. Run the API and containers as non-root users with read-only filesystems and narrowly scoped volumes. 7. Replace automatic startup of potentially changed files with an explicit user confirmation and integrity-verification step. 8. Document the exact reviewed upstream commit and establish a controlled update process requiring a new security review. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:15
Finding
Publicly Documented Static Authentication Code<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:15` **Vulnerability Type**: Hard-coded predictable authentication credential **Risk Level**: Medium ### Vulnerable Code ```text - **AUTH_CODE**: `wewe-rss-2026` ``` The metadata additionally declares that no credential is required: ```json "requiredEnvVars": [], "requiredConfigPaths": [], "primaryCredential": null, "credentialSetup": { "type": "none", "description": "No credential is required. Local deployment, accessed through localhost." } ``` ### Technical Analysis The Skill publishes a fixed authentication code in its documentation while its metadata declares no credential requirement. If a deployment retains this value, it is not a secret: every user of the Skill and anyone with access to the package knows it. The repository containing the actual REST API and Compose configuration is not part of the audited artifact. Therefore, this audit could not verify whether authentication is consistently enforced, whether the services bind exclusively to loopback, or whether the documented code is merely illustrative. The vulnerability is exploitable when the known code is retained and the management interface becomes reachable by another local user, container, LAN host, or remote party. A localhost-only binding reduces remote exposure but does not make a shared static code secure. Port forwarding, reverse proxies, container port publication, or configuration changes can unintentionally make the service reachable beyond loopback. ### Attack Path 1. An operator deploys the service using the publicly documented `wewe-rss-2026` authentication code. 2. The service becomes reachable to an attacker through a LAN binding, published container port, reverse proxy, tunnel, compromised local process, or configuration error. 3. The attacker submits the known authentication code to the protected interface. 4. If the server accepts the static code, the attacker gains the management access associated with ...[truncated 804 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the fixed authentication code from the Skill documentation. 2. Generate a unique, cryptographically random secret for every deployment. 3. Supply the secret through a protected environment variable, Docker secret, or operating-system secret store. 4. Update `_meta.json` to accurately declare the required credential or configuration. 5. Bind both services explicitly to `127.0.0.1` by default and avoid publishing management ports on all interfaces. 6. Require an authenticated reverse proxy with TLS if remote access is necessary. 7. Reject missing, default, or weak authentication values during server startup. 8. Use constant-time credential comparison, rate limiting, failed-attempt logging, and credential rotation. 9. Document firewall requirements and warn users against exposing ports 4000 and 4001 directly to untrusted networks. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (6)

Missing User Warnings

High
Confidence
98% confidence
Finding
The skill instructs sending a login QR or confirmation URL to a Feishu group, which can disclose a live authentication artifact to multiple recipients beyond the intended user. Anyone who can access that group message may be able to complete or interfere with the login flow, leading to account takeover, session hijacking, or unauthorized use of the bound reading account.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
Publishing a hard-coded `AUTH_CODE` in skill documentation exposes a credential-like secret to anyone who can read the file and encourages insecure secret handling. If that code is accepted by the local API or related deployment, an attacker or unintended user could reuse it to gain access or automate against the service.

Description-Behavior Mismatch

Medium
Confidence
93% confidence
Finding
The skill’s documented scope expands from passive article reading into account authorization, subscription management, and operational control of a local service. That broader behavior increases the chance an agent will perform sensitive actions—such as logging into a third-party account or changing persistent subscriptions—without clear user intent, least-privilege boundaries, or consent checkpoints.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The instruction to run `docker compose up -d` gives the agent authority to start local services based solely on an application error, which exceeds the stated reading purpose. Starting containers can execute arbitrary images, expose ports, alter host state, and revive previously configured services without the user understanding the security implications.

Natural-Language Policy Violations

Low
Confidence
83% confidence
Finding
The natural-language instructions throughout the skill are exclusively in Chinese and frame the skill's operation in that language, without indicating that users may choose another language. This can violate language-choice policy when no opt-in or justified locale restriction is documented.

Natural-Language Policy Violations

Low
Confidence
92% confidence
Finding
The natural-language description at L12 is written only in Chinese, which may impose a language/locale expectation without any stated user opt-in or justification. The policy specifically calls for flagging language or locale constraints when the skill does not offer a choice or document why the restriction is necessary.

Static analysis

No suspicious patterns detected.