//! 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; pub(super) mod opnsense; pub(super) use starter::publish_missing as publish_starters; #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Config { gateway_origin: String, updater_sha256: String, updater_bytes: u64, } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Pin { sha256: String, bytes: u64 } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct Previous { pin: Pin, expires_at: i64 } #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct TenantPins { current: Pin, previous: Vec } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub(super) struct UpdaterQuery { platform: Platform, sha256: Option } fn official_windows(platform: Platform) -> bool { platform == Platform::WindowsGnuX64 && std::env::var_os("RMM_AGENT_UPDATE_WINDOWS_GNU_OFFICIAL_KEYRING_FILE").is_some() } async fn config(s: &crate::State, platform: Platform, tenant: Uuid, wanted: Option<&str>) -> Result { let slot = match platform { Platform::LinuxX64 => "RMM_AGENT_BOOTSTRAP_LINUX_FILE", Platform::LinuxArm64 => "RMM_AGENT_BOOTSTRAP_LINUX_ARM64_FILE", Platform::WindowsX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_FILE", Platform::WindowsGnuX64 => "RMM_AGENT_BOOTSTRAP_WINDOWS_GNU_FILE", }; let path = std::env::var(slot).map_err(|_| fail("BOOTSTRAP_NOT_CONFIGURED"))?; let path = FsPath::new(&path); let mut config: Config = serde_json::from_slice(&protected_file(path, 8192)?)?; let scoped = path.with_extension(format!("{tenant}.json")); if scoped.try_exists().map_err(|_| fail("BOOTSTRAP_CONFIGURATION_INVALID"))? { let pins: TenantPins = serde_json::from_slice(&protected_file(&scoped, 32768)?)?; let selected = match wanted { Some(digest) if pins.current.sha256 != digest => pins.previous.into_iter() .find(|p| p.pin.sha256 == digest && p.expires_at > chrono::Utc::now().timestamp()) .map(|p| p.pin).ok_or_else(missing)?, _ => pins.current, }; 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 AND official_windows=$2") .bind(platform_name(platform)).bind(official_windows(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::("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())?; if url.scheme() != "https" || url.domain().is_none() || !url.username().is_empty() || url.password().is_some() || url.query().is_some() || url.fragment().is_some() || url.path() != "/" || !rmm_domain::agent_update::digest(&config.updater_sha256) || !(1..=rmm_updater::MAX_ARTIFACT_BYTES).contains(&config.updater_bytes) { return Err(fail("BOOTSTRAP_CONFIGURATION_INVALID")); } Ok(config) } fn private_json(body: Value) -> Response { ([("cache-control", "private, no-store")], Json(body)).into_response() } pub(super) async fn issue( State(s): State, headers: HeaderMap, Path(t): Path, ) -> Result { let p = s .auth .principal(&s, &headers, true) .await .map_err(|status| Error(status, crate::auth::error_code(status)))?; crate::jobs::scope(&p, t, true)?; if p.session_hash.is_none() { return Err(Error(StatusCode::FORBIDDEN, "INTERACTIVE_AUTH_REQUIRED")); } let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?; crate::permissions::require_principal(&mut tx, &p, "devices:enroll").await?; let bootstrap_origin = std::env::var("RMM_BOOTSTRAP_ORIGIN") .ok() .map(|raw| { let url = url::Url::parse(&raw).map_err(|_| invalid())?; if url.scheme() != "https" || url.domain().is_none() || !url.username().is_empty() || url.password().is_some() || url.path() != "/" || url.query().is_some() || url.fragment().is_some() { return Err(invalid()); } Ok(url.origin().ascii_serialization()) }) .transpose()?; 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 = sqlx::query_scalar("SELECT DISTINCT platform FROM agent_update_releases ORDER BY platform") .fetch_all(&mut *tx) .await?; let expires: chrono::DateTime = sqlx::query_scalar("SELECT issue_enrollment_token($1)") .bind(hash(token.as_bytes())) .fetch_one(&mut *tx) .await?; sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'enrollment_token_issued',$4,now())") .bind(t) .bind(Uuid::new_v4()) .bind(p.name) .bind(json!({"expires_at":expires})) .execute(&mut *tx) .await?; tx.commit().await?; Ok(private_json( json!({"token":token,"expires_at":expires,"bootstrap_origin":bootstrap_origin,"release_platforms":release_platforms, "opnsense_installer":opnsense::available()}), )) } async fn token_tenant(s: &crate::State, h: &HeaderMap) -> Result { let denied = || Error(StatusCode::UNAUTHORIZED, "ENROLLMENT_TOKEN_REQUIRED"); let token = h .get("authorization") .and_then(|v| v.to_str().ok()) .and_then(|v| v.strip_prefix("Enrollment ")) .filter(|v| rmm_domain::agent_update::digest(v)) .ok_or_else(denied)?; let t: Option = sqlx::query_scalar("SELECT bootstrap_enrollment_tenant($1)") .bind(hash(token.as_bytes())) .fetch_one(&s.pool) .await?; t.ok_or_else(denied) } #[derive(serde::Deserialize, serde::Serialize)] #[serde(deny_unknown_fields)] struct TimeTrust { key_generation: u64, server_instance: Uuid, public_keys_hex: std::collections::BTreeMap, } fn device_trust_data(s: &crate::State) -> Result { let job_public = hex::encode(s.job_signer.public_key()?); let path = std::env::var_os("RMM_AGENT_BOOTSTRAP_WINDOWS_FILE") .and_then(|slot| FsPath::new(&slot).parent().map(|p| p.join("windows-time-trust.json"))); let trust = match path { Some(path) if path.try_exists().map_err(|_| fail("BOOTSTRAP_TIME_TRUST_INVALID"))? => { let trust: TimeTrust = serde_json::from_slice(&protected_file(&path, 8192)?)?; if trust.key_generation == 0 || trust.server_instance.is_nil() || !(1..=8).contains(&trust.public_keys_hex.len()) || !trust.public_keys_hex.iter().all(|(id,key)| !id.is_empty() && id.len() <= 64 && id.bytes().all(|b| b.is_ascii_alphanumeric() || b"_-".contains(&b)) && rmm_domain::agent_update::digest(key) && key != &job_public) { return Err(fail("BOOTSTRAP_TIME_TRUST_INVALID")); } Some(trust) } _ => None }; Ok(json!({"job_signing_public_key_hex":job_public,"windows_time_trust":trust})) } pub(super) async fn device_trust(State(s): State, Extension(peer): Extension, headers: HeaderMap) -> Result { device(&s, peer, &headers).await?; Ok(private_json(device_trust_data(&s)?)) } pub(super) async fn current( State(s): State, headers: HeaderMap, Query(q): Query, ) -> Result { let t = token_tenant(&s, &headers).await?; 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)?; let (envelope, manifest) = checked_release(&mut tx, release).await?; tx.commit().await?; let ring: Value = serde_json::from_slice(&keyring_bytes(q.platform)?)?; let ca = s .signer .as_ref() .ok_or_else(missing)? .ca .to_pem() .map_err(|_| invalid())?; let trust = device_trust_data(&s)?; Ok(private_json( json!({"job_signing_public_key_hex":trust["job_signing_public_key_hex"],"windows_time_trust":trust["windows_time_trust"],"schema_version":1,"tenant_id":t,"release_envelope":envelope,"manifest":manifest, "gateway_origin":c.gateway_origin,"ca_pem":String::from_utf8(ca).map_err(|_| invalid())?, "keyring":ring,"updater":{"sha256":c.updater_sha256,"bytes":c.updater_bytes}}), )) } pub(super) async fn artifact( State(s): State, headers: HeaderMap, Path((id, artifact)): Path<(Uuid, Uuid)>, Query(q): Query, ) -> Result { let tenant = token_tenant(&s, &headers).await?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; let (_, manifest) = checked_release(&mut tx, id).await?; if manifest.platform != q.platform { return Err(missing()); } let d = manifest .artifacts .into_iter() .find(|v| v.artifact_id == artifact) .ok_or_else(missing)?; tx.commit().await?; verified_binary(tenant, d.sha256, d.bytes).await } pub(super) async fn updater( State(s): State, headers: HeaderMap, Query(q): Query, ) -> Result { let tenant = token_tenant(&s, &headers).await?; let c = config(&s, q.platform, tenant, q.sha256.as_deref()).await?; verified_binary(tenant, c.updater_sha256, c.updater_bytes).await }