//! Passive protocol clock material only: never a sync decision or job grant. //! Context comes from current mTLS identity + locked tenant installation row. use axum::{ Extension, Json, Router, body::Bytes, extract::{DefaultBodyLimit, State}, http::{HeaderMap, StatusCode}, routing::post, }; use rmm_time_attestation::{Request, SignedAttestation}; use sqlx::Row; use std::{os::unix::fs::MetadataExt, sync::OnceLock, time::Duration}; use tokio::{ io::{AsyncReadExt, AsyncWriteExt}, net::UnixStream, sync::Semaphore, }; const SOCKET: &str = "/run/rmm-time-source/broker.sock"; const MAX_FRAME: usize = 8192; static QUERIES: OnceLock = OnceLock::new(); pub(crate) fn gateway_routes(routes: Router) -> Router { routes.route( "/agent/v1/time-attestation", post(attest).layer(DefaultBodyLimit::max(MAX_FRAME)), ) } fn protected_socket() -> anyhow::Result<(u64, u64)> { use anyhow::ensure; for path in ["/run", "/run/rmm-time-source"] { let m = std::fs::symlink_metadata(path)?; ensure!( m.is_dir() && !m.file_type().is_symlink() && m.uid() == 0 && m.mode() & 0o022 == 0, "TIME_BROKER_DIRECTORY" ); } let m = std::fs::symlink_metadata(SOCKET)?; use std::os::unix::fs::FileTypeExt; ensure!( m.file_type().is_socket() && m.uid() == 0 && m.gid() == 10001 && m.nlink() == 1 && m.mode() & 0o7777 == 0o660, "TIME_BROKER_SOCKET" ); Ok((m.dev(), m.ino())) } async fn broker(request: &Request) -> anyhow::Result { use anyhow::ensure; let owned = protected_socket()?; let mut connection = UnixStream::connect(SOCKET).await?; let peer = connection.peer_cred()?; // A host broker is in an ancestor PID namespace: Linux may report PID0 // (or the wrapper may omit it) to this container. Authorization instead // requires the kernel-mapped root UID, protected root-owned socket inode, // and the verifier's independently pinned end-to-end time signature. // Userns remapping is not compensated: unmapped UID/socket ownership denies. ensure!(peer.uid() == 0, "TIME_BROKER_PEER"); ensure!(protected_socket()? == owned, "TIME_BROKER_REPLACED"); let raw = serde_json::to_vec(request)?; ensure!( !raw.is_empty() && raw.len() <= MAX_FRAME, "TIME_REQUEST_SIZE" ); connection .write_all(&(u32::try_from(raw.len())?).to_be_bytes()) .await?; connection.write_all(&raw).await?; connection.shutdown().await?; let length = connection.read_u32().await? as usize; ensure!(length > 0 && length <= MAX_FRAME, "TIME_RESPONSE_SIZE"); let mut raw = vec![0; length]; connection.read_exact(&mut raw).await?; let mut extra = [0; 1]; ensure!( connection.read(&mut extra).await? == 0, "TIME_RESPONSE_TRAILING" ); ensure!(protected_socket()? == owned, "TIME_BROKER_REPLACED"); let response: SignedAttestation = serde_json::from_slice(&raw)?; ensure!( serde_json::to_vec(&response)? == raw, "TIME_RESPONSE_NONCANONICAL" ); // The independent verifier checks the signature, protected key and whole // challenge. This root-peer transport is not an OS/helper attestation. let payload: rmm_time_attestation::Payload = serde_json::from_str(&response.payload)?; ensure!( payload.request_sha256 == request.sha256()?, "TIME_RESPONSE_REQUEST" ); Ok(response) } async fn attest( State(s): State, Extension(peer): Extension, headers: HeaderMap, bytes: Bytes, ) -> Result, StatusCode> { tokio::time::timeout(Duration::from_millis(500), issue(&s, peer, headers, bytes)) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? } async fn issue( s: &crate::State, peer: crate::Peer, headers: HeaderMap, bytes: Bytes, ) -> Result, StatusCode> { let (tenant, agent) = crate::agent_http::identity(s, peer).await?; if headers.get("content-type").and_then(|v| v.to_str().ok()) != Some("application/json") { return Err(StatusCode::UNSUPPORTED_MEDIA_TYPE); } let request: Request = serde_json::from_slice(&bytes).map_err(|_| StatusCode::BAD_REQUEST)?; request.validate().map_err(|_| StatusCode::BAD_REQUEST)?; let c = &request.context; if c.tenant_id != tenant || c.agent_id != agent { return Err(StatusCode::FORBIDDEN); } let _slot = QUERIES .get_or_init(|| Semaphore::new(4)) .try_acquire() .map_err(|_| StatusCode::TOO_MANY_REQUESTS)?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; // No sync_ready precondition: the independent time check is needed before // the first signed reconciliation, including its strictly negative paths. let row = sqlx::query("SELECT asset_id,enrollment_generation,assignment_version,connection_generation,connection_boot_id,capabilities FROM agent_installations WHERE tenant_id=$1 AND agent_id=$2 AND revoked_at IS NULL FOR SHARE") .bind(tenant).bind(agent).fetch_optional(&mut *tx).await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?.ok_or(StatusCode::FORBIDDEN)?; let same = row.get::("asset_id") == c.asset_id && u64::try_from(row.get::("enrollment_generation")).ok() == Some(c.enrollment_generation) && u64::try_from(row.get::("assignment_version")).ok() == Some(c.assignment_generation) && u64::try_from(row.get::("connection_generation")).ok() == Some(c.connection_generation) && row.get::, _>("connection_boot_id") == Some(c.windows_boot_id) && row .get::("capabilities") .as_array() .is_some_and(|v| v.iter().any(|v| v.as_str() == Some("windows.base/1"))); if !same { return Err(StatusCode::CONFLICT); } // Hold the shared installation lock through this bounded local query: // revoke/reassignment/connection changes cannot race the signing moment. let response = tokio::time::timeout(Duration::from_millis(300), broker(&request)) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; tx.commit() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; Ok(Json(response)) }