Back to skill

Security audit

Avatar Image Generator

Security checks for vulnerabilities and agentic risk

Overview

The skill mostly does what it claims, but it has under-disclosed local-file upload behavior and credential-handling risks that users should review before installing.

Install only if you are comfortable sending prompts, optional reference images, and generated-image metadata to WeryAI. Avoid using local reference-file paths until the documentation and implementation are aligned; use public HTTPS image URLs instead. Prefer setting `IMAGE_GEN_API_KEY` in your environment or a protected secret store rather than persisting it, and install Bun yourself from a trusted source instead of relying on the `npx -y bun` fallback.

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 (4)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/main.ts:193
Finding
WeryAI API Key Can Be Forwarded to an Arbitrary Result URL<![CDATA[ ## Vulnerability Details **File Location**: `scripts/main.ts:193-199` **Duplicate Location**: `scripts/vendor/shared-image-generation/scripts/main.ts:199-205` **Vulnerability Type**: Credential disclosure through unrestricted cross-origin authorization forwarding **Risk Level**: High ### Vulnerable Code ```ts for (const useAuth of [false, true] as const) { try { const init: RequestInit = { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }; if (useAuth) init.headers = { Authorization: `Bearer ${getApiKey()}` }; res = await fetch(url, init); threw = null; if (res.ok) break; lastErr = `HTTP ${res.status}`; if (!useAuth && (res.status === 401 || res.status === 403)) continue; break; } catch (e) { threw = e; res = null; lastErr = e instanceof Error ? e.message : String(e); if (!useAuth) continue; break; } } ``` ### Technical Analysis The image downloader accepts URLs from `detail.images`, which is populated from the remote gateway response. It first accesses each URL without authentication and then retries with the WeryAI bearer credential if the request returns HTTP 401 or 403. No exact-origin validation or hostname allowlist is applied before adding the `Authorization` header. Consequently, the API key can be sent to a domain unrelated to WeryAI. HTTPS alone does not prevent this disclosure because an attacker controlling the destination legitimately receives all request headers. This credential forwarding exceeds the minimum privileges needed to download generated images. Result downloads should ordinarily be performed without gateway credentials, or authenticated only after verifying that the destination is an explicitly trusted WeryAI origin. ### Attack Path 1. An attacker compromises, manipulates, or otherwise influences a gateway task response. 2. The response places an attacker-controlled URL in `detail.images`. 3. The Skill requests that URL without authentication. 4. The attack ...[truncated 799 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Never send the WeryAI API key to URLs returned in image results. 2. Remove the authenticated fallback and download result URLs without an `Authorization` header. 3. If authenticated downloads are unavoidable, parse the URL and enforce: - The `https:` protocol. - An exact allowlist of documented WeryAI/CDN hostnames. - Explicit port restrictions. - Rejection of embedded credentials and nonstandard URL forms. 4. Disable automatic redirects or validate every redirect destination before forwarding authentication. 5. Use origin-bound credentials or short-lived download tokens instead of the main gateway API key. 6. Apply the same correction to the vendored duplicate. 7. Add tests confirming that no authorization header is sent to untrusted hosts, including after 401/403 responses and redirects. 8. Rotate any API key used with the affected implementation if untrusted result URLs may have been processed. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/main.ts:298
Finding
Arbitrary Local Files Can Be Uploaded as Reference Images Contrary to the Declared Safety Boundary<![CDATA[ ## Vulnerability Details **File Location**: `scripts/main.ts:298-305` **Related Validation**: `scripts/main.ts:974-984`, `scripts/main.ts:1013-1018` **Duplicate Location**: `scripts/vendor/shared-image-generation/scripts/main.ts:304-311` **Conflicting Documentation**: `SKILL.md:18` **Vulnerability Type**: Unrestricted local-file read and third-party upload **Risk Level**: Medium ### Vulnerable Code ```ts function toImagePayloadValue(pathOrUrl: string): string { const t = pathOrUrl.trim(); if (/^https?:\/\//i.test(t)) return t; const abs = resolve(t); if (!existsSync(abs)) throw new Error(`Reference image not found: ${abs}`); const buf = readFileSync(abs); const mime = mimeForExt(extname(abs)); return `data:${mime};base64,${buf.toString("base64")}`; } ``` The resulting values are incorporated into the outbound request: ```ts const body: Record<string, unknown> = referenceImages.length > 0 ? { ...baseBody, images: referenceImages.map(toImagePayloadValue) } : baseBody; ``` The declared behavior states: ```md - **Reference images**: Must be public URLs (`https://` recommended). `http://` may work but is insecure. Local file paths and `data:` URLs are rejected. ``` ### Technical Analysis The implementation does not reject local paths. Instead, it resolves any non-HTTP value as a filesystem path, reads the complete file, Base64-encodes its contents, and submits the result to WeryAI. File validation only verifies that the path is accessible. It does not establish that the file is a legitimate image, enforce a permitted extension, inspect magic bytes, limit file size, restrict paths to an approved directory, or require explicit confirmation before upload. Unknown extensions are labeled as `application/octet-stream`, allowing non-image data to be transmitted. This behavior materially conflicts with the Skill's documented safety model. An agent or user relying on `SKILL.md` could reasonably assume that local files cannot ...[truncated 1248 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Choose and consistently enforce one of these security models: ### Preferred: enforce the documented URL-only model 1. Reject every reference value that is not an `https://` URL. 2. Reject `http://`, `file:`, `data:`, and other URL schemes. 3. Update the primary and vendored implementations together. 4. Add tests proving that absolute paths, relative paths, traversal paths, and `data:` values are rejected. ### If local-file upload is intentionally supported 1. Update `SKILL.md` and all user-facing documentation to clearly disclose that local file contents are uploaded to WeryAI. 2. Require explicit user approval before each local upload. 3. Restrict files to an approved project directory and resolve symlinks before checking containment. 4. Validate recognized image extensions and image magic bytes. 5. Reject non-image MIME types, including `application/octet-stream`. 6. Enforce conservative per-file and total upload-size limits. 7. Reject device files, sockets, directories, and other non-regular files. 8. Present the resolved path and destination service before transmission without displaying file contents. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/setup.mjs:126
Finding
Plaintext API Key Is Persisted Without Explicit Restrictive File Permissions<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.mjs:126-130` **Duplicate Location**: `scripts/vendor/shared-image-generation/scripts/setup.mjs:126-130` **Vulnerability Type**: Insecure plaintext secret storage **Risk Level**: Medium ### Vulnerable Code ```js const existing = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : ""; const updated = upsertEnvVar(existing, "IMAGE_GEN_API_KEY", apiKeyInput.value); const wrote = updated !== existing; fs.mkdirSync(path.dirname(envPath), { recursive: true }); if (wrote) fs.writeFileSync(envPath, updated, "utf8"); ``` ### Technical Analysis When persistence is requested, the setup script writes the API key in plaintext to a project- or home-scoped `.env` file. The directory and file are created without explicit permission modes, so their accessibility depends on the process umask and preexisting filesystem permissions. On systems with permissive defaults, shared workspaces, containers with mounted volumes, or multi-user project directories, another local account may be able to read the key. Existing files are also not checked or corrected if they already have insecure permissions. Passing the secret using `--api-key <secret>` additionally risks disclosure through shell history or process argument inspection, although the script itself does not echo the value. ### Attack Path 1. A user runs setup with `--persist-api-key` or `--api-key`. 2. The script writes `IMAGE_GEN_API_KEY` to `.image-skills/avatar-image-generator/.env`. 3. The resulting permissions are inherited from the ambient umask or existing file. 4. Another local user, process, workspace participant, or mounted-volume consumer reads the file. 5. The observer extracts and reuses the WeryAI API credential. ### Impact Assessment The issue may disclose the API key to other local principals with filesystem visibility. A stolen key may permit: - Unauthorized image-generation requests. - Consumption of paid balance or service ...[truncated 244 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Create the configuration directory with mode `0700`. 2. Create the `.env` file atomically with mode `0600`. 3. After opening an existing file, verify that it is a regular file and not a symbolic link. 4. Correct overly broad permissions on existing secret files before using them. 5. Use exclusive creation and atomic replacement to reduce race and symlink risks. 6. Warn users if the underlying filesystem does not support meaningful Unix permission enforcement. 7. Prefer a platform credential store or secret manager over plaintext persistence where available. 8. Avoid recommending `--api-key <secret>` because command-line arguments may enter shell history or process listings. Prefer environment input or protected standard input. 9. Apply equivalent protections to the vendored setup implementation. ]]>

T08 · Insecure Dependencies

Warning
Location
scripts/vendor/weryai-image/run-generate.mjs:22
Finding
Unpinned Remote Bun Package Is Downloaded and Executed Through npx<![CDATA[ ## Vulnerability Details **File Location**: `scripts/vendor/weryai-image/run-generate.mjs:22-23` **Related Locations**: `scripts/package.json:7`, `scripts/smoke-check.mjs:18`, `SKILL.md:95` **Vulnerability Type**: Unpinned remote runtime execution and supply-chain exposure **Risk Level**: Medium ### Vulnerable Code ```js const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx"; const result = spawnSync(npxCommand, ["-y", "bun", entryScript, ...args], { ``` The test script also uses an unpinned package: ```json { "scripts": { "test": "npx -y bun test" } } ``` The documented invocation similarly permits: ```md `${BUN_X}` is either `bun` or `npx -y bun`. ``` ### Technical Analysis When a trusted local Bun executable is unavailable, the Skill invokes `npx -y bun` without an exact package version or integrity constraint. This causes npm registry metadata and package contents to determine which code is downloaded and executed at runtime. The `-y` option suppresses the normal confirmation prompt, reducing the opportunity for users to review the package and version. Because the package is executed rather than merely used as passive data, compromise of the package, its dependencies, registry resolution, or account publishing rights can lead directly to arbitrary local code execution. This is a supply-chain risk rather than evidence that the current `bun` package is malicious. ### Attack Path 1. Bun is not installed locally, or the workflow selects the `npx` fallback. 2. The Skill executes `npx -y bun`. 3. npm resolves the mutable package version from the configured registry. 4. A compromised package release, dependency, maintainer account, or registry response supplies malicious code. 5. `npx` installs and executes that code without interactive confirmation. 6. The malicious package runs with the same operating-system privileges and environment access as the Skill process. ### Impact Assessment A compromised runtime package ...[truncated 565 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Prefer and require a preinstalled, trusted Bun executable. 2. If automatic acquisition is necessary, pin Bun to an audited exact version. 3. Resolve the package through a committed lockfile with integrity metadata. 4. Use a trusted registry explicitly and document the expected package publisher. 5. Avoid `npx -y` for security-sensitive execution paths. 6. Verify package integrity or signatures before execution where supported. 7. Consider distributing a reviewed standalone executable or using the already-required Node.js runtime instead of fetching another runtime dynamically. 8. Ensure CI and production environments use dependency allowlists and immutable caches. 9. Apply the pinned execution strategy consistently to generation, smoke tests, and test scripts. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • System Prompt LeakageDirect Leakage, Indirect Extraction, Tool-Based Exfiltration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (97)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Tp4

High
Category
MCP Tool Poisoning
Confidence
90% confidence
Finding
Generic text-to-image submission to an external API exceeds a narrowly described avatar/headshot function and could be repurposed for arbitrary image generation. In context, this makes the skill more dangerous because users and platform controls may trust it as a constrained creative tool while it actually exposes a broader remote generation interface.

Direct Prompt Extraction

High
Category
System Prompt Leakage
Content
}

function applyStylePreset(prompt: string, style: StylePreset | null | undefined): string {
  if (!style) return prompt;
  return `${prompt.trim()}\n\nStyle preset (${style}): ${STYLE_PRESETS[style]}.`;
}
Confidence
85% confidence
Finding
Skill contains instructions that could directly expose system prompts, internal rules, or hidden instructions to users or external parties.

Direct Prompt Extraction

High
Category
System Prompt Leakage
Content
}

function applyStylePreset(prompt: string, style: StylePreset | null | undefined): string {
  if (!style) return prompt;
  return `${prompt.trim()}\n\nStyle preset (${style}): ${STYLE_PRESETS[style]}.`;
}
Confidence
85% confidence
Finding
Skill contains instructions that could directly expose system prompts, internal rules, or hidden instructions to users or external parties.

Credential Access

High
Category
Privilege Escalation
Content
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
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
const projectSkillDir = path.join(projectRoot, ".image-skills", skillNamespace);
  const homeSkillDir = homeRoot ? path.join(homeRoot, ".image-skills", skillNamespace) : null;

  const projectEnvPath = path.join(projectRoot, ".image-skills", skillNamespace, ".env");
  const projectEnvFile = pathExists(projectEnvPath);
  let apiKeyInProjectEnv = false;
  if (projectEnvFile) {
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Context-Inappropriate Capability

High
Confidence
97% confidence
Finding
The script allows writing credential material to a path under the user's home directory via --scope home, broadening persistence beyond the project boundary. Home-directory secret writes are more dangerous because they may affect multiple projects, survive project deletion, and create a larger target for accidental leakage or abuse by other local processes.

Credential Access

High
Category
Privilege Escalation
Content
-h, --help            Show help

What this does:
  1) Optionally writes IMAGE_GEN_API_KEY into the local skill .env
  2) Runs doctor (read-only)
  3) Ensures a MODELS.json exists (writes the bundled starter if missing)
  4) Initializes EXTEND.md with Nano Banana 2 if no default model exists yet
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
-h, --help            Show help

What this does:
  1) Optionally writes IMAGE_GEN_API_KEY into the local skill .env
  2) Runs doctor (read-only)
  3) Ensures a MODELS.json exists (writes the bundled starter if missing)
  4) Initializes EXTEND.md with Nano Banana 2 if no default model exists yet
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
-h, --help            Show help

What this does:
  1) Optionally writes IMAGE_GEN_API_KEY into the local skill .env
  2) Runs doctor (read-only)
  3) Ensures a MODELS.json exists (writes the bundled starter if missing)
  4) Initializes EXTEND.md with Nano Banana 2 if no default model exists yet
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
-h, --help            Show help

What this does:
  1) Optionally writes IMAGE_GEN_API_KEY into the local skill .env
  2) Runs doctor (read-only)
  3) Ensures a MODELS.json exists (writes the bundled starter if missing)
  4) Initializes EXTEND.md with Nano Banana 2 if no default model exists yet
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Static analysis

Detected: suspicious.dangerous_exec, suspicious.env_credential_access, suspicious.potential_exfiltration

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/bootstrap.mjs:86

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/doctor.mjs:56

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/smoke-check.mjs:18

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/shared-image-generation/scripts/bootstrap.mjs:86

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/shared-image-generation/scripts/doctor.mjs:56

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/shared-image-generation/scripts/smoke-check.mjs:18

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/weryai-image/discover-models.mjs:9

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/weryai-image/doctor.mjs:9

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/weryai-image/main.ts:14

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/weryai-image/recommend-model.mjs:9

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/weryai-image/run-generate.mjs:23

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/vendor/weryai-image/setup.mjs:9

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
scripts/main.ts:47

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
scripts/vendor/shared-image-generation/scripts/main.ts:51

File read combined with network send (possible exfiltration).

Warn
Code
suspicious.potential_exfiltration
Location
scripts/main.ts:6

File read combined with network send (possible exfiltration).

Warn
Code
suspicious.potential_exfiltration
Location
scripts/vendor/shared-image-generation/scripts/main.ts:6