From 42a91972db82e32cf7e66432205be795028f6aba Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 11:09:54 +0100 Subject: [PATCH] Retain named production provider after incompatible Chrony reply evaluation --- crates/time-source-linux/src/native.rs | 218 +++++++++++++------------ docs/handover.md | 6 + 2 files changed, 118 insertions(+), 106 deletions(-) diff --git a/crates/time-source-linux/src/native.rs b/crates/time-source-linux/src/native.rs index 44f73f1..f36d06a 100644 --- a/crates/time-source-linux/src/native.rs +++ b/crates/time-source-linux/src/native.rs @@ -6,7 +6,7 @@ use std::ffi::CString; use std::fs::File; use std::io::Read; use std::mem::{self, size_of, size_of_val}; -use std::os::fd::{AsRawFd, FromRawFd, IntoRawFd, OwnedFd, RawFd}; +use std::os::fd::{AsRawFd, FromRawFd, OwnedFd, RawFd}; use std::os::unix::fs::MetadataExt; use uuid::Uuid; @@ -429,30 +429,11 @@ fn address(path: &str) -> Result<(libc::sockaddr_un, libc::socklen_t)> { (mem::offset_of!(libc::sockaddr_un, sun_path) + path.len() + 1) as _, )) } -fn abstract_address(random: Uuid) -> (libc::sockaddr_un, libc::socklen_t) { - let name = format!("rmm-time-source-tracking-{}", random.simple()); - let mut addr: libc::sockaddr_un = unsafe { mem::zeroed() }; - addr.sun_family = libc::AF_UNIX as _; - // Leading NUL selects Linux's abstract namespace. The exact length excludes - // a trailing NUL: every byte after sun_path[0] belongs to the kernel name. - for (dst, src) in addr.sun_path[1..].iter_mut().zip(name.bytes()) { - *dst = src as _; - } - let len = mem::offset_of!(libc::sockaddr_un, sun_path) + 1 + name.len(); - (addr, len as _) -} -fn bind_once(fd: RawFd, addr: &libc::sockaddr_un, len: libc::socklen_t) -> Result<()> { - ensure!( - unsafe { libc::bind(fd, (addr as *const libc::sockaddr_un).cast(), len) } == 0, - "TIME_CLIENT_BIND_ONCE" - ); - Ok(()) -} struct Client { fd: OwnedFd, dir: OwnedFd, - address: libc::sockaddr_un, - address_len: libc::socklen_t, + name: String, + own: Option, } impl Client { fn open(gid: u32) -> Result { @@ -477,17 +458,62 @@ impl Client { 0, ) })?; - // UUIDv4 uses the OS CSPRNG. A collision denies this observation: no new - // name, adoption, connect retry or filesystem cleanup is attempted. - let (abstract_addr, address_len) = abstract_address(Uuid::new_v4()); - let value = Self { + let name = format!("tracking-{}.sock", Uuid::new_v4().simple()); + let mut value = Self { fd, dir, - address: abstract_addr, - address_len, + name, + own: None, }; + let (addr, len) = address(&format!("{CLIENT_DIR}/{}", value.name))?; bound_dir(CLIENT_DIR, &value.dir, None)?; - bind_once(value.fd.as_raw_fd(), &value.address, value.address_len)?; + ensure!( + unsafe { + libc::bind( + value.fd.as_raw_fd(), + (&addr as *const libc::sockaddr_un).cast(), + len, + ) + } == 0, + "TIME_CLIENT_BIND_ONCE" + ); + let mut own = socket_identity(value.dir.as_raw_fd(), &value.name)?; + ensure!( + own.uid == 0 && own.mode & libc::S_IFMT == libc::S_IFSOCK && own.links == 1, + "TIME_CLIENT_INITIAL_IDENTITY" + ); + value.own = Some(own); + let name = cstr(&value.name)?; + ensure!( + unsafe { + libc::fchownat( + value.dir.as_raw_fd(), + name.as_ptr(), + 0, + gid, + libc::AT_SYMLINK_NOFOLLOW, + ) + } == 0, + "TIME_CLIENT_GROUP" + ); + // Parent is root-write-only: no daemon or unprivileged process can swap + // the leaf between this identity capture and chmod. + ensure!( + unsafe { libc::fchmodat(value.dir.as_raw_fd(), name.as_ptr(), 0o660, 0) } == 0, + "TIME_CLIENT_MODE" + ); + let next = socket_identity(value.dir.as_raw_fd(), &value.name)?; + ensure!( + next.dev == own.dev + && next.ino == own.ino + && next.uid == 0 + && next.gid == gid + && next.mode & 0o7777 == 0o660 + && next.links == 1, + "TIME_CLIENT_READY_IDENTITY" + ); + own = next; + value.own = Some(own); value.verify()?; let yes: libc::c_int = 1; ensure!( @@ -517,31 +543,21 @@ impl Client { } fn verify(&self) -> Result<()> { bound_dir(CLIENT_DIR, &self.dir, None)?; - let mut actual: libc::sockaddr_un = unsafe { mem::zeroed() }; - let mut len = size_of::() as libc::socklen_t; ensure!( - unsafe { - libc::getsockname( - self.fd.as_raw_fd(), - (&mut actual as *mut libc::sockaddr_un).cast(), - &mut len, - ) - } == 0 - && len == self.address_len - && actual.sun_family == self.address.sun_family - && actual.sun_path == self.address.sun_path, - "TIME_CLIENT_ABSTRACT_IDENTITY" + Some(socket_identity(self.dir.as_raw_fd(), &self.name)?) == self.own, + "TIME_CLIENT_REPLACED" ); Ok(()) } - fn cleanup(self) -> Result<()> { - self.verify()?; - // Consume descriptor ownership before close. Linux releases the fd even - // on a close error; retrying could close a reused descriptor. Any error - // leaves the source poisoned and cannot produce positive quality. - let fd = self.fd.into_raw_fd(); - ensure!(unsafe { libc::close(fd) } == 0, "TIME_CLIENT_CLOSE_ONCE"); - Ok(()) + fn cleanup(&mut self) -> Result<()> { + // Consume cleanup authority before any fallible work. Unknown cleanup + // never retries from Drop and never adopts a newly observed leaf. + let expected = self + .own + .take() + .context("TIME_CLIENT_CLEANUP_ALREADY_ATTEMPTED")?; + bound_dir(CLIENT_DIR, &self.dir, None)?; + unlink_owned(self.dir.as_raw_fd(), &self.name, expected) } fn exchange(&self, sequence: u32, daemon: &Pin, start: Capture) -> Result { let request = tracking::request(sequence); @@ -638,6 +654,27 @@ impl Client { tracking::reply(&packet, sequence) } } +fn unlink_owned(dir: RawFd, name: &str, expected: Identity) -> Result<()> { + ensure!( + socket_identity(dir, name)? == expected, + "TIME_CLIENT_CLEANUP_IDENTITY" + ); + let name = cstr(name)?; + ensure!( + unsafe { libc::unlinkat(dir, name.as_ptr(), 0) } == 0, + "TIME_CLIENT_UNLINK" + ); + Ok(()) +} +impl Drop for Client { + fn drop(&mut self) { + // Lost identity is intentionally retained, never recursively removed. + if self.own.is_some() { + let _ = self.cleanup(); + } + } +} + // Linux pathname DGRAM send requires socket write permission; read/execute // bits grant no sending authority. Directory ancestry is separately held and // verified. Neither group nor other may write this daemon-owned socket. @@ -707,7 +744,7 @@ impl NativeTimeSource { let first = kernel()?; self.verify()?; self.poisoned = true; - let client = Client::open(self.daemon.pin.daemon_gid)?; + let mut client = Client::open(self.daemon.pin.daemon_gid)?; let random = Uuid::new_v4(); let sequence = u32::from_ne_bytes(random.as_bytes()[..4].try_into()?); let report = client.exchange(sequence, &self.daemon.pin, before)?; @@ -815,14 +852,22 @@ mod tests { ); } #[test] - fn server_socket_protection_requires_pinned_owner_and_no_group_write() { + fn socket_cleanup_preserves_replaced_name_and_removes_only_exact_own_inode() { + use std::os::unix::{fs::PermissionsExt, net::UnixDatagram}; + let path = std::env::temp_dir().join(format!("rmm-time-source-unit-{}", Uuid::new_v4())); + std::fs::create_dir(&path).unwrap(); + std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o700)).unwrap(); + let dir = openat( + libc::AT_FDCWD, + path.to_str().unwrap(), + libc::O_RDONLY | libc::O_DIRECTORY, + ) + .unwrap(); + let old = UnixDatagram::bind(path.join("own.sock")).unwrap(); + let expected = socket_identity(dir.as_raw_fd(), "own.sock").unwrap(); let server = Identity { - dev: 1, - ino: 2, - uid: 989, - gid: 989, mode: libc::S_IFSOCK | 0o755, - links: 1, + ..expected }; assert!(protected_server_socket(server, server.uid, server.gid)); for mode in [0o775, 0o757] { @@ -835,54 +880,15 @@ mod tests { server.gid, )); } - assert!(!protected_server_socket(server, 0, server.gid)); - assert!(!protected_server_socket(server, server.uid, 0)); - } - #[test] - fn abstract_address_is_exact_kernel_namespace_and_not_a_pathname() { - let (addr, len) = abstract_address(Uuid::from_bytes([0x17; 16])); - let name = b"rmm-time-source-tracking-17171717171717171717171717171717"; - assert_eq!(addr.sun_family as i32, libc::AF_UNIX); - assert_eq!(addr.sun_path[0], 0); - assert_eq!( - addr.sun_path[1..=name.len()] - .iter() - .map(|v| *v as u8) - .collect::>(), - name - ); - assert_eq!( - len as usize, - mem::offset_of!(libc::sockaddr_un, sun_path) + 1 + name.len() - ); - assert!((len as usize) < size_of::()); - } - #[test] - fn abstract_bind_is_exclusive_and_close_releases_only_own_kernel_name() { - let socket = || { - fd_result(unsafe { - libc::socket( - libc::AF_UNIX, - libc::SOCK_DGRAM | libc::SOCK_CLOEXEC | libc::SOCK_NONBLOCK, - 0, - ) - }) - .unwrap() - }; - let (addr, len) = abstract_address(Uuid::new_v4()); - let first = socket(); - bind_once(first.as_raw_fd(), &addr, len).unwrap(); - let second = socket(); - assert!(bind_once(second.as_raw_fd(), &addr, len).is_err()); - let (other, other_len) = abstract_address(Uuid::new_v4()); - let unrelated = socket(); - bind_once(unrelated.as_raw_fd(), &other, other_len).unwrap(); - let raw = first.into_raw_fd(); - assert_eq!(unsafe { libc::close(raw) }, 0); - // A fresh socket can acquire the released name, while the unrelated - // held socket still excludes all others. No pathname was ever created. - bind_once(second.as_raw_fd(), &addr, len).unwrap(); - let third = socket(); - assert!(bind_once(third.as_raw_fd(), &other, other_len).is_err()); + std::fs::rename(path.join("own.sock"), path.join("held.sock")).unwrap(); + let new = UnixDatagram::bind(path.join("own.sock")).unwrap(); + assert!(unlink_owned(dir.as_raw_fd(), "own.sock", expected).is_err()); + assert!(path.join("own.sock").exists()); + let current = socket_identity(dir.as_raw_fd(), "own.sock").unwrap(); + unlink_owned(dir.as_raw_fd(), "own.sock", current).unwrap(); + assert!(!path.join("own.sock").exists()); + unlink_owned(dir.as_raw_fd(), "held.sock", expected).unwrap(); + drop((old, new)); + std::fs::remove_dir(&path).unwrap(); } } diff --git a/docs/handover.md b/docs/handover.md index bcb9c6f..eaaf218 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,11 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Abstrakter Chrony-Transport verworfen:** sechs Kernel-Guards nativ bestanden, +separater realer Trackingrequest blieb aber unbeantwortet; Chronys +C-String-Antwortadressierung ist inkompatibel. Produktionsprovider bleibt +3fd9-Named, keine ARM-/Quality-/Jobfreigabe. +[Belege und Grenzen](server-time-source-abstract-client.md). + **Chrony-Peergegencheck eingegrenzt:** aktive Policy bytegleich belegt; ursprüngliche Queryauslegung wegen libapparmor-Pfadkürzung korrigiert. Named-Connect bleibt EACCES, eigener abstrakter Unix-Connect im gleichen