From 26272cda6ca2e10a36ba5cd3f325b3d082e40525 Mon Sep 17 00:00:00 2001 From: Nils Pukropp Date: Fri, 20 Nov 2026 05:46:38 +0100 Subject: [PATCH] refactor(core): take the keyring store from proton-auth-rs The Secret Service connection that reconnects after the provider restarts (B285) and the item replacement that oo7 before 0.7.0 needs (B291) moved to proton-auth-rs, shared with Proton Gallery and Proton Stream. pdfs-core keeps one KeyringStore per process; the session format, service and user are unchanged. The two secretservice tests moved with the code. --- Cargo.lock | 55 ++++++++-- Cargo.toml | 3 + crates/pdfs-core/Cargo.toml | 1 + crates/pdfs-core/src/auth.rs | 145 +++++++++----------------- crates/pdfs-core/src/error.rs | 9 ++ crates/pdfs-core/src/lib.rs | 1 - crates/pdfs-core/src/secretservice.rs | 135 ------------------------ docs/BUGS.md | 2 +- docs/CHANGELOG.md | 3 + 9 files changed, 112 insertions(+), 242 deletions(-) delete mode 100644 crates/pdfs-core/src/secretservice.rs diff --git a/Cargo.lock b/Cargo.lock index ec5169a..ae17aa2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -182,6 +182,17 @@ version = "1.0.104" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" +[[package]] +name = "apple-native-keyring-store" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b350bfd03649e07aa05c0a81b3e15934374e585c98204a57e20b9d49f49bb9a" +dependencies = [ + "keyring-core", + "log", + "security-framework", +] + [[package]] name = "arbitrary" version = "1.5.0" @@ -1465,7 +1476,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -1920,7 +1931,7 @@ dependencies = [ "gobject-sys", "libc", "system-deps 9.0.1", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -3621,6 +3632,7 @@ dependencies = [ "keyring-core", "libc", "parking_lot 0.13.0", + "proton-auth-rs", "proton-drive-rs", "proton-gallery-rs", "proton-sdk", @@ -3910,6 +3922,22 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "proton-auth-rs" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e140db8b4444e50c818c9793c2078b57c16c5b6c285a8d4bbd74886f41b05c6f" +dependencies = [ + "apple-native-keyring-store", + "dbus-secret-service", + "dbus-secret-service-keyring-store", + "keyring-core", + "thiserror 2.0.21", + "tracing", + "windows-native-keyring-store", + "zeroize", +] + [[package]] name = "proton-drive-rs" version = "0.12.1" @@ -4127,7 +4155,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -4582,7 +4610,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -4639,7 +4667,7 @@ dependencies = [ "security-framework", "security-framework-sys", "webpki-root-certs", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -5147,7 +5175,7 @@ dependencies = [ "getrandom 0.4.3", "once_cell", "rustix", - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -5812,7 +5840,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.61.2", + "windows-sys 0.52.0", ] [[package]] @@ -5862,6 +5890,19 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" +[[package]] +name = "windows-native-keyring-store" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "063426e76fdec7438d56bb777f67e318a84a25c707b07e575cb8b78e10c028f8" +dependencies = [ + "byteorder", + "keyring-core", + "regex", + "windows-sys 0.61.2", + "zeroize", +] + [[package]] name = "windows-result" version = "0.4.1" diff --git a/Cargo.toml b/Cargo.toml index dd16e2e..f3010ae 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -63,6 +63,9 @@ rusqlite = { version = "0.41", features = ["bundled"] } # Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and # with no `target` it matches items v3 wrote, so existing logins survive. keyring-core = "1" +# The keyring store all three apps share: reconnects after a Secret Service +# restart (B285) and replaces items instead of editing them (B291). +proton-auth-rs = "0.1" dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] } # The same Secret Service client the store wraps, used directly to replace an # item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291). diff --git a/crates/pdfs-core/Cargo.toml b/crates/pdfs-core/Cargo.toml index 97c0f8d..9d4733c 100644 --- a/crates/pdfs-core/Cargo.toml +++ b/crates/pdfs-core/Cargo.toml @@ -25,6 +25,7 @@ shell-words.workspace = true sha2.workspace = true rusqlite.workspace = true keyring-core.workspace = true +proton-auth-rs = { workspace = true, features = ["keyring"] } dbus-secret-service-keyring-store.workspace = true dbus-secret-service.workspace = true parking_lot.workspace = true diff --git a/crates/pdfs-core/src/auth.rs b/crates/pdfs-core/src/auth.rs index fe57852..7e2dde4 100644 --- a/crates/pdfs-core/src/auth.rs +++ b/crates/pdfs-core/src/auth.rs @@ -28,6 +28,7 @@ use std::time::Duration; use base64::Engine as _; use base64::engine::general_purpose::STANDARD as BASE64; use keyring_core::Entry; +use proton_auth_rs::{KeyringStore, SecretStore}; use proton_drive_rs::{KeySalt, ProtonDriveClient}; use proton_sdk::account::KeyPassphrases; use proton_sdk::api::{HumanVerification, HumanVerificationCredential}; @@ -125,82 +126,28 @@ fn client_config() -> ProtonClientConfiguration { /// Run `op` on the session's keyring entry. fn with_keyring(op: impl Fn(&Entry) -> keyring_core::Result) -> Result { - with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op) + Ok(keyring().with_entry(KEYRING_USER, op)?) } -/// Run `op` on the entry `service`/`user`, reconnecting once if the Secret -/// Service fails the call. +/// The process's keyring, connected on first use. /// -/// The store holds one D-Bus connection and one Secret Service session for the -/// whole process. The session lives in the provider's memory: once the provider -/// restarts (oo7's unit restarts it on failure, and both oo7 and gnome-keyring -/// can be `--replace`d), every read and write on the old session fails with -/// `NoSession`, for as long as this process runs. A daemon then keeps refreshed -/// tokens only in memory, and a cold boot loses them (`docs/BUGS.md` B285). A -/// platform failure therefore drops the store, and the call is made once more -/// on a new one. A locked keyring, a dismissed prompt or a missing entry is -/// not the connection's fault and comes back as it is. -fn with_keyring_entry( - service: &str, - user: &str, - op: impl Fn(&Entry) -> keyring_core::Result, -) -> Result { - let store = keyring_store()?; - match op(&Entry::new(service, user)?) { - Err(keyring_core::Error::PlatformFailure(e)) => { - tracing::warn!( - error = %e, - "the Secret Service failed this process's connection; reconnecting" - ); - drop_keyring_store(&store); - keyring_store()?; - Ok(op(&Entry::new(service, user)?)?) +/// One connection for the whole process; when the Secret Service fails it +/// (a restarted provider forgets the session, `docs/BUGS.md` B285), the call +/// reconnects and is made once more. A changed session replaces its item +/// instead of editing it (B291). Both live in `proton-auth-rs`. +fn keyring() -> &'static KeyringStore { + static STORE: std::sync::OnceLock = std::sync::OnceLock::new(); + STORE.get_or_init(|| { + #[cfg(not(test))] + { + KeyringStore::new(KEYRING_SERVICE) } - result => Ok(result?), - } -} - -/// Held while the default store is looked at and replaced, so that threads -/// failing at the same time drop the broken store once and share its -/// replacement. -static KEYRING_STORE: parking_lot::Mutex<()> = parking_lot::Mutex::new(()); - -/// The process's Secret Service store, connected now if there is none. -/// -/// Connected lazily rather than once at startup so a session bus that was not -/// up yet on the first attempt is tried again on the next one. -fn keyring_store() -> Result> { - let _swap = KEYRING_STORE.lock(); - if let Some(store) = keyring_core::get_default_store() { - return Ok(store); - } - let store = connect_keyring_store()?; - keyring_core::set_default_store(Arc::clone(&store)); - Ok(store) -} - -/// Forget `failed`, unless another thread has already replaced it. -fn drop_keyring_store(failed: &Arc) { - let _swap = KEYRING_STORE.lock(); - if keyring_core::get_default_store().is_some_and(|store| Arc::ptr_eq(&store, failed)) { - keyring_core::unset_default_store(); - } -} - -#[cfg(not(test))] -fn connect_keyring_store() -> Result> { - Ok(dbus_secret_service_keyring_store::Store::new()?) -} - -/// The tests' in-memory store when they set one, so a reconnect finds the -/// same entries; the real Secret Service otherwise. -#[cfg(test)] -fn connect_keyring_store() -> Result> { - tests::KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst); - match tests::MOCK_STORE.lock().clone() { - Some(store) => Ok(store), - None => Ok(dbus_secret_service_keyring_store::Store::new()?), - } + #[cfg(test)] + { + KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store)) + .replace_items(|| tests::MOCK_STORE.lock().is_none()) + } + }) } /// What the user answered when asked for the mailbox password. @@ -492,33 +439,12 @@ fn classify_verification_gate(e: ProtonError) -> Error { /// Save `stored` to the keyring. /// -/// An existing entry is replaced by a new item rather than edited, because -/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the -/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the -/// fallback: for the first save, and whenever replacing is not possible. +/// Save the session. An existing entry is replaced by a new item rather than +/// edited, because oo7 before 0.7.0 keeps an edit only in memory and a reboot +/// brings the spent refresh token back (`docs/BUGS.md` B291). fn write_stored(stored: &StoredSession) -> Result<()> { let json = Zeroizing::new(serde_json::to_string(stored)?); - if replace_items() { - match crate::secretservice::replace(KEYRING_SERVICE, KEYRING_USER, json.as_bytes()) { - crate::secretservice::Replaced::Saved => return Ok(()), - crate::secretservice::Replaced::Skipped(why) => { - tracing::debug!(%why, "not replacing the keyring item; writing it in place"); - } - } - } - with_keyring(|entry| entry.set_password(&json)) -} - -/// Whether [`write_stored`] talks to the Secret Service directly: always, -/// except in tests that use the in-memory store. -#[cfg(not(test))] -fn replace_items() -> bool { - true -} - -#[cfg(test)] -fn replace_items() -> bool { - tests::MOCK_STORE.lock().is_none() + Ok(keyring().set(KEYRING_USER, &json)?) } /// A short, one-way tag for a refresh token, for the log: enough to tell @@ -1324,9 +1250,30 @@ mod tests { let store: Arc = keyring_core::mock::Store::new().unwrap(); *MOCK_STORE.lock() = Some(Arc::clone(&store)); keyring_core::set_default_store(store); + keyring().disconnect(); turn } + /// The tests' in-memory store when they set one, so a reconnect finds the + /// same entries; the real Secret Service otherwise. + pub(super) fn connect_keyring_store() -> keyring_core::Result> + { + KEYRING_CONNECTS.fetch_add(1, Ordering::SeqCst); + match MOCK_STORE.lock().clone() { + Some(store) => Ok(store), + None => Ok(dbus_secret_service_keyring_store::Store::new()?), + } + } + + /// Run `op` on the entry `service`/`user` of the real Secret Service. + fn with_keyring_entry( + store: &KeyringStore, + user: &str, + op: impl Fn(&Entry) -> keyring_core::Result, + ) -> Result { + Ok(store.with_entry(user, op)?) + } + static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(()); /// The in-memory store a reconnect hands out, so it finds the same @@ -1427,7 +1374,8 @@ mod tests { let _turn = KEYRING.lock(); *MOCK_STORE.lock() = None; keyring_core::unset_default_store(); - let (service, user) = ("pdfs-test", "restart"); + let user = "restart"; + let service = &KeyringStore::with_connector("pdfs-test", Arc::new(connect_keyring_store)); with_keyring_entry(service, user, |e| e.set_password("before")).unwrap(); let status = std::process::Command::new("sh") @@ -1468,6 +1416,7 @@ mod tests { let _turn = KEYRING.lock(); *MOCK_STORE.lock() = None; keyring_core::unset_default_store(); + keyring().disconnect(); for refresh in ["r1", "r2", "r3"] { write_stored(&stored_with(refresh)).unwrap(); diff --git a/crates/pdfs-core/src/error.rs b/crates/pdfs-core/src/error.rs index f1e580a..c3f3ef0 100644 --- a/crates/pdfs-core/src/error.rs +++ b/crates/pdfs-core/src/error.rs @@ -347,6 +347,15 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool { /// The result every request-serving method in the daemon returns. pub type CoreResult = std::result::Result; +impl From for Error { + fn from(error: proton_auth_rs::Error) -> Self { + match error { + proton_auth_rs::Error::Keyring(error) => Self::Keyring(error), + other => Self::Other(other.to_string()), + } + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/pdfs-core/src/lib.rs b/crates/pdfs-core/src/lib.rs index db22d04..9d93b01 100644 --- a/crates/pdfs-core/src/lib.rs +++ b/crates/pdfs-core/src/lib.rs @@ -21,7 +21,6 @@ pub mod opener; pub mod profile; pub mod sdkcache; pub mod search; -mod secretservice; pub mod service; pub mod shell; pub mod syncignore; diff --git a/crates/pdfs-core/src/secretservice.rs b/crates/pdfs-core/src/secretservice.rs deleted file mode 100644 index 5543ba3..0000000 --- a/crates/pdfs-core/src/secretservice.rs +++ /dev/null @@ -1,135 +0,0 @@ -//! Saving a new secret into an existing Secret Service item by replacing the -//! item, not by editing its secret (`docs/BUGS.md` B291). -//! -//! oo7-daemon before 0.7.0 applies `SetSecret` only in memory: the keyring -//! file keeps the old secret, and it comes back once the daemon restarts. -//! Fedora 45 ships such a build (`0.7.0~beta^1.e91b98a`). Every refreshed -//! sign-in pdfs saved there was gone after a reboot, and the next start found -//! a refresh token Proton had already spent. -//! -//! `CreateItem` with `replace` is written to the file there, and every -//! provider implements it. So a secret that changes is written as a new item -//! that replaces the old one: in the old one's collection, with its label and -//! all of its attributes, so the provider recognises it as the same entry. - -use dbus_secret_service::{Collection, EncryptionType, Path, SecretService}; -use std::collections::HashMap; - -/// The content type the keyring store writes its secrets with. -const CONTENT_TYPE: &str = "application/octet-stream"; - -/// What [`replace`] did. -#[derive(Debug, PartialEq, Eq)] -pub(crate) enum Replaced { - /// The secret is saved. - Saved, - /// Nothing was changed; save it the usual way. Says why, for the log. - Skipped(String), -} - -/// Save `secret` into the one item for `service`/`user` by replacing it. -/// -/// Skips, changing nothing, when there is no such item yet (the store creates -/// it), when there is more than one, when it is locked, or when the Secret -/// Service fails before the new item exists. Never shows a prompt: one would -/// block the caller, so it is dismissed and the write is skipped. -pub(crate) fn replace(service: &str, user: &str, secret: &[u8]) -> Replaced { - match try_replace(service, user, secret) { - Ok(replaced) => replaced, - Err(e) => Replaced::Skipped(e.to_string()), - } -} - -fn try_replace( - service: &str, - user: &str, - secret: &[u8], -) -> Result { - let ss = SecretService::connect_with_max_prompt_timeout(EncryptionType::Dh, 0)?; - let lookup = HashMap::from([("service", service), ("username", user)]); - let found = ss.search_items(lookup.clone())?; - if !found.locked.is_empty() { - return Ok(Replaced::Skipped("the item is locked".into())); - } - let [old] = found.unlocked.as_slice() else { - return Ok(Replaced::Skipped(format!( - "{} items match, not one", - found.unlocked.len() - ))); - }; - let Some(collection) = collection_of(&old.path) else { - return Ok(Replaced::Skipped(format!( - "no collection in the item path {}", - old.path - ))); - }; - let label = old.get_label()?; - let attributes = old.get_attributes()?; - let attributes: HashMap<&str, &str> = attributes - .iter() - .map(|(k, v)| (k.as_str(), v.as_str())) - .collect(); - let collection = Collection::new(&ss, collection); - let new = collection.create_item(&label, attributes, secret, true, CONTENT_TYPE)?; - - // A provider that did not match the old item leaves it next to the new - // one, and two items make every read ambiguous. - let after = ss.search_items(lookup)?; - for item in after.unlocked.iter().chain(&after.locked) { - if item.path == new.path { - continue; - } - if let Err(e) = item.delete() { - // The old item still holds the previous secret, so taking the new - // one out leaves things as they were, for the usual write. - if let Err(undo) = new.delete() { - tracing::error!( - error = %undo, - "could not remove a duplicate keyring item; remove one of the two \ - `proton-drive-linux` entries in your keyring and sign in again" - ); - } - return Ok(Replaced::Skipped(format!( - "could not remove the replaced item: {e}" - ))); - } - } - Ok(Replaced::Saved) -} - -/// The collection an item path belongs to: the path without its last part, -/// as long as it is a Secret Service object path. -fn collection_of(item: &Path<'_>) -> Option> { - let (collection, _) = item.rsplit_once('/')?; - if !collection.starts_with("/org/freedesktop/secrets/") || collection.ends_with('/') { - return None; - } - Path::new(collection.to_owned()).ok() -} - -#[cfg(test)] -mod tests { - use super::*; - - fn collection(item: &str) -> Option { - collection_of(&Path::new(item).unwrap()).map(|p| p.to_string()) - } - - #[test] - fn an_item_belongs_to_the_collection_its_path_names() { - assert_eq!( - collection("/org/freedesktop/secrets/collection/login/14").as_deref(), - Some("/org/freedesktop/secrets/collection/login") - ); - assert_eq!( - collection("/org/freedesktop/secrets/aliases/default/3").as_deref(), - Some("/org/freedesktop/secrets/aliases/default") - ); - } - - #[test] - fn a_path_outside_the_secret_service_names_no_collection() { - assert_eq!(collection("/org/example/item/1"), None); - assert_eq!(collection("/item"), None); - } -} diff --git a/docs/BUGS.md b/docs/BUGS.md index 7b8fb21..f7d9e3a 100644 --- a/docs/BUGS.md +++ b/docs/BUGS.md @@ -432,7 +432,7 @@ the build Fedora 45 and 46 ship as stable, from before oo7's [7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3) ("server: Write item changes to the keyring file"). See [the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7). -**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `crates/pdfs-core/src/secretservice.rs` +**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `proton-auth-rs` (`secret_service.rs`, moved from `crates/pdfs-core/src/secretservice.rs`) **Repro:** With oo7-daemon at e91b98a, save the session blob, save it again with a new refresh token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index 28b2789..3e48117 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -19,6 +19,9 @@ scratch (user data in `staging/` and `recovery/` is never touched by this). - RAW+JPEG grouping, Google Takeout reading, EXIF capture times, look-alike detection and the offline town lookup now come from `proton-gallery-rs`, shared with Proton Gallery. No behaviour change. +- The keyring code (one Secret Service connection that reconnects after the provider + restarts, B285, and replacing the session item instead of editing it, B291) now comes + from `proton-auth-rs`, shared with Proton Gallery and Proton Stream. No behaviour change. ## [3.9.0] — 2026-11-19