Back to skill

Security audit

Siluzan CSO

Security checks for vulnerabilities and agentic risk

Overview

The skill appears to support a real CSO/social-media workflow, but its installer makes broad, persistent system and assistant-environment changes using unsafe remote execution patterns.

Review this skill before installing. Prefer manually installing a pinned CLI version, avoid the one-line curl/iex installers, do not allow persistent npm registry changes unless you explicitly want that mirror, and register the skill only into the assistant you intend to use. Use interactive login where possible, avoid placing real API keys or codes in command history, and confirm every upload or publish target before execution.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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 (5)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:50
Finding
Unpinned Remote Installer Content Is Executed Directly<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:50-58` **Vulnerability Type**: Remote payload retrieval and immediate execution **Risk Level**: Critical ### Vulnerable Code ```markdown - **macOS / Linux / WSL:** ```bash bash <(curl -fsSL https://unpkg.com/siluzan-cso-cli@latest/dist/skill/scripts/install.sh) ``` - **Windows PowerShell:** ```powershell irm https://unpkg.com/siluzan-cso-cli@latest/dist/skill/scripts/install.ps1 | iex ``` ``` ### Technical Analysis Both installation commands execute content obtained from an external URL without first saving, inspecting, pinning, or verifying it. The `latest` package tag is mutable, meaning that the effective code executed by these commands can change after this Skill version has been reviewed. HTTPS protects the transport connection but does not establish that a future package release, CDN response, or compromised upstream account contains the reviewed installer. The PowerShell form pipes the response directly to `Invoke-Expression`, while the Bash form executes the response through process substitution. Installing the declared CLI is legitimate functionality, but executing an unpinned network response is not the minimum privilege or minimum trust required to perform that installation. ### Attack Path 1. An attacker compromises the npm package publisher, unpkg delivery path, upstream release process, or another component capable of changing the `latest` artifact. 2. The attacker replaces the referenced installer with code that performs unauthorized actions. 3. A user or AI Agent follows the documented one-line installation command. 4. The network response is passed directly to Bash or `Invoke-Expression`. 5. The attacker-controlled code executes with all privileges available to the invoking user or Agent. ### Impact Assessment Successful exploitation provides arbitrary code execution under the invoking account. Depending on that account's privileges, the payload could: - Read ...[truncated 388 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace `latest` with an immutable package version. 2. Publish SHA-256 checksums or signed release manifests through an independently controlled channel. 3. Download the installer to a local file rather than piping it directly to a shell. 4. Verify the checksum and, where supported, a cryptographic signature before execution. 5. Present the verified script or its planned operations to the user and obtain explicit consent. 6. Prefer the simpler documented installation command where Node.js is already available: ```bash npm install -g siluzan-cso-cli@1.1.45 ``` 7. For PowerShell, apply an execution flow similar to: ```powershell Invoke-WebRequest -Uri $PinnedUrl -OutFile $Installer if ((Get-FileHash $Installer -Algorithm SHA256).Hash -ne $ExpectedHash) { throw "Installer integrity verification failed" } & $Installer ``` 8. Do not use `Invoke-Expression` for downloaded content. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/install.sh:55
Finding
Third-Party Node.js Bootstrap Scripts Are Piped into Bash and Privileged Shells<![CDATA[ ## Vulnerability Details **File Location**: `scripts/install.sh:55-76` **Vulnerability Type**: Unverified remote script execution, including privileged execution **Risk Level**: Critical ### Vulnerable Code ```bash case "$os_type" in macos) if command -v brew >/dev/null 2>&1; then info "Installing Node.js LTS via Homebrew..." brew install node@22 brew link --overwrite node@22 2>/dev/null || true else info "Installing Node.js LTS via install-node.vercel.app..." curl -fsSL https://install-node.vercel.app/lts | bash -s -- --yes fi ;; linux) if command -v apt-get >/dev/null 2>&1; then info "Installing Node.js 22.x via NodeSource (apt)..." curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - sudo apt-get install -y nodejs elif command -v yum >/dev/null 2>&1; then info "Installing Node.js 22.x via NodeSource (yum)..." curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo -E bash - sudo yum install -y nodejs else info "Installing Node.js LTS via install-node.vercel.app..." curl -fsSL https://install-node.vercel.app/lts | bash -s -- --yes fi ;; ``` ### Technical Analysis The installer retrieves scripts from `install-node.vercel.app` and NodeSource endpoints and executes them without content pinning or integrity validation. The Linux package-manager branches explicitly pass downloaded code to `sudo -E bash`, granting the remote response administrative privileges. The use of `sudo -E` additionally preserves parts of the caller's environment. This expands the environment visible to the privileged script and can create further risk if sensitive environment variables or unsafe path-related configuration are present. Automatic installation of a system runtime is broader than necessary for installing a user-facing CLI. A safer design is to treat Node.js as an explicit prerequisite or rely on signed operating-system package metadat ...[truncated 1187 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove all `curl | bash` and `curl | sudo bash` flows. 2. Treat Node.js 18 or later as a prerequisite and stop with manual, platform-specific guidance when it is absent. 3. If automatic installation is essential, use signed operating-system packages and verify repository signing keys through a documented trust process. 4. Pin downloaded artifacts to immutable versions and verify SHA-256 hashes or cryptographic signatures before installation. 5. Avoid `sudo -E`; request elevation only for the exact package-manager command that requires it. 6. Clearly display the operations requiring administrative access and obtain explicit user confirmation before elevation. 7. Prefer a user-scoped Node.js installation when system-wide installation is unnecessary. 8. Run downloaded setup logic with reduced privileges and in an isolated environment where practical. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/install.ps1:107
Finding
Unsigned Git Installer Is Downloaded from a Mirror and Silently Executed<![CDATA[ ## Vulnerability Details **File Location**: `scripts/install.ps1:107-146` **Vulnerability Type**: Unverified executable download and execution **Risk Level**: High ### Vulnerable Code ```powershell function Install-Git { $tmpFile = Join-Path $env:TEMP 'siluzan-git-installer.exe' Write-Info "Downloading Git for Windows: $GIT_INSTALLER_URL" try { $prevProgress = $ProgressPreference $ProgressPreference = 'SilentlyContinue' Invoke-WebRequest -Uri $GIT_INSTALLER_URL -OutFile $tmpFile -UseBasicParsing $ProgressPreference = $prevProgress } catch { Write-Warn "Git installer download failed: $($_.Exception.Message)" return $false } if (-not (Test-Path $tmpFile)) { Write-Warn 'Git installer file not found after download' return $false } $installArgs = @('/VERYSILENT', '/NORESTART', '/NOCANCEL', '/SP-', '/CLOSEAPPLICATIONS', '/RESTARTAPPLICATIONS') if (Test-IsAdmin) { Write-Info 'Installing Git for Windows system-wide (admin detected)...' } else { $userDir = Join-Path $env:LOCALAPPDATA 'Programs\Git' Write-Info "Installing Git for Windows for current user: $userDir" $installArgs += @("/DIR=$userDir") } try { Start-Process -FilePath $tmpFile -ArgumentList $installArgs -Wait -NoNewWindow } catch { Write-Warn "Git installer launch failed: $($_.Exception.Message)" Remove-Item $tmpFile -ErrorAction SilentlyContinue return $false } Remove-Item $tmpFile -ErrorAction SilentlyContinue ``` The URL used by this function is defined at `scripts/install.ps1:20-22`: ```powershell $NPM_MIRROR = 'https://registry.npmmirror.com' # Git for Windows installer (mirrored on Siluzan CDN; bump version here when needed) $GIT_INSTALLER_URL = 'https://staticpn.siluzan.com/assets/git/Git-2.54.0-64-bit.exe' ``` ### Technical Analysis The script downloads a Windows executable from a product-o ...[truncated 1754 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove automatic Git installation because it is only a fallback and not required for the primary CLI installation. 2. Direct users to the official Git for Windows distribution rather than a mirrored executable. 3. If mirroring is operationally required: - Pin the exact version. - Publish and verify a SHA-256 digest. - Validate the Authenticode signature. - Require the signer to match the expected Git for Windows publisher. 4. Create a randomized temporary directory with restrictive permissions instead of using a predictable shared filename. 5. Obtain explicit confirmation before launching any installer, especially in an elevated process. 6. Do not use silent installation flags until artifact identity and user consent have both been established. 7. Abort installation on any signature or checksum mismatch. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/install.sh:134
Finding
Installer Changes Global npm Configuration and Force-Writes Multiple Agent Skill Directories<![CDATA[ ## Vulnerability Details **File Location**: `scripts/install.sh:134-153` **Vulnerability Type**: Excessive global configuration and filesystem modification **Risk Level**: Medium ### Vulnerable Code ```bash local current_registry current_registry=$(npm config get registry 2>/dev/null || echo "") if [ "$current_registry" != "$NPM_MIRROR" ] && [ "$current_registry" != "${NPM_MIRROR}/" ]; then info "Switching npm registry to China mirror for faster downloads..." npm config set registry "$NPM_MIRROR" info "npm registry set to $NPM_MIRROR" else info "npm registry already set to China mirror" fi # Step 2: Install CLI step "Step 2/4: Install ${PKG_NAME}" # 用打包时锁定的 PKG_VERSION,保证脚本与同批 dist/skill 行为对齐 local install_target="${PKG_NAME}@${PKG_VERSION}" info "Running: $PKG_MANAGER install -g ${install_target}" $PKG_MANAGER install -g "${install_target}" info "${install_target} installed" info "Registering Skill to all AI platform global directories..." ${CLI_BIN} init --global --force ``` Equivalent behavior is also present in `scripts/install.ps1:223-243`: ```powershell if ($currentRegistry -ne $NPM_MIRROR -and $currentRegistry -ne "$NPM_MIRROR/") { Write-Info 'Switching npm registry to China mirror for faster downloads...' npm config set registry $NPM_MIRROR Write-Info "npm registry set to $NPM_MIRROR" } $installTarget = "$PKG_NAME@$PKG_VERSION" & npm install -g $installTarget Write-Info 'Registering Skill to all AI platform global directories...' & $CLI_BIN init --global --force ``` ### Technical Analysis The installer persistently changes the user's default npm registry rather than applying the mirror only to this package installation. This changes the supply-chain trust boundary for unrelated future npm commands. It then performs a global package installation and invokes `init --global --force`, which is documented as registering the Skill in every supported AI-assistant directory. The `--force` flag indicates that existing con ...[truncated 1537 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not persistently change the user's npm registry. Apply it only to the current installation: ```bash npm install -g "siluzan-cso-cli@1.1.45" --registry=https://registry.npmmirror.com ``` 2. Prefer the official npm registry unless the user explicitly selects a mirror. 3. Preserve and restore any temporary configuration changes in a guaranteed cleanup handler. 4. Offer local or user-scoped installation instead of global installation where supported. 5. Ask the user which AI assistant should receive the Skill. 6. Initialize only the selected directory rather than every global Agent directory. 7. Remove `--force` by default. If replacement is necessary, show the affected paths and request confirmation. 8. Back up existing Skill content before an approved overwrite. 9. Report every persistent configuration and filesystem change before execution. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/setup.md:36
Finding
Authentication Secrets Are Documented as Command-Line Arguments<![CDATA[ ## Vulnerability Details **File Location**: `references/setup.md:36-47` **Vulnerability Type**: Credential exposure through process arguments and shell history **Risk Level**: Medium ### Vulnerable Code ```bash siluzan-cso login # 交互式登录,按提示创建 API Key 后粘贴 siluzan-cso login --api-key <YOUR_API_KEY> # 直接设置 API Key(跳过交互) siluzan-cso send-login-code --phone 138xxxx # 两段式登录第 1 步:发送短信验证码 siluzan-cso login --phone 138xxxx --code 123456 # 两段式登录第 2 步:用验证码完成登录 siluzan-cso config set --api-key <Key> # 或通过 config set 直接写入 siluzan-cso config set --token <Token> # 备用:设置 JWT Token ``` The file then warns only about one of these documented forms: ```markdown > **⚠️ 不要使用 `config set --token <token>` 的方式。** 该方式会将 Token 明文写入 shell history(`~/.bash_history`、`~/.zsh_history`、PowerShell 历史),存在凭证泄露风险。推荐使用 `siluzan-cso login` 交互式输入。 ``` ### Technical Analysis API keys, JWT tokens, and one-time verification codes are shown as command-line arguments. Command-line secrets may be retained in shell history, terminal logging, Agent execution records, process monitoring, telemetry, crash reports, or support bundles. The document recognizes this risk for `config set --token`, but still presents that command and does not apply the same warning to `--api-key`, `config set --api-key`, or `--code`. API keys and JWT tokens are reusable credentials; an API key may remain valid for the configured validity period. SMS codes are shorter-lived but remain sensitive during their validity window. The audited material does not establish that the CLI redacts process arguments or removes history entries. ### Attack Path 1. A user follows a documented command and substitutes a real API key, token, or verification code. 2. The complete command is recorded in shell history, Agent logs, or process telemetry. 3. Another local user, malicious process, synchronized history service, or support recipient gains acc ...[truncated 731 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove examples that place API keys, JWT tokens, or verification codes directly in command arguments. 2. Make masked interactive input the default and recommended mechanism. 3. Support reading secrets from standard input without echo: ```bash read -rsp "API key: " SILUZAN_API_KEY printf '%s' "$SILUZAN_API_KEY" | siluzan-cso login --api-key-stdin unset SILUZAN_API_KEY ``` 4. On Windows, use `Read-Host -AsSecureString` and a secure CLI input channel. 5. Integrate with operating-system secret stores where possible. 6. If environment variables are supported, clearly warn that they may be inherited by child processes or captured by CI logs. 7. Ensure `~/.siluzan/config.json` is created with restrictive user-only permissions and document those permissions. 8. Redact credentials from stdout, stderr, verbose HTTP logging, telemetry, and Agent-visible execution summaries. 9. Apply the credential-history warning consistently to API keys, JWT tokens, and verification codes. 10. Revoke and rotate any credential suspected of having been entered through an exposed command line. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (32)

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The skill is presented as a CSO workflow assistant, but it also instructs the agent to install software, configure credentials, and register itself into local AI assistant directories. That expanded behavior increases the trust boundary significantly: a user invoking a content/publishing skill may unknowingly authorize system-level changes and credential handling beyond the stated business purpose.

Context-Inappropriate Capability

Medium
Confidence
98% confidence
Finding
The skill directs execution of remote scripts via `curl | bash` and PowerShell `iex`, which allows arbitrary code from a network source to run immediately on the user's machine. In the context of an agent skill, this is especially dangerous because it combines high user trust with system command execution and could lead to full host compromise if the remote content, distribution channel, or dependency chain is tampered with.

Description-Behavior Mismatch

Medium
Confidence
92% confidence
Finding
The publish workflow explicitly permits the AI to directly polish or adapt copy during publishing, which conflicts with the higher-level skill policy requiring copy generation/revision to go through the dedicated content-writer workflow. This creates a policy bypass: users can obtain prohibited direct drafting or rewriting inside an operational publishing flow, undermining required controls, review steps, and routing boundaries.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The installer performs persistent workstation-wide changes beyond merely installing the declared CSO skill: it modifies npm configuration, installs extra software, and registers into multiple assistant skill directories. Broad side effects increase supply-chain and administrative risk because a user running this script for one business skill implicitly authorizes unrelated environment changes.

Context-Inappropriate Capability

Medium
Confidence
97% confidence
Finding
The script explicitly installs Git for Windows as a workaround for unrelated agent-shell behavior, even though Git is not required for the core CSO skill function shown here. This expands the attack surface by downloading and executing a remote EXE, creating unnecessary code-execution risk and violating least-functionality expectations for a business-content skill installer.

Intent-Code Divergence

Low
Confidence
90% confidence
Finding
Although comments describe Git setup as non-fatal fallback support, the code still downloads a remote executable and launches it silently. Silent execution of a network-fetched installer is dangerous because compromise of the hosting path, CDN, or package maintenance process can lead to arbitrary code execution on the user's machine.

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
The installer persistently changes the user's global npm registry to a third-party mirror unrelated to the skill's core CSO functionality. This alters future package resolution for all npm operations, increasing supply-chain risk and creating a hidden system-wide side effect that can expose the user to malicious or stale packages.

Context-Inappropriate Capability

High
Confidence
99% confidence
Finding
The script installs Node.js by fetching and executing remote setup scripts from external domains, including piping content directly into bash and running vendor setup scripts under sudo. This creates a direct remote code execution path during installation, where compromise of the upstream host, network path, or script content would lead to arbitrary code execution on the user's machine.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The trigger examples are very broad generic writing prompts such as '帮我写一篇' and '把这个素材改成文章', which overlap heavily with normal user requests outside this specific workflow. In an agent environment, this can cause unintended auto-routing into the skill, leading to incorrect tool selection, workflow hijacking, or bypass of more appropriate specialized skills mentioned elsewhere in the metadata.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The documentation advertises `--upload` as an automatic convenience feature but does not explicitly warn that image data derived from a local video file will be transmitted to a remote media library. In a skill centered on publishing and media operations, that omission can cause users to upload locally sensitive content without realizing a network transfer and external storage will occur.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The document explicitly instructs users to export account metadata to local JSON files and notes that those files can contain sensitive identifiers such as entityId, mediaCustomerId, and externalMediaAccountTokenId, but it provides no warning about local persistence, access control, or cleanup. In a social-media operations skill, these identifiers are operationally sensitive because they can enable misconfiguration, account targeting, or facilitate misuse if the exported files are exposed on a shared workstation or repo.

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The script persistently changes the user's global npm registry to a mirror without confirmation. This can redirect all future npm installs to a different supply source, affecting unrelated projects and exposing the user to integrity, trust, and availability risks if the mirror serves altered, stale, or compromised packages.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The installer force-registers the skill into multiple global AI assistant directories using init --global --force, causing persistent modification of several tool environments without explicit consent. This is risky because it broadens the trust boundary: one script gains standing integration across many assistants, increasing the chance of unintended invocation or later abuse if the installed CLI or skill is compromised.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The installer changes persistent npm configuration without an explicit warning or consent flow, so users may not realize future npm installs will use a different registry. Hidden persistent configuration changes are dangerous because they affect unrelated software installations and can silently broaden supply-chain exposure.

Missing User Warnings

High
Confidence
99% confidence
Finding
Piping a remotely fetched script directly into bash executes unreviewed code immediately, with no integrity verification or user confirmation. This is a classic unsafe installer pattern that can be abused for arbitrary code execution if the remote source or delivery path is compromised.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The script performs privileged actions with sudo, including executing remote-fetched setup content as root, without a prior warning or confirmation step. This raises the blast radius substantially because any mistake or compromise in the installation path would execute with elevated privileges.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The installer force-registers the skill into multiple global assistant directories using --force without clearly warning the user about filesystem changes and cross-tool persistence. This broadens the trust boundary from a single CLI install to multiple AI environments, increasing the impact if the package is compromised or behaves unexpectedly.

Natural-Language Policy Violations

Medium
Confidence
93% confidence
Finding
The workflow is written to operate in Chinese and repeatedly prescribes Chinese-language process artifacts and outputs without offering any mechanism to honor the user's language preference. In a multilingual agent, this can cause user instructions, compliance constraints, or safety-critical nuances to be misunderstood or rendered inaccessible, increasing the chance of incorrect or non-consensual actions.

Missing User Warnings

Low
Confidence
80% confidence
Finding
The workflow explicitly instructs the agent to persist an intermediate brief file to local storage by default, but it does not require user notice, consent, or any data-minimization step. In a content-operations skill, that brief may contain persona details, business strategy, topic plans, and RAG-derived material, so silent persistence creates unnecessary data-retention and privacy risk if the workspace is shared, synced, or later exfiltrated.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The workflow instructs the agent to write final content files into a persistent output directory and run validation commands, but it does not require any user-facing disclosure or consent before creating files. In an agent setting, silent persistence can surprise users, leak sensitive draft content into shared storage, or create unintended retention of proprietary marketing material.

Ssd 4

Medium
Confidence
88% confidence
Finding
This section explicitly instructs the model to derive a target group's grievances and then construct '反派 + 阵营 + 暗号 + 正当化' to drive group resonance. That is a structured persuasion tactic designed to intensify in-group/out-group dynamics, which can be used to manipulate audiences, inflame hostility, or produce deceptive advocacy content under the guise of ordinary article writing.

Ssd 4

Medium
Confidence
84% confidence
Finding
The document frames public-content writing as a 'sales funnel' and 'emotional rescue,' then later includes conversion-oriented rewriting instructions. In context, this establishes a deliberate manipulation model that prioritizes emotional steering and behavioral conversion over transparent informational writing, increasing the risk of covert persuasive or exploitative content generation.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
linux)
      if command -v apt-get >/dev/null 2>&1; then
        info "Installing Node.js 22.x via NodeSource (apt)..."
        curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
        sudo apt-get install -y nodejs
      elif command -v yum >/dev/null 2>&1; then
        info "Installing Node.js 22.x via NodeSource (yum)..."
Confidence
90% confidence
Finding
Using sudo -E preserves the caller's environment while running a remote-fetched script as root, which can introduce additional risk from environment-variable influence on privileged execution. Combined with network-delivered code, this creates an especially unsafe installation chain.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if command -v apt-get >/dev/null 2>&1; then
        info "Installing Node.js 22.x via NodeSource (apt)..."
        curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
        sudo apt-get install -y nodejs
      elif command -v yum >/dev/null 2>&1; then
        info "Installing Node.js 22.x via NodeSource (yum)..."
        curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo -E bash -
Confidence
86% confidence
Finding
Installing nodejs via sudo apt-get modifies system packages and requires elevated privileges, which is a sensitive operation in an automated skill installer. While package manager use is common, doing so automatically for a non-essential business skill expands the blast radius of installation errors or abuse.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
sudo apt-get install -y nodejs
      elif command -v yum >/dev/null 2>&1; then
        info "Installing Node.js 22.x via NodeSource (yum)..."
        curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo -E bash -
        sudo yum install -y nodejs
      else
        info "Installing Node.js LTS via install-node.vercel.app..."
Confidence
90% confidence
Finding
The yum branch also uses sudo -E while executing upstream setup content, preserving environment state across privilege boundaries. This weakens execution hygiene and can magnify the impact of both local environment manipulation and remote script compromise.

Static analysis

No suspicious patterns detected.