mirror of
https://github.com/narrrl/proton-drive-linux.git
synced 2026-11-20 18:13:49 +01:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1d4f6c0f48 |
No files matched your search
Generated
-68
@@ -182,17 +182,6 @@ 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"
|
||||
@@ -3632,8 +3621,6 @@ dependencies = [
|
||||
"keyring-core",
|
||||
"libc",
|
||||
"parking_lot 0.13.0",
|
||||
"proton-auth-rs",
|
||||
"proton-base-rs",
|
||||
"proton-drive-rs",
|
||||
"proton-gallery-rs",
|
||||
"proton-sdk",
|
||||
@@ -3669,7 +3656,6 @@ dependencies = [
|
||||
"proton-drive-rs",
|
||||
"proton-gallery-app-rs",
|
||||
"proton-gallery-rs",
|
||||
"proton-media-rs",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -3924,34 +3910,6 @@ dependencies = [
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-auth-rs"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "383119b502a1741f1ec4a248cb1e8d2f4835d5ea415803b041f76b6f89cf1ffc"
|
||||
dependencies = [
|
||||
"apple-native-keyring-store",
|
||||
"dbus-secret-service",
|
||||
"dbus-secret-service-keyring-store",
|
||||
"keyring-core",
|
||||
"proton-sdk",
|
||||
"serde_json",
|
||||
"thiserror 2.0.21",
|
||||
"tracing",
|
||||
"windows-native-keyring-store",
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-base-rs"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "451151bb1025ea5cb362f69e2bfb2d45afed603e5c6daa3dc752333a7c29c878"
|
||||
dependencies = [
|
||||
"rusqlite",
|
||||
"thiserror 2.0.21",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-drive-rs"
|
||||
version = "0.12.1"
|
||||
@@ -4046,19 +4004,6 @@ dependencies = [
|
||||
"zip",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-media-rs"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f03aa6c403e4f2f7a8f9a444dff1e268d8bc9bcaf1d0d953cc3a1312d798f1ef"
|
||||
dependencies = [
|
||||
"lru",
|
||||
"sha2 0.11.1",
|
||||
"thiserror 2.0.21",
|
||||
"tokio",
|
||||
"tracing",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proton-sdk"
|
||||
version = "0.12.1"
|
||||
@@ -5917,19 +5862,6 @@ 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"
|
||||
|
||||
@@ -63,11 +63,6 @@ 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.1"
|
||||
proton-base-rs = "0.1"
|
||||
proton-media-rs = "0.1.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).
|
||||
|
||||
@@ -25,8 +25,6 @@ shell-words.workspace = true
|
||||
sha2.workspace = true
|
||||
rusqlite.workspace = true
|
||||
keyring-core.workspace = true
|
||||
proton-auth-rs = { workspace = true, features = ["keyring", "session"] }
|
||||
proton-base-rs.workspace = true
|
||||
dbus-secret-service-keyring-store.workspace = true
|
||||
dbus-secret-service.workspace = true
|
||||
parking_lot.workspace = true
|
||||
|
||||
+169
-106
@@ -28,8 +28,6 @@ use std::time::Duration;
|
||||
use base64::Engine as _;
|
||||
use base64::engine::general_purpose::STANDARD as BASE64;
|
||||
use keyring_core::Entry;
|
||||
use proton_auth_rs::session::{self, SignInError, Step};
|
||||
use proton_auth_rs::{KeyringStore, SecretStore};
|
||||
use proton_drive_rs::{KeySalt, ProtonDriveClient};
|
||||
use proton_sdk::account::KeyPassphrases;
|
||||
use proton_sdk::api::{HumanVerification, HumanVerificationCredential};
|
||||
@@ -127,28 +125,82 @@ fn client_config() -> ProtonClientConfiguration {
|
||||
|
||||
/// Run `op` on the session's keyring entry.
|
||||
fn with_keyring<T>(op: impl Fn(&Entry) -> keyring_core::Result<T>) -> Result<T> {
|
||||
Ok(keyring().with_entry(KEYRING_USER, op)?)
|
||||
with_keyring_entry(KEYRING_SERVICE, KEYRING_USER, op)
|
||||
}
|
||||
|
||||
/// The process's keyring, connected on first use.
|
||||
/// Run `op` on the entry `service`/`user`, reconnecting once if the Secret
|
||||
/// Service fails the call.
|
||||
///
|
||||
/// 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<KeyringStore> = std::sync::OnceLock::new();
|
||||
STORE.get_or_init(|| {
|
||||
#[cfg(not(test))]
|
||||
{
|
||||
KeyringStore::new(KEYRING_SERVICE)
|
||||
/// 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<T>(
|
||||
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)?)?)
|
||||
}
|
||||
#[cfg(test)]
|
||||
{
|
||||
KeyringStore::with_connector(KEYRING_SERVICE, Arc::new(tests::connect_keyring_store))
|
||||
.replace_items(|| tests::MOCK_STORE.lock().is_none())
|
||||
}
|
||||
})
|
||||
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<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.
|
||||
@@ -280,58 +332,74 @@ pub async fn login_verified(
|
||||
get_totp: impl Fn() -> Result<String>,
|
||||
get_mailbox: impl Fn(u32) -> Result<Mailbox>,
|
||||
) -> Result<()> {
|
||||
// The sequence is `proton_auth_rs::session`, shared with the other Proton
|
||||
// apps. It reads the key salts before unlocking, while this access token
|
||||
// still has the `locked` scope: after its first refresh it never will
|
||||
// again, and without them no later resume can unlock the key chain. See
|
||||
// `StoredSession::key_salts`.
|
||||
let mut step = session::begin(client_config(), username, password, verification)
|
||||
.await
|
||||
.map_err(sign_in_error)?;
|
||||
let (unlocked, remember) = loop {
|
||||
step = match step {
|
||||
Step::SecondFactor(pending) => {
|
||||
let code = get_totp()?;
|
||||
pending.second_factor(&code).await.map_err(sign_in_error)?
|
||||
}
|
||||
// A single-password account's mailbox password is the login password.
|
||||
Step::Unlock(pending) => break (pending.unlock().await.map_err(sign_in_error)?, true),
|
||||
// A two-password one has a second secret the user must type, and it is
|
||||
// checked against the account now — a typo found at login is a retry,
|
||||
// found later it is a daemon that never mounts.
|
||||
Step::MailboxPassword(pending) => {
|
||||
let mut attempt = 0;
|
||||
break loop {
|
||||
let mailbox = get_mailbox(attempt)?;
|
||||
match pending.mailbox_password(&mailbox.password).await {
|
||||
Ok(unlocked) => break (unlocked, mailbox.remember),
|
||||
Err(SignInError::WrongMailboxPassword)
|
||||
if attempt + 1 < MAILBOX_ATTEMPTS =>
|
||||
{
|
||||
attempt += 1;
|
||||
}
|
||||
Err(e) => return Err(sign_in_error(e)),
|
||||
let password = Zeroizing::new(password.to_owned());
|
||||
let session = ProtonApiSession::begin_verified(
|
||||
client_config(),
|
||||
username,
|
||||
password.as_bytes(),
|
||||
verification,
|
||||
)
|
||||
.await
|
||||
.map_err(classify_verification_gate);
|
||||
let mut session = session?;
|
||||
|
||||
if session.is_waiting_for_second_factor() {
|
||||
let code = get_totp()?;
|
||||
session.apply_second_factor_code(code.trim()).await?;
|
||||
}
|
||||
|
||||
// Grab the key salts while this access token still has the `locked` scope:
|
||||
// after its first refresh it never will again, and without them no later
|
||||
// resume can unlock the key chain. See `StoredSession::key_salts`.
|
||||
let key_salts = ProtonDriveClient::new(&session, Vec::new())
|
||||
.account()
|
||||
.key_salts()
|
||||
.await?;
|
||||
|
||||
// A single-password account's mailbox password is the login password. A
|
||||
// two-password one has a second secret the user must type, and it is checked
|
||||
// against the account now — a typo found at login is a retry, found later it
|
||||
// is a daemon that never mounts.
|
||||
let (passphrases, remember) = match session.password_mode() {
|
||||
PasswordMode::Single => (
|
||||
derive_verified(&session, password.as_bytes(), key_salts.clone()).await?,
|
||||
true,
|
||||
),
|
||||
PasswordMode::Dual => {
|
||||
let mut attempt = 0;
|
||||
loop {
|
||||
let mailbox = get_mailbox(attempt)?;
|
||||
match derive_verified(&session, mailbox.password.as_bytes(), key_salts.clone())
|
||||
.await
|
||||
{
|
||||
Ok(passphrases) => break (passphrases, mailbox.remember),
|
||||
Err(Error::WrongMailboxPassword) if attempt + 1 < MAILBOX_ATTEMPTS => {
|
||||
attempt += 1;
|
||||
}
|
||||
};
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
let tokens = unlocked.tokens().await;
|
||||
register_refresh_handler(&unlocked.session, tokens.refresh_token.clone());
|
||||
let tokens = session.current_tokens().await;
|
||||
register_refresh_handler(&session, tokens.refresh_token.clone());
|
||||
let stored = StoredSession {
|
||||
session_id: tokens.session_id,
|
||||
username: tokens.username,
|
||||
user_id: tokens.user_id,
|
||||
session_id: session.session_id().as_str().to_owned(),
|
||||
username: session.username().to_owned(),
|
||||
user_id: session.user_id().as_str().to_owned(),
|
||||
access_token: tokens.access_token,
|
||||
refresh_token: tokens.refresh_token,
|
||||
scopes: tokens.scopes,
|
||||
password_mode: session::password_mode_to_wire(tokens.password_mode),
|
||||
scopes: session.scopes().to_vec(),
|
||||
password_mode: match session.password_mode() {
|
||||
PasswordMode::Single => 1,
|
||||
PasswordMode::Dual => 2,
|
||||
},
|
||||
mailbox_password: String::new(),
|
||||
key_salts: unlocked.key_salts,
|
||||
key_salts,
|
||||
key_passphrases: None,
|
||||
};
|
||||
keep_passphrases(stored, &unlocked.key_passphrases, remember)
|
||||
keep_passphrases(stored, &passphrases, remember)
|
||||
}
|
||||
|
||||
/// Derive the key passphrases from `mailbox` and prove they unlock the account.
|
||||
@@ -405,34 +473,52 @@ fn decode_secret(secret: &[u8]) -> Option<KeyPassphrases> {
|
||||
decode(&serde_json::from_slice(secret).ok()?)
|
||||
}
|
||||
|
||||
/// A failed sign-in step as this crate's error.
|
||||
/// Lift a human-verification gate out of the generic API error into the typed
|
||||
/// variant a front-end can act on.
|
||||
///
|
||||
/// A blocked, refused or wrong-code attempt goes back to the Proton error it
|
||||
/// came from, which is what the front-ends word themselves. Only a gate that
|
||||
/// names a solvable method is a [`Error::HumanVerificationRequired`]: one that
|
||||
/// offers only `email`/`sms` stays a plain API error, because sending the UI to
|
||||
/// open a page it cannot complete reads as a hang rather than a refusal.
|
||||
fn sign_in_error(e: SignInError) -> Error {
|
||||
match e {
|
||||
SignInError::HumanVerification(hv) => Error::HumanVerificationRequired(hv),
|
||||
SignInError::SecurityKeyOnly => Error::SecurityKeyOnly,
|
||||
SignInError::Blocked(api) | SignInError::Rejected(api) | SignInError::WrongCode(api) => {
|
||||
Error::Proton(ProtonError::Api(api))
|
||||
}
|
||||
SignInError::WrongMailboxPassword => Error::WrongMailboxPassword,
|
||||
SignInError::Proton(e) => e.into(),
|
||||
other => Error::Other(other.to_string()),
|
||||
/// Only a gate that names a solvable method is converted. A `9001` with no
|
||||
/// `Details`, or one offering only `email`/`sms`, stays a plain API error:
|
||||
/// promoting it would send the UI to open a verification page it cannot
|
||||
/// complete, which reads to the user as a hang rather than a refusal.
|
||||
fn classify_verification_gate(e: ProtonError) -> Error {
|
||||
let ProtonError::Api(api) = &e else {
|
||||
return e.into();
|
||||
};
|
||||
match api.human_verification() {
|
||||
Some(hv) if hv.supports_captcha() => Error::HumanVerificationRequired(Box::new(hv)),
|
||||
_ => e.into(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Save `stored` to the keyring.
|
||||
///
|
||||
/// 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).
|
||||
/// 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.
|
||||
fn write_stored(stored: &StoredSession) -> Result<()> {
|
||||
let json = Zeroizing::new(serde_json::to_string(stored)?);
|
||||
Ok(keyring().set(KEYRING_USER, &json)?)
|
||||
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()
|
||||
}
|
||||
|
||||
/// A short, one-way tag for a refresh token, for the log: enough to tell
|
||||
@@ -1238,30 +1324,9 @@ mod tests {
|
||||
let store: Arc<keyring_core::CredentialStore> = 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<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(());
|
||||
|
||||
/// The in-memory store a reconnect hands out, so it finds the same
|
||||
@@ -1362,8 +1427,7 @@ mod tests {
|
||||
let _turn = KEYRING.lock();
|
||||
*MOCK_STORE.lock() = None;
|
||||
keyring_core::unset_default_store();
|
||||
let user = "restart";
|
||||
let service = &KeyringStore::with_connector("pdfs-test", Arc::new(connect_keyring_store));
|
||||
let (service, user) = ("pdfs-test", "restart");
|
||||
|
||||
with_keyring_entry(service, user, |e| e.set_password("before")).unwrap();
|
||||
let status = std::process::Command::new("sh")
|
||||
@@ -1404,7 +1468,6 @@ 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();
|
||||
|
||||
@@ -457,7 +457,26 @@ fn load_config_at(path: &Path) -> AppConfig {
|
||||
/// [`AppDirs::save_config`] for the file at `path`.
|
||||
fn save_config_at(path: &Path, config: &AppConfig) -> Result<()> {
|
||||
refuse_to_replace_unreadable(path)?;
|
||||
proton_base_rs::atomic::write(path, &serde_json::to_vec_pretty(config)?)?;
|
||||
let parent = path
|
||||
.parent()
|
||||
.ok_or_else(|| Error::Other("configuration path has no parent".into()))?;
|
||||
std::fs::create_dir_all(parent)?;
|
||||
let nonce = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|duration| duration.as_nanos())
|
||||
.unwrap_or(0);
|
||||
let tmp = path.with_extension(format!("json.tmp-{}-{nonce}", std::process::id()));
|
||||
use std::os::unix::fs::OpenOptionsExt as _;
|
||||
let mut file = std::fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.mode(0o600)
|
||||
.open(&tmp)?;
|
||||
use std::io::Write as _;
|
||||
file.write_all(&serde_json::to_vec_pretty(config)?)?;
|
||||
file.sync_all()?;
|
||||
std::fs::rename(&tmp, path)?;
|
||||
std::fs::File::open(parent)?.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -602,8 +621,15 @@ impl AppDirs {
|
||||
use std::io::Read as _;
|
||||
std::fs::File::open("/dev/urandom")?.read_exact(&mut bytes)?;
|
||||
let id: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
|
||||
// Not secret, and other tools may read it; keep it world-readable.
|
||||
proton_base_rs::atomic::write_with_mode(&path, format!("{id}\n").as_bytes(), 0o644)?;
|
||||
let parent = path
|
||||
.parent()
|
||||
.ok_or_else(|| Error::Other("machine id path has no parent".into()))?;
|
||||
std::fs::create_dir_all(parent)?;
|
||||
let tmp = path.with_extension(format!("tmp-{}", std::process::id()));
|
||||
std::fs::write(&tmp, format!("{id}\n"))?;
|
||||
std::fs::File::open(&tmp)?.sync_all()?;
|
||||
std::fs::rename(&tmp, &path)?;
|
||||
std::fs::File::open(parent)?.sync_all()?;
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
|
||||
@@ -42,13 +42,6 @@ pub enum Error {
|
||||
#[error("that mailbox password does not unlock your account")]
|
||||
WrongMailboxPassword,
|
||||
|
||||
/// The account's only second factor is a security key, which needs
|
||||
/// WebAuthn. Asking for a code would only fail as a wrong one.
|
||||
#[error(
|
||||
"this account's only second factor is a security key, which pdfs cannot use yet — add an authenticator app in your Proton account settings"
|
||||
)]
|
||||
SecurityKeyOnly,
|
||||
|
||||
/// The login was gated behind human verification. Not a failure the user can
|
||||
/// fix by retrying: the challenge has to be solved and the login restarted
|
||||
/// with the resulting token (see [`auth::login_verified`](crate::auth::login_verified)).
|
||||
@@ -227,7 +220,6 @@ fn core_kind(e: &Error) -> ErrorKind {
|
||||
| Error::ReloginRequired
|
||||
| Error::Locked
|
||||
| Error::WrongMailboxPassword
|
||||
| Error::SecurityKeyOnly
|
||||
| Error::HumanVerificationRequired(_) => ErrorKind::Denied,
|
||||
Error::Proton(proton) => proton_kind(proton),
|
||||
_ => ErrorKind::Internal,
|
||||
@@ -355,15 +347,6 @@ pub fn sign_in_blocked(e: &proton_sdk::ProtonError) -> bool {
|
||||
/// The result every request-serving method in the daemon returns.
|
||||
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)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -21,6 +21,7 @@ pub mod opener;
|
||||
pub mod profile;
|
||||
pub mod sdkcache;
|
||||
pub mod search;
|
||||
mod secretservice;
|
||||
pub mod service;
|
||||
pub mod shell;
|
||||
pub mod syncignore;
|
||||
|
||||
@@ -40,7 +40,9 @@ pub fn path(state_dir: &Path) -> PathBuf {
|
||||
/// and renamed, so a reader never sees half of it.
|
||||
pub fn record(state_dir: &Path, failure: &MountFailure) -> std::io::Result<()> {
|
||||
let json = serde_json::to_vec(failure).map_err(std::io::Error::other)?;
|
||||
proton_base_rs::atomic::write_with_mode(&path(state_dir), &json, 0o644)
|
||||
let tmp = state_dir.join(format!("{FILE_NAME}.tmp"));
|
||||
std::fs::write(&tmp, json)?;
|
||||
std::fs::rename(&tmp, path(state_dir))
|
||||
}
|
||||
|
||||
/// Forget the failure: a mount is up, or a new daemon has started.
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
//! 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);
|
||||
}
|
||||
}
|
||||
@@ -16,7 +16,6 @@ sha1.workspace = true
|
||||
proton-drive-rs.workspace = true
|
||||
proton-gallery-app-rs.workspace = true
|
||||
proton-gallery-rs.workspace = true
|
||||
proton-media-rs.workspace = true
|
||||
hyper = { version = "1", features = ["http1", "server"] }
|
||||
hyper-util = { version = "0.1", features = ["tokio"] }
|
||||
http-body-util = "0.1"
|
||||
|
||||
@@ -212,12 +212,15 @@ impl BlockRing {
|
||||
}
|
||||
|
||||
/// The result of fetching one block, shared between everyone who wanted it.
|
||||
pub(super) type BlockResult = Result<Arc<Vec<u8>>, Errno>;
|
||||
type BlockResult = Result<Arc<Vec<u8>>, Errno>;
|
||||
|
||||
/// Identifies a block *of a revision*: node, validity tag, and the plaintext
|
||||
/// range the block covers — see [`RingKey`] for why it is the range and not the
|
||||
/// index.
|
||||
pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
||||
type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
||||
|
||||
/// A claim on a block key: who owns the fetch, and where its result is published.
|
||||
type Claim = (u64, tokio::sync::watch::Receiver<Option<BlockResult>>);
|
||||
|
||||
/// Block fetches in flight, so a block is downloaded and decrypted once however
|
||||
/// many readers want it at that moment (audit T1).
|
||||
@@ -228,7 +231,34 @@ pub(super) type BlockKey = (NodeUid, i64, u64, BlockSpan);
|
||||
/// for. Without this each of them pays the full round-trip and decrypt and all
|
||||
/// but one result is discarded — roughly double the bandwidth and CPU in steady
|
||||
/// state. Same shape as [`ReaderSlot::Pending`] one level up.
|
||||
pub(super) type BlockFlight = proton_media_rs::SingleFlight<BlockKey, BlockResult>;
|
||||
#[derive(Default)]
|
||||
pub(super) struct BlockFlight {
|
||||
inflight: Mutex<HashMap<BlockKey, Claim>>,
|
||||
}
|
||||
|
||||
/// Distinguishes attempts at the same key, so a leader only retires its own.
|
||||
static NEXT_FLIGHT_ID: AtomicU64 = AtomicU64::new(0);
|
||||
|
||||
/// The leader's claim on a key. Retires it on drop — including when the task is
|
||||
/// cancelled mid-fetch, which is what keeps a dropped `JoinSet` from leaving a
|
||||
/// key nobody will ever publish.
|
||||
struct Flight {
|
||||
flight: Arc<BlockFlight>,
|
||||
key: BlockKey,
|
||||
id: u64,
|
||||
}
|
||||
|
||||
impl Drop for Flight {
|
||||
fn drop(&mut self) {
|
||||
let mut inflight = self.flight.inflight.lock();
|
||||
if inflight
|
||||
.get(&self.key)
|
||||
.is_some_and(|(id, _)| *id == self.id)
|
||||
{
|
||||
inflight.remove(&self.key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Where each file's reader is expected to read next, so sequential reads can be
|
||||
/// told from random ones and only the former prefetched (audit T2).
|
||||
@@ -551,11 +581,49 @@ impl Core {
|
||||
cache_blocks: bool,
|
||||
) -> BlockResult {
|
||||
let key: BlockKey = (uid.clone(), mtime, fsize, span);
|
||||
self.block_flight
|
||||
.join(key, || {
|
||||
self.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||
})
|
||||
.await
|
||||
let claim = {
|
||||
let mut inflight = self.block_flight.inflight.lock();
|
||||
match inflight.get(&key) {
|
||||
Some((_, rx)) => Err(rx.clone()),
|
||||
None => {
|
||||
let id = NEXT_FLIGHT_ID.fetch_add(1, Ordering::Relaxed);
|
||||
let (tx, rx) = tokio::sync::watch::channel(None);
|
||||
inflight.insert(key.clone(), (id, rx));
|
||||
Ok((
|
||||
tx,
|
||||
Flight {
|
||||
flight: self.block_flight.clone(),
|
||||
key: key.clone(),
|
||||
id,
|
||||
},
|
||||
))
|
||||
}
|
||||
}
|
||||
};
|
||||
let (tx, flight) = match claim {
|
||||
Ok(lead) => lead,
|
||||
Err(mut rx) => {
|
||||
loop {
|
||||
if let Some(result) = rx.borrow_and_update().clone() {
|
||||
return result;
|
||||
}
|
||||
if rx.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return self
|
||||
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let result = self
|
||||
.read_block(reader, uid, mtime, fsize, span, cache_blocks)
|
||||
.await;
|
||||
// Retire the claim before publishing, so a racer that wakes and re-enters
|
||||
// finds no stale entry to join.
|
||||
drop(flight);
|
||||
let _ = tx.send(Some(result.clone()));
|
||||
result
|
||||
}
|
||||
|
||||
/// Download and decrypt one block, then put it where the next reader will
|
||||
|
||||
@@ -336,9 +336,6 @@ pub(crate) fn login_error_message(error: &pdfs_core::Error) -> String {
|
||||
pdfs_core::Error::WrongMailboxPassword => {
|
||||
gettext("That mailbox password didn't unlock your account.")
|
||||
}
|
||||
pdfs_core::Error::SecurityKeyOnly => gettext(
|
||||
"This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code.",
|
||||
),
|
||||
pdfs_core::Error::Other(message) if message.contains("verification") => gettext(
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a new one.",
|
||||
),
|
||||
@@ -714,9 +711,6 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn a_cancelled_prompt_says_which_step_was_skipped() {
|
||||
assert!(
|
||||
login_error_message(&pdfs_core::Error::SecurityKeyOnly).contains("authenticator app")
|
||||
);
|
||||
let totp = pdfs_core::Error::Other("two-factor entry cancelled".into());
|
||||
assert!(login_error_message(&totp).contains("two-factor code"));
|
||||
let hv = pdfs_core::Error::Other("verification cancelled".into());
|
||||
|
||||
+1
-1
@@ -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`; `proton-auth-rs` (`secret_service.rs`, moved from `crates/pdfs-core/src/secretservice.rs`)
|
||||
**Where:** `crates/pdfs-core/src/auth.rs`, `write_stored`; `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
|
||||
|
||||
@@ -13,27 +13,12 @@ scratch (user data in `staging/` and `recovery/` is never touched by this).
|
||||
|
||||
### Changed
|
||||
|
||||
- Signing in runs through `proton_auth_rs::session`, the sequence Proton Gallery and
|
||||
Proton Stream use too. The stored session, the lock/unlock choice for two-password
|
||||
accounts, the three mailbox-password tries and the messages stay as they were.
|
||||
- An account whose only second factor is a security key now gets a clear message at
|
||||
sign-in instead of a code prompt that could only fail.
|
||||
- Block fetches shared by concurrent readers now use `SingleFlight` from
|
||||
`proton-media-rs`, the same code Proton Stream uses. Same behaviour: one
|
||||
download per block, every reader gets its result, and a reader whose fetch was
|
||||
cancelled downloads the block itself.
|
||||
- The shared Gallery engine now comes from the `proton-gallery-rs` and
|
||||
`proton-gallery-app-rs` crates on crates.io instead of a pinned Git revision of
|
||||
Proton Gallery. Builds, vendoring and the Nix package no longer fetch from Git.
|
||||
- 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.
|
||||
- Config, machine-id and mount-failure files are written through `proton-base-rs`'s
|
||||
atomic writer (temporary file, sync, rename, directory sync). The mount-failure file
|
||||
is now synced before the rename too, so a crash cannot leave it empty.
|
||||
|
||||
## [3.9.0] — 2026-11-19
|
||||
|
||||
|
||||
@@ -3599,10 +3599,6 @@ msgstr "Anmeldung abgebrochen: Es wurde kein Postfach-Passwort eingegeben."
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr "Das Postfach-Passwort hat Ihr Konto nicht entsperrt."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "Der einzige zweite Faktor dieses Kontos ist ein Sicherheitsschlüssel, den diese App noch nicht nutzen kann. Fügen Sie in Ihren Proton-Kontoeinstellungen eine Authentifizierungs-App hinzu und melden Sie sich dann mit deren Code an."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3541,10 +3541,6 @@ msgstr "Sign-in cancelled: no mailbox password was entered."
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr "That mailbox password didn't unlock your account."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3575,10 +3575,6 @@ msgstr "Inicio de sesión cancelado: no se introdujo la contraseña del buzón."
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr "Esa contraseña del buzón no desbloqueó tu cuenta."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "El único segundo factor de esta cuenta es una llave de seguridad, que esta aplicación aún no puede usar. Añade una aplicación de autenticación en los ajustes de tu cuenta de Proton y luego inicia sesión con su código."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3600,10 +3600,6 @@ msgid "That mailbox password didn't unlock your account."
|
||||
msgstr ""
|
||||
"Ce mot de passe de boîte aux lettres n’a pas déverrouillé votre compte."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "Le seul second facteur de ce compte est une clé de sécurité, que cette application ne peut pas encore utiliser. Ajoutez une application d’authentification dans les paramètres de votre compte Proton, puis connectez-vous avec son code."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3593,10 +3593,6 @@ msgid "That mailbox password didn't unlock your account."
|
||||
msgstr ""
|
||||
"Quella password della casella di posta non ha sbloccato il tuo account."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "L’unico secondo fattore di questo account è una chiave di sicurezza, che questa app non può ancora usare. Aggiungi un’app di autenticazione nelle impostazioni del tuo account Proton, poi accedi con il suo codice."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3583,10 +3583,6 @@ msgstr "Aanmelden geannuleerd: er is geen mailboxwachtwoord ingevoerd."
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr "Dat mailboxwachtwoord heeft je account niet ontgrendeld."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "De enige tweede factor van dit account is een beveiligingssleutel, die deze app nog niet kan gebruiken. Voeg een authenticator-app toe in je Proton-accountinstellingen en meld je daarna aan met de code daarvan."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3411,10 +3411,6 @@ msgstr ""
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr ""
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr ""
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3652,10 +3652,6 @@ msgstr "Anulowano logowanie: nie wpisano hasła skrzynki pocztowej."
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr "To hasło skrzynki pocztowej nie odblokowało Twojego konta."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "Jedynym drugim składnikiem tego konta jest klucz bezpieczeństwa, którego ta aplikacja nie może jeszcze używać. Dodaj aplikację uwierzytelniającą w ustawieniach konta Proton, a następnie zaloguj się jej kodem."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
@@ -3575,10 +3575,6 @@ msgstr "Entrada cancelada: nenhuma senha da caixa de correio foi digitada."
|
||||
msgid "That mailbox password didn't unlock your account."
|
||||
msgstr "Essa senha da caixa de correio não desbloqueou sua conta."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs
|
||||
msgid "This account's only second factor is a security key, which this app can't use yet. Add an authenticator app in your Proton account settings, then sign in with its code."
|
||||
msgstr "O único segundo fator desta conta é uma chave de segurança, que este app ainda não pode usar. Adicione um app autenticador nas configurações da sua conta Proton e depois entre com o código dele."
|
||||
|
||||
#: crates/pdfs-gui/src/app/pages/login.rs:340
|
||||
msgid ""
|
||||
"Sign-in cancelled: the verification wasn't completed. Sign in again to get a "
|
||||
|
||||
Reference in new issue
Block a user