Back to skill

Security audit

数学可视化服务

Security checks across malware telemetry and agentic risk

Overview

This is an API-backed math visualization skill; it has real credential and network considerations, but the behavior is mostly disclosed and aligned with its purpose.

Before installing, be comfortable giving this skill a XiaoBenYang API key and sending visualization inputs to its remote service. Store the key carefully: it writes XBY_APIKEY into a local .env file, so do not commit or share that file, and rotate the key if it may have been exposed.

SkillSpector

By NVIDIA
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 (20)

Lp3

Medium
Category
MCP Least Privilege
Confidence
91% confidence
Finding
The skill requests or implies environment access, file read/write, and network use, yet no permissions are declared to make those capabilities explicit to reviewers or users. This creates a transparency and consent problem: the skill can collect an API key, persist it to .env, and call external services without the manifest clearly advertising those powers.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared purpose says this is a JSXGraph MCP math-visualization server, but the documented behavior includes acting as an HTTP client to a third-party API, storing API keys locally, and exposing a broader unrelated toolset. This mismatch is dangerous because users and reviewers may trust the skill under a narrower educational-visualization label while it actually has external communication and credential-handling behavior.

Description-Behavior Mismatch

High
Confidence
96% confidence
Finding
The section describing mandatory API-key collection and the surrounding workflow contradict the manifest's claimed local math-visualization purpose. Hidden dependence on an external gated service increases the risk of undisclosed data transfer, unexpected credential handling, and user deception about what the skill actually does.

Intent-Code Divergence

High
Confidence
98% confidence
Finding
The workflow examples reference school-search and gaokao-oriented components that are unrelated to the stated math-visualization service, indicating copied or repurposed instructions. Such inconsistencies are a red flag because they suggest the skill may route user inputs into unintended functions or external services outside the advertised scope.

Description-Behavior Mismatch

Medium
Confidence
87% confidence
Finding
This file implements a generic upstream MCP/API proxy rather than a narrowly scoped local math-visualization helper. Because the destination is configuration-driven and the tool/function name is passed through headers, the skill can be used to invoke broader remote capabilities than its declared purpose, increasing the attack surface and enabling capability expansion beyond JSXGraph visualization.

Context-Inappropriate Capability

Medium
Confidence
91% confidence
Finding
The code can make outbound requests to a configurable upstream and automatically attaches an API key in headers, which creates a credential-bearing remote invocation primitive. If configuration is altered, or if this component is reused in a broader agent context, it could send authenticated requests to unintended services or leak privileged API usage beyond the advertised math use case.

Description-Behavior Mismatch

Medium
Confidence
93% confidence
Finding
The code implements API key persistence by writing secrets into a local .env file and updating global process state, which exceeds what a math visualization skill would ordinarily need. In this context, local credential storage is risky because it creates secret-at-rest exposure without clear necessity, user disclosure, or access controls.

Context-Inappropriate Capability

Medium
Confidence
91% confidence
Finding
The skill reads API credentials directly from a local .env file through custom parsing logic, giving it local credential access capabilities unrelated to a typical visualization workflow. Even if intended for configuration, this broadens the attack surface by allowing the skill to ingest secrets from disk without strong justification or transparency.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The function persists the API key to .env silently, with no user-facing warning that a credential is being written to disk. This is dangerous because users may expect transient use of the key, while the implementation leaves recoverable secrets in project files that may be copied, committed, or read by other local processes.

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 from a .env file enables local credential access, which is security-sensitive in a skill whose declared purpose is math visualization. By itself this may be common configuration practice, but in combination with custom secret parsing and persistence it increases the likelihood of unintended secret handling and storage.

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 reads the .env file and scans for XBY_APIKEY, bypassing normal settings mechanisms to extract a credential from local storage. This is dangerous because it creates custom secret-access behavior that is harder to audit, easier to misuse, and not obviously necessary for the stated skill purpose.

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 is part of a manual secret extraction path. In context, this gives the skill local access to stored credentials, which is more dangerous because the skill's declared function does not justify direct credential file inspection.

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
This function is dedicated to saving an API key into a .env file, creating persistent local secret storage. That is dangerous because .env files are often weakly protected, accidentally shared, or committed to source control, leading to credential disclosure.

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 function is explicitly designed to set and persist the API key to .env, normalizing long-term local credential retention as part of routine operation. In the context of a math visualization skill, this is a disproportionate and insufficiently justified secret-handling capability that raises the risk of leakage.

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
94% confidence
Finding
The dependency is specified with a lower-bound only (`requests>=2.31.0`), which allows future unreviewed versions to be installed and makes builds non-reproducible. In a server-side MCP skill, this increases supply-chain risk and can unexpectedly introduce vulnerable or breaking releases over 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
93% confidence
Finding
`pydantic>=2.7.0` is not pinned, so environments may resolve to different versions with different behavior or newly introduced issues. For an exposed service component, this weakens reproducibility and increases the chance of accidental adoption of insecure or incompatible 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
92% confidence
Finding
`pydantic-settings>=2.2.0` is unpinned, creating a supply-chain and reproducibility issue because any later version satisfying the constraint may be installed. In configuration-handling libraries, unexpected version changes can affect environment parsing and service startup behavior in ways that are hard to audit.

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
93% confidence
Finding
`python-dotenv>=1.0.1` is also unpinned, so deployments may silently consume newer releases that have not been reviewed for security or compatibility. Because this package influences environment-variable loading, unexpected changes can affect secret handling or startup configuration.

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
96% confidence
Finding
The requirement permits `requests` 2.31.0, and the scanner identifies known advisories affecting that version. Because this skill is an MCP server and likely performs outbound HTTP requests, a vulnerable HTTP client can matter in practice, especially for SSRF-adjacent URL handling, redirect behavior, credential leakage, or other request-processing flaws depending on how the library is used.

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 dependency specification allows `python-dotenv` 1.0.1, which is flagged for a symlink-following arbitrary file overwrite issue in `set_key`. This is only exploitable if the skill uses the affected write path on attacker-influenced `.env` targets, but as a server-side tool, unsafe configuration file operations could still damage files or alter runtime behavior.

VirusTotal

65/65 vendors flagged this skill as clean.

View on VirusTotal

Static analysis

No suspicious patterns detected.