Back to skill

Security audit

EdgeOne Pages Deploy

Security checks for vulnerabilities and agentic risk

Overview

This EdgeOne deployment skill is mostly purpose-aligned, but it handles account-level tokens and credentialized deployment URLs in ways users should review before installing.

Install only if you are comfortable with the agent handling EdgeOne credentials. Prefer browser login when possible, avoid saving account-level tokens in the project, rotate any token you expose, verify `.edgeone/.token` and `.env` are not committed or synced, and treat printed deployment URLs with `eo_token` or `eo_time` as sensitive links.

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)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:48
Finding
Mutable Unpinned CLI Dependency Installed Globally<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 48-54 **Vulnerability Type**: Supply-chain exposure through a mutable package version **Risk Level**: Medium ### Vulnerable Code ```bash ## Install CLI ```bash npm install -g edgeone@latest ``` Verify: `edgeone -v` must output `1.2.30` or higher. If not, retry installation. ``` ### Technical Analysis The skill instructs the agent to install `edgeone@latest` globally. The `latest` npm distribution tag is mutable, so the package installed in the future may differ from the version reviewed when this skill was published. An npm installation can execute package lifecycle scripts. Because the package is installed globally, those scripts run with the permissions available to the npm process and can modify globally installed tooling or access data available to the invoking user. Merely checking that the resulting version is at least `1.2.30` does not verify package integrity, provenance, or whether the installed release is trusted. This is an unsafe dependency acquisition pattern rather than evidence that the current EdgeOne package is malicious. ### Attack Path 1. An attacker compromises the npm package, its publisher account, or the release pipeline controlling the `latest` tag. 2. The attacker publishes a malicious release and assigns it to `latest`. 3. A user invokes this skill after the compromised release becomes current. 4. The agent executes `npm install -g edgeone@latest`. 5. Malicious package code or lifecycle scripts execute with the permissions of the npm process. 6. The compromised CLI can subsequently access project files, deployment credentials, and source code supplied during deployment. ### Impact Assessment Successful exploitation could execute arbitrary code with the invoking user's privileges, modify globally installed Node.js tooling, access readable project files, and capture credentials later supplied to the CLI. The scope is limited by the operating-system privile ...[truncated 127 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace the mutable tag with an explicitly reviewed version, for example: ```bash npm install -g edgeone@1.2.30 ``` - Validate package provenance and integrity before installation. - Prefer a project-local or isolated installation rather than a global installation where operationally possible. - Upgrade only through an explicit, reviewed version change. - Use a lockfile and integrity hashes if the CLI is incorporated into a managed project dependency set. - Disable npm lifecycle scripts when feasible, or verify that the audited package requires no installation scripts before doing so. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:137
Finding
Account-Level Token Passed Through Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 137-142 **Vulnerability Type**: Sensitive credential exposure through process arguments **Risk Level**: Medium ### Vulnerable Code ```bash # Project already linked edgeone pages deploy -t <token> # New project edgeone pages deploy -n <project-name> -t <token> ``` The same unsafe pattern is also included in the command reference at line 271: ```bash edgeone pages deploy -t <token> ``` ### Technical Analysis The workflow interpolates an account-level API token directly into the CLI argument vector. Command-line arguments are not a secure secret transport mechanism. Depending on the execution environment, they may be exposed through: - Process inspection interfaces while the deployment command is running. - Agent execution traces, terminal logs, or CI job logs. - Shell history if commands are issued through an interactive shell. - Monitoring, debugging, crash-reporting, or telemetry systems that record command arguments. The document explicitly states that the token has account-level permissions. Consequently, disclosure is more consequential than exposure of a narrowly scoped, single-deployment credential. ### Attack Path 1. The user provides an EdgeOne API token to the agent. 2. The agent constructs a deployment command containing the token after the `-t` option. 3. The complete token becomes part of the process argument vector. 4. A local process observer, logging service, CI trace, terminal recorder, or other actor with access to execution metadata captures the command. 5. The attacker extracts the token and submits it to EdgeOne before it expires or is revoked. 6. The attacker performs deployments or other actions permitted by that token. ### Impact Assessment An attacker who obtains the token can authenticate with the permissions assigned to it. Based on the skill's own description, this is an account-level token. The resulting scope may include unauthorized project deploymen ...[truncated 224 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Use a CLI-supported secure input channel that does not place the token in the argument vector, such as standard input, a credential helper, an operating-system keychain, or an inherited file descriptor. - If the CLI only supports environment variables, use a dedicated secret-injection mechanism and ensure the environment is not logged or inherited by unrelated child processes. - Redact tokens from agent tool traces, terminal output, CI logs, telemetry, and error reports. - Avoid constructing shell command strings containing secrets. - Use narrowly scoped and short-lived deployment tokens if EdgeOne supports them. - Rotate the credential immediately if it is exposed, and document a revocation procedure. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:106
Finding
Account-Level Token Stored in an Unprotected Plaintext File<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 106-111 **Vulnerability Type**: Insecure plaintext credential storage **Risk Level**: Medium ### Vulnerable Code ```bash mkdir -p .edgeone echo "<token>" > .edgeone/.token grep -q '.edgeone/.token' .gitignore 2>/dev/null || echo '.edgeone/.token' >> .gitignore ``` ### Technical Analysis The workflow saves the reusable account-level token as plaintext in `.edgeone/.token`. Adding the path to `.gitignore` only helps prevent ordinary Git staging; it does not provide filesystem confidentiality and does not protect against: - Other local users or processes that can read the project directory. - Backup, synchronization, indexing, or workspace collection tools. - Accidental archival or copying outside Git. - Existing Git tracking or alternate version-control tooling. - Overly permissive file modes caused by the user's default `umask`. The instructions do not set restrictive permissions on either `.edgeone` or `.edgeone/.token`. They also place the token into a shell command, potentially exposing it through execution logs and creating unsafe shell-interpolation behavior if the supplied value contains shell-significant characters. ### Attack Path 1. The user chooses to save the account-level token. 2. The agent creates `.edgeone/.token` using the process's default filesystem permissions. 3. The plaintext file remains in the project across future sessions. 4. Another local user, project-accessible process, backup system, workspace extension, or compromised dependency reads the file. 5. The attacker extracts the reusable token. 6. The attacker authenticates to EdgeOne and performs actions allowed by the token. ### Impact Assessment Compromise of the file discloses a persistent account-level credential. An attacker can inherit all privileges granted to the token, including unauthorized deployments and any other EdgeOne operations within its authorization scope. Adding the file to `.gitignore` ...[truncated 124 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Prefer storing the token in an operating-system credential manager or another approved secret store. - If file storage is unavoidable, create the directory and file with restrictive permissions: ```bash install -d -m 700 .edgeone umask 077 cat > .edgeone/.token chmod 600 .edgeone/.token ``` - Supply the token through a non-echoing input channel rather than embedding it in a generated shell command. - Continue excluding the file from version control, but also verify that it is not already tracked: ```bash git rm --cached .edgeone/.token 2>/dev/null || true ``` - Add checks that reject symlinks and unexpected file types before writing the credential. - Use narrowly scoped, short-lived tokens where supported. - Provide clear token rotation, revocation, and secure-deletion instructions. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (8)

Ssd 3

High
Confidence
98% confidence
Finding
The skill explicitly requires revealing the full `EDGEONE_DEPLOY_URL`, including `eo_token` and `eo_time` query parameters that act as access credentials. Instructing the agent to print credential-bearing URLs increases the risk of credential leakage through chat transcripts, logs, screenshots, browser history sync, and third-party telemetry.

Ssd 3

High
Confidence
99% confidence
Finding
The output parsing instructions tell the agent to extract and show the complete tokenized deployment URL after a successful deploy. That operationalizes credential exfiltration into normal workflow behavior, making accidental disclosure highly likely because the secret is intentionally surfaced in user-visible output.

Credential Access

High
Category
Privilege Escalation
Content
```bash
edgeone pages env ls          # List all
edgeone pages env pull        # Pull to local .env
edgeone pages env add KEY val # Add
edgeone pages env rm KEY      # Remove
```
Confidence
96% confidence
Finding
The environment variable commands include pulling remote env vars into a local `.env`, which is direct credential access behavior. In a deploy skill, this expands the agent from publishing code to retrieving secrets, which materially raises the risk profile if invoked unexpectedly or without strong user awareness.

Vague Triggers

Medium
Confidence
95% confidence
Finding
The invocation description includes broad phrases like "deploy my app," "publish this site," "push this live," and "ship to production." These are common phrases that could match many unrelated deployment workflows, while the description does not provide exclusion conditions or tighter scope beyond mentioning EdgeOne Pages.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
The skill is scoped as a deployment helper, but it also documents broader administrative actions such as environment variable management, local development, project linking, and function initialization. This scope creep increases the chance the agent will perform sensitive actions beyond the user's intended deploy task, especially when those actions touch secrets or mutate project/account state.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
Including `edgeone pages env pull` in a deployment-focused skill enables copying remote environment secrets into a local `.env` file without clear necessity for deployment. That can expose credentials on disk, in editor tooling, backups, or accidental commits, turning a deploy workflow into a secret materialization workflow.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The skill instructs the agent to list and pull environment variables into a local file without an explicit warning that those values are sensitive. Pulling secrets locally can expose them to logs, shell history, IDE indexing, accidental sharing, or source control if `.env` protections are incomplete.

Natural-Language Policy Violations

Low
Confidence
78% confidence
Finding
The instructions require the agent to ask the user to choose between China and Global sites and then route behavior based on that region selection. This imposes a locale/regional handling policy in the skill, and while documented, it does not clearly explain that the choice is purely service-endpoint selection rather than a broader language/locale preference.

Static analysis

No suspicious patterns detected.