Back to skill

Security audit

mmEasyVoice

Security checks for vulnerabilities and agentic risk

Overview

The skill is a mostly coherent MiniMax voice tool, but it needs review because it can upload sensitive voice/text data and its API endpoint can be redirected to send the API key and content elsewhere.

Install only if you are comfortable sending TTS text and selected voice samples to MiniMax, and only clone voices you have permission to use. Keep MINIMAX_API_BASE unset or locked to the official MiniMax origin, use a least-privilege API key, and review custom-voice deletion helpers before exposing this package to automated agents.

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

T09 · Insecure Skill Coding Practices

Error
Location
scripts/utils.py:13
Finding
Unvalidated API Base URL Can Exfiltrate Credentials and Sensitive User Content<![CDATA[ ## Vulnerability Details **File Location**: `scripts/utils.py:13-15, 160-181`; related sinks in `scripts/sync_tts.py:149-173` and `scripts/voice_clone.py:78-96, 132-150` **Vulnerability Type**: Unrestricted credential-bearing network destination **Risk Level**: High ### Complete Code Snippet From `scripts/utils.py`: ```python # API Configuration MINIMAX_VOICE_API_KEY = os.getenv("MINIMAX_VOICE_API_KEY") MINIMAX_API_BASE = os.getenv("MINIMAX_API_BASE", "https://api.minimaxi.com/v1") MINIMAX_API_BASE_BACKUP = "https://api-bj.minimaxi.com/v1" def make_request( method: str, endpoint: str, data: Optional[Dict] = None, files: Optional[Dict] = None, params: Optional[Dict] = None, timeout: int = 120, use_backup: bool = False ) -> Dict[str, Any]: base_url = MINIMAX_API_BASE_BACKUP if use_backup else MINIMAX_API_BASE url = f"{base_url}/{endpoint.lstrip('/')}" if files: headers = { "Authorization": f"Bearer {MINIMAX_VOICE_API_KEY}", "Accept-Encoding": "gzip, deflate", } else: headers = get_headers() response = requests.request( method=method, url=url, headers=headers, json=data if not files else None, data=data if files else None, files=files, params=params, timeout=timeout, ) response.raise_for_status() return response.json() ``` Related TTS sink in `scripts/sync_tts.py`: ```python headers = get_headers() url = f"{MINIMAX_API_BASE}/t2a_v2" with requests.post( url, headers=headers, json=payload, stream=True, timeout=300 ) as response: response.raise_for_status() ``` Related biometric audio upload sink in `scripts/voice_clone.py`: ```python import requests url = f"{MINIMAX_API_BASE}/files/upload" headers = {"Authorization": f"Bearer {MINIMAX_VOICE_API_KEY}"} with open(file_path, "rb") as f: files = {"file": (os.path.basename(file_path), f)} ...[truncated 2923 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Use a fixed official HTTPS origin unless custom endpoints are an explicitly required feature: ```python MINIMAX_API_BASE = "https://api.minimaxi.com/v1" ``` 2. If endpoint customization is required, validate the parsed URL before sending any credential: - Require `https`. - Reject embedded credentials. - Require an approved normalized hostname. - Restrict ports to approved values. - Reject fragments and unexpected path prefixes. - Resolve and compare the final destination against an explicit allowlist. 3. Disable automatic cross-origin redirects for authenticated requests, or manually verify every redirect target before resending the authorization header. 4. Separate endpoint configuration from credential handling. Only attach the bearer token after confirming that the final origin is trusted. 5. Add tests proving that HTTP URLs, unapproved domains, crafted subdomains, user-information components, and cross-origin redirects are rejected. 6. Clearly disclose in the user-facing documentation that TTS text and voice-cloning recordings are transmitted to MiniMax. For biometric voice data, require explicit user intent and recommend obtaining the speaker's consent. ]]>

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Unpinned Dependencies Permit Unreviewed Future Package Versions<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1-4` **Vulnerability Type**: Unbounded and unhashed third-party dependencies **Risk Level**: Medium ### Complete Code Snippet ```text # MiniMax Voice Maker Skill Dependencies requests>=2.28.0 websockets>=10.0 ffmpeg-python>=0.2.0 ``` The documented installation command in `reference/getting-started.md:14` is: ```bash pip install -r requirements.txt ``` ### Technical Analysis All dependencies specify only minimum versions. There are no exact version pins, upper bounds, lockfile entries, or integrity hashes. A fresh installation can therefore resolve to package versions released after the skill was reviewed. This does not demonstrate that any currently named package is malicious. It creates a supply-chain weakness because the effective installed code can change over time without a corresponding change to this project. A compromised upstream release, account takeover, or unexpectedly incompatible future version could be selected automatically. These package names correspond to the declared functionality and no evidence of dependency confusion, typosquatting, or an untrusted package index was found. The issue is the lack of reproducible, integrity-verified resolution. ### Attack Path 1. A future release of one of the permitted packages is compromised, malicious, or otherwise unsafe. 2. The release still satisfies its broad constraint, such as `requests>=2.28.0`. 3. A user or deployment system performs a fresh installation: ```bash pip install -r requirements.txt ``` 4. The package resolver selects the new release because no reviewed exact version or hash is required. 5. Package-controlled code may execute during installation or later when the skill imports the dependency. 6. Such code runs with the permissions of the user, service, container, or CI worker performing the installation or running the skill. ### Impact Assessment The impact depends on the privileges of the insta ...[truncated 496 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin dependencies to reviewed exact versions rather than minimum versions: ```text requests==<reviewed-version> websockets==<reviewed-version> ffmpeg-python==<reviewed-version> ``` 2. Generate and commit a lockfile appropriate to the deployment workflow. 3. Use hash-verified installation, for example a generated requirements file containing `--hash=sha256:...` entries and installation with: ```bash pip install --require-hashes -r requirements.lock ``` 4. Configure package installation to use an explicitly trusted package index and disable unintended additional indexes where feasible. 5. Run automated dependency vulnerability and provenance checks, but update pinned versions only through a reviewed process. 6. Perform dependency installation in an isolated, least-privileged virtual environment or container without unnecessary secrets present. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (65)

Tainted flow: 'url' from os.getenv (line 161, credential/environment) → requests.get (network output)

Critical
Category
Data Flow
Content
Returns:
        Saved file path
    """
    response = requests.get(url, timeout=timeout)
    response.raise_for_status()
    
    with open(output_path, "wb") as f:
Confidence
95% confidence
Finding
The function downloads content from an arbitrary URL and writes it directly to disk without validating the scheme, host, or destination. In a skill context where the URL may originate from API responses or user-influenced input, this creates an SSRF-style primitive and can also be abused to fetch unexpected internal or malicious resources and persist them locally.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Voice listing, metadata retrieval, and deletion/cleanup operations amount to resource management actions, not just TTS. If these actions are undocumented or minimized, a user could authorize the skill expecting harmless generation while it also gains the ability to enumerate and remove remote custom assets.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The file presents itself as a simple text-to-speech skill, but actually exposes substantially broader capabilities including voice cloning, voice design, file merging/conversion, and external environment checks. This scope mismatch is dangerous because users or higher-level agents may grant permissions and trust assumptions appropriate for TTS while unknowingly enabling more privacy-sensitive or system-touching functions.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
Voice cloning is a materially different and more sensitive capability than simple TTS because it processes user-supplied biometric-like voice data and can enable impersonation or fraud. In the context of a supposedly simple TTS skill, this hidden capability increases the chance of misuse and reduces informed user consent.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The package presents itself as a simple text-to-speech skill, but this file exposes a much broader SDK including voice cloning, voice design, voice management, async orchestration, and segment workflows. That scope mismatch is dangerous because it grants callers access to high-risk capabilities that may bypass user expectations, policy review, or least-privilege assumptions for a supposedly simple TTS integration.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
Exporting voice cloning and custom voice design capabilities in a skill advertised as simple TTS introduces impersonation and consent risks far beyond ordinary speech generation. In this context, the mismatch makes the functionality more dangerous because downstream users or agents may unknowingly invoke identity-sensitive features that were not disclosed by the skill metadata.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The file implements end-to-end voice cloning, including uploading source audio and creating new cloned voice identities, while the skill is described as simple text-to-speech with customizable voice selection. That scope mismatch is security-relevant because it introduces sensitive biometric-style processing and impersonation capability that users and reviewers would not reasonably expect from a TTS-only skill.

Context-Inappropriate Capability

High
Confidence
96% confidence
Finding
These functions upload local audio samples to a remote service for voice cloning and prompt conditioning, which involves transmitting highly sensitive voice data beyond the stated TTS use case. Because voice samples can enable impersonation or biometric misuse, silently collecting and sending them materially increases user risk.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The clone_voice function creates new voice identities from uploaded samples instead of merely selecting built-in TTS voices. In the context of a skill advertised as simple TTS, this hidden impersonation-enabling functionality is dangerous because it materially changes the threat model and can be abused to generate convincing synthetic speech in another person's voice.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The cleanup_unused_voices function can bulk-delete all cloned and designed voices, despite the skill being described as simple TTS. A mass-deletion primitive is especially dangerous in agentic contexts because a mistaken invocation, prompt injection chain, or confused deputy flow could irreversibly destroy all user custom voice assets.

Lp3

Medium
Category
MCP Least Privilege
Confidence
88% confidence
Finding
The skill advertises and documents capabilities that involve environment access, file operations, network/API access, and shell execution, but it does not declare any explicit tool scope or permissions. This creates an authorization and transparency gap: a user or host system may permit a seemingly simple TTS skill without realizing it can invoke local commands and access local resources.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill description does not warn that user-provided text is sent to the external MiniMax Voice API for processing. This is a privacy and data-handling issue because users may submit sensitive or regulated text under the assumption processing is local.

Dynamic import via __import__()

Medium
Category
Dangerous Code Execution
Content
def check_package(name):
    """Check if Python package is installed"""
    try:
        __import__(name)
        print(f"[OK] {name}")
        return True
    except ImportError:
Confidence
75% confidence
Finding
Dynamic __import__() can load arbitrary modules at runtime, bypassing static analysis and potentially importing malicious code.

subprocess module call

Medium
Category
Dangerous Code Execution
Content
def check_ffmpeg():
    """Check if FFmpeg is installed"""
    try:
        result = subprocess.run(
            ["ffmpeg", "-version"],
            capture_output=True,
            text=True,
Confidence
70% confidence
Finding
subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The voice cloning flow uploads a user-provided audio sample for remote processing without any explicit privacy warning, consent language, or disclosure of third-party handling. Because voice samples can be sensitive and identifying, lack of disclosure creates meaningful privacy and trust risk even if the underlying API use is intended.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
Voice design/generation goes beyond straightforward text-to-speech and introduces remote creation of new synthetic voices plus preview file output. While less sensitive than cloning, it is still outside the declared scope and can mislead users about what the skill actually does and what data may be sent externally.

Context-Inappropriate Capability

Medium
Confidence
91% confidence
Finding
Generic audio merge/convert operations are unrelated to the stated purpose of simple TTS and broaden the file-system manipulation surface of the skill. This is primarily a least-privilege and transparency issue: users may permit a TTS skill that unexpectedly performs arbitrary local audio processing and writes files to chosen paths.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The environment-check command executes another script, which extends the skill from content generation into local program execution. In a simple TTS skill context, this is more dangerous because operators may not expect delegated execution behavior or review the secondary script with the same scrutiny.

Static analysis

No suspicious patterns detected.