Back to skill

Security audit

AI代理任务管理服务

Security checks for vulnerabilities and agentic risk

Overview

The skill presents itself as a todo/task-memory tool but includes unrelated API-key and school-search behavior that saves credentials locally, so it needs review before installation.

Install only if you intentionally want the school-search/API-key functionality as well as task management, and only after confirming where the API key is stored, how to remove or rotate it, and whether dependencies are pinned to reviewed versions. There is no artifact-backed proof of exfiltration or destructive behavior, but the credential persistence and mismatched documentation are material review concerns.

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
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (17)

Lp3

Medium
Category
MCP Least Privilege
Confidence
96% confidence
Finding
The skill describes capabilities that involve environment access, file read/write, and network use, yet no explicit permissions or trust boundaries are declared. This creates a confused-deputy risk where an agent may handle secrets, persist data, and make outbound requests without transparent user consent or policy controls.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The documentation claims this is a task-memory/todo skill, but the API-key workflow and referenced service point to an unrelated gaokao/school-search integration. This mismatch can mislead users and downstream agents into providing credentials or invoking behaviors they did not intend to authorize.

Intent-Code Divergence

Medium
Confidence
94% confidence
Finding
The workflow example instructs the agent to call `search_schools`, but the documented toolset only exposes todo tools. Contradictory instructions increase the chance of incorrect tool routing, accidental data disclosure to unintended functions, or exploitation through prompt confusion.

Intent-Code Divergence

Medium
Confidence
95% confidence
Finding
The project structure documents API client and API-key persistence components that do not fit the claimed task-only functionality. This inconsistency obscures the real data flows and may hide secret storage or outbound network behavior from users and reviewers.

Missing User Warnings

High
Confidence
98% confidence
Finding
The skill instructs the agent to collect and persist a user's API key without warning about storage, retention, exposure, or safer alternatives. Soliciting secrets through normal chat and saving them programmatically increases the risk of credential leakage, replay, and unauthorized reuse.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The function persists the provided API key into a local .env file automatically, without any confirmation, warning, or controls on file permissions. In an agent/skill context, this increases the risk of long-lived secret exposure through local file disclosure, accidental commits, backups, or reuse by unrelated processes.

Ssd 3

Medium
Confidence
97% confidence
Finding
Requiring the model to ask for a user's API key and then store it in-session or on disk creates a direct sensitive-data handling risk. In the context of an agent skill, this is more dangerous because users may treat the request as trusted platform behavior and disclose credentials without understanding where they are retained.

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
84% confidence
Finding
The code manually reads the .env file and force-extracts XBY_APIKEY, bypassing the safer abstractions already provided by the settings library. In an agent skill context, this custom secret-loading logic increases the chance of pulling credentials from unexpected local files and normalizes direct secret file access, which is more dangerous when the skill's stated purpose does not obviously require credential file manipulation.

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
84% confidence
Finding
The existence check and subsequent direct read of .env are part of the same custom credential-access path. While not exfiltration by itself, it creates unnecessary direct handling of secret-bearing files, which expands the attack surface for accidental disclosure and makes the skill more sensitive in environments where .env may contain multiple secrets.

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
91% confidence
Finding
This function is explicitly designed to write an API key into a local .env file. Persisting secrets in plaintext application files is risky because they are often readable by local users, included in backups, or accidentally committed, and in an agent-integrated skill the persistence may happen without the operator realizing the credential has become durable.

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
90% confidence
Finding
The helper intentionally sets and persists the API key to .env as part of normal flow, making secret storage durable by default. In the context of an agent skill, default persistence is more dangerous because credentials may be supplied programmatically and then silently left behind on disk for future compromise.

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
95% confidence
Finding
The dependency specifier uses a lower-bound only constraint (`requests>=2.31.0`), which allows installation of any future version and undermines reproducible, reviewable builds. In an agent task-management service that may handle sensitive data and run in automated environments, this increases supply-chain and unexpected-breaking-change risk because security posture can change between installs.

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
95% confidence
Finding
`pydantic>=2.7.0` is unpinned, so deployments are not deterministic and may silently consume newer releases with different behavior or newly introduced issues. While not an immediate exploit by itself, it weakens supply-chain control for a service intended to provide reliable external memory and task execution for AI agents.

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
95% confidence
Finding
`pydantic-settings>=2.2.0` permits unreviewed future versions at install time, reducing build reproducibility and increasing exposure to supply-chain or compatibility issues. For infrastructure supporting complex multi-step agent workflows, unexpected dependency drift can affect both security and operational reliability.

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
95% confidence
Finding
`python-dotenv>=1.0.1` is not pinned, allowing arbitrary newer versions during installation and making the environment non-reproducible. Since this package influences configuration loading, version drift can be particularly risky in automated agent services where environment handling may affect secrets and runtime behavior.

Known Vulnerable Dependency: requests==2.31.0 — 5 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) +2 more

Medium
Category
Supply Chain
Confidence
90% confidence
Finding
The requirements allow installation of `requests` version 2.31.0, which is flagged with multiple advisories. In a service for LLM/AI agent task management, outbound HTTP is likely core functionality, so flaws such as credential leakage, request verification issues, or insecure temporary file handling can become materially relevant 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
87% confidence
Finding
The requirements permit `python-dotenv` version 1.0.1, which is associated with an advisory involving symlink following in `set_key` and possible arbitrary file overwrite. This is less universally exploitable than the `requests` issue because impact depends on whether the application calls the affected functionality on attacker-influenced paths, but it is still a genuine dependency risk.

Static analysis

No suspicious patterns detected.