Organize device inventory by customer and restrict token access to its audience

This commit is contained in:
2026-11-17 21:55:24 +01:00
parent aeb9adc649
commit 0afaca1d64
39 changed files with 1950 additions and 225 deletions
+18 -83
View File
@@ -1,6 +1,6 @@
use axum::{
Extension, Json,
extract::{Path, Query, State},
extract::State,
http::{HeaderMap, StatusCode},
};
use chrono::Utc;
@@ -41,37 +41,32 @@ pub async fn agent_job_signing_key(
}
job_signing_key(State(state), h, Extension(peer)).await
}
pub async fn device(
State(state): State<crate::State>,
headers: HeaderMap,
Path((tenant, asset)): Path<(Uuid, Uuid)>,
) -> Result<Json<Value>, StatusCode> {
let list = device_list(&state, &headers, tenant, Some(asset), Default::default()).await?;
let item = list["items"]
.as_array()
.and_then(|items| {
items
.iter()
.find(|i| i["asset_id"].as_str() == Some(asset.to_string().as_str()))
})
.cloned()
.ok_or(StatusCode::NOT_FOUND)?;
Ok(Json(item))
}
pub async fn tenants(
State(state): State<crate::State>,
headers: HeaderMap,
) -> Result<Json<Value>, StatusCode> {
let principal = state.auth.principal(&state, &headers, false).await?;
let mut tx = rmm_persistence::tenant_tx(&state.pool, principal.tenant)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let can_manage = crate::customers::can_manage(&principal, &mut tx)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
tx.commit()
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let mut items = Vec::new();
for tenant in &principal.tenants {
let mut tx = rmm_persistence::tenant_tx(&state.pool, *tenant)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
if crate::permissions::require_principal(&mut tx, &principal, "inventory:read")
.await
.is_err()
{
// A bearer can have different effective scopes in each customer.
let has_read = (principal.name.starts_with("mcp:")
|| principal.permits_scope("inventory:read"))
&& crate::permissions::allowed(&mut tx, &principal.name, "inventory:read")
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
if !has_read {
continue;
}
let rows = sqlx::query("SELECT tenant_id,name FROM tenants")
@@ -89,66 +84,6 @@ pub async fn tenants(
return Err(StatusCode::FORBIDDEN);
}
Ok(Json(
json!({"items": items, "next_cursor":null,"completeness":"complete","truncated":false,"as_of":Utc::now()}),
json!({"items": items, "can_manage_customers":can_manage, "next_cursor":null,"completeness":"complete","truncated":false,"as_of":Utc::now()}),
))
}
pub async fn devices(
State(state): State<crate::State>,
headers: HeaderMap,
Path(tenant): Path<Uuid>,
) -> Result<Json<Value>, StatusCode> {
Ok(Json(
device_list(&state, &headers, tenant, None, Default::default()).await?,
))
}
pub async fn devices_page(
State(state): State<crate::State>,
h: HeaderMap,
Path(tenant): Path<Uuid>,
Query(page): Query<crate::pagination::PageQuery>,
) -> Result<Json<Value>, StatusCode> {
Ok(Json(device_list(&state, &h, tenant, None, page).await?))
}
async fn device_list(
state: &crate::State,
headers: &HeaderMap,
tenant: Uuid,
asset: Option<Uuid>,
query: crate::pagination::PageQuery,
) -> Result<Value, StatusCode> {
if identity(state, headers).await? != tenant {
return Err(StatusCode::NOT_FOUND);
}
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let principal = state.auth.principal(state, headers, false).await?;
crate::permissions::require_principal(&mut tx, &principal, "inventory:read")
.await
.map_err(|e| e.0)?;
let mut page =
crate::pagination::Cursor::parse(state, &principal, "devices:agent_id:asc", query)?;
let rows = sqlx::query("SELECT a.agent_id,a.asset_id,a.revoked_at,a.last_contact_at,a.certificate_sha256,a.last_authenticated_certificate_sha256,a.last_authenticated_at,a.reported_agent_version,a.capabilities,a.enrollment_generation,a.assignment_version,o.observed_at,o.received_at,o.data,o.source_id FROM agent_installations a LEFT JOIN LATERAL (SELECT observed_at,received_at,data,source_id FROM observations WHERE tenant_id=a.tenant_id AND agent_id=a.agent_id AND source_id IN ('linux.base','windows.base') AND received_at<=$2 ORDER BY observed_at DESC, received_at DESC LIMIT 1) o ON true WHERE ($1::uuid IS NULL OR a.asset_id=$1) AND a.agent_id>$3 AND a.created_at<=$2 ORDER BY a.agent_id LIMIT $4")
.bind(asset)
.bind(page.as_of).bind(page.last).bind(i64::from(page.limit)+1)
.fetch_all(&mut *tx).await.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
tx.commit()
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let truncated = rows.len() > usize::from(page.limit);
let items = rows.iter().take(usize::from(page.limit)).map(|r| {
let last: Option<chrono::DateTime<Utc>> = r.get("last_contact_at");
let revoked: Option<chrono::DateTime<Utc>> = r.get("revoked_at");
let age = last.map(|t| (Utc::now()-t).num_seconds());
let presence = if revoked.is_some() { "revoked" } else { match age { None=>"never_seen",Some(n) if n<90=>"online",Some(n) if n<180=>"stale",_=>"unreachable" } };
json!({"agent_id":r.get::<Uuid,_>("agent_id"),"asset_id":r.get::<Uuid,_>("asset_id"),"agent_version":r.get::<Option<String>,_>("reported_agent_version"),"certificate_sha256":r.get::<String,_>("certificate_sha256"),"last_authenticated_certificate_sha256":r.get::<Option<String>,_>("last_authenticated_certificate_sha256"),"last_authenticated_at":r.get::<Option<chrono::DateTime<Utc>>,_>("last_authenticated_at"),"capabilities":r.get::<Value,_>("capabilities"),"enrollment_generation":r.get::<i64,_>("enrollment_generation"),"assignment_version":r.get::<i64,_>("assignment_version"),"presence":presence,"last_contact_at":last,"inventory":r.get::<Option<Value>,_>("data"),"observed_at":r.get::<Option<chrono::DateTime<Utc>>,_>("observed_at"),"received_at":r.get::<Option<chrono::DateTime<Utc>>,_>("received_at"),"source_id":r.get::<Option<String>,_>("source_id"),"quality":if r.get::<Option<Value>,_>("data").is_some(){"valid"}else{"unknown"},"completeness":"partial","health":"unknown"})
}).collect::<Vec<_>>();
let next = if truncated {
Some(page.next(state, rows[usize::from(page.limit) - 1].get("agent_id"))?)
} else {
None
};
Ok(
json!({"items":items,"next_cursor":next,"completeness":if truncated{"partial"}else{"complete"},"truncated":truncated,"as_of":page.as_of}),
)
}
+18 -5
View File
@@ -261,13 +261,26 @@ impl Auth {
}
p
};
if p.name.starts_with("local:")
&& !self
if p.name.starts_with("local:") {
let home = self
.local
.as_ref()
.is_some_and(|local| local.enabled(&p.name, p.tenant))
{
return Err(StatusCode::FORBIDDEN);
.and_then(|local| local.home(&p.name))
.ok_or(StatusCode::FORBIDDEN)?;
let tenants: Vec<Uuid> = sqlx::query_scalar("SELECT local_customer_tenants($1,$2)")
.bind(&p.name)
.bind(home)
.fetch_one(&state.pool)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
if !tenants.contains(&home) {
return Err(StatusCode::FORBIDDEN);
}
p.tenant = selected.unwrap_or(home);
if !tenants.contains(&p.tenant) {
return Err(StatusCode::NOT_FOUND);
}
p.tenants = tenants;
}
if selected.is_some_and(|t| t != p.tenant) {
return Err(StatusCode::NOT_FOUND);
+14 -3
View File
@@ -1,6 +1,7 @@
//! Fresh-device bootstrap. Public scripts contain no credentials. Downloads use
//! the tenant's one-time enrollment token until the final enrollment consumes it.
use super::*;
mod starter;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
@@ -22,7 +23,7 @@ struct TenantPins { current: Pin, previous: Vec<Previous> }
#[serde(deny_unknown_fields)]
pub(super) struct UpdaterQuery { platform: Platform, sha256: Option<String> }
fn config(platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result<Config, Error> {
async fn config(s: &crate::State, platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result<Config, Error> {
let slot = match platform {
Platform::LinuxX64 => "RMM_AGENT_BOOTSTRAP_LINUX_FILE",
Platform::WindowsX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_FILE",
@@ -42,6 +43,15 @@ fn config(platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result<Conf
};
config.updater_sha256 = selected.sha256;
config.updater_bytes = selected.bytes;
} else {
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let pin = sqlx::query("SELECT sha256,size_bytes FROM customer_starter_workers WHERE platform=$1")
.bind(platform_name(platform)).fetch_optional(&mut *tx).await?;
tx.commit().await?;
if let Some(pin) = pin {
config.updater_sha256 = pin.get("sha256");
config.updater_bytes = pin.get::<i64, _>("size_bytes") as u64;
}
}
if wanted.is_some_and(|digest| digest != config.updater_sha256) { return Err(missing()); }
let url = url::Url::parse(&config.gateway_origin).map_err(|_| invalid())?;
@@ -98,6 +108,7 @@ pub(super) async fn issue(
let mut bytes = [0; 32];
openssl::rand::rand_bytes(&mut bytes).map_err(|_| fail("TOKEN_GENERATION_FAILED"))?;
let token = hex::encode(bytes);
starter::publish_missing(&mut tx, t).await?;
let release_platforms: Vec<String> =
sqlx::query_scalar("SELECT DISTINCT platform FROM agent_update_releases ORDER BY platform")
.fetch_all(&mut *tx)
@@ -170,7 +181,7 @@ pub(super) async fn current(
Query(q): Query<Current>,
) -> Result<Response, Error> {
let t = token_tenant(&s, &headers).await?;
let c = config(q.platform, t, None)?;
let c = config(&s, q.platform, t, None).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
let release: Uuid = sqlx::query_scalar("SELECT release_id FROM agent_update_releases WHERE platform=$1 ORDER BY release_sequence DESC LIMIT 1")
.bind(platform_name(q.platform)).fetch_optional(&mut *tx).await?.ok_or_else(missing)?;
@@ -217,6 +228,6 @@ pub(super) async fn updater(
Query(q): Query<UpdaterQuery>,
) -> Result<Response, Error> {
let tenant = token_tenant(&s, &headers).await?;
let c = config(q.platform, tenant, q.sha256.as_deref())?;
let c = config(&s, q.platform, tenant, q.sha256.as_deref()).await?;
verified_binary(tenant, c.updater_sha256, c.updater_bytes).await
}
+73
View File
@@ -0,0 +1,73 @@
//! Seed empty platform catalogs from the operator's protected distribution
//! directory during enrollment. Every download still uses the customer's own
//! catalog, stable-worker pin and verified object store.
use super::*;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Starter {
envelope: ReleaseEnvelope,
worker: Pin,
}
pub(super) async fn publish_missing(tx: &mut Transaction<'_, Postgres>, tenant: Uuid) -> Result<(), Error> {
let Some(slot) = std::env::var_os("RMM_AGENT_BOOTSTRAP_LINUX_FILE") else { return Ok(()) };
let Some(config_dir) = FsPath::new(&slot).parent() else { return Err(invalid()) };
let distribution = config_dir.join("customer-starters");
if !distribution.try_exists().map_err(|_| fail("STARTER_CONFIGURATION"))? { return Ok(()) }
for platform in [Platform::LinuxX64, Platform::WindowsGnuX64, Platform::WindowsX64] {
let name = platform_name(platform);
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT FROM agent_update_releases WHERE platform=$1)")
.bind(name).fetch_one(&mut **tx).await?;
if exists { continue; }
let path = distribution.join(format!("{name}.json"));
if !path.try_exists().map_err(|_| fail("STARTER_CONFIGURATION"))? { continue; }
// Other requests may be publishing the first package for this customer.
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1, 312))")
.bind(format!("{tenant}/{name}")).execute(&mut **tx).await?;
let exists: bool = sqlx::query_scalar("SELECT EXISTS(SELECT FROM agent_update_releases WHERE platform=$1)")
.bind(name).fetch_one(&mut **tx).await?;
if exists { continue; }
let package: Starter = serde_json::from_slice(&protected_file(&path, 65536)?)?;
let manifest = verify_envelope(&package.envelope, None)?;
if manifest.platform != platform { return Err(invalid()); }
let root = std::env::var("RMM_AGENT_UPDATE_ARTIFACT_DIR").map_err(|_| fail("STARTER_STORE"))?;
if !FsPath::new(&root).is_absolute() { return Err(invalid()); }
let owner = fs::symlink_metadata(&path).map_err(|_| fail("STARTER_CONFIGURATION"))?.uid();
let src = distribution.clone();
let mut files: Vec<_> = manifest.artifacts.iter().map(|a| (a.sha256.clone(),a.bytes)).collect();
files.push((package.worker.sha256.clone(), package.worker.bytes));
tokio::task::spawn_blocking(move || -> Result<(), Error> {
let store = UpdateArtifacts::private_directory(root.into(), owner)?;
for (digest, size) in files {
let mut staged = store.begin(tenant,&digest,size)?;
let mut file = fs::OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
.open(src.join(&digest)).map_err(|_| fail("STARTER_OBJECT_MISSING"))?;
let meta = file.metadata().map_err(|_| fail("STARTER_OBJECT_METADATA"))?;
if !meta.is_file() || meta.uid()!=owner || meta.mode() & 0o777 != 0o600 || meta.len()!=size { return Err(fail("STARTER_OBJECT_METADATA")); }
let mut buffer = [0; 65536];
loop {
let n = file.read(&mut buffer).map_err(|_| fail("STARTER_OBJECT_READ"))?;
if n == 0 { break; }
staged.append(&buffer[..n])?;
}
staged.finish(&store,tenant)?;
}
Ok(())
}).await.map_err(|_| fail("STARTER_OBJECT_COPY"))??;
for artifact in &manifest.artifacts {
sqlx::query("INSERT INTO agent_update_artifacts(tenant_id,artifact_id,sha256,size_bytes) VALUES($1,$2,$3,$4) ON CONFLICT DO NOTHING")
.bind(tenant).bind(artifact.artifact_id).bind(&artifact.sha256).bind(artifact.bytes as i64).execute(&mut **tx).await?;
}
let raw = encode(&package.envelope)?;
let a = &manifest.artifacts[0];
let h = &manifest.artifacts[1];
sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)")
.bind(tenant).bind(manifest.release_id).bind(name).bind(i64::try_from(manifest.release_sequence).map_err(|_|invalid())?)
.bind(hash(&package.envelope.decode().map_err(|_|invalid())?.payload_bytes)).bind(hash(&raw)).bind(raw)
.bind(a.artifact_id).bind(&a.sha256).bind(a.bytes as i64).bind(h.artifact_id).bind(&h.sha256).bind(h.bytes as i64).execute(&mut **tx).await?;
sqlx::query("INSERT INTO customer_starter_workers VALUES($1,$2,$3,$4)")
.bind(tenant).bind(name).bind(package.worker.sha256).bind(package.worker.bytes as i64).execute(&mut **tx).await?;
}
Ok(())
}
+37
View File
@@ -25,6 +25,10 @@ pub fn routes(r: Router<crate::State>) -> Router<crate::State> {
"/api/v1/tenants/{tenant}/devices/{asset}/revocation",
post(revoke_device),
)
.route(
"/api/v1/tenants/{tenant}/devices/{asset}/archive",
post(archive_device),
)
.route(
"/api/v1/tenants/{tenant}/operation-plans/{plan}/revocation",
post(revoke_plan),
@@ -63,6 +67,39 @@ async fn audit(
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,$4,$5,now())").bind(p.tenant).bind(Uuid::new_v4()).bind(&p.name).bind(event).bind(json!({"decision":data,"session_hash":p.session_hash,"approval_origin":p.approval_origin(),"testsimulation":p.testsimulation})).execute(&mut **tx).await?;
Ok(())
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Archive {
archived: bool,
}
async fn archive_device(
State(s): State<crate::State>,
h: HeaderMap,
Path((tenant, asset)): Path<(Uuid, Uuid)>,
Json(input): Json<Archive>,
) -> Result<Json<Value>, Error> {
let event = if input.archived {
"device_archived"
} else {
"device_restored"
};
let (p, mut tx) = context(&s, &h, tenant, "devices:revoke", event).await?;
let current: Option<chrono::DateTime<chrono::Utc>> = sqlx::query_scalar(
"SELECT archived_at FROM assets WHERE tenant_id=$1 AND asset_id=$2 FOR UPDATE",
)
.bind(tenant)
.bind(asset)
.fetch_optional(&mut *tx)
.await?
.ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?;
if current.is_some() != input.archived {
sqlx::query("UPDATE assets SET archived_at=CASE WHEN $3 THEN now() END WHERE tenant_id=$1 AND asset_id=$2")
.bind(tenant).bind(asset).bind(input.archived).execute(&mut *tx).await?;
audit(&mut tx, &p, event, json!({"asset_id":asset})).await?;
}
tx.commit().await?;
Ok(Json(json!({"asset_id":asset, "archived":input.archived})))
}
pub async fn revoke_device(
State(s): State<crate::State>,
h: HeaderMap,
+96
View File
@@ -0,0 +1,96 @@
//! Customer directory administration. Customer IDs are the existing tenant IDs.
use crate::{auth::Principal, jobs::Error};
use axum::{
Json,
extract::{Path, State},
http::{HeaderMap, StatusCode},
};
use serde::Deserialize;
use serde_json::{Value, json};
use sqlx::{Postgres, Transaction};
use uuid::Uuid;
pub fn database_error(e: sqlx::Error) -> Error {
match e.as_database_error().and_then(|e| e.code()).as_deref() {
Some("23505") => Error(StatusCode::CONFLICT, "CUSTOMER_ALREADY_EXISTS"),
Some("42501") => Error(StatusCode::FORBIDDEN, "FORBIDDEN"),
Some("22023") => Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"),
_ => e.into(),
}
}
pub async fn can_manage(
p: &Principal,
tx: &mut Transaction<'_, Postgres>,
) -> Result<bool, sqlx::Error> {
if p.testsimulation
|| p.session_hash.is_none()
|| p.csrf.is_none()
|| !p.name.starts_with("local:")
{
return Ok(false);
}
sqlx::query_scalar("SELECT is_customer_admin($1)")
.bind(&p.name)
.fetch_one(&mut **tx)
.await
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Input {
name: String,
}
pub async fn create(
State(state): State<crate::State>,
headers: HeaderMap,
Json(input): Json<Input>,
) -> Result<Json<Value>, Error> {
manage(&state, &headers, input, None).await
}
pub async fn rename(
State(state): State<crate::State>,
Path(id): Path<Uuid>,
headers: HeaderMap,
Json(input): Json<Input>,
) -> Result<Json<Value>, Error> {
manage(&state, &headers, input, Some(id)).await
}
async fn manage(
state: &crate::State,
headers: &HeaderMap,
input: Input,
existing: Option<Uuid>,
) -> Result<Json<Value>, Error> {
let p = state
.auth
.principal(state, headers, true)
.await
.map_err(|s| Error(s, crate::auth::error_code(s)))?;
if input.name.is_empty()
|| input.name.trim() != input.name
|| input.name.chars().count() > 120
|| input.name.chars().any(char::is_control)
{
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
}
if existing.is_some_and(|id| id != p.tenant) {
return Err(Error(StatusCode::NOT_FOUND, "NOT_FOUND"));
}
let mut tx = rmm_persistence::tenant_tx(&state.pool, p.tenant).await?;
if !can_manage(&p, &mut tx).await? {
return Err(Error(StatusCode::FORBIDDEN, "CUSTOMER_ADMIN_REQUIRED"));
}
let id = existing.unwrap_or_else(Uuid::new_v4);
sqlx::query("SELECT manage_customer($1,$2,$3,$4)")
.bind(&p.name)
.bind(id)
.bind(&input.name)
.bind(existing.is_none())
.execute(&mut *tx)
.await
.map_err(database_error)?;
tx.commit().await?;
Ok(Json(json!({"tenant_id":id,"name":input.name})))
}
+43
View File
@@ -0,0 +1,43 @@
WITH classified AS (
SELECT a.tenant_id,a.asset_id,a.agent_id,a.created_at,a.revoked_at,a.last_contact_at,
a.last_authenticated_at,a.last_authenticated_certificate_sha256,a.certificate_sha256,
a.enrollment_generation,a.assignment_version,a.capabilities,a.reported_agent_version,
asset.archived_at,t.name AS customer_name,
CASE
WHEN a.revoked_at IS NOT NULL THEN 'revoked'
WHEN asset.archived_at IS NOT NULL THEN 'archived'
WHEN a.last_contact_at IS NULL THEN 'never_seen'
WHEN a.last_authenticated_at IS NULL THEN 'unverified'
WHEN EXISTS (
SELECT 1 FROM agent_installations newer
WHERE newer.tenant_id=a.tenant_id AND newer.asset_id=a.asset_id
AND newer.enrollment_generation>a.enrollment_generation
AND newer.last_contact_at IS NOT NULL AND newer.last_authenticated_at IS NOT NULL
AND newer.created_at<=$2
) THEN 'replaced'
ELSE 'current'
END AS lifecycle,
CASE WHEN a.last_contact_at IS NULL THEN 'never_seen'
WHEN a.last_contact_at>$2::timestamptz-interval '90 seconds' THEN 'online'
ELSE 'offline' END AS status
FROM agent_installations a
JOIN assets asset USING (tenant_id,asset_id)
JOIN tenants t USING(tenant_id)
WHERE a.tenant_id=$1 AND a.created_at<=$2 AND a.agent_id>$3
AND ($4::uuid IS NULL OR a.asset_id=$4)
AND ($5::uuid IS NULL OR a.agent_id=$5)
)
SELECT c.*,o.observed_at,o.received_at,o.data,o.source_id FROM classified c
LEFT JOIN LATERAL (
SELECT observed_at,received_at,data,source_id FROM observations
WHERE tenant_id=c.tenant_id AND agent_id=c.agent_id AND received_at<=$2
AND source_id IN ('linux.base','windows.base')
ORDER BY observed_at DESC,received_at DESC,sequence DESC LIMIT 1
) o ON true
WHERE ($6::text IS NULL OR (c.lifecycle='current')=($6='current'))
AND ($7::text IS NULL OR c.status=$7)
AND ($8='' OR strpos(lower(o.data->>'hostname'),lower($8))>0)
ORDER BY CASE WHEN $4 IS NOT NULL THEN (c.lifecycle='current') END DESC,
CASE WHEN $4 IS NOT NULL THEN c.enrollment_generation END DESC,
CASE WHEN $4 IS NOT NULL THEN c.created_at END DESC, c.agent_id
LIMIT $9
+478
View File
@@ -0,0 +1,478 @@
//! Visible inventory for the fleet and for a single customer. Each database
//! read stays inside an authorized customer's transaction, including pagination.
use crate::{
jobs::Error,
pagination::{Cursor, PageQuery},
};
use axum::{
Json,
extract::{Path, Query, State},
http::{HeaderMap, HeaderValue, StatusCode},
};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use sqlx::{Postgres, Row, Transaction, postgres::PgRow};
use uuid::Uuid;
#[derive(Default, Deserialize, Serialize, schemars::JsonSchema, Clone, Copy)]
#[serde(rename_all = "snake_case")]
pub enum View {
#[default]
Current,
History,
}
impl View {
fn name(self) -> &'static str {
match self {
Self::Current => "current",
Self::History => "history",
}
}
}
#[derive(Deserialize, Serialize, schemars::JsonSchema, Clone, Copy)]
#[serde(rename_all = "snake_case")]
pub enum Status {
Online,
Offline,
}
impl Status {
fn name(self) -> &'static str {
match self {
Self::Online => "online",
Self::Offline => "offline",
}
}
}
#[derive(Default, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct Filters {
pub cursor: Option<String>,
pub limit: Option<u16>,
#[serde(default)]
pub view: View,
pub status: Option<Status>,
pub q: Option<String>,
}
#[derive(Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DetailQuery {
pub agent_id: Option<Uuid>,
}
pub async fn page(
State(s): State<crate::State>,
h: HeaderMap,
Path(tenant): Path<Uuid>,
Query(q): Query<Filters>,
) -> Result<Json<Value>, Error> {
list(&s, &h, Some(tenant), q).await.map(Json)
}
pub async fn all(
State(s): State<crate::State>,
h: HeaderMap,
Query(q): Query<Filters>,
) -> Result<Json<Value>, Error> {
list(&s, &h, None, q).await.map(Json)
}
struct Selection<'a> {
tenant: Uuid,
asset: Option<Uuid>,
agent: Option<Uuid>,
view: Option<View>,
status: Option<Status>,
hostname: &'a str,
last: Uuid,
as_of: DateTime<Utc>,
limit: i64,
}
impl Selection<'_> {
async fn rows(&self, tx: &mut Transaction<'_, Postgres>) -> Result<Vec<PgRow>, Error> {
Ok(sqlx::query(include_str!("device_list.sql"))
.bind(self.tenant)
.bind(self.as_of)
.bind(self.last)
.bind(self.asset)
.bind(self.agent)
.bind(self.view.map(View::name))
.bind(self.status.map(Status::name))
.bind(self.hostname)
.bind(self.limit)
.fetch_all(&mut **tx)
.await?)
}
}
pub async fn list(
s: &crate::State,
h: &HeaderMap,
tenant: Option<Uuid>,
q: Filters,
) -> Result<Value, Error> {
let p = crate::jobs::principal(s, h, false).await?;
let mut tenants = match tenant {
Some(id) => {
crate::jobs::scope(&p, id, false)?;
vec![id]
}
None => p.tenants.clone(),
};
tenants.sort_unstable();
tenants.dedup();
let hostname = q.q.as_deref().unwrap_or("").trim();
if hostname.len() > 255 || hostname.chars().any(char::is_control) {
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"));
}
let binding = json!([tenant, tenants, q.view, q.status, hostname]);
let scope = format!(
"device-fleet:{}",
rmm_domain::jobs::hash(binding.to_string().as_bytes())
);
let mut page = Cursor::parse(
s,
&p,
&scope,
PageQuery {
cursor: q.cursor,
limit: q.limit,
},
)
.map_err(|code| Error(code, crate::auth::error_code(code)))?;
let capacity = usize::from(page.limit);
let mut items = Vec::new();
let mut last = None;
let mut truncated = false;
let mut authorized = false;
for customer in tenants {
if page.last_tenant.is_some_and(|after| customer < after) {
continue;
}
let mut headers = h.clone();
headers.insert(
"x-rmm-tenant",
HeaderValue::from_str(&customer.to_string())
.map_err(|_| Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?,
);
let current = crate::jobs::principal(s, &headers, false).await?;
crate::jobs::scope(&current, customer, false)?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, customer).await?;
match crate::permissions::require_principal(&mut tx, &current, "inventory:read").await {
Err(Error(StatusCode::FORBIDDEN, _)) if tenant.is_none() => continue,
other => other?,
}
authorized = true;
let rows = Selection {
tenant: customer,
asset: None,
agent: None,
view: Some(q.view),
status: q.status,
hostname,
last: if page.last_tenant == Some(customer) {
page.last
} else {
Uuid::nil()
},
as_of: page.as_of,
limit: (capacity + 1 - items.len()) as i64,
}
.rows(&mut tx)
.await?;
tx.commit().await?;
for row in rows {
if items.len() == capacity {
truncated = true;
break;
}
last = Some((customer, row.get::<Uuid, _>("agent_id")));
items.push(project(&row, page.as_of, tenant.is_some()));
}
if truncated {
break;
}
}
if !authorized {
return Err(Error(StatusCode::FORBIDDEN, "FORBIDDEN"));
}
let next = if let Some((customer, agent)) = last.filter(|_| truncated) {
page.last_tenant = Some(customer);
Some(
page.next(s, agent)
.map_err(|code| Error(code, crate::auth::error_code(code)))?,
)
} else {
None
};
Ok(
json!({"items":items,"next_cursor":next,"truncated":truncated,"completeness":if truncated{"partial"}else{"complete"},"as_of":page.as_of}),
)
}
pub async fn detail(
State(s): State<crate::State>,
h: HeaderMap,
Path((tenant, asset)): Path<(Uuid, Uuid)>,
Query(query): Query<DetailQuery>,
) -> Result<Json<Value>, Error> {
let p = crate::jobs::principal(&s, &h, false).await?;
crate::jobs::scope(&p, tenant, false)?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
crate::permissions::require_principal(&mut tx, &p, "inventory:read").await?;
let now = Utc::now();
let row = Selection {
tenant,
asset: Some(asset),
agent: query.agent_id,
view: None,
status: None,
hostname: "",
last: Uuid::nil(),
as_of: now,
limit: 1,
}
.rows(&mut tx)
.await?
.pop()
.ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?;
let mut item = project(&row, now, true);
item["volumes"] = volumes(&item["inventory"]);
item["recent_jobs"] = if p.permits_scope("operations:read")
&& crate::permissions::allowed(&mut tx, &p.name, "operations:read").await?
{
sqlx::query_scalar::<_,Value>("SELECT jsonb_build_object('job_id',j.job_id,'operation_id',j.operation_id,'state',j.state,'created_at',r.created_at) FROM jobs j JOIN approval_requests r USING(tenant_id,operation_id) WHERE j.tenant_id=$1 AND j.asset_id=$2 AND j.agent_id=$3 ORDER BY r.created_at DESC,j.job_id LIMIT 20")
.bind(tenant).bind(asset).bind(row.get::<Uuid,_>("agent_id")).fetch_all(&mut *tx).await?.into()
} else {
Value::Null
};
tx.commit().await?;
Ok(Json(item))
}
fn observed<'a>(data: &'a Value, scope: &str) -> &'a Value {
data["observations"]
.as_array()
.and_then(|items| {
items
.iter()
.find(|o| o["scope"] == scope && o["quality"] == "valid")
})
.map(|o| &o["data"])
.unwrap_or(&Value::Null)
}
fn volumes(data: &Value) -> Value {
let mut items = Vec::new();
if let Some(rows) = observed(data, "linux.volumes").as_array() {
for entry in rows.iter().filter(|entry| entry["quality"] == "valid") {
let v = &entry["data"];
if v["mount_point"].is_string() {
items.push(json!({"name":v["mount_point"],"free_bytes":v["available_bytes"].as_u64(),"total_bytes":v["total_bytes"].as_u64()}));
}
}
}
if items.is_empty() && data["root_total_bytes"].is_number() {
let name = if observed(data, "windows.volumes").is_object() {
"Systemvolume"
} else {
"/"
};
items.push(json!({"name":name,"free_bytes":data["root_available_bytes"],"total_bytes":data["root_total_bytes"]}));
}
items.into()
}
fn os_label(data: &Value) -> Option<String> {
let raw = data["os"].as_str()?;
if let Some(pretty) = observed(data, "linux.os")["release"]["PRETTY_NAME"].as_str() {
return Some(pretty.to_owned());
}
if let Some(pretty) = raw.lines().find_map(|l| l.strip_prefix("PRETTY_NAME=")) {
return Some(pretty.trim_matches(['"', '\'']).to_owned());
}
let product = observed(data, "windows.os");
if let Some(name) = product["product_name"].as_str() {
// Windows 11 can retain a Windows 10 client ProductName for compatibility.
let product_name = match (
name.strip_prefix("Windows 10 "),
product["build"]
.as_str()
.and_then(|s| s.parse::<u32>().ok()),
) {
(Some(edition), Some(build))
if build >= 22000
&& ["Home", "Pro", "Enterprise", "Education", "IoT"]
.iter()
.any(|prefix| {
edition == *prefix
|| edition
.strip_prefix(prefix)
.is_some_and(|suffix| suffix.starts_with(' '))
}) =>
{
format!("Windows 11 {edition}")
}
_ => name.to_owned(),
};
return Some(
match product["display_version"]
.as_str()
.filter(|v| !v.is_empty())
{
Some(version) => format!("{product_name} {version}"),
None => product_name,
},
);
}
if !raw.contains('\n') {
Some(raw.to_owned())
} else {
Some("Linux".to_owned())
}
}
fn project(row: &PgRow, now: DateTime<Utc>, full: bool) -> Value {
let data = row.get::<Option<Value>, _>("data").unwrap_or(Value::Null);
let cpu = observed(&data, "linux.cpu");
let windows = observed(&data, "windows.hardware");
let last = row.get::<Option<DateTime<Utc>>, _>("last_contact_at");
let revoked = row.get::<Option<DateTime<Utc>>, _>("revoked_at");
let presence = match (revoked, last.map(|t| (now - t).num_seconds())) {
(Some(_), _) => "revoked",
(_, None) => "never_seen",
(_, Some(age)) if age < 90 => "online",
(_, Some(age)) if age < 180 => "stale",
_ => "unreachable",
};
let mut item = json!({
"tenant_id":row.get::<Uuid,_>("tenant_id"),"customer_name":row.get::<String,_>("customer_name"),
"agent_id":row.get::<Uuid,_>("agent_id"),"asset_id":row.get::<Uuid,_>("asset_id"),
"status":row.get::<String,_>("status"),"lifecycle":row.get::<String,_>("lifecycle"),
"archived_at":row.get::<Option<DateTime<Utc>>,_>("archived_at"),"revoked_at":revoked,
"hostname":data["hostname"].as_str(),"os":os_label(&data),
"disk_free_bytes":data["root_available_bytes"].as_u64(),"disk_total_bytes":data["root_total_bytes"].as_u64(),
"cpu_model":cpu["model"].as_str().or_else(||windows["cpu_model"].as_str()),
"cpu_logical_count":cpu["logical_processors"].as_u64().or_else(||windows["logical_processors_visible"].as_u64()),
"ram_total_bytes":observed(&data,"linux.memory")["total_bytes"].as_u64().or_else(||windows["memory_total_bytes"].as_u64()),
"last_contact_at":last,"agent_version":row.get::<Option<String>,_>("reported_agent_version"),
"presence":presence,"observed_at":row.get::<Option<DateTime<Utc>>,_>("observed_at"),
"received_at":row.get::<Option<DateTime<Utc>>,_>("received_at"),
"source_id":row.get::<Option<String>,_>("source_id"),"quality":if data.is_null(){"unknown"}else{"valid"},
"completeness":"partial","health":"unknown"
});
if full {
item["inventory"] = data;
item["capabilities"] = row.get("capabilities");
item["enrollment_generation"] = row.get::<i64, _>("enrollment_generation").into();
item["assignment_version"] = row.get::<i64, _>("assignment_version").into();
item["certificate_sha256"] = row.get::<String, _>("certificate_sha256").into();
item["last_authenticated_certificate_sha256"] =
json!(row.get::<Option<String>, _>("last_authenticated_certificate_sha256"));
item["last_authenticated_at"] =
json!(row.get::<Option<DateTime<Utc>>, _>("last_authenticated_at"));
}
item
}
#[cfg(test)]
mod tests {
use super::*;
fn windows_os(name: &str, build: &str) -> String {
let old = json!({"os":name,"observations":[{"scope":"windows.os","quality":"valid",
"data":{"product_name":name,"build":build,"display_version":"26H2"}}]});
os_label(&old).unwrap()
}
#[test]
fn os_labels_keep_the_edition_and_handle_existing_snapshots() {
assert_eq!(windows_os("Windows 10 Pro", "26300"), "Windows 11 Pro 26H2");
assert_eq!(windows_os("Windows 10 Pro", "19045"), "Windows 10 Pro 26H2");
assert_eq!(
windows_os("Windows Server 2025", "26100"),
"Windows Server 2025 26H2"
);
assert_eq!(
windows_os("Windows 10 Pro", "invalid"),
"Windows 10 Pro 26H2"
);
assert_eq!(
windows_os("Windows 10 Custom", "26100"),
"Windows 10 Custom 26H2"
);
let linux = json!({"os":"NAME=Example\nPRETTY_NAME=\"Test Linux 1.2\"\nID=linux"});
assert_eq!(os_label(&linux).as_deref(), Some("Test Linux 1.2"));
assert!(os_label(&Value::Null).is_none());
}
#[tokio::test]
#[ignore = "requires the disposable RLS database from tests/local_access_database.py"]
async fn visibility_is_filtered_before_the_cursor_limit() {
let admin = sqlx::PgPool::connect(&std::env::var("RMM_TEST_REPAIR_ADMIN_URL").unwrap())
.await
.unwrap();
let app = sqlx::PgPool::connect(&std::env::var("RMM_TEST_REPAIR_APP_URL").unwrap())
.await
.unwrap();
let tenant = Uuid::new_v4();
sqlx::query("INSERT INTO tenants(tenant_id,name) VALUES($1,'Filter test')")
.bind(tenant)
.execute(&admin)
.await
.unwrap();
// In this order: archived, revoked, never connected, old unauthenticated
// metadata, confirmed offline, confirmed online. Same hostnames are intentional.
for n in 1..=6_i32 {
let id = Uuid::from_u128(n as u128);
sqlx::query("INSERT INTO assets(tenant_id,asset_id,archived_at) VALUES($1,$2,CASE WHEN $3=1 THEN now() END)")
.bind(tenant).bind(id).bind(n).execute(&admin).await.unwrap();
let cert = hex::encode(openssl::sha::sha256(format!("{tenant}/{id}").as_bytes()));
sqlx::query("INSERT INTO agent_installations(tenant_id,asset_id,agent_id,certificate_sha256,revoked_at,last_contact_at,last_authenticated_at,last_authenticated_certificate_sha256) VALUES($1,$2,$2,$3,CASE WHEN $4=2 THEN now() END,CASE WHEN $4=5 THEN now()-interval '30 days' WHEN $4<>3 THEN now() END,CASE WHEN $4 NOT IN (3,4) THEN now() END, CASE WHEN $4 NOT IN (3,4) THEN $3 END)")
.bind(tenant).bind(id).bind(cert).bind(n).execute(&admin).await.unwrap();
let data = json!({"hostname":"same-host","os":"Ubuntu","root_available_bytes":10,"root_total_bytes":20,
"observations":[{"scope":"linux.memory","quality":"valid","data":{"total_bytes":1024}},{"scope":"linux.cpu","quality":"valid","data":{"logical_processors":2,"model":"Test CPU"}}]});
sqlx::query("INSERT INTO observations(tenant_id,agent_id,message_id,boot_id,sequence,observed_at,source_id,quality,completeness,snapshot_id,data,payload_sha256) VALUES($1,$2,$3,$4,1,now(),'linux.base','valid','partial',$5,$6,$7)")
.bind(tenant).bind(id).bind(Uuid::new_v4()).bind(Uuid::new_v4()).bind(Uuid::new_v4()).bind(data).bind("0".repeat(64)).execute(&admin).await.unwrap();
}
let mut tx = rmm_persistence::tenant_tx(&app, tenant).await.unwrap();
let mut q = Selection {
tenant,
asset: None,
agent: None,
view: Some(View::Current),
status: None,
hostname: "AME-h",
last: Uuid::nil(),
as_of: Utc::now(),
limit: 1,
};
let row = q.rows(&mut tx).await.unwrap().pop().unwrap();
let summary = project(&row, q.as_of, false);
assert_eq!(summary["status"], "offline");
assert_eq!(summary["ram_total_bytes"], 1024);
assert_eq!(summary["cpu_model"], "Test CPU");
assert_eq!(summary["disk_free_bytes"], 10);
q.last = row.get("agent_id");
assert_eq!(
q.rows(&mut tx).await.unwrap()[0].get::<String, _>("status"),
"online"
);
q.status = Some(Status::Offline);
assert!(q.rows(&mut tx).await.unwrap().is_empty());
q.status = None;
q.last = Uuid::nil();
q.view = Some(View::History);
q.limit = 10;
let got: Vec<String> = q
.rows(&mut tx)
.await
.unwrap()
.iter()
.map(|r| r.get("lifecycle"))
.collect();
assert_eq!(got, ["archived", "revoked", "never_seen", "unverified"]);
q.hostname = "%";
assert!(q.rows(&mut tx).await.unwrap().is_empty());
q.hostname = "";
q.tenant = Uuid::new_v4();
assert!(q.rows(&mut tx).await.unwrap().is_empty());
tx.rollback().await.unwrap();
}
}
+4 -1
View File
@@ -1065,7 +1065,10 @@ pub async fn requester_enabled(
tenant: Uuid,
) -> std::result::Result<bool, sqlx::Error> {
if name.starts_with("mcp:") {
crate::mcp_tokens::enabled_in(tx, name).await
crate::mcp_tokens::issuer_enabled(state, tx, name).await
} else if name.starts_with("local:") {
let Some(home)=state.auth.local.as_ref().and_then(|local|local.home(name)) else {return Ok(false);};
sqlx::query_scalar("SELECT $3=ANY(local_customer_tenants($1,$2))").bind(name).bind(home).bind(tenant).fetch_one(&mut **tx).await
} else {
Ok(state.auth.operator_enabled(name, tenant))
}
+6
View File
@@ -210,6 +210,12 @@ impl LocalAuth {
workers: Arc::new(Semaphore::new(1)),
})
}
pub fn home(&self, principal: &str) -> Option<Uuid> {
self.users
.iter()
.find(|user| !user.disabled && user.principal == principal)
.map(|user| user.tenant)
}
pub fn enabled(&self, principal: &str, tenant: Uuid) -> bool {
self.users
.iter()
+7 -3
View File
@@ -6,10 +6,12 @@ mod agent_update_health;
mod agent_update_policy;
mod agent_updates;
mod api;
mod devices;
mod artifact_store;
mod auth;
mod local_auth;
mod mcp_tokens;
mod customers;
mod catalog;
mod checkpoint_repair;
mod controls;
@@ -208,9 +210,11 @@ async fn main() -> Result<()> {
.route("/auth/session", get(auth::session))
.route("/auth/logout", post(auth::logout))
.route("/api/v1/job-signing-key", get(api::job_signing_key))
.route("/api/v1/tenants", get(api::tenants))
.route("/api/v1/tenants/{tenant}/devices", get(api::devices_page))
.route("/api/v1/tenants/{tenant}/devices/{asset}", get(api::device));
.route("/api/v1/tenants", get(api::tenants).post(customers::create))
.route("/api/v1/tenants/{tenant}", axum::routing::patch(customers::rename))
.route("/api/v1/devices", get(devices::all))
.route("/api/v1/tenants/{tenant}/devices", get(devices::page))
.route("/api/v1/tenants/{tenant}/devices/{asset}", get(devices::detail));
routes = mcp_tokens::routes(routes);
routes = routes.route("/auth/local/login", post(auth::local_login));
routes = jobs::routes(routes);
+29 -14
View File
@@ -38,9 +38,21 @@ struct Devices {
}
#[derive(Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
struct Fleet {
tenant_id: Option<Uuid>,
cursor: Option<String>,
limit: Option<u16>,
#[serde(default)]
view: crate::devices::View,
status: Option<crate::devices::Status>,
q: Option<String>,
}
#[derive(Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
struct Device {
tenant_id: Uuid,
asset_id: Uuid,
agent_id: Option<Uuid>,
}
#[derive(Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
@@ -96,9 +108,9 @@ fn tools() -> Vec<Tool> {
"tenants.list",
"List only the authenticated identity's tenants.",
),
tool::<Devices>(
tool::<Fleet>(
"inventory.list_devices",
"Stored inventory with source, completeness and timestamps; no live collection.",
"List current, previously connected devices. Omit tenant_id for all authorized customers. Use view=history for retired or never-seen installations.",
),
tool::<Device>(
"inventory.get_device",
@@ -195,29 +207,32 @@ impl Adapter {
.0)
}
"inventory.list_devices" => {
let i: Devices = parse(args)?;
Ok(crate::api::devices_page(
State(self.state.clone()),
h,
Path(i.tenant_id),
axum::extract::Query(crate::pagination::PageQuery {
let i: Fleet = parse(args)?;
crate::devices::list(
&self.state,
&h,
i.tenant_id,
crate::devices::Filters {
cursor: i.cursor,
limit: i.limit,
}),
view: i.view,
status: i.status,
q: i.q,
},
)
.await
.map_err(map_http)?
.0)
}
"inventory.get_device" => {
let i: Device = parse(args)?;
Ok(crate::api::device(
Ok(crate::devices::detail(
State(self.state.clone()),
h,
Path((i.tenant_id, i.asset_id)),
axum::extract::Query(crate::devices::DetailQuery {
agent_id: i.agent_id,
}),
)
.await
.map_err(map_http)?
.await?
.0)
}
"monitoring.get_health" => {
+115 -22
View File
@@ -31,8 +31,7 @@ const SCOPES: [&str; 11] = [
"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";
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")
@@ -70,6 +69,8 @@ fn metadata(row: &PgRow) -> Value {
"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"),
@@ -119,20 +120,31 @@ async fn list(
headers: HeaderMap,
Path(tenant): Path<Uuid>,
) -> Result<Response, Error> {
let (_, allowed, mut tx) = administration(&state, &headers, tenant, false).await?;
let (principal, allowed, mut tx) = administration(&state, &headers, tenant, false).await?;
let rows = sqlx::query(&format!(
"SELECT {COLUMNS} FROM mcp_tokens ORDER BY created_at DESC,token_id"
))
.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}),
"allowed_scopes":allowed,"default_scopes":defaults,"can_select_all":can_select_all,"available_customers":available}),
))
}
@@ -140,6 +152,8 @@ async fn list(
#[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>>,
}
@@ -200,15 +214,41 @@ async fn create(
let (scopes, expiry) = selection(&input, &allowed, Utc::now())?;
let token = generate()?;
let id = Uuid::new_v4();
sqlx::query("SELECT issue_mcp_token($1,$2,$3,$4,$5,$6)")
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?;
.await
.map_err(crate::customers::database_error)?;
let row = sqlx::query(&format!(
"SELECT {COLUMNS} FROM mcp_tokens WHERE token_id=$1"
))
@@ -251,7 +291,20 @@ pub async fn authenticate(
raw: &str,
selected: Option<Uuid>,
) -> Result<Principal, StatusCode> {
authenticate_pool(&state.pool, raw, selected).await
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(
@@ -270,36 +323,49 @@ async fn authenticate_pool(
.fetch_optional(pool)
.await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?;
let (tenant, id) = route.ok_or(StatusCode::UNAUTHORIZED)?;
if selected.is_some_and(|value| value != tenant) {
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 row = sqlx::query("SELECT t.principal,t.scopes,m.permissions FROM mcp_tokens t JOIN memberships m USING(tenant_id,principal) WHERE t.token_id=$1 AND t.token_hash=$2 AND t.revoked_at IS NULL AND t.expires_at>now() AND m.kind='automation' AND m.revoked_at IS NULL")
.bind(id).bind(digest).fetch_optional(&mut *tx).await
.map_err(|_| StatusCode::SERVICE_UNAVAILABLE)?.ok_or(StatusCode::UNAUTHORIZED)?;
let allowed: Vec<String> = row.get("permissions");
let effective: BTreeSet<String> = row
.get::<Vec<String>, _>("scopes")
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(|permission| allowed.contains(permission) && SCOPES.contains(&permission.as_str()))
.filter(|p| SCOPES.contains(&p.as_str()))
.collect();
if effective.is_empty() {
return Err(StatusCode::FORBIDDEN);
}
sqlx::query("UPDATE mcp_tokens SET last_used_at=now() WHERE token_id=$1")
.bind(id)
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: row.get("principal"),
name: principal,
operator: effective
.iter()
.any(|scope| !READ_SCOPES.contains(&scope.as_str())),
@@ -308,16 +374,41 @@ async fn authenticate_pool(
scopes: Some(effective),
testsimulation: false,
identity: None,
tenants: vec![tenant],
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()
}
}))
}
pub async fn enabled_in(
tx: &mut Transaction<'_, Postgres>,
principal: &str,
) -> Result<bool, sqlx::Error> {
sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM mcp_tokens t JOIN memberships m USING(tenant_id,principal) WHERE t.principal=$1 AND t.revoked_at IS NULL AND t.expires_at>now() AND m.kind='automation' AND m.revoked_at IS NULL AND t.scopes && m.permissions)")
.bind(principal).fetch_one(&mut **tx).await
sqlx::query_scalar("SELECT cardinality(mcp_current_scopes($1))>0")
.bind(principal)
.fetch_one(&mut **tx)
.await
}
pub async fn enabled(pool: &PgPool, principal: &str, tenant: Uuid) -> bool {
@@ -338,6 +429,8 @@ mod tests {
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,
};
+8 -1
View File
@@ -13,7 +13,14 @@ pub async fn health(
h: HeaderMap,
Path(t): Path<Uuid>,
) -> Result<Json<Value>, StatusCode> {
let Json(devices) = crate::api::devices(State(s), h, Path(t)).await?;
let Json(devices) = crate::devices::page(
State(s),
h,
Path(t),
axum::extract::Query(Default::default()),
)
.await
.map_err(|e| e.0)?;
Ok(Json(
json!({"items":devices["items"],"next_cursor":null,"completeness":devices["completeness"],"truncated":devices["truncated"],"as_of":Utc::now(),"health":"unknown","source_id":"stored_agent_observations"}),
))
+3
View File
@@ -17,6 +17,8 @@ pub struct Cursor {
scope: String,
pub as_of: DateTime<Utc>,
pub last: Uuid,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_tenant: Option<Uuid>,
pub limit: u16,
}
impl Cursor {
@@ -71,6 +73,7 @@ impl Cursor {
scope: scope.into(),
as_of: Utc::now(),
last: Uuid::nil(),
last_tenant: None,
limit: q.limit.unwrap_or(100),
})
}
+6 -25
View File
@@ -3,11 +3,10 @@ use anyhow::Result;
use sqlx::{Postgres, Transaction};
use uuid::Uuid;
pub async fn maintain(tx: &mut Transaction<'_, Postgres>, agent: Option<Uuid>) -> Result<()> {
sqlx::query("UPDATE approval_requests r SET approval_state='expired' FROM operation_plans p WHERE p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id AND r.approval_state='pending_approval' AND p.expires_at<=now()").execute(&mut **tx).await?;
sqlx::query("UPDATE jobs j SET state='expired',pending_reason=NULL FROM operations o,approval_requests r,operation_plans p WHERE j.tenant_id=o.tenant_id AND j.operation_id=o.operation_id AND r.tenant_id=o.tenant_id AND r.operation_id=o.operation_id AND p.tenant_id=r.tenant_id AND p.plan_id=r.plan_id AND ($1::uuid IS NULL OR j.agent_id=$1) AND j.state IN ('queued','accepted') AND NOT j.start_reserved AND p.expires_at<=now()").bind(agent).execute(&mut **tx).await?;
sqlx::query("UPDATE jobs j SET state='unknown',pending_reason='reconciliation_required',result=COALESCE(j.result,'{}'::jsonb)||jsonb_build_object('error_code','START_OR_RESULT_UNCONFIRMED','source_id','server_grant_ledger') FROM execution_permits e WHERE e.tenant_id=j.tenant_id AND e.job_id=j.job_id AND ($1::uuid IS NULL OR j.agent_id=$1) AND j.start_reserved AND ((j.state='accepted' AND (convert_from(e.payload,'UTF8')::jsonb->>'start_before')::timestamptz<now()) OR (j.state IN ('running','verifying') AND (convert_from(e.payload,'UTF8')::jsonb->>'start_before')::timestamptz+make_interval(secs=>(convert_from(e.payload,'UTF8')::jsonb->>'max_runtime_seconds')::integer)<now()))").bind(agent).execute(&mut **tx).await?;
sqlx::query("UPDATE jobs j SET pending_reason=CASE WHEN t.changes_stopped THEN 'tenant_stopped' WHEN r.approval_state<>'approved' THEN 'authorization_revoked' WHEN (convert_from(j.payload,'UTF8')::jsonb->>'not_before')::timestamptz>now() THEN 'maintenance_window' WHEN i.last_contact_at IS NULL OR i.last_contact_at<now()-interval '180 seconds' THEN 'device_offline' ELSE NULL END FROM tenants t,approval_requests r,agent_installations i WHERE j.tenant_id=t.tenant_id AND r.tenant_id=j.tenant_id AND r.operation_id=j.operation_id AND i.tenant_id=j.tenant_id AND i.agent_id=j.agent_id AND j.state IN ('queued','accepted') AND NOT j.start_reserved AND ($1::uuid IS NULL OR j.agent_id=$1)").bind(agent).execute(&mut **tx).await?;
sqlx::query("UPDATE jobs j SET state='unknown',pending_reason='reconciliation_required',result=COALESCE(j.result,'{}'::jsonb)||jsonb_build_object('error_code','REBOOT_REJOIN_UNCONFIRMED','source_id','server_grant_ledger') FROM execution_permits e WHERE e.tenant_id=j.tenant_id AND e.job_id=j.job_id AND ($1::uuid IS NULL OR j.agent_id=$1) AND j.state='awaiting_reboot' AND (convert_from(e.payload,'UTF8')::jsonb->>'start_before')::timestamptz+make_interval(secs=>COALESCE((convert_from(j.payload,'UTF8')::jsonb->'action'->>'reconnect_timeout_seconds')::integer,3600))<now()").bind(agent).execute(&mut **tx).await?;
sqlx::query("SELECT maintain_current_customer($1)")
.bind(agent)
.execute(&mut **tx)
.await?;
Ok(())
}
pub fn start(state: crate::State) {
@@ -15,26 +14,8 @@ pub fn start(state: crate::State) {
let mut timer = tokio::time::interval(std::time::Duration::from_secs(1));
loop {
timer.tick().await;
for tenant in [rmm_domain::TENANT_A, rmm_domain::TENANT_B] {
let result = async {
let tenant = Uuid::parse_str(tenant)?;
let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?;
let acquired: bool = sqlx::query_scalar(
"SELECT pg_try_advisory_xact_lock(hashtextextended($1,0))",
)
.bind(format!("maintenance:{tenant}"))
.fetch_one(&mut *tx)
.await?;
if acquired {
maintain(&mut tx, None).await?;
}
tx.commit().await?;
Ok::<(), anyhow::Error>(())
}
.await;
if result.is_err() {
eprintln!("tenant housekeeping failed; no starts authorized by scheduler");
}
if sqlx::query("SELECT maintain_customers()").execute(&state.pool).await.is_err() {
eprintln!("customer housekeeping failed");
}
}
});
@@ -54,6 +54,10 @@ impl UpdateArtifacts {
profile == "development",
"update object adapter is development-only"
);
Self::private_directory(root, owner)
}
pub(crate) fn private_directory(root: PathBuf, owner: u32) -> Result<Self> {
match fs::create_dir(&root) {
Ok(()) => fs::set_permissions(&root, fs::Permissions::from_mode(0o700))?,
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {}