Back to skill

Security audit

顺序思维服务

Security checks for vulnerabilities and agentic risk

Overview

This skill presents as a sequential-thinking helper but actually sends thought data to a third-party API and stores an API key in a local .env file.

Install only if you are comfortable giving this skill an XiaoBenYang API key, storing that key in a local plaintext .env file, and sending sequential-thinking content to the external mcp.xiaobenyang.com service. Do not use it for private, regulated, or sensitive reasoning unless the publisher clarifies the data handling and credential storage model.

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
95% confidence
Finding
The skill advertises no permissions while its documented behavior includes reading environment variables, reading and writing local files (.env), and making outbound network requests. This deprives users and reviewers of informed consent about sensitive capabilities and increases the risk of silent credential handling and exfiltration through an apparently simple reasoning tool.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The stated purpose is a sequential-thinking MCP server, but the documented behavior is a remote API client that collects, stores, and uses an API key to call an external service. This mismatch can mislead users into trusting the skill with data they would not share if they understood it was forwarding content to a third-party endpoint.

Intent-Code Divergence

Medium
Confidence
88% confidence
Finding
The documentation mixes a sequential-thinking tool with an unrelated API-key workflow and later references a different project identity, which is a strong sign of confused or repurposed instructions. Such inconsistency undermines reviewability and can hide what data is actually collected, where it is sent, and what code is really being invoked.

Description-Behavior Mismatch

High
Confidence
95% confidence
Finding
A mandatory external API-key dependency is not justified by the declared purpose of a sequential-thinking service, which users would reasonably expect to be local or self-contained. Requiring credentials for an unrelated third-party service expands trust boundaries and creates unnecessary exposure of secrets and user prompts.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The skill explicitly instructs the agent to request an API key from the user and persist it locally, even though this is not justified by the advertised functionality. Collecting and storing credentials in a repurposed or misleading skill materially increases the risk of credential theft, misuse, or accidental leakage.

Intent-Code Divergence

Medium
Confidence
90% confidence
Finding
The project structure names a different gaokao-related package and API client, contradicting the skill’s identity as a sequential-thinking service. This kind of mismatch is dangerous because it suggests code reuse or substitution that can conceal unexpected data handling, external calls, or credential flows from users and reviewers.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The file’s behavior materially diverges from the declared 'sequential thinking' skill by managing and persisting credentials for an unrelated external service. In an agent-skill context, unexpected secret handling expands the trust boundary and can enable covert collection or misuse of user-provided API keys.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
The skill can write an API key to .env and mutate the process environment, giving it persistent credential-handling capability unrelated to its stated purpose. In a plugin/agent setting, this is dangerous because it silently leaves sensitive data on disk and in process state where other components, logs, backups, or users may later access it.

Intent-Code Divergence

Medium
Confidence
91% confidence
Finding
The docstring identifies the settings as belonging to a different '高考' skill, contradicting the declared skill identity. This mismatch is a supply-chain trust signal: it suggests code reuse or repackaging that can conceal hidden functionality and makes security review harder, increasing the chance that users authorize an unexpected capability.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The instructions tell the agent to ask for an API key and save it, but they do not inform the user that the credential will be persisted in local configuration. Storing secrets without clear disclosure prevents informed consent and increases the risk of later exposure through filesystem access, backups, logs, or other tools.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The code persists sensitive credentials to disk without any user-facing warning, confirmation, or notice about storage location and lifetime. This can cause users to unknowingly leave secrets in plaintext project files that may be committed, backed up, or exposed to other local processes.

Natural-Language Policy Violations

Medium
Confidence
94% confidence
Finding
The docstring explicitly instructs the model to generate, verify, and repeat chain-of-thought steps, culminating in a final answer. Exposing or requesting internal reasoning is dangerous because downstream systems may surface hidden deliberations, leak sensitive intermediate data, or create policy noncompliance around protected reasoning traces.

Ssd 3

Medium
Confidence
94% confidence
Finding
The skill instructs the model to directly present raw API response data to the user. Raw backend responses may contain sensitive fields, debugging metadata, echoed credentials, identifiers, or other content that should be filtered before display, especially in a tool already involving external API calls and credential handling.

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
89% confidence
Finding
Configuring automatic loading from a local .env file is credential access behavior and broadens the set of secrets this skill may consume. In this context, the danger is elevated because the skill is supposed to provide reasoning support, not secret management, so users may not expect it to read local credentials at all.

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
96% confidence
Finding
The code forcefully reads .env and extracts a specific API key outside the normal settings flow, creating custom secret-access logic that bypasses clearer configuration boundaries. This increases the risk of unauthorized or surprising secret consumption and makes the skill more capable of covert credential use.

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
Reading the contents of .env directly gives the skill access to locally stored credentials in plaintext. In an agent/plugin ecosystem, direct file-based secret access is particularly risky because it can be repurposed to inspect or exfiltrate secrets beyond the user’s expectations for the advertised skill.

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
87% confidence
Finding
The fallback read from os.getenv('XBY_APIKEY') consumes a credential from process environment, which is secret access capability. While common in applications, it is security-relevant here because the skill’s advertised function does not justify credential intake, making the behavior unexpectedly broad.

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
97% confidence
Finding
The function that saves an API key to .env explicitly creates and updates a plaintext credential store on disk. Plaintext secret storage is dangerous because secrets can be exposed through file permissions, accidental commits, backups, local malware, or other users on the system.

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
94% confidence
Finding
The setter explicitly persists user-supplied credentials as part of normal operation, turning secret storage into a built-in feature of the skill. Given the mismatch with the stated skill purpose, this makes the skill context more dangerous because users are less likely to expect or scrutinize credential retention.

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 is specified with a lower-bound constraint only, which allows future installs to resolve to different versions over time. This weakens reproducibility and can unintentionally introduce breaking changes or newly disclosed vulnerable releases into the environment.

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
Using an unpinned version for pydantic means builds are not reproducible and may silently pull in a later release with security or compatibility issues. While not an exploit by itself, it increases supply-chain risk and makes security posture less predictable.

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
A minimum-version-only constraint for pydantic-settings permits uncontrolled dependency drift across environments. This can expose the skill to accidental adoption of vulnerable or incompatible 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 python-dotenv dependency is not pinned, so future installations may resolve to different versions with different behavior or security characteristics. This is a common supply-chain hygiene issue that reduces build determinism.

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
93% confidence
Finding
The requirement allows installation of requests 2.31.0, which is associated with multiple advisories, including credential leakage via .netrc and request verification issues in some session flows. Because the spec is `>=2.31.0`, vulnerable resolutions remain possible unless a fixed minimum version is enforced; in an MCP server that may perform outbound HTTP requests, this increases practical exposure.

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
88% confidence
Finding
The requirement range includes python-dotenv 1.0.1, which is reported as vulnerable to symlink-following file overwrite behavior in set_key. If the skill or its tooling uses dotenv file write operations on attacker-influenced paths, this could enable unintended file modification, though the risk is context-dependent and not guaranteed from the requirements file alone.

Static analysis

No suspicious patterns detected.