Back to skill

Security audit

Obsync

Security checks for vulnerabilities and agentic risk

Overview

The skill is purpose-aligned for Obsidian syncing, but needs Review because it normalizes unsafe password handling and installs a credential-handling CLI from mutable third-party sources.

Install only if you trust the upstream `obsync` project and are comfortable granting it access to your Obsidian account, vault contents, and sync encryption secrets. Avoid putting real passwords in shell commands, shell history, exported environment variables, startup files, or systemd units; prefer interactive prompts, a protected keyring, or a dedicated secret manager. Review the installed version or pin a known release before using always-on sync.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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 (2)

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:16
Finding
Vault encryption secrets exposed through command-line arguments and environment variables## Vulnerability Details **File Location**: `SKILL.md`, lines 16-17 and 30-33 **Vulnerability Type**: Secret exposure through insecure credential handling **Risk Level**: Medium ### Vulnerable Code ```sh - For headless servers: `export OBSYNC_KEYRING_BACKEND=file` - Optionally set keyring password: `export OBSYNC_KEYRING_PASSWORD=mysecret` ``` ```sh - Pull vault: `obsync pull "My Notes" ~/notes -p "e2e-password"` - Pull and save password: `obsync pull "My Notes" ~/notes -p "e2e-password" -s` - Push local changes: `obsync push "My Notes" ~/notes -p "e2e-password"` - Watch (continuous sync): `obsync watch "My Notes" ~/notes -p "e2e-password"` ``` ### Technical Analysis The documentation encourages users to provide the vault end-to-end encryption password directly through the `-p` command-line option. Secrets placed in commands can be retained in shell history and may be exposed through process inspection, terminal recording, diagnostics, monitoring agents, or verbose operational logs. The keyring password is also assigned to an exported environment variable. Exported variables are inherited by child processes and can consequently become accessible to compromised subprocesses, debugging tools, crash-reporting systems, or other processes operating with sufficient local privileges. The values shown are examples rather than confirmed production credentials. The vulnerability is the documented secret-handling pattern, which users are likely to reproduce with real credentials. ### Attack Path 1. A user follows the documented command and substitutes a real vault encryption password for `e2e-password`. 2. The shell records the complete command in its history, or the password appears in the process argument list while `obsync` is running. 3. A local attacker, compromised monitoring component, or process with access to the user's shell history or process metadata obtains the password. 4. Alternatively, the user exports ...[truncated 813 chars]
Remediation
## Remediation Suggestions - Prefer interactive, non-echoing password input from a terminal rather than command-line password arguments. - Support reading secrets from a protected file descriptor, operating-system credential store, or dedicated secret-management service. - Replace examples containing inline password values with interactive commands and explicit warnings not to place secrets in shell commands. - Avoid exporting long-lived secret variables. If environment-based input is unavoidable, scope it to one process, clear it immediately afterward, and document its exposure risks. - Ensure verbose and JSON output never includes credentials, authentication tokens, encryption keys, or password-derived material. - For file-backed keyring storage, document restrictive file and directory permissions, such as user-only access, and ensure the CLI enforces secure permissions when creating files. - Advise users to remove any previously entered credential-bearing commands from shell history and rotate credentials if exposure is suspected.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:5
Finding
Unpinned installation from mutable third-party sources## Vulnerability Details **File Location**: `SKILL.md`, line 5 **Vulnerability Type**: Unpinned and unverifiable third-party dependency source **Risk Level**: Medium ### Vulnerable Code ```yaml metadata: {"clawdbot":{"emoji":"🔄","os":["darwin","linux"],"requires":{"bins":["obsync"]},"install":[{"id":"homebrew","kind":"brew","formula":"bpauli/tap/obsync","bins":["obsync"],"label":"Homebrew (recommended)"},{"id":"source","kind":"source","url":"https://github.com/bpauli/obsync","bins":["obsync"],"label":"Build from source (Go 1.25+)"}]}} ``` ### Technical Analysis The installation metadata directs users to a custom Homebrew tap or a mutable GitHub repository without specifying a reviewed release version, immutable commit identifier, cryptographic checksum, or signature-verification requirement. As a result, the code installed in the future may differ from the code that existed when the Skill was audited. The custom tap and source repository are legitimate-looking sources consistent with the Skill's stated purpose; there is no evidence in the audited file that they are currently malicious. Nevertheless, the absence of immutable versioning and integrity verification creates a supply-chain trust gap. Compromise of the repository, release process, maintainer account, or Homebrew tap could replace the expected CLI with modified code. ### Attack Path 1. An attacker compromises the upstream GitHub repository, maintainer account, release pipeline, or custom Homebrew tap. 2. The attacker modifies the referenced source or formula so that it builds or installs a malicious `obsync` binary. 3. A user installs or updates the dependency using the unpinned source specified by the Skill. 4. The malicious binary executes with the user's privileges when the user logs in, pulls, pushes, watches a vault, or installs the documented user service. 5. Because the CLI legitimately handles account credentials, encryption passwords, local vault files, a ...[truncated 672 chars]
Remediation
## Remediation Suggestions - Pin installation to a specific reviewed release and, for source builds, an immutable commit hash. - Publish and verify cryptographic checksums for downloaded release artifacts. - Prefer signed releases and require verification against a documented maintainer signing key. - Pin the Homebrew formula or package version where supported rather than implicitly accepting the latest mutable state. - Use reproducible builds and compare locally generated artifacts with trusted release attestations. - Document the exact reviewed version in the Skill metadata and establish a controlled process for dependency updates. - Consider provenance attestations and automated supply-chain scanning for both the source repository and packaging configuration.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Rogue AgentSelf-Modification, Session Persistence
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (5)

Credential Access

High
Category
Privilege Escalation
Content
- `obsync login` (enter email, password, and optional MFA code)
- For headless servers: `export OBSYNC_KEYRING_BACKEND=file`
- Optionally set keyring password: `export OBSYNC_KEYRING_PASSWORD=mysecret`
- Verify: `obsync list`

Output
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill explicitly recommends setting a keyring password in an environment variable (`OBSYNC_KEYRING_PASSWORD=mysecret`) without warning that environment variables may be exposed through shell history, process environments, crash reports, or service definitions. In a headless/server context, this is more dangerous because credentials are commonly persisted in shell profiles or systemd units, increasing the chance of long-term secret exposure.

Ssd 3

Medium
Confidence
96% confidence
Finding
The documentation encourages users to place a sensitive credential directly into an environment variable, which can leak through shell history, `env` dumps, debugging output, inherited process environments, or misconfigured service files. Because this skill targets headless Linux servers, operators are especially likely to automate setup in scripts or persistent profiles, amplifying exposure risk.

Ssd 3

Medium
Confidence
99% confidence
Finding
The example commands place the E2E password directly on the command line via `-p "e2e-password"`, which can expose the secret in shell history, process listings, audit logs, terminal scrollback, and monitoring tools. This is a genuine insecure-usage pattern, and the repeated examples normalize unsafe handling of encryption secrets.

Session Persistence

Medium
Category
Rogue Agent
Content
- Pull and save password: `obsync pull "My Notes" ~/notes -p "e2e-password" -s`
- Push local changes: `obsync push "My Notes" ~/notes -p "e2e-password"`
- Watch (continuous sync): `obsync watch "My Notes" ~/notes -p "e2e-password"`
- Install systemd service: `obsync install "My Notes" ~/notes`
- Check service status: `obsync status "My Notes"`
- View service logs: `journalctl --user -u obsync@<vault-id>.service -f`
- Uninstall service: `obsync uninstall "My Notes"`
Confidence
80% 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.

Static analysis

No suspicious patterns detected.