Back to skill

Security audit

volcengine-deploy

Security checks for vulnerabilities and agentic risk

Overview

This appears to be a real Volcengine deployment skill, but it needs review because it combines cloud-resource control, secrets, remote command execution, and untrusted builds with some unsafe scoping.

Review this skill before installing or using it on real cloud accounts. Use project-scoped, short-lived Volcengine credentials; run builds for untrusted repositories in an isolated environment; validate repository/service names before remote commands; avoid leaving kubeconfig or plaintext Secret manifests in the repository; and do not run the generated smoke-test compose stack on a publicly reachable host without tightening ports and credentials.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
Findings (7)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/poll-status.sh:21
Finding

Arbitrary Command Execution Through Shell eval

Content
View full analysis
&2 exit 2 ;; esac done out=$(eval "$cmd" 2>&1 || true) ``` ### Technical Analysis The script accepts a command as a single string through `--cmd` and passes it to `eval`. Unlike direct execution of an argument array, `eval` reparses shell metacharacters, command substitutions, pipelines, redirections, and command separators. Consequently, any untrusted value incorporated into `--cmd` can change the intended probe into arbitrary shell commands. Quoting at the caller is not a reliable security boundary because `eval` performs another shell-parsing pass. ### Attack Path 1. An automated deployment workflow constructs the polling command from repository-controlled or user-controlled metadata. 2. An attacker supplies a value containing shell syntax, such as `;`, `$()`, backticks, or output redirection. 3. The resulting value is passed to `poll-status.sh --cmd`. 4. Line 47 reparses the string through `eval`. 5. The injected command executes with the same local privileges and environment as the deployment agent. ### Impact Assessment Successful exploitation permits arbitrary command execution on the deployment host. Depending on the invoking environment, an attacker may: - Read source code, local files, environment variables, and CLI configuration. - Access Volcengine credentials available to the agent. - Modify deployment state or generated infrastructure configuration. - Invoke cloud APIs using the agent's permissions. - Establish additional local or remote exec ...[truncated 21 chars]
Remediation
View remediation
&2 exit 2 fi out=$("${cmd[@]}" 2>&1 || true) ``` Additional hardening should include: 1. Validate `interval` and `max_attempts` as bounded positive integers. 2. Avoid constructing command strings from repository metadata. 3. Use dedicated polling functions for known Volcengine APIs where possible. 4. Run probes with the minimum environment and privileges required. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:78
Finding

Untrusted Repository Code Is Built Without Isolation

Content
View full analysis
/dev/null || true ./mvnw package -DskipTests -B ./gradlew bootJar --no-daemon -x test cargo build --release bundle install --deployment --without development test ``` Docker templates likewise invoke package managers and project build scripts: ```dockerfile RUN npm ci COPY . . RUN npm run build 2>/dev/null || true ``` ### Technical Analysis Package installation and build operations are code-execution boundaries. Examples include npm lifecycle hooks, Maven and Gradle wrappers, build plugins, native package build scripts, Ruby gem extensions, Rust build scripts, and arbitrary Dockerfile `RUN` instructions. The workflow does not require an ephemeral sandbox, removal of cloud credentials, restricted filesystem access, or restricted network access before running these operations. Therefore, a remote repository can change its effective payload after the Skill itself has been reviewed. ### Attack Path 1. An attacker supplies or recommends a crafted Git repository for deployment. 2. The repository contains a malicious build hook, wrapper, plugin, dependency, or Dockerfile instruction. 3. The Skill clones the current re ...[truncated 929 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
references/ecs-deploy-steps.md:367
Finding

Command and systemd Directive Injection Through Unvalidated Deployment Values

Content
View full analysis
/etc/systemd/system/$repo_name.service && \ systemctl daemon-reload && \ systemctl enable --now $repo_name.service" ``` ```bash run_cmd "create-user" 60 "id appuser >/dev/null 2>&1 || useradd --system --no-create-home appuser; \ chown -R appuser:appuser /opt/$repo_name" ``` The standalone generator also places arguments directly into systemd syntax: ```bash cat <
Remediation
View remediation
&2 exit 2 fi ``` 2. Never interpolate data into a remote shell program. Transfer values as encoded files or positional parameters and quote them at the final execution boundary. 3. Reject `\r`, `\n`, and NUL characters from every systemd field. 4. Validate usernames, absolute paths, service names, and executable paths against field-specific allowlists. 5. Prefer fixed unit templates whose only substitutions are validated scalar values. 6. Run `systemd-analyze verify` on generated units before installation. 7. Apply systemd hardening such as `NoNewPrivileges=true`, `ProtectSystem=strict`, `PrivateTmp=true`, `ProtectHome=true`, and narrowly scoped `ReadWritePaths`. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/gen-docker-compose-test.sh:55
Finding

Generated Smoke-Test Services Are Exposed With Weak or Missing Authentication

Content
View full analysis
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/gen-docker-compose-test.sh:21
Finding

Unvalidated Values Permit Docker Compose YAML Injection

Content
View full analysis
Remediation
View remediation
65535 )); then echo "Invalid application port" >&2 exit 2 fi ``` 2. Validate image names against an OCI/Docker image-reference parser rather than a permissive hand-written expression. 3. Generate YAML using a structured serializer such as `yq`, Python with a safe YAML library, or a JSON document accepted by Compose. 4. Treat analysis JSON as untrusted repository input. 5. Run `docker compose config --quiet` and inspect the normalized configuration before starting services. 6. Reject unexpected top-level keys and privileged features in the normalized output. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/k8s-manifests.md:17
Finding

Kubernetes Secrets Are Persisted as Plaintext Files Inside the Repository

Content
View full analysis
-secret namespace: type: Opaque stringData: # Sensitive config (DB connections, etc.); replace with real values at generation time, never leave placeholders DATABASE_URL: "" REDIS_URL: "" ``` The generated directory is then applied: ```bash kubectl apply -f .volcengine/k8s/ ``` ### Technical Analysis Kubernetes `stringData` values are plaintext in the manifest. The instructions place generated files beneath `.volcengine/k8s/` in the source repository and require replacing placeholders with real database and Redis connection strings. While the primary Skill states that generated sensitive files should use mode `0600`, the workflow does not require immediate deletion after application or ensure that the generated secret manifest is excluded from version control. File mode alone does not protect against accidental commits, backups, source-archive creation, or later local compromise. ### Attack Path 1. The deployment workflow resolves real database, Redis, token, or connection-string values. 2. It writes those values into `.volcengine/k8s/01-config.yaml`. 3. The manifest is applied but remains in the repository. 4. A later broad `git add`, backup operation, artifact bundle, or local compromise captures the file. 5. The disclosed credentials are used to access the corresponding managed service. ### Impact Assessment The scope depends on the secret contents and service allowlists. Exposure may grant: - Read/write access to application databases. - Access to Redis sessions or cached data. - Access to third-party APIs. - Di ...[truncated 279 chars]
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
scripts/gen-docker-compose-test.sh:133
Finding

Mutable latest Container Tags Allow Unreviewed Dependency Changes

Content
View full analysis
Remediation
View remediation
image: clickhouse/clickhouse-server@sha256: ``` Additionally: 1. Maintain an explicit dependency-update process. 2. Verify signatures or provenance attestations where available. 3. Scan images for known vulnerabilities before use. 4. Record the selected digest in deployment artifacts. 5. Avoid implicit pulls during privileged workflows. 6. Apply the same digest-pinning policy to all base, runtime, and dependency images rather than relying only on version tags. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (47)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

This is a clear description/behavior mismatch. The declared purpose is a deployment skill for publishing projects to Volcengine cloud environments. The actual code chunk only generates a Docker Compose YAML for local testing of a prebuilt image and optional service dependencies. While local smoke testing could be a supporting step in a larger deployment workflow, this code by itself does not perform deployment, provisioning, publishing, cloud exposure, or Volcengine-specific actions. Its primary purpose is materially different from the declared deployment behavior.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The declared description presents a full deployment skill for publishing a project or repository to Volcengine cloud targets. The supplied code chunk does not perform deployment, provisioning, packaging, uploading, repository handling, or any Volcengine-specific operations. Its sole function is to emit a systemd unit file to stdout for running a binary as a Linux service. While this could be a supporting helper inside a larger ECS deployment workflow, the chunk itself materially differs from the declared primary purpose and exposes a much narrower, local capability.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding

The declared description says this skill deploys applications/projects to Volcengine cloud targets. However, the actual code shown only implements a generic polling helper script (poll-status.sh) that runs an arbitrary command on an interval and checks its stdout against a regex. This is at most a supporting utility for waiting on some external deployment state, but by itself it does not deploy code, create or manage Volcengine resources, interact with Volcengine APIs/CLI, package a project, or expose a service. Therefore the code chunk's actual behavior does not match the claimed primary purpose.

Content

No source excerpt is available for this finding.

Hidden Instructions

High
Category
Prompt Injection
Confidence
70% confidence
Finding

Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Content

Scanner excerpt · references/deployment-plan-template.md (reported line 25)May include surrounding context.

Template

Copy this structure when generating .volcengine/deployment-plan.md. Translate visible headings and table labels into the user's original language. Keep frontmatter keys, enum values, and <!-- volcengine:section=... --> markers unchanged.

md
---

Chaining Abuse

High
Category
Tool Misuse
Confidence
75% confidence
Finding

Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Content

Scanner excerpt · references/dockerfile-templates.md (reported line 182)May include surrounding context.

md
RUN apk add --no-cache musl-dev
WORKDIR /app
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo "fn main(){}" > src/main.rs && cargo build --release && rm -rf src
COPY . .
RUN touch src/main.rs && cargo build --release

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/dockerfile-templates.md (reported line 233)May include surrounding context.

text
.git
.gitignore
.env
.env.*
node_modules
__pycache__

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ecs-deploy-steps.md (reported line 346)May include surrounding context.

text
.git
.gitignore
.env
.env.*
node_modules
__pycache__

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ecs-deploy-steps.md (reported line 398)May include surrounding context.

text
.git
.gitignore
.env
.env.*
node_modules
__pycache__

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

The remote command interpolates $repo_name into shell code without showing any validation or safe quoting for path-sensitive use. If an attacker can influence the repository/project slug, shell metacharacters or path traversal could alter the command's behavior on the target instance, and the subsequent tar -xzf extraction into /opt/$repo_name also risks writing attacker-controlled paths when combined with an unsafe destination choice.

Content

Scanner excerpt · references/ecs-deploy-steps.md (reported line 169)May include surrounding context.

run_cmd "upload-tos" 600 "mkdir -p /opt/$repo_name &&
curl --http1.1 --retry 5 --retry-all-errors --connect-timeout 10 --max-time 180 -L '$url' -o /tmp/app.tar.gz &&
tar -xzf /tmp/app.tar.gz -C /opt/$repo_name &&
rm /tmp/app.tar.gz"

text

Only pass the pre-signed URL into the remote command. Do not print it, put it in the resource ledger, include it in the final summary, or write it to README/log files. Reports and ledgers must record the durable `tos://bucket/key` object path instead. For cleanup, delete only the deployment prefix, for example `tosutil rm tos://bucket/prefix/ -r -f`; do not use `-y`.

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · references/ecs-deploy-steps.md (reported line 172)May include surrounding context.

rm /tmp/app.tar.gz"

text

Only pass the pre-signed URL into the remote command. Do not print it, put it in the resource ledger, include it in the final summary, or write it to README/log files. Reports and ledgers must record the durable `tos://bucket/key` object path instead. For cleanup, delete only the deployment prefix, for example `tosutil rm tos://bucket/prefix/ -r -f`; do not use `-y`.

### Pre-flight: agent readiness
Before any `RunCommand`, confirm the Cloud Assistant agent is `Running`:

Credential Access

High
Category
Privilege Escalation
Confidence
78% confidence
Finding

This deployment flow constructs secret-bearing environment content locally and embeds the full base64-encoded .env into the remote command string sent through Cloud Assistant. Even though the file is later stored with restrictive permissions, secrets may be exposed in command history, orchestration logs, control-plane telemetry, or debugging output associated with remote command execution.

Content

Scanner excerpt · references/ecs-deploy-steps.md (reported line 397)May include surrounding context.

"REDIS_URL=$redis_url") encoded_env=$(printf '%s' "$env_content" | base64 | tr -d '\n') run_cmd "write-env" 60 "install -d -m 0750 /opt/$repo_name &&
echo '$encoded_env' | base64 -d > /opt/$repo_name/.env &&
chmod 0600 /opt/$repo_name/.env &&
chown appuser:appuser /opt/$repo_name/.env"

text

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/ecs-deploy-steps.md (reported line 399)May include surrounding context.

run_cmd "write-env" 60 "install -d -m 0750 /opt/$repo_name &&
echo '$encoded_env' | base64 -d > /opt/$repo_name/.env &&
chmod 0600 /opt/$repo_name/.env &&
chown appuser:appuser /opt/$repo_name/.env"

text

---

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · SKILL.md (reported line 272)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · SKILL.md (reported line 295)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · SKILL.md (reported line 329)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · SKILL.md (reported line 343)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/k8s-manifests.md (reported line 353)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 5)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 16)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 18)May include surrounding context.

md
Execution runbook for the VKE branch. The main `SKILL.md` keeps only the control-flow skeleton and hard boundaries; this file carries the command-level pipeline. Template details live in [`k8s-manifests.md`](./k8s-manifests.md) and [`dockerfile-templates.md`](./dockerfile-templates.md); for deeper CLI detail, activate the `volcengine-cli` skill and follow its VKE and CR guidance; a real end-to-end run is in `volcengine-iac/references/volcengine-vke-cr-nginx.md`.

Do not skip steps or reorder them. The most common failures come from running a later step before an earlier one converges (e.g. `kubectl apply` before the kubeconfig exists, or generating a Deployment before the image is pushed).

## Execution pipeline

Credential Access

High
Category
Privilege Escalation
Confidence
78% confidence
Finding

The runbook instructs the agent to consume kubeconfig_private from .volcengine/iac-outputs.json, which places cluster access credentials in a predictable local file. In an agent context, storing reusable cluster credentials in workspace artifacts increases the chance of unintended disclosure to other tools, logs, or later steps that read project files.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 11)May include surrounding context.

md
### 1. Provision or reuse VKE + CR

- `infra_management=iac`: use `volcengine-iac` outputs in `.volcengine/iac-outputs.json` for VPC/subnets/security group, `cluster_id`, CR registry/namespace/repository, and (when present) `kubeconfig_private`.
- CLI fast path: create or reuse VPC/subnet/security group, the VKE cluster + node pool, and a CR registry/namespace/repository, recording every CLI-created resource in `.volcengine/created-resources.json` immediately. Reuse a user-specified cluster/registry when given.

Do not hardcode node instance types. Build the image for the node architecture (default `linux/amd64` unless node-pool data proves otherwise).

Credential Access

High
Category
Privilege Escalation
Confidence
84% confidence
Finding

This step directs the agent to read kubeconfig from .volcengine/iac-outputs.json or create one, which operationally grants cluster-admin style access material to the workflow. In an autonomous-agent environment, producing or reusing kubeconfig without explicit controls can broaden access and create credential leakage risk through files, artifact retention, or downstream command inspection.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 30)May include surrounding context.

[ "$phase" = "Running" ] || { echo "cluster not Running: $phase" >&2; exit 1; }

text

Then read kubeconfig from `.volcengine/iac-outputs.json` when present, otherwise create one:

```bash
ve vke CreateKubeconfig --ClusterId "$cluster_id" --Type Public

Credential Access

High
Category
Privilege Escalation
Confidence
88% confidence
Finding

ve vke CreateKubeconfig --ClusterId "$cluster_id" --Type Public explicitly creates cluster access credentials reachable over the public control-plane endpoint. While legitimate for deployment, this is sensitive because the generated kubeconfig can be reused to control the cluster if exposed, and the public type increases the usefulness of a leaked credential.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 33)May include surrounding context.

Then read kubeconfig from .volcengine/iac-outputs.json when present, otherwise create one:

bash
ve vke CreateKubeconfig --ClusterId "$cluster_id" --Type Public
# Decode the returned Kubeconfig (base64) to a file and export KUBECONFIG.

Credential Access

High
Category
Privilege Escalation
Confidence
91% confidence
Finding

Exporting KUBECONFIG exposes the path to active cluster credentials across subsequent processes in the session, increasing the blast radius if any later step, plugin, or subprocess is compromised or overly curious. In agent environments, inherited environment variables are often visible to helper tools and can unintentionally grant cluster control to unrelated operations.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 34)May include surrounding context.

bash
ve vke CreateKubeconfig --ClusterId "$cluster_id" --Type Public
# Decode the returned Kubeconfig (base64) to a file and export KUBECONFIG.

CreateKubeconfig before the cluster is Running returns OperationDenied — that is why the poll above must succeed first. Use --Type Private only when the agent runs inside the VPC.

Credential Access

High
Category
Privilege Escalation
Confidence
91% confidence
Finding

Exporting KUBECONFIG exposes the path to active cluster credentials across subsequent processes in the session, increasing the blast radius if any later step, plugin, or subprocess is compromised or overly curious. In agent environments, inherited environment variables are often visible to helper tools and can unintentionally grant cluster control to unrelated operations.

Content

Scanner excerpt · references/vke-deploy-steps.md (reported line 34)May include surrounding context.

bash
ve vke CreateKubeconfig --ClusterId "$cluster_id" --Type Public
# Decode the returned Kubeconfig (base64) to a file and export KUBECONFIG.

CreateKubeconfig before the cluster is Running returns OperationDenied — that is why the poll above must succeed first. Use --Type Private only when the agent runs inside the VPC.

Static analysis

Detected: suspicious.exposed_secret_literal

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
references/ecs-deploy-steps.md:205