Back to skill

Security audit

WebChat Voice Full Stack

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed voice-stack installer, but it runs mutable downstream installer scripts and overstates its checksum protection.

Review and pin the three downstream skills before using this. Do not treat rehash.sh as proof of a safe download; it only records a local trust baseline after installation. Be aware that deployment can install user-level services, modify OpenClaw gateway/UI behavior, and run downstream scripts with your user privileges.

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
scripts/rehash.sh:26
Finding
Integrity Verification Fails to Detect Unlisted or Non-Shell Dependency Files<![CDATA[ ## Vulnerability Details **File Location**: `scripts/rehash.sh:26-36`; verification logic in `scripts/deploy.sh:27-58` **Vulnerability Type**: Incomplete integrity validation **Risk Level**: High ### Vulnerable Code ```bash count=0 for skill in "${SUB_SKILLS[@]}"; do script_dir="$SKILLS_DIR/$skill/scripts" if [[ ! -d "$script_dir" ]]; then echo "WARNING: $skill/scripts not found, skipping" >&2 continue fi while IFS= read -r -d '' script; do rel_path="${script#"$SKILLS_DIR/"}" hash="$(sha256sum "$script" | awk '{print $1}')" echo "$hash $rel_path" >> "$CHECKSUMS" ((count++)) done < <(find "$script_dir" -type f -name '*.sh' -print0 | sort -z) done ``` The resulting manifest is verified as follows: ```bash while IFS= read -r line; do # skip comments and empty lines [[ "$line" =~ ^[[:space:]]*# ]] && continue [[ -z "${line// }" ]] && continue local expected_hash file_rel expected_hash="$(echo "$line" | awk '{print $1}')" file_rel="$(echo "$line" | awk '{print $2}')" local file_abs="$SKILLS_DIR/$file_rel" if [[ ! -f "$file_abs" ]]; then echo " MISSING: $file_rel" >&2 ((failed++)) continue fi local actual_hash actual_hash="$(sha256sum "$file_abs" | awk '{print $1}')" if [[ "$actual_hash" != "$expected_hash" ]]; then echo " MISMATCH: $file_rel" >&2 echo " expected: $expected_hash" >&2 echo " actual: $actual_hash" >&2 ((failed++)) else echo " OK: $file_rel" fi done < "$CHECKSUMS" ``` ### Technical Analysis The baseline-generation process includes only files ending in `.sh`. It does not cover Python, JavaScript, service definitions, configuration files, or other payloads that a downstream deployment script may execute, install, or copy. The generator also silently skips a dependency whose `scripts` directory is absent. The verifier only checks entries already present in the manifest; it does not compare the manifest against an authoritative list ...[truncated 1430 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Ship a reviewed, immutable checksum manifest with the Skill rather than relying solely on a locally generated baseline. - Define an authoritative inventory of every required downstream file. - Reject missing files, unexpected files, duplicate manifest entries, malformed hashes, and unsafe paths. - Hash all executable and deployment-consumed content, including Python, JavaScript, service units, hooks, templates, and configuration files. - Require all three downstream skills and their expected entry points to be represented in the manifest. - Verify each dependency immediately before executing it to reduce time-of-check/time-of-use exposure. - Prefer signed release manifests or publisher signatures tied to immutable package versions. - Treat `rehash.sh` only as an explicit trust-administration operation and clearly warn that it does not establish provenance by itself. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:29
Finding
Unpinned Registry Dependencies Are Executed as Trusted Deployment Code<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:29-33`; execution in `scripts/deploy.sh:98-106` **Vulnerability Type**: Unpinned and unauthenticated external dependencies **Risk Level**: Medium ### Vulnerable Code ```bash npx clawhub install faster-whisper-local-service npx clawhub install webchat-https-proxy npx clawhub install webchat-voice-gui ``` The installed dependencies are subsequently executed: ```bash echo "=== [full-stack] Step 1/3: Deploy backend (faster-whisper-local-service) ===" bash "$BACKEND" echo "" echo "=== [full-stack] Step 2/3: Deploy HTTPS proxy (webchat-https-proxy) ===" bash "$PROXY" echo "" echo "=== [full-stack] Step 3/3: Deploy voice GUI (webchat-voice-gui) ===" bash "$GUI" ``` ### Technical Analysis The installation instructions identify dependencies only by package name. They do not pin immutable versions, content digests, publisher identities, or signed release metadata. The local rehash workflow records the contents obtained from the registry after installation. It can detect later modification of recorded files, but it cannot prove that the initially downloaded version was legitimate. If a registry entry or publisher account is compromised before installation, a user can create a checksum baseline for malicious content and subsequently execute it as trusted code. The delegated dependencies perform security-sensitive operations such as installing services, changing gateway configuration, injecting UI assets, and exposing an HTTPS/WSS proxy. Their integrity and provenance are therefore material to the security of this Skill. ### Attack Path 1. An attacker compromises a downstream package, publisher account, registry entry, or mutable release. 2. A user follows the documented unversioned `npx clawhub install` commands. 3. The registry supplies the attacker-controlled release. 4. The user runs `rehash.sh`, which records hashes for the content already received and therefore treats it as the trusted baseline ...[truncated 723 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin each downstream skill to an immutable, reviewed version. - Publish trusted content hashes with this meta-skill instead of deriving trust from whatever content was downloaded. - Verify registry publisher identity, package signatures, and provenance metadata before installation. - Fail closed if an exact expected release cannot be obtained or authenticated. - Consider vendoring reviewed dependency code when reproducible signed packages are unavailable. - Document a controlled upgrade process that reviews changes and updates pinned versions and trusted hashes through code review. - Apply least-privilege execution controls to downstream installers and isolate deployment where feasible. ]]>

T08 · Insecure Dependencies

Warning
Location
scripts/status.sh:9
Finding
Status Command Executes Unverified Dependency-Controlled Scripts<![CDATA[ ## Vulnerability Details **File Location**: `scripts/status.sh:9-29` **Vulnerability Type**: Unverified third-party script execution **Risk Level**: Medium ### Vulnerable Code ```bash echo "=== [full-stack] Backend status ===" if [[ -f "$BACKEND_STATUS" ]]; then bash "$BACKEND_STATUS" else echo " faster-whisper-local-service not installed." fi echo "" echo "=== [full-stack] HTTPS Proxy status ===" if [[ -f "$PROXY_STATUS" ]]; then bash "$PROXY_STATUS" else echo " webchat-https-proxy not installed." fi echo "" echo "=== [full-stack] Voice GUI status ===" if [[ -f "$GUI_STATUS" ]]; then bash "$GUI_STATUS" else echo " webchat-voice-gui not installed." fi ``` ### Technical Analysis The status wrapper executes three scripts located in dependency-controlled directories without applying the integrity-verification routine used by `deploy.sh`. A file-existence check provides no authenticity or integrity protection. This is especially risky because users generally expect a status command to be observational and low risk. Modification of a downstream `status.sh` after installation provides an execution path that bypasses the project’s advertised checksum controls entirely. ### Attack Path 1. An attacker or compromised process gains the ability to modify a downstream skill directory. 2. The attacker replaces one of the downstream `scripts/status.sh` files with malicious shell commands. 3. The user invokes `bash scripts/status.sh` to inspect deployment health. 4. The wrapper checks only that the modified file exists. 5. The malicious script executes through `bash` without checksum or provenance validation. ### Impact Assessment The injected script executes with all privileges of the user running the status command. It can read or modify user-accessible data, inspect environment variables, change OpenClaw configuration, replace Skill files, or establish user-level persistence. No direct root escalation is demonstrated, but the command can c ...[truncated 59 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Verify each downstream status script against a strict trusted manifest immediately before execution. - Reuse a common verification function across deployment, status, uninstall, and maintenance entry points. - Prefer implementing status checks directly in this wrapper using fixed commands rather than executing dependency-provided code. - Reject unlisted, missing, modified, or symlinked entry points. - Resolve and validate canonical paths to ensure scripts remain inside the expected skills directory. - Run observational status checks with a sanitized environment and the minimum permissions available. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (10)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# 3. STT Backend (service, venv)
systemctl --user stop openclaw-transcribe.service
systemctl --user disable openclaw-transcribe.service
rm -f ~/.config/systemd/user/openclaw-transcribe.service
systemctl --user daemon-reload
```
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Rp1

Medium
Category
MCP Rug Pull
Confidence
91% confidence
Finding
The skill instructs users to run `npx clawhub install ...` without pinning a specific package version. This creates a supply-chain risk because the fetched package can change over time or be replaced upstream, causing users to install unreviewed code despite the later checksum step only applying after installation.

Rp1

Medium
Category
MCP Rug Pull
Confidence
91% confidence
Finding
This line repeats the use of unpinned `npx clawhub install` for a sub-skill dependency. An attacker controlling or compromising the registry or package publisher could deliver altered code before any local checksum baseline is established.

Rp1

Medium
Category
MCP Rug Pull
Confidence
91% confidence
Finding
The third prerequisite install command also relies on unpinned `npx clawhub`, exposing users to the same mutable upstream dependency risk. In a meta-installer that chains multiple skills, this broadens the attack surface because compromise of any fetched component can affect the final deployment.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
Safety characteristics:
- all changes are documented and reversible via uninstall scripts
- no root/sudo required (user scope only)
- no hidden background tasks beyond documented services
- no outbound telemetry or data exfiltration behavior
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Rp1

Medium
Category
MCP Rug Pull
Confidence
88% confidence
Finding
The workflow again tells users to fetch sub-skills using unpinned `npx clawhub install <sub-skill>`. Although the skill describes a checksum verification process afterward, that mechanism does not protect the initial retrieval step and can normalize trusting whatever was first downloaded.

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
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
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.

Scope Creep

Low
Category
Excessive Agency
Content
Safety characteristics:
- all changes are documented and reversible via uninstall scripts
- no root/sudo required (user scope only)
- no hidden background tasks beyond documented services
- no outbound telemetry or data exfiltration behavior

### Integrity verification
Confidence
70% confidence
Finding
Skill's behavior or capabilities extend beyond its stated purpose. Scope creep allows an agent to perform actions unrelated to its documented functionality, increasing the attack surface.

Static analysis

No suspicious patterns detected.