Back to skill

Security audit

Minimax Usage

Security checks for vulnerabilities and agentic risk

Overview

This skill appears to be a straightforward MiniMax usage checker with disclosed API-key use and no hidden persistence or destructive behavior.

Before installing, use a dedicated virtual environment, consider pinning requests to a reviewed version, and only store a MiniMax API key you are comfortable using for this checker. Add cron or heartbeat monitoring only if you want periodic authenticated calls to MiniMax.

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

Note
Location
requirements.txt:1
Finding
Unbounded Third-Party Dependency Produces Non-Reproducible Builds<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1` **Vulnerability Type**: Unbounded third-party dependency **Risk Level**: Low ### Vulnerable Code ```text requests>=2.28.0 ``` The related installation instructions in `README.md:24-27` and `SKILL.md:43-46` direct users to install `requests` without a lock file or integrity verification: ```bash pip install requests ``` ### Technical Analysis The dependency specification accepts every `requests` release from version 2.28.0 onward. No upper bound, exact version, lock file, or package hash is provided. Consequently, separate installations may resolve to different dependency versions, including versions published after the Skill was audited. This is a supply-chain hardening weakness rather than evidence that the current `requests` package is malicious. The package name and documented PyPI installation method are legitimate, with no observed typosquatting or untrusted package index. Nevertheless, unrestricted future versions make installations non-reproducible and expand exposure to a future compromised, malicious, or incompatible release. ### Attack Path 1. An attacker compromises the upstream package publishing process or an allowed future dependency release. 2. A user follows the documented installation command or installs from `requirements.txt`. 3. The package resolver selects the compromised release because it satisfies `requests>=2.28.0`. 4. Malicious package installation or import-time code executes with the privileges of the user running `pip` or the Skill. 5. Because the Skill imports `requests` while holding `MINIMAX_CODING_KEY` in its process environment, malicious dependency code could access that credential or tamper with the authenticated API request. This path requires an upstream supply-chain compromise or malicious future release; no such compromise was identified during this audit. ### Impact Assessment Exploitation could execute code with the privileges of the ...[truncated 475 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `requests` to a specifically reviewed version instead of accepting all future versions: ```text requests==<reviewed-version> ``` 2. Generate and commit a lock file containing exact transitive dependency versions. 3. Require package hashes during installation, such as with a hash-pinned requirements file and: ```bash pip install --require-hashes -r requirements.txt ``` 4. Review and deliberately update dependency pins on a controlled schedule after vulnerability and compatibility testing. 5. Install dependencies in a dedicated virtual environment under a non-administrative account. 6. Document the trusted package index explicitly if automated installation occurs in a managed environment. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (5)

Tainted flow: 'headers' from os.environ.get (line 39, credential/environment) → requests.get (network output)

Critical
Category
Data Flow
Content
"Content-Type": "application/json"
    }
    
    r = requests.get(url, headers=headers)
    
    if r.status_code != 200:
        return {"error": f"API error: {r.status_code}", "detail": r.text}
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Natural-Language Policy Violations

Low
Confidence
92% confidence
Finding
This markdown file contains user-facing instructions exclusively in Chinese, including the title, setup steps, troubleshooting, and safety notes. Under the policy rule for natural-language violations, forcing a specific language without user opt-in can be a locale/language policy issue when no alternative or opt-in is provided.

Natural-Language Policy Violations

Low
Confidence
94% confidence
Finding
The module docstring presents the script description and usage only in Chinese, which imposes a specific language on users without any opt-in or alternative. The policy for natural-language violations applies to all file types, including code comments and string literals.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.28.0
Confidence
95% confidence
Finding
The dependency is specified as `requests>=2.28.0`, which allows any newer version to be installed and prevents reproducible builds. This makes it difficult to verify exactly which code will run and can permit installation of a vulnerable or incompatible release if the ecosystem changes.

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
90% confidence
Finding
The manifest includes `requests` without pinning to a specific version, while multiple advisories exist for that package. Because the resolved version is unknown, there is no assurance that installation will avoid affected releases, which weakens supply-chain security and patch verification.