Back to skill

Security audit

MiniMax Frontend Dev

Security checks for vulnerabilities and agentic risk

Overview

The skill is largely a disclosed frontend and media-generation helper, but its MiniMax scripts can send API keys and user prompts to an arbitrary environment-configured endpoint and fetch unvalidated media URLs.

Review this before installing if you will use MiniMax media generation. Only set MINIMAX_API_BASE to official MiniMax HTTPS endpoints, keep the API key narrowly scoped and revocable, avoid putting confidential text or lyrics into prompts, and be cautious with returned download URLs and unpinned package installation. The skill does not show evidence of intentional theft or persistence, but its current endpoint and download handling are too broad for a clean benign install.

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

T09 · Insecure Skill Coding Practices

Error
Location
scripts/minimax_music.py:21
Finding
API credential and user-content disclosure through an unrestricted endpoint<![CDATA[ ## Vulnerability Details **File Location**: `scripts/minimax_music.py:21-26, 42-72`; equivalent behavior in `scripts/minimax_tts.py:21-26, 44-74`, `scripts/minimax_image.py:20-36, 60-65`, and `scripts/minimax_video.py:21-34, 62-67` **Vulnerability Type**: Arbitrary credential-bearing API destination **Risk Level**: High ### Vulnerable Code ```python API_KEY = os.getenv("MINIMAX_API_KEY") # China Mainland: https://api.minimaxi.com/v1 # Overseas: https://api.minimax.io/v1 API_BASE = os.getenv("MINIMAX_API_BASE") if not API_BASE: raise SystemExit("ERROR: MINIMAX_API_BASE is not set.") ``` ```python if not API_KEY: raise SystemExit("ERROR: MINIMAX_API_KEY is not set.\n export MINIMAX_API_KEY='your-key'") payload = { "model": model, "audio_setting": { "sample_rate": sample_rate, "bitrate": bitrate, "format": fmt, }, "output_format": output_format, } if prompt: payload["prompt"] = prompt if lyrics: payload["lyrics"] = lyrics if is_instrumental: payload["is_instrumental"] = True if lyrics_optimizer: payload["lyrics_optimizer"] = True resp = requests.post( f"{API_BASE}/music_generation", headers={ "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json", }, json=payload, timeout=timeout, ) ``` ### Technical Analysis All four MiniMax clients obtain the credential from `MINIMAX_API_KEY` and the request destination from the independent, environment-controlled `MINIMAX_API_BASE` variable. They do not verify that the URL uses HTTPS, that its hostname is an official MiniMax endpoint, or that it contains no embedded credentials or unsafe redirect behavior. As a result, a process-environment change can redirect the Bearer credential to an arbitrary server. The same request also contains user-provided prompts, lyrics, TTS text, or video/image descriptions. Transmitting those values to the legitimate service is required for media generation ...[truncated 1622 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the mandatory arbitrary base URL with a trusted default: ```python API_BASE = "https://api.minimax.io/v1" ``` 2. If regional endpoint selection is required, map a constrained region value to an exact allowlist: ```python ALLOWED_BASES = { "overseas": "https://api.minimax.io/v1", "china": "https://api.minimaxi.com/v1", } ``` 3. Parse the URL and require: - `https` as the scheme; - an exact approved hostname; - no username or password component; - the expected port and path prefix. 4. Disable automatic redirects for credential-bearing requests or validate every redirect before following it. Never forward the `Authorization` header to a different host. 5. Apply the same validation helper consistently to image, video, music, and TTS clients. 6. Document endpoint selection and explicitly warn that API keys must only be sent to official MiniMax domains. 7. Prefer narrowly scoped, revocable API keys and rotate any credential used with the current implementation. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/minimax_image.py:76
Finding
Unvalidated response-directed downloads permit SSRF and unbounded file retrieval<![CDATA[ ## Vulnerability Details **File Location**: `scripts/minimax_image.py:76-81, 123-127`; equivalent response-directed downloads in `scripts/minimax_video.py:122-129` and `scripts/minimax_music.py:101-103, 145-149` **Vulnerability Type**: Untrusted URL retrieval and unbounded download **Risk Level**: Medium ### Vulnerable Code ```python def download_and_save(url: str, output_path: str): """Download image from URL and save.""" resp = requests.get(url, timeout=60) resp.raise_for_status() with open(output_path, "wb") as f: f.write(resp.content) return len(resp.content) ``` ```python else: urls = result.get("data", {}).get("image_urls", []) for i, url in enumerate(urls): path = args.output if len(urls) == 1 else _numbered_path(args.output, i) size = download_and_save(url, path) print(f"OK: {size} bytes -> {path}") ``` The video client contains the same pattern: ```python download_url = data.get("file", {}).get("download_url", "") if not download_url: raise SystemExit(f"No download_url in response: {json.dumps(data, indent=2)}") print(f" Downloading from {download_url[:80]}...") video_resp = requests.get(download_url, timeout=300) video_resp.raise_for_status() os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True) with open(output_path, "wb") as f: f.write(video_resp.content) ``` ### Technical Analysis The scripts trust URLs returned in API responses and issue unrestricted `GET` requests to them. They do not validate the URL scheme, hostname, resolved IP address, redirect chain, response content type, or response size. A malicious or compromised API endpoint can therefore make the client connect to loopback, private, link-local, or cloud metadata addresses. Because `requests` follows redirects by default, an apparently acceptable public URL could also redirect to an internal destination. This creates a server-side request forgery primitive from the machine running the Skill ...[truncated 1786 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Parse every returned URL and require HTTPS. 2. Maintain an allowlist of documented MiniMax media-storage hostnames. If hosts are dynamic, validate them against a narrowly defined provider-owned suffix with correct DNS-boundary checks. 3. Resolve the hostname before connection and reject loopback, private, link-local, multicast, reserved, and cloud-metadata address ranges for both IPv4 and IPv6. 4. Disable redirects initially: ```python requests.get(url, allow_redirects=False, stream=True, timeout=...) ``` Validate each redirect destination before following it. 5. Stream responses in bounded chunks and enforce a type-specific maximum file size using both `Content-Length` and a running byte count. 6. Require an expected media `Content-Type` and verify file signatures before accepting the file. 7. Write to a temporary file, validate it, and atomically rename it to the final output path. 8. Prefer base64 or authenticated first-party response modes where supported, reducing the need to follow arbitrary response-provided URLs. ]]>

T08 · Insecure Dependencies

Warning
Location
references/env-setup.md:8
Finding
Unpinned third-party package installation creates supply-chain exposure<![CDATA[ ## Vulnerability Details **File Location**: `references/env-setup.md:8-16`; additional unpinned npm commands in `SKILL.md:361-366` and an unpinned pip command in `references/troubleshooting.md:41` **Vulnerability Type**: Unpinned dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash pip install requests # FFmpeg (optional, for audio post-processing) # macOS: brew install ffmpeg # Ubuntu: sudo apt install ffmpeg ``` The core Skill also instructs installation of unpinned frontend packages: ```bash npm install framer-motion # UI (keep at top level) npm install gsap # Scroll (lazy-load) npm install lottie-react # Icons (lazy-load) npm install three @react-three/fiber @react-three/drei # 3D (lazy-load) ``` ### Technical Analysis The installation commands do not specify reviewed package versions, lockfile requirements, registry restrictions, or integrity hashes. The behavior installed when the Skill is used can consequently change after the Skill itself has been audited. Package managers may execute package lifecycle hooks during installation. If a dependency account, release channel, registry, or transitive package is compromised, the installation can execute attacker-controlled code with the privileges of the user or Agent running the command. The operating-system package examples additionally include `sudo apt install`, which can install changing repository content with elevated privileges. No malicious package or repository is currently identified; the confirmed issue is the absence of reproducible, integrity-controlled dependency installation. ### Attack Path 1. A named package, transitive dependency, maintainer account, release pipeline, or configured package registry is compromised. 2. A malicious release becomes the version selected by the unpinned command. 3. The user or Agent follows the Skill and runs `pip install`, `npm install`, or the operating-system package command. 4. T ...[truncated 800 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every direct dependency to a reviewed exact version. 2. Supply and enforce lockfiles with integrity metadata: - `requirements.txt` with hashes or a locked Python environment; - `package-lock.json`, `pnpm-lock.yaml`, or `yarn.lock` committed after review. 3. For Python, use hash-checked installation, for example: ```bash pip install --require-hashes -r requirements.txt ``` 4. Use official registries explicitly and reject unexpected registry overrides in automated environments. 5. Use `npm ci` rather than unconstrained `npm install` for reproducible installations. 6. Disable package lifecycle scripts where compatible, and separately review any package requiring them. 7. Scan pinned direct and transitive dependencies before release and update them through a controlled review process. 8. Avoid directing an Agent to run elevated package-manager commands automatically. Require explicit user approval for system-level installation. ]]>

T03 · Remote Payload Retrieval and Execution

Warning
Location
templates/viewer.html:23
Finding
Browser template retrieves and executes remote JavaScript without integrity verification<![CDATA[ ## Vulnerability Details **File Location**: `templates/viewer.html:23-26` **Vulnerability Type**: Mutable remote payload retrieval and execution **Risk Level**: Medium ### Vulnerable Code ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.7.0/p5.min.js"></script> <link rel="preconnect" href="https://fonts.googleapis.com"> <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin> <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600&family=Lora:wght@400;500&display=swap" rel="stylesheet"> ``` ### Technical Analysis The HTML template loads executable p5.js code from CDNJS at page-open time without a Subresource Integrity hash. It also does not establish a restrictive Content Security Policy. Although the URL includes a library version, the browser has no cryptographic assertion that the returned bytes match the version reviewed by the Skill author. If the CDN resource, account, delivery infrastructure, or network trust path is compromised, substituted JavaScript executes in the viewer's page context. This is a remote payload execution channel whose effective content can change independently of the audited Skill package. The template comments describe the output as a “self-contained artifact,” but it depends on CDNJS and Google Fonts. Opening it therefore produces third-party network requests that reveal visitor IP address, user-agent details, referrer behavior subject to browser policy, and timing metadata. ### Attack Path 1. An attacker compromises the CDN-hosted asset, its publishing path, or a trusted delivery component. 2. The user opens an interactive artifact created from `templates/viewer.html`. 3. The browser requests `p5.min.js` from CDNJS. 4. Because no integrity hash is present, the browser accepts any successfully delivered JavaScript. 5. The substituted payload executes with the privileges available to scripts in the viewer's origin. 6. It may read or modify page content, issue netw ...[truncated 768 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Vendor a reviewed p5.js build into the project and reference it locally. 2. Bundle the required fonts locally rather than using Google Fonts. 3. If a remote script is unavoidable, add a verified Subresource Integrity hash and CORS mode: ```html <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.7.0/p5.min.js" integrity="sha384-REPLACE_WITH_VERIFIED_HASH" crossorigin="anonymous"></script> ``` 4. Do not use a placeholder hash; calculate and independently verify it against the exact reviewed asset. 5. Add a restrictive Content Security Policy that limits scripts, styles, fonts, images, and network connections to the minimum required destinations. 6. Set an appropriate `Referrer-Policy`. 7. Update the template documentation so “self-contained” is used only when every executable and font asset is actually included locally. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • System Prompt LeakageDirect Leakage, Indirect Extraction, Tool-Based Exfiltration
Findings (65)

Tainted flow: 'API_BASE' from os.getenv (line 23, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
if seed is not None:
        payload["seed"] = seed

    resp = requests.post(
        f"{API_BASE}/image_generation",
        headers=_headers(),
        json=payload,
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Tainted flow: 'API_BASE' from os.getenv (line 24, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
if lyrics_optimizer:
        payload["lyrics_optimizer"] = True

    resp = requests.post(
        f"{API_BASE}/music_generation",
        headers={
            "Authorization": f"Bearer {API_KEY}",
Confidence
96% confidence
Finding
The request target is taken directly from the MINIMAX_API_BASE environment variable and used to send a Bearer token plus user-supplied prompt/lyrics to whatever host is configured. If an attacker can influence the environment, this becomes an SSRF/exfiltration sink that can leak credentials and content to an attacker-controlled endpoint; the frontend/media-generation context increases sensitivity because prompts and lyrics may contain proprietary or user data.

Tainted flow: 'API_BASE' from os.getenv (line 24, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
"output_format": "hex",
    }

    resp = requests.post(
        f"{API_BASE}/t2a_v2",
        headers={
            "Authorization": f"Bearer {API_KEY}",
Confidence
93% confidence
Finding
The request destination is taken directly from the MINIMAX_API_BASE environment variable and the Authorization bearer token is sent to that endpoint. If an attacker or untrusted runtime controls the environment, they can redirect requests to an arbitrary server and exfiltrate the API key and user-provided text, making this an SSRF-style credential leakage issue rather than a harmless configuration choice.

Tainted flow: 'API_BASE' from os.getenv (line 24, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
"prompt_optimizer": prompt_optimizer,
    }

    resp = requests.post(
        f"{API_BASE}/video_generation",
        headers=_headers(),
        json=payload,
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

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

Critical
Category
Data Flow
Content
"""Poll task status until Success. Returns file_id."""
    elapsed = 0
    while elapsed < max_wait:
        resp = requests.get(
            f"{API_BASE}/query/video_generation",
            headers=_headers(),
            params={"task_id": task_id},
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

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

Critical
Category
Data Flow
Content
def download_video(file_id: str, output_path: str):
    """Retrieve download URL via file_id and save the video."""
    resp = requests.get(
        f"{API_BASE}/files/retrieve",
        headers=_headers(),
        params={"file_id": file_id},
Confidence
90% confidence
Finding
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description presents a broad frontend development and creative web production skill focused on premium UI design, motion, copywriting, and media generation in the context of building web pages. The supplied code does not implement frontend development, page generation, animations, copywriting, or visual art workflows. Instead, it is narrowly a synchronous text-to-speech client for the MiniMax API, taking text input, calling an external TTS endpoint with an API key, decoding returned hex audio, and writing audio files locally. While the description mentions generating media assets including audio/music, this code’s primary purpose is specifically TTS generation and file export, which is materially different from the declared primary skill of full-stack frontend/web experience creation.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The declared description presents a comprehensive frontend development and creative-production skill centered on building visually striking web pages and related assets. The supplied code does not implement frontend development or page-building behavior at all. Instead, it is a standalone command-line script for one specific backend task: generating a video from text via the MiniMax API, polling task status, and downloading the resulting file. While the description does mention generating media assets, that reference is much broader and embedded in a web-development skill; the actual code’s primary purpose is materially different and much narrower. It also performs undeclared external API access and local file download/storage using API keys. Therefore the description does not accurately represent the code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The supplied code does not implement a broad frontend-development or media-generation skill. Instead, it is a narrow JavaScript template for p5.js generative art sketches. It includes seeded randomness, p5 lifecycle scaffolding, utility helpers, parameter updates, and image export, but no page-building logic, no UI framework usage, no copywriting, no AI/media-generation integrations, and no cinematic web animation system. While generative art is one small subset of the declared description, the actual code’s primary purpose is materially narrower and different from the declared all-in-one frontend and creative production capability.

Direct Prompt Extraction

High
Category
System Prompt Leakage
Content
## 3.2 Workflow
1. **Parse:** type, quantity, style, spec, usage
2. **Craft prompt:** Be specific (composition, lighting, style). **NEVER** include text in image prompts.
3. **Execute:** Show prompt to user, **MUST confirm before generating**, then run script
4. **Save:** `<project>/public/assets/{images,videos,audio}/` as `{type}-{descriptor}-{timestamp}.{ext}` — **MUST save locally**
5. **Post-process:** Images → WebP, Videos → ffmpeg compress, Audio → normalize
6. **Deliver:** File path + code snippet + CSS suggestion
Confidence
85% confidence
Finding
Skill contains instructions that could directly expose system prompts, internal rules, or hidden instructions to users or external parties.

Lp3

Medium
Category
MCP Least Privilege
Confidence
88% confidence
Finding
The skill explicitly references environment variables, local file access, and external API-backed generation scripts, but it does not declare any tool scope or allowed-tools restrictions. In an agent environment, this creates unnecessary ambiguity about what capabilities the skill may exercise and increases the chance of overbroad execution, especially where network and filesystem actions are involved.

Natural-Language Policy Violations

Medium
Confidence
91% confidence
Finding
The instruction "ANTI-EMOJI POLICY: NEVER use emojis anywhere" imposes a communication-style restriction that functions as a language/locale policy without any user choice or documented justification. This can conflict with user preferences or accessibility/communication norms and is stated as a mandatory rule.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
# macOS:
brew install ffmpeg
# Ubuntu:
sudo apt install ffmpeg
```

## 3. Quick test
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Indirect Prompt Extraction

Medium
Category
System Prompt Leakage
Content
| 1002 | Rate limit | Wait and retry |
| 1004 | Auth failed | Check API key |
| 1008 | Insufficient balance | Top up account |
| 1026 | Content flagged | Rephrase prompt/lyrics |
| 2013 | Invalid parameters | Check prompt/lyrics length |
Confidence
75% confidence
Finding
Skill contains patterns that could indirectly extract system prompts through rephrasing, translation, summarization, or side-channel techniques.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
# 10 seconds, 1080P
python scripts/minimax_video.py "City skyline at sunset [Push in]" -o city.mp4 --duration 10 --resolution 1080P

# Disable prompt auto-optimization
python scripts/minimax_video.py "Exact prompt I want used" -o out.mp4 --no-optimize
```
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
# 10 seconds, 1080P
python scripts/minimax_video.py "City skyline at sunset [Push in]" -o city.mp4 --duration 10 --resolution 1080P

# Disable prompt auto-optimization
python scripts/minimax_video.py "Exact prompt I want used" -o out.mp4 --no-optimize
```
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
# 10 seconds, 1080P
python scripts/minimax_video.py "City skyline at sunset [Push in]" -o city.mp4 --duration 10 --resolution 1080P

# Disable prompt auto-optimization
python scripts/minimax_video.py "Exact prompt I want used" -o out.mp4 --no-optimize
```
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Natural-Language Policy Violations

Medium
Confidence
96% confidence
Finding
The document makes gender matching a mandatory, non-negotiable rule for voice selection, which can encode discriminatory behavior into downstream applications. In a frontend/content-generation skill, this guidance may cause systems to deny user preference, mis-handle nonbinary or ambiguous characters, and produce biased UX decisions at scale.

YARA rule 'network_reconnaissance': Network reconnaissance and scanning patterns [hacktools]

Medium
Category
YARA Match
Content
ritated male voice | Drama, comedy |
| `Spanish_AssertiveQueen` | Assertive Queen | Confident, commanding queen voice | Drama, fantasy |
| `Spanish_CaringGirlfriend` | Caring Girlfriend | Nurturing, loving girlfriend voice | Romance, relationship |
| `Spanish_PowerfulSoldier` | Powerful Soldier | Strong, brave soldier voice | Action, military |
| `Spanish_PassionateWarrior` | Passionate Warrior | Fierce, dedicated warrior voice | Action, fantasy |
| `Spanish_ChattyGirl` | Chatty Girl | Talkative, sociable girl voice | Comedy, social |
| `Spanish_RomanticHusband` | Romantic Husband | Loving, romantic husband voice | Romance, family |
| `Spanish_CompellingGirl` | CompellingGirl | Persuasive, magnetic girl voice | Marketing, entertainment |
| `Spanish_PowerfulVeteran` | Powerful Veteran | Experienced, strong veteran voice | Military, drama |
| `Spanish_SensibleManager` | Sensible Manager | Practical, reasonable manager voice | Business, guidance |
| `Spanish_ThoughtfulLady` | Thoughtful L
Confidence
65% confidence
Finding
YARA rule matched a hack tool or exploit indicator (offensive tools, reconnaissance, privilege escalation, or exploit frameworks).

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
brew install ffmpeg

# Ubuntu
sudo apt install ffmpeg

# Verify
ffmpeg -version
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

External Transmission

Medium
Category
Data Exfiltration
Content
import requests

API_KEY = os.getenv("MINIMAX_API_KEY")
# China Mainland: https://api.minimaxi.com/v1
# Overseas:       https://api.minimax.io/v1
API_BASE = os.getenv("MINIMAX_API_BASE")
if not API_BASE:
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
import requests

API_KEY = os.getenv("MINIMAX_API_KEY")
# China Mainland: https://api.minimaxi.com/v1
# Overseas:       https://api.minimax.io/v1
API_BASE = os.getenv("MINIMAX_API_BASE")
if not API_BASE:
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
import requests

API_KEY = os.getenv("MINIMAX_API_KEY")
# China Mainland: https://api.minimaxi.com/v1
# Overseas:       https://api.minimax.io/v1
API_BASE = os.getenv("MINIMAX_API_BASE")
if not API_BASE:
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
import requests

API_KEY = os.getenv("MINIMAX_API_KEY")
# China Mainland: https://api.minimaxi.com/v1
# Overseas:       https://api.minimax.io/v1
API_BASE = os.getenv("MINIMAX_API_BASE")
if not API_BASE:
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
API_KEY = os.getenv("MINIMAX_API_KEY")
# China Mainland: https://api.minimaxi.com/v1
# Overseas:       https://api.minimax.io/v1
API_BASE = os.getenv("MINIMAX_API_BASE")
if not API_BASE:
    raise SystemExit("ERROR: MINIMAX_API_BASE is not set.")
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Static analysis

No suspicious patterns detected.