From f6753774e7e9925bdc48378166748ae7f3338c0c Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Thu, 12 Nov 2026 06:00:26 +0700 Subject: [PATCH] fix(windows): hold sign-out for unsaved work, split long secrets, close late sessions --- core/ARCHITECTURE.md | 2 +- core/crates/ffi/src/cloud.rs | 1 + core/crates/ffi/src/core_handle.rs | 78 +++- core/crates/ffi/src/credential_manager.rs | 268 ++++++++++--- core/crates/ffi/src/credential_parts.rs | 355 ++++++++++++++++++ core/crates/ffi/src/lib.rs | 2 + core/crates/ffi/src/library.rs | 69 +++- core/crates/ffi/tests/library.rs | 58 ++- core/crates/ffi/tests/row_edits.rs | 12 +- core/crates/ffi/tests/safe_mode_gate.rs | 12 +- windows/docs/decisions/0004-app-shell.md | 14 +- .../src/TablePro.App.Model/ConnectionDraft.cs | 20 + .../src/TablePro.App.Model/ConnectionLife.cs | 160 ++++---- .../TablePro.App.Model/WorkspaceNotices.cs | 12 + .../src/TablePro.App.Model/WorkspaceTabs.cs | 8 + .../ConnectionFormWindow.xaml.cs | 12 +- windows/src/TablePro.App/MainWindow.xaml.cs | 61 ++- .../src/TablePro.App/Services/SessionEnd.cs | 63 +++- .../TablePro.App/Strings/en-US/Resources.resw | 9 + .../src/TablePro.App/Views/OpenConnection.cs | 2 + .../TablePro.App/Views/WorkspaceView.xaml.cs | 30 +- .../Generated/tablepro_ffi.cs | 12 +- windows/src/TablePro.Interop/TableProCore.cs | 6 +- .../ConnectionDraftTests.cs | 26 ++ .../ConnectionFakes.cs | 11 +- .../ConnectionLifeTests.cs | 126 ++++++- .../WorkspaceTabsTests.cs | 28 ++ .../ConnectionLibraryTests.cs | 16 + 28 files changed, 1295 insertions(+), 178 deletions(-) create mode 100644 core/crates/ffi/src/credential_parts.rs diff --git a/core/ARCHITECTURE.md b/core/ARCHITECTURE.md index 8a4fc27513..c4770bb521 100644 --- a/core/ARCHITECTURE.md +++ b/core/ARCHITECTURE.md @@ -98,7 +98,7 @@ A `cfg` split inside a crate: | SQLite | the distribution's | bundled | bundled | | DuckDB's file lock while a file is replaced | fcntl | fcntl | LockFileEx | | SQL Server integrated login | MIT Kerberos, behind the `kerberos` feature | the system's GSS framework, behind the `kerberos` feature | SSPI, NTLM only (winauth) | -| `ffi`'s system secret store | none | none | Credential Manager, generic credentials named `TablePro/connection//` | +| `ffi`'s system secret store | none | none | Credential Manager, generic credentials named `TablePro/connection//`; a secret over a credential's 2,560 bytes goes on in `/1`, `/2`, each part carrying a `TablePro_Parts` attribute with its write, part count and length (`credential_parts`) | | OpenSSH transport, askpass helper | yes | yes | not built | | The in-process SSH transport's agent | `SSH_AUTH_SOCK` | `SSH_AUTH_SOCK` | `SSH_AUTH_SOCK`, else `\\.\pipe\openssh-ssh-agent`, then Pageant | | A server's own Unix-domain socket (`tablepro_net::LocalSocketTransport`, `NetworkOption::LocalSocket`) | yes | yes | not built: no engine offers one | diff --git a/core/crates/ffi/src/cloud.rs b/core/crates/ffi/src/cloud.rs index 18b5244dfa..c35b8e8196 100644 --- a/core/crates/ffi/src/cloud.rs +++ b/core/crates/ffi/src/cloud.rs @@ -67,6 +67,7 @@ impl ConnectionLibrary { .transpose()?, }; let deleted = pull.deleted.connections.clone(); + let _held = self.hold_writes().await; self.blocking(move |store| Ok(store.apply_cloud_pull_blocking(&pull)?)) .await?; self.delete_secrets(deleted).await diff --git a/core/crates/ffi/src/core_handle.rs b/core/crates/ffi/src/core_handle.rs index 2fac15fbc0..341bd3712e 100644 --- a/core/crates/ffi/src/core_handle.rs +++ b/core/crates/ffi/src/core_handle.rs @@ -22,7 +22,10 @@ use crate::cancel_token::{CancelToken, token}; use crate::drivers::{self, DriverInfo}; use crate::error::CoreError; use crate::host::{HostConfig, HostSecretStore, HostSecrets}; -use crate::library::{ConnectionLibrary, ConnectionRecord, ConnectionSecrets, apply, blank, parse_id, tls_config}; +use crate::library::{ + ConnectionLibrary, ConnectionRecord, ConnectionSecrets, LibraryWrites, apply, blank, keep_proved_secrets, parse_id, + tls_config, +}; use crate::prompter::{HostPrompter, HostPrompterBridge}; use crate::runtime::{self, on_runtime}; use crate::session::DatabaseSession; @@ -37,6 +40,7 @@ pub struct Core { vault: Arc, items: Arc, store: Option, + writes: LibraryWrites, pub(crate) tasks: Tasks, pub(crate) ssh: Arc, } @@ -88,6 +92,7 @@ impl Core { store, self.vault.clone(), self.tasks.clone(), + self.writes.clone(), ))) } @@ -144,11 +149,12 @@ impl Core { .await } - // Typed secrets come first, then Credential Manager; with no prompter an SSH login fails where it would ask. + // Typed secrets come first, then Credential Manager; `keep` is stored once it logs in; no prompter, no SSH asks. pub async fn connect_saved( &self, id: String, secrets: ConnectionSecrets, + keep: ConnectionSecrets, prompter: Option>, cancel: Option>, ) -> Result, CoreError> { @@ -158,6 +164,7 @@ impl Core { let connector = self.connector.clone(); let deadlines = self.deadlines.clone(); let vault = self.vault.clone(); + let writes = self.writes.clone(); let tasks = self.tasks.clone(); let prompter = self.prompter(prompter); let cancel = token(cancel); @@ -172,7 +179,7 @@ impl Core { .find(|saved| saved.id == id) .cloned() .ok_or_else(|| CoreError::failed("storage.connection_not_found", format!("no connection {id}")))?; - let credentials = Arc::new(Prefilled::new(&saved, vault, secrets)); + let credentials = Arc::new(Prefilled::new(&saved, vault.clone(), secrets)); let refreshed = resolve_saved( &saved, ®istry, @@ -192,6 +199,7 @@ impl Core { ); return Err(CoreError::Cancelled); } + keep_proved_secrets(&store, &vault, &writes, &tasks, &saved, keep.into_typed()).await; let session = Session::start( pending, SessionDeps { @@ -288,6 +296,7 @@ impl Core { vault, items, store, + writes: LibraryWrites::default(), tasks, ssh, }) @@ -581,7 +590,7 @@ mod tests { }; let connect = core - .connect_saved(stored.id.to_string(), typed(), None, None) + .connect_saved(stored.id.to_string(), typed(), ConnectionSecrets::default(), None, None) .await .unwrap_err(); let test = core @@ -593,6 +602,67 @@ mod tests { assert_eq!(test.code(), connect.code()); } + #[tokio::test] + async fn a_secret_a_connect_proved_is_kept_only_while_nothing_was_saved_since() { + let dir = tempfile::tempdir().unwrap(); + let store = ConnectionStore::new(&storage_paths(dir.path())); + let vault: Arc = Arc::new(Vault::default()); + let writes = LibraryWrites::default(); + let tasks = runtime::tasks().unwrap(); + let mut proved = blank(Uuid::new_v4()); + proved.driver_id = "postgres".to_owned(); + proved.host = "localhost".to_owned(); + proved.port = 5432; + proved.username = "app".to_owned(); + proved.ssh = Some(SavedSshConfig { + host: "staging-bastion".to_owned(), + port: None, + username: None, + jump_hosts: Vec::new(), + auth: SavedSshAuth::Agent, + }); + let typed = || vec![(SecretKind::DatabasePassword, SecretString::from("typed"))]; + let held = |vault: Arc, id| async move { + vault + .load(id, SecretKind::DatabasePassword) + .await + .unwrap() + .found() + .map(|secret| secret.expose_secret().to_owned()) + }; + + keep_proved_secrets(&store, &vault, &writes, &tasks, &proved, typed()).await; + let deleted = held(vault.clone(), proved.id).await; + let mut renamed = proved.clone(); + renamed.name = "renamed".to_owned(); + store.upsert_blocking(renamed.clone()).unwrap(); + keep_proved_secrets(&store, &vault, &writes, &tasks, &proved, typed()).await; + let kept = held(vault.clone(), proved.id).await; + vault.delete_connection(proved.id).await.unwrap(); + let mut moved = renamed.clone(); + moved.ssh.as_mut().unwrap().host = "prod-bastion".to_owned(); + store.upsert_blocking(moved).unwrap(); + keep_proved_secrets(&store, &vault, &writes, &tasks, &proved, typed()).await; + let after_move = held(vault.clone(), proved.id).await; + store.upsert_blocking(renamed).unwrap(); + vault + .store( + proved.id, + SecretKind::DatabasePassword, + &SecretString::from("saved since"), + "label", + ) + .await + .unwrap(); + keep_proved_secrets(&store, &vault, &writes, &tasks, &proved, typed()).await; + let after_save = held(vault.clone(), proved.id).await; + + assert_eq!(deleted, None); + assert_eq!(kept.as_deref(), Some("typed")); + assert_eq!(after_move, None); + assert_eq!(after_save.as_deref(), Some("saved since")); + } + struct Answer { value: &'static str, asked: Mutex>, diff --git a/core/crates/ffi/src/credential_manager.rs b/core/crates/ffi/src/credential_manager.rs index 309cd0280b..001d5d5d32 100644 --- a/core/crates/ffi/src/credential_manager.rs +++ b/core/crates/ffi/src/credential_manager.rs @@ -8,11 +8,23 @@ use tablepro_storage::english_item_label; use uuid::Uuid; use windows_sys::Win32::Foundation::{ERROR_NOT_FOUND, GetLastError}; use windows_sys::Win32::Security::Credentials::{ - CRED_PERSIST_LOCAL_MACHINE, CRED_TYPE_GENERIC, CREDENTIALW, CredDeleteW, CredFree, CredReadW, CredWriteW, + CRED_MAX_CREDENTIAL_BLOB_SIZE, CRED_MAX_STRING_LENGTH, CRED_PERSIST_LOCAL_MACHINE, CRED_TYPE_GENERIC, + CREDENTIAL_ATTRIBUTEW, CREDENTIALW, CredDeleteW, CredFree, CredReadW, CredWriteW, }; +use crate::credential_parts::{self, Layout, PartStore, Stored}; + static STORE: std::sync::Mutex<()> = std::sync::Mutex::new(()); +// CredWriteW refuses a larger blob, which an Entra or RDS IAM token passes. +const PART_SIZE: usize = CRED_MAX_CREDENTIAL_BLOB_SIZE as usize; + +// One unit short of CRED_MAX_STRING_LENGTH leaves room for the NUL whether or not CredWriteW counts it. +const COMMENT_UNITS: usize = CRED_MAX_STRING_LENGTH as usize - 1; + +// An attribute keyword of the form CREDENTIAL_ATTRIBUTEW asks for, _. +const LAYOUT_KEYWORD: &str = "TablePro_Parts"; + // Generic credentials under one prefix, so Credential Manager lists TablePro's together and a test keeps to its own. pub(crate) struct CredentialManager { prefix: String, @@ -113,79 +125,143 @@ fn decode(blob: &[u8]) -> Result { Ok(SecretString::from(text)) } -fn read(target: &str) -> Result, SecretError> { - let name = wide(target); - let mut found: *mut CREDENTIALW = std::ptr::null_mut(); - // SAFETY: `name` is NUL-terminated and outlives the call; `found` receives a buffer CredFree releases. - let ok = unsafe { CredReadW(name.as_ptr(), CRED_TYPE_GENERIC, 0, &raw mut found) }; - if ok == 0 { - // SAFETY: reads the last error CredReadW set. - if unsafe { GetLastError() } == ERROR_NOT_FOUND { - return Ok(None); +struct Credentials; + +impl PartStore for Credentials { + type Error = SecretError; + + fn read(&self, target: &str) -> Result, SecretError> { + let name = wide(target); + let mut found: *mut CREDENTIALW = std::ptr::null_mut(); + // SAFETY: `name` is NUL-terminated and outlives the call; `found` receives a buffer CredFree releases. + let ok = unsafe { CredReadW(name.as_ptr(), CRED_TYPE_GENERIC, 0, &raw mut found) }; + if ok == 0 { + // SAFETY: reads the last error CredReadW set. + if unsafe { GetLastError() } == ERROR_NOT_FOUND { + return Ok(None); + } + return Err(failure("read")); } - return Err(failure("read")); - } - // SAFETY: CredReadW succeeded, so `found` is live until CredFree, the process owns it, and a non-null blob - // holds its size. - let decoded = unsafe { - let credential = &*found; - let size = credential.CredentialBlobSize as usize; - if credential.CredentialBlob.is_null() || size == 0 { - decode(&[]) + let keyword = wide(LAYOUT_KEYWORD); + // SAFETY: CredReadW succeeded: `found`, its blob and its attributes are live and sized as given until CredFree. + let stored = unsafe { + let credential = &*found; + let size = credential.CredentialBlobSize as usize; + let blob = if credential.CredentialBlob.is_null() || size == 0 { + Zeroizing::new(Vec::new()) + } else { + let blob = std::slice::from_raw_parts_mut(credential.CredentialBlob, size); + let copied = Zeroizing::new(blob.to_vec()); + // CredFree releases the block as it is, so the decrypted text would stay in freed memory. + blob.zeroize(); + copied + }; + let attributes = if credential.Attributes.is_null() { + &[][..] + } else { + std::slice::from_raw_parts(credential.Attributes, credential.AttributeCount as usize) + }; + let layout = attributes + .iter() + .find(|attribute| names(attribute.Keyword, &keyword)) + .filter(|attribute| !attribute.Value.is_null()) + .and_then(|attribute| { + Layout::from_bytes(std::slice::from_raw_parts( + attribute.Value, + attribute.ValueSize as usize, + )) + }); + Stored { blob, layout } + }; + // SAFETY: `found` came from CredReadW and is freed once. + unsafe { CredFree(found.cast_const().cast()) }; + Ok(Some(stored)) + } + + fn write(&self, target: &str, blob: &[u8], label: &str, layout: Option) -> Result<(), SecretError> { + let name = wide(target); + let mut comment = wide(credential_parts::fitted(label, COMMENT_UNITS)); + let mut user = wide("TablePro"); + let size = u32::try_from(blob.len()).map_err(|_| SecretError::Backend { + detail: "a part of the secret is too long for Credential Manager".to_owned(), + service_message: None, + })?; + // SAFETY: every field of CREDENTIALW is a number or a pointer, for which zero is valid. + let mut credential: CREDENTIALW = unsafe { std::mem::zeroed() }; + credential.Type = CRED_TYPE_GENERIC; + credential.TargetName = name.as_ptr().cast_mut(); + credential.Comment = comment.as_mut_ptr(); + credential.CredentialBlobSize = size; + // CredWriteW reads the blob and never writes through the pointer. + credential.CredentialBlob = if blob.is_empty() { + std::ptr::null_mut() } else { - let blob = std::slice::from_raw_parts_mut(credential.CredentialBlob, size); - let decoded = decode(blob); - // CredFree releases the block as it is, so the decrypted text would stay in freed memory. - blob.zeroize(); - decoded + blob.as_ptr().cast_mut() + }; + credential.Persist = CRED_PERSIST_LOCAL_MACHINE; + credential.UserName = user.as_mut_ptr(); + let mut keyword = wide(LAYOUT_KEYWORD); + let mut value = layout.map(Layout::to_bytes); + let mut attribute = CREDENTIAL_ATTRIBUTEW::default(); + if let Some(value) = value.as_mut() { + attribute.Keyword = keyword.as_mut_ptr(); + attribute.ValueSize = Layout::SIZE as u32; + attribute.Value = value.as_mut_ptr(); + credential.AttributeCount = 1; + credential.Attributes = &raw mut attribute; + } + // SAFETY: every pointer in `credential` points into a buffer that outlives the call. + let ok = unsafe { CredWriteW(&raw const credential, 0) }; + if ok == 0 { + return Err(failure("write")); + } + Ok(()) + } + + fn delete(&self, target: &str) -> Result { + let name = wide(target); + // SAFETY: `name` is NUL-terminated and outlives the call. + if unsafe { CredDeleteW(name.as_ptr(), CRED_TYPE_GENERIC, 0) } != 0 { + return Ok(true); + } + // SAFETY: reads the last error CredDeleteW set. + if unsafe { GetLastError() } == ERROR_NOT_FOUND { + return Ok(false); + } + Err(failure("delete")) + } +} + +// The keyword is NUL-terminated, and a shorter one differs at its NUL before anything past it is read. +unsafe fn names(keyword: *const u16, expected: &[u16]) -> bool { + if keyword.is_null() { + return false; + } + for (index, unit) in expected.iter().enumerate() { + // SAFETY: every unit before `index` matched one of `expected`'s, none of which is the NUL before its last. + if unsafe { *keyword.add(index) } != *unit { + return false; } - }; - // SAFETY: `found` came from CredReadW and is freed once. - unsafe { CredFree(found.cast_const().cast()) }; - decoded.map(Some) + } + true +} + +fn read(target: &str) -> Result, SecretError> { + match credential_parts::read_secret(&Credentials, target)? { + Some(blob) => decode(&blob).map(Some), + None => Ok(None), + } } fn write(target: &str, secret: &str, label: &str) -> Result<(), SecretError> { - let name = wide(target); - let mut comment = wide(label); - let mut user = wide("TablePro"); // Sized up front: a collect that grew would leave parts of the secret in the buffers it gave up. let mut blob: Zeroizing> = Zeroizing::new(Vec::with_capacity(secret.encode_utf16().count() * 2)); blob.extend(secret.encode_utf16().flat_map(u16::to_le_bytes)); - let size = u32::try_from(blob.len()).map_err(|_| SecretError::Backend { - detail: "the secret is too long for Credential Manager".to_owned(), - service_message: None, - })?; - // SAFETY: every field of CREDENTIALW is a number or a pointer, for which zero is valid. - let mut credential: CREDENTIALW = unsafe { std::mem::zeroed() }; - credential.Type = CRED_TYPE_GENERIC; - credential.TargetName = name.as_ptr().cast_mut(); - credential.Comment = comment.as_mut_ptr(); - credential.CredentialBlobSize = size; - credential.CredentialBlob = if blob.is_empty() { - std::ptr::null_mut() - } else { - blob.as_mut_ptr() - }; - credential.Persist = CRED_PERSIST_LOCAL_MACHINE; - credential.UserName = user.as_mut_ptr(); - // SAFETY: every pointer in `credential` points into a buffer that outlives the call. - let ok = unsafe { CredWriteW(&raw const credential, 0) }; - if ok == 0 { - return Err(failure("write")); - } - Ok(()) + credential_parts::write_secret(&Credentials, target, &blob, label, PART_SIZE) } fn delete(target: &str) -> Result<(), SecretError> { - let name = wide(target); - // SAFETY: `name` is NUL-terminated and outlives the call. - let ok = unsafe { CredDeleteW(name.as_ptr(), CRED_TYPE_GENERIC, 0) }; - // SAFETY: reads the last error CredDeleteW set. - if ok == 0 && unsafe { GetLastError() } != ERROR_NOT_FOUND { - return Err(failure("delete")); - } - Ok(()) + credential_parts::delete_secret(&Credentials, target) } #[async_trait] @@ -301,6 +377,74 @@ mod tests { ); } + #[tokio::test] + async fn a_token_longer_than_one_credential_holds_is_kept_whole_under_a_long_label() { + let manager = manager(); + let id = Uuid::new_v4(); + // The key's two UTF-16 units straddle the first credential's last byte. + let token = format!("{}\u{1f511}{}", "a".repeat(PART_SIZE / 2 - 1), "b".repeat(2000)); + let label = "l".repeat(1000); + + manager + .store( + id, + SecretKind::DatabasePassword, + &SecretString::from(token.clone()), + &label, + ) + .await + .unwrap(); + let found = manager.load(id, SecretKind::DatabasePassword).await.unwrap(); + manager + .store(id, SecretKind::DatabasePassword, &SecretString::from("short"), &label) + .await + .unwrap(); + let shortened = manager.load(id, SecretKind::DatabasePassword).await.unwrap(); + let continued = Credentials + .read(&format!( + "{}/1", + manager.connection_target(id, SecretKind::DatabasePassword) + )) + .unwrap(); + manager.delete_connection(id).await.unwrap(); + + assert_eq!( + found.found().map(|secret| secret.expose_secret().to_owned()), + Some(token) + ); + assert_eq!( + shortened.found().map(|secret| secret.expose_secret().to_owned()), + Some("short".to_owned()) + ); + assert!(continued.is_none()); + } + + #[tokio::test] + async fn a_secret_that_fills_a_credential_exactly_reads_back() { + let manager = manager(); + let id = Uuid::new_v4(); + let secret = "x".repeat(PART_SIZE); + + manager + .store( + id, + SecretKind::SshPassphrase, + &SecretString::from(secret.clone()), + "label", + ) + .await + .unwrap(); + let found = manager.load(id, SecretKind::SshPassphrase).await.unwrap(); + manager.delete_connection(id).await.unwrap(); + let gone = manager.load(id, SecretKind::SshPassphrase).await.unwrap(); + + assert_eq!( + found.found().map(|secret| secret.expose_secret().to_owned()), + Some(secret) + ); + assert!(!gone.is_stored()); + } + #[tokio::test] async fn relabelling_keeps_the_secret_and_a_missing_one_stays_missing() { let manager = manager(); diff --git a/core/crates/ffi/src/credential_parts.rs b/core/crates/ffi/src/credential_parts.rs new file mode 100644 index 0000000000..2a7ee3484e --- /dev/null +++ b/core/crates/ffi/src/credential_parts.rs @@ -0,0 +1,355 @@ +use secrecy::zeroize::Zeroizing; +use uuid::Uuid; + +// Credential Manager caps one credential's blob, so a longer secret goes on in `/1`, `/2` and on. +pub(crate) trait PartStore { + type Error; + + fn read(&self, target: &str) -> Result, Self::Error>; + + fn write(&self, target: &str, blob: &[u8], label: &str, layout: Option) -> Result<(), Self::Error>; + + // Ok(false) lets a cleanup stop at the first part that is gone. + fn delete(&self, target: &str) -> Result; +} + +pub(crate) struct Stored { + pub(crate) blob: Zeroizing>, + pub(crate) layout: Option, +} + +// Every part of a split secret carries it, so a write cut short between parts reads as no secret, never as a mix. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct Layout { + pub(crate) write_id: [u8; 16], + pub(crate) parts: u32, + pub(crate) bytes: u32, +} + +impl Layout { + pub(crate) const SIZE: usize = 24; + + pub(crate) fn to_bytes(self) -> [u8; Self::SIZE] { + let mut bytes = [0; Self::SIZE]; + bytes[..16].copy_from_slice(&self.write_id); + bytes[16..20].copy_from_slice(&self.parts.to_le_bytes()); + bytes[20..].copy_from_slice(&self.bytes.to_le_bytes()); + bytes + } + + pub(crate) fn from_bytes(bytes: &[u8]) -> Option { + if bytes.len() != Self::SIZE { + return None; + } + Some(Self { + write_id: bytes[..16].try_into().ok()?, + parts: u32::from_le_bytes(bytes[16..20].try_into().ok()?), + bytes: u32::from_le_bytes(bytes[20..].try_into().ok()?), + }) + } +} + +pub(crate) fn part_target(target: &str, index: usize) -> String { + if index == 0 { + target.to_owned() + } else { + format!("{target}/{index}") + } +} + +// A secret one credential holds has no layout, as every secret stored before the split had none. +pub(crate) fn read_secret(store: &S, target: &str) -> Result>>, S::Error> { + let Some(first) = store.read(target)? else { + return Ok(None); + }; + let Some(layout) = first.layout else { + return Ok(Some(first.blob)); + }; + let mut parts = vec![first.blob]; + for index in 1..layout.parts as usize { + match store.read(&part_target(target, index))? { + Some(part) if part.layout == Some(layout) => parts.push(part.blob), + _ => return Ok(torn(target)), + } + } + let size: usize = parts.iter().map(|part| part.len()).sum(); + if size != layout.bytes as usize { + return Ok(torn(target)); + } + // Sized up front: a growing buffer would leave parts of the secret in the memory it gave up. + let mut blob = Zeroizing::new(Vec::with_capacity(size)); + for part in &parts { + blob.extend_from_slice(part); + } + Ok(Some(blob)) +} + +// Read as not stored, so the app asks for the secret again rather than send a wrong one. +fn torn(target: &str) -> Option>> { + tracing::warn!( + credential = target, + "a secret split over several credentials has a part missing or from another write" + ); + None +} + +pub(crate) fn write_secret( + store: &S, + target: &str, + blob: &[u8], + label: &str, + part_size: usize, +) -> Result<(), S::Error> { + let before = held_parts(store, target)?; + let parts: Vec<&[u8]> = if blob.len() <= part_size { + vec![blob] + } else { + blob.chunks(part_size).collect() + }; + let layout = match (u32::try_from(parts.len()), u32::try_from(blob.len())) { + (Ok(count), Ok(bytes)) if count > 1 => Some(Layout { + write_id: Uuid::new_v4().into_bytes(), + parts: count, + bytes, + }), + _ => None, + }; + // The first part goes last, so a write cut short leaves the secret before it whole or reads as none. + for (index, part) in parts.iter().enumerate().skip(1) { + store.write(&part_target(target, index), part, label, layout)?; + } + store.write(target, parts[0], label, layout)?; + delete_parts(store, target, parts.len(), before) +} + +pub(crate) fn delete_secret(store: &S, target: &str) -> Result<(), S::Error> { + let before = held_parts(store, target)?; + delete_parts(store, target, 1, before)?; + store.delete(target)?; + Ok(()) +} + +fn held_parts(store: &S, target: &str) -> Result { + Ok(store + .read(target)? + .and_then(|stored| stored.layout) + .map_or(1, |layout| layout.parts as usize)) +} + +// The parts of the secret before, last first, so a cleanup cut short leaves a run from `from` the next one finds. +fn delete_parts(store: &S, target: &str, from: usize, before: usize) -> Result<(), S::Error> { + for index in (from..before).rev() { + store.delete(&part_target(target, index))?; + } + let mut index = from.max(before); + while store.delete(&part_target(target, index))? { + index += 1; + } + Ok(()) +} + +// CredWriteW refuses a longer comment, and the label only describes the entry, so it is cut between characters. +pub(crate) fn fitted(label: &str, units: usize) -> &str { + let mut used = 0; + for (index, character) in label.char_indices() { + used += character.len_utf16(); + if used > units { + return &label[..index]; + } + } + label +} + +#[cfg(test)] +mod tests { + use super::*; + use std::cell::RefCell; + use std::collections::BTreeMap; + + const SIZE: usize = 4; + + type Held = BTreeMap, Option)>; + + // Refuses a blob over SIZE bytes, as CredWriteW refuses one over CRED_MAX_CREDENTIAL_BLOB_SIZE. + #[derive(Default)] + struct Store { + held: RefCell, + refuses: Option, + } + + impl PartStore for Store { + type Error = String; + + fn read(&self, target: &str) -> Result, String> { + Ok(self.held.borrow().get(target).map(|(blob, layout)| Stored { + blob: Zeroizing::new(blob.clone()), + layout: *layout, + })) + } + + fn write(&self, target: &str, blob: &[u8], _label: &str, layout: Option) -> Result<(), String> { + if blob.len() > SIZE || self.refuses.as_deref() == Some(target) { + return Err(format!("refused {target}")); + } + self.held + .borrow_mut() + .insert(target.to_owned(), (blob.to_vec(), layout)); + Ok(()) + } + + fn delete(&self, target: &str) -> Result { + Ok(self.held.borrow_mut().remove(target).is_some()) + } + } + + impl Store { + fn names(&self) -> Vec { + self.held.borrow().keys().cloned().collect() + } + + fn secret(&self) -> Option> { + read_secret(self, "t").unwrap().map(|blob| blob.to_vec()) + } + + fn save(&self, secret: &[u8]) -> Result<(), String> { + write_secret(self, "t", secret, "label", SIZE) + } + + fn put(&self, target: &str, blob: &[u8]) { + self.held.borrow_mut().insert(target.to_owned(), (blob.to_vec(), None)); + } + } + + #[test] + fn a_secret_longer_than_one_part_reads_back_whole() { + let store = Store::default(); + + store.save(b"0123456789").unwrap(); + + assert_eq!(store.names(), ["t", "t/1", "t/2"]); + assert_eq!(store.secret(), Some(b"0123456789".to_vec())); + } + + #[test] + fn a_secret_that_fills_its_parts_exactly_reads_back() { + let store = Store::default(); + + store.save(b"01234567").unwrap(); + + assert_eq!(store.names(), ["t", "t/1"]); + assert_eq!(store.secret(), Some(b"01234567".to_vec())); + } + + #[test] + fn a_secret_one_part_holds_is_stored_as_before_the_split() { + let store = Store::default(); + store.put("t", b"ab"); + + assert_eq!(store.secret(), Some(b"ab".to_vec())); + + store.save(b"abcd").unwrap(); + + assert_eq!(store.held.borrow()["t"], (b"abcd".to_vec(), None)); + } + + #[test] + fn a_shorter_secret_leaves_none_of_a_longer_ones_parts() { + let store = Store::default(); + store.save(b"0123456789").unwrap(); + + store.save(b"abcd").unwrap(); + + assert_eq!(store.names(), ["t"]); + assert_eq!(store.secret(), Some(b"abcd".to_vec())); + } + + #[test] + fn an_empty_secret_is_stored_as_one() { + let store = Store::default(); + store.save(b"0123456789").unwrap(); + + store.save(b"").unwrap(); + + assert_eq!(store.names(), ["t"]); + assert_eq!(store.secret(), Some(Vec::new())); + } + + #[test] + fn deleting_removes_every_part_and_a_missing_secret_reads_as_none() { + let store = Store::default(); + store.save(b"0123456789").unwrap(); + store.put("other", b"kept"); + + delete_secret(&store, "t").unwrap(); + + assert_eq!(store.names(), ["other"]); + assert_eq!(store.secret(), None); + } + + #[test] + fn a_write_cut_short_over_a_split_secret_reads_as_none_never_a_mix() { + let store = Store::default(); + store.save(b"0123456789").unwrap(); + let refusing = Store { + held: RefCell::new(store.held.borrow().clone()), + refuses: Some("t".to_owned()), + }; + + assert!(refusing.save(b"abcdefghij").is_err()); + + assert_eq!(refusing.secret(), None); + } + + #[test] + fn a_write_cut_short_keeps_the_secret_one_credential_held() { + let store = Store { + refuses: Some("t/2".to_owned()), + ..Store::default() + }; + store.put("t", b"ab"); + + assert!(store.save(b"0123456789").is_err()); + + assert_eq!(store.secret(), Some(b"ab".to_vec())); + } + + #[test] + fn parts_a_cleanup_left_behind_go_with_the_next_write_or_delete() { + let store = Store::default(); + store.put("t", b"ab"); + store.put("t/1", b"0123"); + store.put("t/2", b"45"); + + store.save(b"xy").unwrap(); + + assert_eq!(store.names(), ["t"]); + + store.held.borrow_mut().remove("t"); + store.put("t/1", b"0123"); + + delete_secret(&store, "t").unwrap(); + + assert!(store.names().is_empty()); + } + + #[test] + fn a_layout_reads_back_from_its_bytes() { + let layout = Layout { + write_id: *Uuid::new_v4().as_bytes(), + parts: 3, + bytes: 6000, + }; + + assert_eq!(Layout::from_bytes(&layout.to_bytes()), Some(layout)); + assert_eq!(Layout::from_bytes(&[0; 8]), None); + } + + #[test] + fn a_label_is_cut_between_characters() { + assert_eq!(fitted("short", 255), "short"); + assert_eq!(fitted("abcdef", 4), "abcd"); + // The key is two UTF-16 units, which a cut never splits. + assert_eq!(fitted("abc\u{1f511}d", 4), "abc"); + assert_eq!(fitted("abc\u{1f511}d", 5), "abc\u{1f511}"); + } +} diff --git a/core/crates/ffi/src/lib.rs b/core/crates/ffi/src/lib.rs index 55034ff845..3cd5086513 100644 --- a/core/crates/ffi/src/lib.rs +++ b/core/crates/ffi/src/lib.rs @@ -7,6 +7,8 @@ mod connection_url; mod core_handle; #[cfg(windows)] mod credential_manager; +#[cfg(any(windows, test))] +mod credential_parts; mod drivers; mod editor; mod error; diff --git a/core/crates/ffi/src/library.rs b/core/crates/ffi/src/library.rs index 7d6054b31c..26ea269e5a 100644 --- a/core/crates/ffi/src/library.rs +++ b/core/crates/ffi/src/library.rs @@ -195,16 +195,78 @@ const RECENT_LIMIT: usize = 8; // A kind as the vault held it before a save, None for no value or one that could not be read. type HeldValue = (SecretKind, Option); +// Held by every write that can change or drop a connection, and by a connect keeping the secret it logged in with. +pub(crate) type LibraryWrites = Arc>; + +// An edit, a delete or a secret saved since the connect read the record wins: what it typed may unlock nothing now. +pub(crate) async fn keep_proved_secrets( + store: &ConnectionStore, + vault: &Arc, + writes: &LibraryWrites, + tasks: &Tasks, + proved: &SavedConnection, + typed: Vec<(SecretKind, SecretString)>, +) { + if typed.is_empty() { + return; + } + let _held = writes.lock().await; + let reader = store.clone(); + let id = proved.id; + let current = match tasks.spawn_blocking_task(move || reader.list_blocking()).await { + Ok(Ok(list)) => list.connections.iter().find(|saved| saved.id == id).cloned(), + Ok(Err(error)) => { + tracing::warn!(%error, "could not read the connection to keep the secret its connect logged in with"); + return; + } + Err(failure) => { + tracing::warn!(%failure, "could not read the connection to keep the secret its connect logged in with"); + return; + } + }; + let Some(current) = current.filter(|current| current.connects_like(proved)) else { + return; + }; + for (kind, secret) in typed { + // The connect asked for it because none was stored, so one stored now came from a save since. + if !matches!(vault.load(id, kind).await, Ok(SecretLookup::NotStored)) { + continue; + } + let target = current.secret_target(kind); + if let Err(error) = vault + .store(id, kind, &secret, &english_secret_label(kind, &target)) + .await + { + tracing::warn!(%error, "could not keep the secret a connect logged in with"); + } + } +} + #[derive(uniffi::Object)] pub struct ConnectionLibrary { store: ConnectionStore, secrets: Arc, tasks: Tasks, + writes: LibraryWrites, } impl ConnectionLibrary { - pub(crate) fn new(store: ConnectionStore, secrets: Arc, tasks: Tasks) -> Self { - Self { store, secrets, tasks } + pub(crate) fn new( + store: ConnectionStore, + secrets: Arc, + tasks: Tasks, + writes: LibraryWrites, + ) -> Self { + Self { + store, + secrets, + tasks, + writes, + } + } + + pub(crate) async fn hold_writes(&self) -> tokio::sync::MutexGuard<'_, ()> { + self.writes.lock().await } pub(crate) async fn delete_secrets(&self, ids: Vec) -> Result<(), CoreError> { @@ -385,6 +447,7 @@ impl ConnectionLibrary { let tls = tls_config(&record.tls)?; let typed = secrets.into_typed(); let kinds = typed.iter().map(|(kind, _)| *kind).collect(); + let _held = self.hold_writes().await; // Read before anything is written, for a refused secret to put back. let previous = match id { Some(id) => self.held_values(id, kinds).await?, @@ -429,6 +492,7 @@ impl ConnectionLibrary { // Secrets go first, so a refused store leaves the connection listed to delete again, never a secret no entry names. pub async fn delete(&self, id: String) -> Result<(), CoreError> { let id = parse_id(&id)?; + let _held = self.hold_writes().await; self.delete_secrets(vec![id]).await?; self.blocking(move |store| { store.remove_blocking(id)?; @@ -584,6 +648,7 @@ impl ConnectionLibrary { // Merges a TablePro connections file; it carries no passwords. pub async fn import_file(&self, path: String) -> Result { + let _held = self.hold_writes().await; self.blocking(move |store| { let path = PathBuf::from(path); let bytes = std::fs::read(&path).map_err(|error| { diff --git a/core/crates/ffi/tests/library.rs b/core/crates/ffi/tests/library.rs index 02bc1dee6f..4c704a8e07 100644 --- a/core/crates/ffi/tests/library.rs +++ b/core/crates/ffi/tests/library.rs @@ -543,7 +543,13 @@ async fn a_saved_sqlite_file_connects_lists_its_tables_and_becomes_recent() { .unwrap(); let session = core - .connect_saved(saved.id.clone(), ConnectionSecrets::default(), None, None) + .connect_saved( + saved.id.clone(), + ConnectionSecrets::default(), + ConnectionSecrets::default(), + None, + None, + ) .await .unwrap(); let objects = session.objects(ObjectScopeArg::DefaultSchema, None).await.unwrap(); @@ -599,6 +605,46 @@ async fn a_test_logs_in_and_a_missing_file_fails_by_code() { assert_eq!(missing.code(), "driver.file_not_found"); } +#[tokio::test] +async fn a_typed_secret_is_kept_once_its_connect_logs_in_and_not_when_it_fails() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("people.sqlite"); + let secrets = MemorySecrets::default(); + let core = core(dir.path(), secrets.clone()); + sqlite_file(&core, &path).await; + let library = core.library().unwrap(); + let people = library + .save( + record("people", "sqlite", &path.display().to_string()), + ConnectionSecrets::default(), + ) + .await + .unwrap(); + let mut shop = record("shop", "postgres", "shop"); + shop.host = "127.0.0.1".to_owned(); + shop.port = 1; + let shop = library.save(shop, ConnectionSecrets::default()).await.unwrap(); + let typed = || ConnectionSecrets { + database_password: Some(SecretString::from("typed")), + ..ConnectionSecrets::default() + }; + + core.connect_saved(people.id.clone(), typed(), typed(), None, None) + .await + .unwrap(); + core.connect_saved(shop.id.clone(), typed(), typed(), None, None) + .await + .unwrap_err(); + + let held = secrets.0.lock().unwrap(); + assert_eq!( + held.get(&(people.id, SecretKindTag::DatabasePassword)) + .map(|secret| secret.expose_secret().to_owned()), + Some("typed".to_owned()) + ); + assert!(!held.contains_key(&(shop.id, SecretKindTag::DatabasePassword))); +} + #[tokio::test] async fn a_network_login_with_no_saved_password_says_so() { let dir = tempfile::tempdir().unwrap(); @@ -610,7 +656,13 @@ async fn a_network_login_with_no_saved_password_says_so() { let saved = library.save(shop, ConnectionSecrets::default()).await.unwrap(); let error = core - .connect_saved(saved.id, ConnectionSecrets::default(), None, None) + .connect_saved( + saved.id, + ConnectionSecrets::default(), + ConnectionSecrets::default(), + None, + None, + ) .await .unwrap_err(); @@ -638,6 +690,7 @@ async fn a_password_typed_at_connect_is_used_when_none_is_saved() { database_password: Some(SecretString::from("typed")), ..ConnectionSecrets::default() }, + ConnectionSecrets::default(), None, None, ) @@ -769,6 +822,7 @@ async fn an_empty_database_password_survives_a_separately_stored_ssh_password() database_password: Some(SecretString::from("")), ..ConnectionSecrets::default() }, + ConnectionSecrets::default(), None, None, ) diff --git a/core/crates/ffi/tests/row_edits.rs b/core/crates/ffi/tests/row_edits.rs index f089cc0d1d..44d773ca08 100644 --- a/core/crates/ffi/tests/row_edits.rs +++ b/core/crates/ffi/tests/row_edits.rs @@ -163,9 +163,15 @@ async fn saved(core: &Core, path: &Path, safe_mode: SafeModeTag) -> Arc Arc