Back to skill

Security audit

Traditional Chinese Dictionary

Security checks for vulnerabilities and agentic risk

Overview

This skill is a disclosed Traditional Chinese dictionary lookup/update tool that downloads public MOE dictionary data into a local user directory, with manageable supply-chain and download-safety caveats.

Reasonable to install if you want a Taiwan MOE Traditional Chinese dictionary skill. Before use, consider pinning dependencies or installing from a locked environment, and be aware that manual or cron updates download ZIP files from MOE and store extracted data in ~/.openclaw/dictionaries or your configured storage path.

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

Warning
Location
requirements.txt:4
Finding
Unpinned Third-Party Dependencies Create a Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:4-5` **Vulnerability Type**: Unpinned dependencies without integrity verification **Risk Level**: Medium ### Vulnerable Code ```text pandas>=2.0.0 openpyxl>=3.1.0 ``` The documented installation commands in `SKILL.md:12-17` and `README.md:29-36` install these dependencies directly from the user's configured Python package index: ```bash uv pip install -r requirements.txt # Alternative pip install -r requirements.txt ``` ### Technical Analysis Both dependencies use lower-bound-only version constraints. Consequently, the package resolver may install any current or future release satisfying the minimum version. The project provides neither a reviewed lockfile nor package hashes, so installations are not reproducible and package integrity is not independently verified. This does not establish that `pandas` or `openpyxl` is currently malicious. The weakness is that a future compromised release, compromised package index, or maliciously configured index could supply code that differs from what was reviewed during this audit. Python packages may execute build or installation logic, and imported dependencies subsequently execute with the privileges of the user running the Skill. ### Attack Path 1. An attacker compromises a permitted dependency release or the package source configured on the victim's system. 2. The attacker publishes or serves a malicious version that still satisfies `pandas>=2.0.0` or `openpyxl>=3.1.0`. 3. A user follows the documented `pip` or `uv pip` installation command. 4. The resolver selects the attacker-controlled version because no exact version or trusted hash is required. 5. Malicious installation, import-time, or runtime code executes with the installing or invoking user's privileges. ### Impact Assessment Successful exploitation could execute arbitrary code under the affected user's account. Depending on that account's permissions, an attacker could read or ...[truncated 281 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin all direct dependencies to exact, reviewed versions rather than using open-ended lower bounds. 2. Generate and commit a reproducible lockfile containing transitive dependencies. 3. Record and enforce cryptographic hashes for every distributable package, such as through a hash-locked requirements file and `pip --require-hashes`. 4. Configure installation to use a trusted package index explicitly and disallow unexpected extra indexes. 5. Automate dependency vulnerability monitoring, but update pinned versions only after review and testing. 6. Prefer prebuilt, hash-verified wheels from trusted publishers and avoid source builds where practical. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/download_dictionary.py:164
Finding
Remote ZIP Archives Are Downloaded and Extracted Without Integrity or Resource Limits<![CDATA[ ## Vulnerability Details **File Location**: `scripts/download_dictionary.py:164-190` **Vulnerability Type**: Unbounded download and archive extraction **Risk Level**: Medium ### Vulnerable Code ```python # Download zip with proper SSL verification with urllib.request.urlopen(download_url, timeout=30) as response: with open(tmp_path, 'wb') as f: shutil.copyfileobj(response, f) logger.info(f"Downloaded {os.path.getsize(tmp_path)} bytes") # Extract to storage with zip-slip protection extract_path = self.storage_path / extract_folder extract_path.mkdir(parents=True, exist_ok=True) # Securely extract zip file, validating all paths with zipfile.ZipFile(tmp_path, 'r') as zip_ref: # Validate all members before extraction for member in zip_ref.namelist(): if not validate_zip_path(member, extract_path): raise ValueError(f"Zip file contains unsafe path: {member}") logger.info(f"Zip contains: {zip_ref.namelist()}") zip_ref.extractall(extract_path) ``` ### Technical Analysis The implementation correctly uses default TLS certificate verification and validates archive member paths against directory traversal. However, it places no limit on: - The number of downloaded bytes - Archive member count - Individual uncompressed member size - Total uncompressed archive size - Compression ratio - Extraction duration or available disk space The archive is also not verified against a publisher signature or a separately trusted cryptographic digest. TLS protects transport to the authenticated endpoint, but it does not provide release-level integrity if the upstream server or published artifact is compromised. Calling `extractall()` after path validation permits a malicious or malformed ZIP archive to expand until available resources are exhausted. The downloader also creates the final extraction directory before archive processing and does not remove partially extracted content after failure. ### Attack Path 1. An atta ...[truncated 1216 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Stream downloads in fixed-size chunks while tracking the cumulative byte count, and abort when a strict maximum archive size is exceeded. 2. Before extraction, inspect every `ZipInfo` entry and reject archives exceeding configured limits for: - Member count - Per-member uncompressed size - Aggregate uncompressed size - Compression ratio 3. Extract entries individually only after all archive-wide checks pass instead of calling unrestricted `extractall()`. 4. Verify a publisher-provided digital signature or a cryptographic checksum obtained through a separately trusted channel before opening the archive. 5. Extract into a new temporary directory on the same filesystem, validate the expected XLSX file and schema, and atomically rename the directory into place only after all checks succeed. 6. Delete temporary downloads and partial extraction directories on every failure path. 7. Apply reasonable file permissions and confirm sufficient free disk space before extraction. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (12)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The skill claims a specific trusted source and dataset scope, but the documentation alone does not prove the code enforces those constraints. If source URLs or dictionary types are configurable without strict validation, the skill could fetch unexpected remote content under the guise of a trusted dictionary updater, expanding supply-chain risk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill claims a specific trusted source and dataset scope, but the documentation alone does not prove the code enforces those constraints. If source URLs or dictionary types are configurable without strict validation, the skill could fetch unexpected remote content under the guise of a trusted dictionary updater, expanding supply-chain risk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The skill claims a specific trusted source and dataset scope, but the documentation alone does not prove the code enforces those constraints. If source URLs or dictionary types are configurable without strict validation, the skill could fetch unexpected remote content under the guise of a trusted dictionary updater, expanding supply-chain risk.

Credential Access

High
Category
Privilege Escalation
Content
Validate that a zip member path does not escape the target directory.
    
    Prevents zip-slip attacks where a zip file contains paths like:
    - ../../../etc/passwd
    - /absolute/path/file
    
    Args:
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Lp3

Medium
Category
MCP Least Privilege
Confidence
88% confidence
Finding
The skill advertises network access and file-writing behavior in its documentation, but it does not declare an explicit tool scope such as permissions or allowed-tools. That creates a least-privilege and transparency problem: an agent or reviewer cannot easily tell what capabilities are intended, increasing the chance of unintended network fetches or filesystem modifications during use.

Natural-Language Policy Violations

Medium
Confidence
90% confidence
Finding
The usage examples and response guidance are entirely in Traditional Chinese and instruct the skill to answer dictionary queries in that locale, but the file does not state that this is an opt-in or region-specific language constraint. Under the language/locale policy, forcing a specific language without user choice can be a natural-language policy violation.

Natural-Language Policy Violations

Low
Confidence
83% confidence
Finding
The README explicitly highlights Traditional Chinese usage, and the usage examples are entirely in Traditional Chinese. For an all-file-types language policy check, this can be a locale/language constraint without user opt-in, and the README does not clearly state that the skill is intentionally region-specific or offer alternatives.

Natural-Language Policy Violations

Low
Confidence
78% confidence
Finding
The text states that pronunciation uses 'Zhuyin (ㄅㄆㄇ) notation (Taiwan standard)', which imposes a locale-specific linguistic convention in natural language. Because the document does not explicitly frame this as a Taiwan-specific schema constraint or offer alternatives, it can be read as a forced locale choice.

Unpinned Dependencies

Low
Category
Supply Chain
Content
# openclaw-tc-dict-skill dependencies
# Install with: uv pip install -r requirements.txt

pandas>=2.0.0
openpyxl>=3.1.0
Confidence
97% confidence
Finding
The dependency is specified with only a lower bound (pandas>=2.0.0), which makes builds non-reproducible and allows future upstream releases to be pulled in without review. This increases supply-chain risk and also prevents verifying whether a resolved version is affected by known vulnerabilities.

Unverifiable Dependency: pandas has 1 known advisory(ies) (CVE-2020-13091 (** DISPUTED ** pandas through 1.0.3 can unserialize and execute commands from an)), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
40% confidence
Finding
Dependency has known vulnerabilities (CVEs). Using packages with unpatched security flaws exposes the environment to known exploits.

Unpinned Dependencies

Low
Category
Supply Chain
Content
# Install with: uv pip install -r requirements.txt

pandas>=2.0.0
openpyxl>=3.1.0
Confidence
97% confidence
Finding
The dependency is specified as openpyxl>=3.1.0 rather than an exact version, so installations may resolve to different releases over time. That weakens reproducibility and can silently introduce vulnerable or incompatible versions through normal dependency installation.

Unverifiable Dependency: openpyxl has 2 known advisory(ies) (CVE-2017-5992 (Improper Restriction of XML External Entity Reference in Openpyxl); CVE-2017-5992 (Openpyxl 2.4.1 resolves external entities by default, which allows remote attack)), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
40% confidence
Finding
Dependency has known vulnerabilities (CVEs). Using packages with unpatched security flaws exposes the environment to known exploits.

Static analysis

No suspicious patterns detected.