use super::server_lifecycle::HANDSHAKE_TIMEOUT_MS;
use core::fmt;
use shep_core::protocol::{PROTOCOL_VERSION, WireError};
#[cfg(unix)]
pub fn check_peer(stream: &tokio::net::UnixStream, daemon_uid: u32) -> Result<u32, AuthError> {
let cred = stream
.peer_cred()
.map_err(|err| AuthError::NoCredentials(err.to_string()))?;
let peer = cred.uid();
if peer == daemon_uid {
Ok(peer)
} else {
Err(AuthError::ForeignUid {
peer,
daemon: daemon_uid,
})
}
}
#[cfg(unix)]
#[must_use]
pub fn peer_pid(stream: &tokio::net::UnixStream) -> Option<u32> {
u32::try_from(stream.peer_cred().ok()?.pid()?).ok()
}
#[cfg(unix)]
#[must_use]
pub fn daemon_uid() -> u32 {
nix::unistd::geteuid().as_raw()
}
#[non_exhaustive]
#[cfg_attr(windows, allow(dead_code))]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AuthError {
NoCredentials(String),
ForeignUid {
peer: u32,
daemon: u32,
},
}
impl fmt::Display for AuthError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NoCredentials(msg) => write!(f, "could not read peer credentials: {msg}"),
Self::ForeignUid { peer, daemon } => {
write!(f, "peer uid {peer} does not match daemon uid {daemon}")
}
}
}
}
impl core::error::Error for AuthError {}
#[non_exhaustive]
#[derive(Debug)]
pub enum ConnError {
Auth(AuthError),
Frame(std::io::Error),
Decode(WireError),
Encode(WireError),
ProtocolMismatch {
client: u32,
},
HandshakeTimeout,
NoHandshake,
PeerGone,
}
impl fmt::Display for ConnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Auth(err) => write!(f, "peer-credential check failed: {err}"),
Self::Frame(err) => write!(f, "frame transport error: {err}"),
Self::Decode(err) => write!(f, "frame decode error: {err}"),
Self::Encode(err) => write!(f, "frame encode error: {err}"),
Self::ProtocolMismatch { client } => write!(
f,
"client sent protocol {client}, daemon speaks {PROTOCOL_VERSION}"
),
Self::HandshakeTimeout => write!(
f,
"peer did not send Hello within {HANDSHAKE_TIMEOUT_MS} ms"
),
Self::NoHandshake => f.write_str("peer closed before sending Hello"),
Self::PeerGone => f.write_str("connection's write queue is gone"),
}
}
}
impl core::error::Error for ConnError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Auth(err) => Some(err),
Self::Frame(err) => Some(err),
Self::Decode(err) | Self::Encode(err) => Some(err),
Self::ProtocolMismatch { .. }
| Self::HandshakeTimeout
| Self::NoHandshake
| Self::PeerGone => None,
}
}
}
impl From<AuthError> for ConnError {
fn from(source: AuthError) -> Self {
Self::Auth(source)
}
}
impl From<std::io::Error> for ConnError {
fn from(source: std::io::Error) -> Self {
Self::Frame(source)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(unix)]
#[tokio::test]
async fn peer_credentials_gate_on_uid() {
let (a, _b) = tokio::net::UnixStream::pair().unwrap();
let me = daemon_uid();
assert_eq!(check_peer(&a, me).unwrap(), me);
assert_eq!(
check_peer(&a, me + 1).unwrap_err(),
AuthError::ForeignUid {
peer: me,
daemon: me + 1
}
);
}
}