T03 · Remote Payload Retrieval and Execution
- Location
scripts/xui_install.sh:39- Finding
Execution of a Mutable Remote Installer Without Integrity Verification
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is purpose-aligned for remote 3x-ui administration, but it uses unsafe automation patterns that can expose credentials or change servers without strong trust checks.
Review before installing. Use this only on disposable or test servers unless you are comfortable with automated remote administration. Avoid passing passwords in chat or command arguments, do not store panel passwords in plaintext YAML, require HTTPS with valid certificates, verify SSH host keys, and replace the remote curl-to-bash installer with a pinned and verified source.
scripts/xui_install.sh:39Execution of a Mutable Remote Installer Without Integrity Verification
scripts/xui_install.sh:28SSH Host Authentication Is Disabled
scripts/xui_batch.py:443TLS Certificate Verification Is Disabled for Panel Administration
scripts/xui_install.sh:11Sensitive Credentials Are Exposed Through Arguments, Output, Plaintext Configuration, and HTTP Fallback
scripts/requirements.txt:1Python Dependencies Are Unpinned and Installed Without Integrity Hashes
The workflow explicitly instructs execution of a remote installer fetched via curl on a server, yet this high-risk behavior is not transparently declared in the skill summary. Undeclared remote code execution on infrastructure is dangerous because users may provide credentials expecting simple panel management while the skill actually installs software from a live third-party source.
The workflow explicitly instructs execution of a remote installer fetched via curl on a server, yet this high-risk behavior is not transparently declared in the skill summary. Undeclared remote code execution on infrastructure is dangerous because users may provide credentials expecting simple panel management while the skill actually installs software from a live third-party source.
The skill omits a clear upfront warning that it will SSH into servers and execute a remote install script fetched over the network. Given the infrastructure-management context, that omission is especially dangerous because users may unknowingly authorize privileged remote code execution on production or rented servers.
Referenced artifact was not completely inspected
pip install -r scripts/requirements.txt
Setting session.verify = False causes all authenticated requests to panel endpoints to skip server certificate validation while the script transmits usernames, passwords, retrieves keys, edits Xray settings, and restarts services. An attacker positioned on the network or controlling DNS/proxy infrastructure could impersonate a panel, steal credentials, return malicious configuration data, or alter the deployed node settings.
The README explicitly promotes fully automated SSH login, panel installation, and credential handling, but it does not prominently warn that users will be supplying and storing highly sensitive server and panel credentials in plaintext-like workflows. In an AI-driven skill, this increases the chance that credentials are exposed in chat history, local config files, logs, or accidental reuse without the user's informed consent.
The README normalizes automatic remote installation and node creation but does not clearly warn that the skill can make disruptive system changes, including installing 3x-ui, modifying Xray configuration, adding routes, and restarting services. In this context, users may trigger impactful changes through casual natural-language requests without understanding downtime or configuration risk.
The skill invokes shell and network-capable operations but declares no tool scope or permission boundaries. In this context, that means an agent could be induced to run SSH commands, fetch remote code, or modify local files without explicit capability restriction, increasing the risk of unintended remote administration and secret handling.
Broad activation phrases like requests related to 'install panel, create node, 3x-ui' can cause accidental invocation in contexts where the user did not intend remote admin actions. Because this skill can handle credentials, edit files, and potentially perform server-side installation, ambiguous triggering materially increases the chance of unsafe execution.
The instructions direct storing panel URLs, usernames, and passwords in a local YAML file without warning about plaintext secret storage, access control, or lifecycle management. In a skill that manages remote panels, such credentials could be exposed through local compromise, backups, logs, or accidental sharing, leading to unauthorized panel access.
The script globally disables urllib3 TLS warnings and later disables certificate verification on requests sessions, which suppresses indicators of man-in-the-middle risk. In this skill's context, the tool logs into remote admin panels and pushes configuration changes, so insecure TLS handling directly exposes panel credentials and administrative actions to interception or tampering.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
xray_bin = find_xray_bin()
if xray_bin:
try:
out = subprocess.run([xray_bin, "x25519"], capture_output=True, text=True, timeout=10)
priv = re.search(r'PrivateKey:\s*(\S+)', out.stdout).group(1)
pub = re.search(r'PublicKey\):\s*(\S+)', out.stdout).group(1)
return priv, pub
The insecure default of disabling certificate verification is especially dangerous because this script is an administrative automation tool that operates over remote sessions and changes proxy/routing behavior on multiple servers. The skill context increases risk: one unsafe default can compromise several panels at once, leak credentials, and result in unauthorized network redirection or service disruption.
for panel in panels:
print(f"\n── {panel['name']} ──")
s = requests.Session()
s.verify = False
if proxies:
s.proxies = proxies
The script disables SSH host key verification (StrictHostKeyChecking=no) and auto-accepts connection and installation prompts, removing critical trust and review checkpoints. This makes man-in-the-middle attacks, connection to the wrong host, and unsafe default installation choices far more likely, especially because the skill is designed to log into remote servers noninteractively with passwords.
The script remotely executes an installer fetched at runtime from GitHub over SSH using bash <(curl ...), which gives the remote content full shell execution on the target server without integrity verification, version pinning, or user confirmation. In this skill’s context—automated installation on arbitrary servers via provided SSH credentials—this significantly increases supply-chain and remote-code-execution risk if the upstream script is compromised, changed unexpectedly, or intercepted.
Several workflow and safety lines are written in Chinese while the rest of the document is in English, and the skill does not state that it is intended for a Chinese-speaking audience or offer language selection. This can impose a locale/language assumption on users and operators without opt-in.
The dependency is specified with only a lower bound (pyyaml>=6.0), which allows builds to resolve to different versions over time and makes the installed package set non-reproducible. In a skill that provisions servers and networking software, this increases supply-chain risk and makes it impossible to verify whether a safe version is consistently installed.
pyyaml>=6.0
requests>=2.28
qrcode>=7.4
cryptography>=41.0
PyYAML has known historical advisories, and because the manifest does not pin a version, there is no way to confirm that installations avoid affected releases. If the skill parses YAML from user-controlled or remote sources, a vulnerable resolver could enable unsafe parsing behaviors or input-validation issues.
requests>=2.28 is unpinned, so future installations may pull different releases with different security characteristics. Because this skill appears to interact with remote servers over SSH and likely performs network operations, uncontrolled dependency resolution raises supply-chain and patch-verification concerns.
pyyaml>=6.0
requests>=2.28
qrcode>=7.4
cryptography>=41.0
Requests has multiple known advisories, and without exact version pinning the project cannot demonstrate that deployed environments avoid affected versions. In a server-management skill that likely makes outbound network requests and may handle credentials, an affected HTTP client could leak secrets or mishandle TLS/session behavior.
qrcode>=7.4 is not version-pinned, which weakens build reproducibility and makes dependency auditing harder. While this package is less security-sensitive than transport or crypto libraries, leaving it floating still exposes the project to unexpected upstream changes or compromised releases.
pyyaml>=6.0
requests>=2.28
qrcode>=7.4
cryptography>=41.0
cryptography>=41.0 is unpinned despite being a high-sensitivity security library. Allowing arbitrary newer versions without review can introduce incompatible crypto behavior, vulnerable transitive components, or compromised package releases, which is more concerning in a tool that configures secure proxying and server access.
pyyaml>=6.0
requests>=2.28
qrcode>=7.4
cryptography>=41.0
Cryptography has numerous advisories, including issues related to bundled OpenSSL and cryptographic side channels; without pinning, the installed version may be vulnerable and cannot be verified. Given this skill's context of managing panels, nodes, and secure connectivity, weaknesses in a crypto library are more operationally significant than in a generic utility.
The script's comments and runtime messages are written in Chinese only, including usage and status output. This imposes a language choice on users without offering an opt-in, fallback, or documenting that the skill is intentionally limited to a Chinese-speaking audience.