Back to skill

Security audit

Qveris Skill

Security checks for vulnerabilities and agentic risk

Overview

The skill does what it claims, but it enables broad automatic third-party tool execution with under-disclosed data sharing and includes unsafe installation guidance.

Install only if you are comfortable sending tool searches and execution parameters to QVeris and potentially third-party APIs. Avoid putting secrets, private code, internal URLs, or sensitive business data in parameters, and prefer verified package-manager installation methods instead of the documented curl-to-shell, PowerShell iex, or unpinned npx commands.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T03 · Remote Payload Retrieval and Execution

Error
Location
README.md:18
Finding
Documentation Executes Mutable Remote Installer Scripts Without Integrity Verification## Vulnerability Details **File Location**: `README.md:18-27`; duplicated in `README.zh-CN.md:18-27` **Vulnerability Type**: Remote payload retrieval and immediate execution **Risk Level**: Critical ### Vulnerable Code ```bash **macOS and Linux:** ```bash curl -LsSf https://astral.sh/uv/install.sh | sh ``` **Windows:** ```powershell powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" ``` ``` The same commands appear in both the English and Chinese installation guides. ### Technical Analysis These installation instructions retrieve mutable content from an external URL and pass it directly to a command interpreter. The Unix command pipes the HTTP response into `sh`, while the Windows command evaluates the response through `iex` and explicitly bypasses PowerShell execution-policy restrictions. The commands provide no opportunity to inspect the downloaded scripts and perform no version pinning, checksum validation, or cryptographic signature verification. Consequently, the code that users execute can differ from the code available when this Skill was audited. The domains shown appear to be official Astral infrastructure, but the repository itself provides no mechanism to establish the integrity of a particular installer payload. A compromise involving the remote hosting service, release process, DNS resolution, or another part of the delivery chain could therefore turn the documented prerequisite installation into arbitrary local code execution. Installing `uv` is relevant to the Skill's declared operation. However, directly executing unverified network content exceeds the minimum-risk approach necessary to install that dependency. ### Attack Path 1. A user follows the prerequisite installation instructions in either README. 2. The command requests a mutable installer from the external Astral endpoint. 3. The remote endpoint or its delivery chain supplies malicious or compromis ...[truncated 984 chars]
Remediation
## Remediation Suggestions 1. Remove instructions that pipe downloaded content directly into `sh` or `iex`. 2. Prefer an operating-system package manager or another installation channel that supports signed and versioned packages. 3. If a standalone installer is necessary: - Pin a specific release and artifact URL. - Download the artifact to disk without executing it. - Publish the expected SHA-256 digest in the documentation. - Verify the digest or a trusted cryptographic signature before execution. - Allow users to inspect the downloaded content. 4. Remove the PowerShell `-ExecutionPolicy ByPass` instruction. 5. Apply the same changes to both `README.md` and `README.zh-CN.md`. 6. Document the exact supported `uv` version so installations are reproducible and auditable.

T08 · Insecure Dependencies

Warning
Location
README.md:37
Finding
Unpinned NPX Package Is Retrieved and Executed During Skill Installation## Vulnerability Details **File Location**: `README.md:37-40`; duplicated in `README.zh-CN.md:37-40` **Vulnerability Type**: Unpinned executable third-party dependency **Risk Level**: Medium ### Vulnerable Code ```bash **Option 2: Install via NPX (For other coding agents)** ```bash npx skills add hqman/qveris ``` ``` The equivalent unpinned command is also present in the Chinese installation guide. ### Technical Analysis `npx` can resolve, download, and execute a package from the configured npm registry. The documented command does not specify a version of the `skills` package and does not provide an expected package integrity value. Its behavior may therefore change as registry tags and package releases change. The repository also does not include a lockfile or verification procedure governing this installation route. If the resolved package, publisher account, registry entry, or dependency chain is compromised, package code can execute locally during installation. This finding concerns the dynamically retrieved `skills` command. The repository contents reviewed do not demonstrate that `hqman/qveris` itself contains embedded malicious code. ### Attack Path 1. A user runs the documented `npx skills add hqman/qveris` command. 2. `npx` resolves the unversioned `skills` package using the user's configured registry. 3. An attacker compromises the package, publisher account, registry resolution, or a transitive dependency used by the resolved release. 4. `npx` downloads the compromised package content. 5. The package or its dependency lifecycle executes attacker-controlled JavaScript with the invoking user's permissions. 6. The malicious code accesses or changes resources available to that user before, during, or after the requested Skill installation. ### Impact Assessment Exploitation can produce arbitrary code execution under the invoking user account. Potentially exposed resources include project files, e ...[truncated 337 chars]
Remediation
## Remediation Suggestions 1. Pin the installer package to a reviewed, immutable version rather than relying on the current registry tag. 2. Document the expected package publisher, version, and integrity digest. 3. Prefer an installation process that downloads the package first and verifies its provenance and integrity before running it. 4. Use a lockfile or equivalent reproducible dependency mechanism where applicable. 5. Review package lifecycle scripts and transitive dependencies before recommending the command. 6. Update both language versions of the README with the hardened command and verification steps.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (14)

Chaining Abuse

High
Category
Tool Misuse
Content
**macOS and Linux:**
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

**Windows:**
Confidence
96% confidence
Finding
The `curl ... | sh` pattern is a classic command-chaining hazard because it immediately executes content retrieved from the network. In the context of a skill README, this is more dangerous than a normal documentation issue because users are primed to copy-paste setup commands, so any upstream compromise or typo-squatted URL could directly lead to arbitrary code execution on the user's machine.

Chaining Abuse

High
Category
Tool Misuse
Content
**macOS 和 Linux:**
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

**Windows:**
Confidence
97% confidence
Finding
Using `curl ... | sh` creates an immediate code-execution chain from unaudited network content into a shell. In the context of an agent skill README, this is especially risky because users may copy-paste commands verbatim, making compromise of the remote script a direct path to system takeover.

Vague Triggers

High
Confidence
93% confidence
Finding
The trigger patterns are broad terms such as 'analysis', 'data', and stock/trading keywords combined with auto_invoke, which can cause the skill to activate for many ordinary conversations. Because this skill can search for and execute external tools dynamically, unintended invocation increases the chance of sending user queries or parameters to third-party services without clear user intent.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The README says the skill can dynamically search and execute tools via the QVeris API, but it does not clearly warn users that their prompts, tool queries, or related metadata may be sent to a third-party service. In an agent context, this can cause inadvertent disclosure of sensitive code, secrets, or business data because users may assume processing is local or first-party.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The README advertises that the skill can execute any discovered tool with parameters and offers wide API coverage, but it does not warn that discovered tools may perform arbitrary external actions or exfiltrate supplied data. In this context, the danger is elevated because an agent may autonomously invoke third-party tools, turning a benign-looking discovery feature into a powerful action surface.

Rp1

Medium
Category
MCP Rug Pull
Confidence
86% confidence
Finding
The README instructs users to install the skill via `npx skills add hqman/qveris` without pinning an exact package version. That creates a supply-chain risk because users may unknowingly fetch a changed or compromised package at install time, especially since this is an agent skill that can influence tool execution behavior.

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.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The auto-trigger guidance is very broad, covering common topics like weather, stocks, web search, and currency, with no narrowing conditions or user-confirmation boundary. In an agent skill context, this can cause the skill to activate for routine requests and unnecessarily route user queries to an external API, increasing the chance of unintended data exposure or unsafe tool execution chaining.

Vague Triggers

Medium
Confidence
88% confidence
Finding
The manifest advertises broad dynamic tool execution across many domains, but its triggers are focused mainly on stocks and trading while examples include unrelated areas like weather. This ambiguity can cause the skill to be invoked unexpectedly or omitted when relevant, reducing predictability around when external third-party calls may occur.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill instructs users to discover and execute third-party tools dynamically, but it does not clearly disclose that user-supplied parameters and query content may be transmitted to external services. In a dynamic tool marketplace model, this creates privacy and data-handling risk because users may unknowingly send sensitive prompts, locations, financial interests, or other personal data to unknown APIs.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The execute path forwards arbitrary user-provided JSON parameters directly to a third-party remote API, but the CLI provides no explicit warning, confirmation, or redaction guidance before transmitting that data. In a skill context, users may paste secrets, personal data, internal URLs, or proprietary content into --params without realizing it will be sent off-host, creating a real data exposure risk even though the behavior appears intentional and functional rather than malicious.

External Script Fetching

Low
Category
Supply Chain
Content
**macOS and Linux:**
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

**Windows:**
Confidence
90% confidence
Finding
The README recommends installing `uv` by piping a remotely fetched script directly into a shell. Even if the source is legitimate, this pattern is dangerous because it executes network-delivered code without local inspection, making users dependent on the integrity of the remote host, transport, and any intermediate compromise.

External Script Fetching

Low
Category
Supply Chain
Content
**macOS 和 Linux:**
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

**Windows:**
Confidence
95% confidence
Finding
The documentation instructs users to fetch and execute a remote installation script directly from the network. This is dangerous because any compromise of the host, CDN, DNS path, or served script contents can immediately lead to arbitrary code execution on the user's machine during installation.

Unverifiable Dependency: httpx has 2 known advisory(ies) (CVE-2021-41945 (Improper Input Validation in httpx); CVE-2021-41945 (Encode OSS httpx <=1.0.0.beta0 is affected by improper input validation in `http)), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
90% confidence
Finding
The dependency specification uses a broad lower bound (httpx>=0.25.0) instead of pinning or constraining to a known-safe range, so builds may resolve to different versions across environments without assurance that vulnerable releases are excluded. This creates supply-chain uncertainty and can allow installation of a release affected by known advisories if dependency resolution or mirrors introduce an unsafe version.

Static analysis

No suspicious patterns detected.