Back to skill

Security audit

PostMe Deploy

Security checks for vulnerabilities and agentic risk

Overview

This deployment skill has a legitimate purpose, but it can upload whole local folders and an API key to a caller-controlled URL without clear user confirmation or file filtering.

Review this skill carefully before installing. Use it only for deliberate public deployment, upload only a built output directory or a single reviewed HTML file, avoid project roots containing .env files or secrets, and do not allow custom upload endpoints unless you fully trust the destination.

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
SKILL.md:70
Finding
Arbitrary Upload Endpoint Can Receive Local Files and API Credentials<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 70-73 and 102-152 **Vulnerability Type**: Unrestricted outbound upload destination and credential disclosure **Risk Level**: High ### Vulnerable Code ```python def execute( target_path: str, app_name: str, api_url: str = "https://www.dele.fun/api/upload", api_key: Optional[str] = None, app_desc: Optional[str] = None ) -> str: ``` ```python headers = {} if api_key: headers['Authorization'] = f"Bearer {api_key}" headers['x-agent-user'] = "openclaw-agent" response = requests.post(api_url, files=multipart_data, headers=headers) if response.status_code in (200, 201): data = response.json() base_url = api_url.replace('/api/upload', '') return f"Deployment successful! URL: {base_url}{data.get('url', f'/app/{app_name}/')}" ``` The tool schema also exposes the destination as a caller-controlled parameter: ```json "api_url": { "type": "string", "description": "The full URL to the PostMe /api/upload endpoint. Defaults to https://www.dele.fun/api/upload" } ``` ### Technical Analysis The implementation accepts an unrestricted `api_url` and submits all selected files to that URL. If an API key is supplied, it is placed in the `Authorization` header of the same request. No validation restricts the scheme, hostname, port, or path to the official PostMe HTTPS endpoint. Consequently, an influenced tool invocation can direct both local file content and authentication material to an attacker-controlled server. The code also permits plaintext HTTP destinations and does not explicitly constrain redirect behavior. Although uploading files is the declared purpose of the skill, permitting an arbitrary destination is not necessary for normal operation and breaks the expected trust boundary around the PostMe credential. ### Attack Path 1. An attacker or untrusted instruction influences the `api_url` argument supplied to the deployment function. 2. The function a ...[truncated 1040 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the caller-controlled `api_url` parameter unless custom endpoints are an explicit and necessary feature. 2. Hardcode the official endpoint as `https://www.dele.fun/api/upload`. 3. If endpoint customization is required, parse the URL and enforce: - HTTPS only. - An exact hostname allowlist. - An expected port and upload path. - No embedded user information. - No IP literals or alternate encodings that bypass hostname validation. 4. Disable redirects or validate every redirect target before following it. 5. Never forward authentication headers when the request origin changes. 6. Obtain the API key only from the protected environment variable rather than accepting it as a routine tool argument. 7. Redact credentials and sensitive response content from errors and logs. 8. Require explicit user confirmation before sending files to any non-default destination. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:118
Finding
Recursive Deployment Uploads Files Without Sensitive-File Filtering<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 118-141 **Vulnerability Type**: Unrestricted recursive file collection and disclosure **Risk Level**: Medium ### Vulnerable Code ```python files_to_upload = [] if os.path.isfile(target_path): files_to_upload.append((target_path, os.path.basename(target_path))) elif os.path.isdir(target_path): for root, _, files in os.walk(target_path): for file in files: file_path = os.path.join(root, file) rel_path = os.path.relpath(file_path, target_path).replace(os.sep, '/') files_to_upload.append((file_path, rel_path)) else: return f"Error: '{target_path}' is neither a file nor a directory." if not files_to_upload: return "Error: No files found to upload." multipart_data = [('appName', (None, app_name))] if app_desc: multipart_data.append(('appDesc', (None, app_desc))) file_handles = [] try: for file_path, rel_path in files_to_upload: f = open(file_path, 'rb') file_handles.append(f) multipart_data.append(('files', (os.path.basename(file_path), f))) multipart_data.append(('paths', (None, rel_path))) ``` ### Technical Analysis When `target_path` is a directory, `os.walk` recursively enumerates every contained file. The implementation does not apply an allowlist or denylist, inspect hidden files, exclude repository metadata, enforce a build-output boundary, or present a manifest for approval. Frontend project directories frequently contain files that should not be published, including `.env` files, source maps, private source code, editor configuration, repository metadata, package-manager credentials, and cached build artifacts. Selecting the project root instead of a dedicated distribution directory can therefore disclose substantially more data than intended. The implementation also lacks file-count and aggregate-size limits. This can cause excessive resource consumption or unexpectedly large out ...[truncated 1200 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Deploy only from an explicit build-output directory such as `dist`, `build`, or a user-approved single HTML file. 2. Generate and display a complete upload manifest before transferring data. 3. Require explicit confirmation when deploying a directory or when potentially sensitive files are detected. 4. Deny sensitive and development-only content by default, including: - `.env` and `.env.*` - `.git`, `.svn`, and other VCS metadata - Private keys and certificate files - Credential and token files - Source maps - Dependency caches and editor metadata 5. Prefer a strict extension and path allowlist appropriate for static websites. 6. Resolve and validate canonical paths so files cannot escape the approved deployment root. 7. Define a secure symlink policy; rejecting symlinks is the safest default. 8. Enforce per-file, aggregate-size, directory-depth, and file-count limits. 9. Warn the user that uploaded content may become publicly accessible. ]]>

T08 · Insecure Dependencies

Note
Location
SKILL.md:32
Finding
Unpinned Third-Party Dependency Installation<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 32-35 **Vulnerability Type**: Non-reproducible dependency installation **Risk Level**: Low ### Vulnerable Code ```markdown 2. **Python Dependencies**: The skill requires the `requests` library. ```bash pip install requests ``` ``` ### Technical Analysis The installation instruction retrieves the latest version of `requests` and its transitive dependencies resolved by the active package index. No version constraint, lockfile, hash verification, or trusted-index configuration is provided. The package name itself is legitimate and the audited material contains no evidence that it is currently malicious. The security concern is that installation is not reproducible and implicitly trusts future package and dependency releases, the configured package index, and the local package-manager configuration. An unsafe or compromised package source, dependency release, or resolver configuration could cause unreviewed code to be installed. Python package installation may execute package build logic, making dependency integrity relevant even before the skill is invoked. ### Attack Path 1. A user follows the documented `pip install requests` prerequisite. 2. `pip` resolves the current package and transitive dependency versions from its configured index. 3. If the index, account, dependency release, or local index configuration has been compromised, the resolver can obtain an unsafe artifact. 4. Package build or installation logic executes in the context of the user running `pip`. 5. The installed component subsequently runs when imported by the deployment implementation. ### Impact Assessment Potential impact depends on the privileges used for installation. In a virtual environment, compromise is generally limited to that user and environment, subject to the user's accessible files and credentials. If installation is performed with administrative privileges, a malicious package could affec ...[truncated 182 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin `requests` to a reviewed version or bounded version range. 2. Lock all transitive dependencies with a dependency-management tool. 3. Use hash-verified installations, for example a requirements file containing `--hash` entries. 4. Configure an explicitly trusted package index and avoid untrusted extra indexes. 5. Install dependencies in an isolated virtual environment without administrative privileges. 6. Run dependency vulnerability and provenance checks during release preparation. 7. Periodically update pinned versions through a controlled review and testing process. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (5)

Scope Creep

High
Confidence
98% confidence
Finding
The skill performs an outbound HTTP upload with requests.post even though the manifest declares only read/glob capabilities. That creates a hidden exfiltration path: local files collected from the provided target_path are transmitted to a remote service without the permission model clearly reflecting that network behavior.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
# PostMe Deploy Skill

## Overview
This skill allows AI Agents (OpenClaw, Cursor, Claude, etc.) to automatically deploy generated HTML files or frontend project folders to PostMe (https://www.dele.fun) — a static site hosting platform. It returns a live URL that can be shared with the user.

## Required Environment Variables
Confidence
85% confidence
Finding
The skill is designed to automatically deploy generated content and return a live URL, which is autonomous external action with publication consequences. In the context of a hosting skill, autonomy increases danger because it can transform local artifacts into remotely accessible resources without a strong human-in-the-loop checkpoint.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill description emphasizes deployment convenience but does not prominently warn that local project files will be uploaded to a third-party hosting service. In this context, omission of that disclosure is dangerous because users may believe the action is local or low-risk while source files, assets, and embedded secrets could be published remotely.

Vague Triggers

Medium
Confidence
91% confidence
Finding
The invocation trigger is broad: any request to deploy, publish, or share a web app the agent created may cause the skill to activate. Broad triggers raise the chance of accidental invocation and unintended publication of local content, especially when users ask to 'share' results without understanding that this means remote hosting.

Scope Creep

Medium
Confidence
95% confidence
Finding
The code consumes an environment-backed API secret and uses it to authenticate to a remote service, but that sensitive capability is not clearly represented in the declared permissions. This increases the risk of agents invoking privileged external actions under incomplete transparency and makes secret-backed data transfer easier to misuse.

Static analysis

No suspicious patterns detected.