Back to skill

Security audit

GSAP动画生成工具

Security checks for vulnerabilities and agentic risk

Overview

This GSAP animation skill is not clearly malicious, but it needs Review because it sends user prompts and code to an external service while collecting and storing an API key in a local .env file, with several stale Gaokao/school-search remnants that make its scope unclear.

Install only if you are comfortable giving this publisher an XBY API key and sending animation prompts or source code to the XiaoBenYang remote API. Avoid pasting proprietary code, secrets, internal URLs, or customer data unless the publisher provides clear privacy, retention, and key-handling terms; consider using a dedicated low-privilege API key and removing the local .env entry when finished.

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
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (27)

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill declares no permissions, yet its documented behavior includes reading environment variables, persisting an API key, local file access, and outbound network calls. This breaks the principle of least privilege and prevents informed consent, making it easier for a seemingly harmless animation skill to access credentials and communicate with an external service.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The skill claims to be a GSAP animation generator, but its documented implementation relies on storing API keys, reading local configuration, and sending data to an external domain to perform the real work. This description-behavior mismatch is dangerous because users may provide code, prompts, or credentials under the assumption of a local animation helper when the data is actually being relayed to a remote service.

Intent-Code Divergence

High
Confidence
99% confidence
Finding
The workflow example and tool descriptions present GSAP animation functionality, but the actual invocation example references school-search parameters, indicating copied or mismatched operational logic. Such inconsistency is a strong trust signal failure: it suggests the skill may call unintended backends or process user inputs in ways unrelated to its advertised purpose.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
A GSAP animation skill should not include operational examples for school-search queries, because this indicates either stale documentation or a repurposed backend. Even if accidental, it raises the risk that user inputs and secrets are routed to an unrelated service, violating user expectations and increasing the chance of data mishandling.

Intent-Code Divergence

Medium
Confidence
97% confidence
Finding
The project structure is named 'xiaobenyang_gaokao_skill', which contradicts the claimed identity as a GSAP animation generator. This inconsistency materially increases suspicion that the skill was repackaged from another project and may still contain unrelated logic, endpoints, or data handling behaviors.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The file’s behavior is materially unrelated to the declared GSAP animation purpose and instead implements credential management for an external XBY/Gaokao service. This kind of capability mismatch is a strong indicator of hidden functionality that could collect, persist, or redirect secrets under false pretenses, making the skill context significantly more dangerous.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
This code saves and manages an external API key even though such credential handling is not justified by a GSAP animation generator. In this context, collecting and persisting secrets is suspicious because it expands the attack surface for credential theft, misuse, and covert service access without a legitimate product need.

Intent-Code Divergence

Medium
Confidence
95% confidence
Finding
The docstring identifies the module as a Gaokao skill configuration, directly contradicting the manifest’s GSAP animation identity. Such identity inconsistency is a classic sign of code reuse or repurposing that can conceal unauthorized behavior, and in a skill package it increases suspicion of deceptive packaging.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The function writes an API key to a local .env file without any visible user warning, consent flow, or security notice. Persisting secrets in plaintext can expose them to other local users, backups, logs, source control accidents, or later exfiltration by unrelated code.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The function forwards arbitrary user-provided animation requests and context to an external API via call_api, but this file shows no disclosure, consent flow, or data-classification guard. While the transmitted content is usually less sensitive than source code, prompts may still contain proprietary project details, making silent exfiltration a real privacy and compliance risk.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
This helper sends user-supplied API lookup queries to an external service without any visible warning in the implementation. Even if the expected input is just GSAP API names, users may include internal code snippets or architecture details, causing unintended third-party disclosure.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The setup generator transmits framework and plugin selections externally without visible notice or consent. Although these inputs are typically low sensitivity, they can still reveal internal technology stack choices and dependency plans, which may be confidential in some environments.

Missing User Warnings

High
Confidence
98% confidence
Finding
The debugging function explicitly accepts code and issue descriptions, then sends them to an external API. This creates a substantial risk of leaking proprietary source code, embedded secrets, internal URLs, credentials, or vulnerability details to a third party without user awareness.

Missing User Warnings

High
Confidence
98% confidence
Finding
This function sends full animation code to an external API for optimization, which can expose confidential source code and any hardcoded secrets or business logic embedded in that code. The absence of visible disclosure or safeguards makes this a genuine data exfiltration/privacy vulnerability.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The production-pattern generator sends user-provided pattern and industry details to an external API without visible disclosure. While generally lower sensitivity, these inputs can still reveal product direction, client verticals, or internal design strategy to a third party.

Credential Access

High
Category
Privilege Escalation
Content
model_config = SettingsConfigDict(
        env_prefix="XBY_GAOKAO_",
        env_file=".env",
        env_file_encoding="utf-8",
        extra="ignore",
    )
Confidence
86% confidence
Finding
Configuring the application to load secrets from a .env file is a credential access mechanism, and in this skill it is unjustified by the stated GSAP animation purpose. While .env usage is common in legitimate apps, here the surrounding capability mismatch makes secret loading meaningfully riskier.

Credential Access

High
Category
Privilege Escalation
Content
default_year: int = 2025

    def model_post_init(self, __context):
        # 强制从 .env 文件读取 XBY_APIKEY
        env_path = Path(".env")
        if env_path.exists():
            content = env_path.read_text(encoding="utf-8")
Confidence
95% confidence
Finding
The code explicitly opens and parses the .env file to extract XBY_APIKEY, bypassing the normal settings abstraction and force-reading a specific secret. In the context of a GSAP tool, this direct targeted credential access strongly suggests secret collection behavior unrelated to the advertised functionality.

Credential Access

High
Category
Privilege Escalation
Content
def model_post_init(self, __context):
        # 强制从 .env 文件读取 XBY_APIKEY
        env_path = Path(".env")
        if env_path.exists():
            content = env_path.read_text(encoding="utf-8")
            for line in content.splitlines():
Confidence
95% confidence
Finding
The existence check and subsequent read of .env are part of a deliberate secret-access path targeting local credential storage. Because the skill is supposed to generate GSAP animations, direct reads of secret files are unnecessary and increase the risk of unauthorized credential exposure.

Credential Access

High
Category
Privilege Escalation
Content
if line.startswith("XBY_APIKEY="):
                    self.api_key = line.split("=", 1)[1].strip()
                    break
        # 如果环境变量有值,覆盖 .env 的值
        env_val = os.getenv("XBY_APIKEY", "")
        if env_val:
            self.api_key = env_val
Confidence
88% confidence
Finding
Reading XBY_APIKEY from the environment is standard in isolation, but here it supports unrelated external-service credential intake within a misrepresented skill. The danger comes from the surrounding deceptive context, which makes otherwise common secret access behavior suspicious and unjustified.

Credential Access

High
Category
Privilege Escalation
Content
def save_api_key_to_env(api_key: str) -> bool:
    """将API key保存到.env文件"""
    try:
        env_path = Path(".env")
        lines = []
        if env_path.exists():
            lines = env_path.read_text(encoding="utf-8").splitlines()
Confidence
94% confidence
Finding
This function is specifically designed to persist an API key into .env, creating a long-lived plaintext credential store on disk. In a skill that should only generate animations, such secret persistence is unnecessary and raises the chance of credential leakage through filesystem access, backups, or accidental commits.

Credential Access

High
Category
Privilege Escalation
Content
def set_api_key(api_key: str) -> bool:
    """设置API key并持久化到.env"""
    if not api_key or not api_key.strip():
        return False
    api_key = api_key.strip()
Confidence
92% confidence
Finding
The helper exposes a simple API for setting and persisting an external service API key, which operationalizes credential collection inside a skill that does not need it for its advertised purpose. This lowers the barrier for secret capture and normalizes storing sensitive data where users would not expect it.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
pydantic>=2.7.0
pydantic-settings>=2.2.0
python-dotenv>=1.0.1
Confidence
91% confidence
Finding
The dependency is specified with only a lower bound, which allows future installs to resolve to different versions over time. This creates supply-chain and reliability risk because a later release could introduce a vulnerability or breaking change without review.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
pydantic>=2.7.0
pydantic-settings>=2.2.0
python-dotenv>=1.0.1
Confidence
91% confidence
Finding
The pydantic package is unpinned and may resolve to any newer version satisfying the lower bound. That weakens build reproducibility and can expose consumers to newly introduced vulnerable releases or incompatible behavior.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
pydantic>=2.7.0
pydantic-settings>=2.2.0
python-dotenv>=1.0.1
Confidence
90% confidence
Finding
Using an unpinned pydantic-settings version permits uncontrolled upgrades during installation. In a distributed skill or tool, that increases supply-chain exposure and makes security posture dependent on upstream changes at install time.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
pydantic>=2.7.0
pydantic-settings>=2.2.0
python-dotenv>=1.0.1
Confidence
91% confidence
Finding
The unpinned python-dotenv dependency can drift to newer releases without explicit review. This is a low-severity supply-chain weakness because dependency resolution is non-deterministic and may pull in vulnerable or unexpected versions.

Static analysis

No suspicious patterns detected.