Back to skill

Security audit

OpenClaw Turbo-Bundle: Groq, OpenRouter & Elite TTS

Security checks for vulnerabilities and agentic risk

Overview

The skill mostly matches its Groq/OpenRouter voice-assistant purpose, but its setup installs uncontrolled third-party packages and its external API use is under-disclosed.

Review this before installing. Use a virtual environment, pin or audit dependencies, and avoid running configure.py from an untrusted directory. Only provide Groq/OpenRouter keys you are comfortable using with this skill, and do not send sensitive text for TTS unless you accept that it will be transmitted to the provider.

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)

T08 · Insecure Dependencies

Warning
Location
configure.py:17
Finding

Automatic Installation of Unpinned and Undeclared Third-Party Dependencies

Content
View full analysis

Vulnerability Details

File Location: configure.py:17-19, requirements.txt:1-2
Vulnerability Type: Supply-chain exposure through unpinned dependencies
Risk Level: Medium

Vulnerable code:

python
# 1. Install dependencies
run_cmd("pip install -r requirements.txt")
run_cmd("pip install free-ride")
text
groq>=1.1.1
python-dotenv>=1.0.0

Technical Analysis

The setup script automatically installs packages from the active Python package registry. The groq and python-dotenv requirements use open-ended minimum-version constraints, so future releases can be selected without review. The free-ride package is installed separately without any version constraint and is not declared in the reviewed dependency manifest.

Python package installation may execute package build or installation logic. Therefore, a compromised package release, dependency-confusion event, malicious registry response, or subsequently published unsafe version could execute arbitrary code when a user follows the documented python configure.py setup procedure.

No evidence establishes that the currently named packages are malicious. The vulnerability is the absence of version locking, hash verification, and controlled dependency provenance.

Attack Path

  1. An attacker compromises a package release, a transitive dependency, or the package registry used by the victim.
  2. Alternatively, an unsafe future version becomes eligible under the open-ended constraints.
  3. A user follows the installation documentation and runs python configure.py.
  4. The script invokes pip and downloads the uncontrolled package version.
  5. Malicious package installation or runtime code executes with the privileges of the user running the configuration script.

Impact Assessment

Successful exploitation could permit arbitrary code execution under the installing user's account. The resulting scope may include access to ...[truncated 230 chars]

Remediation
View remediation

Remediation Suggestions

  1. Pin every direct and transitive dependency to an exact, reviewed version.
  2. Generate a lock file containing cryptographic hashes and install with pip's --require-hashes option.
  3. Add free-ride to the reviewed dependency manifest with an exact version and hashes, or remove it if it is unnecessary.
  4. Use a trusted, explicitly configured package index and review package ownership and provenance.
  5. Install dependencies inside a dedicated virtual environment with minimum privileges.
  6. Use automated dependency scanning and controlled update reviews before accepting newer releases.
  7. Separate dependency installation from normal setup and require explicit user confirmation before downloading or executing third-party packages.

T09 · Insecure Skill Coding Practices

Note
Location
configure.py:7
Finding

Shell-Based Installer Uses Environment-Dependent Executable and Relative Requirements Path

Content
View full analysis

Vulnerability Details

File Location: configure.py:7-12, configure.py:17-19
Vulnerability Type: Unsafe subprocess invocation and working-directory-dependent path resolution
Risk Level: Low

Vulnerable code:

python
def run_cmd(cmd):
    print(f"Running: {cmd}")
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"Error: {result.stderr}")
    return result.stdout
python
# 1. Install dependencies
run_cmd("pip install -r requirements.txt")
run_cmd("pip install free-ride")

Technical Analysis

The script passes command strings through subprocess.run(..., shell=True) even though no shell functionality is required. Although the current command strings are fixed and do not include user-controlled interpolation, shell invocation unnecessarily expands the attack surface.

The bare pip command is resolved according to the process environment and executable search path rather than being tied to the Python interpreter running configure.py. An attacker-controlled executable earlier in that search path could therefore be invoked instead of the intended pip program.

In addition, requirements.txt is a relative path resolved from the caller's current working directory, not from the directory containing configure.py. If the script is launched from another directory containing an attacker-controlled file with that name, pip may install unintended dependencies.

The function also does not raise an exception when a command fails. Setup continues and prints a completion message, which can leave users with a partially installed or inconsistent environment.

Attack Path

  1. An attacker obtains influence over the victim's executable search path or persuades the victim to execute the setup from an attacker-controlled directory.
  2. The attacker places a malicious executable named pip in a higher-priority search- ...[truncated 802 chars]
Remediation
View remediation

Remediation Suggestions

Avoid the shell, bind pip to the active Python interpreter, resolve the requirements file relative to the script, and terminate setup on failure:

python
import subprocess
import sys
from pathlib import Path

def install_dependencies():
    project_dir = Path(__file__).resolve().parent
    requirements = project_dir / "requirements.txt"

    subprocess.run(
        [
            sys.executable,
            "-m",
            "pip",
            "install",
            "--require-hashes",
            "-r",
            str(requirements),
        ],
        check=True,
    )

Place every required package in the locked requirements file rather than issuing a separate string-based installation command. Validate that the requirements file exists and is a regular file before invoking pip. Use check=True and report setup as complete only after every required operation succeeds.

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
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (21)

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
96% confidence
Finding

Using subprocess.run with shell=True is a classic tool-parameter abuse pattern because it delegates parsing to the shell and expands the attack surface for metacharacters, environment manipulation, and path hijacking. Although this script currently invokes fixed pip install commands, the skill context is a setup/bootstrap script, which commonly evolves to consume external parameters and therefore makes this unsafe pattern more concerning.

Content

Scanner excerpt · configure.py (reported line 9)May include surrounding context.

python
def run_cmd(cmd):
    print(f"Running: {cmd}")
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"Error: {result.stderr}")
    return result.stdout

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · configure.py (reported line 29)May include surrounding context.

python
print("\nSetup complete!")
    print("1. Copy the 'skills/groq-arabic-tts' folder to your workspace/skills/.")
    print("2. Copy 'config/MODELS_JSON_EXAMPLE.txt' info into your models.json.")
    print("3. Rename 'ENV_EXAMPLE.txt' to '.env' and add your API key.")
    print("\nStay fast and free with your new vocal AI assistant!")

if __name__ == "__main__":

Credential Access

High
Category
Privilege Escalation
Confidence
92% confidence
Finding

The explicit loading of a local .env file is credential-access behavior and increases the skill's access to secrets stored near the code. In a shared agent workspace, this pattern is dangerous because skills should not implicitly harvest local secrets unless clearly justified and constrained.

Content

Scanner excerpt · skills/groq-arabic-tts/speech.py (reported line 7)May include surrounding context.

python
from groq import Groq
from dotenv import load_dotenv

# Load API key from local .env
env_path = Path(__file__).parent / ".env"
load_dotenv(dotenv_path=env_path)

Credential Access

High
Category
Privilege Escalation
Confidence
92% confidence
Finding

The code path around the .env loading and subsequent environment access confirms the skill is sourcing credentials from local configuration. Even without exfiltration shown in this file, unnecessary secret access is itself a risk because it normalizes broad secret availability to code that may later be modified or reused insecurely.

Content

Scanner excerpt · skills/groq-arabic-tts/speech.py (reported line 8)May include surrounding context.

python
from dotenv import load_dotenv

# Load API key from local .env
env_path = Path(__file__).parent / ".env"
load_dotenv(dotenv_path=env_path)

api_key = os.getenv("GROQ_API_KEY")

Credential Access

High
Category
Privilege Escalation
Confidence
94% confidence
Finding

Using the retrieved GROQ_API_KEY to initialize the API client operationalizes the secret and enables external service use from the skill. In this context, the danger is not that the key is immediately leaked in code, but that secret access plus network capability allows unreviewed third-party transmission and potential billing abuse.

Content

Scanner excerpt · skills/groq-arabic-tts/speech.py (reported line 13)May include surrounding context.

python
api_key = os.getenv("GROQ_API_KEY")
if not api_key:
    print("Error: GROQ_API_KEY not found in .env file.")
    sys.exit(1)

client = Groq(api_key=api_key)

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
78% confidence
Finding

The README describes the voice capability as providing 'Professional Saudi Arabic and English voices' only, with no indication that users can choose other languages or that the scope is intentionally region-specific. This can constitute a language/locale policy issue because the skill presents a fixed bilingual language constraint without explicit opt-in or justification.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

This file is named README_EN.md, but the operational instructions and usage guidance are primarily written in French. That creates a language-policy concern because users expecting English documentation are not offered an explicit language choice or opt-in.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The skill advertises Groq and OpenRouter integration plus cloud TTS, but the description does not warn that user prompts, generated content, or voice data may be transmitted to third-party APIs. This can mislead users into enabling the skill without understanding data disclosure, privacy, compliance, or cost implications, especially because the bundle is framed as 'cost-free' and optimized rather than externally connected.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
50% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · config/MODELS_JSON_EXAMPLE.txt (reported line 3)May include surrounding context.

text
{
  "groq": {
    "baseUrl": "https://api.groq.com/openai/v1",
    "apiKey": "VOTRE_CLE_GROQ_ICI",
    "models": [
      {

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
84% confidence
Finding

The config contains the natural-language label "Arabic Model" tied to a specific Arabic/Saudi model, which implies a language/locale constraint. There is no accompanying opt-in, user choice, or documented region-specific justification in this file, so it may violate the language/locale policy requirement.

Content

No source excerpt is available for this finding.

subprocess module call

Medium
Category
Dangerous Code Execution
Confidence
95% confidence
Finding

The helper executes shell commands with shell=True, which is dangerous because any future untrusted input passed into run_cmd could lead to command injection. In this file the current callers use hardcoded strings, so the immediate exploitability is limited, but the reusable wrapper normalizes an unsafe pattern in a setup script that installs packages from the network.

Content

Scanner excerpt · configure.py (reported line 9)May include surrounding context.

python
def run_cmd(cmd):
    print(f"Running: {cmd}")
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"Error: {result.stderr}")
    return result.stdout

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
89% confidence
Finding

The skill includes a hard requirement that the agent must always output a specific response artifact, which overrides normal user-directed behavior and can force unintended output formatting or language-related behavior without user consent. Even though the static label mentions French-language forcing, the broader issue is instruction injection inside the skill that compels fixed output, reducing agent autonomy and potentially exposing internal/local resource links to users.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The skill loads a local .env file and reads a GROQ_API_KEY, which is credential access behavior. While this is common for API-backed utilities, the skill metadata provides no declared need, scope, or permission model for accessing local secrets, so the behavior expands trust boundaries and could expose or misuse credentials in an agent environment.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

If the caller omits the language argument, the code silently selects Arabic ("ar") and the Saudi Arabic model rather than prompting for or negotiating the user's preferred language. This is a natural-language policy concern because it imposes a language/locale default without explicit opt-in or a clearly documented region-specific justification in the file.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The script sends data to an external Groq TTS service over the network, but the skill description does not establish that outbound network access is expected or authorized. In an agent skill context, undisclosed external calls are risky because they transfer user content outside the local environment and rely on a third-party service.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

User-provided text is transmitted to a third-party API using stored credentials without any user-facing warning, consent, or disclosure. This creates a privacy and compliance risk because sensitive text may be sent off-host unexpectedly, and the user is not informed that a paid/authenticated external service is being used.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
86% confidence
Finding

The README instructs users to place GROQ_API_KEY in a .env file and set OPENROUTER_API_KEY in environment variables, but it provides no user-facing warning about treating these values as sensitive secrets or avoiding accidental exposure. For a markdown file, credential-related behavior should include a brief warning when privacy or account security could be affected.

Content

No source excerpt is available for this finding.

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
77% confidence
Finding

The description presents Saudi Arabic and English voices as a built-in scope without stating that language/voice selection is optional or user-configurable. This can create unwanted localization behavior or biased defaults, reducing user autonomy and potentially causing inappropriate output selection in multilingual contexts.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
96% confidence
Finding

The dependency specifier groq>=1.1.1 is unpinned, so installs may resolve to different future versions over time. That creates supply-chain and reproducibility risk because a later release could introduce breaking changes or a vulnerable package version without any review by the skill author.

Content

Scanner excerpt · requirements.txt (reported line 1)May include surrounding context.

text
groq>=1.1.1
python-dotenv>=1.0.0

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
99% confidence
Finding

The dependency specifier python-dotenv>=1.0.0 is unpinned, allowing installation of any later version. This is risky because dependency resolution becomes non-deterministic and may pull in a compromised or vulnerable release, especially relevant here since known advisories exist for this package family.

Content

Scanner excerpt · requirements.txt (reported line 2)May include surrounding context.

text
groq>=1.1.1
python-dotenv>=1.0.0

Unverifiable Dependency: python-dotenv has 2 known advisory(ies) (CVE-2026-28684 (python-dotenv: Symlink following in set_key allows arbitrary file overwrite via ); CVE-2026-28684 (python-dotenv reads key-value pairs from a .env file and can set them as environ)), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
92% confidence
Finding

python-dotenv has known advisories, and because the manifest does not pin a version, there is no way to verify whether the eventually installed version is affected. In a skill context, dotenv libraries often process local environment files, so a vulnerable version could matter if the skill writes .env entries or operates in directories influenced by an attacker.

Content

No source excerpt is available for this finding.