T03 · Remote Payload Retrieval and Execution
- Location
SKILL.md:27- Finding
Mutable Remote Executable Installed into a Privileged System Path
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This VPS automation skill is not clearly malicious, but it installs and runs high-impact root-level remediation with weak reviewability and insufficient approval controls.
Review carefully before installing. Do not use the documented sudo curl install path unless the payload is pinned and verified. Start with dry-run only, avoid daemon or cron mode on production hosts, and require explicit approvals, allowlists, backups, and rollback plans before enabling process kills, /tmp cleanup, service restarts, cache drops, or firewall changes.
SKILL.md:27Mutable Remote Executable Installed into a Privileged System Path
src/guardian.py:88Flawed CPU Detection Can Terminate Critical Processes as Root
src/guardian.py:198Root-Level Cleanup Deletes Unrelated Files from Shared Temporary Storage
src/guardian.py:345Documented Firewall Approval Gate Is Not Implemented
The skill prominently advertises autonomous destructive actions—killing processes, freeing disk, restarting services, and hardening security—without an upfront warning about service interruption, data loss, or lockout risk. In a VPS-management context, these actions can directly affect availability and system integrity if triggered incorrectly or on incomplete telemetry.
The docstring says approval is required for blocking, but the code can automatically block IPs when auto_block is enabled in configuration. This mismatch is dangerous because it undermines operator expectations and can cause privileged, security-sensitive actions to occur without the human review the documentation promises.
The skill describes capabilities that clearly imply shell execution and filesystem modification, but it declares no explicit tool scope or permission boundaries. For an autonomous remediation skill that can kill processes, restart services, and modify security settings, this omission is dangerous because an agent may be granted broader-than-necessary powers without user visibility or enforcement.
The skill is framed with broad activation language such as autonomous monitoring, fixing, and hardening, without clear trigger constraints or bounded operating conditions. In an agent ecosystem, vague scope increases the chance the skill is invoked in inappropriate contexts and performs destructive actions on production systems without sufficiently specific user intent.
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.
# Download
sudo curl -o /usr/local/bin/vps-guardian https://raw.githubusercontent.com/vps-guardian/guardian/main/src/guardian.py
sudo chmod +x /usr/local/bin/vps-guardian
# Configure (optional — defaults are sensible)
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.
# Download
sudo curl -o /usr/local/bin/vps-guardian https://raw.githubusercontent.com/vps-guardian/guardian/main/src/guardian.py
sudo chmod +x /usr/local/bin/vps-guardian
# Configure (optional — defaults are sensible)
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.
# Download
sudo curl -o /usr/local/bin/vps-guardian https://raw.githubusercontent.com/vps-guardian/guardian/main/src/guardian.py
sudo chmod +x /usr/local/bin/vps-guardian
# Configure (optional — defaults are sensible)
Tool defaults are unsafe or overly permissive (e.g. disabled TLS verification, no authentication, world-writable permissions). Unsafe defaults widen the attack surface.
### 4. Security Hardening
- Detects unexpected listening ports (diffs against baseline)
- Identifies brute-force SSH attempts (fail2ban integration)
- Flags world-writable files in /etc, /root
- Checks for suspicious processes (crypto miners, reverse shells)
- **Action**: Blocks IPs via iptables, chmods files, kills suspicious processes
- Never auto-blocks — always requires approval (prevents lockout)
The documentation contradicts itself about whether IP blocking is automatic or approval-gated, which creates ambiguity in a security-sensitive autonomous tool. Operators or downstream agents may assume blocking is safe to perform automatically and unintentionally lock out legitimate users or apply firewall changes without consent.
The example logs show an IP being blocked automatically, while the safety section says security actions always require confirmation. This inconsistency can cause implementers or autonomous agents to perform destructive network controls despite policy expectations, undermining trust and safety guarantees.
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.
- Linux (systemd-based)
- Python 3.8+
- Root or sudo access
- No external dependencies (stdlib only)
## Differences from Monitoring Tools
The package description explicitly advertises broad autonomous intervention capabilities such as killing processes, freeing disk, restarting services, and hardening security, but it provides no activation boundaries, approval gates, or scope limitations. In a VPS-management skill, this is dangerous because downstream users or agents may interpret the description as authorization for high-impact system changes without explicit user confirmation.
The phrase 'Not alerts. Action.' and the listed behaviors indicate the skill is intended to autonomously perform destructive or disruptive remediation rather than merely recommend or request approval. In the context of production VPS administration, such language materially increases risk of accidental service outages, data loss, termination of legitimate workloads, or unsafe security reconfiguration if the skill is invoked by an agent without strong human-in-the-loop controls.
The tool can automatically SIGTERM and then SIGKILL processes based on a flawed CPU heuristic that uses lifetime-average CPU, not current runaway behavior. In an autonomous privileged agent, this is dangerous because it can kill legitimate long-running services or business-critical jobs without confirmation, causing outages or corruption.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
if age_days > cfg["rotate_logs_days"]:
size = os.path.getsize(log_file)
if not dry_run:
subprocess.run(["gzip", "-f", log_file], timeout=30, capture_output=True)
freed += size
except (OSError, subprocess.TimeoutExpired):
pass
The agent deletes files from /tmp automatically based only on age, with no ownership checks, path policy, or explicit user warning beyond logs. In a self-healing VPS tool, this can destroy legitimate temporary application data and cause service outages or data loss, especially because /tmp is shared by many processes and applications.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
# Truncate journal if too large
if cfg["journal_max_size_mb"]:
try:
result = subprocess.run(
["journalctl", "--disk-usage"],
capture_output=True, text=True, timeout=10
)
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
size_mb *= 1024
if size_mb > cfg["journal_max_size_mb"]:
if not dry_run:
subprocess.run(
["journalctl", "--vacuum-size=f{cfg['journal_max_size_mb']}M"],
timeout=30, capture_output=True
)
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
if cfg["apt_cache_clean"]:
try:
if not dry_run:
result = subprocess.run(
["apt-get", "clean"], timeout=30, capture_output=True
)
if result.returncode == 0:
Automatic service restarts are disruptive actions that can interrupt active sessions, reset stateful services, or worsen failures when root cause is unknown. In the context of this skill, the risk is elevated because restart targets can be influenced by configuration and are attempted repeatedly without an explicit user-approval step.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
for svc in critical_services:
try:
result = subprocess.run(
["systemctl", "is-active", svc],
capture_output=True, text=True, timeout=5
)
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
log(f"SERVICE {svc}: {status} → restarting")
if not dry_run:
for attempt in range(3):
subprocess.run(
["systemctl", "restart", svc],
capture_output=True, timeout=30
)
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
capture_output=True, timeout=30
)
time.sleep(5 * (2 ** attempt)) # exponential backoff
check = subprocess.run(
["systemctl", "is-active", svc],
capture_output=True, text=True, timeout=5
)
Writing 3 to /proc/sys/vm/drop_caches changes kernel behavior and can significantly degrade performance or destabilize workloads under memory pressure, while providing limited benefit if used indiscriminately. As an automatic remediation in a privileged daemon, this is dangerous because it performs a system-wide, impactful action without operator acknowledgment or context-aware safeguards.
The skill's scope expands from health monitoring into active network access control by appending iptables DROP rules. In an autonomous VPS agent, this makes the behavior more dangerous because a monitoring tool is expected to observe and remediate host health, not silently alter perimeter policy, which can create self-inflicted denial of service or unintended blocking of valid clients.
No suspicious patterns detected.