Back to skill

Security audit

台灣即時停車查詢

Security checks for vulnerabilities and agentic risk

Overview

This Taiwan parking lookup skill is purpose-matched overall, but it needs Review because it includes an unverified self-updater and unsafe URL/command handling that can exceed normal parking-query behavior.

Review this skill carefully before installing. Do not run update.sh unless you trust the remote repository and have checked the exact code being installed. Prefer pinning dependencies, hardening or disabling token caching, and restricting map URL inputs to known Google Maps hosts before using it with untrusted messages or shared systems.

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

T03 · Remote Payload Retrieval and Execution

Error
Location
update.sh:7
Finding

Mutable Remote Code Replacement Through Unverified Self-Update

Content
View full analysis
/dev/null | awk '{print $3}') if [ -z "$REMOTE_VER" ]; then echo "[parking_query] ⚠️ 無法取得遠端版本,跳過" exit 0 fi if [ "$LOCAL_VER" = "$REMOTE_VER" ]; then echo "[parking_query] ✅ 已是最新版($LOCAL_VER)" exit 0 fi echo "[parking_query] 發現新版本:$LOCAL_VER → $REMOTE_VER,開始更新..." curl -sf "$REPO_URL/raw/main/parking_query.py" -o "$CURRENT.tmp" && \ mv "$CURRENT.tmp" "$CURRENT" && \ curl -sf "$REPO_URL/raw/main/skill.yml" -o "$SKILL_DIR/skill.yml.tmp" && \ mv "$SKILL_DIR/skill.yml.tmp" "$SKILL_DIR/skill.yml" ``` ### Technical Analysis The updater downloads executable Python code and configuration from the mutable `main` branch of an external personal GitHub repository. It then replaces the locally reviewed `parking_query.py` and `skill.yml` files without verifying a digital signature, cryptographic digest, immutable commit identifier, or trusted release provenance. The version value does not provide integrity protection because it is extracted from the same attacker-controlled remote file. An attacker can change both the version declaration and the payload. Although the script itself does not install a scheduled task, its comments explicitly contemplate invocation by a weekly maintenance cron job, which could increase exposure if configured externally. ### Attack Path 1. An attacker compromises the GitHub account, repository, publishing token, or another mechanism capable of modifying ...[truncated 1086 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
skill.yml:31
Finding

Potential Shell Command Injection Through Skill Parameter Interpolation

Content
View full analysis
python3 ~/.openclaw/skills/parking_query/parking_query.py --mode ${mode} --lat "${lat}" --lon "${lon}" --url "${url}" ``` ### Technical Analysis The command template embeds user-controlled Skill parameters into a command string. In particular, `url` is an unrestricted string and is placed inside double quotes. Double quotes alone are not a safe shell-escaping mechanism: a value containing a quote can terminate the argument and introduce shell operators or command substitutions. Exploitation depends on the OpenClaw command runner executing the expanded `run` value through a shell. If it does, malicious input can escape the intended argument and become shell syntax. The schema's numeric types reduce exposure for `lat` and `lon`, and `mode` is enum-restricted, but no equivalent structural restriction protects `url`. ### Attack Path 1. An attacker submits a crafted value for the `url` parameter containing a closing quote followed by shell syntax. 2. OpenClaw interpolates the value into the `run` command. 3. If the runner invokes a shell, the injected quote terminates the `--url` argument. 4. The remaining input is parsed as shell operators and commands. 5. The injected command executes with the privileges of the OpenClaw gateway user. ### Impact Assessment Successful exploitation could permit arbitrary command execution in the gateway user's security context. The attacker could access files and environment variables available to that user, steal API credentials, modify Skills or configuration, invoke network tools, or establish user-level persistence. Passing a URL to the Python program is necessary for the declared feature, but passing it through a shell command string is not. This behavior therefore violates least-risk execution design. ]]>
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
parking_query.py:126
Finding

Server-Side Request Forgery Through Weak Google Maps URL Validation

Content
View full analysis
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
parking_query.py:75
Finding

Bearer Token Stored in Predictable Cache Without Explicit Permission Hardening

Content
View full analysis
time.time() + 30: return cached["access_token"] r = requests.post(AUTH_URL, data={ "grant_type": "client_credentials", "client_id": client_id, "client_secret": client_secret, }, timeout=10) r.raise_for_status() resp = r.json() cache = {"access_token": resp["access_token"], "expires_at": time.time() + resp.get("expires_in", 3600)} TOKEN_CACHE.write_text(json.dumps(cache)) return resp["access_token"] ``` ### Technical Analysis The TDX bearer token is written in plaintext to the predictable path `~/.openclaw/.tdx_token_cache` through `Path.write_text()`. The code does not explicitly enforce mode `0600`, verify that the path is a regular file owned by the current user, reject symbolic links, or perform an atomic protected write. The resulting permissions depend on the process umask and pre-existing filesystem state. Under a permissive configuration, another local user may be able to read the token. A maliciously prepared filesystem object at the predictable path could also interfere with reads or redirect writes. Caching is useful for avoiding unnecessary authentication calls, but storing a bearer credential does not require broad or process-default filesystem access. ### Attack Path 1. A local attacker gains access to the same host and identifies the predictable cache path. 2. If permissions are permissive, the attacker reads the cached bearer token directly. 3. Alternatively, where filesystem permissions allow it, the attacker prepares or replaces the cache path with a symbolic link or other unexpected filesystem object. 4. The Skill follows the path during token reads or writes. 5 ...[truncated 625 chars]
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding

Unpinned Third-Party Dependency Produces a Non-Reproducible Supply Chain

Content
View full analysis
=2.28.0 ``` ### Technical Analysis The dependency specification accepts any future `requests` release at or above version 2.28.0. It does not provide an exact reviewed version, an upper bound, a lock file, or cryptographic hashes. Consequently, installations performed at different times can resolve to different package contents and transitive dependency versions. No evidence in the reviewed project shows that the current `requests` package is malicious. The risk arises from allowing future, unreviewed supply-chain content to enter the execution environment automatically. The documentation further recommends `pip3 install requests`, which has the same reproducibility limitation. ### Attack Path 1. A user installs the Skill's dependencies at a later time. 2. The package resolver selects a newer release satisfying `requests>=2.28.0`, along with mutable transitive dependencies. 3. If a selected release or package source is compromised, malicious or unsafe code is installed. 4. Package installation hooks or imported runtime code execute in the user's Python environment. ### Impact Assessment A compromised dependency can execute with the privileges of the user performing installation or running the Skill. It may access environment variables, local files, TDX credentials, network resources, and other Python packages available in that environment. The Skill legitimately requires an HTTP client, but it does not require accepting arbitrary future dependency releases without review or integrity verification. ]]>
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (14)

Tainted flow: 'client_id' from os.getenv (line 59, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Confidence
90% confidence
Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · parking_query.py (reported line 69)May include surrounding context.

python
if cached.get("expires_at", 0) > time.time() + 30:
            return cached["access_token"]

    r = requests.post(AUTH_URL, data={
        "grant_type": "client_credentials",
        "client_id": client_id,
        "client_secret": client_secret,

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

A parking lookup skill should not need to download code from GitHub, overwrite local skill files, or run an auto-update workflow. Hidden self-update behavior creates a supply-chain and remote code execution risk, because an attacker controlling the remote source or update path could replace the installed skill with arbitrary code without clear user consent.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The README explicitly instructs users to send precise location data or Google Maps links so the skill can query nearby parking, and it documents calls to external TDX services, but it does not warn users that their location data may be transmitted to third-party services or retained in logs. Because location data is sensitive, missing disclosure and consent guidance increases privacy risk and can lead to unintended sharing of a user's movements or destination.

Content

No source excerpt is available for this finding.

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
79% confidence
Finding

The skill declares no explicit tool scope even though its documented usage and detected capabilities imply access to environment variables, local files, network, and shell execution. In an agent environment, missing permission boundaries increases the blast radius if the skill is misused or later modified, because the runtime may grant broader access than users expect.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill processes precise location data and Google Maps URLs but does not clearly disclose that this information will be sent to third-party services such as TDX and potentially mapping providers. This is dangerous because users may unknowingly expose sensitive travel patterns or home/work locations, creating a privacy and compliance risk.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

The skill caches an access token on disk under the user's home directory without setting restrictive permissions, encryption, or disclosing this behavior. On shared systems or permissive umasks, another local user or process could read the cached bearer token and reuse it until expiry.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The skill performs a network request to a user-supplied URL and follows redirects, which can leak the runner's IP address and be abused for SSRF-style access to arbitrary hosts if an attacker supplies a crafted URL containing 'goo.gl' or 'maps.app' in the string. The context makes this more relevant because the skill explicitly accepts map URLs from chat platforms, so untrusted input is expected.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The user-facing description and command metadata are entirely written in Traditional Chinese, which imposes a specific language/locale on users without any opt-in or alternative language path. The file does not state that the skill is intended only for a Taiwan-specific audience as a documented language policy exception, even though the data source is Taiwan-focused.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The script downloads executable skill code and metadata from a remote repository and overwrites the local installed files without any integrity verification, signature checking, or pinned commit/version source. If the GitHub repo, account, branch, or network path is compromised, arbitrary code can be delivered on the next update and later executed by the skill runtime.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The script silently replaces local skill files from a remote source with no user warning, approval, or audit control. Even if intended for maintenance convenience, this creates an unsafe trust boundary because code changes can be introduced outside normal review/deployment processes and may surprise operators.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
90% confidence
Finding

The natural-language instructions and usage documentation are presented only in Traditional Chinese, which can impose a language requirement on users without offering alternatives. The policy allows locale constraints when clearly documented and justified, but this file does not state that the skill is intentionally limited to Chinese-speaking users or provide a language choice.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
86% confidence
Finding

The skill name, description, and all usage instructions are presented only in Traditional Chinese and the functionality is scoped to Taiwan, but the document does not indicate that this locale/language limitation is optional or user-selectable. Under the stated policy, forcing a specific language or locale without opt-in can be a natural-language policy violation.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
95% confidence
Finding

The dependency is specified as requests>=2.28.0, which allows any newer version to be installed and makes builds non-reproducible. This can unintentionally pull in a vulnerable or breaking release later, and in a network-facing skill that processes user-supplied locations/URLs, that increases supply-chain and stability risk.

Content

Scanner excerpt · requirements.txt (reported line 1)May include surrounding context.

text
requests>=2.28.0

Unverifiable Dependency: requests has 16 known advisory(ies) (CVE-2014-1830 (Exposure of Sensitive Information to an Unauthorized Actor in Requests); CVE-2024-47081 (Requests vulnerable to .netrc credentials leak via malicious URLs); CVE-2024-35195 (Requests `Session` object does not verify requests after making first request wi) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
91% confidence
Finding

Because requests is not pinned, it is impossible to verify whether the installed version includes fixes for known advisories affecting this package. In a skill that likely fetches remote resources and may handle user-provided Google Maps URLs, using an affected requests release could expose the skill to credential leakage, TLS/redirect issues, or other client-side request handling flaws depending on the resolved version.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.