Back to skill

Security audit

quicker-connector

Security checks for vulnerabilities and agentic risk

Overview

This appears to be a real Quicker integration skill, but it needs Review because it can execute local and remote automation with unsafe defaults and inaccurate security disclosures.

Review carefully before installing. Use only with a trusted Quicker action catalog, disable or avoid automatic execution, do not configure push_user/push_code unless you accept remote transmission to Quicker's push service, and avoid passing untrusted action IDs or parameters until shell invocation and confirmation handling are fixed.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/quicker_connector.py:570
Finding
Windows Command Injection Through shell=True<![CDATA[ ## Vulnerability Details **File Location**: `scripts/quicker_connector.py:570-620` **Vulnerability Type**: OS command injection **Risk Level**: High ### Vulnerable Code ```python cmd = [self.starter_path] if wait_for_result: cmd.append(f"-c{timeout}") if action_identifier.startswith('quicker:'): action_cmd = action_identifier else: action_cmd = f"runaction:{action_identifier}" if parameters: action_cmd = f"{action_cmd}?{parameters}" cmd.append(action_cmd) if wait_for_result: process = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding='utf-8', shell=True ) else: subprocess.Popen( cmd, shell=True, creationflags=subprocess.DETACHED_PROCESS ) ``` ### Technical Analysis `action_identifier` and `parameters` are incorporated into a command passed to `subprocess.Popen` with `shell=True`. On Windows, this causes the command to be processed through the command shell. Shell metacharacters contained in either value may therefore be interpreted as command separators or redirection operators rather than as literal Quicker arguments. Although the normal CLI path usually selects an action ID from a local CSV or database, the public methods `execute_action`, `run_action`, `run_by_id`, and `run_by_name` accept caller-controlled strings directly. The code does not implement the argument validation claimed by the Skill documentation. The executable path check does not prevent this vulnerability. Verifying that `self.starter_path` points to an existing `QuickerStarter.exe` does not stop the shell from interpreting additional commands embedded in later arguments. ### Attack Path 1. An untrusted caller, agent instruction, integration, or imported Python module obtains access to `QuickerConnector.execute_action` or `QuickerActionRunner.run_action`. 2. The caller supplies an action identifier or parameter containing Win ...[truncated 750 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Set `shell=False`, which is already the default, and continue passing arguments as a list. - Reject action identifiers that do not match an explicit Quicker ID or URI grammar. - Validate parameter names and values separately instead of concatenating a query string manually. - Resolve and compare the executable path against an explicit allowlist using canonical paths. - Do not permit arbitrary action names, URIs, or parameters to reach the process boundary without validation. - Add regression tests containing Windows shell metacharacters such as `&`, `|`, `<`, `>`, `%`, `^`, and line breaks. - Consider using an official Quicker API or IPC interface that does not involve a command shell. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/init_quicker.py:121
Finding
Quicker Push Credentials Stored in Plaintext Configuration<![CDATA[ ## Vulnerability Details **File Location**: `scripts/init_quicker.py:121-188` **Vulnerability Type**: Plaintext credential storage and insecure secret input **Risk Level**: Medium ### Vulnerable Code ```python push_user = input("Quicker account email: ").strip() push_code = input("Push verification code: ").strip() if not push_user or not push_code: return {} return {"push_user": push_user, "push_code": push_code} ``` The resulting values are persisted by the following logic: ```python if extra: config.update(extra) parent = os.path.dirname(config_file) if parent: os.makedirs(parent, exist_ok=True) with open(config_file, 'w', encoding='utf-8') as f: json.dump(config, f, indent=2, ensure_ascii=False) ``` ### Technical Analysis The initialization flow collects an account email and push verification code and stores both directly in `config.json`. No operating-system credential store, encryption, restrictive file permissions, or secret-file separation is used. The verification code is also collected with `input`, so it is displayed on the terminal while being entered. The documentation incorrectly claims that the configuration file contains only paths and no sensitive information. The secret is subsequently read by `get_config()` and used as a reusable credential by `QuickerPushRunner`. ### Attack Path 1. A user enables remote push execution during initialization. 2. The account email and verification code are written to the Skill directory in `config.json`. 3. Another local process, user, backup service, diagnostic bundle, or accidentally published package reads the file. 4. The exposed verification code is reused against the Quicker push service to attempt actions for the affected account. ### Impact Assessment Exposure may permit unauthorized remote triggering of Quicker actions, depending on Quicker's server-side credential scope and safeguards. It also discloses the user's account email. The practical scope includes a ...[truncated 244 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Store the verification code in Windows Credential Manager or another operating-system secret store. - Keep non-sensitive paths and sensitive credentials in separate storage. - Use `getpass.getpass()` rather than `input()` for secret entry. - If a fallback secret file is unavoidable, create it with access restricted to the current user and verify its permissions before use. - Ensure `config.json` is excluded from source packages, logs, backups, and diagnostic exports. - Never print the credential, even in masked form alongside identifying account details. - Document credential scope, transmission destination, revocation instructions, and rotation procedures. - Support environment-variable or runtime secret injection for managed deployments. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/quicker_connector.py:655
Finding
Outbound Credential Transmission Contradicts Declared Network Permissions<![CDATA[ ## Vulnerability Details **File Location**: `scripts/quicker_connector.py:655-757` **Vulnerability Type**: Undeclared network access and sensitive-data transmission **Risk Level**: Medium ### Vulnerable Code ```python PUSH_API_URL = "https://push.getquicker.cn/to/quicker" payload = { "toUser": self.user, "code": self.code, "operation": "action", "action": action, "wait": wait, } if data: payload["data"] = data body = json.dumps(payload, ensure_ascii=False).encode("utf-8") req = urllib.request.Request( PUSH_API_URL, data=body, headers={"Content-Type": "application/json; charset=utf-8"}, method="POST" ) with urllib.request.urlopen(req, timeout=timeout) as resp: raw = resp.read().decode("utf-8") ``` The behavior conflicts with the published permission declaration: ```json "network": false ``` That declaration appears in `skill.json:346`, `skill_optimized.json:346`, and `clawhub-manifest.json:288`. `SKILL.md:109-111` and `SKILL.md:308-311` also state that the Skill has no network access, transmits no user data, and stores no sensitive information. ### Technical Analysis The implementation performs an HTTPS POST containing: - The user's Quicker account email. - A reusable push verification code. - The action name or ID. - Optional caller-supplied action data. - Whether the service should wait for a result. Remote push can be a legitimate optional feature, and the initialization prompt gives the user a basic description of it. However, the runtime behavior is inconsistent with the Skill's formal permission metadata and security documentation. If network declarations are advisory rather than enforced, users and reviewers may approve the Skill under the incorrect assumption that it cannot make outbound requests. If permissions are enforced, the feature will fail unpredictably. There is also no explicit destination allowlist represented in the manifest and no clear warning that arbitrary action data ma ...[truncated 1134 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Either remove the remote push feature or declare network access accurately in every manifest. - If retained, restrict network access to the exact HTTPS origin `https://push.getquicker.cn`. - Make the network permission optional and disabled by default. - Obtain explicit user consent immediately before first transmission and explain every transmitted field. - Update all security documentation to state that credentials and action data are sent to Quicker's service. - Prevent sensitive action data from being sent unless the user explicitly approves it. - Add certificate-validation and response-size expectations, and avoid exposing full remote response bodies in error messages. - Reconcile `skill.json`, `skill_optimized.json`, `clawhub-manifest.json`, `SKILL.md`, and `SKILL_OPTIMIZED.md` so they describe the same behavior. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/quicker_skill.py:58
Finding
Ambiguous Natural-Language Matches Are Automatically Executed Without Confirmation<![CDATA[ ## Vulnerability Details **File Location**: `scripts/quicker_skill.py:58-142` **Vulnerability Type**: Unsafe automatic execution of local automation actions **Risk Level**: High ### Vulnerable Code ```python matches = self.connector.match_actions(user_need, top_n=5) if not matches: return f"No action was found for '{user_need}'" selected_action = self._select_action(matches) if not selected_action: return "Operation cancelled" result = self.connector.execute_action(selected_action.id) ``` The selector executes the top result even when the documented confidence threshold is not met: ```python if len(matches) == 1 and matches[0]['score'] > 0.8: return matches[0]['action'] return matches[0]['action'] ``` ### Technical Analysis The Skill documentation states that low-confidence or ambiguous matches should require confirmation. The implementation does not follow that rule. `_select_action` always returns the highest-scoring result whenever at least one match exists. The matcher is based on basic substring and keyword scoring. It does not establish that the selected action is safe, read-only, reversible, or consistent with the user's exact intent. Quicker actions may perform broad desktop automation, including launching programs, manipulating files, sending keystrokes, accessing clipboard data, or initiating network activity. The `auto_select_threshold` setting documented in `SKILL.md` and stored in `config.json` is not consulted by this execution path. ### Attack Path 1. A user or untrusted message causes the Skill to process a request containing the trigger word. 2. The keyword matcher produces one or more approximate action candidates. 3. Even if the candidates are ambiguous or have low scores, `_select_action` chooses the first result. 4. The selected action ID is passed to `QuickerStarter.exe`. 5. The local Quicker action runs without an explicit user confirmation step. 6. If the incorrectly selected action is destructive or ...[truncated 519 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Require explicit confirmation before executing every action by default. - At minimum, require confirmation for ambiguous, low-confidence, destructive, privacy-sensitive, or parameterized actions. - Read and enforce `auto_select_threshold`; do not merely document it. - Present the selected action name, description, ID, parameters, and expected effects before execution. - Maintain a denylist or risk classification for actions involving deletion, command execution, credentials, clipboard access, messages, or external network access. - Separate search and recommendation from execution so a natural-language match does not itself authorize side effects. - Add a non-interactive policy requiring a separately authenticated approval token. - Log action selection and user approval without logging sensitive action parameters. ]]>

T03 · Remote Payload Retrieval and Execution

Warning
Location
README_EN.md:27
Finding
Release Archive Is Installed Without Integrity or Authenticity Verification<![CDATA[ ## Vulnerability Details **File Location**: `README_EN.md:27-41` **Vulnerability Type**: Unverified remote Skill package installation **Risk Level**: Medium ### Vulnerable Code ```bash wget https://github.com/awamwang/quicker-connector/releases/download/v1.2.0/quicker-connector-1.2.0.tar.gz tar -xzf quicker-connector-1.2.0.tar.gz cp -r quicker-connector/* ~/.openclaw/workspace/skills/quicker-connector/ openclaw gateway restart ``` Equivalent instructions are present in `README.md:27-41`. ### Technical Analysis The recommended installation method downloads a release archive from a personal GitHub repository, extracts it, copies its contents into the active OpenClaw Skill directory, and restarts the gateway. No cryptographic checksum, signature, provenance attestation, or package-content verification is performed. The archive is not piped directly into a shell, so this is not an immediate `curl | bash` pattern. Nevertheless, restarting the gateway after installation creates an execution path for whatever Skill code is present in the downloaded archive. Pinning the URL to version `v1.2.0` does not provide integrity if the release asset, repository account, or hosting workflow is compromised or the asset is replaced. ### Attack Path 1. An attacker compromises the repository owner account, release workflow, or release asset. 2. The attacker replaces the archive at the documented URL with a modified Skill package. 3. A user follows the recommended `wget` command. 4. The archive is extracted without checking a trusted digest or signature. 5. Its files are copied into the active OpenClaw Skill directory. 6. The user restarts the OpenClaw gateway. 7. The modified Skill is loaded and can execute with the gateway's granted permissions. ### Impact Assessment A compromised archive could replace Skill instructions, manifests, Python scripts, or installation hooks. Resulting impact could include arbitrary code execution under the OpenClaw account, acc ...[truncated 303 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Publish a SHA-256 digest through an independently protected release channel and require users to verify it before extraction. - Prefer signed release artifacts using Sigstore, minisign, GPG, or another verifiable signing system. - Use immutable release assets and protected, reviewed release workflows. - Prefer installation through a registry that validates package provenance and integrity. - Add an inspection step before copying files into the active Skill directory. - Extract into a newly created temporary directory and reject path traversal, symlinks, and unexpected files. - Do not restart the gateway automatically until package verification has succeeded. - Apply the same corrected instructions to both `README.md` and `README_EN.md`. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (61)

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The analyzed behavior appears focused on testing/validation and local JSON export, including writing to `/tmp/quicker_actions_optimized.json`, rather than solely acting as the declared Quicker connector. This mismatch is dangerous because undocumented file writes and non-production code paths can surprise users, leak action metadata, and undermine informed consent about what the skill actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The analyzed behavior appears focused on testing/validation and local JSON export, including writing to `/tmp/quicker_actions_optimized.json`, rather than solely acting as the declared Quicker connector. This mismatch is dangerous because undocumented file writes and non-production code paths can surprise users, leak action metadata, and undermine informed consent about what the skill actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The analyzed behavior appears focused on testing/validation and local JSON export, including writing to `/tmp/quicker_actions_optimized.json`, rather than solely acting as the declared Quicker connector. This mismatch is dangerous because undocumented file writes and non-production code paths can surprise users, leak action metadata, and undermine informed consent about what the skill actually does.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The analyzed behavior appears focused on testing/validation and local JSON export, including writing to `/tmp/quicker_actions_optimized.json`, rather than solely acting as the declared Quicker connector. This mismatch is dangerous because undocumented file writes and non-production code paths can surprise users, leak action metadata, and undermine informed consent about what the skill actually does.

Vague Triggers

High
Confidence
96% confidence
Finding
The trigger phrases are broad enough to match ordinary conversation such as '快速' or generic requests involving '用.*quicker', which raises the chance of accidental invocation. In a skill that can execute local automation actions, accidental triggering can lead to unintended command execution, data modification, or disruptive UI automation without meaningful user intent.

Vague Triggers

High
Confidence
97% confidence
Finding
触发词包含“快速”“快键”等高频、宽泛的日常表达,以及较弱约束的正则,会让技能在与 Quicker 无关的普通对话中被误触发。该技能一旦被激活,不只是读取数据,还具备调用本地 QuickerStarter 执行动作的能力,因此误触发可升级为本地自动化执行风险。

Vague Triggers

High
Confidence
98% confidence
Finding
系统提示明确规定当用户说“用 quicker 做 X”时应映射为调用动作完成任务,但未定义充分的排除条件、敏感操作限制或默认确认机制。这会把宽泛自然语言直接连接到本地自动化执行链路,在存在高分匹配时可能自动执行错误或高风险动作。

Tool Parameter Abuse

High
Category
Tool Misuse
Content
cmd.append(action_cmd)

            if wait_for_result:
                process = subprocess.Popen(
                    cmd,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
Confidence
97% confidence
Finding
This duplicate finding points to the same underlying issue: attacker-influenced parameters are used to invoke an external automation tool. The skill context increases danger because its core feature is executing actions, so lack of input constraints turns intended automation into an arbitrary capability surface.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
cmd.append(action_cmd)

            if wait_for_result:
                process = subprocess.Popen(
                    cmd,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
Confidence
97% confidence
Finding
This duplicate finding points to the same underlying issue: attacker-influenced parameters are used to invoke an external automation tool. The skill context increases danger because its core feature is executing actions, so lack of input constraints turns intended automation into an arbitrary capability surface.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
exit_code=exit_code
                )
            else:
                subprocess.Popen(
                    cmd,
                    shell=True,
                    creationflags=subprocess.DETACHED_PROCESS
Confidence
98% confidence
Finding
This duplicate finding points to the silent detached-launch branch, where untrusted inputs can trigger background automation with minimal observability. That makes it suitable for stealthy misuse and raises the operational impact if an attacker can influence the chosen action or arguments.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
exit_code=exit_code
                )
            else:
                subprocess.Popen(
                    cmd,
                    shell=True,
                    creationflags=subprocess.DETACHED_PROCESS
Confidence
98% confidence
Finding
This duplicate finding points to the silent detached-launch branch, where untrusted inputs can trigger background automation with minimal observability. That makes it suitable for stealthy misuse and raises the operational impact if an attacker can influence the chosen action or arguments.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
The skill is described as a local Quicker connector, but the implementation also includes remote cloud-triggered execution through Quicker's push service. This capability materially expands the trust boundary by transmitting execution requests and credentials over the network, which is more dangerous than the declared local-only automation context suggests.

Context-Inappropriate Capability

High
Confidence
95% confidence
Finding
Outbound network functionality is present for sending actions and data to a remote service, despite the stated purpose focusing on local integration. This creates an unexpected exfiltration and remote-trigger channel that can be abused to run actions on linked Quicker instances or leak sensitive action parameters off-host.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## Key Design Decisions

- **Dual data source**: CSV and DB readers share the same interface; CSV is preferred, DB is fallback
- `auto_select_threshold` (default 0.8) — if top match score ≥ this value, auto-execute without confirmation
- Permissions declared in `skill_optimized.json` restrict subprocess execution to `QuickerStarter.exe` paths and disable network access
Confidence
91% confidence
Finding
The phrase 'auto-execute without confirmation' describes autonomous operation over local executable workflows, not merely passive recommendation. Even with restricted executable paths and no network access, the local impact can still be significant because Quicker actions may alter files, launch programs, or perform other unintended system actions.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## Key Design Decisions

- **Dual data source**: CSV and DB readers share the same interface; CSV is preferred, DB is fallback
- `auto_select_threshold` (default 0.8) — if top match score ≥ this value, auto-execute without confirmation
- Permissions declared in `skill_optimized.json` restrict subprocess execution to `QuickerStarter.exe` paths and disable network access
Confidence
91% confidence
Finding
The phrase 'auto-execute without confirmation' describes autonomous operation over local executable workflows, not merely passive recommendation. Even with restricted executable paths and no network access, the local impact can still be significant because Quicker actions may alter files, launch programs, or perform other unintended system actions.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The documented design explicitly allows automatic execution of a matched Quicker action once a relevance threshold is met, without a confirmation step. Because Quicker actions can trigger local automation with real side effects, a misclassification or adversarial prompt could cause unintended execution of powerful local actions.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The report includes copy-pasteable shell commands that replace live skill files and restart the gateway, but it does not warn about service interruption, rollback planning, or the trust implications of deploying generated artifacts. In a skill ecosystem, operational instructions embedded in documentation can directly influence administrators to make production changes without validation, increasing the chance of accidental outage or deployment of unsafe content.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The README promotes searching and executing Quicker actions, including synchronous/asynchronous execution and parameter passing, but does not warn that these actions can trigger arbitrary local automation with real side effects. In this skill’s context, action execution is the core feature, so missing safety guidance increases the risk that users invoke destructive or privacy-impacting automations without understanding the consequences.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The configuration documents an auto_select_threshold for automatic execution after natural-language matching, but it does not warn that ambiguous AI matching can select the wrong automation and execute it on the local machine. Because this skill is specifically designed to bridge natural-language requests to Windows automation via QuickerStarter, an incorrect match could launch programs, send input, or alter user data without explicit confirmation.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The README explicitly promotes natural-language matching and action execution, including sync/async execution with parameter support, but does not warn that matched actions may trigger real system automation with side effects. In the context of an AI-driven skill that can execute local Quicker actions, lack of clear safety guidance increases the risk of unintended command execution, file/application changes, or other user-environment impacts.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
Documenting an `auto_select_threshold` for automatic execution without a corresponding warning or confirmation requirement normalizes autonomous action runs based on fuzzy matching confidence. Because this skill bridges natural-language requests to local automation actions, an incorrect match could execute an unintended workflow, causing system, application, or data changes without adequate user awareness.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The README advertises reading, searching, and executing Quicker actions through AI-powered natural-language matching, but it does not warn users that natural-language interpretation can trigger local automation execution. In the context of a connector to a local automation tool, this omission is materially risky because users may not understand that ambiguous prompts could cause unintended actions on their machine.

Lp3

Medium
Category
MCP Least Privilege
Confidence
78% confidence
Finding
The skill advertises capabilities that imply file access, shell execution, and possibly network behavior, but it does not declare an explicit tool scope or permissions boundary. That makes it harder for reviewers and users to understand what the skill may access, and increases the risk of over-privileged execution if the runtime grants broad defaults.

Natural-Language Policy Violations

Medium
Confidence
84% confidence
Finding
The skill description and all user-facing examples and instructions are written exclusively in Chinese, indicating a fixed language experience without offering the user a language choice or documenting a justified locale restriction. This can violate language/locale policy when the skill is not explicitly declared as Chinese-only with user opt-in.

Vague Triggers

Medium
Confidence
90% confidence
Finding
示例“帮我翻译这段文字”未要求用户提及 Quicker,却被定义为可由本技能智能匹配并执行,这会训练/诱导代理把普通任务错误路由到具备本地执行能力的技能。结合该技能的自动匹配与自动执行阈值设计,普通请求可能在无明确产品上下文下触发本地动作。

Static analysis

No suspicious patterns detected.