Retain named production provider after incompatible Chrony reply evaluation
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user