244 lines
10 KiB
Rust
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
|
|
}
|