Back to skill

Security audit

huawei-cloud-install-openjiuwenswarm

Security checks across malware telemetry and agentic risk

Overview

This installer is mostly aligned with deploying JiuwenSwarm, but it silently changes the environment, persists cloud credentials, runs downloaded code without integrity checks, and can kill or replace local processes and commands.

Install only in a disposable Huawei Cloud development container where you are comfortable with package installation, global command changes, a long-running exposed service, and local plaintext persistence of the API key in ~/.jiuwenswarm/config/.env. Avoid running the verification instructions that print or source the .env file in shared logs or terminals, and prefer a version that pins and verifies the downloaded runtime before execution.

SkillSpector

By NVIDIA
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
Findings (59)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
tmp_dir = tempfile.mkdtemp()
    try:
        write_progress("[1/5]       Cloning via git LFS...")
        subprocess.run(
            ["git", "clone", "--depth", "1", "-b", "main",
             LFS_REPO_URL, tmp_dir],
            check=True, timeout=DOWNLOAD_TIMEOUT
Confidence
88% confidence
Finding
subprocess.run( ["git", "clone", "--depth", "1", "-b", "main", LFS_REPO_URL, tmp_dir], check=True, timeout=DOWNLOAD_TIMEOUT )

subprocess module call

Medium
Category
Dangerous Code Execution
Content
"Check mirror archive structure")
if not os.path.isfile(ENV_FILE):
    os.makedirs(os.path.dirname(ENV_FILE), exist_ok=True)
    subprocess.run(RUNTIME_INIT, capture_output=True)

# Config .env
config = get_keyring_config()
Confidence
89% confidence
Finding
subprocess.run(RUNTIME_INIT, capture_output=True)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
for cmd_name, cmd_path in commands.items():
    link_path = os.path.join(bin_dir, cmd_name)
    if os.path.islink(link_path) or os.path.isfile(link_path):
        subprocess.run(f"{sudo} rm -f {link_path}", shell=True, capture_output=True)
    if os.path.isfile(cmd_path):
        subprocess.run(f"{sudo} ln -sf {cmd_path} {link_path}", shell=True, capture_output=True)
        subprocess.run(f"{sudo} chmod +x {link_path}", shell=True, capture_output=True)
Confidence
95% confidence
Finding
subprocess.run(f"{sudo} rm -f {link_path}", shell=True, capture_output=True)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
if os.path.islink(link_path) or os.path.isfile(link_path):
        subprocess.run(f"{sudo} rm -f {link_path}", shell=True, capture_output=True)
    if os.path.isfile(cmd_path):
        subprocess.run(f"{sudo} ln -sf {cmd_path} {link_path}", shell=True, capture_output=True)
        subprocess.run(f"{sudo} chmod +x {link_path}", shell=True, capture_output=True)

# Init workspace
Confidence
95% confidence
Finding
subprocess.run(f"{sudo} ln -sf {cmd_path} {link_path}", shell=True, capture_output=True)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
subprocess.run(f"{sudo} rm -f {link_path}", shell=True, capture_output=True)
    if os.path.isfile(cmd_path):
        subprocess.run(f"{sudo} ln -sf {cmd_path} {link_path}", shell=True, capture_output=True)
        subprocess.run(f"{sudo} chmod +x {link_path}", shell=True, capture_output=True)

# Init workspace
if not os.path.isfile(RUNTIME_INIT):
Confidence
93% confidence
Finding
subprocess.run(f"{sudo} chmod +x {link_path}", shell=True, capture_output=True)

subprocess module call

Medium
Category
Dangerous Code Execution
Content
print(f"[4/5] 🛑 Stopping existing instance (ports found: {existing_ports})...", flush=True)
    try:
        # Kill processes occupying jiuwenswarm ports
        result = subprocess.run(
            "ss -tlnp 2>/dev/null | grep -E ':(517[0-9]|1809[0-9]|1900[0-9]|1901[0-9])' | grep -oP 'pid=\\K\\d+' | sort -u",
            shell=True, capture_output=True, text=True, timeout=5
        )
Confidence
92% confidence
Finding
result = subprocess.run( "ss -tlnp 2>/dev/null | grep -E ':(517[0-9]|1809[0-9]|1900[0-9]|1901[0-9])' | grep -oP 'pid=\\K\\d+' | sort -u", shell=True, capture_output=Tru

subprocess module call

Medium
Category
Dangerous Code Execution
Content
def is_port_listening(port):
    result = subprocess.run(
        f"ss -tlnp | grep ':{port}'",
        shell=True, capture_output=True
    )
Confidence
94% confidence
Finding
result = subprocess.run( f"ss -tlnp | grep ':{port}'", shell=True, capture_output=True )

subprocess module call

Medium
Category
Dangerous Code Execution
Content
sudo = "sudo" if os.getuid() != 0 else ""
    for pm in ["dnf", "yum", "apt-get"]:
        if subprocess.run(f"command -v {pm}", shell=True, capture_output=True).returncode == 0:
            subprocess.run(f"{sudo} {pm} install -y keyutils", shell=True, capture_output=True)
            return
Confidence
91% confidence
Finding
subprocess.run(f"{sudo} {pm} install -y keyutils", shell=True, capture_output=True)

Tainted flow: 'download_url' from requests.post (line 90, network input) → requests.get (network output)

Medium
Category
Data Flow
Content
actions = result["objects"][0].get("actions", {})
                download_url = actions.get("download", {}).get("href", "")
                if download_url:
                    resp = requests.get(download_url, stream=True, timeout=DOWNLOAD_TIMEOUT)
                    resp.raise_for_status()
                    total = int(resp.headers.get("content-length", 0))
                    total_mb = total // 1024 // 1024
Confidence
95% confidence
Finding
resp = requests.get(download_url, stream=True, timeout=DOWNLOAD_TIMEOUT)

Lp3

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding
The skill documents capabilities including environment access, file read/write, network download, and shell-like command execution, but does not declare permissions. This weakens reviewability and user awareness, making high-risk actions easier to hide behind an apparently simple installer.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The skill claims to perform a local install, but its documented behavior also includes credential access, package installation, global symlink creation, process termination, and generation of an externally reachable URL. That mismatch prevents informed consent and can cause users to authorize broader system and credential changes than the description suggests.

Intent-Code Divergence

Medium
Confidence
98% confidence
Finding
The document first says the agent must ask for confirmation before write operations, then later instructs it to perform writes and dependency installation without asking. Contradictory safety rules create a path for silent execution of privileged changes while appearing compliant earlier in the document.

Intent-Code Divergence

Medium
Confidence
93% confidence
Finding
Although the skill frames itself as a contained local deployment, the service-management instructions include broad port-based process killing that can terminate unrelated workloads inside the container. In a shared or preconfigured environment, this can disrupt other services and cause unintended denial of service.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
The script modifies system-wide command state by installing global symlinks in /usr/local/bin rather than limiting changes to a local workspace. In a supposedly local container setup, this broadens persistence and trust boundaries, making accidental or malicious replacement of common commands more dangerous.

Context-Inappropriate Capability

Medium
Confidence
98% confidence
Finding
The script reads stored credential material from keyring configuration and writes API secrets into a .env file on disk. Materializing secrets into plaintext files increases exposure through file reads, backups, logs, shell sessions, and later tooling that may inadvertently disclose the .env contents.

Description-Behavior Mismatch

Medium
Confidence
97% confidence
Finding
The script kills any process bound to broad port ranges associated with JiuwenSwarm, without verifying process identity, ownership, or installation provenance. In a shared or repurposed container, this can terminate unrelated applications and cause denial of service beyond the stated purpose of merely installing and starting JiuwenSwarm.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
The use of unconditional `SIGKILL` (`os.kill(..., 9)`) provides a forceful process termination capability that can disrupt arbitrary local services if port matching is inaccurate. Because this skill is described as the mandatory deployment path, embedding broad kill behavior makes the operational impact more dangerous: invoking the skill can silently destroy existing workloads.

Context-Inappropriate Capability

Medium
Confidence
99% confidence
Finding
The skill reads Huawei Cloud settings and extracts an API key from the user's kernel keyring even though the stated purpose is local installation/startup of JiuwenSwarm. This is over-privileged credential access and creates unnecessary exposure of sensitive cloud credentials. In the context of an install skill, this mismatch is especially suspicious and dangerous.

Missing User Warnings

High
Confidence
99% confidence
Finding
The skill explicitly requires silent package installation and forbids telling the user. Hidden dependency installation changes the environment without consent and can introduce supply-chain risk or break reproducibility in the development container.

Missing User Warnings

Medium
Confidence
87% confidence
Finding
The top-level description understates that the skill will read local configuration and kernel keyring credentials during execution. Even if the reads are local, omitting that behavior from the primary description deprives the user of clear notice about sensitive data access.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The documentation explicitly instructs users to print the entire `/root/.jiuwenswarm/config/.env` file. `.env` files commonly contain secrets, tokens, internal endpoints, and service credentials, so displaying the full file can expose sensitive data in terminals, logs, screenshots, or shared troubleshooting output.

Missing User Warnings

Medium
Confidence
98% confidence
Finding
The verification script uses `source "$ENV_FILE"`, which executes the file as shell code rather than merely parsing key-value pairs. If the `.env` file is modified maliciously or contains shell metacharacters/commands, running the verification script can lead to arbitrary command execution under the current user, which is especially dangerous in a privileged container context.

Missing User Warnings

Medium
Confidence
87% confidence
Finding
The script performs privileged deletion and symlink creation under /usr/local/bin without any explicit warning or confirmation. In this skill context, the metadata strongly pushes all deployments through the skill, so silent global modification is more concerning because users may not realize they are authorizing system-level command changes.

Missing User Warnings

Medium
Confidence
86% confidence
Finding
The script initializes the workspace by executing an external runtime script without an explicit warning or confirmation. Because this is a deployment skill that downloads and configures software automatically, hidden execution of extracted scripts increases supply-chain and post-download execution risk.

Missing User Warnings

High
Confidence
99% confidence
Finding
The script silently reads API credentials and writes them into a .env file without explicitly informing the user that secrets will be persisted to disk. This is dangerous because disk persistence broadens the exposure window and may violate least-secret-handling expectations in shared or ephemeral container environments.

VirusTotal

VirusTotal findings are pending for this skill version.

View on VirusTotal

Static analysis

No suspicious patterns detected.