Back to skill

Security audit

Currency Converter

Security checks for vulnerabilities and agentic risk

Overview

This is a straightforward currency conversion skill that uses a disclosed external exchange-rate API and does not show hidden access, persistence, or destructive behavior.

Before installing, be aware that currency lookups contact exchangerate-api.com and that the package uses an unpinned requests dependency. This looks appropriate for a currency converter, but security-sensitive deployments should pin dependencies and consider whether a third-party exchange-rate service is acceptable.

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

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Unbounded Third-Party Dependency Permits Unreviewed Future Releases<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1` **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium **Vulnerable Code:** ```text requests>=2.25.0 ``` ### Technical Analysis The dependency specification defines only a minimum version and allows the package resolver to install any later release of `requests`. As a result, installations are not reproducible, and future dependency versions can be introduced without review. The requirements file also contains no cryptographic hashes to verify the integrity of downloaded artifacts. This does not demonstrate that the current `requests` package is malicious. However, it creates a supply-chain exposure: if a future compatible release or its distribution infrastructure is compromised, a subsequent installation may automatically select and install the affected artifact. ### Attack Path 1. An attacker compromises a future `requests` release, a maintainer account, or the package distribution channel. 2. The attacker publishes a malicious version greater than or equal to `2.25.0`. 3. A user installs the project dependencies without a lockfile, constraints file, or hash enforcement. 4. The package resolver selects the compromised release because it satisfies `requests>=2.25.0`. 5. Malicious code may run during package installation or when `currency_converter.py` imports `requests`. ### Impact Assessment Successful exploitation would execute code with the privileges of the account installing or running the Skill. Depending on those privileges, the attacker could access readable files and environment variables, alter user-accessible data, make unauthorized network requests, or compromise the Skill's runtime environment. The scope is limited by the operating-system permissions and sandbox controls applied to that account. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Pin `requests` to a specifically reviewed version, for example: ```text requests==<reviewed-version> ``` - Generate and commit a lockfile or fully pinned requirements file that includes all transitive dependencies. - Require cryptographic hashes during installation, such as by using `pip install --require-hashes -r requirements.txt`. - Obtain packages only from an explicitly configured, trusted package index. - Use automated dependency monitoring to identify vulnerable or compromised releases. - Review and deliberately update dependency pins rather than permitting automatic resolution to arbitrary future versions. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (6)

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The manifest description, usage guidance, trigger examples, and prescribed user-facing replies are all written to require Chinese output, with no indication that the user may choose another language. This is a natural-language policy concern because it imposes a specific language/locale without opt-in or documented justification.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The natural-language strings throughout the script, including the module description, argument help, and all user-facing error/output labels, are in Chinese only. The file does not offer a language selection mechanism or explain that the tool is intentionally restricted to a Chinese-speaking context, which can violate language/locale policy requirements.

External Transmission

Medium
Category
Data Exfiltration
Content
"""
    try:
        # 使用免费API(不需要API密钥)
        url = f"https://api.exchangerate-api.com/v4/latest/{from_currency}"
        
        response = requests.get(url, timeout=10)
        response.raise_for_status()
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Missing User Warnings

Low
Confidence
92% confidence
Finding
This code sends the requested base currency to a third-party HTTPS endpoint using requests.get, but there is no user-facing disclosure in the CLI help, printed output, or surrounding comments that user input will be transmitted externally. For a code file, outbound network transmission of user-provided data should have some visible warning unless clearly disclosed as part of the skill behavior.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.25.0
Confidence
96% confidence
Finding
The dependency is specified as `requests>=2.25.0`, which allows any newer version to be installed and does not guarantee reproducible or reviewed builds. This makes it harder to verify exactly which code will run and can permit introduction of vulnerable or breaking releases through normal dependency resolution.

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
89% confidence
Finding
Because `requests` is not pinned, it is not possible to determine from this manifest whether installation will resolve to a version affected by known advisories. In security-sensitive environments, this uncertainty is itself risky because deployments may consume different versions over time, including vulnerable ones.

Static analysis

No suspicious patterns detected.