Files
rust-discovery/crates/server/src/bootstrap/mod.rs
T

244 lines
10 KiB
Rust

//! 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<Previous> }
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct UpdaterQuery { platform: Platform, sha256: Option<String> }
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<Config, Error> {
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::<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())?;
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<crate::State>,
headers: HeaderMap,
Path(t): Path<Uuid>,
) -> Result<Response, Error> {
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<String> =
sqlx::query_scalar("SELECT DISTINCT platform FROM agent_update_releases ORDER BY platform")
.fetch_all(&mut *tx)
.await?;
let expires: chrono::DateTime<chrono::Utc> =
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<Uuid, Error> {
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<Uuid> = 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<String, String>,
}
fn device_trust_data(s: &crate::State) -> Result<Value, Error> {
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<crate::State>, Extension(peer): Extension<crate::Peer>, headers: HeaderMap) -> Result<Response, Error> {
device(&s, peer, &headers).await?;
Ok(private_json(device_trust_data(&s)?))
}
pub(super) async fn current(
State(s): State<crate::State>,
headers: HeaderMap,
Query(q): Query<Current>,
) -> Result<Response, Error> {
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<crate::State>,
headers: HeaderMap,
Path((id, artifact)): Path<(Uuid, Uuid)>,
Query(q): Query<Current>,
) -> Result<Response, Error> {
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<crate::State>,
headers: HeaderMap,
Query(q): Query<UpdaterQuery>,
) -> Result<Response, Error> {
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
}