Back to skill

Security audit

agent-pack-n-go

Security checks for vulnerabilities and agentic risk

Overview

This skill does what it says, but it asks for very broad system and credential access that users should review carefully before installing.

Install only if both devices are fully trusted and you are comfortable cloning secrets. Before use, avoid NOPASSWD:ALL, review cron entries, exclude or regenerate SSH private keys where possible, encrypt the migration archive, delete it immediately after verification, and avoid skipped-permission automation.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
Findings (5)

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/setup.sh:149
Finding
Unverified Remote Installation Scripts Are Piped Directly to Bash<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.sh:149-163` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: High ### Vulnerable Code ```bash NVM_VERSION="v0.40.3" # Three-tier fallback: official → Gitee mirror → error _nvm_install_official() { curl -fsSL --connect-timeout 15 \ "https://raw.githubusercontent.com/nvm-sh/nvm/${NVM_VERSION}/install.sh" | bash } _nvm_install_gitee() { curl -fsSL --connect-timeout 15 \ "https://gitee.com/mirrors/nvm/raw/${NVM_VERSION}/install.sh" | bash } if run_with_spinner "Installing nvm (official)..." _nvm_install_official 2>/dev/null; then echo -e "[5/${TOTAL}] nvm installed (official source) ${GREEN}✅${NC}" elif run_with_spinner "Installing nvm (Gitee mirror)..." _nvm_install_gitee 2>/dev/null; then echo -e "[5/${TOTAL}] nvm installed (Gitee mirror) ${GREEN}✅${NC}" else fail "nvm installation failed, please check network connectivity." fi ``` ### Technical Analysis The setup process retrieves shell code from an external URL and immediately executes it using `bash`. Neither downloaded script is verified against an expected cryptographic digest or trusted signature before execution. Although `NVM_VERSION` is set to a specific tag, a tag or URL alone does not authenticate the returned content. The effective payload can change after the Skill has been audited if an upstream account, repository reference, mirror, DNS path, TLS trust chain, or hosting platform is compromised. The Gitee fallback creates an additional supply-chain trust boundary. A failure to contact the official source automatically causes code from the mirror to be executed without requiring separate user approval. ### Attack Path 1. An attacker compromises an upstream repository account, tag, mirror, hosting service, or relevant network trust path. 2. The attacker modifies the script returned for the configured NVM installation URL. 3. The user invokes the Skill on the mig ...[truncated 1002 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not pipe network responses directly into a shell. 2. Download the installer into a newly created private temporary directory: ```bash umask 077 tmp_dir="$(mktemp -d)" curl --proto '=https' --tlsv1.2 -fL \ -o "$tmp_dir/nvm-install.sh" \ "https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh" ``` 3. Verify the file against a hardcoded, reviewed SHA-256 digest or a valid upstream cryptographic signature obtained through an independent trust path. 4. Abort on any verification failure; do not silently fall back to another provider. 5. Execute the local file only after successful validation: ```bash printf '%s %s\n' "$EXPECTED_SHA256" "$tmp_dir/nvm-install.sh" | sha256sum -c - bash "$tmp_dir/nvm-install.sh" ``` 6. Remove the unauthenticated mirror fallback or require explicit user approval and an independently pinned digest for the mirror artifact. 7. Ensure unrestricted passwordless sudo has been removed before any externally obtained user-level installer is executed. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/pack.sh:13
Finding
Sensitive Credential and SSH-Key Archive Is Stored Without Enforced Protection<![CDATA[ ## Vulnerability Details **File Location**: `scripts/pack.sh:13, 31-32, 38-79, 166-174`; `scripts/deploy.sh:337-343` **Vulnerability Type**: Insecure handling of plaintext sensitive data **Risk Level**: High ### Vulnerable Code ```bash PACK_FILE=~/openclaw-migration-pack.tar.gz TMP_DIR=~/openclaw-migration-tmp rm -rf "$TMP_DIR" mkdir -p "$TMP_DIR"/{openclaw-config,claude-config,ssh-keys} OPENCLAW_DIR=~/.openclaw if [ -d "$OPENCLAW_DIR" ]; then PACKED_ITEMS=() for item in openclaw.json credentials skills extensions memory feishu \ workspace workspace-coder workspace-paper-tracker \ CLAUDE.md exec-approvals.json; do src="$OPENCLAW_DIR/$item" if [ -e "$src" ]; then cp -r "$src" "$TMP_DIR/openclaw-config/" PACKED_ITEMS+=("$item") fi done fi if [ -d ~/.claude ]; then cp -r ~/.claude/. "$TMP_DIR/claude-config/" fi if [ -d ~/.ssh ]; then cp -r ~/.ssh/. "$TMP_DIR/ssh-keys/" fi if command -v pv > /dev/null 2>&1; then tar cz -C "$TMP_DIR" . | pv -s "$(du -sb "$TMP_DIR" | cut -f1)" > "$PACK_FILE" else tar czf "$PACK_FILE" -C "$TMP_DIR" . fi ``` Automated deployment removes only the extracted temporary directory and explicitly retains the archive: ```bash rm -rf "$MIGRATION_TMP" echo -e " ${GREEN}✅${NC}" echo -e " ${YELLOW}ℹ️ setup.sh + deploy.sh kept for reference${NC}" echo -e " ${YELLOW}ℹ️ To free space after verification: rm ~/openclaw-migration-pack.tar.gz ~/openclaw-migration-pack.sha256${NC}" ``` ### Technical Analysis The migration archive contains high-value secrets, including: - OpenClaw API keys and channel credentials - Claude Code settings and OAuth credentials - Every file under `~/.ssh`, including private keys - Agent memory and workspace contents - Execution approval configuration - Scheduled tasks and other operational configuration The packing script does not set `umask 077`, does not explicitly apply mode `0600` ...[truncated 2097 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Enforce restrictive permissions before creating any staging data: ```bash umask 077 mkdir -m 700 "$TMP_DIR" ``` 2. Explicitly set the archive and checksum permissions: ```bash chmod 600 "$PACK_FILE" ~/openclaw-migration-pack.sha256 ``` 3. Encrypt the archive using authenticated encryption, such as `age`, with a destination public key or a separately supplied passphrase. 4. Never place the encryption secret in command history, the archive, generated instructions, or process arguments. 5. Make SSH-key migration disabled by default. Display discovered keys and require the user to select individual keys explicitly. 6. Prefer generating a new SSH key on the target and updating authorized services rather than copying old private keys. 7. Minimize Claude and OpenClaw data to the specific files necessary for migration. 8. Delete plaintext staging data through a guaranteed cleanup trap on success, interruption, and failure. 9. Delete the archive from both source and target immediately after verified restoration unless the user explicitly requests an encrypted backup. 10. Warn that secure deletion cannot be guaranteed on copy-on-write filesystems, SSDs, snapshots, or cloud-backed home directories; encryption should therefore be the primary control. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:98
Finding
Migration Workflow Grants Unrestricted Passwordless Root Access<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:98-111, 300-303` **Vulnerability Type**: Excessive privilege grant **Risk Level**: Critical ### Vulnerable Code ```bash ssh USER@NEW_IP 'echo "USERNAME ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/migration' ``` The associated cleanup is optional: ```bash # Security note: After clone is verified (Phase 4), user can remove this with: ssh USER@NEW_IP 'sudo rm /etc/sudoers.d/migration' ``` The final instructions also describe cleanup ambiguously as applying to the old device: ```text - (Optional) Remove sudoers on the old device: sudo rm /etc/sudoers.d/migration ``` ### Technical Analysis The sudoers entry grants the migration account permission to run every command as any user, including root, without authentication: ```text USERNAME ALL=(ALL) NOPASSWD:ALL ``` The deployment only requires a limited set of privileged operations, such as package management, narrowly scoped `/etc/hosts` updates, proxy configuration, and `loginctl`. Granting unrestricted passwordless sudo is materially broader than those requirements and violates least privilege. Cleanup is not enforced by the scripts and is deferred until after verification. The later wording can direct users to remove the entry on the wrong device, increasing the likelihood that the target remains permanently configured with passwordless root access. ### Attack Path 1. The user follows the mandatory migration preparation and creates `/etc/sudoers.d/migration` on the target. 2. The entry grants the migration user unrestricted passwordless sudo. 3. Deployment restores credentials, private SSH keys, dependencies, workspace content, and executable configuration to that account. 4. Cleanup is skipped, forgotten, fails, or is mistakenly performed on the old device. 5. An attacker compromises any process running as the migration user, abuses a restored script, exploits an installed dependency, or gains access through a stolen credential. 6. ...[truncated 832 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the recommendation to configure `NOPASSWD:ALL`. 2. Use interactive sudo for the small number of privileged steps, or ask the user to perform those operations directly. 3. If automation is essential, create a temporary sudoers rule restricted to exact commands and validated arguments. 4. Do not permit general shells, interpreters, package-manager arbitrary arguments, `tee`, `cp`, or other commands that can trivially escape an allowlist. 5. Validate temporary sudoers files before installation: ```bash sudo visudo -cf /path/to/generated-rule ``` 6. Install and remove the temporary rule inside a tightly controlled setup wrapper with an `EXIT`, `INT`, and `TERM` cleanup trap. 7. Verify at completion that `/etc/sudoers.d/migration` no longer exists on the target. 8. Treat cleanup failure as a fatal deployment failure and provide a target-specific remediation command. 9. Update all documentation to state unambiguously that any temporary rule is created and removed on the new device. ]]>

T06 · System Persistence

Warning
Location
scripts/deploy.sh:181
Finding
Source Crontab Is Automatically Activated on the Target Without Review<![CDATA[ ## Vulnerability Details **File Location**: `scripts/pack.sh:89-98`; `scripts/deploy.sh:181-194`; `scripts/generate-instructions.sh:126-134` **Vulnerability Type**: Unvalidated scheduled-task persistence **Risk Level**: Medium ### Vulnerable Code The source account's complete crontab is exported: ```bash echo -n "[${step}/${TOTAL}] Exporting crontab..." if crontab -l > "$TMP_DIR/crontab-backup.txt" 2>/dev/null; then CRON_COUNT=$(grep -v "^#" "$TMP_DIR/crontab-backup.txt" 2>/dev/null | grep -c "[^[:space:]]" || echo 0) echo -e " ${GREEN}✅${NC} (${CRON_COUNT} 条任务)" else echo "# no crontab" > "$TMP_DIR/crontab-backup.txt" echo -e " ${YELLOW}⚠️ crontab is empty, created empty file${NC}" fi ``` The complete file is then installed automatically on the target: ```bash echo -n "[${step}/${TOTAL}] Restoring crontab..." if [ -f "$MIGRATION_TMP/crontab-backup.txt" ] && grep -qv '^#' "$MIGRATION_TMP/crontab-backup.txt" 2>/dev/null; then crontab "$MIGRATION_TMP/crontab-backup.txt" && { CRON_COUNT=$(crontab -l 2>/dev/null | grep -cv '^#' || echo 0) echo -e " ${GREEN}✅${NC} (${CRON_COUNT} 条任务)" } || { echo -e " ${RED}❌ crontab restore failed${NC}" FAILED_STEPS+=("Step ${step}: restore crontab") } else echo -e " ${YELLOW}⚠️ crontab backup empty, skipping${NC}" fi ``` ### Technical Analysis Cron migration is related to the declared full-device-clone functionality, but the implementation restores every source entry without presenting its contents for approval, limiting migration to OpenClaw-related tasks, validating referenced commands, or initially disabling the entries. A source crontab can contain stale, destructive, compromised, host-specific, or malicious commands. Automatic activation converts all such entries into cross-session persistence on the new device. Simple username path replacement does not establish that a command is safe or appropriate for the target environme ...[truncated 1154 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Do not install the complete crontab automatically. 2. Parse and display each non-comment entry before migration. 3. Require explicit user approval for every scheduled task. 4. Default to migrating only clearly identified OpenClaw-related jobs. 5. Restore approved jobs into a review file rather than activating them immediately. 6. Validate referenced executable paths, scripts, environment variables, redirections, and remote URLs. 7. Reject or prominently warn about entries that invoke shells, network downloaders, interpreters, encoded commands, writable scripts, or privileged operations. 8. Provide a diff between the current target crontab and the proposed replacement. 9. Preserve existing target jobs by merging approved entries instead of replacing the complete target crontab. 10. Verify the final crontab after installation and provide a rollback copy. ]]>

T08 · Insecure Dependencies

Warning
Location
scripts/setup.sh:220
Finding
Unpinned Global Packages and Migrated Python Requirements Are Executed<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.sh:220-235`; `scripts/deploy.sh:106-115, 303-308`; `scripts/generate-instructions.sh:43-47, 217-223` **Vulnerability Type**: Insecure third-party dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash if command -v claude > /dev/null 2>&1; then echo -e " ${GREEN}✅ Already installed ($(claude --version 2>/dev/null || echo 'unknown'))${NC}" else if run_with_spinner "Installing Claude Code..." \ timeout 120 npm install -g @anthropic-ai/claude-code; then ok else echo -e " ${YELLOW}⚠️ Install timeout, trying npmmirror...${NC}" npm config set registry https://registry.npmmirror.com if run_with_spinner "Installing Claude Code (npmmirror)..." \ timeout 120 npm install -g @anthropic-ai/claude-code; then echo -e "[8/${TOTAL}] Claude Code installed (npmmirror) ${GREEN}✅${NC}" else fail "Claude Code installation failed, please check network" fi fi fi ``` ```bash npm install -g openclaw mcporter > /tmp/npm-install.log 2>&1 && { OC_VER=$(openclaw --version 2>/dev/null || echo "unknown") echo -e " ${GREEN}✅${NC} (openclaw ${OC_VER})" } || { echo -e " ${RED}❌ npm install failed (see /tmp/npm-install.log)${NC}" FAILED_STEPS+=("Step ${step}: npm install openclaw mcporter") } ``` ```bash if [ -f ~/openclaw-dashboard/backend/requirements.txt ]; then timeout 120 pip3 install \ -r ~/openclaw-dashboard/backend/requirements.txt \ > /tmp/pip-dashboard.log 2>&1 || true fi ``` ### Technical Analysis The Skill installs global npm packages without exact versions or lockfile integrity metadata. This causes migration behavior to depend on whatever package versions and dependency graphs are current at execution time rather than the versions reviewed with the Skill. On network failure, the script changes the persistent npm registry to a mirror and retries in ...[truncated 1557 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every npm package to an exact reviewed version: ```bash npm install -g openclaw@X.Y.Z mcporter@A.B.C npm install -g @anthropic-ai/claude-code@X.Y.Z ``` 2. Use lockfiles and verified integrity metadata where supported. 3. Record the versions used on the source and install those same versions on the target. 4. Use only explicitly trusted registries and avoid automatically switching to a mirror. 5. If a mirror is necessary, require user approval and verify downloaded package integrity against independently obtained official metadata. 6. Restore the original npm registry after any temporary change. 7. Disable package lifecycle scripts when they are not required: ```bash npm install --ignore-scripts ... ``` 8. Review packages that genuinely require lifecycle scripts before enabling them. 9. Require a fully pinned Python lockfile with hashes and install using: ```bash pip install --require-hashes -r requirements.lock ``` 10. Do not execute a requirements file merely because it was present in the migrated dashboard. Verify its checksum against a trusted manifest and obtain explicit approval first. 11. Perform dependency installation before restoring credentials and private keys where operationally possible, reducing the secrets available to installer code. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (151)

Ssd 3

High
Confidence
96% confidence
Finding
The quick-start instructions encourage users to hand over SSH credentials and allow the agent to automate the full transfer process. That normalizes high-trust behavior around secret handling and remote control, making accidental overexposure or misuse more likely in a real deployment context.

Missing User Warnings

High
Confidence
95% confidence
Finding
The README normalizes the agent asking for SSH credentials and handling everything automatically, but does not prominently warn that the operation can transfer highly sensitive data and modify another system. Users may authorize the workflow without understanding that credentials, memory, and keys may be copied and deployed remotely.

Ssd 3

High
Confidence
99% confidence
Finding
The README frames transfer of highly sensitive local data—including credentials, OAuth material, SSH keys, and system configuration—as normal operation. Duplicating such secrets to another device substantially increases the blast radius of compromise and can directly enable lateral movement or account takeover if the destination is less trusted or later breached.

Missing User Warnings

High
Confidence
98% confidence
Finding
The list of cloned items explicitly includes credential stores and SSH keys, yet the README provides no strong warning about the consequences of duplicating private keys, OAuth tokens, and agent memory onto another host. This can lead to credential compromise, unauthorized access propagation, and long-lived secret sprawl.

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding
The declared description promises an end-to-end automated clone workflow: collect all agent data on the old device, securely transfer it with SCP, then remotely deploy and restore it on the new device via SSH. The supplied code does none of that directly. It only writes a migration-instructions.md document containing step-by-step manual commands for a user or another agent to run locally. Its primary purpose is instruction generation, not migration execution. It also includes system-level restoration actions and package/service configuration steps that are not mentioned in the declared purpose. While these may support migration, the lack of actual packaging, transfer, and auto-deployment makes the description materially inaccurate for this code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description promises a device migration/agent cloning capability, including collecting sensitive agent assets and transferring/restoring them on a new machine. The actual code does not implement any migration behavior. Its sole function is to test outbound network connectivity to several services and classify the environment as DIRECT, PROXY_NEEDED, or NO_INTERNET. While such a check could be a supporting helper for a migration workflow, the supplied chunk by itself has a materially different primary purpose and lacks the core behaviors described. Therefore this code chunk does not accurately match the declared skill description.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
The description promises an end-to-end migration/cloning workflow spanning old-device packaging, secure transfer, and automatic deployment on the new device. The actual code only handles part of the destination-side preparation and partial restore from an already-present local archive (~/openclaw-migration-pack.tar.gz). It sets up runtime dependencies and restores Claude config and SSH keys, but does not perform scp, SSH orchestration, source-device cloning, full agent restoration, or automatic deployment. This is a material purpose mismatch rather than a minor implementation detail difference.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
There is a material mismatch between the declared purpose and the supplied code chunk. The description presents the skill as an operational agent migration utility with sensitive capabilities such as handling credentials, transferring data to another device, and remote deployment. The actual code only echoes a post-install informational message. While the message itself is consistent with the declared post-install text, the code shown does not implement the primary declared functionality at all.

Chaining Abuse

High
Category
Tool Misuse
Content
Ask user to run:

```bash
ssh USER@NEW_IP 'echo "USERNAME ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/migration'
```

(Replace `USERNAME` with the actual SSH user. This will prompt for password one last time.)
Confidence
90% confidence
Finding
The pipeline writes attacker-significant content directly into a privileged sudoers path through sudo tee, combining shell chaining with privilege elevation. Even though the template shows a fixed string, this pattern is dangerous in agent workflows because small substitutions or user-controlled values can turn it into arbitrary privileged file modification.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
(Replace `USERNAME` with the actual SSH user. This will prompt for password one last time.)

> **Security note:** After clone is verified (Phase 4), user can remove this with:
> `ssh USER@NEW_IP 'sudo rm /etc/sudoers.d/migration'`

---
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
>
> 🧹 **后续清理(3-7 天后):**
> - 新设备上删除临时文件:`rm ~/openclaw-migration-pack.tar.gz ~/setup.sh ~/deploy.sh ~/migration-instructions.md`
> - (可选)旧设备移除 sudoers:`sudo rm /etc/sudoers.d/migration`
> - (可选)旧设备关闭服务:`systemctl --user disable openclaw-gateway`
>
> 🦁 **Enjoy your new home!**
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Agent Config Directory Access

High
Category
Agent Snooping
Content
#    User replies via Discord/Feishu

# 3. Agent writes config
# ~/.claude/settings.json

# 4. Agent tests
claude "hello test"
Confidence
95% confidence
Finding
The document instructs the agent to write `~/.claude/settings.json`, which is a sensitive agent configuration file likely containing API endpoints and credentials. In a migration skill that already moves secrets and later runs Claude Code with reduced safeguards, automated write access to this directory materially increases the risk of credential tampering, persistence, or redirection to attacker-controlled services.

Missing User Warnings

High
Confidence
99% confidence
Finding
The guide explicitly instructs the user to run Claude Code with `--dangerously-skip-permissions`, which disables execution safeguards before processing a migration instruction file that performs package installation, system modification, credential restoration, and service management. In this skill’s context, that creates a direct path for unreviewed code or prompt-driven actions to access secrets and execute privileged operations on the new host.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
# Clean up sensitive files after migration
rm -rf ~/migration-tmp/
rm ~/openclaw-migration-pack.tar.gz
rm ~/setup.sh
# migration-instructions.md can be kept for reference
Confidence
90% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Tool Parameter Abuse

High
Category
Tool Misuse
Content
# Clean up sensitive files after migration
rm -rf ~/migration-tmp/
rm ~/openclaw-migration-pack.tar.gz
rm ~/setup.sh
# migration-instructions.md can be kept for reference
```
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Credential Access

High
Category
Privilege Escalation
Content
| Claude Code fails to start | npm install overwrote the nvm wrapper | Rebuild the bash wrapper script |
| Discord images fail to load | CDN DNS resolution failure | Add Discord CDN static entries to /etc/hosts |
| workspace path errors | Different username on old/new device | Use sed to bulk-replace paths in openclaw.json |
| git push fails | SSH key permissions wrong | `chmod 600 ~/.ssh/id_ed25519` |
| Service dies after SSH logout | systemd user session terminated | `sudo loginctl enable-linger $USER` |
| OpenClaw port already in use | Old process not cleaned up | Kill old process or change port in openclaw.json |
| Discord Bot offline | Same token running on two devices | Ensure old device is stopped before starting new one |
Confidence
97% confidence
Finding
The guide explicitly migrates `~/.ssh/` including `id_ed25519`, meaning the skill packages and restores private SSH keys onto another device. This is highly sensitive credential material; in the context of automated transfer, remote deployment, and reduced permission checks, compromise of either endpoint or workflow exposes reusable authentication secrets.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Agent Config Directory Access

High
Category
Agent Snooping
Content
**Solution**:
```bash
# Use a third-party API proxy, modify ~/.claude/settings.json
# Change apiBaseUrl to your proxy address
{
  "apiBaseUrl": "https://your-api-proxy.example.com",
Confidence
90% confidence
Finding
Skill reads from agent configuration directories (.claude/, .codex/, .gemini/). These directories may contain API keys, personal settings, and other credentials that the skill has no legitimate need to access.

Credential Access

High
Category
Privilege Escalation
Content
**Solution**:
```bash
# Fix private key permissions
chmod 600 ~/.ssh/id_ed25519
chmod 600 ~/.ssh/id_rsa  # if rsa key exists
chmod 700 ~/.ssh
chmod 600 ~/.ssh/config
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
```bash
# Fix private key permissions
chmod 600 ~/.ssh/id_ed25519
chmod 600 ~/.ssh/id_rsa  # if rsa key exists
chmod 700 ~/.ssh
chmod 600 ~/.ssh/config
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Static analysis

No suspicious patterns detected.