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
+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(())
}