Back to skill

Security audit

Smallest Ai

Security checks for vulnerabilities and agentic risk

Overview

This skill is a coherent Smallest AI voice integration, but users should understand that text and audio are sent to a third-party API.

Install only if you are comfortable sending selected text, audio files, and metadata to Smallest AI for processing. Avoid using it for secrets, regulated data, private recordings, or other people's voices unless you have authorization and have reviewed the provider's privacy and retention terms. Prefer the shell/curl scripts or a pinned SDK version in an isolated environment if using Python.

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

T08 · Insecure Dependencies

Warning
Location
references/api-reference.md:115
Finding
Unpinned Python SDK Creates a Supply-Chain Execution Risk## Vulnerability Details **File Location**: `SKILL.md:58`, `README.md:103`, `references/api-reference.md:115-119`, and `scripts/tts.py:24-35` **Vulnerability Type**: T08: Insecure Dependencies **Risk Level**: Medium The documentation recommends installing the `smallestai` Python package without a version constraint, integrity hash, or lock file: `SKILL.md:58`: ```text ### Python (requires `pip install smallestai` or just `requests`) ``` `README.md:103`: ```text Optional: `pip install smallestai` for the official SDK with async support and streaming. ``` `references/api-reference.md:115-119`: ```markdown ## Python SDK ```bash pip install smallestai ``` ``` When that package is available, `scripts/tts.py:24-35` automatically imports and invokes it: ```python def synthesize_sdk(text, voice, speed, rate, lang, out_path, api_key): """Use the official Smallest AI Python SDK.""" from smallestai.waves import WavesClient client = WavesClient(api_key=api_key) client.synthesize( text=text, voice=voice, save_as=out_path, sample_rate=rate, speed=speed, ) return True ``` ### Technical Analysis Installing a package without pinning an audited version allows the installed code to change independently of the reviewed Skill. Python packages may execute code during installation, module import, object initialization, or method invocation. The Skill automatically prefers the SDK whenever the import succeeds, so an altered package release would be placed directly in the TTS execution path. No evidence establishes that the current package is malicious. The issue is the absence of version and integrity controls around executable third-party code. This exceeds the minimum dependency requirement because the Skill already includes direct HTTPS and `curl` implementations that do not require the SDK. ### Attack Path 1. An attacker compromi ...[truncated 1369 chars]
Remediation
## Remediation Suggestions 1. Pin the SDK to a reviewed release, for example: ```bash python3 -m pip install "smallestai==REVIEWED_VERSION" ``` 2. Publish a lock file or requirements file containing cryptographic hashes and require hash verification: ```bash python3 -m pip install --require-hashes -r requirements.txt ``` 3. Record the reviewed package version, expected publisher, package index, and release provenance in the documentation. 4. Prefer the fixed-endpoint `requests` or `curl` implementation unless SDK-specific functionality is required. 5. Consider making SDK use explicit rather than automatically importing and preferring any installed package. 6. Install dependencies in an isolated virtual environment under an unprivileged account. 7. Add dependency scanning and release verification to the project's maintenance process. 8. Keep API credentials narrowly scoped and rotate `SMALLEST_API_KEY` if dependency compromise is suspected.
Vulnerability Patterns
  • 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
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
Findings (42)

Tainted flow: 'api_key' from os.environ.get (line 174, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
with open(audio_path, "rb") as f:
        audio_data = f.read()

    response = requests.post(
        "https://api.smallest.ai/waves/v1/pulse/get_text",
        params=params,
        headers={
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_key' from os.environ.get (line 141, credential/environment) → requests.post (network output)

Critical
Category
Data Flow
Content
"""Use the requests library for direct HTTP calls."""
    import requests

    response = requests.post(
        "https://api.smallest.ai/waves/v1/lightning-v3.1/get_speech",
        headers={
            "Authorization": f"Bearer {api_key}",
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
98% confidence
Finding
The code chunk implements only STT/transcription behavior and does not perform any text-to-speech, speech synthesis, voice cloning, or voice selection. While the STT-related parts of the description align well with the code (Pulse model, multilingual transcription, diarization/timestamps/emotions), the declared purpose materially overstates the skill by presenting it as a combined TTS/STT and voice-cloning tool. No undeclared suspicious capability is present; the mismatch is that the description promises major capabilities absent from the code.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The declared description describes a broad multimodal audio skill covering both TTS and STT, including reading text aloud, generating speech, and cloning voices. The actual code chunk only performs speech-to-text by sending an audio file to the Pulse get_text endpoint. It accepts audio input, never accepts text for synthesis, does not select voices, and does not invoke any TTS or voice-cloning API. The implemented behavior is consistent with a subset of the description (transcription) but materially narrower than the declared primary purpose, so this is a description-to-behavior mismatch.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The code chunk is narrowly focused on synthesizing speech from text. It parses text and TTS parameters, requires an API key, and invokes Smallest AI's TTS service via SDK, requests, or curl, then writes a WAV file. There is no logic for uploading or processing audio input, no transcription/STT endpoint usage, and no voice-cloning workflow. The TTS-related parts of the description are accurate, but the broader declared description materially overstates the implemented capabilities in this supplied code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The code chunk clearly performs text-to-speech only. It parses text, voice, rate, speed, language, and output path, then POSTs to Smallest AI's /lightning-v3.1/get_speech endpoint and saves the returned WAV file. There is no handling of audio input, no transcription logic, no speech-to-text API usage, and no voice cloning functionality. The declared description presents a broader skill covering TTS, STT, and voice cloning, but the supplied code supports only TTS. Access to the Smallest AI API and local file output are consistent with the TTS portion, and there are no unrelated hidden behaviors.

Missing User Warnings

High
Confidence
99% confidence
Finding
Voice cloning involves biometric voice data, which is sensitive personal information and can be abused for impersonation, fraud, or non-consensual synthesis. Advertising this capability without any consent, authorization, or safety guidance materially increases the risk of misuse in the skill's intended context.

Credential Access

High
Category
Privilege Escalation
Content
## Setup

1. Get API key from https://waves.smallest.ai → click "API Key" in left panel
2. Set `SMALLEST_API_KEY` in your environment:
```bash
export SMALLEST_API_KEY="your_key_here"
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

External Script Fetching

High
Category
Supply Chain
Content
80+ more voices available. Fetch the full list via API:
```bash
curl -s "https://api.smallest.ai/waves/v1/lightning-v3.1/get_voices" \
  -H "Authorization: Bearer $SMALLEST_API_KEY" | python3 -m json.tool
```
Confidence
90% confidence
Finding
Remote code is downloaded and executed. This bypasses code review and could introduce malicious code.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The plan routes user reply text to a third-party TTS provider but does not mention consent, disclosure, or controls for sensitive content. In an agent context, replies may contain personal, confidential, or regulated data, so silent external transmission can create privacy, compliance, and data-handling risk.

External Transmission

Medium
Category
Data Exfiltration
Content
### TTS: Lightning v3.1

```
POST https://api.smallest.ai/waves/v1/lightning-v3.1/get_speech
Authorization: Bearer <SMALLEST_API_KEY>
Content-Type: application/json
```
Confidence
90% confidence
Finding
This finding reflects intentional external transmission to a third-party API. In this skill context, that is expected for cloud TTS, but it is still security-relevant because arbitrary reply text may leave the local trust boundary and be processed by an external vendor.

Description-Behavior Mismatch

Medium
Confidence
98% confidence
Finding
The skill manifest says the skill provides both STT and voice cloning, but the plan states "STT: Pulse (future scope, not in initial PR)" and later lists voice cloning as future work. The described code changes throughout the file are limited to adding a native TTS provider, so the documented implementation scope does not match the broader manifest claims.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The examples encourage reading email summaries aloud and transcribing meetings with speaker labels and action items, both of which commonly contain confidential content. Presenting these workflows without any notice about third-party data processing, consent requirements, or sensitivity handling can lead users to expose personal, corporate, or legally protected information.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The README explicitly promotes transcribing WhatsApp voice notes and building a voice-in/voice-out loop, which can involve highly sensitive personal or business communications. Because the documentation does not warn that audio is sent to a third-party service or advise users to obtain consent and avoid regulated/sensitive data, it creates a real privacy and compliance risk through unsafe default usage.

Lp3

Medium
Category
MCP Least Privilege
Confidence
96% confidence
Finding
The skill declares it requires environment variables and uses shell/network-capable workflows, but it does not define an explicit tool scope such as permissions or allowed-tools. That creates unnecessary ambiguity about what the skill may access or invoke at runtime, increasing the chance of over-privileged execution or unintended command/network use.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The skill encourages users to submit text and audio for processing by a third-party API without clearly warning that content leaves the local environment. This can expose sensitive text, recordings, or transcriptions to an external provider without informed user consent, which is especially risky for personal, confidential, or regulated data.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The trigger guidance is broad enough to overlap with ordinary phrases like 'say', 'speak', or 'read aloud', which can lead to accidental invocation. In this skill's context, unintended activation could cause private text or audio to be sent to an external speech provider or generate unexpected media output.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
This markdown file documents authenticated REST/WebSocket calls and examples that send user-provided text and audio to a remote service, but it does not include any warning or disclosure about transmitting potentially sensitive data off-device. Under the markdown-specific SQP-2 criteria, descriptions of behaviors affecting user data or privacy should warn users when data is sent to external services.

External Transmission

Medium
Category
Data Exfiltration
Content
with open(audio_path, "rb") as f:
        audio_data = f.read()

    response = requests.post(
        "https://api.smallest.ai/waves/v1/pulse/get_text",
        params=params,
        headers={
Confidence
70% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The script uploads complete audio content to a third-party remote API without an explicit runtime warning or consent gate about privacy, retention, or network transmission. Because speech data may contain sensitive personal, biometric, health, legal, or business information, silent exfiltration to an external processor creates a real privacy and compliance risk in this skill context.

subprocess module call

Medium
Category
Dangerous Code Execution
Content
f"&emotion_detection={'true' if emotions else 'false'}"
    )

    result = subprocess.run(
        [
            "curl", "-s",
            "--connect-timeout", "15",
Confidence
70% confidence
Finding
subprocess module calls execute external commands. Without careful input validation, this enables command injection.

Tainted flow: 'api_key' from os.environ.get (line 174, credential/environment) → subprocess.run (code execution)

Medium
Category
Data Flow
Content
f"&emotion_detection={'true' if emotions else 'false'}"
    )

    result = subprocess.run(
        [
            "curl", "-s",
            "--connect-timeout", "15",
Confidence
65% confidence
Finding
Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.

External Transmission

Medium
Category
Data Exfiltration
Content
PARAMS="model=pulse&language=$LANG&diarize=$DIARIZE&word_timestamps=$TIMESTAMPS&emotion_detection=$EMOTIONS"

# API call
RESPONSE=$(curl -s \
  --connect-timeout 15 \
  --max-time 120 \
  -X POST \
Confidence
89% confidence
Finding
This curl invocation sends the contents of the local audio file and metadata parameters to an external network endpoint. In an STT skill this is functionally required, but it is still a true external-transmission risk because users may supply sensitive recordings and the script performs the upload without additional trust-boundary warnings or controls.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The script uploads the provided audio file to a third-party API for transcription but does not provide any explicit runtime warning, consent prompt, or privacy notice before transmitting potentially sensitive voice data. Because speech recordings can contain personal, confidential, or regulated information, silent exfiltration to an external service creates a real privacy and compliance risk even if this is the expected product behavior.

External Transmission

Medium
Category
Data Exfiltration
Content
"""Use the requests library for direct HTTP calls."""
    import requests

    response = requests.post(
        "https://api.smallest.ai/waves/v1/lightning-v3.1/get_speech",
        headers={
            "Authorization": f"Bearer {api_key}",
Confidence
95% confidence
Finding
The skill transmits user-supplied text and authentication material to an external third-party service. In a TTS context this is functionally necessary, but it is still a real security/privacy concern because sensitive prompts, names, secrets, or regulated data could be sent off-host without explicit user awareness or policy controls.

Static analysis

Detected: suspicious.exposed_secret_literal

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
PLAN.md:156