T06 · System Persistence
- Location
scripts/scan_and_report.py:62- Finding
Automatic Installation of Persistent Daily Scheduled Tasks
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill is a disclosed security scanner, but it automatically creates persistent daily jobs and sends reports to all discovered channels after one trigger.
Review before installing. This skill may be useful for monitoring installed skills, but invoking it once can create ongoing daily OpenClaw cron jobs and send findings to every channel/recipient discovered in your OpenClaw session metadata. Only install it if you are comfortable with that persistence and broad report distribution, and be prepared to inspect and remove created cron jobs manually.
scripts/scan_and_report.py:62Automatic Installation of Persistent Daily Scheduled Tasks
scripts/scan_and_report.py:48Global Session Metadata Read Exceeds the Scanner's Minimum Privileges
scripts/skill_audit.py:193Unbounded File and Archive Processing Can Exhaust Host Resources
The documented behavior includes discovering active messaging channels and creating persistent cron jobs, but these sensitive actions are not transparently and narrowly disclosed as privileged operations. A skill that silently enumerates recipients and establishes persistence can lead to unauthorized data disclosure and ongoing execution beyond the user's immediate intent.
The documented behavior includes discovering active messaging channels and creating persistent cron jobs, but these sensitive actions are not transparently and narrowly disclosed as privileged operations. A skill that silently enumerates recipients and establishes persistence can lead to unauthorized data disclosure and ongoing execution beyond the user's immediate intent.
YARA rule matched a known webshell pattern (PHP, Python, JSP, or ASPX webshell).
ew
This skill scans OpenClaw skills for security vulnerabilities before installation. It performs static analysis on skill files and provides a risk assessment.
## Security Check Categories
### 🔴 CRITICAL - Block Installation
These issues will cause automatic rejection of skill installation:
| Check | Pattern | Description |
|-------|---------|-------------|
| exec/eval with user input | `exec(request.args...)` | Dynamic code execution with unsanitized input |
| Hardcoded credentials | `password = "..."` | Credentials will be exposed to all users |
| Environment exfiltration | `os.environ[key]` → `requests.post()` | Sends secrets to external servers |
| Shell injection | `subprocess(user_input)` | Command injection vulnerabilities |
| File exfiltration | `open(os.environ[...])` | Reads files based on env vars |
### 🟠 HIGH - Require Confirmation
These issues will prompt a warning but allow manual override:
| Check | Pattern | Description |
|-------|---------|------------
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.
| Network without timeout | `curl ...` (no -m) | May hang indefinitely |
| os.system usage | `os.system(cmd)` | Shell command execution |
| Raw socket connections | `socket.connect()` | Unknown network destinations |
| Sensitive paths | `/etc/passwd`, `/proc/` | System file access |
### 🟡 MEDIUM - Caution
The skill advertises capabilities that imply reading installed skills, creating scheduled tasks, and sending reports over channels, but it declares no explicit tool scope or permissions. In an agent environment, undocumented access to file, shell, and network surfaces weakens user consent and makes any later implementation of these behaviors harder to constrain or audit.
The manifest description is written in Chinese and presents Chinese trigger language alongside one English phrase, while the rest of the skill instructions consistently assume Chinese usage. This can be a language/locale policy issue because the skill does not offer an explicit language choice or explain that it is intentionally limited to Chinese-speaking users.
The skill says reports are sent to configured channels, but it does not clearly warn that it will automatically discover active channels and push data to all of them. Even if the report is only a scan summary, broadcasting findings about installed skills or detected issues can leak sensitive environment details to unintended recipients.
The first-use flow creates a recurring daily cron job after a single trigger, but the persistence aspect is not warned about strongly enough. Hidden or easy-to-miss persistence increases the risk of unwanted ongoing execution, repeated data access, and continued outbound reporting after the user no longer expects the skill to run.
The script reads session configuration to enumerate active channels and recipients, which is broader access than needed to locally scan skills. This can expose communication metadata and enables the skill to target discovered destinations automatically, increasing the blast radius if the skill is misused or compromised.
The script alters scheduler state by creating cron jobs even though the declared behavior is scanning installed skills and reporting findings. This persistence mechanism can make the skill self-propagating in practice, repeatedly executing itself and expanding its runtime footprint without the user's informed consent.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
"""Set up cron jobs for daily scanning if they don't exist."""
# Check if cron jobs already exist
try:
result = subprocess.run(['openclaw', 'cron', 'list'],
capture_output=True, text=True, timeout=10)
if 'auto skill scanner' in result.stdout.lower() or 'skill audit' in result.stdout.lower():
print("Cron jobs already exist, skipping setup.")
Provisioning outbound cron tasks through the OpenClaw CLI is a privileged capability not obviously required for a scanner. In context, this combines discovery of user channels with persistent scheduled execution, making the skill more dangerous than a normal reporting utility because it can establish recurring outbound behavior automatically.
This subprocess call provisions new cron jobs using data auto-discovered from session state, causing persistent side effects beyond simple scanning. Although it does not use shell=True and is not a direct command-injection sink, it expands the skill's authority by creating scheduled outbound actions tied to channels and recipients without clear user approval.
'--timeout-seconds', '60'
]
result = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
if result.returncode == 0:
print(f"Created cron job for {channel_name}")
else:
This code emits user-facing report content primarily in Chinese, including headings, summaries, and remediation guidance. The file does not provide any opt-in, fallback, or explanation that the skill is intended only for Chinese-speaking users, which violates the language/locale policy criteria.
Skill grants unrestricted tool access without appropriate constraints. An agent with unfettered tool access can perform arbitrary actions including file modification, network requests, and code execution.
{
"name": "Pickle deserialization",
"pattern": r'pickle\.loads?|pickle\.load\s*\(',
"description": "Pickle deserialization - can execute arbitrary code",
"severity": MEDIUM
},
{
The manifest describes a monitoring tool that automatically scans installed skills daily and pushes reports to channels like Telegram or Feishu. This file only implements a command-line scanner that accepts a path argument, prints a local report, and exits, with no automation, installed-skill discovery, or notification delivery behavior.
The top-level documentation says the script scans skills and sends a security report, implying direct delivery behavior. In this file, report generation ends with printing to stdout, while the only delivery-related action is indirect cron setup, so the documented intent does not match the implemented behavior here.
The manifest narrows scope to scanning already installed OpenClaw skills. The implementation accepts any filesystem path, including a single file, any directory tree, or a .skill zip archive, which is broader than the stated installed-skill monitoring scope.