Retain named production provider after incompatible Chrony reply evaluation
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 11:09:54 +01:00
parent 636362aea5
commit 42a91972db
2 changed files with 118 additions and 106 deletions
+112 -106
View File
@@ -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<Identity>,
}
impl Client {
fn open(gid: u32) -> Result<Self> {
@@ -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::<libc::sockaddr_un>() 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<tracking::Tracking> {
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::<Vec<_>>(),
name
);
assert_eq!(
len as usize,
mem::offset_of!(libc::sockaddr_un, sun_path) + 1 + name.len()
);
assert!((len as usize) < size_of::<libc::sockaddr_un>());
}
#[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();
}
}
+6
View File
@@ -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