Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| acbf499bb7 | |||
| 8bc6d5d1c5 | |||
| 4b7bdc487f | |||
| f4e483dd36 |
@@ -7,8 +7,7 @@ code and an appropriate test or desktop/package observation support it.
|
||||
|
||||
- [x] SQLCipher storage with manually entered, non-persisted passphrase.
|
||||
- [x] Wrong-passphrase rejection and encrypted round-trip coverage.
|
||||
- [x] Explicit migration from legacy plaintext history.
|
||||
- [x] Optional removal of retained plaintext migration backups.
|
||||
- [x] Explicit rejection of legacy plaintext history; no plaintext migration or bypass path.
|
||||
- [x] User-only permissions for data, config, logs, lock, and socket.
|
||||
- [x] Bounded clipboard reads and no clipboard contents in normal logs.
|
||||
- [ ] Review and test crash, swap, and snapshot exposure of plaintext in memory.
|
||||
@@ -21,7 +20,7 @@ code and an appropriate test or desktop/package observation support it.
|
||||
- [x] Tray popup, pause state, and graceful Quit action.
|
||||
- [x] Single-instance lock and show/toggle command.
|
||||
- [ ] Complete real Cinnamon/X11 acceptance of shortcut, focus/paste, tray,
|
||||
opacity, pause, migration, and quit behavior.
|
||||
opacity, pause, passphrase, and quit behavior.
|
||||
|
||||
## Delivery
|
||||
|
||||
@@ -36,12 +35,12 @@ code and an appropriate test or desktop/package observation support it.
|
||||
## Test policy
|
||||
|
||||
- [x] Audited the inline tests against current behavior; removed one path-shape
|
||||
smoke test and stale documentation-coupled naming. The remaining 31 tests
|
||||
cover data-loss, ordering, privacy, bounds, migration, lifecycle, or parsing
|
||||
smoke test and stale documentation-coupled naming. The remaining 32 tests
|
||||
cover data-loss, ordering, privacy, bounds, encryption, lifecycle, or parsing
|
||||
behavior; GUI/X11 acceptance remains manual where headless tests cannot prove
|
||||
it.
|
||||
- Unit tests must protect data-loss, ordering, privacy, bounds, migration,
|
||||
lifecycle, or parsing behavior.
|
||||
- GUI/X11 behavior that cannot be exercised headlessly remains explicitly
|
||||
marked as manual acceptance, not represented by a green unit-test count.
|
||||
- Passphrase rotation is intentionally out of scope for this goal.
|
||||
- Passphrase rotation is covered by an encrypted round-trip test.
|
||||
|
||||
2
Cargo.lock
generated
2
Cargo.lock
generated
@@ -148,7 +148,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "cliphoard"
|
||||
version = "1.0.0"
|
||||
version = "1.2.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"dirs",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "cliphoard"
|
||||
version = "1.0.0"
|
||||
version = "1.2.0"
|
||||
edition = "2021"
|
||||
description = "A tiny, keyboard-first clipboard history utility"
|
||||
license = "MIT"
|
||||
|
||||
25
README.md
25
README.md
@@ -8,15 +8,16 @@ with SQLCipher and unlocked with a passphrase that Cliphoard does not store.
|
||||
Install the package on Debian, Ubuntu, or Mint:
|
||||
|
||||
```bash
|
||||
sudo apt install ./cliphoard_1.0.0_amd64.deb
|
||||
sudo apt install ./cliphoard_1.2.0_amd64.deb
|
||||
```
|
||||
|
||||
The package installs the `cliphoard` command, desktop launcher, tray icon,
|
||||
autostart entry, and a copy of this README at
|
||||
`/usr/share/doc/cliphoard/README.md`. Start it from the desktop menu, tray, or
|
||||
with `cliphoard`.
|
||||
On first start, enter a passphrase. An older plaintext database is migrated
|
||||
only after confirmation; Cliphoard then offers to remove its retained backup.
|
||||
On first start, create a passphrase and remember it; Cliphoard cannot recover
|
||||
it. Existing history must already be encrypted. Plaintext databases are not
|
||||
opened or migrated.
|
||||
|
||||
## Build from source
|
||||
|
||||
@@ -28,7 +29,7 @@ sudo apt install cargo rustc dpkg-dev libgtk-4-dev libdbus-1-dev libx11-dev libx
|
||||
cargo test --locked --all-features
|
||||
cargo build --release --locked --features gui
|
||||
packaging/build-deb.sh
|
||||
sudo apt install ./target/cliphoard_1.0.0_amd64.deb
|
||||
sudo apt install ./target/cliphoard_1.2.0_amd64.deb
|
||||
```
|
||||
|
||||
An isolated Docker build produces the same package:
|
||||
@@ -78,3 +79,19 @@ Cliphoard’s control.
|
||||
|
||||
Runtime paths are `~/.local/share/cliphoard/cliphoard.db`,
|
||||
`~/.config/cliphoard/config.toml`, and `~/.local/state/cliphoard/`.
|
||||
|
||||
## Upgrade from a plaintext database
|
||||
|
||||
Version 1.1.0 no longer opens or migrates plaintext databases. If Cliphoard
|
||||
reports that the database is plaintext, stop Cliphoard and remove the old
|
||||
database before starting the new version. This permanently removes its
|
||||
history:
|
||||
|
||||
```bash
|
||||
pkill -x cliphoard || true
|
||||
rm -f ~/.local/share/cliphoard/cliphoard.db \
|
||||
~/.local/share/cliphoard/cliphoard.db.plaintext-backup*
|
||||
```
|
||||
|
||||
If the old history is needed, keep a copy elsewhere and use the previous
|
||||
release to export or otherwise preserve it before deleting the local files.
|
||||
|
||||
21
RELEASE_NOTES.md
Normal file
21
RELEASE_NOTES.md
Normal file
@@ -0,0 +1,21 @@
|
||||
# Cliphoard 1.2.0
|
||||
|
||||
## Highlights
|
||||
|
||||
- Added configurable popup opacity and always-on-top behavior.
|
||||
- Added settings for startup behavior, keyboard shortcut, history limits, and
|
||||
retention.
|
||||
- Added search reset-on-reopen and privacy-pattern clipboard filtering.
|
||||
- Settings changes are persisted in the user configuration file.
|
||||
|
||||
## Compatibility and migration
|
||||
|
||||
This release continues to use encrypted SQLCipher storage and the existing
|
||||
passphrase. No database migration is required. Plaintext databases remain
|
||||
unsupported and are not opened or migrated; preserve any needed data with the
|
||||
previous release before removing a plaintext database.
|
||||
|
||||
## Build requirements
|
||||
|
||||
Linux/X11, GTK4, and the runtime libraries listed by the Debian package are
|
||||
required. See `README.md` for installation and plaintext-database handling.
|
||||
123
RELEASING.md
Normal file
123
RELEASING.md
Normal file
@@ -0,0 +1,123 @@
|
||||
# Cliphoard release procedure
|
||||
|
||||
Run releases from the repository root. The process produces a source tag,
|
||||
release binary, Debian package, checksums, and a Gitea release.
|
||||
|
||||
## Prepare
|
||||
|
||||
```bash
|
||||
git switch main
|
||||
git pull --ff-only
|
||||
git status --short
|
||||
```
|
||||
|
||||
Choose the next semantic version, such as `1.2.0`, and matching tag `v1.2.0`.
|
||||
Update the version in `Cargo.toml`, the root `cliphoard` package in
|
||||
`Cargo.lock`, `packaging/debian/control`, `packaging/build-deb.sh`, and the
|
||||
versioned `.deb` names in `README.md`. Review changes since the previous tag
|
||||
and write notes covering features, fixes, breaking changes, migration needs,
|
||||
passphrase behavior, and platform requirements.
|
||||
|
||||
## Verify and build
|
||||
|
||||
```bash
|
||||
cargo fmt --all -- --check
|
||||
cargo test --locked --all-features
|
||||
cargo clippy --locked --all-features -- -D warnings
|
||||
cargo build --release --locked --features gui
|
||||
CLIPHOARD_VERSION=1.2.0 packaging/build-deb.sh
|
||||
dpkg-deb --info target/cliphoard_1.2.0_amd64.deb
|
||||
dpkg-deb --contents target/cliphoard_1.2.0_amd64.deb
|
||||
sha256sum target/cliphoard_1.2.0_amd64.deb target/release/cliphoard > target/cliphoard_1.2.0_SHA256SUMS
|
||||
```
|
||||
|
||||
The isolated package path is:
|
||||
|
||||
```bash
|
||||
docker build -t cliphoard-builder .
|
||||
docker run --rm -v "$PWD/target:/out" cliphoard-builder
|
||||
```
|
||||
|
||||
Do not commit `target/`; retain the exact package, binary, and checksum files
|
||||
for upload.
|
||||
|
||||
## Commit and tag
|
||||
|
||||
Only commit after the gates pass:
|
||||
|
||||
```bash
|
||||
git diff --check
|
||||
git status --short
|
||||
git add Cargo.toml Cargo.lock README.md packaging/debian/control packaging/build-deb.sh src .agents RELEASING.md
|
||||
git commit -m "Release Cliphoard 1.2.0"
|
||||
git tag -a v1.2.0 -m "Release Cliphoard 1.2.0"
|
||||
```
|
||||
|
||||
Replace `1.2.0` and `v1.2.0` with the actual version.
|
||||
|
||||
## Push Git
|
||||
|
||||
Confirm the remote has not moved since the preparation pull. Never force-push:
|
||||
|
||||
```bash
|
||||
git show --stat --oneline HEAD
|
||||
git show --no-patch --decorate HEAD
|
||||
git push origin main
|
||||
git push origin v1.2.0
|
||||
```
|
||||
|
||||
If the remote changed, stop and reconcile it before pushing.
|
||||
|
||||
## Publish on Gitea
|
||||
|
||||
Pushing Git does not upload ignored `target/` files. Create a release for the
|
||||
pushed tag and attach:
|
||||
|
||||
- `target/cliphoard_1.2.0_amd64.deb`
|
||||
- `target/release/cliphoard`
|
||||
- `target/cliphoard_1.2.0_SHA256SUMS`
|
||||
|
||||
Using the Gitea web UI: open **Releases**, choose **New Release**, select
|
||||
`v1.2.0`, enter `Cliphoard 1.2.0`, paste the release notes, upload all three
|
||||
files, and publish. Include breaking changes and the plaintext-database
|
||||
deletion warning and commands from `README.md`.
|
||||
|
||||
For API automation, create a repository release-write token and set the
|
||||
installation-specific values without committing them:
|
||||
|
||||
```bash
|
||||
GITEA_URL="https://gitea.example.com"
|
||||
GITEA_OWNER="owner"
|
||||
GITEA_REPO="cliphoard"
|
||||
GITEA_TOKEN="..."
|
||||
VERSION="1.2.0"
|
||||
TAG="v${VERSION}"
|
||||
```
|
||||
|
||||
Create the release, then upload each artifact:
|
||||
|
||||
```bash
|
||||
release_json=$(curl --fail-with-body -sS \
|
||||
-H "Authorization: token ${GITEA_TOKEN}" \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d "$(jq -n --arg tag "$TAG" --arg name "Cliphoard $VERSION" --arg body "$(cat RELEASE_NOTES.md)" \
|
||||
'{tag_name:$tag,target_commitish:"main",name:$name,body:$body,draft:false,prerelease:false}')" \
|
||||
"${GITEA_URL}/api/v1/repos/${GITEA_OWNER}/${GITEA_REPO}/releases"
|
||||
release_id=$(jq -r '.id' <<<"$release_json")
|
||||
for artifact in "target/cliphoard_${VERSION}_amd64.deb" "target/release/cliphoard" "target/cliphoard_${VERSION}_SHA256SUMS"; do
|
||||
curl --fail-with-body -sS -H "Authorization: token ${GITEA_TOKEN}" \
|
||||
-F "attachment=@${artifact}" \
|
||||
"${GITEA_URL}/api/v1/repos/${GITEA_OWNER}/${GITEA_REPO}/releases/${release_id}/assets?name=$(basename "$artifact")"
|
||||
done
|
||||
```
|
||||
|
||||
Never put a token in the repository, shell history, or release notes. If no
|
||||
authenticated Gitea web session or API token is available, stop after the Git
|
||||
push and resume at publication.
|
||||
|
||||
## Final smoke check
|
||||
|
||||
On a clean machine, install the exact `.deb`, start Cliphoard, create/unlock
|
||||
the encrypted database, and check tray, popup, autostart, settings, and
|
||||
passphrase flows. Verify artifacts against `cliphoard_1.2.0_SHA256SUMS` and
|
||||
record the release URL, tag, checksums, and test results.
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
version="${CLIPHOARD_VERSION:-1.0.0}"
|
||||
version="${CLIPHOARD_VERSION:-1.2.0}"
|
||||
package_root="${PWD}/target/cliphoard-deb"
|
||||
rm -rf "$package_root"
|
||||
mkdir -p "$package_root/DEBIAN" \
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
Package: cliphoard
|
||||
Version: 1.0.0
|
||||
Version: 1.2.0
|
||||
Section: utils
|
||||
Priority: optional
|
||||
Architecture: amd64
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
use anyhow::{Context, Result};
|
||||
use serde::Deserialize;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{fs, os::unix::fs::PermissionsExt, path::PathBuf};
|
||||
|
||||
#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
|
||||
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
|
||||
#[serde(default)]
|
||||
pub struct Config {
|
||||
pub history_limit: usize,
|
||||
@@ -11,6 +11,11 @@ pub struct Config {
|
||||
pub history_retention_days: u64,
|
||||
pub global_shortcut: String,
|
||||
pub autostart: bool,
|
||||
pub always_on_top: bool,
|
||||
pub show_window_after_unlock: bool,
|
||||
pub clear_search_on_reopen: bool,
|
||||
pub inactive_opacity: f64,
|
||||
pub ignored_patterns: Vec<String>,
|
||||
pub log_level: String,
|
||||
}
|
||||
|
||||
@@ -23,6 +28,11 @@ impl Default for Config {
|
||||
history_retention_days: 30,
|
||||
global_shortcut: "Ctrl+Alt+V".into(),
|
||||
autostart: true,
|
||||
always_on_top: true,
|
||||
show_window_after_unlock: true,
|
||||
clear_search_on_reopen: false,
|
||||
inactive_opacity: 0.60,
|
||||
ignored_patterns: Vec::new(),
|
||||
log_level: "info".into(),
|
||||
}
|
||||
}
|
||||
@@ -95,6 +105,9 @@ impl Config {
|
||||
if self.history_retention_days == 0 {
|
||||
anyhow::bail!("history_retention_days must be greater than zero")
|
||||
}
|
||||
if !self.inactive_opacity.is_finite() || !(0.0..=1.0).contains(&self.inactive_opacity) {
|
||||
anyhow::bail!("inactive_opacity must be between 0 and 1")
|
||||
}
|
||||
if !matches!(
|
||||
self.log_level.to_ascii_lowercase().as_str(),
|
||||
"trace" | "debug" | "info" | "warn" | "error"
|
||||
@@ -103,6 +116,24 @@ impl Config {
|
||||
}
|
||||
validate_shortcut(&self.global_shortcut)
|
||||
}
|
||||
|
||||
pub fn save(&self) -> Result<()> {
|
||||
let path = Self::path();
|
||||
if let Some(parent) = path.parent() {
|
||||
fs::create_dir_all(parent).with_context(|| {
|
||||
format!(
|
||||
"failed to create configuration directory {}",
|
||||
parent.display()
|
||||
)
|
||||
})?;
|
||||
fs::set_permissions(parent, fs::Permissions::from_mode(0o700))?;
|
||||
}
|
||||
let text = toml::to_string_pretty(self).context("failed to serialize configuration")?;
|
||||
fs::write(&path, text)
|
||||
.with_context(|| format!("failed to write configuration {}", path.display()))?;
|
||||
fs::set_permissions(&path, fs::Permissions::from_mode(0o600))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn validate_shortcut(shortcut: &str) -> Result<()> {
|
||||
@@ -134,6 +165,9 @@ mod tests {
|
||||
assert_eq!(c.max_entry_bytes, 1_048_576);
|
||||
assert_eq!(c.history_retention_days, 30);
|
||||
assert_eq!(c.global_shortcut, "Ctrl+Alt+V");
|
||||
assert!(c.always_on_top);
|
||||
assert!(c.show_window_after_unlock);
|
||||
assert_eq!(c.inactive_opacity, 0.60);
|
||||
assert!(c.validate().is_ok());
|
||||
}
|
||||
|
||||
@@ -159,4 +193,15 @@ mod tests {
|
||||
assert!(config.validate().is_ok(), "{shortcut}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_inactive_opacity() {
|
||||
for inactive_opacity in [-0.01, 1.01, f64::NAN, f64::INFINITY] {
|
||||
let config = Config {
|
||||
inactive_opacity,
|
||||
..Config::default()
|
||||
};
|
||||
assert!(config.validate().is_err(), "{inactive_opacity}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
489
src/gui.rs
489
src/gui.rs
@@ -1,5 +1,6 @@
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
path::Path,
|
||||
rc::Rc,
|
||||
sync::{
|
||||
atomic::{AtomicBool, Ordering},
|
||||
@@ -11,8 +12,8 @@ use std::{
|
||||
use anyhow::{Context, Result};
|
||||
use gtk4::prelude::*;
|
||||
use gtk4::{
|
||||
Application, ApplicationWindow, Box as GtkBox, Button, Entry, Label, ListBox, ListBoxRow,
|
||||
Orientation, ResponseType, ScrolledWindow, TextView,
|
||||
Application, ApplicationWindow, Box as GtkBox, Button, CheckButton, Entry, Label, ListBox,
|
||||
ListBoxRow, Orientation, ResponseType, Scale, ScrolledWindow, SpinButton, TextView,
|
||||
};
|
||||
use zeroize::Zeroizing;
|
||||
|
||||
@@ -71,24 +72,9 @@ const PLAY_ICON: &str = "▶";
|
||||
const HELP_ICON: &str = "❓";
|
||||
|
||||
pub fn run(config: Config, instance: InstanceGuard, show_on_start: bool) -> Result<()> {
|
||||
let passphrase = prompt_for_passphrase()?;
|
||||
let database_path = Database::default_path();
|
||||
let migrated = Database::is_plaintext(&database_path)?;
|
||||
let database = if migrated {
|
||||
if !confirm_plaintext_migration()? {
|
||||
anyhow::bail!("plaintext history migration was declined")
|
||||
}
|
||||
Database::migrate_plaintext(&database_path, &passphrase)
|
||||
.context("could not encrypt existing Cliphoard history")?
|
||||
} else {
|
||||
Database::open_encrypted(&database_path, &passphrase)
|
||||
.context("could not unlock Cliphoard history; check the passphrase")?
|
||||
};
|
||||
if migrated && confirm_plaintext_cleanup()? {
|
||||
if let Err(error) = Database::remove_plaintext_backups(&database_path) {
|
||||
tracing::error!(%error, "failed to remove plaintext migration backup");
|
||||
}
|
||||
}
|
||||
let first_start = !database_path.exists();
|
||||
let (passphrase, database) = prompt_for_database(&database_path, first_start)?;
|
||||
drop(passphrase);
|
||||
let now = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
@@ -97,6 +83,7 @@ pub fn run(config: Config, instance: InstanceGuard, show_on_start: bool) -> Resu
|
||||
database.prune_expired(now, config.history_retention_days)?;
|
||||
database.trim_unpinned(config.history_limit)?;
|
||||
let application = Application::new(Some("io.cliphoard.Cliphoard"), Default::default());
|
||||
let show_window = show_on_start || config.show_window_after_unlock;
|
||||
let clipboard_watcher = match X11ClipboardWatcher::start() {
|
||||
Ok(watcher) => Some(watcher),
|
||||
Err(error) => {
|
||||
@@ -148,7 +135,7 @@ pub fn run(config: Config, instance: InstanceGuard, show_on_start: bool) -> Resu
|
||||
application,
|
||||
&startup_config,
|
||||
Rc::clone(&startup_state),
|
||||
show_on_start,
|
||||
show_window,
|
||||
startup_tray.clone(),
|
||||
) {
|
||||
tracing::error!(%error, "failed to build popup window");
|
||||
@@ -160,116 +147,144 @@ pub fn run(config: Config, instance: InstanceGuard, show_on_start: bool) -> Resu
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn prompt_for_passphrase() -> Result<Zeroizing<String>> {
|
||||
fn prompt_for_database(path: &Path, first_start: bool) -> Result<(Zeroizing<String>, Database)> {
|
||||
let application = Application::new(Some("io.cliphoard.Cliphoard.Unlock"), Default::default());
|
||||
let passphrase = Rc::new(RefCell::new(None));
|
||||
let result = Rc::clone(&passphrase);
|
||||
let result = Rc::new(RefCell::new(None));
|
||||
let result_for_activate = Rc::clone(&result);
|
||||
let path = path.to_path_buf();
|
||||
application.connect_activate(move |application| {
|
||||
let window = ApplicationWindow::builder()
|
||||
.application(application)
|
||||
.title("Unlock Cliphoard")
|
||||
.title(if first_start {
|
||||
"Create Cliphoard passphrase"
|
||||
} else {
|
||||
"Unlock Cliphoard"
|
||||
})
|
||||
.default_width(420)
|
||||
.default_height(140)
|
||||
.default_height(220)
|
||||
.modal(true)
|
||||
.build();
|
||||
let content = GtkBox::new(Orientation::Vertical, 10);
|
||||
content.set_margin_top(18);
|
||||
content.set_margin_bottom(18);
|
||||
content.set_margin_start(18);
|
||||
content.set_margin_end(18);
|
||||
content.append(&Label::new(Some("Enter your Cliphoard passphrase:")));
|
||||
let instructions = if first_start {
|
||||
"Create a passphrase for your encrypted clipboard history. You will need to remember it every time Cliphoard starts. Cliphoard cannot recover it."
|
||||
} else {
|
||||
"Enter the passphrase you created for Cliphoard to unlock your encrypted clipboard history."
|
||||
};
|
||||
let instruction_label = Label::new(Some(instructions));
|
||||
instruction_label.set_wrap(true);
|
||||
content.append(&instruction_label);
|
||||
let input = Entry::new();
|
||||
input.set_visibility(false);
|
||||
input.set_placeholder_text(Some("Passphrase"));
|
||||
input.set_activates_default(true);
|
||||
content.append(&input);
|
||||
let unlock = Button::with_label("Unlock");
|
||||
let confirmation = if first_start {
|
||||
let confirmation = Entry::new();
|
||||
confirmation.set_visibility(false);
|
||||
confirmation.set_placeholder_text(Some("Confirm passphrase"));
|
||||
confirmation.set_activates_default(true);
|
||||
content.append(&confirmation);
|
||||
Some(confirmation)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let error_label = Label::new(None);
|
||||
error_label.set_wrap(true);
|
||||
error_label.set_selectable(true);
|
||||
content.append(&error_label);
|
||||
let unlock = Button::with_label(if first_start {
|
||||
"Create passphrase"
|
||||
} else {
|
||||
"Unlock"
|
||||
});
|
||||
unlock.set_receives_default(true);
|
||||
content.append(&unlock);
|
||||
let cancel = Button::with_label("Cancel");
|
||||
content.append(&cancel);
|
||||
window.set_child(Some(&content));
|
||||
window.set_default_widget(Some(&unlock));
|
||||
let application_for_unlock = application.clone();
|
||||
let result_for_unlock = Rc::clone(&result);
|
||||
let result_for_unlock = Rc::clone(&result_for_activate);
|
||||
let input_for_unlock = input.clone();
|
||||
let confirmation_for_unlock = confirmation.clone();
|
||||
let error_for_unlock = error_label.clone();
|
||||
let path_for_unlock = path.clone();
|
||||
let window_for_unlock = window.clone();
|
||||
unlock.connect_clicked(move |_| {
|
||||
let value = input_for_unlock.text().to_string();
|
||||
if !value.is_empty() {
|
||||
*result_for_unlock.borrow_mut() = Some(value);
|
||||
application_for_unlock.quit();
|
||||
if value.is_empty() {
|
||||
error_for_unlock.set_text("Enter a passphrase to continue, or choose Cancel to close.");
|
||||
} else if confirmation_for_unlock
|
||||
.as_ref()
|
||||
.is_some_and(|confirmation| confirmation.text().as_str() != value)
|
||||
{
|
||||
error_for_unlock
|
||||
.set_text("The passphrases do not match. Check both fields and try again.");
|
||||
} else {
|
||||
match Database::open_encrypted(&path_for_unlock, &value) {
|
||||
Ok(database) => {
|
||||
*result_for_unlock.borrow_mut() =
|
||||
Some((Zeroizing::new(value), database));
|
||||
window_for_unlock.set_visible(false);
|
||||
application_for_unlock.quit();
|
||||
}
|
||||
Err(open_error) => {
|
||||
let detail = open_error.to_string();
|
||||
if detail.contains("plaintext databases are no longer supported") {
|
||||
error_for_unlock.set_text("This database is plaintext and cannot be opened by Cliphoard. Delete or replace it with an encrypted Cliphoard database, then try again.");
|
||||
} else {
|
||||
error_for_unlock.set_text(&format!(
|
||||
"Could not unlock Cliphoard: {detail}\n\nCheck your passphrase and try again."
|
||||
));
|
||||
}
|
||||
input_for_unlock.set_text("");
|
||||
if let Some(confirmation) = confirmation_for_unlock.as_ref() {
|
||||
confirmation.set_text("");
|
||||
}
|
||||
input_for_unlock.grab_focus();
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
let application_for_cancel = application.clone();
|
||||
let window_for_cancel = window.clone();
|
||||
cancel.connect_clicked(move |_| {
|
||||
window_for_cancel.set_visible(false);
|
||||
application_for_cancel.quit();
|
||||
});
|
||||
let application_for_close = application.clone();
|
||||
let window_for_close = window.clone();
|
||||
window.connect_close_request(move |_| {
|
||||
window_for_close.set_visible(false);
|
||||
application_for_close.quit();
|
||||
glib::Propagation::Stop
|
||||
});
|
||||
let application_for_escape = application.clone();
|
||||
let window_for_escape = window.clone();
|
||||
let keys = gtk4::EventControllerKey::new();
|
||||
keys.connect_key_pressed(move |_, key, _, _| {
|
||||
if key == gtk4::gdk::Key::Escape {
|
||||
window_for_escape.set_visible(false);
|
||||
application_for_escape.quit();
|
||||
glib::Propagation::Stop
|
||||
} else {
|
||||
glib::Propagation::Proceed
|
||||
}
|
||||
});
|
||||
window.add_controller(keys);
|
||||
window.present();
|
||||
input.grab_focus();
|
||||
});
|
||||
application.run_with_args(&["cliphoard-unlock"]);
|
||||
let result = passphrase
|
||||
let result = result
|
||||
.borrow_mut()
|
||||
.take()
|
||||
.context("Cliphoard unlock was cancelled");
|
||||
result.map(Zeroizing::new)
|
||||
}
|
||||
|
||||
fn confirm_plaintext_migration() -> Result<bool> {
|
||||
let application = Application::new(Some("io.cliphoard.Cliphoard.Migrate"), Default::default());
|
||||
let migrate = Rc::new(RefCell::new(false));
|
||||
let result = Rc::clone(&migrate);
|
||||
application.connect_activate(move |application| {
|
||||
let dialog = gtk4::Dialog::builder()
|
||||
.application(application)
|
||||
.title("Encrypt existing Cliphoard history?")
|
||||
.modal(true)
|
||||
.default_width(520)
|
||||
.build();
|
||||
dialog.content_area().append(&Label::new(Some(
|
||||
"An unencrypted Cliphoard history was found. Migrate it to an encrypted database? The original will be retained as a backup until you remove it.",
|
||||
)));
|
||||
dialog.add_button("Cancel", ResponseType::Cancel);
|
||||
dialog.add_button("Migrate and encrypt", ResponseType::Accept);
|
||||
let result_for_response = Rc::clone(&result);
|
||||
let application_for_response = application.clone();
|
||||
dialog.connect_response(move |dialog, response| {
|
||||
*result_for_response.borrow_mut() = response == ResponseType::Accept;
|
||||
dialog.close();
|
||||
application_for_response.quit();
|
||||
});
|
||||
dialog.present();
|
||||
});
|
||||
application.run_with_args(&["cliphoard-migrate"]);
|
||||
let result = *migrate.borrow();
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn confirm_plaintext_cleanup() -> Result<bool> {
|
||||
let application = Application::new(Some("io.cliphoard.Cliphoard.Cleanup"), Default::default());
|
||||
let remove = Rc::new(RefCell::new(false));
|
||||
let result = Rc::clone(&remove);
|
||||
application.connect_activate(move |application| {
|
||||
let dialog = gtk4::Dialog::builder()
|
||||
.application(application)
|
||||
.title("Remove plaintext backup?")
|
||||
.modal(true)
|
||||
.default_width(520)
|
||||
.build();
|
||||
dialog.content_area().append(&Label::new(Some(
|
||||
"The encrypted history is ready. Remove the retained plaintext migration backup now? This removes the file from disk but cannot erase copies in backups or snapshots.",
|
||||
)));
|
||||
dialog.add_button("Keep backup", ResponseType::Cancel);
|
||||
dialog.add_button("Remove plaintext backup", ResponseType::Accept);
|
||||
let result_for_response = Rc::clone(&result);
|
||||
let application_for_response = application.clone();
|
||||
dialog.connect_response(move |dialog, response| {
|
||||
*result_for_response.borrow_mut() = response == ResponseType::Accept;
|
||||
dialog.close();
|
||||
application_for_response.quit();
|
||||
});
|
||||
dialog.present();
|
||||
});
|
||||
application.run_with_args(&["cliphoard-cleanup"]);
|
||||
let result = *remove.borrow();
|
||||
Ok(result)
|
||||
result
|
||||
}
|
||||
|
||||
fn build_window(
|
||||
@@ -307,6 +322,8 @@ fn build_window(
|
||||
let clear_button = Button::with_label(&format!("{CLEAR_ICON} Clear History"));
|
||||
let pause_button = Button::with_label(&format!("{PAUSE_ICON} Pause Recording"));
|
||||
let help_button = Button::with_label(&format!("{HELP_ICON} Help"));
|
||||
let change_passphrase_button = Button::with_label("Change passphrase");
|
||||
let settings_button = Button::with_label("Settings");
|
||||
let row_actions = RowActions {
|
||||
copy: copy_button.clone(),
|
||||
paste: paste_button.clone(),
|
||||
@@ -330,6 +347,8 @@ fn build_window(
|
||||
actions.append(&clear_button);
|
||||
actions.append(&pause_button);
|
||||
actions.append(&help_button);
|
||||
actions.append(&change_passphrase_button);
|
||||
actions.append(&settings_button);
|
||||
root.append(&actions);
|
||||
root.append(&status);
|
||||
let window = ApplicationWindow::builder()
|
||||
@@ -339,6 +358,10 @@ fn build_window(
|
||||
.default_height(420)
|
||||
.child(&root)
|
||||
.build();
|
||||
let inactive_opacity = Rc::new(std::cell::Cell::new(config.inactive_opacity));
|
||||
let always_on_top = Rc::new(std::cell::Cell::new(config.always_on_top));
|
||||
let clear_search_on_reopen = Rc::new(std::cell::Cell::new(config.clear_search_on_reopen));
|
||||
let runtime_config = Rc::new(RefCell::new(config.clone()));
|
||||
let css = gtk4::CssProvider::new();
|
||||
css.load_from_data(
|
||||
"button.paused { background-color: #f3a6a6; color: #3d0000; font-weight: bold; } row.pinned { background-color: rgba(79, 107, 237, 0.10); border-radius: 6px; }",
|
||||
@@ -351,20 +374,40 @@ fn build_window(
|
||||
);
|
||||
}
|
||||
let window_for_opacity = window.clone();
|
||||
let inactive_opacity_for_realize = Rc::clone(&inactive_opacity);
|
||||
let always_on_top_for_realize = Rc::clone(&always_on_top);
|
||||
window.connect_realize(move |_| {
|
||||
crate::platform::linux::x11_window::configure(&window_for_opacity);
|
||||
crate::platform::linux::x11_window::configure(
|
||||
&window_for_opacity,
|
||||
inactive_opacity_for_realize.get(),
|
||||
always_on_top_for_realize.get(),
|
||||
);
|
||||
});
|
||||
let window_for_above = window.clone();
|
||||
let inactive_opacity_for_map = Rc::clone(&inactive_opacity);
|
||||
let always_on_top_for_map = Rc::clone(&always_on_top);
|
||||
window.connect_map(move |_| {
|
||||
crate::platform::linux::x11_window::configure(&window_for_above);
|
||||
crate::platform::linux::x11_window::configure(
|
||||
&window_for_above,
|
||||
inactive_opacity_for_map.get(),
|
||||
always_on_top_for_map.get(),
|
||||
);
|
||||
});
|
||||
let window_for_opacity = window.clone();
|
||||
let inactive_opacity_for_active = Rc::clone(&inactive_opacity);
|
||||
window.connect_is_active_notify(move |_| {
|
||||
crate::platform::linux::x11_window::set_active_opacity(&window_for_opacity);
|
||||
crate::platform::linux::x11_window::set_active_opacity(
|
||||
&window_for_opacity,
|
||||
inactive_opacity_for_active.get(),
|
||||
);
|
||||
});
|
||||
let window_for_opacity = window.clone();
|
||||
let inactive_opacity_for_timeout = Rc::clone(&inactive_opacity);
|
||||
glib::timeout_add_local(std::time::Duration::from_millis(100), move || {
|
||||
crate::platform::linux::x11_window::set_active_opacity(&window_for_opacity);
|
||||
crate::platform::linux::x11_window::set_active_opacity(
|
||||
&window_for_opacity,
|
||||
inactive_opacity_for_timeout.get(),
|
||||
);
|
||||
glib::ControlFlow::Continue
|
||||
});
|
||||
let recording = state.borrow().recording;
|
||||
@@ -670,6 +713,34 @@ fn build_window(
|
||||
let shortcut_for_help = config.global_shortcut.clone();
|
||||
help_button.connect_clicked(move |_| show_help(&window_for_help, &shortcut_for_help));
|
||||
|
||||
let window_for_passphrase = window.clone();
|
||||
let state_for_passphrase = Rc::clone(&state);
|
||||
let status_for_passphrase = status.clone();
|
||||
change_passphrase_button.connect_clicked(move |_| {
|
||||
change_passphrase(
|
||||
&window_for_passphrase,
|
||||
Rc::clone(&state_for_passphrase),
|
||||
&status_for_passphrase,
|
||||
);
|
||||
});
|
||||
|
||||
let window_for_settings = window.clone();
|
||||
let config_for_settings = Rc::clone(&runtime_config);
|
||||
let status_for_settings = status.clone();
|
||||
let inactive_opacity_for_settings = Rc::clone(&inactive_opacity);
|
||||
let always_on_top_for_settings = Rc::clone(&always_on_top);
|
||||
let clear_search_for_settings = Rc::clone(&clear_search_on_reopen);
|
||||
settings_button.connect_clicked(move |_| {
|
||||
show_settings(
|
||||
&window_for_settings,
|
||||
Rc::clone(&config_for_settings),
|
||||
&status_for_settings,
|
||||
Rc::clone(&inactive_opacity_for_settings),
|
||||
Rc::clone(&always_on_top_for_settings),
|
||||
Rc::clone(&clear_search_for_settings),
|
||||
);
|
||||
});
|
||||
|
||||
let state_for_clear = Rc::clone(&state);
|
||||
let cleared_list = list.clone();
|
||||
let status_for_clear = status.clone();
|
||||
@@ -724,7 +795,7 @@ fn build_window(
|
||||
|
||||
let state_for_watch = Rc::clone(&state);
|
||||
let list_for_watch = list.clone();
|
||||
let config_for_watch = config.clone();
|
||||
let config_for_watch = Rc::clone(&runtime_config);
|
||||
let row_actions_for_watch = row_actions.clone();
|
||||
let window_for_events = window.clone();
|
||||
let search_for_events = search_box.clone();
|
||||
@@ -740,6 +811,9 @@ fn build_window(
|
||||
if window_for_events.is_visible() {
|
||||
window_for_events.set_visible(false);
|
||||
} else {
|
||||
if clear_search_on_reopen.get() {
|
||||
search_for_events.set_text("");
|
||||
}
|
||||
request_focus(&mut state);
|
||||
window_for_events.present();
|
||||
search_for_events.grab_focus();
|
||||
@@ -749,6 +823,9 @@ fn build_window(
|
||||
if window_for_events.is_visible() {
|
||||
window_for_events.set_visible(false);
|
||||
} else {
|
||||
if clear_search_on_reopen.get() {
|
||||
search_for_events.set_text("");
|
||||
}
|
||||
request_focus(&mut state);
|
||||
window_for_events.present();
|
||||
search_for_events.grab_focus();
|
||||
@@ -766,7 +843,7 @@ fn build_window(
|
||||
&mut state,
|
||||
result,
|
||||
&list_for_watch,
|
||||
&config_for_watch,
|
||||
&config_for_watch.borrow(),
|
||||
&row_actions_for_watch,
|
||||
);
|
||||
}
|
||||
@@ -852,6 +929,14 @@ fn process_clipboard_result(
|
||||
&& !content.trim().is_empty()
|
||||
&& content.len() <= config.max_entry_bytes =>
|
||||
{
|
||||
if config
|
||||
.ignored_patterns
|
||||
.iter()
|
||||
.any(|pattern| content.contains(pattern))
|
||||
{
|
||||
tracing::debug!("ignored clipboard entry matching a privacy pattern");
|
||||
return;
|
||||
}
|
||||
match state.database.upsert_content(&content, now()) {
|
||||
Ok(entry) => {
|
||||
if let Err(error) = state.database.trim_unpinned(config.history_limit) {
|
||||
@@ -1055,6 +1140,207 @@ fn show_text_dialog(window: &ApplicationWindow, title: &str, content: &str) {
|
||||
dialog.present();
|
||||
}
|
||||
|
||||
fn show_settings(
|
||||
window: &ApplicationWindow,
|
||||
config: Rc<RefCell<Config>>,
|
||||
status: &Label,
|
||||
inactive_opacity: Rc<std::cell::Cell<f64>>,
|
||||
always_on_top: Rc<std::cell::Cell<bool>>,
|
||||
clear_search_on_reopen: Rc<std::cell::Cell<bool>>,
|
||||
) {
|
||||
let current_config = config.borrow().clone();
|
||||
let dialog = gtk4::Dialog::builder()
|
||||
.transient_for(window)
|
||||
.modal(true)
|
||||
.title("Cliphoard settings")
|
||||
.default_width(460)
|
||||
.build();
|
||||
let content = GtkBox::new(Orientation::Vertical, 10);
|
||||
content.set_margin_top(18);
|
||||
content.set_margin_bottom(18);
|
||||
content.set_margin_start(18);
|
||||
content.set_margin_end(18);
|
||||
let show_window = CheckButton::with_label("Show the Cliphoard window after unlock");
|
||||
show_window.set_active(current_config.show_window_after_unlock);
|
||||
content.append(&show_window);
|
||||
let keep_on_top = CheckButton::with_label("Always keep the popup in the foreground");
|
||||
keep_on_top.set_active(always_on_top.get());
|
||||
content.append(&keep_on_top);
|
||||
let clear_search = CheckButton::with_label("Clear the search field when reopening");
|
||||
clear_search.set_active(clear_search_on_reopen.get());
|
||||
content.append(&clear_search);
|
||||
let explanation = Label::new(Some(
|
||||
"When disabled, Cliphoard starts in the tray after you enter the passphrase. You can still open the window with the global shortcut. Shortcut, autostart, and history-limit changes apply after restart.",
|
||||
));
|
||||
explanation.set_wrap(true);
|
||||
content.append(&explanation);
|
||||
let opacity_label = Label::new(Some("Opacity when unfocused"));
|
||||
content.append(&opacity_label);
|
||||
let opacity = Scale::with_range(Orientation::Horizontal, 0.0, 100.0, 1.0);
|
||||
opacity.set_value(inactive_opacity.get() * 100.0);
|
||||
opacity.set_digits(0);
|
||||
opacity.set_draw_value(true);
|
||||
opacity.set_hexpand(true);
|
||||
opacity.set_tooltip_text(Some("How transparent the popup is when it is not focused"));
|
||||
content.append(&opacity);
|
||||
let shortcut_label = Label::new(Some("Global shortcut (applies after restart)"));
|
||||
content.append(&shortcut_label);
|
||||
let shortcut = Entry::new();
|
||||
shortcut.set_text(¤t_config.global_shortcut);
|
||||
shortcut.set_tooltip_text(Some("For example: Ctrl+Alt+V"));
|
||||
content.append(&shortcut);
|
||||
let autostart = CheckButton::with_label("Start Cliphoard automatically when I log in");
|
||||
autostart.set_active(current_config.autostart);
|
||||
content.append(&autostart);
|
||||
let history_limit_label = Label::new(Some("Maximum unpinned history entries"));
|
||||
content.append(&history_limit_label);
|
||||
let history_limit = SpinButton::with_range(1.0, 10_000.0, 1.0);
|
||||
history_limit.set_value(current_config.history_limit as f64);
|
||||
content.append(&history_limit);
|
||||
let pinned_limit_label = Label::new(Some("Maximum pinned entries"));
|
||||
content.append(&pinned_limit_label);
|
||||
let pinned_limit = SpinButton::with_range(1.0, 10_000.0, 1.0);
|
||||
pinned_limit.set_value(current_config.pinned_limit as f64);
|
||||
content.append(&pinned_limit);
|
||||
let retention_label = Label::new(Some("Remove unpinned entries older than (days)"));
|
||||
content.append(&retention_label);
|
||||
let retention_days = SpinButton::with_range(1.0, 3_650.0, 1.0);
|
||||
retention_days.set_value(current_config.history_retention_days as f64);
|
||||
content.append(&retention_days);
|
||||
let ignored_label = Label::new(Some(
|
||||
"Ignore clipboard entries containing (comma-separated)",
|
||||
));
|
||||
content.append(&ignored_label);
|
||||
let ignored_patterns = Entry::new();
|
||||
ignored_patterns.set_text(¤t_config.ignored_patterns.join(", "));
|
||||
ignored_patterns.set_tooltip_text(Some("For example: password, secret-token"));
|
||||
content.append(&ignored_patterns);
|
||||
dialog.content_area().append(&content);
|
||||
dialog.add_button("Cancel", ResponseType::Cancel);
|
||||
dialog.add_button("Save", ResponseType::Accept);
|
||||
let config_for_response = Rc::clone(&config);
|
||||
let status_for_response = status.clone();
|
||||
let window_for_response = window.clone();
|
||||
dialog.connect_response(move |dialog, response| {
|
||||
if response == ResponseType::Accept {
|
||||
let mut updated_config = config_for_response.borrow().clone();
|
||||
updated_config.show_window_after_unlock = show_window.is_active();
|
||||
updated_config.always_on_top = keep_on_top.is_active();
|
||||
updated_config.clear_search_on_reopen = clear_search.is_active();
|
||||
updated_config.inactive_opacity = opacity.value() / 100.0;
|
||||
updated_config.global_shortcut = shortcut.text().to_string();
|
||||
updated_config.autostart = autostart.is_active();
|
||||
updated_config.history_limit = history_limit.value_as_int() as usize;
|
||||
updated_config.pinned_limit = pinned_limit.value_as_int() as usize;
|
||||
updated_config.history_retention_days = retention_days.value_as_int() as u64;
|
||||
updated_config.ignored_patterns = ignored_patterns
|
||||
.text()
|
||||
.split(',')
|
||||
.map(str::trim)
|
||||
.filter(|pattern| !pattern.is_empty())
|
||||
.map(str::to_owned)
|
||||
.collect();
|
||||
if let Err(error) = updated_config.validate() {
|
||||
set_status(
|
||||
&status_for_response,
|
||||
&format!("Could not save settings: {error}"),
|
||||
);
|
||||
return;
|
||||
}
|
||||
match updated_config.save() {
|
||||
Ok(()) => {
|
||||
*config_for_response.borrow_mut() = updated_config.clone();
|
||||
inactive_opacity.set(updated_config.inactive_opacity);
|
||||
always_on_top.set(updated_config.always_on_top);
|
||||
clear_search_on_reopen.set(updated_config.clear_search_on_reopen);
|
||||
crate::platform::linux::x11_window::set_active_opacity(
|
||||
&window_for_response,
|
||||
updated_config.inactive_opacity,
|
||||
);
|
||||
crate::platform::linux::x11_window::set_always_on_top(
|
||||
&window_for_response,
|
||||
updated_config.always_on_top,
|
||||
);
|
||||
set_status(&status_for_response, "Settings saved");
|
||||
}
|
||||
Err(error) => set_status(
|
||||
&status_for_response,
|
||||
&format!("Could not save settings: {error}"),
|
||||
),
|
||||
}
|
||||
}
|
||||
dialog.close();
|
||||
});
|
||||
dialog.present();
|
||||
}
|
||||
|
||||
fn change_passphrase(window: &ApplicationWindow, state: Rc<RefCell<UiState>>, status: &Label) {
|
||||
let dialog = gtk4::Dialog::builder()
|
||||
.transient_for(window)
|
||||
.modal(true)
|
||||
.title("Change Cliphoard passphrase")
|
||||
.default_width(460)
|
||||
.build();
|
||||
let content = GtkBox::new(Orientation::Vertical, 10);
|
||||
content.set_margin_top(18);
|
||||
content.set_margin_bottom(18);
|
||||
content.set_margin_start(18);
|
||||
content.set_margin_end(18);
|
||||
let explanation = Label::new(Some(
|
||||
"Choose a new passphrase and remember it. You will need it the next time Cliphoard starts.",
|
||||
));
|
||||
explanation.set_wrap(true);
|
||||
content.append(&explanation);
|
||||
let new_passphrase = Entry::new();
|
||||
new_passphrase.set_visibility(false);
|
||||
new_passphrase.set_placeholder_text(Some("New passphrase"));
|
||||
content.append(&new_passphrase);
|
||||
let confirmation = Entry::new();
|
||||
confirmation.set_visibility(false);
|
||||
confirmation.set_placeholder_text(Some("Confirm new passphrase"));
|
||||
content.append(&confirmation);
|
||||
let error = Label::new(None);
|
||||
error.set_wrap(true);
|
||||
content.append(&error);
|
||||
dialog.content_area().append(&content);
|
||||
dialog.add_button("Cancel", ResponseType::Cancel);
|
||||
dialog.add_button("Change passphrase", ResponseType::Accept);
|
||||
let new_passphrase_for_response = new_passphrase.clone();
|
||||
let confirmation_for_response = confirmation.clone();
|
||||
let state_for_response = state;
|
||||
let status_for_response = status.clone();
|
||||
dialog.connect_response(move |dialog, response| {
|
||||
if response != ResponseType::Accept {
|
||||
dialog.close();
|
||||
return;
|
||||
}
|
||||
let value = new_passphrase_for_response.text().to_string();
|
||||
if value.is_empty() {
|
||||
error.set_text("Enter a new passphrase, or choose Cancel to close.");
|
||||
return;
|
||||
}
|
||||
if confirmation_for_response.text().as_str() != value {
|
||||
error.set_text("The passphrases do not match. Check both fields and try again.");
|
||||
return;
|
||||
}
|
||||
match state_for_response
|
||||
.borrow()
|
||||
.database
|
||||
.change_passphrase(&value)
|
||||
{
|
||||
Ok(()) => {
|
||||
set_status(&status_for_response, "Passphrase changed successfully");
|
||||
dialog.close();
|
||||
}
|
||||
Err(error_value) => {
|
||||
error.set_text(&format!("Could not change passphrase: {error_value}"));
|
||||
}
|
||||
}
|
||||
});
|
||||
dialog.present();
|
||||
new_passphrase.grab_focus();
|
||||
}
|
||||
|
||||
fn show_help(window: &ApplicationWindow, shortcut: &str) {
|
||||
let help = format!(
|
||||
"Cliphoard help\n\n\
|
||||
@@ -1072,8 +1358,9 @@ Search\n\
|
||||
Search is case-insensitive and ranks exact, prefix, substring, then fuzzy matches.\n\
|
||||
Pinned entries stay above unpinned results; matching text is highlighted.\n\n\
|
||||
Security\n\
|
||||
Enter the passphrase at startup. It is never stored. Legacy plaintext history is\n\
|
||||
migrated only after confirmation, then its backup can be removed.\n\n\
|
||||
On first start, create a passphrase and remember it. Enter it at every startup;\n\
|
||||
it is never stored and Cliphoard cannot recover it. Plaintext databases are not\n\
|
||||
opened or migrated.\n\n\
|
||||
Installation and removal\n\
|
||||
See README.md for the exact source-build, .deb, uninstall, autostart, and data\n\
|
||||
removal commands. The tray menu includes Quit Cliphoard.\n",
|
||||
|
||||
@@ -9,10 +9,13 @@ use x11rb::{
|
||||
};
|
||||
|
||||
const ACTIVE_OPACITY: f64 = 1.0;
|
||||
const INACTIVE_OPACITY: f64 = 0.60;
|
||||
|
||||
pub fn configure(window: &ApplicationWindow) {
|
||||
set_active_opacity(window);
|
||||
pub fn configure(window: &ApplicationWindow, inactive_opacity: f64, always_on_top: bool) {
|
||||
set_active_opacity(window, inactive_opacity);
|
||||
set_always_on_top(window, always_on_top);
|
||||
}
|
||||
|
||||
pub fn set_always_on_top(window: &ApplicationWindow, always_on_top: bool) {
|
||||
let Some(surface) = window.surface() else {
|
||||
return;
|
||||
};
|
||||
@@ -37,15 +40,6 @@ pub fn configure(window: &ApplicationWindow) {
|
||||
let Ok(above) = above_cookie.reply() else {
|
||||
return;
|
||||
};
|
||||
if let Err(error) = connection.change_property32(
|
||||
x11rb::protocol::xproto::PropMode::REPLACE,
|
||||
xid,
|
||||
state.atom,
|
||||
x11rb::protocol::xproto::AtomEnum::ATOM,
|
||||
&[above.atom],
|
||||
) {
|
||||
tracing::warn!(%error, "could not mark popup as always on top");
|
||||
}
|
||||
let root = connection.setup().roots[0].root;
|
||||
let event = ClientMessageEvent {
|
||||
response_type: CLIENT_MESSAGE_EVENT,
|
||||
@@ -53,7 +47,7 @@ pub fn configure(window: &ApplicationWindow) {
|
||||
sequence: 0,
|
||||
window: xid,
|
||||
type_: state.atom,
|
||||
data: ClientMessageData::from([1, above.atom, 0, 0, 0]),
|
||||
data: ClientMessageData::from([if always_on_top { 1 } else { 0 }, above.atom, 0, 0, 0]),
|
||||
};
|
||||
match connection.send_event(
|
||||
false,
|
||||
@@ -63,15 +57,17 @@ pub fn configure(window: &ApplicationWindow) {
|
||||
) {
|
||||
Ok(cookie) => {
|
||||
if let Err(error) = cookie.check() {
|
||||
tracing::debug!(%error, "window manager rejected always-on-top request");
|
||||
tracing::debug!(%error, always_on_top, "window manager rejected always-on-top request");
|
||||
}
|
||||
}
|
||||
Err(error) => tracing::debug!(%error, "could not send always-on-top request"),
|
||||
Err(error) => {
|
||||
tracing::debug!(%error, always_on_top, "could not send always-on-top request")
|
||||
}
|
||||
}
|
||||
let _ = connection.flush();
|
||||
}
|
||||
|
||||
pub fn set_active_opacity(window: &ApplicationWindow) {
|
||||
pub fn set_active_opacity(window: &ApplicationWindow, inactive_opacity: f64) {
|
||||
let Some(surface) = window.surface() else {
|
||||
return;
|
||||
};
|
||||
@@ -90,7 +86,7 @@ pub fn set_active_opacity(window: &ApplicationWindow) {
|
||||
let value = if window.is_active() {
|
||||
ACTIVE_OPACITY
|
||||
} else {
|
||||
INACTIVE_OPACITY
|
||||
inactive_opacity
|
||||
};
|
||||
let scaled = (value * u32::MAX as f64).round() as u32;
|
||||
if let Err(error) = connection.change_property32(
|
||||
|
||||
@@ -33,9 +33,24 @@ impl Database {
|
||||
!passphrase.is_empty(),
|
||||
"database passphrase must not be empty"
|
||||
);
|
||||
let path = path.as_ref();
|
||||
anyhow::ensure!(
|
||||
!Self::is_plaintext(path)?,
|
||||
"a plaintext database was found; plaintext databases are no longer supported"
|
||||
);
|
||||
Self::open_internal(path, Some(passphrase))
|
||||
}
|
||||
|
||||
pub fn change_passphrase(&self, new_passphrase: &str) -> Result<()> {
|
||||
anyhow::ensure!(
|
||||
!new_passphrase.is_empty(),
|
||||
"database passphrase must not be empty"
|
||||
);
|
||||
self.connection
|
||||
.pragma_update(None, "rekey", new_passphrase)
|
||||
.context("failed to change database passphrase")
|
||||
}
|
||||
|
||||
pub fn is_plaintext(path: impl AsRef<Path>) -> Result<bool> {
|
||||
let path = path.as_ref();
|
||||
if !path.exists() {
|
||||
@@ -55,100 +70,6 @@ impl Database {
|
||||
Ok(bytes == header.len() && &header == Self::SQLITE_HEADER)
|
||||
}
|
||||
|
||||
pub fn migrate_plaintext(path: impl AsRef<Path>, passphrase: &str) -> Result<Self> {
|
||||
let path = path.as_ref().to_path_buf();
|
||||
anyhow::ensure!(
|
||||
Self::is_plaintext(&path)?,
|
||||
"database is not plaintext SQLite"
|
||||
);
|
||||
let metadata = std::fs::symlink_metadata(&path)?;
|
||||
anyhow::ensure!(
|
||||
!metadata.file_type().is_symlink(),
|
||||
"refusing to migrate symlinked database {}",
|
||||
path.display()
|
||||
);
|
||||
let source = Connection::open(&path)
|
||||
.with_context(|| format!("failed to open plaintext history {}", path.display()))?;
|
||||
let mut statement = source.prepare(
|
||||
"SELECT id, content, created_at, last_used_at, pinned FROM entries ORDER BY id",
|
||||
)?;
|
||||
let entries = statement
|
||||
.query_map([], |row| {
|
||||
Ok(Entry {
|
||||
id: row.get(0)?,
|
||||
content: row.get(1)?,
|
||||
content_hash: content_hash(&row.get::<_, String>(1)?),
|
||||
created_at: row.get(2)?,
|
||||
last_used_at: row.get(3)?,
|
||||
pinned: row.get::<_, i64>(4)? != 0,
|
||||
})
|
||||
})?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
drop(statement);
|
||||
drop(source);
|
||||
|
||||
let temporary = path.with_extension(format!("db.migrating-{}", std::process::id()));
|
||||
anyhow::ensure!(
|
||||
!temporary.exists(),
|
||||
"database migration is already in progress"
|
||||
);
|
||||
let encrypted = Self::open_encrypted(&temporary, passphrase)?;
|
||||
for entry in entries {
|
||||
encrypted.connection.execute(
|
||||
"INSERT OR IGNORE INTO entries(id, content, content_hash, created_at, last_used_at, pinned) VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
|
||||
params![entry.id, entry.content, entry.content_hash, entry.created_at, entry.last_used_at, entry.pinned as i64],
|
||||
)?;
|
||||
}
|
||||
drop(encrypted);
|
||||
|
||||
let mut backup = path.with_extension("db.plaintext-backup");
|
||||
let mut suffix = 1;
|
||||
while backup.exists() {
|
||||
backup = path.with_extension(format!("db.plaintext-backup.{suffix}"));
|
||||
suffix += 1;
|
||||
}
|
||||
std::fs::rename(&path, &backup).with_context(|| {
|
||||
format!(
|
||||
"failed to preserve plaintext database as {}",
|
||||
backup.display()
|
||||
)
|
||||
})?;
|
||||
if let Err(error) = std::fs::rename(&temporary, &path) {
|
||||
let _ = std::fs::rename(&backup, &path);
|
||||
let _ = std::fs::remove_file(&temporary);
|
||||
return Err(error).with_context(|| {
|
||||
format!("failed to install encrypted database {}", path.display())
|
||||
});
|
||||
}
|
||||
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))?;
|
||||
Self::open_encrypted(path, passphrase)
|
||||
}
|
||||
|
||||
pub fn remove_plaintext_backups(path: impl AsRef<Path>) -> Result<usize> {
|
||||
let path = path.as_ref();
|
||||
let parent = path
|
||||
.parent()
|
||||
.context("database path has no parent directory")?;
|
||||
let filename = path
|
||||
.file_name()
|
||||
.context("database path has no filename")?
|
||||
.to_string_lossy();
|
||||
let prefix = format!("{filename}.plaintext-backup");
|
||||
let mut removed = 0;
|
||||
for entry in std::fs::read_dir(parent)? {
|
||||
let entry = entry?;
|
||||
let name = entry.file_name();
|
||||
let name = name.to_string_lossy();
|
||||
if (name == prefix || name.starts_with(&format!("{prefix}.")))
|
||||
&& entry.file_type()?.is_file()
|
||||
{
|
||||
std::fs::remove_file(entry.path())?;
|
||||
removed += 1;
|
||||
}
|
||||
}
|
||||
Ok(removed)
|
||||
}
|
||||
|
||||
fn open_internal(path: impl AsRef<Path>, passphrase: Option<&str>) -> Result<Self> {
|
||||
let path = path.as_ref().to_path_buf();
|
||||
if let Ok(metadata) = std::fs::symlink_metadata(&path) {
|
||||
@@ -451,9 +372,28 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plaintext_migration_preserves_history_and_keeps_a_backup() {
|
||||
fn encrypted_database_can_change_passphrase() {
|
||||
let path = std::env::temp_dir().join(format!(
|
||||
"cliphoard-migration-{}-{}.db",
|
||||
"cliphoard-rekey-{}-{}.db",
|
||||
std::process::id(),
|
||||
std::thread::current().name().unwrap_or("test")
|
||||
));
|
||||
let _ = std::fs::remove_file(&path);
|
||||
let db = Database::open_encrypted(&path, "old passphrase").unwrap();
|
||||
db.upsert_content("rekey test payload", 1).unwrap();
|
||||
db.change_passphrase("new passphrase").unwrap();
|
||||
drop(db);
|
||||
|
||||
assert!(Database::open_encrypted(&path, "old passphrase").is_err());
|
||||
let db = Database::open_encrypted(&path, "new passphrase").unwrap();
|
||||
assert_eq!(db.load_entries().unwrap()[0].content, "rekey test payload");
|
||||
let _ = std::fs::remove_file(path);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn encrypted_open_rejects_plaintext_databases() {
|
||||
let path = std::env::temp_dir().join(format!(
|
||||
"cliphoard-plaintext-{}-{}.db",
|
||||
std::process::id(),
|
||||
std::thread::current().name().unwrap_or("test")
|
||||
));
|
||||
@@ -462,26 +402,15 @@ mod tests {
|
||||
source
|
||||
.execute_batch(include_str!("../../migrations/001_initial.sql"))
|
||||
.unwrap();
|
||||
source
|
||||
.execute(
|
||||
"INSERT INTO entries(content, content_hash, created_at, last_used_at, pinned) VALUES (?1, ?2, ?3, ?4, ?5)",
|
||||
params!["migrate me", content_hash("migrate me"), 10_i64, 20_i64, 1_i64],
|
||||
)
|
||||
.unwrap();
|
||||
drop(source);
|
||||
|
||||
let db = Database::migrate_plaintext(&path, "migration passphrase").unwrap();
|
||||
let entries = db.load_entries().unwrap();
|
||||
assert_eq!(entries.len(), 1);
|
||||
assert_eq!(entries[0].content, "migrate me");
|
||||
assert_eq!(entries[0].created_at, 10);
|
||||
assert!(entries[0].pinned);
|
||||
drop(db);
|
||||
assert!(!Database::is_plaintext(&path).unwrap());
|
||||
let backup = path.with_extension("db.plaintext-backup");
|
||||
assert!(backup.exists());
|
||||
assert_eq!(Database::remove_plaintext_backups(&path).unwrap(), 1);
|
||||
assert!(!backup.exists());
|
||||
let error = match Database::open_encrypted(&path, "some passphrase") {
|
||||
Ok(_) => panic!("plaintext database was opened as encrypted storage"),
|
||||
Err(error) => error,
|
||||
};
|
||||
assert!(error
|
||||
.to_string()
|
||||
.contains("plaintext databases are no longer supported"));
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user