Compare commits

..
Author SHA1 Message Date
nvrl a79193f606 Merge pull request #109 from narrrl/refactor/proton-auth-rs
refactor(core): take the keyring store from proton-auth-rs
2026-11-20 12:18:06 +01:00
nvrl 26272cda6c 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.
2026-11-20 12:01:50 +01:00
9 changed files with 112 additions and 242 deletions

No files matched your search

Generated
+48 -7
View File
@@ -182,6 +182,17 @@ version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" 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]] [[package]]
name = "arbitrary" name = "arbitrary"
version = "1.5.0" version = "1.5.0"
@@ -1465,7 +1476,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [ dependencies = [
"libc", "libc",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -1920,7 +1931,7 @@ dependencies = [
"gobject-sys", "gobject-sys",
"libc", "libc",
"system-deps 9.0.1", "system-deps 9.0.1",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -3621,6 +3632,7 @@ dependencies = [
"keyring-core", "keyring-core",
"libc", "libc",
"parking_lot 0.13.0", "parking_lot 0.13.0",
"proton-auth-rs",
"proton-drive-rs", "proton-drive-rs",
"proton-gallery-rs", "proton-gallery-rs",
"proton-sdk", "proton-sdk",
@@ -3910,6 +3922,22 @@ dependencies = [
"syn 2.0.119", "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]] [[package]]
name = "proton-drive-rs" name = "proton-drive-rs"
version = "0.12.1" version = "0.12.1"
@@ -4127,7 +4155,7 @@ dependencies = [
"once_cell", "once_cell",
"socket2", "socket2",
"tracing", "tracing",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -4582,7 +4610,7 @@ dependencies = [
"errno", "errno",
"libc", "libc",
"linux-raw-sys", "linux-raw-sys",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -4639,7 +4667,7 @@ dependencies = [
"security-framework", "security-framework",
"security-framework-sys", "security-framework-sys",
"webpki-root-certs", "webpki-root-certs",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -5147,7 +5175,7 @@ dependencies = [
"getrandom 0.4.3", "getrandom 0.4.3",
"once_cell", "once_cell",
"rustix", "rustix",
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -5812,7 +5840,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.52.0",
] ]
[[package]] [[package]]
@@ -5862,6 +5890,19 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" 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]] [[package]]
name = "windows-result" name = "windows-result"
version = "0.4.1" version = "0.4.1"
+3
View File
@@ -63,6 +63,9 @@ rusqlite = { version = "0.41", features = ["bundled"] }
# Secret Service store is the one keyring 3's `sync-secret-service` wrapped, and # 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. # with no `target` it matches items v3 wrote, so existing logins survive.
keyring-core = "1" 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"] } dbus-secret-service-keyring-store = { version = "1", features = ["crypto-rust"] }
# The same Secret Service client the store wraps, used directly to replace an # 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). # item instead of editing it, which oo7 before 0.7.0 kept only in memory (B291).
+1
View File
@@ -25,6 +25,7 @@ shell-words.workspace = true
sha2.workspace = true sha2.workspace = true
rusqlite.workspace = true rusqlite.workspace = true
keyring-core.workspace = true keyring-core.workspace = true
proton-auth-rs = { workspace = true, features = ["keyring"] }
dbus-secret-service-keyring-store.workspace = true dbus-secret-service-keyring-store.workspace = true
dbus-secret-service.workspace = true dbus-secret-service.workspace = true
parking_lot.workspace = true parking_lot.workspace = true
+47 -98
View File
@@ -28,6 +28,7 @@ use std::time::Duration;
use base64::Engine as _; use base64::Engine as _;
use base64::engine::general_purpose::STANDARD as BASE64; use base64::engine::general_purpose::STANDARD as BASE64;
use keyring_core::Entry; use keyring_core::Entry;
use proton_auth_rs::{KeyringStore, SecretStore};
use proton_drive_rs::{KeySalt, ProtonDriveClient}; use proton_drive_rs::{KeySalt, ProtonDriveClient};
use proton_sdk::account::KeyPassphrases; use proton_sdk::account::KeyPassphrases;
use proton_sdk::api::{HumanVerification, HumanVerificationCredential}; use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
@@ -125,82 +126,28 @@ fn client_config() -> ProtonClientConfiguration {
/// Run `op` on the session's keyring entry. /// Run `op` on the session's keyring entry.
fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> { fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
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 /// The process's keyring, connected on first use.
/// Service fails the call.
/// ///
/// The store holds one D-Bus connection and one Secret Service session for the /// One connection for the whole process; when the Secret Service fails it
/// whole process. The session lives in the provider's memory: once the provider /// (a restarted provider forgets the session, `docs/BUGS.md` B285), the call
/// restarts (oo7's unit restarts it on failure, and both oo7 and gnome-keyring /// reconnects and is made once more. A changed session replaces its item
/// can be `--replace`d), every read and write on the old session fails with /// instead of editing it (B291). Both live in `proton-auth-rs`.
/// `NoSession`, for as long as this process runs. A daemon then keeps refreshed fn keyring() -> &'static KeyringStore {
/// tokens only in memory, and a cold boot loses them (`docs/BUGS.md` B285). A static STORE: std::sync::OnceLock<KeyringStore> = std::sync::OnceLock::new();
/// platform failure therefore drops the store, and the call is made once more STORE.get_or_init(|| {
/// on a new one. A locked keyring, a dismissed prompt or a missing entry is #[cfg(not(test))]
/// not the connection's fault and comes back as it is. {
fn with_keyring_entry<T>( KeyringStore::new(KEYRING_SERVICE)
service: &str,
user: &str,
op: impl Fn(&Entry) -> keyring_core::Result<T>,
) -> Result<T> {
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)?)?)
} }
result => Ok(result?), #[cfg(test)]
} {
} KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store))
.replace_items(|| tests::MOCK_STORE.lock().is_none())
/// 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<Arc<keyring_core::CredentialStore>> {
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<keyring_core::CredentialStore>) {
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<Arc<keyring_core::CredentialStore>> {
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<Arc<keyring_core::CredentialStore>> {
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()?),
}
} }
/// What the user answered when asked for the mailbox password. /// 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. /// Save `stored` to the keyring.
/// ///
/// An existing entry is replaced by a new item rather than edited, because /// Save the session. An existing entry is replaced by a new item rather than
/// oo7 before 0.7.0 keeps an edit only in memory and a reboot brings the /// edited, because oo7 before 0.7.0 keeps an edit only in memory and a reboot
/// spent refresh token back (`docs/BUGS.md` B291). The usual write is the /// brings the spent refresh token back (`docs/BUGS.md` B291).
/// fallback: for the first save, and whenever replacing is not possible.
fn write_stored(stored: &StoredSession) -> Result<()> { fn write_stored(stored: &StoredSession) -> Result<()> {
let json = Zeroizing::new(serde_json::to_string(stored)?); let json = Zeroizing::new(serde_json::to_string(stored)?);
if replace_items() { Ok(keyring().set(KEYRING_USER, &json)?)
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()
} }
/// A short, one-way tag for a refresh token, for the log: enough to tell /// 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::CredentialStore> = keyring_core::mock::Store::new().unwrap(); let store: Arc<keyring_core::CredentialStore> = keyring_core::mock::Store::new().unwrap();
*MOCK_STORE.lock() = Some(Arc::clone(&store)); *MOCK_STORE.lock() = Some(Arc::clone(&store));
keyring_core::set_default_store(store); keyring_core::set_default_store(store);
keyring().disconnect();
turn 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<Arc<keyring_core::CredentialStore>>
{
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<T>(
store: &KeyringStore,
user: &str,
op: impl Fn(&Entry) -> keyring_core::Result<T>,
) -> Result<T> {
Ok(store.with_entry(user, op)?)
}
static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(()); static KEYRING: parking_lot::Mutex<()> = parking_lot::Mutex::new(());
/// The in-memory store a reconnect hands out, so it finds the same /// The in-memory store a reconnect hands out, so it finds the same
@@ -1427,7 +1374,8 @@ mod tests {
let _turn = KEYRING.lock(); let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None; *MOCK_STORE.lock() = None;
keyring_core::unset_default_store(); 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(); with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
let status = std::process::Command::new("sh") let status = std::process::Command::new("sh")
@@ -1468,6 +1416,7 @@ mod tests {
let _turn = KEYRING.lock(); let _turn = KEYRING.lock();
*MOCK_STORE.lock() = None; *MOCK_STORE.lock() = None;
keyring_core::unset_default_store(); keyring_core::unset_default_store();
keyring().disconnect();
for refresh in ["r1", "r2", "r3"] { for refresh in ["r1", "r2", "r3"] {
write_stored(&stored_with(refresh)).unwrap(); write_stored(&stored_with(refresh)).unwrap();
+9
View File
@@ -347,6 +347,15 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool {
/// The result every request-serving method in the daemon returns. /// The result every request-serving method in the daemon returns.
pub type CoreResult<T> = std::result::Result<T, CoreError>; pub type CoreResult<T> = std::result::Result<T, CoreError>;
impl From<proton_auth_rs::Error> 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)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
-1
View File
@@ -21,7 +21,6 @@ pub mod opener;
pub mod profile; pub mod profile;
pub mod sdkcache; pub mod sdkcache;
pub mod search; pub mod search;
mod secretservice;
pub mod service; pub mod service;
pub mod shell; pub mod shell;
pub mod syncignore; pub mod syncignore;
-135
View File
@@ -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<Replaced, dbus_secret_service::Error> {
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<Path<'static>> {
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<String> {
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);
}
}
+1 -1
View File
@@ -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) [7fb11dd](https://github.com/linux-credentials/oo7/commit/7fb11dd111c4be8fec01996e3caa31c44fa962b3)
("server: Write item changes to the keyring file"). See ("server: Write item changes to the keyring file"). See
[the investigation](ISSUE-78.md#setsecret-is-kept-only-in-memory-in-fedoras-oo7). [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 **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 token, and restart oo7-daemon. The read after the restart returns the first blob. The keyring
+3
View File
@@ -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 - RAW+JPEG grouping, Google Takeout reading, EXIF capture times, look-alike
detection and the offline town lookup now come from `proton-gallery-rs`, detection and the offline town lookup now come from `proton-gallery-rs`,
shared with Proton Gallery. No behaviour change. 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 ## [3.9.0] — 2026-11-19