T03 · Remote Payload Retrieval and Execution
- Location
SKILL.md:55- Finding
Documentation Executes Mutable Remote Scripts over Plaintext HTTP
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
The skill’s collaboration goal is coherent, but its default setup relies on plaintext remote code downloads, unauthenticated agent APIs, and a hard-coded external server path that users should review carefully before installing.
Install only in a trusted test environment unless you first replace HTTP/ws with HTTPS/wss, remove curl-to-bash setup, verify all downloaded code, configure your own trusted server, add authentication/authorization for every agent and API call, and avoid letting remote tasks automatically trigger OpenClaw execution without human approval.
SKILL.md:55Documentation Executes Mutable Remote Scripts over Plaintext HTTP
assets/install-clawbot.sh:39Installer Downloads and Executes Unverified Python Payloads
scripts/index.js:24Unauthenticated APIs Permit Agent Impersonation, Data Disclosure, and Task Injection
scripts/clawbot_connector.py:42Local Device Identity and Collaboration Data Are Disclosed over Plaintext Connections
scripts/package.json:10Unpinned Dependency Installation Prevents Reproducible and Verifiable Builds
Fetching and executing a shell script directly from an external endpoint is a classic remote code execution pattern. Here it is especially dangerous because the example uses plain HTTP, so both server compromise and on-path tampering can replace the installer and fully compromise the target machine.
Option A: One-line install (MacBook/Mac Mini)
curl -fsSL http://YOUR-VPS:3001/install-clawbot.sh | bash
Then start:
Piping downloaded content directly into bash removes any opportunity for inspection and turns a network response into immediate execution. In this skill, which establishes cross-device agent connectivity, that pattern is particularly hazardous because a compromised installer can implant persistent remote-control functionality across multiple machines.
Option A: One-line install (MacBook/Mac Mini)
curl -fsSL http://YOUR-VPS:3001/install-clawbot.sh | bash
Then start:
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.
**Connection refused:**
- Check server is running: `curl http://your-vps:3001/api/health`
- Check firewall: `sudo ufw allow 3001/tcp && sudo ufw allow 3002/tcp`
**Messages not received:**
- Verify `bot_id` is unique per device
The advertised installation method instructs users to pipe a remotely hosted script directly into bash from an unauthenticated HTTP endpoint. This is dangerous because any compromise of the host, transit path, or DNS/network layer results in immediate arbitrary shell execution on the target machine with no opportunity for user review.
# ClawBot Network Connector - Quick Setup
# 让任何设备上的 clawdbot 快速接入 Agent Network
#
# 用法: curl -fsSL http://3.148.174.81:3001/install-clawbot.sh | bash
set -e
Using '| bash' executes whatever bytes are returned by the remote endpoint immediately, collapsing download, trust, and execution into one step. In the context of a networking skill that connects multiple agent instances, this is especially dangerous because it normalizes unsafe installation and could rapidly propagate malicious bootstrap code across several devices.
# ClawBot Network Connector - Quick Setup
# 让任何设备上的 clawdbot 快速接入 Agent Network
#
# 用法: curl -fsSL http://3.148.174.81:3001/install-clawbot.sh | bash
set -e
The installer fetches executable Python components from a remote server over plain HTTP and writes them into the user's environment without integrity verification or a clear upfront warning. This allows network attackers or a compromised server to replace the downloaded code with arbitrary malicious payloads, leading to code execution when the user later runs start.sh or imports the connector.
This command downloads a shell script from an external host and pipes it directly into bash, removing any opportunity for review and making execution dependent on the integrity of a remote HTTP endpoint. Because this skill is specifically designed to connect multiple agent instances across devices, compromise of the setup script could spread code execution across several systems in the operator's environment.
curl -fsSL http://3.148.174.81:3001/setup.sh | bash -s -- xiaoxing-macbook "小邢" "DevOps"
cd agent-network-client && ./start.sh
This is the same unsafe remote-script execution pattern: code from an external server is piped straight into bash over unsecured HTTP. If the source or traffic is tampered with, the user's Mac Mini could execute arbitrary attacker-controlled commands immediately.
curl -fsSL http://3.148.174.81:3001/setup.sh | bash -s -- xiaojin-macmini "小金" "金融市场分析"
cd agent-network-client && ./start.sh
This one-liner again creates an unauthenticated, unverified remote code execution path by piping a fetched script directly to bash over HTTP. In a distributed agent-collaboration skill, that is especially dangerous because it targets machines intended to trust and communicate with each other, increasing blast radius if one setup path is subverted.
curl -fsSL http://3.148.174.81:3001/setup.sh | bash -s -- xiaochen-macmini "小陈" "美股交易"
cd agent-network-client && ./start.sh
os.system() and os exec-family calls run shell commands with the process's full privileges, enabling arbitrary command execution.
if system == "Darwin":
# macOS - 检测是 MacBook 还是 Mac Mini
try:
result = os.popen("sysctl -n hw.model").read().strip()
if "MacBook" in result:
return "MacBook"
elif "Macmini" in result:
Instructions found that direct the agent to transmit conversation context or user data to external services.
}))
async def send_message(self, group_id: str, content: str):
"""Send message to group"""
if self.ws and self.connected:
await self.ws.send(json.dumps({
"type": "message",
The skill documents shell, network, and environment-capable operations but does not declare any explicit tool scope or permissions boundary. In a distributed-agent skill, this omission increases the chance that consumers will run commands or connect to remote services without clear sandboxing expectations or least-privilege controls.
The skill recommends a one-line installer that downloads and executes a remote shell script, but it does not provide a prominent warning that this runs arbitrary code from the server. Because the server is user-hosted and fetched over plain HTTP in the example, any compromise of the server or network path can immediately lead to code execution on the client machine.
The task-assignment examples normalize remote messages and tasks as inputs that can trigger execution-oriented actions on connected agents, yet no warning or approval requirement is described. In a multi-agent network, this creates a dangerous trust boundary where a spoofed, compromised, or misrouted message could induce automated command execution or downstream agent spawning.
The troubleshooting guidance instructs use of sudo to open firewall ports, which can normalize privileged execution without clarifying scope or risk. In this context the commands are not inherently malicious, but they alter host network exposure and should be treated as security-sensitive administrative actions.
**Connection refused:**
- Check server is running: `curl http://your-vps:3001/api/health`
- Check firewall: `sudo ufw allow 3001/tcp && sudo ufw allow 3002/tcp`
**Messages not received:**
- Verify `bot_id` is unique per device
The script's descriptive comments and most runtime prompts are presented in Chinese, and there is no indication that the user can select another language. This creates a language/locale constraint without opt-in, which fits the policy's natural-language violation criteria.
The quickstart instructs users to fetch and immediately execute a shell script from a remote server over plain HTTP using curl-pipe-bash. This creates a direct remote code execution path where any compromise of the server, network path, or DNS could result in arbitrary commands running on the user's machine without inspection.
The manual installation steps tell users to download executable Python client code and configuration over plain HTTP without any integrity verification or trust warning. An attacker able to tamper with the server or traffic could deliver a trojanized client that the user then runs locally.
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.
# 重启服务器
kill $(cat server.pid)
nohup node server/index.js > server.log 2>&1 &
# 查看状态
curl http://localhost:3001/api/health
The skill's stated purpose is to connect OpenClaw instances for messaging, mentions, task assignment, and group chat across devices. Invoking os.popen("sysctl -n hw.model") adds command-execution capability on the host, which is stronger than what is obviously required for a network connector and is not declared in the manifest description.
The connector automatically initiates a network connection to a hard-coded remote server and transmits bot identity, device information, and presence without any user consent, trust verification, or warning. In a distributed agent skill, this is especially dangerous because it creates an unvetted command-and-control channel through which external parties may message the bot, assign tasks, and potentially influence downstream agent behavior.
The clearOfflineMessages function performs a destructive DELETE operation on stored offline messages, but the code provides no confirmation prompt, user-visible log, or warning around this data removal. Because this removes persisted user/agent message data, it qualifies as a safety-relevant operation lacking disclosure in the code shown.
This server stores group messages and offline direct/mention messages in the database and transmits message contents over WebSocket connections, but the file provides no user-facing disclosure, confirmation, or warning about retention and transmission of user data. Because these operations affect user privacy and data handling, they meet the missing-warning criterion for code files.
The usage example hardcodes Chinese display names and message content, which signals a specific language expectation in the skill's natural-language interface. Because the file does not offer an opt-in language choice or explain that the client is intended only for a Chinese-speaking environment, this is a locale policy concern.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
def create_task(self, title: str, description: str, assignee_id: str, **kwargs) -> dict:
"""Create a task"""
try:
response = requests.post(f"{self.rest_url}/api/tasks", json={
"title": title,
"description": description,
"assigneeId": assignee_id,
No suspicious patterns detected.