Back to skill

Security audit

Flyworks Avatar Video

Security checks for vulnerabilities and agentic risk

Overview

The skill does what it claims, but it handles face and voice media, uploads local files to a third-party service, and uses a shared embedded API token with too little user-facing safety and privacy control.

Review this skill before installing. Only upload images and voice samples you own or have explicit permission to use, assume those files and prompts are sent to Flyworks/HiFly infrastructure, set your own API token only if you understand account and quota impact, and prefer a pinned, project-local installation in an isolated environment.

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

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/hifly_client.py:10
Finding
Hardcoded Shared Bearer Token Used as an Automatic Fallback<![CDATA[ ## Vulnerability Details **File Location**: `scripts/hifly_client.py:10-17` **Vulnerability Type**: Hardcoded credential **Risk Level**: Medium ### Vulnerable Code ```python DEFAULT_TOKEN = "2aeda3bcefac46a3" BASE_URL = "https://hfw-api.hifly.cc/api/v2/hifly" MEMORY_FILE = Path(__file__).parent / "memory.json" def get_token(): token = os.environ.get("HIFLY_API_TOKEN") if not token: token = DEFAULT_TOKEN print(f"Warning: Using default free-tier token ({DEFAULT_TOKEN}). Videos <30s only, watermarked.") return token ``` ### Technical Analysis The project embeds a reusable bearer token directly in its source code and automatically uses it whenever `HIFLY_API_TOKEN` is absent. The documentation identifies this as a limited demonstration token, but it is still an authentication credential accepted by the remote API. Anyone with access to the package can extract and use the token independently of the client. Automatic fallback also makes it easy for users to submit images, voice recordings, and text under a shared account without deliberately selecting that authentication context. Printing the complete token further exposes it to terminal logs, agent transcripts, and captured build output. Because the credential is public and shared, it cannot reliably identify individual callers or provide meaningful accountability. Revocation or exhaustion by one party can affect every installation relying on it. ### Attack Path 1. An attacker downloads the skill or examines its public source. 2. The attacker extracts `2aeda3bcefac46a3` from `DEFAULT_TOKEN`. 3. The attacker constructs requests to `https://hfw-api.hifly.cc/api/v2/hifly` with: ```http Authorization: Bearer 2aeda3bcefac46a3 ``` 4. The attacker invokes API operations supported by the token without using the distributed client. 5. Shared quota or service resources can be consumed, and abusive activity is attributed to the shared credential. 6. If the provider revok ...[truncated 702 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove `DEFAULT_TOKEN` from the source and rotate or revoke the exposed credential. 2. Require `HIFLY_API_TOKEN` to be configured explicitly: ```python def get_token(): token = os.environ.get("HIFLY_API_TOKEN") if not token: raise RuntimeError( "HIFLY_API_TOKEN is required. Obtain a token from the service settings." ) return token ``` 3. If demonstration access is required, issue short-lived, narrowly scoped credentials through a controlled service rather than distributing a static token. 4. Apply server-side rate limits, operation restrictions, expiration, and per-user attribution to demonstration credentials. 5. Never print complete bearer tokens. Log only whether authentication was configured or, when necessary, a small redacted suffix. 6. Clearly notify users that media and text are uploaded to a third-party API before submission, especially for biometric images and voice samples. ]]>

T08 · Insecure Dependencies

Note
Location
requirements.txt:1
Finding
Unpinned Python Dependency Produces Non-Reproducible and Unsafe Builds<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1` **Vulnerability Type**: Unconstrained third-party dependency **Risk Level**: Low ### Vulnerable Code ```text requests ``` ### Technical Analysis The project declares `requests` without a version constraint or integrity hash. As a result, `pip install -r requirements.txt` resolves whichever compatible release is available from the configured package index at installation time. This does not prove that the current `requests` package is malicious. However, it means the installed dependency can differ from the version reviewed or tested by the project. Future compromised, defective, or incompatible releases could therefore enter the runtime without a corresponding change to this repository. The outcome also depends on the user's configured Python package index and resolver environment. ### Attack Path 1. A user follows the documented installation command: ```bash pip install -r requirements.txt ``` 2. `pip` resolves `requests` dynamically because no exact version or hash is specified. 3. A future compromised release, an unsafe package-index configuration, or an incompatible version is selected. 4. The package is installed into the user's Python environment. 5. Malicious or defective dependency behavior executes with the privileges of the user running installation or the client. Exploitation depends on compromise or unsafe configuration of the dependency supply chain; the audited repository itself does not contain evidence that the current upstream package is malicious. ### Impact Assessment A compromised dependency would execute with the privileges of the Python installation process and subsequently the client process. Depending on how installation is performed, this could range from access to one virtual environment and the invoking user's files to broader system impact if installation is run with elevated privileges. At runtime, the dependency can also observe HTTP req ...[truncated 134 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `requests` to a reviewed exact version rather than leaving it unconstrained. 2. Generate a lock file containing transitive dependencies and cryptographic hashes, for example with `pip-tools`. 3. Install dependencies with hash verification: ```bash pip install --require-hashes -r requirements.txt ``` 4. Use an isolated virtual environment and avoid running `pip` as an administrator or root user. 5. Add automated dependency vulnerability scanning and a controlled process for reviewing and updating pinned versions. 6. Configure trusted package indexes explicitly in deployment environments and reject unexpected alternate indexes. ]]>

T08 · Insecure Dependencies

Warning
Location
README.md:16
Finding
Installation Instructions Execute an Unpinned npx Package and Install an Unpinned Repository Revision<![CDATA[ ## Vulnerability Details **File Location**: `README.md:16-22` **Vulnerability Type**: Unpinned package execution and mutable installation source **Risk Level**: Medium ### Vulnerable Code ```bash # Install globally npx skills add Flyworks-AI/skills -a claude-code -g # Or install to current project only npx skills add Flyworks-AI/skills -a claude-code ``` ### Technical Analysis The recommended installation procedure invokes `npx skills` without specifying an exact package version. When the package is not already available locally, `npx` may download and execute the currently resolved release of the `skills` package. That executable package is therefore outside the immutable contents reviewed in this audit. The `Flyworks-AI/skills` source is also referenced without a commit hash or immutable release identifier. A later upstream change can consequently cause users to install skill content different from the audited artifact. This is a supply-chain exposure rather than proof that either current upstream source is malicious. The risk arises because executable installer behavior and installed content can change after review without any modification to these instructions. ### Attack Path 1. An attacker compromises the package publishing account, package distribution channel, or referenced repository. 2. The attacker publishes a modified `skills` package or changes the repository content resolved by `Flyworks-AI/skills`. 3. A user follows the README and runs the unversioned `npx skills add` command. 4. `npx` retrieves and executes the newly resolved installer package. 5. The installer retrieves mutable repository content and installs it into the agent's skill directory. 6. If the global option is used, the modified skill becomes available across multiple projects or agent sessions. ### Impact Assessment The `npx` package executes with the operating-system privileges of the invoking user. A compromised installer could potentially read or modify fil ...[truncated 434 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the `npx` package to an exact reviewed version: ```bash npx --yes skills@<reviewed-version> add <immutable-source> -a claude-code ``` 2. Reference an immutable repository commit or signed release instead of a mutable repository default branch. 3. Publish expected commit identifiers or checksums and instruct users to verify them before installation. 4. Prefer project-local installation over global installation so a compromised component has a smaller persistence and exposure scope. 5. Run installation without elevated privileges and in an isolated environment where practical. 6. Review installer updates separately before changing the pinned version. 7. Consider replacing executable bootstrap instructions with a transparent manual download-and-verification process for security-sensitive environments. ]]>
Vulnerability Patterns
  • 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
  • Rogue AgentSelf-Modification, Session Persistence
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
Findings (23)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The documented behavior goes beyond the declared purpose by relying on an embedded default API token and persisting aliases in memory.json without clearly surfacing those behaviors as security- and privacy-relevant features. Hidden credentials can be abused for unauthorized third-party API use, and undeclared persistence can retain sensitive identifiers or user-specific data longer than expected.

Session Persistence

Medium
Category
Rogue Agent
Content
## Features

- 🎬 **Public Avatar Video**: Create videos using pre-made realistic avatars with TTS
- 🖼️ **Talking Photo**: Turn any image into a talking video
- 🎙️ **Voice Cloning**: Clone voices from audio samples
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The README promotes talking-photo generation and voice cloning from user-supplied images/audio but does not warn about consent, biometric/privacy sensitivity, or the risks of uploading personal media to a third-party service. In this context, the omission is meaningful because the skill is specifically designed to process highly sensitive likeness and voice data, which could lead users to misuse the feature or expose personal data without informed consent.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Rp1

Medium
Category
MCP Rug Pull
Confidence
70% confidence
Finding
npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill advertises and documents capabilities that read environment variables, access local files, write to local state, and make network requests, but it does not declare any tool scope or allowed-tools boundary. That increases the chance an agent will invoke broader-than-expected capabilities without explicit operator review, especially when handling user-supplied paths, media, and remote URLs.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
Voice cloning is a sensitive biometric and impersonation capability, and the skill describes it as a normal feature without requiring consent or warning about privacy, fraud, or misuse risks. In this context, omission of consent and safety guidance makes accidental or abusive impersonation substantially easier.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The examples instruct users to upload custom photos and audio, including potentially sensitive personal media, to a remote service without clearly warning that data will leave the local environment. In a skill centered on avatars and voice cloning, that omission is materially risky because facial images and voice samples are highly sensitive and can enable identity misuse if mishandled.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill documents creating talking-photo avatars from arbitrary portrait images, including remote image URLs, without any warning about consent, privacy, rights of use, or biometric-data sensitivity. This can enable non-consensual avatar generation or misuse of third-party images, which is especially risky in a digital-human/video generation context where impersonation and deceptive media are plausible outcomes.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The documentation instructs users to upload or reference audio samples for voice cloning without any warning about obtaining consent, protecting biometric voice data, or the fact that samples may be transmitted to an external service. Because cloned voices can enable impersonation, privacy violations, and misuse of sensitive audio, omission of these safeguards creates a real security and abuse-enablement risk in the skill.

Context-Inappropriate Capability

Medium
Confidence
99% confidence
Finding
The script embeds a working default API token and automatically uses it when no user token is configured. This enables anyone running the skill to consume a third-party account or service allocation without explicit authorization, and normalizes secret-in-code practices that can lead to abuse, quota exhaustion, and account misuse.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The skill accepts local file paths and uploads those files to a remote third-party service with no explicit consent prompt or strong disclosure at the point of transmission. In an agent-skill context, this increases the risk of accidental exfiltration of sensitive local files if a user or upstream tool passes an unintended path.

External Transmission

Medium
Category
Data Exfiltration
Content
headers = get_headers()
    
    try:
        resp = requests.post(url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if data.get("code", 0) != 0:
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
headers = get_headers()
    
    try:
        resp = requests.post(url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if data.get("code", 0) != 0:
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
headers = get_headers()
    
    try:
        resp = requests.post(url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if data.get("code", 0) != 0:
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
headers = get_headers()
    
    try:
        resp = requests.post(url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if data.get("code", 0) != 0:
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
headers = get_headers()
    
    try:
        resp = requests.post(url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if data.get("code", 0) != 0:
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Tainted flow: 'upload_url' from requests.post (line 137, network input) → requests.put (network output)

Medium
Category
Data Flow
Content
print(f"Uploading {file_path.name}...")
        with open(file_path, 'rb') as f:
            headers_put = {"Content-Type": content_type}
            resp_put = requests.put(upload_url, data=f, headers=headers_put)
            resp_put.raise_for_status()
            
        print(f"Upload successful. File ID: {file_id}")
Confidence
93% confidence
Finding
The code trusts an upload URL returned by a remote API and then performs a PUT of a local file directly to that URL without validating the destination host, scheme, or expected storage provider. If the API is compromised or returns an unexpected presigned URL, the client will exfiltrate arbitrary local file contents to an attacker-controlled endpoint.

Missing User Warnings

Low
Confidence
91% confidence
Finding
The README instructs users to provide their own API token for non-demo usage without warning that doing so may incur charges, consume account quotas, or expose the user's external account to unintended actions. While not a code-execution flaw, it is a real safety issue because agents or users may proceed without understanding the financial/account impact of enabling live credentials.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests
Confidence
98% confidence
Finding
The dependency manifest specifies `requests` without a version pin, which makes builds non-reproducible and can pull in unexpectedly old or newly broken releases depending on the installation environment. In a skill that likely performs outbound API calls for avatar/video generation, this increases supply-chain and maintenance risk because security posture depends on whichever version gets resolved at install time.

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
95% confidence
Finding
Because `requests` is unpinned, it is impossible to verify from this manifest whether installation will select a version affected by known advisories, including issues involving credential leakage or TLS/request verification behavior. For a network-integrating skill, that uncertainty is meaningful: if deployed in an environment that resolves an affected release, API tokens, session behavior, or request handling could be exposed to known weaknesses.

Missing User Warnings

Low
Confidence
76% confidence
Finding
save_memory persistently writes alias mappings to memory.json, but there is no prior warning that user-provided aliases and IDs will be stored on disk. The later success message confirms saving occurred, but it does not serve as advance disclosure of the file write behavior.

Intent-Code Divergence

Low
Confidence
95% confidence
Finding
The comment at L227 states 'Should call create_video_tts but here we are,' indicating the documented intent for text input is to invoke TTS handling. The actual code instead rejects text input with an error and returns, so the inline documentation explicitly conflicts with runtime behavior.

Static analysis

No suspicious patterns detected.