//! Tenant-bound, independently revocable automation credentials. use crate::{auth::Principal, jobs::Error}; use axum::{ Json, Router, extract::{Path, State}, http::{HeaderMap, StatusCode}, response::{IntoResponse, Response}, routing::{get, post}, }; use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; use chrono::{DateTime, Duration, Utc}; use rmm_domain::jobs::hash; use serde::Deserialize; use serde_json::{Value, json}; use sqlx::{PgPool, Postgres, Row, Transaction, postgres::PgRow}; use std::collections::BTreeSet; use uuid::Uuid; const PREFIX: &str = "rmm_mcp_"; const SCOPES: [&str; 12] = [ "inventory:read", "logs:read", "logs:read_sensitive", "operations:read", "operations:plan", "operations:submit", "jobs:cancel", "scripts:execute", "system:execute", "root:execute", "updates:apply", "catalog:write", ]; const READ_SCOPES: [&str; 3] = ["inventory:read", "logs:read", "operations:read"]; const COLUMNS: &str = "token_id,principal,name,scopes,created_at,expires_at,last_used_at,revoked_at,all_customers,coalesce(customer_ids,ARRAY[tenant_id]) AS customer_ids"; fn invalid() -> Error { Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR") } fn denied() -> Error { Error(StatusCode::FORBIDDEN, "INTERACTIVE_TOKEN_ADMIN_REQUIRED") } fn private_json(value: Value) -> Response { ( [ ("cache-control", "private, no-store"), ("pragma", "no-cache"), ], Json(value), ) .into_response() } pub fn routes(router: Router) -> Router { router .route( "/api/v1/tenants/{tenant}/mcp-tokens", get(list).post(create), ) .route( "/api/v1/tenants/{tenant}/mcp-tokens/{token}/revoke", post(revoke), ) } fn metadata(row: &PgRow) -> Value { json!({ "token_id":row.get::("token_id"), "principal":row.get::("principal"), "name":row.get::("name"), "audience":if row.get::("all_customers") {"all"} else {"selected"}, "tenant_ids":row.get::,_>("customer_ids"), "scopes":row.get::,_>("scopes"), "created_at":row.get::,_>("created_at"), "expires_at":row.get::,_>("expires_at"), "last_used_at":row.get::>,_>("last_used_at"), "revoked_at":row.get::>,_>("revoked_at"), }) } fn interactive(principal: &Principal) -> Result<(), Error> { if principal.session_hash.is_none() || principal.csrf.is_none() || principal.testsimulation || principal.scopes.is_some() { return Err(denied()); } Ok(()) } async fn administration<'a>( state: &'a crate::State, headers: &HeaderMap, tenant: Uuid, write: bool, ) -> Result<(Principal, Vec, Transaction<'a, Postgres>), Error> { let principal = state .auth .principal(state, headers, write) .await .map_err(|status| Error(status, crate::auth::error_code(status)))?; crate::jobs::scope(&principal, tenant, write)?; interactive(&principal)?; let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?; let permissions: Option> = sqlx::query_scalar( "SELECT permissions FROM memberships WHERE principal=$1 AND kind='human' AND revoked_at IS NULL AND 'tokens:manage'=ANY(permissions)", ).bind(&principal.name).fetch_optional(&mut *tx).await?; let allowed = permissions .ok_or_else(denied)? .into_iter() .filter(|permission| SCOPES.contains(&permission.as_str())) .collect(); Ok((principal, allowed, tx)) } async fn list( State(state): State, headers: HeaderMap, Path(tenant): Path, ) -> Result { let (principal, allowed, mut tx) = administration(&state, &headers, tenant, false).await?; let rows = sqlx::query(&format!( "SELECT {COLUMNS} FROM mcp_tokens WHERE can_manage_mcp_token($1,token_id,$2) ORDER BY created_at DESC,token_id" )) .bind(&principal.name) .bind(&principal.tenants) .fetch_all(&mut *tx) .await?; let can_select_all = crate::customers::can_manage(&principal, &mut tx).await?; tx.commit().await?; let mut available = Vec::new(); for customer in &principal.tenants { let mut customer_tx = rmm_persistence::tenant_tx(&state.pool, *customer).await?; let name:Option=sqlx::query_scalar("SELECT name FROM tenants WHERE tenant_id=$1 AND EXISTS(SELECT 1 FROM memberships WHERE principal=$2 AND kind='human' AND revoked_at IS NULL AND 'tokens:manage'=ANY(permissions))") .bind(customer).bind(&principal.name).fetch_optional(&mut *customer_tx).await?; if let Some(name) = name { available.push(json!({"tenant_id":customer,"name":name})); } customer_tx.commit().await?; } let defaults: Vec<_> = READ_SCOPES .into_iter() .filter(|scope| allowed.iter().any(|permission| permission == scope)) .collect(); Ok(private_json( json!({"tokens":rows.iter().map(metadata).collect::>(), "allowed_scopes":allowed,"default_scopes":defaults,"can_select_all":can_select_all,"available_customers":available}), )) } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Create { name: String, audience: Option, tenant_ids: Option>, scopes: Option>, expires_at: Option>, } fn selection( input: &Create, allowed: &[String], now: DateTime, ) -> Result<(Vec, DateTime), Error> { if input.name.is_empty() || input.name.trim() != input.name || input.name.chars().count() > 120 || input.name.chars().any(char::is_control) { return Err(invalid()); } let selected: BTreeSet<_> = match &input.scopes { Some(scopes) => { if scopes.len() > SCOPES.len() { return Err(invalid()); } scopes.iter().cloned().collect() } None => READ_SCOPES .into_iter() .filter(|scope| allowed.iter().any(|p| p == scope)) .map(str::to_owned) .collect(), }; if selected.is_empty() || selected .iter() .any(|scope| !SCOPES.contains(&scope.as_str()) || !allowed.contains(scope)) { return Err(invalid()); } let expires = input.expires_at.unwrap_or(now + Duration::days(90)); if expires <= now || expires > now + Duration::days(365) { return Err(invalid()); } Ok((selected.into_iter().collect(), expires)) } fn generate() -> Result { let mut random = [0_u8; 32]; openssl::rand::rand_bytes(&mut random) .map_err(|_| Error(StatusCode::SERVICE_UNAVAILABLE, "ENTROPY_UNAVAILABLE"))?; Ok(format!("{PREFIX}{}", URL_SAFE_NO_PAD.encode(random))) } async fn create( State(state): State, headers: HeaderMap, Path(tenant): Path, Json(input): Json, ) -> Result { let (principal, allowed, mut tx) = administration(&state, &headers, tenant, true).await?; let (scopes, expiry) = selection(&input, &allowed, Utc::now())?; let token = generate()?; let id = Uuid::new_v4(); let global = match input.audience.as_deref() { None | Some("selected") => false, Some("all") => true, _ => return Err(invalid()), }; let customers = input .tenant_ids .unwrap_or_else(|| if global { vec![] } else { vec![tenant] }); if global { if !customers.is_empty() { return Err(invalid()); } if !crate::customers::can_manage(&principal, &mut tx).await? { return Err(denied()); } } else if customers.is_empty() || customers.len() > 512 || customers.iter().collect::>().len() != customers.len() { return Err(invalid()); } else if customers.iter().any(|t| !principal.tenants.contains(t)) { return Err(denied()); } sqlx::query("SELECT issue_customer_token($1,$2,$3,$4,$5,$6,$7,$8)") .bind(&principal.name) .bind(id) .bind(&input.name) .bind(hash(token.as_bytes())) .bind(scopes) .bind(expiry) .bind(global) .bind(&customers) .execute(&mut *tx) .await .map_err(crate::customers::database_error)?; let row = sqlx::query(&format!( "SELECT {COLUMNS} FROM mcp_tokens WHERE token_id=$1" )) .bind(id) .fetch_one(&mut *tx) .await?; tx.commit().await?; let mut response = metadata(&row); response["token"] = Value::String(token); Ok(private_json(response)) } async fn revoke( State(state): State, headers: HeaderMap, Path((tenant, id)): Path<(Uuid, Uuid)>, ) -> Result { let (principal, _, mut tx) = administration(&state, &headers, tenant, true).await?; let found: bool = sqlx::query_scalar("SELECT revoke_mcp_token($1,$2,$3,$4)") .bind(&principal.name) .bind(id) .bind(Uuid::new_v4()) .bind(&principal.tenants) .fetch_one(&mut *tx) .await?; if !found { return Err(Error(StatusCode::NOT_FOUND, "NOT_FOUND")); } let row = sqlx::query(&format!( "SELECT {COLUMNS} FROM mcp_tokens WHERE token_id=$1" )) .bind(id) .fetch_one(&mut *tx) .await?; tx.commit().await?; Ok(private_json(metadata(&row))) } pub async fn authenticate( state: &crate::State, raw: &str, selected: Option, ) -> Result { let principal = authenticate_pool(&state.pool, raw, selected).await?; let mut tx = rmm_persistence::tenant_tx(&state.pool, principal.tenant) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; if !issuer_enabled(state, &mut tx, &principal.name) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)? { return Err(StatusCode::UNAUTHORIZED); } tx.commit() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; Ok(principal) } async fn authenticate_pool( pool: &PgPool, raw: &str, selected: Option, ) -> Result { let encoded = raw.strip_prefix(PREFIX).ok_or(StatusCode::UNAUTHORIZED)?; if encoded.len() != 43 || URL_SAFE_NO_PAD.decode(encoded).is_err() { return Err(StatusCode::UNAUTHORIZED); } let digest = hash(raw.as_bytes()); let route: Option<(Uuid, Uuid)> = sqlx::query_as("SELECT tenant_id,token_id FROM mcp_token_route($1)") .bind(&digest) .fetch_optional(pool) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let (home, id) = route.ok_or(StatusCode::UNAUTHORIZED)?; let tenants: Vec = sqlx::query_scalar("SELECT mcp_credential_customers($1)") .bind(&digest) .fetch_one(pool) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let default = tenants.first().copied().ok_or(StatusCode::UNAUTHORIZED)?; let tenant = selected.unwrap_or(default); if !tenants.contains(&tenant) { return Err(StatusCode::NOT_FOUND); } let principal = format!("mcp:{id}"); let mut tx = rmm_persistence::tenant_tx(pool, tenant) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let permissions: Vec = sqlx::query_scalar("SELECT mcp_current_scopes($1)") .bind(&principal) .fetch_one(&mut *tx) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let effective: BTreeSet = permissions .into_iter() .filter(|p| SCOPES.contains(&p.as_str())) .collect(); if effective.is_empty() { return Err(StatusCode::FORBIDDEN); } sqlx::query("SELECT set_config('app.tenant_id',$1,true)") .bind(home.to_string()) .execute(&mut *tx) .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; let used=sqlx::query("UPDATE mcp_tokens SET last_used_at=now() WHERE token_id=$1 AND token_hash=$2 AND revoked_at IS NULL AND expires_at>now()") .bind(id).bind(&digest).execute(&mut *tx).await.map_err(|_|StatusCode::SERVICE_UNAVAILABLE)?; if used.rows_affected() != 1 { return Err(StatusCode::UNAUTHORIZED); } tx.commit() .await .map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?; Ok(Principal { tenant, name: principal, operator: effective .iter() .any(|scope| !READ_SCOPES.contains(&scope.as_str()) && scope != "logs:read_sensitive"), session_hash: None, csrf: None, scopes: Some(effective), testsimulation: false, identity: None, tenants, }) } pub async fn issuer_enabled( state: &crate::State, tx: &mut Transaction<'_, Postgres>, principal: &str, ) -> Result { let issuer: Option = sqlx::query_scalar("SELECT mcp_current_issuer($1)") .bind(principal) .fetch_one(&mut **tx) .await?; Ok(issuer.is_some_and(|actor| { if actor.starts_with("local:") { state .auth .local .as_ref() .and_then(|local| local.home(&actor)) .is_some() } else { actor.starts_with("oidc:") && state.auth.oidc.is_some() } })) } #[cfg(test)] async fn enabled_in( tx: &mut Transaction<'_, Postgres>, principal: &str, ) -> Result { sqlx::query_scalar("SELECT cardinality(mcp_current_scopes($1))>0") .bind(principal) .fetch_one(&mut **tx) .await } #[cfg(test)] async fn enabled(pool: &PgPool, principal: &str, tenant: Uuid) -> bool { let Ok(mut tx) = rmm_persistence::tenant_tx(pool, tenant).await else { return false; }; let allowed = enabled_in(&mut tx, principal).await.unwrap_or(false); tx.commit().await.is_ok() && allowed } #[cfg(test)] mod tests { use super::*; mod stored_logs; #[test] fn mcp_token_selection_is_explicit_and_bounded() { let now = Utc::now(); let allowed: Vec = SCOPES.into_iter().map(str::to_owned).collect(); let mut input = Create { name: "Inventory reader".into(), audience: None, tenant_ids: None, scopes: None, expires_at: None, }; let (selected, expiry) = selection(&input, &allowed, now).unwrap(); assert_eq!(selected, READ_SCOPES.map(str::to_owned)); assert_eq!(expiry, now + Duration::days(90)); for permission in [ "plans:approve", "plans:revoke", "tokens:manage", "unknown", "", ] { input.scopes = Some(vec![permission.into()]); assert!(selection(&input, &allowed, now).is_err()); } input.scopes = Some(vec!["scripts:execute".into()]); assert!(selection(&input, &["inventory:read".into()], now).is_err()); for expires in [now, now - Duration::seconds(1), now + Duration::days(366)] { input.expires_at = Some(expires); assert!(selection(&input, &allowed, now).is_err()); } input.expires_at = None; for name in [ "".into(), " x ".into(), "secret\nname".into(), "a".repeat(121), ] { input.name = name; assert!(selection(&input, &allowed, now).is_err()); } let first = generate().unwrap(); let second = generate().unwrap(); assert_ne!(first, second); assert_eq!( URL_SAFE_NO_PAD .decode(&first[PREFIX.len()..]) .unwrap() .len(), 32 ); } async fn mint( pool: &PgPool, tenant: Uuid, actor: &str, permissions: &[&str], ) -> (Uuid, String) { let id = Uuid::new_v4(); let token = generate().unwrap(); let mut tx = rmm_persistence::tenant_tx(pool, tenant).await.unwrap(); sqlx::query("SELECT issue_mcp_token($1,$2,'test token',$3,$4,now()+interval '1 day')") .bind(actor) .bind(id) .bind(hash(token.as_bytes())) .bind(permissions) .execute(&mut *tx) .await .unwrap(); tx.commit().await.unwrap(); (id, token) } #[tokio::test] #[ignore = "requires disposable PostgreSQL with all migrations applied"] async fn mcp_tokens_database() { let app = PgPool::connect(&std::env::var("RMM_TEST_REPAIR_APP_URL").unwrap()) .await .unwrap(); let admin = PgPool::connect(&std::env::var("RMM_TEST_REPAIR_ADMIN_URL").unwrap()) .await .unwrap(); let tenant = Uuid::parse_str(rmm_domain::TENANT_A).unwrap(); let other = Uuid::parse_str(rmm_domain::TENANT_B).unwrap(); let actor = format!("local:{}", Uuid::new_v4()); sqlx::query("INSERT INTO memberships(tenant_id,principal,kind,permissions) VALUES($1,$2,'human',ARRAY['inventory:read','logs:read','operations:read','operations:plan','operations:submit','scripts:execute','tokens:manage'])") .bind(tenant).bind(&actor).execute(&admin).await.unwrap(); let (id, token) = mint( &app, tenant, &actor, &["inventory:read", "operations:plan", "scripts:execute"], ) .await; let principal = authenticate_pool(&app, &token, None).await.unwrap(); assert_eq!(principal.tenant, tenant); assert_eq!(principal.name, format!("mcp:{id}")); assert!(principal.operator && !principal.testsimulation); assert!(principal.session_hash.is_none() && principal.csrf.is_none()); assert!(interactive(&principal).is_err()); assert!(principal.permits_scope("scripts:execute")); for banned in ["plans:approve", "plans:revoke", "tokens:manage"] { assert!(!principal.permits_scope(banned)); } assert_eq!( authenticate_pool(&app, &token, Some(other)).await.err(), Some(StatusCode::NOT_FOUND) ); assert_eq!( authenticate_pool(&app, &generate().unwrap(), None) .await .err(), Some(StatusCode::UNAUTHORIZED) ); assert!(enabled(&app, &principal.name, tenant).await); assert!(!enabled(&app, &principal.name, other).await); assert!( sqlx::query("SELECT * FROM mcp_token_routes") .fetch_all(&app) .await .is_err() ); let outside: i64 = sqlx::query_scalar("SELECT count(*) FROM mcp_tokens") .fetch_one(&app) .await .unwrap(); assert_eq!(outside, 0); let mut tx = rmm_persistence::tenant_tx(&app, other).await.unwrap(); let foreign: i64 = sqlx::query_scalar("SELECT count(*) FROM mcp_tokens WHERE token_id=$1") .bind(id) .fetch_one(&mut *tx) .await .unwrap(); assert_eq!(foreign, 0); tx.commit().await.unwrap(); let mut tx = rmm_persistence::tenant_tx(&app, tenant).await.unwrap(); let row = sqlx::query(&format!( "SELECT {COLUMNS} FROM mcp_tokens WHERE token_id=$1" )) .bind(id) .fetch_one(&mut *tx) .await .unwrap(); let public = metadata(&row); assert!(public["last_used_at"].is_string()); assert!(!public.to_string().contains(&token) && public.get("token_hash").is_none()); tx.commit().await.unwrap(); // A later membership edit cannot add permission beyond the original scopes. sqlx::query("UPDATE memberships SET permissions=ARRAY['inventory:read','plans:approve','tokens:manage'] WHERE tenant_id=$1 AND principal=$2") .bind(tenant).bind(&principal.name).execute(&admin).await.unwrap(); let reduced = authenticate_pool(&app, &token, None).await.unwrap(); assert!( !reduced.operator && reduced.permits_scope("inventory:read") && !reduced.permits_scope("plans:approve") ); let mut tx = rmm_persistence::tenant_tx(&app, tenant).await.unwrap(); for permission in ["plans:approve", "tokens:manage", "scripts:execute"] { let allowed: bool = sqlx::query_scalar("SELECT mcp_principal_permission($1,$2)") .bind(&principal.name) .bind(permission) .fetch_one(&mut *tx) .await .unwrap(); assert!(!allowed); } tx.commit().await.unwrap(); sqlx::query("UPDATE memberships SET revoked_at=now() WHERE tenant_id=$1 AND principal=$2") .bind(tenant) .bind(&principal.name) .execute(&admin) .await .unwrap(); assert_eq!( authenticate_pool(&app, &token, None).await.err(), Some(StatusCode::UNAUTHORIZED) ); assert!(!enabled(&app, &principal.name, tenant).await); let (revoked_id, revoked) = mint(&app, tenant, &actor, &["inventory:read"]).await; let mut tx = rmm_persistence::tenant_tx(&app, tenant).await.unwrap(); let found: bool = sqlx::query_scalar("SELECT revoke_mcp_token($1,$2,$3,$4)") .bind(&actor) .bind(revoked_id) .bind(Uuid::new_v4()) .bind(vec![tenant]) .fetch_one(&mut *tx) .await .unwrap(); assert!(found); tx.commit().await.unwrap(); assert_eq!( authenticate_pool(&app, &revoked, None).await.err(), Some(StatusCode::UNAUTHORIZED) ); assert!(!enabled(&app, &format!("mcp:{revoked_id}"), tenant).await); let (expired_id, expired) = mint(&app, tenant, &actor, &["inventory:read"]).await; sqlx::query("UPDATE mcp_tokens SET created_at=now()-interval '2 days',expires_at=now()-interval '1 day' WHERE tenant_id=$1 AND token_id=$2") .bind(tenant).bind(expired_id).execute(&admin).await.unwrap(); assert_eq!( authenticate_pool(&app, &expired, None).await.err(), Some(StatusCode::UNAUTHORIZED) ); assert!(!enabled(&app, &format!("mcp:{expired_id}"), tenant).await); // The narrow definer rejects automation administrators and forbidden scopes. for (who, permissions) in [ (&principal.name, vec!["inventory:read"]), (&actor, vec!["plans:approve"]), (&actor, vec!["root:execute"]), ] { let mut tx = rmm_persistence::tenant_tx(&app, tenant).await.unwrap(); let denied = sqlx::query("SELECT issue_mcp_token($1,$2,'denied',$3,$4,now()+interval '1 day')") .bind(who) .bind(Uuid::new_v4()) .bind(hash(generate().unwrap().as_bytes())) .bind(permissions) .execute(&mut *tx) .await; assert!(denied.is_err()); tx.rollback().await.unwrap(); } let audit: Vec = sqlx::query_scalar("SELECT data FROM audit_events WHERE event_type LIKE 'mcp_token_%'") .fetch_all(&admin) .await .unwrap(); assert!( audit .iter() .all(|row| row.get("token").is_none() && row.get("token_hash").is_none()) ); println!( "PASS MCP random credentials, RLS routing, live membership/scopes, expiry, revoke, admin restrictions and secret-free metadata" ); app.close().await; admin.close().await; } }