Back to skill

Security audit

ClawSync

Security checks for vulnerabilities and agentic risk

Overview

This skill needs review because it can automatically sync much more sensitive OpenClaw data than promised and has serious cloud authentication and installer risks.

Do not install or use this version without careful review and fixes. Avoid running provider setup on machines without preinstalled rclone, do not rely on BYOS storage being encrypted, and do not use the hosted cloud/dashboard flow until authentication and key-registration are corrected. Existing users should audit remote storage for unintended OpenClaw files and rotate any exposed credentials or vault keys.

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
  • 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
Findings (9)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
cloud-api-worker/src/index.ts:260
Finding

Unauthenticated Public-Key Registration Enables Existing Vault Takeover

Content
View full analysis
{ const body = await c.req.json<{ email: string; public_key: string; hostname?: string; os?: string; instance_id?: string }>(); if (!body.email) return c.json({ error: "email required" }, 400); const db = c.env.DB; const existing = await db.prepare("SELECT id FROM vaults WHERE email = ?").bind(body.email).first<{ id: string }>(); if (existing) { if (body.public_key) { const fp = await computeFingerprintAsync(body.public_key); const dup = await db.prepare("SELECT id FROM vault_keys WHERE vault_id = ? AND fingerprint = ? AND revoked_at IS NULL").bind(existing.id, fp).first(); if (!dup) await db.prepare("INSERT INTO vault_keys (id, vault_id, public_key, fingerprint, hostname, instance_id) VALUES (?, ?, ?, ?, ?, ?)").bind(crypto.randomUUID(), existing.id, body.public_key, fp, body.hostname || "", body.instance_id || "").run(); } return c.json({ vault_id: existing.id, status: "existing" }); } ``` ### Technical Analysis The public signup endpoint identifies an existing vault using only an email address. When a matching vault exists, it registers the submitted public key without verifying control of the email account or requiring a signature from an already authorized key. The endpoint also returns the existing vault ID. Consequently, the same unauthenticated request both discovers the target identifier and grants an attacker-controlled key access to it. This bypasses the otherwise meaningful Ed25519 signature checks on protected vault routes. ### Attack Path 1. An attacker obtains or guesses a victim's email address. 2. The attacker generates an Ed25519 key pair. 3. The attacker submits the victim's email and the attacker's public key to `POST /v1/signup`. 4. The endp ...[truncated 671 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
cloud-api-worker/src/index.ts:247
Finding

Dashboard Login Treats Email and Vault ID as Authentication Secrets

Content
View full analysis
{ const { email, vault_id } = await c.req.json<{ email: string; vault_id: string }>(); if (!email || !vault_id) return c.json({ error: "email and vault_id required" }, 400); const vault = await c.env.DB.prepare("SELECT id, email FROM vaults WHERE id = ? AND email = ?").bind(vault_id, email).first<{ id: string; email: string }>(); if (!vault) return c.json({ error: "Invalid credentials" }, 401); const now = Math.floor(Date.now() / 1000); const token = await signJWT({ vault_id, email, iat: now, exp: now + 86400 }, c.env.JWT_SECRET); return c.json({ token, vault_id, email, expires_in: 86400 }); }); ``` ### Technical Analysis The dashboard endpoint issues a 24-hour JWT after checking only that the supplied email and vault ID correspond to a database record. Neither value proves user identity: email addresses are commonly known, while vault IDs are identifiers returned by signup and stored in client configuration. No password, verified email challenge, WebAuthn assertion, OAuth identity, or registered-key signature is required. Once issued, the JWT is accepted as an alternative to Ed25519 authentication for vault operations. ### Attack Path 1. An attacker obtains the victim's email and vault ID from configuration, browser storage, logs, disclosure, or the vulnerable signup behavior. 2. The attacker submits both values to `POST /v1/dashboard/auth`. 3. The API returns a valid 24-hour JWT. 4. The attacker sends the token through the `Authorization: Bearer` header. 5. The attacker lists profiles and files, reads file contents, and copies files between profiles. ### Impact Assessment The vulnerability grants remote dashboard-level access to the entire target vault. Accessible data can include ...[truncated 169 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Error
Location
src/sync-engine.sh:151
Finding

Synchronization Silently Uploads the Entire OpenClaw Directory

Content
View full analysis
/dev/null | head -1 | awk '{print $2}' | tr -d '"') if [[ -z "$openclaw_dir" || ! -d "$openclaw_dir" ]]; then return 0 fi # Mirror entire openclaw directory into vault (excluding .git and runtime files) mkdir -p "$VAULT_DIR/openclaw" rsync -a --delete \ --exclude '.git/' \ --exclude 'node_modules/' \ --exclude '*.swp' \ --exclude '*.swo' \ "$openclaw_dir/" "$VAULT_DIR/openclaw/" 2>/dev/null || true } ``` ### Technical Analysis The Skill documentation states that selected identity and knowledge files are synchronized, that configuration and credentials are opt-in, and that `SOUL.md` and `IDENTITY.md` must not be automatically synchronized. The implementation instead mirrors the entire detected OpenClaw directory into the vault. The exclusion list only removes Git metadata, dependencies, and editor swap files. It does not exclude credentials, channel tokens, model configuration, conversation state, local identity files, runtime databases, or other sensitive OpenClaw content. Subsequent provider operations upload the resulting `openclaw/` directory. This exceeds the minimum file access required for the declared synchronization feature and contradicts the explicit consent boundaries in `SKILL.md`. ### Attack Path 1. The user initializes ClawSync and configures a storage provider. 2. A push or background synchronization invokes `sync_from_openclaw`. 3. The entire OpenClaw directory is copied under `~/.clawsync/openclaw`. 4. Provider code uploads that directory unless it happens to be excluded by provider-specific behavior. 5. Sensitive data becomes available in remote storage without the promised opt-in. ### Impact A ...[truncated 322 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
providers/s3.sh:61
Finding

Bring-Your-Own-Storage Providers Upload Vault Contents Without Client-Side Encryption

Content
View full analysis
&1 | grep -E "Transferred|Elapsed" || true log "Push to S3 complete (profile: $profile_name)" } ``` Equivalent direct file synchronization is used by the Dropbox, Google Drive, WebDAV, FTP/SFTP, Git, and local providers. ### Technical Analysis The S3 provider directly synchronizes individual vault files. It does not create an encrypted archive or use an rclone crypt remote. Ed25519 keys used elsewhere provide authentication and signatures, not confidentiality. Only the managed cloud provider applies AES encryption before upload. Therefore, the general documentation claim that synchronization is encrypted does not accurately describe BYOS providers. This is especially dangerous because the synchronization engine collects the entire OpenClaw directory. ### Attack Path 1. The user selects S3 or another BYOS provider. 2. The synchronization engine collects vault and OpenClaw files. 3. The provider directly uploads the files through `rclone`, `rsync`, or Git. 4. A provider operator, repository collaborator, compromised storage account, or misconfigured bucket reads the plaintext data. ### Impact Assessment Remote storage can expose identity, memory, project information, manifests, configuration, and unexpectedly collected OpenClaw files. In Git, sensitive content may also persist indefinitely in commit history after deletion. ]]>
Remediation
View remediation

T03 · Remote Payload Retrieval and Execution

Error
Location
providers/s3.sh:8
Finding

Provider Setup Downloads and Executes Mutable Remote Installer Scripts

Content
View full analysis
/dev/null; then log "rclone not found. Installing..." case "$(uname -s)" in Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;; Linux) curl https://rclone.org/install.sh | sudo bash ;; esac fi } ``` The same installation pattern also appears in: - `providers/dropbox.sh:12-13` - `providers/gdrive.sh:30-31` - `providers/webdav.sh:11` ### Technical Analysis The effective installer payload is retrieved at runtime and immediately piped to a shell. It is not version-pinned, downloaded for inspection, or verified using an embedded checksum or trusted signature. The Linux path executes the remote script through `sudo bash`, granting it root privileges. Even if the current upstream host is legitimate, the reviewed Skill package does not determine the code that will execute later. A compromise of DNS, TLS infrastructure, the upstream website, CDN, or installer publication process would become local arbitrary code execution. ### Attack Path 1. A user configures an rclone-backed provider on a machine without rclone. 2. `ensure_rclone` downloads the current contents of `https://rclone.org/install.sh`. 3. The response is streamed directly into Bash. 4. On Linux, Bash runs under `sudo`. 5. A compromised or substituted response executes arbitrary commands with root privileges. ### Impact Assessment The remote payload can obtain complete host control, install persistence, read all user data and credentials, modify system binaries, or compromise other applications. On Linux, the impact is system-wide root code execution. ]]>
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
track-packages.sh:260
Finding

Remote Package Manifest Can Inject Shell Commands Through Eval

Content
View full analysis
/dev/null | grep '^\s*- name:' | awk -F'"' '{print $2}') for pkg in $mgr_pkgs; do if echo "$missing" | grep -qx "$pkg"; then mgr_missing="$mgr_missing $pkg" fi done if [[ -n "$mgr_missing" ]]; then local cmd="" case "$mgr" in brew) cmd="brew install$mgr_missing" ;; apt) cmd="sudo apt install -y$mgr_missing" ;; npm_global) cmd="npm install -g$mgr_missing" ;; pip_global) cmd="pip3 install$mgr_missing" ;; snap) cmd="sudo snap install$mgr_missing" ;; flatpak) cmd="flatpak install$mgr_missing" ;; esac if [[ -n "$cmd" ]]; then echo "Install command ($mgr):" echo " $cmd" echo "" read -rp "Run this command? [y/N]: " yn if [[ "$yn" =~ ^[Yy] ]]; then eval "$cmd" || log "Some packages failed to install" fi fi fi done ``` ### Technical Analysis Package names are extracted from a synchronized requirements file, concatenated into a command string, and executed with `eval`. No package-manager-specific validation or shell-safe argument construction is performed. A malicious package value containing shell metacharacters can alter command parsing. User confirmation does not remove the vulnerability; it merely asks the user to approve a string that may contain disguised or overlooked shell syntax. Commands for APT and Snap may invoke `sudo`, increasing the potential impact. ### Attack Path 1. An attacker modifies `requirements.yaml` in a remote provider or compromised vault. 2. A package name is crafted to contain shell ...[truncated 549 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
providers/ftp.sh:17
Finding

SFTP Provider Disables Host Verification and Interpolates Unvalidated Remote Paths

Content
View full analysis
/dev/null echo "────────────────────────────────" cat > "$PROVIDER_CONFIG" </dev/null || true log "Pushing via $proto to $host (profile: $profile_name)..." rsync -avz -e "ssh -i $key -p $port -o StrictHostKeyChecking=no" \ $EXCLUDE "$VAULT_DIR/" "$user@$host:$target_path/" 2>&1 | tail -3 ``` ### Technical Analysis `StrictHostKeyChecking=no` removes normal SSH server identity verification. A network attacker able to intercept the connection can present an untrusted host key and receive the synchronized data. The remote path is also inserted into a remote shell command inside single quotes. Because the input is not validated, a path containing a single quote and shell syntax can escape the intended quoting and execute commands on the remote host. Host, ...[truncated 1158 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
providers/cloud.sh:235
Finding

Cloud Restore Extracts Archives Without Validating Entry Paths

Content
View full analysis
/dev/null || { log "Cloud API not available or vault not found." return 1 } if [[ -f "$archive" && -s "$archive" ]]; then # Decrypt the archive local decrypted="${archive}.dec" openssl enc -d -aes-256-cbc -pbkdf2 \ -in "$archive" -out "$decrypted" \ -pass "file:$KEY_DIR/clawsync_ed25519" 2>/dev/null if [[ -f "$decrypted" && -s "$decrypted" ]]; then mv "$decrypted" "$archive" fi # (if decryption fails, archive might be unencrypted — legacy compat) # Extract to staging, then merge (don't overwrite local/) local pull_dir="$VAULT_DIR/.pull-staging" mkdir -p "$pull_dir" tar -xzf "$archive" -C "$pull_dir" 2>/dev/null # Restore entire openclaw directory if present if [[ -d "$pull_dir/openclaw" ]]; then local openclaw_dir openclaw_dir=$(grep 'openclaw_dir:' "$CONFIG" 2>/dev/null | head -1 | awk '{print $2}' | tr -d '"') if [[ -n "$openclaw_dir" ]]; then mkdir -p "$openclaw_dir" rsync -a --exclude '.git/' --exclude 'node_modules/' "$pull_dir/openclaw/" "$openclaw_dir/" 2>/dev/null || true fi fi ``` ### Technical Analysis The archive is passed directly to `tar` without first validating member names or types. Depending on the installed tar implementation and options, entries containing absolute paths, parent traversal components, links, or other special types may escape the intended staging directory or redirect later writes. The legacy compatibility behavior increases exposure: if decryption fails, the original response remains in place and is treated as a potentially unencrypted archive. Therefore, an authorized attacker can upload a ...[truncated 1031 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
web/dashboard.html:463
Finding

Dashboard Stores Vault Bearer Tokens in Persistent Local Storage

Content
View full analysis
Remediation
View remediation
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • 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 (120)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

If the actual implementation primarily performs package inventory/diff/install rather than vault sync, the manifest is misleading about both function and risk. Package installation is a privileged operation that can materially alter the host, so mislabeling it as a vault feature reduces user scrutiny around a more dangerous capability.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

If the actual implementation primarily performs package inventory/diff/install rather than vault sync, the manifest is misleading about both function and risk. Package installation is a privileged operation that can materially alter the host, so mislabeling it as a vault feature reduces user scrutiny around a more dangerous capability.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

If the actual implementation primarily performs package inventory/diff/install rather than vault sync, the manifest is misleading about both function and risk. Package installation is a privileged operation that can materially alter the host, so mislabeling it as a vault feature reduces user scrutiny around a more dangerous capability.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
90% confidence
Finding

If the actual implementation primarily performs package inventory/diff/install rather than vault sync, the manifest is misleading about both function and risk. Package installation is a privileged operation that can materially alter the host, so mislabeling it as a vault feature reduces user scrutiny around a more dangerous capability.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding

If the actual implementation primarily performs package inventory/diff/install rather than vault sync, the manifest is misleading about both function and risk. Package installation is a privileged operation that can materially alter the host, so mislabeling it as a vault feature reduces user scrutiny around a more dangerous capability.

Content

No source excerpt is available for this finding.

Known Vulnerable Dependency: hono==4.12.2 — 16 advisory(ies): CVE-2026-56762 (Hono missing validation of cookie name on write path in setCookie()); CVE-2026-47676 (Hono: app.mount() strips mount prefix using undecoded path, causing incorrect ro); CVE-2026-47675 (Hono: Cookie helper does not sanitize sameSite and priority, allowing Set-Cookie) +13 more

High
Category
Supply Chain
Confidence
95% confidence
Finding

The project directly depends on hono 4.12.2, and the listed advisories include cookie handling and routing issues that can affect request processing and security header generation in a web-facing API. Because this skill is a cloud sync/identity vault component handling remote API traffic, flaws in cookie validation, mount prefix stripping, or header generation are more dangerous than in a non-networked tool and could enable session manipulation, routing bypass, or other web security failures.

Content

No source excerpt is available for this finding.

Known Vulnerable Dependency: sharp==0.34.5 — 2 advisory(ies): GHSA-f88m-g3jw-g9cj (sharp inherited vulnerabilities in libvips: CVE-2026-33327, CVE-2026-33328, CVE-); GHSA-rgj7-g3m4-5g8c (sharp: Vulnerabilities in libheif: GHSA-g89c-p67h-r497 and GHSA-2jg2-4ch7-h545)

High
Category
Supply Chain
Confidence
87% confidence
Finding

sharp 0.34.5 is present transitively through miniflare and carries inherited image parsing risks from libvips/libheif. This is a real dependency vulnerability, but because it is only in development tooling here, the practical exposure is mainly during local development or test workflows that process attacker-controlled image content rather than in the deployed worker itself.

Content

No source excerpt is available for this finding.

Known Vulnerable Dependency: undici==7.18.2 — 16 advisory(ies): CVE-2026-1525 (Undici has an HTTP Request/Response Smuggling issue); CVE-2026-6733 (undici vulnerable to HTTP response queue poisoning via keep-alive socket reuse); CVE-2026-1527 (Undici has CRLF Injection in undici via `upgrade` option) +13 more

High
Category
Supply Chain
Confidence
90% confidence
Finding

undici 7.18.2 is included via miniflare and has reported request smuggling, queue poisoning, and CRLF-related issues. The dependency is real, but here it is part of developer tooling rather than the deployed application runtime, which reduces direct production exposure while still leaving local dev servers, previews, or CI integrations at risk if they handle untrusted traffic.

Content

No source excerpt is available for this finding.

Known Vulnerable Dependency: ws==8.18.0 — 2 advisory(ies): CVE-2026-45736 (ws: Uninitialized memory disclosure); CVE-2026-48779 (ws: Memory exhaustion DoS from tiny fragments and data chunks)

High
Category
Supply Chain
Confidence
90% confidence
Finding

ws 8.18.0 is a real vulnerable dependency with advisories for memory disclosure and memory exhaustion DoS. In this lockfile it is transitively included through miniflare development tooling, so the main risk is to local preview/debug services or CI environments that expose WebSocket functionality, not the production worker bundle itself.

Content

No source excerpt is available for this finding.

Known Vulnerable Dependency: hono==4.12.2 — 16 advisory(ies): CVE-2026-56762 (Hono missing validation of cookie name on write path in setCookie()); CVE-2026-47676 (Hono: app.mount() strips mount prefix using undecoded path, causing incorrect ro); CVE-2026-47675 (Hono: Cookie helper does not sanitize sameSite and priority, allowing Set-Cookie) +13 more

High
Category
Supply Chain
Confidence
97% confidence
Finding

The package manifest permits installation of hono 4.12.2, and the finding indicates that version has multiple known advisories, including cookie-handling and routing issues. In a cloud sync API worker that likely handles authentication, sessions, routing, and sensitive vault traffic, vulnerable framework behavior could enable request confusion, header/cookie injection, or auth/session weaknesses with serious downstream impact.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
99% confidence
Finding

The dashboard auth endpoint issues a bearer token solely from knowledge of an email address and vault ID, with no password, possession proof, email verification, challenge-response, or other identity check. Anyone who can guess or obtain those two values can mint a valid JWT and then access vault data and perform privileged actions as the vault owner.

Content

No source excerpt is available for this finding.

Known Vulnerable Dependency: @hono/node-server==1.19.9 — 3 advisory(ies): CVE-2026-39406 (@hono/node-server: Middleware bypass via repeated slashes in serveStatic); GHSA-frvp-7c67-39w9 (Node.js Adapter for Hono: Path traversal in `serve-static` on Windows via encode); CVE-2026-29087 (@hono/node-server has authorization bypass for protected static paths via encode)

High
Category
Supply Chain
Confidence
97% confidence
Finding

The lockfile pins @hono/node-server to 1.19.9, and the cited advisories describe path traversal and authorization/middleware bypass issues in static file serving. In a cloud sync API handling vault and backup data, any static-path bypass or traversal bug is especially dangerous because it could expose protected files or bypass access controls if serveStatic is used anywhere in the service.

Content

No source excerpt is available for this finding.

External Script Fetching

High
Category
Supply Chain
Confidence
98% confidence
Finding

Fetching a script from the internet and executing it with bash is a classic arbitrary code execution pattern with no integrity verification. Even on Darwin where sudo is not used in this branch, the script still executes attacker-controlled content in the user's shell if the source is compromised.

Content

Scanner excerpt · providers/dropbox.sh (reported line 12)May include surrounding context.

sh
if ! command -v rclone &>/dev/null; then
    log "rclone not found. Installing..."
    case "$(uname -s)" in
      Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;;
      Linux)  curl https://rclone.org/install.sh | sudo bash ;;
    esac
  fi

External Script Fetching

High
Category
Supply Chain
Confidence
99% confidence
Finding

This line combines remote script fetching with privileged execution, turning a supply-chain or MITM event into full root compromise. In the context of a portability/sync skill, this behavior is unrelated to core sync functionality and therefore more dangerous because it is unexpected and easy to overlook.

Content

Scanner excerpt · providers/dropbox.sh (reported line 13)May include surrounding context.

sh
log "rclone not found. Installing..."
    case "$(uname -s)" in
      Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;;
      Linux)  curl https://rclone.org/install.sh | sudo bash ;;
    esac
  fi
}

Chaining Abuse

High
Category
Tool Misuse
Confidence
97% confidence
Finding

The command chain uses a pipe to send untrusted network content directly into a privileged shell, collapsing fetch, trust, and execution into a single step. This amplifies abuse potential because there is no inspection point, no integrity validation, and compromise results in root-level code execution immediately.

Content

Scanner excerpt · providers/dropbox.sh (reported line 13)May include surrounding context.

sh
log "rclone not found. Installing..."
    case "$(uname -s)" in
      Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;;
      Linux)  curl https://rclone.org/install.sh | sudo bash ;;
    esac
  fi
}

Missing User Warnings

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

Disabling host key verification without any warning or confirmation removes the primary protection against SSH endpoint spoofing during outbound sync. In the context of a portable identity vault, this can expose highly sensitive knowledge, memory, and package metadata to interception or tampering, making the risk more severe than in a low-sensitivity file transfer tool.

Content

No source excerpt is available for this finding.

External Script Fetching

High
Category
Supply Chain
Confidence
99% confidence
Finding

Piping curl output directly into bash executes network-delivered code without integrity verification, review, or pinning. This is a classic supply-chain anti-pattern and is more dangerous here because a cloud sync helper is expected to handle files, not execute arbitrary remote installation logic.

Content

Scanner excerpt · providers/gdrive.sh (reported line 30)May include surrounding context.

sh
if ! command -v rclone &>/dev/null; then
    log "rclone not found. Installing..."
    case "$(uname -s)" in
      Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;;
      Linux)  curl https://rclone.org/install.sh | sudo bash ;;
    esac
  fi

External Script Fetching

High
Category
Supply Chain
Confidence
99% confidence
Finding

This variant is more severe because the fetched script is piped directly into sudo bash, granting root privileges to unaudited remote content. Any compromise of the installer source or delivery path becomes immediate privileged remote code execution on the host.

Content

Scanner excerpt · providers/gdrive.sh (reported line 31)May include surrounding context.

sh
log "rclone not found. Installing..."
    case "$(uname -s)" in
      Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;;
      Linux)  curl https://rclone.org/install.sh | sudo bash ;;
    esac
  fi
}

Chaining Abuse

High
Category
Tool Misuse
Confidence
98% confidence
Finding

The pipe into sudo creates a dangerous execution chain where untrusted network data flows directly into a privileged shell. This chaining removes opportunities for validation and magnifies the impact from simple network or upstream compromise into full root-level execution.

Content

Scanner excerpt · providers/gdrive.sh (reported line 31)May include surrounding context.

sh
log "rclone not found. Installing..."
    case "$(uname -s)" in
      Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;;
      Linux)  curl https://rclone.org/install.sh | sudo bash ;;
    esac
  fi
}

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
75% 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).

Content

Scanner excerpt · providers/git.sh (reported line 57)May include surrounding context.

sh
# Fetch latest from remote, reset to it
  _git fetch origin "$branch" --quiet 2>/dev/null || true
  _git reset --hard "origin/$branch" --quiet 2>/dev/null || true

  # Apply vault contents into profile subdirectory
  mkdir -p "$profile_dir/identity" "$profile_dir/knowledge"

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
75% 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).

Content

Scanner excerpt · providers/git.sh (reported line 108)May include surrounding context.

sh
# Fetch latest from remote, reset to it
  _git fetch origin "$branch" --quiet 2>/dev/null || true
  _git reset --hard "origin/$branch" --quiet 2>/dev/null || true

  # Apply vault contents into profile subdirectory
  mkdir -p "$profile_dir/identity" "$profile_dir/knowledge"

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
84% confidence
Finding

During pull, the script hard-resets the local sync repo to the remote branch and then copies the resulting content into the live vault. In a tool that treats the remote as authoritative for sensitive identity data, this compounds the risk from an untrusted or compromised remote by making destructive state replacement automatic and non-interactive.

Content

Scanner excerpt · providers/git.sh (reported line 86)May include surrounding context.

sh
profile_name=$(get_profile_name)

  _git fetch origin "$branch" --quiet 2>/dev/null
  _git reset --hard "origin/$branch" --quiet 2>/dev/null || _git pull origin "$branch" --quiet 2>/dev/null

  local source_dir="$REPO_DIR/profiles/$profile_name"
  # Fallback for legacy (pre-profile) repos

External Script Fetching

High
Category
Supply Chain
Confidence
99% confidence
Finding

Fetching the installer and piping it to sudo bash is especially dangerous because it turns a network-delivered script into immediate root-level code execution. A compromised installer source would yield full system compromise rather than just user-level execution.

Content

Scanner excerpt · providers/s3.sh (reported line 11)May include surrounding context.

sh
ensure_rclone() {
  if ! command -v rclone &>/dev/null; then
    log "rclone not found. Installing..."
    case "$(uname -s)" in Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;; Linux) curl https://rclone.org/install.sh | sudo bash ;; esac
  fi
}

External Script Fetching

High
Category
Supply Chain
Confidence
99% confidence
Finding

Fetching the installer and piping it to sudo bash is especially dangerous because it turns a network-delivered script into immediate root-level code execution. A compromised installer source would yield full system compromise rather than just user-level execution.

Content

Scanner excerpt · providers/s3.sh (reported line 11)May include surrounding context.

sh
ensure_rclone() {
  if ! command -v rclone &>/dev/null; then
    log "rclone not found. Installing..."
    case "$(uname -s)" in Darwin) brew install rclone 2>/dev/null || curl https://rclone.org/install.sh | bash ;; Linux) curl https://rclone.org/install.sh | sudo bash ;; esac
  fi
}

Missing User Warnings

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The script automatically installs rclone by piping a network-fetched shell script directly into bash, and on Linux does so via sudo, without any integrity verification or explicit user confirmation. This creates a supply-chain and remote-code-execution path where a compromised upstream server, MITM, or malicious mirror could execute arbitrary code on the host, potentially with elevated privileges.

Content

No source excerpt is available for this finding.