Back to skill

Security audit

农历日历服务

Security checks for vulnerabilities and agentic risk

Overview

The skill is not clearly malware, but it needs review because it stores an API key locally and sends calendar and birth-date queries to a third-party API despite describing itself as Python/lunar-python based.

Install only if you are comfortable giving this publisher an API key and sending dates, birth dates, and birth times to xiaobenyang.com/mcp.xiaobenyang.com. Treat the stored .env API key as a local secret, avoid using a sensitive shared workspace, and prefer a scoped or disposable key if you proceed.

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

Lp3

Medium
Category
MCP Least Privilege
Confidence
91% confidence
Finding
The skill documentation indicates capabilities to read environment variables, read/write local files, and make network calls, yet no permissions are explicitly declared to the user. This creates a transparency and consent problem: the skill can persist secrets and transmit data externally without clear upfront disclosure, which increases the risk of unintended credential exposure or unauthorized data handling.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The skill is presented as a local Python/lunar-python calendar service, but the documented behavior relies on an external service, persists an API key locally, and exposes additional fortune-analysis functions not clearly disclosed in the description. This mismatch can mislead users about where processing occurs and what data is collected or transmitted, undermining informed consent and trust boundaries.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
The manifest advertises a local calendar capability, but the operating instructions route all functionality through a third-party API gated by an API key. Users may provide dates, birth times, and other potentially sensitive personal data believing it is processed locally, when it is actually transmitted to an external provider.

Description-Behavior Mismatch

Medium
Confidence
84% confidence
Finding
References to a gaokao-oriented external service and mismatched example function naming suggest copy-pasted or confused project identity. While not inherently exploitative, this inconsistency is a supply-chain and trust warning because it obscures what backend is actually being contacted and whether the skill's purpose matches the remote service.

Intent-Code Divergence

Medium
Confidence
90% confidence
Finding
Claiming the skill is based on Python 3.12 and lunar-python while later stating that code only calls an API is materially misleading about the computation model and dependency surface. This can cause reviewers and users to underestimate privacy, availability, and integrity risks associated with a remote service dependency.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
This file acts as a generic proxy to a remote MCP API by accepting arbitrary tool names and parameters and forwarding them off-box, which exceeds the stated purpose of a local lunar calendar service. That creates a capability-expansion and data-exfiltration risk: any caller that can reach this function may trigger unintended remote actions or send sensitive user inputs to an external service.

Context-Inappropriate Capability

Medium
Confidence
90% confidence
Finding
The code retrieves an API key and uses it to call an external service, despite the skill being described as a lunar calendar feature that should not obviously require remote privileged access. This broadens the trust boundary, introduces secret-handling risk, and enables hidden dependence on a third-party backend that could process or retain user data.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
The configuration defines remote service endpoint details and an API key for an external service even though the declared skill is a lunar calendar utility. This mismatch is dangerous because it introduces hidden outbound-integration and credential-handling capability that users would not reasonably expect from the stated functionality, increasing the risk of covert data exfiltration or unauthorized remote calls.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The code persistently reads and writes an API key to a local .env file, which is unrelated to the advertised calendar behavior and creates credential storage capability inside the skill. In this context, undisclosed secret persistence is risky because it can silently retain sensitive tokens on disk, be harvested by other local processes, or be accidentally committed or exposed.

Intent-Code Divergence

Medium
Confidence
90% confidence
Finding
The class docstring claims this is a '高考Skill配置' while the package is presented as a lunar calendar service, indicating likely code reuse or repurposing from another skill. Identity inconsistency is a security concern here because it undermines trust, suggests undeclared functionality may remain, and makes review of hidden behavior more difficult.

Intent-Code Divergence

Medium
Confidence
94% confidence
Finding
The environment-variable prefix and field naming reference a different business domain/API namespace than the stated lunar calendar service. This mismatch increases danger in context because it is evidence of transplanted configuration that may connect to unrelated infrastructure and handle secrets beyond the skill's declared scope.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The instructions require asking the user for an API key and then saving it via set_api_key, but there is no user-facing warning that the key will be persisted to local configuration. Storing credentials without explicit disclosure and consent increases the risk of secret retention, accidental reuse, or later exposure through filesystem access.

Missing User Warnings

Medium
Confidence
87% confidence
Finding
The request sends both user-supplied parameters and an API key to an external endpoint without any user-facing disclosure or consent mechanism visible in the code. In a calendar utility context, that is risky because users would reasonably expect local computation, not silent transmission of their inputs to a third party.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The function writes the provided API key into .env without any user-facing warning, consent flow, or notice that credentials will be stored persistently. This is dangerous because users or integrators may assume the key is ephemeral, while the skill silently leaves recoverable secrets on disk where they may be leaked through backups, logs, local compromise, or source-control mistakes.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
This function sends birth date and birth time to an external API, which are personal data elements and may be sensitive in context. Users are not informed in this wrapper that their data leaves the local environment for remote processing, creating a privacy and consent risk, especially for fortune-telling or profile-like analysis derived from birth information.

Missing User Warnings

Low
Confidence
83% confidence
Finding
The `calendar_convert` function transmits the provided date to a remote API without clear disclosure of network transmission. A date alone is relatively low sensitivity, but users may still assume local calendar conversion for a simple utility, so undisclosed remote processing creates avoidable privacy and transparency concerns.

Missing User Warnings

Low
Confidence
82% confidence
Finding
The `huangli_query` wrapper sends a date to an external service without explicit notice. Although the sensitivity is low, users may not expect a read-only almanac lookup to involve third-party processing, making this a transparency/privacy weakness rather than a severe security bug.

Missing User Warnings

Low
Confidence
84% confidence
Finding
The `fortune_daily` function sends user-provided date input to an external API for analysis without informing the user. The data sensitivity is limited, but the hidden remote processing can still violate user expectations and organizational data-handling requirements.

Missing User Warnings

Low
Confidence
80% confidence
Finding
The `jieqi_query` function transmits a year value to an external API without notice of remote handling. This is low-risk data, but it still reflects unnecessary opacity about network transmission for what appears to be a simple informational lookup.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
This function sends birth date and time to an external API for Five Elements analysis without clear disclosure or consent. In this skill context, birth information is central to profiling-style analysis and may be considered sensitive personal data, so undisclosed sharing increases privacy, compliance, and trust risks.

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
93% confidence
Finding
The post-init logic explicitly opens and parses .env to extract a specific API key outside normal settings handling, adding custom credential-access behavior. In the context of a calendar skill, this is dangerous because it demonstrates intentional secret retrieval unrelated to the declared function and creates a pathway for hidden 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
93% confidence
Finding
The code checks for and reads the .env file specifically to recover an API credential, which is an explicit secret-access operation. This is risky in a mismatched skill because it broadens the module from calendar logic into hidden credential processing that could support undisclosed remote-service interaction.

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
96% confidence
Finding
This function is dedicated to saving an API key into a plaintext .env file, creating explicit credential-access and credential-persistence behavior. In this skill context, such handling is outside the expected local calendar feature set and materially increases exposure of secrets to local disclosure, accidental commits, and misuse by unrelated code.

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
95% confidence
Finding
The function explicitly promises to persist an API key to .env, signaling intentional credential retention within the skill lifecycle. That is dangerous here because secret persistence is not justified by the advertised calendar-service purpose and may cause long-lived credential exposure without clear user awareness.

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
96% confidence
Finding
The dependency is specified with only a lower bound (`requests>=2.31.0`), which allows future builds to resolve to different versions over time. This weakens reproducibility and can silently introduce vulnerable or breaking releases through the supply chain, especially for a network-facing library like `requests`.

Static analysis

No suspicious patterns detected.