Back to skill

Security audit

Content Creator Workflow

Security checks for vulnerabilities and agentic risk

Overview

This skill matches its stated WhatsApp-to-image workflow, but it stores a messaging token in plaintext and can automatically process and reply to customer content without clear safeguards.

Review before installing or running against real customers. Use a test account first, avoid long-lived WhatsApp tokens, restrict ~/.wacli/config.json permissions or move the token to a secure secret store, add consent/privacy notices for OpenAI transcription and image generation, and put human review or policy checks in front of automatic replies before connecting a real WhatsApp backend.

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
scripts/wacli.py:20
Finding

WhatsApp Authentication Token Stored Without Enforced Access Restrictions

Content
View full analysis

Vulnerability Details

File Location: scripts/wacli.py:20-28
Vulnerability Type: Plaintext sensitive-data storage with insecure file permissions
Risk Level: Medium

Complete Code Snippet:

python
def save_config(self):
    os.makedirs(os.path.dirname(self.config_path), exist_ok=True)
    with open(self.config_path, "w") as f:
        json.dump(self.config, f, indent=2)

def login(self, auth_token):
    """Authenticate with WhatsApp CLI service"""
    self.config["auth_token"] = auth_token
    self.save_config()
    print("Login successful")

Technical Analysis

The login method stores the authentication token in the client configuration, and save_config writes that configuration as plaintext JSON to the default path ~/.wacli/config.json. The code does not explicitly create the containing directory with mode 0700 or the configuration file with mode 0600. Its effective permissions therefore depend on the process umask and any pre-existing directory or file permissions.

Because load_config later trusts and reads this file, any local account or process that can read it can obtain the token. If another user can modify the file, that user could also replace configuration values used by the client. The present WhatsApp implementation is a mock, but the token becomes security-sensitive when the documented real backend is connected.

Attack Path

  1. A user runs wacli.py login <token>.
  2. The supplied token is assigned to self.config["auth_token"].
  3. save_config writes the token in plaintext to ~/.wacli/config.json.
  4. File accessibility is determined by the environment's umask or pre-existing permissions rather than an enforced owner-only policy.
  5. A local process or user with read access copies the token.
  6. Once a real WhatsApp provider is connected, the copied token may be presented to that provider to impersonate the legitimate client, subject to the prov ...[truncated 522 chars]
Remediation
View remediation

Remediation Suggestions

  • Prefer an operating-system credential manager or dedicated secret-management service instead of a plaintext JSON file.
  • If file storage is unavoidable, create ~/.wacli with mode 0700 and atomically create the configuration file with mode 0600.
  • Before loading an existing configuration, verify that it is a regular file, is owned by the current user, and is not accessible by group or other users.
  • Avoid following symbolic links when creating or replacing the file. Write to a securely created temporary file in the same directory, set its permissions, and atomically rename it.
  • Separate sensitive credentials from non-secret settings such as the default phone number.
  • Support token rotation and revocation, and document immediate revocation procedures for suspected exposure.
  • Consider accepting the token through a protected environment variable or credential-helper interface rather than a command-line argument, since command-line arguments may be exposed through shell history or process inspection.

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding

Unpinned and Integrity-Unverified Python Dependencies

Content
View full analysis

Vulnerability Details

File Location: requirements.txt:1-4
Vulnerability Type: Non-reproducible dependency resolution without integrity verification
Risk Level: Medium

Complete Code Snippet:

text
openai>=1.0.0
pydub>=0.25.1
requests>=2.31.0
python-dotenv>=1.0.0

The documented installation command in SKILL.md:43-45 is:

bash
pip install -r {baseDir}/requirements.txt

Technical Analysis

Every dependency uses an open-ended minimum-version constraint. Installation can consequently resolve to versions that were not available or reviewed when the Skill was audited. No lockfile or package hashes constrain the artifacts selected by pip.

This does not establish that any currently named package is malicious. The weakness is that future compromised, malicious, or unexpectedly incompatible releases can be introduced without a corresponding project change. Python packages can execute build-related code during installation and application code when imported, so dependency compromise may affect both installation and runtime.

Attack Path

  1. An attacker compromises an upstream dependency release, its publisher account, or a package-distribution path.
  2. The attacker publishes a version satisfying one of the unrestricted >= constraints.
  3. A user follows the documented pip install -r requirements.txt procedure after that release becomes available.
  4. pip resolves the affected dependency or transitive dependency without checking it against a project-maintained hash allowlist.
  5. Malicious package code executes during package installation, import, or subsequent Skill execution with the privileges of the installing or running user.

This path depends on an upstream supply-chain compromise; the audited repository itself does not contain evidence that the currently declared package names are malicious or typosquatted.

Impact Assessment

A compromised depen ...[truncated 440 chars]

Remediation
View remediation

Remediation Suggestions

  • Pin all direct dependencies to reviewed versions and generate a lockfile that also records transitive dependencies.
  • Produce and verify cryptographic hashes for every approved distribution, using a workflow such as pip install --require-hashes -r requirements.txt.
  • Generate lock data separately for each supported Python version and platform where dependency artifacts differ.
  • Install only from explicitly trusted package indexes over TLS and disable unintended extra indexes to reduce dependency-confusion exposure.
  • Prefer isolated virtual environments and avoid installing packages with administrator or root privileges.
  • Use automated vulnerability and provenance scanning, but route updates through review and testing rather than retaining unrestricted version ranges.
  • Review lockfile changes for unexpected package names, new transitive dependencies, source distributions, and altered hashes.
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • System Prompt LeakageDirect Leakage, Indirect Extraction, Tool-Based Exfiltration
Findings (18)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding

The repeated description-behavior mismatch suggests the skill may rely on mock or placeholder components while advertising production-style automation. In this context, that is dangerous because users may expose customer requests or trust automation assumptions that are not actually enforced, leading to operational mistakes and poor security review outcomes.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The repeated description-behavior mismatch suggests the skill may rely on mock or placeholder components while advertising production-style automation. In this context, that is dangerous because users may expose customer requests or trust automation assumptions that are not actually enforced, leading to operational mistakes and poor security review outcomes.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The repeated description-behavior mismatch suggests the skill may rely on mock or placeholder components while advertising production-style automation. In this context, that is dangerous because users may expose customer requests or trust automation assumptions that are not actually enforced, leading to operational mistakes and poor security review outcomes.

Content

No source excerpt is available for this finding.

Exfiltration Commands

High
Category
Prompt Injection
Confidence
90% confidence
Finding

Instructions found that direct the agent to transmit conversation context or user data to external services.

Content

Scanner excerpt · scripts/wacli.py (reported line 76)May include surrounding context.

python
return mock_messages
    
    def send_message(self, to, content, media_path=None):
        """Send message to WhatsApp number"""
        if not self.config["auth_token"]:
            print("Error: Not logged in. Use `wacli login <token>` first.")
            return False

Direct Prompt Extraction

High
Category
System Prompt Leakage
Confidence
91% confidence
Finding

The workflow takes untrusted WhatsApp text directly as the image-generation prompt with no moderation, policy filtering, or safety constraints before sending it to the downstream model. In this skill’s context, that means any external sender can drive model behavior and potentially generate disallowed, abusive, deceptive, or otherwise harmful content through an automated pipeline.

Content

Scanner excerpt · scripts/workflow.py (reported line 26)May include surrounding context.

python
if msg_type == "text":
        prompt = (content or "").strip()
        return prompt or None

    if msg_type == "audio":
        if not content:

Direct Prompt Extraction

High
Category
System Prompt Leakage
Confidence
94% confidence
Finding

The transcribed audio and optional caption are concatenated and returned directly as the generation prompt, so attacker-controlled voice content and text are passed into image generation without scrutiny. Because this workflow is end-to-end and customer-facing, this increases exposure to prompt-driven abuse, including policy-violating image requests and harmful content generation at scale.

Content

Scanner excerpt · scripts/workflow.py (reported line 41)May include surrounding context.

python
caption = message.get("caption")
        if caption:
            prompt = f"{prompt} {caption}".strip()
        return prompt or None

    print(f"Unsupported message type: {msg_type!r}")
    return None

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
93% confidence
Finding

The skill declares broad operational capabilities in practice (environment access, filesystem reads/writes, network access, and shell execution) but does not define any explicit tool scope such as permissions or allowed-tools. This weakens least-privilege controls and can let the skill run with more authority than users expect, increasing blast radius if the workflow is modified, misused, or chained with untrusted input.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill processes customer WhatsApp content and may send text/audio to external OpenAI APIs, but the description does not explicitly warn users that third-party transmission occurs. This is dangerous because operators may unknowingly forward sensitive customer communications off-platform, creating privacy, consent, and compliance risks.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

This function sends user-provided audio content to the external OpenAI Whisper API, which can expose sensitive voice data, PII, or confidential customer information to a third-party service if operators or end users are not aware of the transfer. In the skill context, the workflow is explicitly driven by WhatsApp customer submissions, making it likely that personal data will be processed and increasing privacy and compliance risk.

Content

No source excerpt is available for this finding.

Tainted flow: 'output_path' from os.environ.get (line 110, credential/environment) → open (file write)

Medium
Category
Data Flow
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.

Content

Scanner excerpt · scripts/transcribe.py (reported line 113)May include surrounding context.

python
output_path = os.path.join(
        DEFAULT_OUTPUT_DIR, f"{os.path.basename(audio_path)}.txt"
    )
    with open(output_path, "w", encoding="utf-8") as handle:
        handle.write(transcript)

    print(f"Transcription saved to {output_path}")

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The CLI persists a WhatsApp auth token in a local JSON config file under the user's home directory with no protection, encryption, or permission hardening. If another local user, malware, backups, or logs can access that file, the token can be reused to impersonate the account and access messaging capabilities unrelated to the immediate content-generation task.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The login flow silently writes the provided authentication token to disk when save_config() is called, without warning the user that a credential is being persisted locally. This increases the chance of accidental credential exposure because users may assume the token is only used in-memory for the current session.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
94% confidence
Finding

The dependency specification openai>=1.0.0 is unpinned, which allows future installs to resolve to different versions over time. This creates supply-chain and reproducibility risk because a newly released upstream version could introduce a vulnerability or breaking behavior without any change to this repository.

Content

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

text
openai>=1.0.0
pydub>=0.25.1
requests>=2.31.0
python-dotenv>=1.0.0

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
94% confidence
Finding

The dependency specification pydub>=0.25.1 is unpinned, so deployments may install different versions depending on when and where resolution occurs. That weakens build integrity and can expose the skill to newly introduced upstream vulnerabilities or incompatible transitive changes.

Content

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

text
openai>=1.0.0
pydub>=0.25.1
requests>=2.31.0
python-dotenv>=1.0.0

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
98% confidence
Finding

The dependency requests>=2.31.0 is unpinned, so the environment may resolve to any later release, making it impossible to know which code will actually run. In a workflow that receives untrusted customer content over WhatsApp and makes outbound network requests, this increases supply-chain exposure and complicates assurance against known HTTP client flaws.

Content

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

text
openai>=1.0.0
pydub>=0.25.1
requests>=2.31.0
python-dotenv>=1.0.0

Unverifiable Dependency: requests has 16 known advisory(ies) (CVE-2014-1830 (Exposure of Sensitive Information to an Unauthorized Actor in Requests); CVE-2024-47081 (Requests vulnerable to .netrc credentials leak via malicious URLs); CVE-2024-35195 (Requests `Session` object does not verify requests after making first request wi) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
91% confidence
Finding

requests has multiple known advisories, and because the manifest does not pin a version, there is no reliable way to determine whether deployments will install an affected release. In this skill, which likely performs external HTTP interactions as part of message handling and API usage, an affected HTTP client could expose credentials, weaken request validation, or mishandle attacker-controlled URLs.

Content

No source excerpt is available for this finding.

Unpinned Dependencies

Low
Category
Supply Chain
Confidence
96% confidence
Finding

The dependency python-dotenv>=1.0.0 is unpinned, which means future installations may pull different releases with different security properties. Because this package can influence environment loading and configuration behavior, unreviewed version drift can create avoidable security and operational risk.

Content

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

text
openai>=1.0.0
pydub>=0.25.1
requests>=2.31.0
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
88% confidence
Finding

python-dotenv has known advisories, but the unpinned requirement prevents verification that the installed version is safe. While the package is typically used for local configuration, vulnerabilities involving file handling or environment loading can still matter if the skill writes or reads .env files in an unsafe runtime context.

Content

No source excerpt is available for this finding.