674 lines
24 KiB
Rust
674 lines
24 KiB
Rust
//! 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<crate::State>) -> Router<crate::State> {
|
|
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::<Uuid,_>("token_id"),
|
|
"principal":row.get::<String,_>("principal"),
|
|
"name":row.get::<String,_>("name"),
|
|
"audience":if row.get::<bool,_>("all_customers") {"all"} else {"selected"},
|
|
"tenant_ids":row.get::<Vec<Uuid>,_>("customer_ids"),
|
|
"scopes":row.get::<Vec<String>,_>("scopes"),
|
|
"created_at":row.get::<DateTime<Utc>,_>("created_at"),
|
|
"expires_at":row.get::<DateTime<Utc>,_>("expires_at"),
|
|
"last_used_at":row.get::<Option<DateTime<Utc>>,_>("last_used_at"),
|
|
"revoked_at":row.get::<Option<DateTime<Utc>>,_>("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<String>, 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<Vec<String>> = 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<crate::State>,
|
|
headers: HeaderMap,
|
|
Path(tenant): Path<Uuid>,
|
|
) -> Result<Response, Error> {
|
|
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<String>=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::<Vec<_>>(),
|
|
"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<String>,
|
|
tenant_ids: Option<Vec<Uuid>>,
|
|
scopes: Option<Vec<String>>,
|
|
expires_at: Option<DateTime<Utc>>,
|
|
}
|
|
|
|
fn selection(
|
|
input: &Create,
|
|
allowed: &[String],
|
|
now: DateTime<Utc>,
|
|
) -> Result<(Vec<String>, DateTime<Utc>), 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<String, Error> {
|
|
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<crate::State>,
|
|
headers: HeaderMap,
|
|
Path(tenant): Path<Uuid>,
|
|
Json(input): Json<Create>,
|
|
) -> Result<Response, Error> {
|
|
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::<BTreeSet<_>>().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<crate::State>,
|
|
headers: HeaderMap,
|
|
Path((tenant, id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<Response, Error> {
|
|
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<Uuid>,
|
|
) -> Result<Principal, StatusCode> {
|
|
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<Uuid>,
|
|
) -> Result<Principal, StatusCode> {
|
|
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<Uuid> = 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<String> = sqlx::query_scalar("SELECT mcp_current_scopes($1)")
|
|
.bind(&principal)
|
|
.fetch_one(&mut *tx)
|
|
.await
|
|
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
|
|
let effective: BTreeSet<String> = 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<bool, sqlx::Error> {
|
|
let issuer: Option<String> = 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<bool, sqlx::Error> {
|
|
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<String> = 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<Value> =
|
|
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;
|
|
}
|
|
}
|