Back to skill

Security audit

Supertonic TTS

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly coherent for local text-to-speech, but it needs review because its scripts trust an unrelated shared Python environment and use unpinned downloaded components.

Install only if you are comfortable with a Python package and model download running under your user account. Prefer a dedicated virtual environment with pinned and hash-checked dependencies, avoid relying on the browser-use virtualenv, and use voice cloning only if uploading biometric voice audio to Supertone is acceptable for your use case.

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 (2)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:29
Finding
Unpinned Third-Party Package Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:29-35`; duplicated in `references/deployment.md:3-8` **Vulnerability Type**: Unpinned and unverified third-party dependency **Risk Level**: Medium ```markdown ## Prerequisites Requires the Python SDK and model assets. Install once: ```bash pip install supertonic ``` ``` The deployment reference repeats the installation instruction: ```markdown ## Python SDK ```bash pip install supertonic ``` - First run auto-downloads ~400MB model from Hugging Face - Models cached in `~/.cache/supertonic3/` - Minimal dependencies: onnxruntime, numpy, soundfile, huggingface-hub ``` ### Technical Analysis The installation instructions retrieve the latest available `supertonic` distribution from the user's configured Python package index. No reviewed version, cryptographic hash, lock file, trusted index URL, or isolated environment is specified. Python packages can execute code during installation and whenever imported. Consequently, the effective code executed by this Skill may change after the Skill itself has been reviewed. This creates exposure to compromised upstream releases, package-index compromise, and unsafe private-index configuration. The scripts subsequently import `supertonic` and instantiate its `TTS` class. This finding does not establish that the current `supertonic` package is malicious. It identifies the absence of controls that would ensure users install the same reviewed dependency. ### Attack Path 1. An attacker compromises the upstream package, a future release, or a package index selected by the user's `pip` configuration. 2. The attacker publishes a malicious distribution under the expected `supertonic` package name. 3. A user follows the documented `pip install supertonic` instruction without a pinned version or hash. 4. Malicious package code executes during installation or when either Skill script imports `supertonic`. 5. The package gains the privileges and data access of the ...[truncated 468 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `supertonic` and all transitive dependencies to versions that have been reviewed and tested. 2. Provide a hash-locked requirements file, for example: ```text supertonic==<reviewed-version> --hash=sha256:<verified-distribution-hash> ``` 3. Install with hash enforcement: ```bash python3 -m pip install --require-hashes -r requirements.txt ``` 4. Document and enforce the expected package index, while ensuring credentials are not embedded in project files. 5. Use a dedicated virtual environment rather than installing into a user-wide or system-wide Python environment. 6. Add automated dependency vulnerability and integrity scanning to the release process. 7. Review and pin dependencies involved in automatic model retrieval, and document the trusted Hugging Face repository and expected model revisions or checksums. ]]>

T08 · Insecure Dependencies

Warning
Location
scripts/synthesize.py:14
Finding
Local Module Hijacking Through an Unrelated Shared Virtual Environment<![CDATA[ ## Vulnerability Details **File Location**: `scripts/synthesize.py:14-27`; equivalent behavior in `scripts/list_voices.py:9-22` **Vulnerability Type**: Unsafe import-path modification and shared-environment dependency trust **Risk Level**: Medium The synthesis script modifies import precedence before importing `supertonic`: ```python # Auto-activate venv _VENV = Path.home() / ".openclaw/workspace/.browser-use-venv" if _VENV.is_dir(): sp = _VENV / f"lib/python{sys.version_info.major}.{sys.version_info.minor}/site-packages" if not sp.is_dir(): for v in [(3,14), (3,13), (3,12), (3,11)]: sp = _VENV / f"lib/python{v[0]}.{v[1]}/site-packages" if sp.is_dir(): break if str(sp) not in sys.path and sp.is_dir(): sys.path.insert(0, str(sp)) try: from supertonic import TTS ``` The voice-listing script contains the equivalent logic: ```python # Auto-activate venv _VENV = Path.home() / ".openclaw/workspace/.browser-use-venv" if _VENV.is_dir(): sp = _VENV / f"lib/python{sys.version_info.major}.{sys.version_info.minor}/site-packages" if not sp.is_dir(): for v in [(3,14), (3,13), (3,12), (3,11)]: sp = _VENV / f"lib/python{v[0]}.{v[1]}/site-packages" if sp.is_dir(): break if str(sp) not in sys.path and sp.is_dir(): sys.path.insert(0, str(sp)) try: from supertonic import TTS ``` ### Technical Analysis Both scripts treat `~/.openclaw/workspace/.browser-use-venv` as a trusted source of Python modules even though its name indicates that it belongs to a separate browser-use component. The selected `site-packages` directory is inserted at index zero of `sys.path`, giving modules in that directory priority over packages available through the script's normal interpreter environment. Python executes top-level module code during import. Therefore, a malicious `supertonic.py` file or `supertonic` package placed in this shared envi ...[truncated 1674 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the automatic `sys.path` modification from both scripts. 2. Create a dedicated virtual environment for this Skill instead of reusing the browser-use environment: ```bash python3 -m venv .venv .venv/bin/python -m pip install --require-hashes -r requirements.txt ``` 3. Invoke the scripts through the dedicated environment's interpreter: ```bash .venv/bin/python scripts/synthesize.py "Hello" ``` 4. Pin and hash-lock all dependencies installed into that environment. 5. Do not search site-package directories associated with Python versions other than the active interpreter. 6. If environment discovery is necessary, verify that the resolved interpreter and package directory belong to the Skill's dedicated environment before importing dependencies. 7. Restrict write permissions on the dedicated environment so unrelated components cannot replace installed modules. 8. Consider verifying the imported module's resolved path during startup and fail closed if it is outside the expected environment. ]]>
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • 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
Findings (1)

Context-Inappropriate Capability

Low
Confidence
90% confidence
Finding
The script prepends a user-home virtualenv site-packages path to sys.path, causing imports to come from a mutable location outside the skill/package boundary. It also enables TTS(auto_download=True), which permits network-driven code/resource retrieval at runtime; together these behaviors increase supply-chain and environment-hijacking risk if a local attacker or compromised environment can control that virtualenv or downloaded artifacts.

Static analysis

No suspicious patterns detected.