Back to skill

Security audit

智能体安全管家

Security checks for vulnerabilities and agentic risk

Overview

The skill is a plausible security-audit tool, but it needs review because offline scans still create a persistent device ID and the audit reads broad sensitive local data that is not fully disclosed.

Review before installing. Use it only if you are comfortable with a local security audit reading broad system, workspace, SSH/GPG, process, and agent-memory metadata and writing persistent files under ~/.openclaw. Avoid running it as root, do not use --push unless you trust Changeway's server with device and skill-inventory data, and check for/remove ~/.openclaw/.agent-id and any openclaw cron jobs if you do not want persistence.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (3)

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/openclaw-hybrid-audit-changeway.js:1146
Finding
Persistent Device Identifier Is Created During Offline Scans<![CDATA[ ## Vulnerability Details **File Location**: `scripts/openclaw-hybrid-audit-changeway.js`, lines 1146-1153 and 1254-1288 **Vulnerability Type**: Privacy boundary violation and unintended persistent state **Risk Level**: Medium ### Vulnerable Code ```javascript function generateAgentId() { const idPath = path.join(OC, '.agent-id'); if (fs.existsSync(idPath)) { return fs.readFileSync(idPath, 'utf-8').trim(); } const id = crypto.randomUUID(); try { fs.writeFileSync(idPath, id, { mode: 0o600 }); } catch (e) {} return id; } ``` ```javascript function finalizeAndPushData() { const agentId = generateAgentId(); const status = RED_COUNT > 0 ? "warning" : "success"; const checkedCount = ITEM_SEQ - SKIP_COUNT; const passCount = checkedCount - RED_COUNT; let outputObj = { report_time: REPORT_TIME, status, red_item: RED_COUNT, checkedCount: checkedCount, passCount: passCount, agent_id: agentId, data: JSON_DATA }; // ... fs.writeFileSync(JSON_OUT_FILE, JSON.stringify(outputObj, null, 2), { encoding: 'utf-8', mode: 0o600 }); // ... if (!PUSH_ENABLED) { SUMMARY += `${COLORS.dim}────────────────────────────────────────────────────────────────────────${COLORS.reset}\n`; console.log(SUMMARY); console.log(`${COLORS.dim}Detailed audit report saved to: \`${REPORT_FILE}\`${COLORS.reset}`); process.exit(0); return; } } ``` ### Technical Analysis `finalizeAndPushData()` invokes `generateAgentId()` before checking `PUSH_ENABLED`. Consequently, a normal offline scan creates or reuses the persistent file `~/.openclaw/.agent-id`, even though the Skill documentation states that this identifier is created only when the user explicitly selects `--push`. The identifier is also included in the locally persisted JSON report. A later network-enabled run reuses the same value, allowing sca ...[truncated 1286 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Move identifier generation entirely inside the `PUSH_ENABLED` branch: ```javascript function finalizeAndPushData() { const status = RED_COUNT > 0 ? "warning" : "success"; const checkedCount = ITEM_SEQ - SKIP_COUNT; const passCount = checkedCount - RED_COUNT; const outputObj = { report_time: REPORT_TIME, status, red_item: RED_COUNT, checkedCount, passCount, data: JSON_DATA }; if (!PUSH_ENABLED) { fs.writeFileSync( JSON_OUT_FILE, JSON.stringify(outputObj, null, 2), { encoding: 'utf-8', mode: 0o600 } ); // Finish without creating an agent identifier. return; } const agentId = generateAgentId(); outputObj.agent_id = agentId; // Continue with the consented upload. } ``` 2. Do not include `agent_id` in offline JSON reports. 3. Add a migration option that informs users about and, with confirmation, removes identifiers created by previous offline runs. 4. Add an automated test asserting that an offline execution does not create `.agent-id`. 5. Add a second test confirming that `--push` creates the identifier only after explicit mode selection. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/openclaw-hybrid-audit-changeway.js:1060
Finding
Undisclosed Access to Persistent Agent Memory<![CDATA[ ## Vulnerability Details **File Location**: `scripts/openclaw-hybrid-audit-changeway.js`, lines 1060-1090 **Vulnerability Type**: Excessive access to sensitive persistent Agent state **Risk Level**: Medium ### Vulnerable Code ```javascript function getMemoryFilesForLast24h(memoryDir) { try { const todayStr = getLocalDateStr(now); const yestStr = getLocalDateStr(yest); return fs.readdirSync(memoryDir) .filter(f => { if (!f.toLowerCase().endsWith('.md')) return false; return f.startsWith(todayStr) || f.startsWith(yestStr); }) .map(f => buildSafeChildPath(memoryDir, f)) .filter(Boolean) .sort(); } catch (e) { return []; } } const memoryDir = path.join(OC, 'workspace/memory'); const memFiles = getMemoryFilesForLast24h(memoryDir); let memCount = 0; for (const f of memFiles) { memCount += countMatchesInFile( f, platform === 'win32' ? /privileged/gim : /sudo/gim ); } const privLabel = platform === 'win32' ? 'privileged extraction' : 'Sudo'; let detail13 = `${privLabel} Count (Today): ${sudoCount}\n` + `Memory Count (Today): ${memCount}\n` + `Memory Files (Matched): ${memFiles.length}\n` + `${memFiles.length ? memFiles.join('\n') : '(none)'}`; ``` ### Technical Analysis The Skill opens recent Markdown files from `~/.openclaw/workspace/memory` and scans their full contents for privilege-related terms. Agent memory may contain conversation-derived data, user preferences, operational context, or other persistent private information. The privacy declaration identifies system logs, MAC address, hostname, temporary paths, and the installed Skill inventory, but it does not clearly identify persistent Agent-memory files as an input to the scan. Therefore, the access exceeds the specifically disclosed data boundary. The implementation only records match counts and file paths rather than m ...[truncated 1355 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove direct Agent-memory scanning from the default audit. 2. If correlation with privileged operations is necessary, use a dedicated, structured audit-event store rather than conversation-derived memory. 3. Place memory inspection behind a separate opt-in flag, such as `--scan-agent-memory`, with explicit consent describing: - The directory being accessed. - The type of content processed. - What metadata is persisted. - Whether any result can be uploaded. 4. Do not persist full memory paths. Record only aggregate counts or sanitized identifiers. 5. Apply a strict size limit and reject symbolic links before reading any memory file. 6. Update the privacy documentation to identify Agent memory as sensitive input if the feature remains. 7. Add tests proving that default and `--push` scans do not access Agent memory unless the dedicated opt-in is present. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/openclaw-hybrid-audit-changeway.js:272
Finding
Default and Optional Audits Traverse an Excessively Broad Sensitive Host Surface<![CDATA[ ## Vulnerability Details **File Location**: `scripts/openclaw-hybrid-audit-changeway.js`, lines 272-284, 421-482, 526-546, and 1009-1039 **Vulnerability Type**: Violation of least privilege through broad sensitive-file and process inspection **Risk Level**: Medium ### Vulnerable Code The optional configuration-baseline mode attempts to hash highly sensitive host files: ```javascript if (platform === 'win32') { configFiles.push( path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'ssh', 'sshd_config'), path.join(HOME, '.ssh/authorized_keys'), path.join(HOME, '.ssh/config') ); } else { configFiles.push( '/etc/ssh/sshd_config', path.join(HOME, '.ssh/authorized_keys'), path.join(HOME, '.ssh/config'), '/etc/passwd', '/etc/shadow' ); } ``` The default audit recursively traverses broad sensitive directories: ```javascript let SENSITIVE_ROOTS; if (platform === 'win32') { SENSITIVE_ROOTS = [ OC, path.join(HOME, '.ssh'), path.join(HOME, '.gnupg'), path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'ssh') ]; } else { SENSITIVE_ROOTS = [ OC, '/etc', path.join(HOME, '.ssh'), path.join(HOME, '.gnupg'), '/usr/local/bin' ]; } const MS_24H = 24 * 60 * 60 * 1000; let lines = findRecentFiles(SENSITIVE_ROOTS, PRUNE_PATTERNS, MS_24H); ``` On Linux, it opens the Gateway process environment: ```javascript if (platform === 'linux') { const environPath = `/proc/${gwPid}/environ`; try { const environData = fs.readFileSync(environPath, 'utf-8'); const envEntries = environData.split('\0').filter(Boolean); const sensitivePattern = /^(.*?(SECRET|TOKEN|PASSWORD|KEY|PRIVATE).*?)=/i; const hitNames = []; envEntries.forEach(entry => { const m = entry.match(sensitivePattern); if (m) hitNames.push(m[1] + '=(REDACTED)'); }); ...[truncated 4878 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove `/etc/shadow` from baseline generation. Password-database integrity should be delegated to a dedicated host-integrity tool. 2. Restrict the default scan to OpenClaw-owned configuration, report, Skill, and plugin paths. 3. Put host-wide checks behind separate, explicit options, for example: - `--scan-system-config` - `--scan-ssh` - `--scan-gpg` - `--scan-process-environment` - `--scan-workspace-secrets` 4. Clearly disclose each sensitive data source and request explicit consent before accessing it. 5. Refuse to run broad scans as root unless the user supplies a specific acknowledgement flag. 6. Replace workspace-wide content reads with: - Explicit include paths. - Strict file-size limits. - A small allowlist of text extensions. - Exclusions for credential stores, private keys, backups, databases, and archives. 7. Reject symbolic links with `lstatSync()` and verify every resolved path remains inside the intended root: ```javascript const root = fs.realpathSync(scanRoot); const stat = fs.lstatSync(fullPath); if (stat.isSymbolicLink()) { continue; } const resolved = fs.realpathSync(fullPath); if (resolved !== root && !resolved.startsWith(root + path.sep)) { continue; } ``` 8. For process-environment inspection, use a Gateway diagnostic interface that returns only approved variable names rather than reading the complete environment block. 9. Store only aggregate results where possible, and avoid persisting absolute paths or sensitive hashes. 10. Explicitly preserve the current rule that `authorized_keys` and other SSH files are read-only; add tests that fail if any write operation targets `.ssh`. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (30)

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The skill’s declared behavior understates or misstates several material actions: persistent agent_id creation, baseline/hash snapshot writes, actual cron behavior, and the breadth of uploaded identifiers and skill metadata. This is dangerous because users and policy engines may consent to a narrower privacy/security impact than what the skill actually performs, undermining informed consent and trust boundaries.

Ae1

High
Category
analysis-evasion
Content
macOS/Linux:shasum -a 256 scripts/openclaw-hybrid-audit-changeway.js
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

YARA rule 'backdoor_persistence': Backdoor persistence with malicious payloads (shell commands, SSH key injection, hidden root users) [malware]

High
Category
YARA Match
Content
配置定时任务。配置完成后再继续第三步。
- 用户选 **2**(或回复"先跑一次"、"以后再说"、"跳过"等含义)→ 创建标记文件 `~/.openclaw/.audit-first-run`(内容写 `skipped`),然后继续第三步。

**关于定时任务的硬性要求**:
- 必须使用 `openclaw cron add` 命令
- 禁止使用系统 crontab(`crontab -e` 等)
- 原因:系统 crontab 无法正确初始化 OpenClaw 环境,会导致执行失败
- ⚠️ 基础设施绑定说明:使用 `openclaw cron` 会将定时执行与 openclaw 基础设施绑定;如不希望依赖此基础设施,可不设置定时任务,改为手动执行
- **cron 命令中严禁添加 `--push` 参数**:定时任务只以本地离线模式运行,绝不自动向远端上报设备标识

## 第三步:询问检测模式

向用户发送以下消息,然后等待用户回复:

```
请选择检测模式:

1. 仅本地扫描(默认)— 不联网、不发送任何数据
   · �
Confidence
75% confidence
Finding
YARA rule matched a known malware signature (reverse shell, backdoor, ransomware, C2 framework, or info stealer).

YARA rule 'backdoor_persistence': Backdoor persistence with malicious payloads (shell commands, SSH key injection, hidden root users) [malware]

High
Category
YARA Match
Content
# OpenClaw 安全巡检定时任务配置指南

## ⚠️ 重要警告(必读)

### 必须使用 `openclaw cron`,禁止使用系统 crontab

❌ **错误做法**:使用 `crontab -e` 或编辑 `/etc/crontab`


✅ **正确做法**:使用 OpenClaw 内置的 cron 系统
```bash
openclaw cron add ...
```

**原因**:
1. 系统 crontab 无法正确初始化 OpenClaw 环境变量和会话
2. 会导致执行失败、权限问题或推送异常
3. `openclaw cron` 自动处理隔离会话、超时、推送等逻辑

## 快速配置

### 使用 OpenClaw Cron 注册

```bash
openclaw cron add \
  --name "changeway-security-audit" \
  --description "每晚安全巡检" \
  --cron "45 23 * * *" \
  --tz "Asia/Shanghai" \
  --session "isolated" \
  --message "Run the security audit script: node <skill-path>/scripts/openclaw-hybrid-audit-changeway.js — then from the output extract and report ONLY these three items: (1) the l
Confidence
75% confidence
Finding
YARA rule matched a known malware signature (reverse shell, backdoor, ransomware, C2 framework, or info stealer).

Credential Access

High
Category
Privilege Escalation
Content
if (platform === 'win32') {
        configFiles.push(
            path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'ssh', 'sshd_config'),
            path.join(HOME, '.ssh/authorized_keys'),
            path.join(HOME, '.ssh/config')
        );
    } else {
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
if (platform === 'win32') {
        configFiles.push(
            path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'ssh', 'sshd_config'),
            path.join(HOME, '.ssh/authorized_keys'),
            path.join(HOME, '.ssh/config')
        );
    } else {
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
if (platform === 'win32') {
        configFiles.push(
            path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'ssh', 'sshd_config'),
            path.join(HOME, '.ssh/authorized_keys'),
            path.join(HOME, '.ssh/config')
        );
    } else {
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
if (platform === 'win32') {
        configFiles.push(
            path.join(process.env.PROGRAMDATA || 'C:\\ProgramData', 'ssh', 'sshd_config'),
            path.join(HOME, '.ssh/authorized_keys'),
            path.join(HOME, '.ssh/config')
        );
    } else {
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
'/etc/ssh/sshd_config',
            path.join(HOME, '.ssh/authorized_keys'),
            path.join(HOME, '.ssh/config'),
            '/etc/passwd',
            '/etc/shadow'
        );
    }
Confidence
96% confidence
Finding
Including /etc/passwd in the baseline causes the script to read a system account database file outside the declared sensitive-information scope. While /etc/passwd is often world-readable, enumerating it still expands host reconnaissance and should be explicitly justified and disclosed.

Credential Access

High
Category
Privilege Escalation
Content
path.join(HOME, '.ssh/authorized_keys'),
            path.join(HOME, '.ssh/config'),
            '/etc/passwd',
            '/etc/shadow'
        );
    }
Confidence
99% confidence
Finding
The script attempts to hash /etc/shadow, a highly sensitive credential store, during baseline generation. Accessing this file is unnecessary for most agent security audits, requires elevated privileges, and materially increases the risk of credential exposure or abuse if the tool or its outputs are compromised.

Chaining Abuse

High
Category
Tool Misuse
Content
// Event ID 4672 = 特权提升
    let psOut = spawnCmd('powershell', ['-NoProfile', '-Command',
        `(Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4672; StartTime=(Get-Date).AddDays(-1)} -ErrorAction SilentlyContinue | Measure-Object).Count`
    ]);
    sudoCount = parseInt(psOut, 10) || 0;
}
Confidence
75% confidence
Finding
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Lp3

Medium
Category
MCP Least Privilege
Confidence
98% confidence
Finding
The skill requires shell and environment access to read system identifiers, logs, installed skills, and to write persistent files, but it does not declare any explicit tool scope or permission boundaries. This increases the risk of overbroad execution because hosts and reviewers cannot enforce least privilege or clearly understand what capabilities the skill needs before activation.

Natural-Language Policy Violations

Medium
Confidence
88% confidence
Finding
The file specifies user-facing descriptions, prompts, and reply formats entirely in Chinese, while also advertising English trigger coverage such as “security audit.” There is no indication that users may choose their preferred language, which can violate language/locale policy when applied to broader audiences.

Vague Triggers

Medium
Confidence
95% confidence
Finding
Broad trigger phrases like “巡检” and “系统安全” can cause the skill to activate on generic user requests unrelated to this specific tool. Because this skill reads sensitive local information and can optionally persist data or initiate setup flows, accidental activation expands privacy risk and may lead to surprising privileged behavior.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
必需:Node.js v18+
    可选:openclaw CLI(用于定时任务管理;若使用定时巡检功能,需依赖 openclaw cron 命令)
    脚本调用的系统命令(缺失时对应检查项会 SKIP,不影响其他项):
      macOS:find、lsof、netstat、ps、last、lastb、grep、awk、cat、sudo
      Linux:find、ss、lsof、ps、journalctl、last、lastb、grep、awk、cat、sudo
      Windows:wmic、netstat、tasklist、findstr
Confidence
84% confidence
Finding
Declaring use of sudo as part of supported system commands indicates the skill may invoke privileged context or inspect privileged data paths. Even if intended for read-only auditing, introducing sudo into an agent skill materially raises the blast radius if the command set expands, the host configuration is weak, or users are socially engineered into granting elevation.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
可选:openclaw CLI(用于定时任务管理;若使用定时巡检功能,需依赖 openclaw cron 命令)
    脚本调用的系统命令(缺失时对应检查项会 SKIP,不影响其他项):
      macOS:find、lsof、netstat、ps、last、lastb、grep、awk、cat、sudo
      Linux:find、ss、lsof、ps、journalctl、last、lastb、grep、awk、cat、sudo
      Windows:wmic、netstat、tasklist、findstr

security_notes: |
Confidence
84% confidence
Finding
The Linux command list also includes sudo, which signals potential privileged execution or privileged-state inspection. In an agent environment, any elevation-capable path is sensitive because mistakes, future feature creep, or wrapper abuse can turn a read-only audit tool into one that operates with higher-than-expected system authority.

Session Persistence

Medium
Category
Rogue Agent
Content
**关于定时任务的硬性要求**:
- 必须使用 `openclaw cron add` 命令
- 禁止使用系统 crontab(`crontab -e` 等)
- 原因:系统 crontab 无法正确初始化 OpenClaw 环境,会导致执行失败
- ⚠️ 基础设施绑定说明:使用 `openclaw cron` 会将定时执行与 openclaw 基础设施绑定;如不希望依赖此基础设施,可不设置定时任务,改为手动执行
- **cron 命令中严禁添加 `--push` 参数**:定时任务只以本地离线模式运行,绝不自动向远端上报设备标识
Confidence
90% confidence
Finding
The skill explicitly supports configuring recurring scheduled execution through openclaw cron, creating persistent behavior on the host. Even though it is presented as optional and local-only, persistence increases risk because sensitive scans and file writes will continue after the initial session and may be forgotten, misconfigured, or later combined with changed code or environment.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
✅ 安全。扫描了工作区的所有文件,没有发现明文写死的私钥或助记词。

### 13. 特权提权(Sudo)操作对账审计
✅ 安全。今天系统没有执行过 sudo 特权命令,Agent 的记忆记录也没有相关内容,两边对账一致,不存在偷偷提权的情况。

### 14. 生态组件恶意威胁情报扫描
✅ 安全。已列出本机安装的 54 个 Skill 组件,全部在安全名单中。(如果使用了完整检测模式且命中威胁情报,这里会显示具体的恶意组件和处置建议。)
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Session Persistence

Medium
Category
Rogue Agent
Content
### 必须使用 `openclaw cron`,禁止使用系统 crontab

❌ **错误做法**:使用 `crontab -e` 或编辑 `/etc/crontab`


✅ **正确做法**:使用 OpenClaw 内置的 cron 系统
Confidence
85% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Session Persistence

Medium
Category
Rogue Agent
Content
### 必须使用 `openclaw cron`,禁止使用系统 crontab

❌ **错误做法**:使用 `crontab -e` 或编辑 `/etc/crontab`


✅ **正确做法**:使用 OpenClaw 内置的 cron 系统
Confidence
85% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Session Persistence

Medium
Category
Rogue Agent
Content
## 常见错误及修复

### 错误 1:使用了系统 crontab
**现象**:任务显示在 `crontab -l` 中,但执行失败或没有推送
**修复**:
```bash
# 1. 删除系统 crontab 中的任务
Confidence
85% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Scope Creep

Medium
Confidence
96% confidence
Finding
The script hashes highly sensitive files including /etc/shadow, /etc/passwd, and SSH configuration material as part of baseline generation. Even if it does not print file contents, it still performs undeclared access to credential- and identity-related files, expanding the skill's privilege footprint beyond the manifest and creating unnecessary exposure if the script is run with elevated privileges.

Scope Creep

Medium
Confidence
94% confidence
Finding
The script recursively scans broad sensitive roots such as /etc, ~/.ssh, ~/.gnupg, /usr/local/bin, and the entire OpenClaw state tree for recent changes. This exceeds the manifest's declared scope and can enumerate security-sensitive metadata across the host, increasing privacy and reconnaissance risk if the skill is misused or compromised.

Scope Creep

Medium
Confidence
98% confidence
Finding
On Linux, the script reads /proc/<pid>/environ for another process to identify secret-like environment variable names. Accessing another process's environment is sensitive because it can reveal credential presence, deployment details, and sometimes actual secrets if protections fail or future code changes log more than intended.

Scope Creep

Medium
Confidence
96% confidence
Finding
The script recursively scans the workspace for secret-like patterns, including hex private-key material and mnemonic phrases. This is broader than the declared access scope and can inspect arbitrary user project files, creating significant privacy and data-handling risk even if the intention is defensive.

Static analysis

Detected: suspicious.dangerous_exec

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
scripts/openclaw-hybrid-audit-changeway.js:165