Back to skill

Security audit

Waifu Generator Skill

Security checks for vulnerabilities and agentic risk

Overview

This skill does what it claims, but users should understand it sends prompts and an API token to an external image-generation service.

Install only if you are comfortable sending your image prompts, optional reference image UUIDs, and Neta API token to api.talesofai.com. Avoid putting long-lived or high-value tokens directly in shell commands when possible, rotate the token if it may have been logged, and prefer a pinned or verified install source if available.

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

Warning
Location
waifugenerator.js:11
Finding
API Token Exposure Through Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `waifugenerator.js:11-12, 22-29`; documented in `SKILL.md:13-17` and `README.md:71-76` **Vulnerability Type**: Sensitive credential exposure through process arguments **Risk Level**: Medium ### Vulnerable Code ```javascript } else if (args[i] === "--token" && args[i + 1]) { tokenFlag = args[++i]; } ``` ```javascript // --- Token resolution --- const TOKEN = tokenFlag; if (!TOKEN) { console.error("Token required. Pass via: --token YOUR_TOKEN"); process.exit(1); } ``` The documented invocation explicitly places the credential on the command line: ```bash node <script> "your prompt" --token YOUR_TOKEN ``` ### Technical Analysis The skill accepts its Neta API token exclusively through the `--token` command-line argument. Command-line arguments are not an appropriate secret-transport mechanism because they can be exposed through: - Shell history files. - Process listings and process inspection interfaces. - Command telemetry, terminal logging, or audit systems. - Wrapper scripts and automation logs that record complete commands. The token is legitimately transmitted to the intended API through the `x-token` header, but its initial acquisition through `process.argv` unnecessarily exposes it on the local system. No hardcoded token or transmission to an unrelated domain was identified. ### Attack Path 1. A user follows the documented command and supplies a valid token using `--token`. 2. The shell records the complete command in its history, or the argument remains visible through process inspection while the script is running. 3. Another local user, monitoring tool, support bundle, or log collector obtains the command-line contents. 4. The exposed token is extracted and replayed against the Neta API. 5. The attacker performs API operations within the authorization and quota associated with the compromised token. ### Impact Assessment Successful exploitation does not grant additional operating-syst ...[truncated 324 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Support a protected environment variable, such as `NETA_API_TOKEN`, as the primary authentication source. 2. Support reading the token interactively from a hidden terminal prompt or from standard input without echoing it. 3. If `--token` must remain for compatibility, mark it as insecure and deprecated. 4. Update all documentation examples so they do not embed credentials in command lines. 5. Avoid including tokens in exceptions, debug output, telemetry, or request diagnostics. 6. Recommend short-lived, narrowly scoped tokens and provide token-rotation instructions. Example hardening approach: ```javascript const TOKEN = process.env.NETA_API_TOKEN; if (!TOKEN) { console.error("Token required. Set NETA_API_TOKEN or provide it through a secure prompt."); process.exit(1); } ``` Document usage without placing the secret directly in the command: ```bash read -s NETA_API_TOKEN export NETA_API_TOKEN node waifugenerator.js "your prompt" unset NETA_API_TOKEN ``` ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:31
Finding
Unpinned Remote Installation Chain<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:31-34`; duplicated in `README.md:12-16` **Vulnerability Type**: Mutable and unpinned third-party installation source **Risk Level**: Medium ### Vulnerable Code `SKILL.md` contains the following installation instruction: ```markdown ## Install ```bash npx skills add TomCarranzaem/waifu-generator-skill ``` ``` `README.md` similarly recommends: ```markdown **Via npx skills:** ```bash npx skills add TomCarranzaem/waifu-generator-skill ``` ``` ### Technical Analysis The documented installation process invokes `npx` without pinning the `skills` package to a specific version. It also identifies the skill using a mutable remote owner/repository reference without a release version, immutable commit identifier, checksum, lockfile, or signature. Consequently, code obtained by a future installation may differ from the artifact covered by this audit. If either the package distribution channel, installer package, repository, publisher account, or referenced default branch is compromised or maliciously modified, users can receive altered skill content without an integrity check. No malicious dependency or remote payload was found in the currently audited project. This finding concerns the unsafe, mutable installation chain documented for future installations. ### Attack Path 1. An attacker compromises the installer package, upstream repository, publisher account, or another mutable distribution component. 2. The attacker publishes or replaces the referenced content with a modified skill or installer version. 3. A user runs the documented unpinned `npx skills add TomCarranzaem/waifu-generator-skill` command. 4. `npx` resolves an unpinned installer version, and the installer obtains the current mutable skill content. 5. The user later loads or invokes the modified skill. 6. Malicious instructions or code execute with the permissions available to the user or hosting agent. ### Impact Assessment The event ...[truncated 408 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the `skills` package used by `npx` to an explicitly reviewed version rather than resolving the latest available version. 2. Pin the installed skill to an immutable release tag or, preferably, a full commit digest. 3. Publish cryptographic checksums or signatures for releases and verify them before installation. 4. Use lockfiles and package-manager integrity metadata where applicable. 5. Document the exact source revision corresponding to the reviewed release. 6. Protect publisher and repository accounts with multi-factor authentication and restricted release permissions. 7. Provide a manual installation procedure that allows users to download, verify, and inspect the exact artifact before execution. A hardened installation flow should conceptually resemble: ```bash npx skills@<reviewed-version> add TomCarranzaem/waifu-generator-skill@<immutable-release-or-commit> ``` The actual syntax should be verified against the installer, and the resulting artifact should be checked against a published checksum or signature. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (11)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding indicates a substantial description-behavior mismatch: the skill claims to use Neta AI but reportedly interacts with a different external service, includes reference-image editing behavior, and exposes CLI token handling not fully declared in the description. This kind of mismatch is dangerous because it undermines informed consent, conceals where sensitive prompts and credentials go, and may hide additional capabilities from reviewers and users.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The README states that prompts are sent to the Neta/talesofai API and also documents `--ref` reference-image usage, but it does not explicitly warn users that their prompts, tokens, and image identifiers may be transmitted to a third-party service. In an image-generation skill, this context makes the issue more significant because users may submit sensitive text or reference images assuming local-only processing.

Rp1

Medium
Category
MCP Rug Pull
Confidence
87% confidence
Finding
The README instructs users to install and run the skill via `npx skills` without pinning a specific version or immutable source. That creates a supply-chain risk: users may fetch whatever package/version is current at execution time, which could be replaced, updated maliciously, or differ from what was reviewed.

Rp1

Medium
Category
MCP Rug Pull
Confidence
84% confidence
Finding
The ClawHub install example references the skill by name only, without a pinned version or immutable identifier. This similarly exposes users to supply-chain drift or takeover risk if the published artifact changes after review.

Lp3

Medium
Category
MCP Least Privilege
Confidence
93% confidence
Finding
The skill declares only the Bash tool and does not specify any explicit tool scope or permissions, yet its described behavior clearly requires outbound network access to an external API. This creates a transparency and least-privilege problem: users and hosting systems cannot easily tell that prompts and tokens will be transmitted off-platform, increasing the risk of unintended data exposure.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill description does not clearly warn that user prompts and token-authenticated requests are transmitted to a third-party image generation service. This is a material omission because prompts may contain sensitive content and the token is a credential; users need clear notice before data leaves the local environment.

Vague Triggers

Medium
Confidence
90% confidence
Finding
The trigger guidance is very broad and can cause the skill to activate on generic requests to create images without meaningful constraints or confirmation. In a skill that sends prompts and authenticated requests to an external service, overbroad activation increases the chance of accidental invocation, unintended data sharing, and surprising external actions.

Rp1

Medium
Category
MCP Rug Pull
Confidence
88% confidence
Finding
The install instruction uses `npx skills` without pinning a specific version, which makes installation dependent on whatever package version is current at execution time. This weakens supply-chain integrity because a later compromised or incompatible release could be fetched and executed unexpectedly.

External Transmission

Medium
Category
Data Exfiltration
Content
// --- Submit job ---
async function submitJob() {
  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
Confidence
91% confidence
Finding
This finding highlights the hardcoded external destination https://api.talesofai.com/ used for image job submission. Hardcoded outbound network calls are risky in agent skills because they send user input and authentication material off-platform, and here the unexpected mismatch with the advertised Neta AI service makes the transmission more suspicious.

External Transmission

Medium
Category
Data Exfiltration
Content
// --- Submit job ---
async function submitJob() {
  const res = await fetch("https://api.talesofai.com/v3/make_image", {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
Confidence
91% confidence
Finding
This finding highlights the hardcoded external destination https://api.talesofai.com/ used for image job submission. Hardcoded outbound network calls are risky in agent skills because they send user input and authentication material off-platform, and here the unexpected mismatch with the advertised Neta AI service makes the transmission more suspicious.

External Transmission

Medium
Category
Data Exfiltration
Content
// --- Poll for result ---
async function pollTask(taskUuid) {
  const url = `https://api.talesofai.com/v1/artifact/task/${taskUuid}`;
  const MAX_ATTEMPTS = 90;
  const INTERVAL_MS = 2000;
Confidence
86% confidence
Finding
The polling request repeatedly contacts the same third-party API and includes the authentication header, extending exposure of credentials and metadata across many outbound requests. While it mainly retrieves job status, it still increases the attack surface and operational leakage to an external service.

Static analysis

No suspicious patterns detected.