Back to skill

Security audit

Yummy Gen Voice

Security checks for vulnerabilities and agentic risk

Overview

This TTS skill is mostly coherent, but it needs review because its shell command examples can mishandle user-provided text and it installs an unpinned executable dependency.

Install only if you trust the yummycli npm package and are comfortable providing Gemini credentials. Agents using this skill should pass text, speaker names, voices, and output paths as literal process arguments rather than constructing shell strings, and should choose an explicit output path for sensitive audio.

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)

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:49
Finding
Shell Command Injection Through User-Controlled Command Arguments<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 49-58 **Vulnerability Type**: Shell command injection through unsafe command construction **Risk Level**: High ### Vulnerable Code ```bash yummycli gemini speak --text "<text>" ``` ```bash yummycli gemini speak \ --text "<text>" \ --voice Kore \ --output narration.wav ``` ### Technical Analysis The documented command templates place user-controlled narration text directly inside shell commands. Although the placeholder is enclosed in double quotes, double-quoted Bash strings still process command substitutions such as `$(command)` and backtick expressions when those expressions become part of the command text parsed by the shell. The output path may also be user-controlled. If an agent constructs a shell command as a string by replacing these placeholders, malicious quotation marks, command substitutions, redirections, or shell metacharacters could alter the intended command. This issue applies when the agent generates or executes a shell command from the documented template. It can be avoided by invoking the executable directly with a structured argument array and without a shell. ### Attack Path 1. An attacker requests speech synthesis using malicious text, such as text containing `$(malicious-command)` or a quotation mark followed by shell syntax. 2. The agent substitutes the supplied text into the documented Bash template. 3. The resulting command string is passed to a shell for execution. 4. The shell interprets the injected command substitution or metacharacters before or alongside execution of `yummycli`. 5. The injected command runs with the operating-system privileges and environment available to the agent. ### Impact Assessment Successful exploitation could allow arbitrary local command execution with the agent's privileges. Depending on the execution environment, this could permit: - Reading or modifying files accessible to the agent. - Accessing environment vari ...[truncated 389 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Explicitly prohibit constructing shell command strings by interpolating user-provided text, speaker names, voice values, or output paths. - Invoke `yummycli` directly with a structured argument array and shell execution disabled. Conceptually: ```javascript execFile("yummycli", [ "gemini", "speak", "--text", userText, "--voice", selectedVoice, "--output", outputPath ]); ``` - If only a shell execution interface is available, pass untrusted values through positional parameters rather than inserting them into command source text. - Validate voices and models against explicit allowlists. - Validate speaker names according to a restrictive documented format. - Resolve the output path and require it to remain inside an approved workspace directory. - Continue enforcing the `.wav` suffix, but do not treat suffix validation alone as sufficient path validation. - Reject output paths containing traversal components or paths that resolve through symbolic links outside the approved directory. - Add tests using quotation marks, `$()`, backticks, semicolons, redirections, newlines, and path traversal sequences to verify that each value is passed as one literal process argument. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:18
Finding
Unpinned Executable npm Dependency<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 18-21 **Vulnerability Type**: Unpinned third-party executable dependency **Risk Level**: Medium ### Vulnerable Code ```yaml install: - kind: node package: "@yummysource/yummycli" bins: ["yummycli"] ``` ### Technical Analysis The skill declares the npm package `@yummysource/yummycli` without an exact version or integrity value. Consequently, installation may resolve to a package release different from the release that was originally tested or audited. The package supplies an executable invoked by the skill. It operates in a context that may contain `GEMINI_API_KEY`, receives user-provided TTS content, writes local files, and may communicate with external services. A compromised publisher account, malicious package update, or unexpectedly incompatible future release could therefore execute code with the agent's permissions. No evidence in the audited file demonstrates that the current package is malicious. The vulnerability is the mutable and unverified dependency resolution process. ### Attack Path 1. An attacker compromises the package publisher, package registry account, or another part of the dependency publication pipeline. 2. The attacker publishes a malicious release under the same package name. 3. A subsequent skill installation resolves `@yummysource/yummycli` to that release because no exact version is specified. 4. Package installation hooks or the installed `yummycli` executable run attacker-controlled code. 5. The malicious code accesses resources available to the installation or runtime process, potentially including credentials, user-provided text, workspace files, and network access. ### Impact Assessment A malicious resolved dependency could obtain the same privileges as the process installing or running the package. Potential consequences include: - Theft of `GEMINI_API_KEY` or other inherited environment variables. - Disclosure of text submitted for spee ...[truncated 375 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin `@yummysource/yummycli` to a specific version that has been reviewed, rather than allowing mutable latest-version resolution. - Where supported by the skill installation format, record and verify the package integrity hash. - Use a lockfile or equivalent immutable dependency manifest for the package and its transitive dependencies. - Retrieve packages only from an explicitly configured trusted registry. - Review package provenance, publisher identity, release signatures, and npm provenance attestations before updating. - Treat dependency updates as security-relevant changes and repeat the audit for each version change. - Disable package lifecycle scripts during installation where they are unnecessary. - Provide `GEMINI_API_KEY` only to the runtime process that requires it, and prevent installation processes from inheriting the credential. - Run the CLI with restricted filesystem and network permissions appropriate to its TTS function. ]]>
Vulnerability Patterns
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • 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 (2)

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The skill explicitly describes generating `.wav` files and notes that, when `--output` is omitted, a timestamped audio file is written to the current working directory, but it does not prominently warn that this creates a persistent disk artifact. In agentic contexts, this can lead to unexpected local file creation, leakage of sensitive synthesized content into shared workspaces, or storage of files in directories the user did not intend.

Vague Triggers

Low
Confidence
81% confidence
Finding
The 'When to Use' line lists generic requests such as 'convert text to audio' and 'generate a voiceover' as activation cues, but it does not include exclusion conditions or negative examples. In a markdown skill description, this can make invocation boundaries less precise and increase the chance of unintended activation for adjacent audio-editing or non-Gemini workflows.

Static analysis

No suspicious patterns detected.