Back to skill

Security audit

pass - stores, retrieves, generates, and synchronizes passwords securely

Security checks for vulnerabilities and agentic risk

Overview

This is a coherent guide for the Unix pass password manager, with sensitive but expected password-management commands that need careful use.

Install only if you intend to use pass and are comfortable managing GPG-backed password stores. Review commands before running them, be especially careful with -f and -r options, protect private GPG keys, TOTP seeds, and password-manager export files, and prefer verified or pinned third-party extension installs when possible.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:243
Finding
Unpinned Third-Party Packages and Mutable Password-Manager Extension## Vulnerability Details **File Location**: `SKILL.md`, lines 243 and 259–262 **Vulnerability Type**: Unverified and unpinned third-party dependencies **Risk Level**: Medium ### Vulnerable Code ```bash pip install pass-import # or: pacman -S pass-import ``` ```bash # Install git clone https://github.com/roddhjav/pass-update ~/.password-store/.extensions/update.bash # Update a password interactively pass update email/gmail ``` ### Technical Analysis The skill instructs users to install `pass-import` from PyPI without pinning an exact version and to clone the mutable default branch of a GitHub repository without selecting an immutable commit, verifying a checksum, or validating a cryptographic signature. These dependencies operate near a sensitive password store. In particular, the cloned component is intended to become a `pass` extension and is subsequently invoked using `pass update`. If an upstream release, repository, maintainer account, or distribution channel is compromised, code different from the code originally reviewed could be installed and executed. The documented clone destination is also potentially unreliable: `git clone` ordinarily creates a directory at the specified destination, while a `pass` extension conventionally requires an executable extension script. This ambiguity may encourage users to perform additional unsafe installation steps to make the extension executable. ### Attack Path 1. An attacker compromises the PyPI package, GitHub repository, maintainer account, or another part of the upstream release process. 2. The attacker publishes a malicious package version or modifies the repository's mutable default branch. 3. A user follows the skill instructions and runs the unpinned `pip install` or `git clone` command. 4. The malicious dependency is installed without integrity or provenance verification. 5. The user invokes `pass import` or `pass update`. 6. Attacker-controlled code ...[truncated 1043 chars]
Remediation
## Remediation Suggestions 1. Prefer packages supplied and verified by the operating-system distribution where practical. 2. Pin Python dependencies to an explicitly reviewed version, for example with an exact `==` constraint. 3. Use a lock file containing cryptographic hashes and install with hash verification, such as `pip install --require-hashes`. 4. Pin the Git dependency to a reviewed immutable commit rather than relying on the repository's mutable default branch. 5. Verify signed tags, release signatures, or independently published checksums before installation. 6. Review extension source code before making it executable or enabling `PASSWORD_STORE_ENABLE_EXTENSIONS`. 7. Replace the ambiguous clone command with documented installation steps that copy only the reviewed extension script to the correct extension path and apply the minimum required permissions. 8. Execute import and extension tooling with ordinary user privileges, never with `sudo`, and restrict unnecessary network access where feasible. 9. Back up the encrypted password store before running third-party migration or update extensions.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • 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 (12)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
### Remove an entry

```bash
pass rm email/gmail
pass rm -r email/          # remove a folder recursively
pass rm -f email/gmail     # no confirmation prompt
```
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
```bash
pass rm email/gmail
pass rm -r email/          # remove a folder recursively
pass rm -f email/gmail     # no confirmation prompt
```
Confidence
85% confidence
Finding
`pass rm -r email/` performs recursive deletion of an entire folder of secrets, which materially increases blast radius and can be dangerous if copied or suggested without caution. In a password-store skill, recursive deletion is legitimate functionality, but presenting it without warning raises the chance of large-scale accidental credential loss.

Tool Parameter Abuse

High
Category
Tool Misuse
Content
```bash
pass rm email/gmail
pass rm -r email/          # remove a folder recursively
pass rm -f email/gmail     # no confirmation prompt
```

### Move / copy
Confidence
89% confidence
Finding
`pass rm -f email/gmail` suppresses confirmation for deletion of a secret, making accidental or automated misuse more likely. While the command is valid, in a skill that may be reused by agents or less experienced users, omitting a warning increases the chance of irreversible credential loss.

Vague Triggers

Medium
Confidence
94% confidence
Finding
The trigger text includes a catch-all phrase like "or any variation," which can cause the skill to activate for loosely related requests beyond the intended `pass` scope. In an agent setting, over-broad routing can expose users to irrelevant or risky terminal-password-manager instructions when the user did not actually ask for them.

Session Persistence

Medium
Category
Rogue Agent
Content
pass insert email/gmail              # prompted twice for confirmation
pass insert -e email/gmail           # echo password as you type (single prompt)
pass insert -m email/gmail           # multiline (recommended, ends with Ctrl-D)
pass insert -f email/gmail           # overwrite without prompt
```

### Generate a new password
Confidence
60% 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.

Missing User Warnings

Medium
Confidence
92% confidence
Finding
The guide documents force/overwrite options such as `insert -f`, `generate -f`, and similar destructive variants without warning about irreversible overwrite risk. In a password-management context, normalizing no-prompt destructive flags can lead to accidental credential loss or replacement, especially if an agent suggests commands without highlighting the consequences.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
```bash
pass rm email/gmail
pass rm -r email/          # remove a folder recursively
pass rm -f email/gmail     # no confirmation prompt
```

### Move / copy
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The instructions tell users to import a private GPG key but do not warn that the file contains highly sensitive secret key material whose exposure compromises all encrypted entries protected by that key. In a password-store workflow, mishandling the private key can enable full decryption of the user's password database on any system where the key is imported or copied insecurely.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The pass-otp example instructs users to paste an `otpauth://` URI containing the live TOTP seed without stating that this seed is equivalent to possession of the second factor. Anyone who captures that secret can generate valid future codes, defeating MFA protections for the associated account.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The import examples use password-manager export files without warning that such exports are often plaintext or otherwise highly sensitive bulk credential dumps. If users leave these files on disk, sync them accidentally, or process them in untrusted locations, an attacker could obtain complete account access across many services.

Session Persistence

Medium
Category
Rogue Agent
Content
## 8. Shell Completion

```bash
# bash — add to ~/.bashrc
source /usr/share/bash-completion/completions/pass

# zsh — add to ~/.zshrc
Confidence
90% 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
# bash — add to ~/.bashrc
source /usr/share/bash-completion/completions/pass

# zsh — add to ~/.zshrc
autoload -U compinit && compinit

# fish — works out of the box after install
Confidence
90% 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.