Back to skill

Security audit

A2a4b2b Mcp

Security checks for vulnerabilities and agentic risk

Overview

This skill matches its stated A2A network purpose, but it needs Review because it can publish or transmit business data externally and its local configuration handling can misdirect API credentials.

Install only if you intend this agent to communicate with a2a4b2b.com and possibly publish business-facing content. Use a low-privilege API key, avoid secrets or regulated data in messages/RFPs/proposals/posts, pin reviewed package versions where possible, and ensure the server is launched from a trusted directory with an explicit approved base URL.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (3)

T09 · Insecure Skill Coding Practices

Error
Location
src/a2a4b2b_mcp/client.py:7
Finding
API Key Disclosure Through Untrusted .env Configuration## Vulnerability Details **File Location**: `src/a2a4b2b_mcp/client.py:7-47` **Vulnerability Type**: Untrusted configuration loading and credential redirection **Risk Level**: High ### Vulnerable Code ```python def load_env(): """Load environment variables from a .env file.""" possible_paths = [ os.path.join(os.path.dirname(__file__), '.env'), os.path.join(os.path.dirname(__file__), '..', '..', '.env'), os.path.join(os.getcwd(), '.env'), ] for env_path in possible_paths: if os.path.exists(env_path): with open(env_path, 'r') as f: for line in f: line = line.strip() if line and not line.startswith('#') and '=' in line: key, value = line.split('=', 1) os.environ.setdefault(key, value) break load_env() class A2A4B2BClient: def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None): self.api_key = api_key or os.getenv("A2A4B2B_API_KEY") self.base_url = base_url or os.getenv( "A2A4B2B_BASE_URL", "https://a2a4b2b.com" ) self.agent_id = os.getenv("A2A4B2B_AGENT_ID") if not self.api_key: raise ValueError("API Key is required. Set A2A4B2B_API_KEY env var.") def _headers(self) -> Dict[str, str]: return { "X-API-Key": self.api_key, "Content-Type": "application/json" } def _request(self, method: str, endpoint: str, **kwargs) -> Any: url = f"{self.base_url}{endpoint}" response = requests.request(method, url, headers=self._headers(), **kwargs) response.raise_for_status() return response.json() if response.content else None ``` ### Technical Analysis Importing the client module automatically searches for and loads a `.env` file. One of the se ...[truncated 1746 chars]
Remediation
## Remediation Suggestions 1. Remove automatic `.env` discovery from the current working directory. 2. Require the host application to provide security-sensitive configuration explicitly. 3. If `.env` support is required, load only a single administrator-selected path with verified ownership and restrictive permissions. 4. Permit only HTTPS API destinations. 5. Validate the API origin against an explicit allowlist, defaulting to `https://a2a4b2b.com`. 6. Reject URLs containing user information, fragments, unexpected ports, or non-approved hosts. 7. Ensure credentials are not forwarded when an HTTP redirect changes the origin. 8. Consider removing configurable production endpoints entirely unless custom deployments are a documented requirement.

T08 · Insecure Dependencies

Warning
Location
skill.json:69
Finding
Unpinned and Unverified Package Installation## Vulnerability Details **File Location**: `skill.json:69-71`, `pyproject.toml:24-27`, and `src/a2a4b2b_mcp/requirements.txt:1-3` **Vulnerability Type**: Unbounded third-party dependency resolution **Risk Level**: Medium ### Vulnerable Code `skill.json`: ```json "dependencies": { "pip": ["a2a4b2b-mcp>=0.1.0"] } ``` `pyproject.toml`: ```toml dependencies = [ "requests>=2.31.0", "mcp>=0.9.0", ] ``` `src/a2a4b2b_mcp/requirements.txt`: ```text requests>=2.31.0 python-dotenv>=1.0.0 mcp>=0.9.0 ``` ### Technical Analysis The installation declarations use open-ended minimum-version constraints and do not provide cryptographic hashes. Installation can therefore resolve future releases that were not part of this audit. The Skill manifest also instructs the host to install `a2a4b2b-mcp` from the configured pip registry instead of explicitly binding execution to the reviewed source tree. This creates a trust gap between the audited artifact and the code that may actually be installed and executed. This does not establish that any current dependency is malicious. It creates a supply-chain exposure in which a compromised registry account, compromised future release, dependency substitution, or incompatible package update could introduce unreviewed code. ### Attack Path 1. An attacker compromises a relevant package publishing account, registry, or future dependency release. 2. The attacker publishes a version satisfying one of the open-ended constraints. 3. A user installs or reinstalls the Skill after the malicious or compromised version becomes available. 4. Pip resolves the newer version because no exact version or hash restricts selection. 5. The package's build, installation, import, or runtime code executes with the privileges of the MCP server process. ### Impact Assessment A compromised dependency could execute arbitrary Python code under the account running OpenClaw or the ...[truncated 360 chars]
Remediation
## Remediation Suggestions 1. Pin the Skill package and all runtime dependencies to exact reviewed versions. 2. Generate and commit a lock file containing cryptographic package hashes. 3. Install with hash verification, such as pip's `--require-hashes` mode. 4. Ensure the manifest executes the source distributed in the reviewed Skill artifact rather than independently resolving another copy from a public registry. 5. Use a controlled package index or approved internal mirror where practical. 6. Review dependency updates before changing pins. 7. Add automated vulnerability and provenance checks to the release process. 8. Keep dependency declarations consistent across `skill.json`, `pyproject.toml`, and `requirements.txt`.

T09 · Insecure Skill Coding Practices

Note
Location
src/a2a4b2b_mcp/client.py:44
Finding
Outbound HTTP Requests Can Block Indefinitely## Vulnerability Details **File Location**: `src/a2a4b2b_mcp/client.py:44-47` **Vulnerability Type**: Missing network timeout **Risk Level**: Low ### Vulnerable Code ```python def _request(self, method: str, endpoint: str, **kwargs) -> Any: url = f"{self.base_url}{endpoint}" response = requests.request(method, url, headers=self._headers(), **kwargs) response.raise_for_status() return response.json() if response.content else None ``` ### Technical Analysis `requests.request()` is called without a connect or read timeout. By default, the Requests library can wait indefinitely for a connection or response. The MCP tool handlers invoke this synchronous method directly from asynchronous handlers. A stalled remote request can therefore block the server's event loop and prevent other tool calls from being processed. ### Attack Path 1. The configured API endpoint becomes unavailable, malicious, or intentionally slow. 2. The endpoint accepts a connection but does not complete the response, or network establishment remains stalled. 3. An agent invokes an MCP tool that calls `_request()`. 4. The synchronous request waits without a deadline. 5. The MCP server remains blocked, degrading or eliminating tool availability until the connection terminates or the process is restarted. ### Impact Assessment Exploitation can cause denial of service for the MCP integration and stall dependent agent workflows. This issue does not directly grant additional privileges or disclose data, but it can prevent the affected process from servicing other operations.
Remediation
## Remediation Suggestions 1. Configure explicit connect and read timeouts, for example: ```python response = requests.request( method, url, headers=self._headers(), timeout=(5, 30), **kwargs, ) ``` 2. Prevent caller-supplied keyword arguments from silently overriding mandatory timeout policy. 3. Add bounded retries with exponential backoff only for idempotent operations and transient failures. 4. Move synchronous HTTP operations to a worker thread or adopt an asynchronous HTTP client so one request cannot block the MCP event loop. 5. Return structured timeout errors to the MCP caller and apply an overall operation deadline.
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
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (30)

Credential Access

High
Category
Privilege Escalation
Content
# 直接加载环境变量,不依赖 dotenv
def load_env():
    """从 .env 文件加载环境变量"""
    # 尝试多个可能的 .env 文件位置
    possible_paths = [
        os.path.join(os.path.dirname(__file__), '.env'),
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
# 直接加载环境变量,不依赖 dotenv
def load_env():
    """从 .env 文件加载环境变量"""
    # 尝试多个可能的 .env 文件位置
    possible_paths = [
        os.path.join(os.path.dirname(__file__), '.env'),
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""从 .env 文件加载环境变量"""
    # 尝试多个可能的 .env 文件位置
    possible_paths = [
        os.path.join(os.path.dirname(__file__), '.env'),
        os.path.join(os.path.dirname(__file__), '..', '..', '.env'),
        os.path.join(os.getcwd(), '.env'),
    ]
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""从 .env 文件加载环境变量"""
    # 尝试多个可能的 .env 文件位置
    possible_paths = [
        os.path.join(os.path.dirname(__file__), '.env'),
        os.path.join(os.path.dirname(__file__), '..', '..', '.env'),
        os.path.join(os.getcwd(), '.env'),
    ]
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
"""从 .env 文件加载环境变量"""
    # 尝试多个可能的 .env 文件位置
    possible_paths = [
        os.path.join(os.path.dirname(__file__), '.env'),
        os.path.join(os.path.dirname(__file__), '..', '..', '.env'),
        os.path.join(os.getcwd(), '.env'),
    ]
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The README advertises tools that can publish capabilities, create posts, create proposals, create sessions, and send messages to external systems without any warning about side effects, authorization expectations, or operational safeguards. In an agent/MCP context, this can mislead users into enabling a server with write-capable actions that may trigger unintended external communications or content publication.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The skill explicitly connects an agent to an external agent network and describes publishing capabilities, creating sessions, and collaborating with third parties, but it provides no warning that agent metadata, prompts, or message contents may leave the local system. This creates a real privacy and data-governance risk because users may enable the skill without understanding that internal business data could be transmitted to external parties.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The registration and usage instructions direct users to invoke external API operations and onboard an agent to a third-party service without any user-facing caution about off-system data transfer. In practice, this can lead users to register internal agents and later exchange sensitive operational or commercial information without understanding the privacy, compliance, or trust implications.

External Transmission

Medium
Category
Data Exfiltration
Content
You need to register an agent on [a2a4b2b.com](https://a2a4b2b.com) first:

```bash
curl -X POST https://a2a4b2b.com/v1/agents/register \
  -H "Content-Type: application/json" \
  -d '{"name":"MyAgent","type":"publisher"}'
```
Confidence
83% confidence
Finding
The curl example performs a POST to an external domain to register an agent, which is a genuine external transmission of user-supplied data. While the example itself is expected for a network integration skill, it is still security-relevant because it normalizes sending information to a third-party service without accompanying caution, validation guidance, or discussion of what data is exposed.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The manifest exposes tools that create sessions, send messages, publish capabilities, proposals, RFPs, and posts to an external agent network, but it does not warn users that invoking these tools can transmit data off-platform or make information public to third parties. This creates a real risk of unintended disclosure of prompts, business data, identifiers, or other sensitive content because users may reasonably treat the skill as local automation rather than external publishing or messaging.

External Transmission

Medium
Category
Data Exfiltration
Content
You need to register an agent on [a2a4b2b.com](https://a2a4b2b.com) first:

```bash
curl -X POST https://a2a4b2b.com/v1/agents/register \
  -H "Content-Type: application/json" \
  -d '{"name":"MyAgent","type":"publisher"}'
```
Confidence
84% confidence
Finding
The registration step instructs users to POST agent information to an external service, which is an external transmission of data. While contacting a remote API is expected for this skill's purpose, the security issue is that the documentation does not contextualize the privacy implications or data handling expectations, so users may disclose organizational information to a third party without sufficient warning.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill advertises network discovery, session creation, messaging, RFP posting, and proposal submission, but it does not clearly warn that these actions send agent metadata, capabilities, and message content to a third-party service. In an agent framework, users may treat tools as local unless explicitly told otherwise, which can lead to unintended disclosure of sensitive business data or prompts to an external network.

Natural-Language Policy Violations

Medium
Confidence
97% confidence
Finding
The README content, including feature descriptions and usage guidance, is written entirely in Chinese, which implicitly enforces a specific language for users. Under the stated policy, this is a natural-language locale constraint unless the file offers an opt-in choice or explains why the skill is region-specific.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The client sends authenticated network requests using the X-API-Key header and may transmit session messages, posts, proposals, and other payload data to a remote service. Although the code has developer-facing docstrings, it lacks any user-facing warning, logging, or confirmation indicating that data and credentials will be sent over the network.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
This Python code exposes multiple actions that appear to transmit user-supplied data over a network via the client object, including creating sessions, sending messages, creating RFPs, proposals, and posts. The file contains no confirmation prompt, visible logging/print disclosure, or inline warning/comment explaining that these operations publish or transmit data externally.

Rp1

Low
Category
MCP Rug Pull
Confidence
60% confidence
Finding
pip install without ==version installs the latest release, which could include malicious changes.

Unverifiable Dependency: setuptools has 10 known advisory(ies) (CVE-2013-1633 (Setuptools vulnerable to Man-in-the-middle attacks); CVE-2025-47273 (setuptools has a path traversal vulnerability in PackageIndex.download that lead); CVE-2024-6345 (setuptools vulnerable to Command Injection via package URL) +7 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
88% confidence
Finding
wheel is also unpinned in the build-system requirements, so artifact creation depends on whichever version the build environment resolves. That weakens reproducibility and can expose the build pipeline to known issues in packaging tooling, even if it does not directly affect runtime code.

Unverifiable Dependency: wheel has 4 known advisory(ies) (CVE-2026-24049 (Wheel Affected by Arbitrary File Permission Modification via Path Traversal in w); CVE-2022-40898 (pypa/wheel vulnerable to Regular Expression denial of service (ReDoS)); CVE-2022-40898 (An issue discovered in Python Packaging Authority (PyPA) Wheel 0.37.1 and earlie) +1 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
88% confidence
Finding
wheel is also unpinned in the build-system requirements, so artifact creation depends on whichever version the build environment resolves. That weakens reproducibility and can expose the build pipeline to known issues in packaging tooling, even if it does not directly affect runtime code.

Unverifiable Dependency: requests has 16 known advisory(ies) (CVE-2014-1830 (Exposure of Sensitive Information to an Unauthorized Actor in Requests); 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) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
95% confidence
Finding
The dependency specification for requests uses a lower-bound only constraint (>=2.31.0) rather than a fully pinned or tightly bounded version. That makes builds non-reproducible and prevents reviewers from verifying whether deployed environments avoid known vulnerable releases, increasing supply-chain risk if an affected version is resolved.

Unverifiable Dependency: mcp has 12 known advisory(ies) (CVE-2025-53366 (MCP Python SDK vulnerability in the FastMCP Server causes validation error, lead); CVE-2025-66416 (Model Context Protocol (MCP) Python SDK does not enable DNS rebinding protection); CVE-2026-52870 (MCP Python SDK: Experimental task handlers allow any client to access and cancel) +9 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
96% confidence
Finding
The mcp dependency is only lower-bounded (>=0.9.0), so consumers may resolve to versions with known security issues or behavior changes. Because this package is an MCP server, weaknesses in the MCP SDK are more relevant than for a non-networked utility and could directly affect exposed server functionality.

Unverifiable Dependency: pytest has 2 known advisory(ies) (CVE-2025-71176 (pytest has vulnerable tmpdir handling); CVE-2025-71176 (pytest has vulnerable tmpdir handling)), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
40% confidence
Finding
Dependency has known vulnerabilities (CVEs). Using packages with unpatched security flaws exposes the environment to known exploits.

Unverifiable Dependency: black has 5 known advisory(ies) (CVE-2026-32274 (Black: Arbitrary file writes from unsanitized user input in cache file name); CVE-2024-21503 (Black vulnerable to Regular Expression Denial of Service (ReDoS)); CVE-2024-21503 (Versions of the package black before 24.3.0 are vulnerable to Regular Expression) +2 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
40% confidence
Finding
Dependency has known vulnerabilities (CVEs). Using packages with unpatched security flaws exposes the environment to known exploits.

Natural-Language Policy Violations

Low
Confidence
83% confidence
Finding
Comments, docstrings, and inline descriptions throughout the file are written exclusively in Chinese, which imposes a specific language context without offering an alternative or documenting a justified locale restriction. This can violate language/locale policy when users or maintainers are not given a choice.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
python-dotenv>=1.0.0
mcp>=0.9.0
Confidence
98% confidence
Finding
The dependency is specified with a lower bound only, which allows builds to resolve to different versions over time and prevents reproducible installations. This becomes a security risk because vulnerable or breaking releases may be pulled in without review, and the manifest gives no assurance about which version is actually installed.

Unverifiable Dependency: requests has 16 known advisory(ies) (CVE-2014-1830 (Exposure of Sensitive Information to an Unauthorized Actor in Requests); 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) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
93% confidence
Finding
Requests has multiple known advisories, and because the manifest does not pin a version, it is impossible to verify whether the installed release is affected. The danger is not that requests is inherently vulnerable here, but that the project leaves open the possibility of resolving to a vulnerable version with no auditable guarantee otherwise.

Static analysis

No suspicious patterns detected.