Back to skill

Security audit

Celo服务

Security checks for vulnerabilities and agentic risk

Overview

The skill is advertised as a Celo helper, but it requires a XiaoBenYang API key, stores it locally, and sends requests to a XiaoBenYang remote service.

Review carefully before installing. Do not provide an API key unless you intend to use XiaoBenYang's remote service and are comfortable with the key being stored in a plaintext .env file. The publisher should align the name, documentation, code, endpoint, credential name, and storage behavior before this should be trusted as a Celo skill.

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

Lp3

Medium
Category
MCP Least Privilege
Confidence
86% confidence
Finding
The skill advertises no declared permissions, yet its documented behavior includes reading environment variables, writing to `.env`, and making external network requests. This creates a transparency and consent problem: users and reviewers cannot accurately assess what data the skill can access or transmit before use.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The stated purpose is local installation/configuration of a Celo MCP server on macOS, but the documented workflow actually collects an API key, persists it, and proxies requests to an unrelated external XiaoBenYang service. This mismatch can mislead users into granting secrets or trust under false assumptions, increasing the chance of credential exposure and unintended data transfer.

Description-Behavior Mismatch

High
Confidence
94% confidence
Finding
The manifest and introductory text describe a Celo Composer Kit installer/configurator, but the operational instructions route the model to API-key-gated tools in a different project/domain. Such domain and purpose swapping is a strong trust-boundary issue because users may provide credentials believing they are interacting with a local Celo-related utility rather than a third-party remote service.

Intent-Code Divergence

Medium
Confidence
81% confidence
Finding
The documentation says the code 'only calls APIs' and frames the skill around Celo component tools, but elsewhere the same file introduces unrelated API-key handling and inconsistent project identity. These contradictions make it harder for users and reviewers to understand real behavior, which is risky when credentials and external requests are involved.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The skill requires collecting and storing an external API key even though its stated purpose does not justify that capability. Unnecessary credential collection broadens the attack surface and may condition users to disclose secrets without a clear need or understanding of where they will be stored and used.

Description-Behavior Mismatch

High
Confidence
96% confidence
Finding
The code implements a generic client for an unrelated upstream '小笨羊MCP' service rather than functionality aligned with the declared Celo installer/configuration purpose. This mismatch is a strong supply-chain red flag because it can covertly proxy data and actions to an external service under misleading packaging, increasing the likelihood of unauthorized remote command/tool execution or data exfiltration.

Context-Inappropriate Capability

High
Confidence
95% confidence
Finding
The client accepts user-controlled tool_name and params and forwards them directly to a remote API via headers and JSON body, enabling arbitrary remote tool invocation. In the context of a server installation/configuration utility, this creates an unjustified remote execution proxy that could be abused to trigger unexpected actions, leak sensitive inputs, or extend the skill beyond its stated trust boundary.

Intent-Code Divergence

Medium
Confidence
89% confidence
Finding
The class docstring explicitly identifies this as a '小笨羊MCP API' client, contradicting the declared Celo-focused skill purpose. While a docstring alone is not executable, here it corroborates the implementation mismatch and materially increases confidence that the package is misrepresented, which is dangerous in a supply-chain context.

Intent-Code Divergence

Medium
Confidence
88% confidence
Finding
The function docstring states that it calls the '小笨羊MCP API', again conflicting with the manifest's Celo-specific description. This inconsistency strengthens the evidence of deceptive packaging or negligent repurposing, both of which undermine user trust and can hide risky remote behavior behind an unrelated skill label.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The file claims to belong to a Celo MCP server skill, but the code and identifiers point to an unrelated 'XBY_GAOKAO' service and a hard-coded remote endpoint. This kind of identity mismatch is a strong supply-chain red flag because users may believe they are configuring one service while actually sending credentials to another, enabling credential theft or unauthorized remote access.

Intent-Code Divergence

Medium
Confidence
95% confidence
Finding
The class docstring identifies the component as a different skill ('小笨羊高考Skill配置') than the advertised Celo service. While a docstring alone is not exploitable code, in this context it materially reinforces deceptive provenance and increases the likelihood that users will trust code that handles secrets for an unrelated backend.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The function persists the API key in plaintext to a local .env file and updates the process environment without any user-facing warning, consent, or discussion of storage risks. This can expose credentials to other local users, accidental commits, backups, logs, or tooling that reads workspace files.

Ssd 3

Medium
Confidence
96% confidence
Finding
The instructions explicitly tell the agent to ask for a user API key and save it for continued use. Persisting user-provided credentials in `.env` or similar local storage raises clear secret-retention risks: the key may be exposed to other tools, logs, backups, or future sessions beyond the user's intent.

Ssd 3

Medium
Confidence
88% confidence
Finding
The instruction to directly display `result["raw"]` encourages unfiltered disclosure of external API responses. If the remote service returns secrets, tokens, personal data, stack traces, or internal metadata, the skill may expose sensitive content to the user without validation or minimization.

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
81% confidence
Finding
The code explicitly and forcibly reads XBY_APIKEY from a local .env file in custom logic, bypassing the normal scoped env_prefix configuration and tying the skill to a secret for an unrelated service. In the context of the service-identity mismatch, this increases the chance that users unknowingly load and use credentials for a different backend than the advertised Celo skill.

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
81% confidence
Finding
Opening and reading the .env file directly to search for a hard-coded XBY_APIKEY goes beyond generic configuration loading and targets a specific unrelated credential. In this deceptive skill context, that behavior can capture or repurpose secrets that users did not intend to provide to a Celo tool.

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
78% confidence
Finding
This line reads XBY_APIKEY from the environment and overrides the .env-derived value, again binding the advertised Celo skill to an unrelated secret namespace. In isolation, environment reads are normal, but within a mislabeled skill they create a realistic risk of silently consuming credentials intended for another service.

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
90% confidence
Finding
This function is explicitly designed to save an API key into a .env file, creating plaintext credential persistence on disk. If the workspace is shared, backed up, or accidentally committed, the secret can be recovered and used to access the associated backend.

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
89% confidence
Finding
The API key setter is designed to persist the secret to .env as part of normal operation, encouraging long-lived plaintext storage rather than ephemeral use. In a skill already showing identity mismatch, this makes credential exposure more dangerous because users may store secrets for an unintended third-party service.

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
97% confidence
Finding
The dependency uses a lower-bound specifier (`requests>=2.31.0`) instead of a pinned version, which makes builds non-reproducible and can pull in unexpected upstream releases. In a security-sensitive tool, this increases supply-chain risk and can also allow installation of a version that still falls within a vulnerable range if constraints are not otherwise managed.

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
97% confidence
Finding
The dependency declaration `pydantic>=2.7.0` is unpinned, so future installs may resolve to different versions over time. This weakens reproducibility and increases supply-chain exposure because newly published versions could introduce breaking changes or security issues without explicit 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
97% confidence
Finding
`pydantic-settings>=2.2.0` allows any newer version to be installed, which can cause drift between environments and reduce control over dependency integrity. While not an immediate exploit by itself, it is a real supply-chain hardening issue because trust is delegated to future upstream releases.

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
97% confidence
Finding
The requirement `python-dotenv>=1.0.1` is unpinned and therefore permits unreviewed future versions during installation. This creates a low-severity supply-chain risk and makes it harder to ensure deterministic, audited deployments.

Known Vulnerable Dependency: requests==2.31.0 — 3 advisory(ies): 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); CVE-2026-25645 (Requests has Insecure Temp File Reuse in its extract_zipped_paths() utility func)

Low
Category
Supply Chain
Confidence
89% confidence
Finding
The requirement permits `requests` version 2.31.0, which is associated with multiple advisories, and because the specifier is `>=2.31.0`, installs may still resolve to an affected version depending on environment constraints. Since this skill is an MCP server installer/configuration tool that likely performs network operations, use of a vulnerable HTTP client library is more relevant than in an offline-only package.

Known Vulnerable Dependency: python-dotenv==1.0.1 — 1 advisory(ies): CVE-2026-28684 (python-dotenv: Symlink following in set_key allows arbitrary file overwrite via )

Low
Category
Supply Chain
Confidence
76% confidence
Finding
The requirement permits `python-dotenv` version 1.0.1, which is flagged for a symlink-following arbitrary file overwrite issue in `set_key`. This is only practically dangerous if the skill actually invokes vulnerable write-path functionality on attacker-influenced `.env` paths, which is not shown in this file, but keeping an affected version allowed is still a real dependency risk.

Static analysis

No suspicious patterns detected.