use axum::{ Json, extract::{Query, Request, State}, http::{HeaderMap, HeaderValue, StatusCode}, middleware::Next, response::{IntoResponse, Redirect, Response}, }; use chrono::{DateTime, Duration, Utc}; use rmm_domain::{TENANT_A, TENANT_B, jobs::hash}; use rmm_oidc_auth::{CLEAR_BINDING_COOKIE, Callback, Identity}; use serde::Deserialize; use serde_json::json; use sqlx::Row; use std::{ collections::{BTreeSet, HashMap}, sync::Mutex, }; use uuid::Uuid; #[derive(Clone)] pub struct Principal { pub tenant: Uuid, pub name: String, pub operator: bool, pub session_hash: Option, pub csrf: Option, pub scopes: Option>, pub testsimulation: bool, pub identity: Option, pub tenants: Vec, } impl Principal { pub fn approval_origin(&self) -> &'static str { if self.testsimulation { "dev_test_browser_simulation" } else { "human_webui" } } pub fn permits_scope(&self, permission: &str) -> bool { self.scopes.as_ref().is_none_or(|s| s.contains(permission)) } } #[derive(Clone)] struct Session { principal: Principal, expires: DateTime, } pub struct Auth { sessions: Mutex>, login_attempts: Mutex>, username: Option, password_hash: Option, operator_a: Option, operator_b: Option, pub origin: String, pub oidc: Option, development: bool, } impl Auth { pub fn validate_separation(&self, a: &[u8; 32], b: &[u8; 32]) -> anyhow::Result<()> { let mut hashes = vec![hex::encode(a), hex::encode(b)]; hashes.extend( [ self.password_hash.clone(), self.operator_a.clone(), self.operator_b.clone(), ] .into_iter() .flatten(), ); let count = hashes.len(); hashes.sort(); hashes.dedup(); anyhow::ensure!( hashes.len() == count, "browser, operator and viewer credentials must be distinct" ); Ok(()) } pub fn operator_enabled(&self, name: &str, tenant: Uuid) -> bool { (self.oidc.is_some() && name.starts_with("oidc:") && name.len() == 69) || (name == "simulated-testprincipal-a" && tenant.to_string() == TENANT_A && self.username.is_some()) || (name == format!("automation:{tenant}") && ((tenant.to_string() == TENANT_A && self.operator_a.is_some()) || (tenant.to_string() == TENANT_B && self.operator_b.is_some()))) } pub async fn from_env(profile: &str) -> anyhow::Result { let development = profile == "development"; let optional = |name: &str| std::env::var(name).ok().filter(|s| !s.is_empty()); if !development { anyhow::ensure!( [ "RMM_DEV_USERNAME", "RMM_DEV_PASSWORD", "RMM_OPERATOR_A", "RMM_OPERATOR_B", "RMM_VIEWER_A", "RMM_VIEWER_B" ] .iter() .all(|n| optional(n).is_none()), "development credentials forbidden in production" ); } let username = optional("RMM_DEV_USERNAME"); let password = optional("RMM_DEV_PASSWORD"); anyhow::ensure!( username.is_some() == password.is_some(), "dev login requires username AND password" ); let secret = |name| -> anyhow::Result> { let value = optional(name); if let Some(v) = &value { anyhow::ensure!(v.len() >= 32, "development credential too short"); } Ok(value.map(|v| hash(v.as_bytes()))) }; let origin = optional("RMM_UI_ORIGIN").unwrap_or_else(|| "https://rmm-dev.internal:18443".into()); let url = url::Url::parse(&origin)?; anyhow::ensure!( url.scheme() == "https" && url.origin().ascii_serialization() == origin, "UI origin must be an exact HTTPS origin" ); let oidc = crate::oidc::configured(profile, &origin).await?; anyhow::ensure!( development || oidc.is_some(), "production OIDC not_configured" ); Ok(Self { sessions: Mutex::new(HashMap::new()), login_attempts: Mutex::new(vec![]), username, password_hash: secret("RMM_DEV_PASSWORD")?, operator_a: secret("RMM_OPERATOR_A")?, operator_b: secret("RMM_OPERATOR_B")?, origin, oidc, development, }) } fn origin(&self, h: &HeaderMap) -> Result<(), StatusCode> { if h.get("origin").and_then(|v| v.to_str().ok()) != Some(self.origin.as_str()) { return Err(StatusCode::FORBIDDEN); } Ok(()) } fn rate_limit(&self) -> Result<(), StatusCode> { let mut attempts = self .login_attempts .lock() .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; attempts.retain(|t| t.elapsed() < std::time::Duration::from_secs(60)); if attempts.len() >= 40 { return Err(StatusCode::TOO_MANY_REQUESTS); } attempts.push(std::time::Instant::now()); Ok(()) } pub async fn principal( &self, state: &crate::State, h: &HeaderMap, write: bool, ) -> Result { let selected = h .get("x-rmm-tenant") .map(|v| { v.to_str() .ok() .and_then(|v| Uuid::parse_str(v).ok()) .ok_or(StatusCode::BAD_REQUEST) }) .transpose()?; let mut p = if let Some(b) = h.get("authorization") { let raw = b .to_str() .ok() .and_then(|s| s.strip_prefix("Bearer ")) .ok_or(StatusCode::UNAUTHORIZED)?; let digest = hash(raw.as_bytes()); let local = if !self.development { None } else if self.operator_a.as_ref().is_some_and(|s| equal(s, &digest)) { Some((TENANT_A, true)) } else if self.operator_b.as_ref().is_some_and(|s| equal(s, &digest)) { Some((TENANT_B, true)) } else if equal(&hex::encode(state.viewer_a), &digest) { Some((TENANT_A, false)) } else if equal(&hex::encode(state.viewer_b), &digest) { Some((TENANT_B, false)) } else { None }; if let Some((tenant, operator)) = local { let tenant = Uuid::parse_str(tenant).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; Principal { tenant, name: format!( "{}:{tenant}", if operator { "automation" } else { "viewer" } ), operator, session_hash: None, csrf: None, scopes: None, testsimulation: true, identity: None, tenants: vec![tenant], } } else { let provider = self.oidc.as_ref().ok_or(StatusCode::UNAUTHORIZED)?; let bearer = provider .auth .verify_mcp_bearer(raw, &[]) .await .map_err(|_| StatusCode::UNAUTHORIZED)?; self.mapped(state, bearer.identity, Some(bearer.scopes), selected, false) .await? } } else { let token = cookie(h, "__Host-rmm_session")?; let mut p = { let sessions = self .sessions .lock() .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; sessions .get(&hash(token.as_bytes())) .filter(|s| s.expires > Utc::now()) .ok_or(StatusCode::UNAUTHORIZED)? .principal .clone() }; if let Some(identity) = p.identity.clone() { let mapped = self.mapped(state, identity, None, selected, true).await?; p.tenant = mapped.tenant; p.tenants = mapped.tenants; } if write { self.origin(h)?; let csrf = h .get("x-csrf-token") .and_then(|v| v.to_str().ok()) .ok_or(StatusCode::FORBIDDEN)?; if !p.csrf.as_deref().is_some_and(|v| equal(v, csrf)) { return Err(StatusCode::FORBIDDEN); } } p }; if selected.is_some_and(|t| t != p.tenant) { return Err(StatusCode::NOT_FOUND); } let mut tx = rmm_persistence::tenant_tx(&state.pool, p.tenant) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let active: bool = sqlx::query_scalar( "SELECT EXISTS(SELECT 1 FROM memberships WHERE principal=$1 AND revoked_at IS NULL)", ) .bind(&p.name) .fetch_one(&mut *tx) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; tx.commit() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; if !active { return Err(StatusCode::FORBIDDEN); } if write && !p.operator { return Err(StatusCode::FORBIDDEN); } if h.contains_key("authorization") { p.session_hash = None; p.csrf = None; } Ok(p) } async fn mapped( &self, state: &crate::State, identity: Identity, scopes: Option>, selected: Option, browser: bool, ) -> Result { let row = sqlx::query("SELECT principal,tenant_ids FROM oidc_identity_binding($1,$2)") .bind(&identity.issuer) .bind(&identity.subject) .fetch_optional(&state.pool) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? .ok_or(StatusCode::FORBIDDEN)?; let name: String = row.get("principal"); if name != crate::oidc::principal_id(&identity.issuer, &identity.subject) { return Err(StatusCode::FORBIDDEN); } let mut tenants: Vec = row.get("tenant_ids"); tenants.sort(); tenants.dedup(); let tenant = selected .or_else(|| tenants.first().copied()) .filter(|t| tenants.contains(t)) .ok_or(StatusCode::NOT_FOUND)?; let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let kind: Option = sqlx::query_scalar( "SELECT kind FROM memberships WHERE principal=$1 AND revoked_at IS NULL", ) .bind(&name) .fetch_optional(&mut *tx) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; tx.commit() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let kind = kind.ok_or(StatusCode::FORBIDDEN)?; if browser && kind != "human" { return Err(StatusCode::FORBIDDEN); } Ok(Principal { tenant, name, operator: true, session_hash: None, csrf: None, scopes, testsimulation: self.oidc.as_ref().is_some_and(|o| o.simulation), identity: Some(identity), tenants, }) } fn establish(&self, mut p: Principal) -> Result { let token = random(); let key = hash(token.as_bytes()); p.session_hash = Some(key.clone()); p.csrf = Some(random()); let mut sessions = self .sessions .lock() .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; sessions.retain(|_, s| s.expires > Utc::now()); if sessions.len() >= 128 { return Err(StatusCode::TOO_MANY_REQUESTS); } sessions.insert( key, Session { principal: p, expires: Utc::now() + Duration::hours(1), }, ); let mut response = Redirect::to("/").into_response(); response.headers_mut().append("set-cookie",HeaderValue::from_str(&format!("__Host-rmm_session={token}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=3600")).map_err(|_|StatusCode::INTERNAL_SERVER_ERROR)?); Ok(response) } } fn random() -> String { format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple()) } fn equal(a: &str, b: &str) -> bool { a.len() == b.len() && openssl::memcmp::eq(a.as_bytes(), b.as_bytes()) } pub fn error_code(status: StatusCode) -> &'static str { match status { StatusCode::NOT_FOUND => "NOT_FOUND", StatusCode::UNAUTHORIZED => "UNAUTHENTICATED", StatusCode::SERVICE_UNAVAILABLE => "DEPENDENCY_UNAVAILABLE", StatusCode::BAD_REQUEST => "VALIDATION_ERROR", _ => "FORBIDDEN", } } fn cookie<'a>(h: &'a HeaderMap, name: &str) -> Result<&'a str, StatusCode> { let mut values = h .get_all("cookie") .iter() .filter_map(|v| v.to_str().ok()) .flat_map(|c| c.split(';')) .filter_map(|s| s.trim().split_once('=')) .filter(|(n, _)| *n == name) .map(|(_, v)| v); let result = values.next().ok_or(StatusCode::UNAUTHORIZED)?; if values.next().is_some() { return Err(StatusCode::BAD_REQUEST); } Ok(result) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct Login { username: String, password: String, } pub async fn login( State(state): State, h: HeaderMap, Json(input): Json, ) -> Result { if !state.auth.development { return Err(StatusCode::NOT_FOUND); } state.auth.origin(&h)?; state.auth.rate_limit()?; if input.username.len() > 128 || input.password.len() > 256 { return Err(StatusCode::BAD_REQUEST); } if !state .auth .username .as_ref() .is_some_and(|u| equal(u, &input.username)) || !state .auth .password_hash .as_ref() .is_some_and(|p| equal(p, &hash(input.password.as_bytes()))) { tokio::time::sleep(std::time::Duration::from_millis(250)).await; return Err(StatusCode::UNAUTHORIZED); } let tenant = Uuid::parse_str(TENANT_A).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; let p = Principal { tenant, name: "simulated-testprincipal-a".into(), operator: true, session_hash: None, csrf: None, scopes: None, testsimulation: true, identity: None, tenants: vec![tenant], }; let mut response = state.auth.establish(p)?; *response.status_mut() = StatusCode::OK; response.headers_mut().remove("location"); *response.body_mut() = axum::body::Body::from("{\"authenticated\":true,\"testsimulation\":true}"); response .headers_mut() .insert("content-type", HeaderValue::from_static("application/json")); Ok(response) } pub async fn configuration(State(state): State) -> Json { Json( json!({"oidc_configured":state.auth.oidc.is_some(),"oidc_login_url":state.auth.oidc.as_ref().map(|_|"/auth/oidc/login"),"dev_login_enabled":state.auth.username.is_some()}), ) } pub async fn oidc_login(State(state): State) -> Result { state.auth.rate_limit()?; let start = state .auth .oidc .as_ref() .ok_or(StatusCode::NOT_IMPLEMENTED)? .auth .login_start() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let mut response = Redirect::to(start.authorization_url.as_str()).into_response(); response.headers_mut().append( "set-cookie", HeaderValue::from_str(&start.binding_set_cookie) .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?, ); Ok(response) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct Code { code: String, state: String, iss: Option, } pub async fn oidc_callback( State(state): State, h: HeaderMap, query: Result, axum::extract::rejection::QueryRejection>, ) -> Response { let result = async { state.auth.rate_limit()?; let Query(code) = query.map_err(|_| StatusCode::BAD_REQUEST)?; let binding = cookie(&h, "__Host-rmm_oidc_binding")?; let provider = state .auth .oidc .as_ref() .ok_or(StatusCode::NOT_IMPLEMENTED)?; let identity = provider .auth .callback(Callback { code: &code.code, state: &code.state, browser_binding: binding, }) .await .map_err(|_| StatusCode::UNAUTHORIZED)?; if code .iss .as_deref() .is_some_and(|iss| iss != identity.issuer) { return Err(StatusCode::UNAUTHORIZED); } let p = state .auth .mapped(&state, identity, None, None, true) .await?; state.auth.establish(p) } .await; let mut response = match result { Ok(r) => r, Err(s) => (s, Json(json!({"code":"UNAUTHENTICATED","message":"OIDC callback failed","retryable":false,"correlation_id":Uuid::new_v4(),"details":{}}))).into_response(), }; response .headers_mut() .append("set-cookie", HeaderValue::from_static(CLEAR_BINDING_COOKIE)); response } pub async fn session( State(state): State, h: HeaderMap, ) -> Result, StatusCode> { let p = state.auth.principal(&state, &h, false).await?; if p.session_hash.is_none() { return Err(StatusCode::FORBIDDEN); } let mut tx = rmm_persistence::tenant_tx(&state.pool, p.tenant) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let permissions: Option> = sqlx::query_scalar( "SELECT permissions FROM memberships WHERE principal=$1 AND revoked_at IS NULL", ) .bind(&p.name) .fetch_optional(&mut *tx) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; tx.commit() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; Ok(Json( json!({"principal":p.name,"tenant_id":p.tenant,"permissions":permissions.ok_or(StatusCode::FORBIDDEN)?,"roles":[if p.testsimulation {"dev_test_member"} else {"member"}],"csrf_token":p.csrf,"testsimulation":p.testsimulation,"approval_origin":p.approval_origin()}), )) } pub async fn logout( State(state): State, h: HeaderMap, ) -> Result { let p = state.auth.principal(&state, &h, true).await?; let key = p.session_hash.ok_or(StatusCode::FORBIDDEN)?; state .auth .sessions .lock() .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? .remove(&key); let mut response = StatusCode::NO_CONTENT.into_response(); response.headers_mut().insert( "set-cookie", HeaderValue::from_static( "__Host-rmm_session=; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=0", ), ); Ok(response) } /// Tenant header is only a selection, never authority; path selection overrides caller headers. pub async fn context(mut request: Request, next: Next) -> Response { if let Some(t) = request .uri() .path() .strip_prefix("/api/v1/tenants/") .and_then(|p| p.split('/').next()) .and_then(|s| Uuid::parse_str(s).ok()) && let Ok(value) = HeaderValue::from_str(&t.to_string()) { request.headers_mut().insert("x-rmm-tenant", value); } let auth = request.uri().path().starts_with("/auth/"); let mut response = next.run(request).await; if auth { response .headers_mut() .insert("cache-control", HeaderValue::from_static("no-store")); response .headers_mut() .insert("referrer-policy", HeaderValue::from_static("no-referrer")); } response } #[cfg(test)] mod tests { use super::*; #[test] fn duplicate_binding_cookies_are_rejected() { let mut h = HeaderMap::new(); h.append( "cookie", HeaderValue::from_static("__Host-rmm_oidc_binding=one"), ); assert_eq!(cookie(&h, "__Host-rmm_oidc_binding"), Ok("one")); h.append( "cookie", HeaderValue::from_static("other=x; __Host-rmm_oidc_binding=two"), ); assert_eq!( cookie(&h, "__Host-rmm_oidc_binding"), Err(StatusCode::BAD_REQUEST) ); } #[test] fn access_scopes_are_not_browser_approval_authority() { let p = Principal { tenant: Uuid::nil(), name: "test".into(), operator: true, session_hash: None, csrf: None, scopes: Some(BTreeSet::from(["inventory:read".into()])), testsimulation: false, identity: None, tenants: vec![], }; assert!(p.permits_scope("inventory:read")); assert!(!p.permits_scope("plans:approve")); assert!(p.session_hash.is_none()); assert_eq!(p.approval_origin(), "human_webui"); } }