- Lightweight & feature-rich Wayland clipboard "manager" with fast persistent history and
- robust multi-media support. Stores and previews clipboard entries (text, images)
- on the clipboard with a neat TUI and advanced scripting capabilities.
+ Lightweight & feature-rich Wayland clipboard "manager" with fast persistent
+ history and robust multi-media support. Stores and previews clipboard
+ entries (text, images) on the clipboard with a neat TUI and advanced scripting
+ capabilities.
@@ -52,6 +53,7 @@ with many features such as but not necessarily limited to:
- Drop-in replacement for `wl-clipboard` tools (`wl-copy` and `wl-paste`)
- Sensitive clipboard filtering via regex (see below)
- Sensitive clipboard filtering by application (see below)
+- Database encryption using age (see below)
on top of the existing features of Cliphist, which are as follows:
@@ -124,7 +126,7 @@ releases are made when a version gets tagged, and are available under
- Build and install from source with Cargo:
```bash
- cargo install stash-clipboard --locked
+ cargo install stash --locked
```
Additionally, you may get Stash from source via `cargo install` using
@@ -357,21 +359,38 @@ sensitive pattern, using a regular expression. This is useful for preventing
accidental storage of secrets, passwords, or other sensitive data. You don't
want sensitive data ending up in your persistent clipboard, right?
-The filter can be configured in one of three ways, as part of two separate
-features.
+The filter can be configured in several ways, as part of two separate features.
#### Clipboard Filtering by Entry Regex
-This can be configured in one of two ways. You can use the **environment
-variable** `STASTH_SENSITIVE_REGEX` to a valid regex pattern, and if the
+This can be configured in one of several ways. You can use the **environment
+variable** `STASH_SENSITIVE_REGEX` to a valid regex pattern, and if the
clipboard text matches the regex it will not be stored. This can be used for
trivial secrets such as but not limited to GitHub tokens or secrets that follow
a rule, e.g. a prefix. You would typically set this in your `~/.bashrc` or
similar but in some cases this might be a security flaw.
-The safer alternative to this is using **Systemd LoadCrediental**. If Stash is
-running as a Systemd service, you can provide a regex pattern using a crediental
-file. For example, add to your `stash.service`:
+The _less-insecure_ [^1] alternative to this is using
+`STASH_SENSITIVE_REGEX_FILE` to read the regex from a file path. This is useful
+for NixOS secrets managers like agenix or sops-nix.
+
+```bash
+# You can set this in your configuration with `environment.sessionVariables`
+# or similar, pointing to the *decryption path*.
+$ export STASH_SENSITIVE_REGEX_FILE=/run/secrets/stash/clipboard_filter
+```
+
+Or use `STASH_SENSITIVE_REGEX_COMMAND` to execute a command that returns the
+regex pattern. This works well with password managers:
+
+```bash
+# Stash will execute the command and consume the result
+$ export STASH_SENSITIVE_REGEX_COMMAND="pass show stash/clipboard-filter"
+```
+
+The safest option is using **Systemd LoadCredential**. If Stash is running as a
+Systemd service, you can provide a regex pattern using a credential file. For
+example, add to your `stash.service`:
```dosini
LoadCredential=clipboard_filter:/etc/stash/clipboard_filter
@@ -382,9 +401,9 @@ quotes). This is done automatically in the
[vendored Systemd service](./contrib/stash.service). Remember to set the
appropriate file permissions if using this option.
-The service will check the credential file first, then the environment variable.
-If a clipboard entry matches the regex, it will be skipped and a warning will be
-logged.
+The service will check the credential file first, then the command, then the
+file path, then the environment variable. If a clipboard entry matches the
+regex, it will be skipped and a warning will be logged.
> [!TIP]
> **Example regex to block common password patterns**:
@@ -393,17 +412,21 @@ logged.
>
> For security reasons, you are recommended to use the regex only for generic
> tokens that follow a specific rule, for example a generic prefix or suffix.
+> For blocking entries from applications that emit sensitive data, such as
+> password managers, filter by application class instead.
#### Clipboard Filtering by Application Class
Stash allows blocking an entry from the persistent history if it has been copied
from certain applications. This depends on the `use-toplevel` feature flag and
uses the the `wlr-foreign-toplevel-management-v1` protocol for precise focus
-detection. While this feature flag is enabled (the default) you may use
-`--excluded-apps` in, e.g., `stash watch` or set the `STASH_EXCLUDED_APPS`
-environment variable to block entries from persisting in the database if they
-are coming from your password manager for example. The entry is still copied to
-the clipboard, but it will never be put inside the database.
+detection.
+
+While this feature flag is enabled (the default) you may use `--excluded-apps`
+in, e.g., `stash watch` or set the `STASH_EXCLUDED_APPS` environment variable to
+block entries from persisting in the database if they are coming from your
+password manager for example. The entry is still copied to the clipboard, but it
+will never be put inside the database.
This is a more robust alternative to using the regex method above, since you
likely do not want to catch your passwords with a regex. Simply pass your
@@ -516,6 +539,66 @@ figured out something new, e.g. a neat shell trick, feel free to add it here!
the packagers. While building from source, you may link
`target/release/stash` manually.
+### Database Encryption
+
+Stash supports encrypting clipboard entries at rest using the
+[age](https://age-encryption.org/) encryption format. This provides protection
+for sensitive data stored in the database.
+
+> [!WARNING]
+> If you enable encryption after already having entries in the database, the
+> existing entries will remain unencrypted. Only new entries added after
+> configuring encryption will be encrypted. To encrypt existing entries, you
+> would need to wipe the database and re-copy your clipboard contents.
+
+Encryption is **opt-in** and only takes effect when a passphrase is configured.
+When one _is_ configured, all new clipboard entries are encrypted before being
+stored in the database. Entries without encryption configured are stored in
+plaintext instead.
+
+Encrypted entries are detected by the `age-encryption.org/v1` header and
+decrypted automatically on retrieval. Search operations (e.g.,
+`stash delete --type query`) decrypt entries on-the-fly to match queries;
+entries that fail decryption are skipped with a warning
+
+#### Configuration
+
+Encryption is configured using a passphrase, which can be provided in one of
+several ways. The simplest is using the **environment variable**
+`STASH_ENCRYPTION_PASSPHRASE`:
+
+```bash
+export STASH_ENCRYPTION_PASSPHRASE="your-secure-passphrase"
+```
+
+Alternatively, you can use `STASH_ENCRYPTION_PASSPHRASE_FILE` to read the
+passphrase from a file path. This is useful for NixOS secrets managers:
+
+```bash
+export STASH_ENCRYPTION_PASSPHRASE_FILE=/run/secrets/stash/encryption_passphrase
+```
+
+Or use `STASH_ENCRYPTION_PASSPHRASE_COMMAND` to execute a command that returns
+the passphrase. This works well with password managers:
+
+```bash
+export STASH_ENCRYPTION_PASSPHRASE_COMMAND="pass show stash/encryption-key"
+```
+
+The safest option is using **Systemd LoadCredential**. If Stash is running as a
+Systemd service, you can provide the passphrase using a credential file:
+
+```dosini
+LoadCredential=stash_encryption_passphrase:/etc/stash/encryption_passphrase
+```
+
+This is done automatically in the
+[vendored Systemd service](./contrib/stash.service).
+
+> [!TIP]
+> When using encryption, make sure to back up your passphrase. Without it, you
+> will not be able to recover encrypted entries.
+
### Entry Expiration
Stash supports time-to-live (TTL) for clipboard entries. When an entry's
diff --git a/flake.lock b/flake.lock
index 8a9f105..e50ffba 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
"nodes": {
"crane": {
"locked": {
- "lastModified": 1777830388,
- "narHash": "sha256-2uoQAqUk2H0ijQtGiWAyNeQYGYc6yfAcRRLlJAz4Gp8=",
+ "lastModified": 1775839657,
+ "narHash": "sha256-SPm9ck7jh3Un9nwPuMGbRU04UroFmOHjLP56T10MOeM=",
"owner": "ipetkov",
"repo": "crane",
- "rev": "d459c1350e96ce1a7e3859c513ef5e9869d67d6f",
+ "rev": "7cf72d978629469c4bd4206b95c402514c1f6000",
"type": "github"
},
"original": {
@@ -17,11 +17,11 @@
},
"nixpkgs": {
"locked": {
- "lastModified": 1777954456,
- "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=",
+ "lastModified": 1775710090,
+ "narHash": "sha256-ar3rofg+awPB8QXDaFJhJ2jJhu+KqN/PRCXeyuXR76E=",
"owner": "NixOS",
"repo": "nixpkgs",
- "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1",
+ "rev": "4c1018dae018162ec878d42fec712642d214fdfa",
"type": "github"
},
"original": {
diff --git a/src/clipboard/persist.rs b/src/clipboard/persist.rs
index f5312a7..a677f50 100644
--- a/src/clipboard/persist.rs
+++ b/src/clipboard/persist.rs
@@ -196,7 +196,8 @@ fn serve_clipboard_child(prepared: PreparedCopy) {
},
Err(e) => {
- log::debug!("clipboard persistence: serve ended: {e}");
+ log::error!("clipboard persistence: serve failed: {e}");
+ exit(1);
},
}
}
diff --git a/src/commands/list.rs b/src/commands/list.rs
index 369949c..b3041e5 100644
--- a/src/commands/list.rs
+++ b/src/commands/list.rs
@@ -698,7 +698,7 @@ impl SqliteClipboardDb {
let mime_type = match mime {
Some(ref m) if m == "text/plain" => MimeType::Text,
Some(ref m) => MimeType::Specific(m.clone().clone()),
- None => MimeType::Autodetect,
+ None => MimeType::Text,
};
let copy_result = opts
.copy(Source::Bytes(contents.clone().into()), mime_type);
diff --git a/src/commands/watch.rs b/src/commands/watch.rs
index 111a330..71cdc17 100644
--- a/src/commands/watch.rs
+++ b/src/commands/watch.rs
@@ -435,14 +435,6 @@ impl WatchCommand for SqliteClipboardDb {
log::info!("clipboard entry excluded by app filter");
last_hash = Some(current_hash);
},
- Err(crate::db::StashError::AllWhitespace) => {
- log::debug!("clipboard entry is all whitespace, skipping");
- last_hash = Some(current_hash);
- },
- Err(crate::db::StashError::TooSmall(_)) => {
- log::debug!("clipboard entry below minimum size, skipping");
- last_hash = Some(current_hash);
- },
Err(e) => {
log::error!("failed to store clipboard entry: {e}");
last_hash = Some(current_hash);
@@ -526,8 +518,8 @@ mod tests {
#[test]
fn test_pick_image_preference_falls_back() {
- // No image types in offer set; first type is used as fallback.
let offered = vec!["text/html".to_string(), "text/plain".to_string()];
+ // No image types offered — falls back to first
assert_eq!(pick_mime(&offered, "image").unwrap(), "text/html");
}
@@ -558,14 +550,14 @@ mod tests {
#[test]
fn test_pick_html_fallback_when_only_html() {
- // text/html is used when it is the only offered type.
+ // When text/html is the only type, pick it
let offered = vec!["text/html".to_string()];
assert_eq!(pick_mime(&offered, "any").unwrap(), "text/html");
}
#[test]
fn test_pick_text_over_html_when_no_image() {
- // html + plain with no image type; plain text wins over html.
+ // Rich text copy: html + plain, no image — prefer plain text
let offered = vec!["text/html".to_string(), "text/plain".to_string()];
assert_eq!(pick_mime(&offered, "any").unwrap(), "text/plain");
}
diff --git a/src/db/mod.rs b/src/db/mod.rs
index 8ff5f8d..c0d24d8 100644
--- a/src/db/mod.rs
+++ b/src/db/mod.rs
@@ -215,12 +215,18 @@ pub enum StashError {
QueryDelete(Box
),
#[error("Failed to delete entry with id {0}: {1}")]
DeleteEntry(i64, Box),
+
+ #[error("Encryption error: {0}")]
+ Encryption(Box),
+ #[error("Decryption error: {0}")]
+ Decryption(Box),
}
pub trait ClipboardDb {
/// Store a new clipboard entry.
///
/// # Arguments
+ ///
/// * `input` - Reader for the clipboard content
/// * `max_dedupe_search` - Maximum number of recent entries to check for
/// duplicates
@@ -338,87 +344,215 @@ impl SqliteClipboardDb {
if schema_version == 0 {
tx.execute_batch(
"CREATE TABLE IF NOT EXISTS clipboard (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- contents BLOB NOT NULL,
- mime TEXT
- );",
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ contents BLOB NOT NULL,
+ mime TEXT
+ );",
)
- .map_err(migration_err)?;
- tx.pragma_update(None, "user_version", 1i64)
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to create clipboard table: {e}").into(),
+ )
+ })?;
+
+ tx.execute("PRAGMA user_version = 1", []).map_err(|e| {
+ StashError::Store(format!("Failed to set schema version: {e}").into())
+ })?;
}
+ // Add content_hash column if it doesn't exist. Migration MUST be done to
+ // avoid breaking existing installations.
if schema_version < 2 {
- if !column_exists(&tx, "content_hash") {
+ let has_content_hash: bool = tx
+ .query_row(
+ "SELECT sql FROM sqlite_master WHERE type='table' AND \
+ name='clipboard'",
+ [],
+ |row| {
+ let sql: String = row.get(0)?;
+ Ok(sql.to_lowercase().contains("content_hash"))
+ },
+ )
+ .unwrap_or(false);
+
+ if !has_content_hash {
tx.execute("ALTER TABLE clipboard ADD COLUMN content_hash INTEGER", [])
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to add content_hash column: {e}").into(),
+ )
+ })?;
}
+
+ // Create index for content_hash if it doesn't exist
tx.execute(
"CREATE INDEX IF NOT EXISTS idx_content_hash ON \
clipboard(content_hash)",
[],
)
- .map_err(migration_err)?;
- tx.pragma_update(None, "user_version", 2i64)
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to create content_hash index: {e}").into(),
+ )
+ })?;
+
+ tx.execute("PRAGMA user_version = 2", []).map_err(|e| {
+ StashError::Store(format!("Failed to set schema version: {e}").into())
+ })?;
}
+ // Add last_accessed column if it doesn't exist
if schema_version < 3 {
- if !column_exists(&tx, "last_accessed") {
+ let has_last_accessed: bool = tx
+ .query_row(
+ "SELECT sql FROM sqlite_master WHERE type='table' AND \
+ name='clipboard'",
+ [],
+ |row| {
+ let sql: String = row.get(0)?;
+ Ok(sql.to_lowercase().contains("last_accessed"))
+ },
+ )
+ .unwrap_or(false);
+
+ if !has_last_accessed {
tx.execute("ALTER TABLE clipboard ADD COLUMN last_accessed INTEGER", [
])
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to add last_accessed column: {e}").into(),
+ )
+ })?;
}
+
+ // Create index for last_accessed if it doesn't exist
tx.execute(
"CREATE INDEX IF NOT EXISTS idx_last_accessed ON \
clipboard(last_accessed)",
[],
)
- .map_err(migration_err)?;
- tx.pragma_update(None, "user_version", 3i64)
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to create last_accessed index: {e}").into(),
+ )
+ })?;
+
+ tx.execute("PRAGMA user_version = 3", []).map_err(|e| {
+ StashError::Store(format!("Failed to set schema version: {e}").into())
+ })?;
}
+ // Add expires_at column if it doesn't exist (v4)
if schema_version < 4 {
- if !column_exists(&tx, "expires_at") {
+ let has_expires_at: bool = tx
+ .query_row(
+ "SELECT sql FROM sqlite_master WHERE type='table' AND \
+ name='clipboard'",
+ [],
+ |row| {
+ let sql: String = row.get(0)?;
+ Ok(sql.to_lowercase().contains("expires_at"))
+ },
+ )
+ .unwrap_or(false);
+
+ if !has_expires_at {
tx.execute("ALTER TABLE clipboard ADD COLUMN expires_at REAL", [])
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to add expires_at column: {e}").into(),
+ )
+ })?;
}
+
+ // Create partial index for expires_at (only index non-NULL values)
tx.execute(
"CREATE INDEX IF NOT EXISTS idx_expires_at ON clipboard(expires_at) \
WHERE expires_at IS NOT NULL",
[],
)
- .map_err(migration_err)?;
- tx.pragma_update(None, "user_version", 4i64)
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to create expires_at index: {e}").into(),
+ )
+ })?;
+
+ tx.execute("PRAGMA user_version = 4", []).map_err(|e| {
+ StashError::Store(format!("Failed to set schema version: {e}").into())
+ })?;
}
+ // Add is_expired column if it doesn't exist (v5)
if schema_version < 5 {
- if !column_exists(&tx, "is_expired") {
+ let has_is_expired: bool = tx
+ .query_row(
+ "SELECT sql FROM sqlite_master WHERE type='table' AND \
+ name='clipboard'",
+ [],
+ |row| {
+ let sql: String = row.get(0)?;
+ Ok(sql.to_lowercase().contains("is_expired"))
+ },
+ )
+ .unwrap_or(false);
+
+ if !has_is_expired {
tx.execute(
"ALTER TABLE clipboard ADD COLUMN is_expired INTEGER DEFAULT 0",
[],
)
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to add is_expired column: {e}").into(),
+ )
+ })?;
}
+
+ // Create index for is_expired (for filtering)
tx.execute(
"CREATE INDEX IF NOT EXISTS idx_is_expired ON clipboard(is_expired) \
WHERE is_expired = 1",
[],
)
- .map_err(migration_err)?;
- tx.pragma_update(None, "user_version", 5i64)
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to create is_expired index: {e}").into(),
+ )
+ })?;
+
+ tx.execute("PRAGMA user_version = 5", []).map_err(|e| {
+ StashError::Store(format!("Failed to set schema version: {e}").into())
+ })?;
}
+ // Add mime_types column if it doesn't exist (v6)
+ // Stores all MIME types offered by the source application as JSON array.
+ // Needed for clipboard persistence to re-offer the same types.
if schema_version < 6 {
- if !column_exists(&tx, "mime_types") {
+ let has_mime_types: bool = tx
+ .query_row(
+ "SELECT sql FROM sqlite_master WHERE type='table' AND \
+ name='clipboard'",
+ [],
+ |row| {
+ let sql: String = row.get(0)?;
+ Ok(sql.to_lowercase().contains("mime_types"))
+ },
+ )
+ .unwrap_or(false);
+
+ if !has_mime_types {
tx.execute("ALTER TABLE clipboard ADD COLUMN mime_types TEXT", [])
- .map_err(migration_err)?;
+ .map_err(|e| {
+ StashError::Store(
+ format!("Failed to add mime_types column: {e}").into(),
+ )
+ })?;
}
- tx.pragma_update(None, "user_version", 6i64)
- .map_err(migration_err)?;
+
+ tx.execute("PRAGMA user_version = 6", []).map_err(|e| {
+ StashError::Store(format!("Failed to set schema version: {e}").into())
+ })?;
}
tx.commit().map_err(|e| {
@@ -427,29 +561,14 @@ impl SqliteClipboardDb {
)
})?;
+ // Initialize Wayland state in background thread. This will be used to track
+ // focused window state.
#[cfg(feature = "use-toplevel")]
crate::wayland::init_wayland_state();
Ok(Self { conn, db_path })
}
}
-/// Check whether `column` exists in the `clipboard` table.
-fn column_exists(conn: &Connection, column: &str) -> bool {
- conn
- .prepare("PRAGMA table_info(clipboard)")
- .and_then(|mut stmt| {
- stmt
- .query_map([], |row| row.get::<_, String>(1))
- .map(|rows| rows.filter_map(Result::ok).any(|c| c == column))
- })
- .unwrap_or(false)
-}
-
-/// Convert a rusqlite error into [`StashError::Store`].
-fn migration_err(e: rusqlite::Error) -> StashError {
- StashError::Store(e.to_string().into())
-}
-
impl SqliteClipboardDb {
pub fn list_json(
&self,
@@ -482,11 +601,24 @@ impl SqliteClipboardDb {
.get(2)
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
+ let decrypted_contents = if contents.starts_with(b"age-encryption.org/v1")
+ {
+ match decrypt_data(&contents) {
+ Ok(decrypted) => decrypted,
+ Err(e) => {
+ warn!("skipping entry {id}: decryption failed: {e}");
+ continue;
+ },
+ }
+ } else {
+ contents
+ };
+
let contents_str = match mime.as_deref() {
Some(m) if m.starts_with("text/") || m == "application/json" => {
- String::from_utf8_lossy(&contents).into_owned()
+ String::from_utf8_lossy(&decrypted_contents).into_owned()
},
- _ => base64::prelude::BASE64_STANDARD.encode(&contents),
+ _ => base64::prelude::BASE64_STANDARD.encode(&decrypted_contents),
};
entries.push(serde_json::json!({
"id": id,
@@ -576,13 +708,22 @@ impl ClipboardDb for SqliteClipboardDb {
None => None,
};
+ let encrypted_buf = if load_encryption_passphrase().is_some() {
+ Some(encrypt_data(&buf)?)
+ } else {
+ debug!("No encryption passphrase configured, storing entry unencrypted");
+ None
+ };
+
+ let contents_to_store = encrypted_buf.unwrap_or(buf);
+
self
.conn
.execute(
"INSERT INTO clipboard (contents, mime, content_hash, last_accessed, \
mime_types) VALUES (?1, ?2, ?3, ?4, ?5)",
params![
- buf,
+ contents_to_store,
mime,
content_hash,
std::time::SystemTime::now()
@@ -652,7 +793,7 @@ impl ClipboardDb for SqliteClipboardDb {
.conn
.execute(
"DELETE FROM clipboard WHERE id IN (SELECT id FROM clipboard ORDER \
- BY COALESCE(last_accessed, 0) ASC, id ASC LIMIT ?1)",
+ BY id ASC LIMIT ?1)",
params![i64::try_from(to_delete).unwrap_or(i64::MAX)],
)
.map_err(|e| StashError::Trim(e.to_string().into()))?;
@@ -724,8 +865,20 @@ impl ClipboardDb for SqliteClipboardDb {
let mime: Option = row
.get(2)
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
+ let preview_contents = if contents.starts_with(&[0x01u8]) {
+ match decrypt_data(&contents) {
+ Ok(decrypted) => decrypted,
+ Err(e) => {
+ warn!("skipping entry {id}: decryption failed: {e}");
+ continue;
+ },
+ }
+ } else {
+ contents
+ };
- let preview = preview_entry(&contents, mime.as_deref(), preview_width);
+ let preview =
+ preview_entry(&preview_contents, mime.as_deref(), preview_width);
if writeln!(out, "{id}\t{preview}").is_ok() {
listed += 1;
}
@@ -759,8 +912,15 @@ impl ClipboardDb for SqliteClipboardDb {
|row| Ok((row.get(0)?, row.get(1)?)),
)
.map_err(|e| StashError::DecodeGet(e.to_string().into()))?;
+
+ let decrypted_contents = if contents.starts_with(&[0x01u8]) {
+ decrypt_data(&contents)?
+ } else {
+ contents
+ };
+
out
- .write_all(&contents)
+ .write_all(&decrypted_contents)
.map_err(|e| StashError::DecodeWrite(e.to_string().into()))?;
log::info!("decoded entry with id {id}");
Ok(())
@@ -785,7 +945,23 @@ impl ClipboardDb for SqliteClipboardDb {
let contents: Vec = row
.get(1)
.map_err(|e| StashError::QueryDelete(e.to_string().into()))?;
- if contents.windows(query.len()).any(|w| w == query.as_bytes()) {
+
+ let searchable_contents = if contents.starts_with(&[0x01u8]) {
+ match decrypt_data(&contents) {
+ Ok(decrypted) => decrypted,
+ Err(e) => {
+ warn!("skipping entry {id}: decryption failed: {e}");
+ continue;
+ },
+ }
+ } else {
+ contents
+ };
+
+ if searchable_contents
+ .windows(query.len())
+ .any(|w| w == query.as_bytes())
+ {
self
.conn
.execute("DELETE FROM clipboard WHERE id = ?1", params![id])
@@ -815,25 +991,48 @@ impl ClipboardDb for SqliteClipboardDb {
&self,
id: i64,
) -> Result<(i64, Vec, Option), StashError> {
- let (contents, mime): (Vec, Option) = self
- .conn
- .query_row(
- "SELECT contents, mime FROM clipboard WHERE id = ?1",
- params![id],
- |row| Ok((row.get(0)?, row.get(1)?)),
- )
- .map_err(|e| StashError::DecodeGet(e.to_string().into()))?;
+ let (contents, mime, content_hash): (Vec, Option, Option) =
+ self
+ .conn
+ .query_row(
+ "SELECT contents, mime, content_hash FROM clipboard WHERE id = ?1",
+ params![id],
+ |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?)),
+ )
+ .map_err(|e| StashError::DecodeGet(e.to_string().into()))?;
- self
- .conn
- .execute(
- "UPDATE clipboard SET last_accessed = CAST(strftime('%s', 'now') AS \
- INTEGER) WHERE id = ?1",
- params![id],
- )
- .map_err(|e| StashError::Store(e.to_string().into()))?;
+ if let Some(hash) = content_hash {
+ let most_recent_id: Option = self
+ .conn
+ .query_row(
+ "SELECT id FROM clipboard WHERE content_hash = ?1 AND last_accessed \
+ = (SELECT MAX(last_accessed) FROM clipboard WHERE content_hash = \
+ ?1)",
+ params![hash],
+ |row| row.get(0),
+ )
+ .optional()
+ .map_err(|e| StashError::DecodeGet(e.to_string().into()))?;
- Ok((id, contents, mime))
+ if most_recent_id != Some(id) {
+ self
+ .conn
+ .execute(
+ "UPDATE clipboard SET last_accessed = CAST(strftime('%s', 'now') \
+ AS INTEGER) WHERE id = ?1",
+ params![id],
+ )
+ .map_err(|e| StashError::Store(e.to_string().into()))?;
+ }
+ }
+
+ let decrypted_contents = if contents.starts_with(&[0x01u8]) {
+ decrypt_data(&contents)?
+ } else {
+ contents
+ };
+
+ Ok((id, decrypted_contents, mime))
}
}
@@ -908,7 +1107,20 @@ impl SqliteClipboardDb {
let mime: Option = row
.get(2)
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
- let preview = preview_entry(&contents, mime.as_deref(), preview_width);
+ let decrypted_contents = if contents.starts_with(&[0x01u8]) {
+ match decrypt_data(&contents) {
+ Ok(decrypted) => decrypted,
+ Err(e) => {
+ warn!("skipping entry {id}: decryption failed: {e}");
+ continue;
+ },
+ }
+ } else {
+ contents
+ };
+
+ let preview =
+ preview_entry(&decrypted_contents, mime.as_deref(), preview_width);
let mime_str = mime.unwrap_or_default();
window.push((id, preview, mime_str));
}
@@ -1025,10 +1237,23 @@ impl SqliteClipboardDb {
/// changes made after daemon startup. Regex compilation is cached by
/// pattern to avoid recompilation.
fn load_sensitive_regex() -> Option {
+ use std::process::Command;
+
// Get the current pattern from env vars
- let pattern = if let Ok(regex_path) = env::var("CREDENTIALS_DIRECTORY") {
- let file = format!("{regex_path}/clipboard_filter");
+ let pattern = if let Ok(cred_dir) = env::var("CREDENTIALS_DIRECTORY") {
+ let file = format!("{cred_dir}/clipboard_filter");
fs::read_to_string(&file).ok().map(|s| s.trim().to_string())
+ } else if let Ok(cmd) = env::var("STASH_SENSITIVE_REGEX_COMMAND") {
+ Command::new("sh")
+ .args(["-c", &cmd])
+ .output()
+ .ok()
+ .filter(|o| o.status.success())
+ .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string())
+ } else if let Ok(file_path) = env::var("STASH_SENSITIVE_REGEX_FILE") {
+ fs::read_to_string(&file_path)
+ .ok()
+ .map(|s| s.trim().to_string())
} else {
env::var("STASH_SENSITIVE_REGEX").ok()
}?;
@@ -1055,6 +1280,68 @@ fn load_sensitive_regex() -> Option {
})
}
+fn load_encryption_passphrase() -> Option {
+ use std::process::Command;
+
+ static PASSPHRASE_CACHE: OnceLock =
+ OnceLock::new();
+
+ if let Some(cached) = PASSPHRASE_CACHE.get() {
+ return Some(cached.clone());
+ }
+
+ let passphrase = if let Ok(cred_dir) = env::var("CREDENTIALS_DIRECTORY") {
+ let file = format!("{cred_dir}/stash_encryption_passphrase");
+ fs::read_to_string(&file).ok().map(|s| s.trim().to_owned())
+ } else if let Ok(cmd) = env::var("STASH_ENCRYPTION_PASSPHRASE_COMMAND") {
+ Command::new("sh")
+ .args(["-c", &cmd])
+ .output()
+ .ok()
+ .filter(|o| o.status.success())
+ .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_owned())
+ } else if let Ok(file_path) = env::var("STASH_ENCRYPTION_PASSPHRASE_FILE") {
+ fs::read_to_string(&file_path)
+ .ok()
+ .map(|s| s.trim().to_owned())
+ } else {
+ env::var("STASH_ENCRYPTION_PASSPHRASE").ok()
+ }?;
+
+ let secret = age::secrecy::SecretString::from(passphrase);
+ let _ = PASSPHRASE_CACHE.set(secret.clone());
+ Some(secret)
+}
+
+fn encrypt_data(data: &[u8]) -> Result, StashError> {
+ let passphrase = load_encryption_passphrase().ok_or_else(|| {
+ StashError::Encryption("No encryption passphrase configured".into())
+ })?;
+
+ let recipient = age::scrypt::Recipient::new(passphrase);
+ let encrypted = age::encrypt(&recipient, data)
+ .map_err(|e| StashError::Encryption(e.to_string().into()))?;
+ // Prepend marker byte to identify our encrypted data
+ let mut result = Vec::with_capacity(1 + encrypted.len());
+ result.push(0x01u8);
+ result.extend_from_slice(&encrypted);
+ Ok(result)
+}
+
+fn decrypt_data(encrypted: &[u8]) -> Result, StashError> {
+ let passphrase = load_encryption_passphrase().ok_or_else(|| {
+ StashError::Decryption("No encryption passphrase configured".into())
+ })?;
+
+ // Strip our marker byte if present
+ let data_to_decrypt = encrypted.strip_prefix(&[0x01u8]).unwrap_or(encrypted);
+
+ let identity = age::scrypt::Identity::new(passphrase);
+ let decrypted = age::decrypt(&identity, data_to_decrypt)
+ .map_err(|e| StashError::Decryption(e.to_string().into()))?;
+ Ok(decrypted)
+}
+
pub fn extract_id(input: &str) -> Result {
let id_str = input.split('\t').next().unwrap_or("");
id_str.parse().map_err(|_| "invalid id")
@@ -1123,10 +1410,17 @@ pub fn size_str(size: usize) -> String {
/// Check if clipboard should be excluded based on excluded apps configuration.
/// Uses timing correlation and focused window detection to identify source app.
fn should_exclude_by_app(excluded_apps: Option<&[String]>) -> bool {
- match excluded_apps {
- Some(apps) if !apps.is_empty() => detect_excluded_app_activity(apps),
- _ => false,
+ let excluded = match excluded_apps {
+ Some(apps) if !apps.is_empty() => apps,
+ _ => return false,
+ };
+
+ // Try multiple detection strategies
+ if detect_excluded_app_activity(excluded) {
+ return true;
}
+
+ false
}
/// Detect if clipboard likely came from an excluded app using multiple
@@ -2101,231 +2395,4 @@ mod tests {
"Regex loading should be deterministic"
);
}
-
- #[test]
- fn test_migration_from_v3() {
- let temp_dir = tempfile::tempdir().expect("temp dir");
- let db_path = temp_dir.path().join("test_v3.db");
- let conn = Connection::open(&db_path).expect("open");
- conn
- .execute_batch(
- "CREATE TABLE clipboard (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- contents BLOB NOT NULL,
- mime TEXT,
- content_hash INTEGER,
- last_accessed INTEGER
- );
- INSERT INTO clipboard (contents, mime, content_hash) VALUES \
- (x'010203', 'text/plain', 12345);",
- )
- .expect("create v3 schema");
- conn
- .pragma_update(None, "user_version", 3i64)
- .expect("set version");
-
- let db = SqliteClipboardDb::new(conn, db_path).expect("migrate");
- assert_eq!(get_schema_version(&db.conn).expect("version"), 6);
- assert!(table_column_exists(&db.conn, "clipboard", "expires_at"));
- assert!(table_column_exists(&db.conn, "clipboard", "is_expired"));
- assert!(table_column_exists(&db.conn, "clipboard", "mime_types"));
- let count: i64 = db
- .conn
- .query_row("SELECT COUNT(*) FROM clipboard", [], |r| r.get(0))
- .expect("count");
- assert_eq!(count, 1, "existing data must survive migration");
- }
-
- #[test]
- fn test_migration_from_v4() {
- let temp_dir = tempfile::tempdir().expect("temp dir");
- let db_path = temp_dir.path().join("test_v4.db");
- let conn = Connection::open(&db_path).expect("open");
- conn
- .execute_batch(
- "CREATE TABLE clipboard (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- contents BLOB NOT NULL,
- mime TEXT,
- content_hash INTEGER,
- last_accessed INTEGER,
- expires_at REAL
- );
- INSERT INTO clipboard (contents, mime) VALUES (x'aabbcc', \
- 'image/png');",
- )
- .expect("create v4 schema");
- conn
- .pragma_update(None, "user_version", 4i64)
- .expect("set version");
-
- let db = SqliteClipboardDb::new(conn, db_path).expect("migrate");
- assert_eq!(get_schema_version(&db.conn).expect("version"), 6);
- assert!(table_column_exists(&db.conn, "clipboard", "is_expired"));
- assert!(table_column_exists(&db.conn, "clipboard", "mime_types"));
- let count: i64 = db
- .conn
- .query_row("SELECT COUNT(*) FROM clipboard", [], |r| r.get(0))
- .expect("count");
- assert_eq!(count, 1, "existing data must survive migration");
- }
-
- #[test]
- fn test_migration_from_v5() {
- let temp_dir = tempfile::tempdir().expect("temp dir");
- let db_path = temp_dir.path().join("test_v5.db");
- let conn = Connection::open(&db_path).expect("open");
- conn
- .execute_batch(
- "CREATE TABLE clipboard (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- contents BLOB NOT NULL,
- mime TEXT,
- content_hash INTEGER,
- last_accessed INTEGER,
- expires_at REAL,
- is_expired INTEGER DEFAULT 0
- );
- INSERT INTO clipboard (contents, mime) VALUES (x'deadbeef', \
- 'application/octet-stream');",
- )
- .expect("create v5 schema");
- conn
- .pragma_update(None, "user_version", 5i64)
- .expect("set version");
-
- let db = SqliteClipboardDb::new(conn, db_path).expect("migrate");
- assert_eq!(get_schema_version(&db.conn).expect("version"), 6);
- assert!(table_column_exists(&db.conn, "clipboard", "mime_types"));
- }
-
- /// Pre-migration entries (NULL content_hash) must have last_accessed
- /// updated when accessed via copy_entry.
- #[test]
- fn test_copy_entry_updates_last_accessed_null_hash() {
- let db = test_db();
- db.conn
- .execute(
- "INSERT INTO clipboard (contents, mime, content_hash, last_accessed) \
- VALUES (?1, 'text/plain', NULL, 0)",
- rusqlite::params![b"legacy data".as_ref()],
- )
- .expect("insert null-hash entry");
- let id: i64 = db
- .conn
- .query_row("SELECT last_insert_rowid()", [], |r| r.get(0))
- .expect("id");
-
- db.copy_entry(id).expect("copy");
-
- let last_accessed: i64 = db
- .conn
- .query_row(
- "SELECT last_accessed FROM clipboard WHERE id = ?1",
- [id],
- |r| r.get(0),
- )
- .expect("last_accessed");
- assert!(
- last_accessed > 0,
- "last_accessed must be updated for null-hash entries"
- );
- }
-
- /// trim_db must evict the least-recently-accessed entries, not the
- /// lowest-id entries.
- #[test]
- fn test_trim_db_evicts_lru_not_oldest() {
- let db = test_db();
- let mut ids = Vec::new();
- for i in 0..5u8 {
- let id = db
- .store_entry(
- std::io::Cursor::new(vec![i; 4]),
- 0,
- 100,
- None,
- None,
- DEFAULT_MAX_ENTRY_SIZE,
- None,
- None,
- )
- .expect("store");
- ids.push(id);
- }
-
- // Zero out all timestamps so copy_entry produces a strictly higher value.
- db.conn
- .execute("UPDATE clipboard SET last_accessed = 0", [])
- .expect("reset timestamps");
-
- // Touch the first (oldest by id) entry to make it most-recently-used.
- db.copy_entry(ids[0]).expect("copy");
-
- // Trim to 4; ids[0] was just accessed and must survive.
- db.trim_db(4).expect("trim");
-
- let still_there: i64 = db
- .conn
- .query_row(
- "SELECT COUNT(*) FROM clipboard WHERE id = ?1",
- [ids[0]],
- |r| r.get(0),
- )
- .expect("count");
- assert_eq!(
- still_there, 1,
- "recently accessed entry must not be evicted"
- );
-
- let total: i64 = db
- .conn
- .query_row("SELECT COUNT(*) FROM clipboard", [], |r| r.get(0))
- .expect("total");
- assert_eq!(total, 4);
- }
-
- /// All new columns must be NULL for entries created before their respective
- /// schema versions.
- #[test]
- fn test_migration_null_columns_for_legacy_entries() {
- let temp_dir = tempfile::tempdir().expect("temp dir");
- let db_path = temp_dir.path().join("test_legacy.db");
- {
- let conn = Connection::open(&db_path).expect("open");
- conn
- .execute_batch(
- "CREATE TABLE clipboard (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- contents BLOB NOT NULL,
- mime TEXT
- );
- INSERT INTO clipboard (contents, mime) VALUES (x'68656c6c6f', \
- 'text/plain');",
- )
- .expect("create v0 schema");
- }
-
- let conn = Connection::open(&db_path).expect("open");
- let db = SqliteClipboardDb::new(conn, db_path).expect("migrate");
-
- let (hash, accessed, expires): (Option, Option, Option) = db
- .conn
- .query_row(
- "SELECT content_hash, last_accessed, expires_at FROM clipboard WHERE \
- id = 1",
- [],
- |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
- )
- .expect("query");
- assert!(hash.is_none(), "content_hash must be NULL for pre-v2 entry");
- assert!(
- accessed.is_none(),
- "last_accessed must be NULL for pre-v3 entry"
- );
- assert!(
- expires.is_none(),
- "expires_at must be NULL for pre-v4 entry"
- );
- }
}
diff --git a/src/db/nonblocking.rs b/src/db/nonblocking.rs
index d6a00cd..d62e0dd 100644
--- a/src/db/nonblocking.rs
+++ b/src/db/nonblocking.rs
@@ -8,7 +8,6 @@ use crate::db::{ClipboardDb, SqliteClipboardDb, StashError};
/// on a thread pool to avoid blocking the async runtime. Since
/// [`rusqlite::Connection`] is not Send, we store the database path and open a
/// new connection for each operation.
-#[derive(Clone)]
pub struct AsyncClipboardDb {
db_path: PathBuf,
}
@@ -73,11 +72,25 @@ impl AsyncClipboardDb {
AND (is_expired IS NULL OR is_expired = 0) ORDER BY expires_at ASC",
)
.map_err(|e| StashError::ListDecode(e.to_string().into()))?;
- stmt
- .query_map([], |row| Ok((row.get::<_, f64>(0)?, row.get::<_, i64>(1)?)))
+
+ let mut rows = stmt
+ .query([])
+ .map_err(|e| StashError::ListDecode(e.to_string().into()))?;
+ let mut expirations = Vec::new();
+
+ while let Some(row) = rows
+ .next()
.map_err(|e| StashError::ListDecode(e.to_string().into()))?
- .collect::, _>>()
- .map_err(|e| StashError::ListDecode(e.to_string().into()))
+ {
+ let exp = row
+ .get::<_, f64>(0)
+ .map_err(|e| StashError::ListDecode(e.to_string().into()))?;
+ let id = row
+ .get::<_, i64>(1)
+ .map_err(|e| StashError::ListDecode(e.to_string().into()))?;
+ expirations.push((exp, id));
+ }
+ Ok(expirations)
})
.await
}
@@ -123,6 +136,14 @@ impl AsyncClipboardDb {
}
}
+impl Clone for AsyncClipboardDb {
+ fn clone(&self) -> Self {
+ Self {
+ db_path: self.db_path.clone(),
+ }
+ }
+}
+
#[cfg(test)]
mod tests {
use std::{collections::HashSet, hash::Hasher};
diff --git a/src/multicall/wl_copy.rs b/src/multicall/wl_copy.rs
index 7948c68..3794420 100644
--- a/src/multicall/wl_copy.rs
+++ b/src/multicall/wl_copy.rs
@@ -222,7 +222,8 @@ fn fork_and_serve(prepared_copy: wl_clipboard_rs::copy::PreparedCopy) {
0 => {
// Child process - serve clipboard content
if let Err(e) = prepared_copy.serve() {
- log::debug!("background clipboard service ended: {e}");
+ log::error!("background clipboard service failed: {e}");
+ std::process::exit(1);
}
std::process::exit(0);
},
diff --git a/src/multicall/wl_paste.rs b/src/multicall/wl_paste.rs
index 5a893d6..5daa1fd 100644
--- a/src/multicall/wl_paste.rs
+++ b/src/multicall/wl_paste.rs
@@ -456,9 +456,6 @@ fn handle_regular_paste(
bail!("no content available and --no-newline specified");
}
if let Err(e) = out.write_all(&buf) {
- if e.kind() == io::ErrorKind::BrokenPipe {
- return Ok(());
- }
bail!("failed to write to stdout: {e}");
}
@@ -474,12 +471,12 @@ fn handle_regular_paste(
|| types == "application/x-sh"
};
- if !args.no_newline && is_text_content && !buf.ends_with(b"\n") {
- if let Err(e) = out.write_all(b"\n") {
- if e.kind() != io::ErrorKind::BrokenPipe {
- bail!("failed to write newline to stdout: {e}");
- }
- }
+ if !args.no_newline
+ && is_text_content
+ && !buf.ends_with(b"\n")
+ && let Err(e) = out.write_all(b"\n")
+ {
+ bail!("failed to write newline to stdout: {e}");
}
},
Err(PasteError::NoSeats) => {