T03 · Remote Payload Retrieval and Execution
- Location
references/setup.md:20- Finding
Remote Installer Downloaded and Executed Without Integrity Verification
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
The skill’s image and web-search functions are coherent, but it relies on unpinned external tooling with an API key and includes unsafe installer guidance.
Review before installing. Avoid the curl-to-sh installer path, prefer a pinned and reviewed MCP package, use a narrowly scoped MiniMax key, and do not submit sensitive images, URLs, or search queries unless you are comfortable sending them through MiniMax tooling. Clean up any Telegram images stored under ~/.openclaw/media/inbound if they may contain private data.
references/setup.md:20Remote Installer Downloaded and Executed Without Integrity Verification
scripts/understand_image.py:40Unpinned MCP Package Is Retrieved and Executed with API Credentials
There is a material description-behavior mismatch for this code chunk. The declared purpose says the skill analyzes images and searches the web, but the provided code only performs pre-publication setup and validation checks. While these checks may support the skill, this specific code does not implement the declared end-user functionality. It also accesses local environment variables and system executables, which are not reflected in the declared purpose or permissions.
The code chunk's behavior is narrowly focused on image understanding: it validates MINIMAX_API_KEY, starts uvx minimax-coding-plan-mcp, sends MCP requests for initialization and a single tools/call to understand_image, and prints the returned analysis. There is no logic for web searching, browsing, or calling any search-related tool. Therefore, the declared description overstates the implemented functionality in this code chunk. The external API/subprocess use is consistent with MiniMax MCP usage, but the omission of any declared permissions may be mildly inconsistent.
The description claims two capabilities: image analysis and web search using MiniMax MCP tools. The actual code only performs web search through the web_search MCP tool. It does not accept image inputs, invoke any image-analysis tool, or process image data. The subprocess execution and environment variable handling are supporting implementation details consistent with web search, not undeclared harmful capabilities. Therefore this is a description-behavior mismatch due to missing declared image-analysis functionality in the supplied code.
The command explicitly chains untrusted network input into shell execution via | sh, which is dangerous because it turns any upstream compromise into immediate code execution. This pattern materially increases exploitability compared with merely downloading a file, since it bypasses review and encourages blind execution.
Fallback: Official installer (curl|sh)
curl -LsSf https://astral.sh/uv/install.sh | sh
The | sh pattern is dangerous because it chains remote content retrieval directly into shell execution, making command review and validation unlikely. In a troubleshooting document, users are especially prone to copy-paste such commands under time pressure, which raises practical exploitation risk.
Install uvx:
curl -LsSf https://astral.sh/uv/install.sh | sh
The skill declares operational requirements for environment variables and a binary but does not define an explicit tool or permission scope, while its stated workflow clearly implies shell execution and outbound network use. In an agent environment, that gap can cause users or orchestrators to invoke the skill without understanding that it may access secrets and external services.
The skill encourages users to supply local image paths, image URLs, Telegram-sourced files, and search queries, but does not warn that these inputs may be transmitted to external MiniMax services. This creates a real privacy and data-handling risk because users may unintentionally submit sensitive images, URLs, or queries to a third party.
The README states that Telegram images are automatically saved to a local directory, but it does not clearly warn users about the privacy and data-retention implications of storing potentially sensitive user images on disk. In an image-analysis skill, users may reasonably assume transient processing, so undocumented local persistence increases the risk of unintended exposure through shared accounts, backups, or weak filesystem permissions.
The guide recommends piping a remotely fetched script directly into the shell, which removes the user's opportunity to inspect the script before execution and creates a supply-chain execution path if the remote host, transport, or published installer is compromised. In a setup document for developer tooling, this is especially risky because readers are likely to run the command verbatim on their workstation.
The setup guide instructs users to export an API key and append it directly into a shell profile without warning about risks such as plaintext credential persistence, accidental disclosure through dotfile syncing/backups, or exposure to other local users/processes. While common in developer docs, omitting safer handling guidance can lead to credential leakage and long-lived compromise of the associated MiniMax account.
The troubleshooting guide instructs users to modify shell startup files and execute a remote installer without any warning about persistence or system impact. While common in developer docs, these actions can permanently alter a user's environment and increase the chance of unsafe copy-paste execution, especially when paired with network-fetched scripts.
uvx/uv tool run commands without ==version create a rug-pull risk.
uvx/uv tool run commands without ==version create a rug-pull risk.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
Check network and API key:
curl -H "Authorization: Bearer $MINIMAX_API_KEY" https://api.minimaxi.com/v1/models
uvx/uv tool run commands without ==version create a rug-pull risk.
uvx/uv tool run commands without ==version create a rug-pull risk.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
def check_uvx():
"""Check if uvx is installed."""
print("1. Checking uvx installation...")
result = subprocess.run(['which', 'uvx'], capture_output=True, text=True)
if result.returncode == 0:
print(f" ✓ uvx found at: {result.stdout.strip()}")
return True
uvx/uv tool run commands without ==version create a rug-pull risk.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
for script in scripts:
path = os.path.join(script_dir, script)
if os.path.exists(path):
result = subprocess.run(['python3', '-m', 'py_compile', path],
capture_output=True, text=True)
if result.returncode == 0:
print(f" ✓ {script} is valid Python")
The skill executes an MCP server via uvx without pinning an exact package version or trusted source, which can cause different code to be fetched and run over time. Because the launched tool receives the API key in its environment and handles attacker-influenced inputs, a compromised or substituted package could exfiltrate credentials or execute arbitrary behavior.
The manifest describes a skill for analyzing images and searching the web using MiniMax MCP tools. While web search itself is in-scope, directly reading credentials from environment variables is a separate sensitive capability that is not stated in the manifest and is not inherent from the user-facing purpose alone.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
]
try:
proc = subprocess.Popen(
['uvx', 'minimax-coding-plan-mcp'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=env, text=True
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
]
try:
proc = subprocess.Popen(
['uvx', 'minimax-coding-plan-mcp'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=env, text=True
Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.
]
try:
proc = subprocess.Popen(
['uvx', 'minimax-coding-plan-mcp'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=env, text=True
Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.
]
try:
proc = subprocess.Popen(
['uvx', 'minimax-coding-plan-mcp'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=env, text=True