Integrate signed agent catalog, tenant enrollment and HTTPS installers

This commit is contained in:
2026-11-17 15:56:18 +01:00
parent 689f326460
commit 7fd17272d5
70 changed files with 12982 additions and 327 deletions
+133 -25
View File
@@ -1,5 +1,7 @@
//! Tenant release publication and update-only bounded object transport.
//! Catalog metadata and passive checks never create/approve an execution job.
#[path = "bootstrap/mod.rs"]
mod bootstrap;
use crate::{
jobs::Error,
update_artifact_store::{MAX_CHUNK_BYTES, UpdateArtifacts},
@@ -42,6 +44,7 @@ pub fn platform_name(platform: Platform) -> &'static str {
match platform {
Platform::LinuxX64 => "x86_64-unknown-linux-gnu",
Platform::WindowsX64 => "x86_64-pc-windows-msvc",
Platform::WindowsGnuX64 => "x86_64-pc-windows-gnu",
}
}
pub fn protected_file(path: &FsPath, maximum: u64) -> Result<Vec<u8>, Error> {
@@ -122,9 +125,11 @@ pub fn store() -> Result<UpdateArtifacts, Error> {
}
Ok(UpdateArtifacts::new(
&std::env::var("RMM_PROFILE").unwrap_or_default(),
path.parent()
.ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))?
.join("agent-update-artifacts"),
match std::env::var_os("RMM_AGENT_UPDATE_ARTIFACT_DIR") {
Some(value) if FsPath::new(&value).is_absolute() => value.into(),
Some(_) => return Err(fail("AGENT_UPDATE_NOT_CONFIGURED")),
None => path.parent().ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))?.join("agent-update-artifacts"),
},
metadata.uid(),
)?)
}
@@ -132,6 +137,7 @@ fn verifier_platform(platform: Platform) -> rmm_updater::Platform {
match platform {
Platform::LinuxX64 => rmm_updater::Platform::LinuxX64,
Platform::WindowsX64 => rmm_updater::Platform::WindowsX64,
Platform::WindowsGnuX64 => rmm_updater::Platform::WindowsGnuX64,
}
}
/// Network input can choose only one of two statically named protected
@@ -143,6 +149,7 @@ fn keyring_path_with(
let name = match platform {
Platform::LinuxX64 => "RMM_AGENT_UPDATE_LINUX_KEYRING_FILE",
Platform::WindowsX64 => "RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE",
Platform::WindowsGnuX64 => "RMM_AGENT_UPDATE_WINDOWS_GNU_KEYRING_FILE",
};
if let Some(path) = lookup(name)? {
if path.is_empty() || !FsPath::new(&path).is_absolute() {
@@ -161,12 +168,10 @@ pub fn verify_envelope(
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
) -> Result<ReleaseManifest, Error> {
let platform = envelope.decode().map_err(|_| invalid())?.manifest.platform;
let path = keyring_path_with(platform, |name| match std::env::var(name) {
Ok(value) => Ok(Some(value)),
Err(std::env::VarError::NotPresent) => Ok(None),
Err(std::env::VarError::NotUnicode(_)) => Err(fail("AGENT_UPDATE_NOT_CONFIGURED")),
})?;
let raw = protected_file(&path, 16384)?;
if platform == Platform::WindowsGnuX64 && std::env::var("RMM_PROFILE").as_deref() != Ok("development") {
return Err(fail("AGENT_UPDATE_DEVELOPMENT_CHANNEL_REQUIRED"));
}
let raw = keyring_bytes(platform)?;
verify_envelope_with_keyring(
envelope,
binding,
@@ -177,6 +182,14 @@ pub fn verify_envelope(
.map_err(|_| invalid())?,
)
}
fn keyring_bytes(platform: Platform) -> Result<Vec<u8>, Error> {
let path = keyring_path_with(platform, |name| match std::env::var(name) {
Ok(value) => Ok(Some(value)),
Err(std::env::VarError::NotPresent) => Ok(None),
Err(std::env::VarError::NotUnicode(_)) => Err(fail("AGENT_UPDATE_NOT_CONFIGURED")),
})?;
protected_file(&path, 16384)
}
fn verify_envelope_with_keyring(
envelope: &ReleaseEnvelope,
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
@@ -242,6 +255,7 @@ fn verify_envelope_with_keyring(
}
pub fn routes(router: Router<crate::State>) -> Router<crate::State> {
router
.route("/api/v1/tenants/{tenant}/enrollment-tokens", post(bootstrap::issue))
.route(
"/api/v1/tenants/{tenant}/agent-releases",
get(list).post(import),
@@ -253,7 +267,20 @@ pub fn routes(router: Router<crate::State>) -> Router<crate::State> {
}
pub fn gateway_routes(router: Router<crate::State>) -> Router<crate::State> {
router
.route("/install/linux.sh", get(|| async { ([("content-type", "text/x-shellscript")], concat!(include_str!("bootstrap/install.sh"),include_str!("bootstrap/lifecycle.py"),"
RMM_BOOTSTRAP_PYTHON
/usr/bin/python3 -I \"$file\" install \"$@\"
")) }))
.route("/install/windows.ps1", get(|| async { ([("content-type", "text/plain; charset=utf-8")], include_str!("bootstrap/install.ps1")) }))
.route("/agent/v1/bootstrap/current", get(bootstrap::current))
.route("/agent/v1/bootstrap/releases/{release}/artifacts/{artifact}", get(bootstrap::artifact))
.route("/agent/v1/bootstrap/updater", get(bootstrap::updater))
.route("/agent/v1/releases/current", get(current))
.route("/agent/v1/releases/installed", get(installed))
.route(
"/agent/v1/releases/{release}/artifacts/{artifact}",
get(release_artifact),
)
.route("/agent/v1/update-artifacts/{artifact}", get(download))
}
#[derive(Deserialize)]
@@ -412,12 +439,26 @@ pub async fn import(
let sequence = i64::try_from(m.release_sequence).map_err(|_| invalid())?;
resolve_artifacts(&mut tx, t, &m.artifacts).await?;
let manifest_sha = hash(&envelope.decode().map_err(|_| invalid())?.payload_bytes);
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(t).bind(m.release_id).bind(platform_name(m.platform)).bind(sequence).bind(&manifest_sha).bind(hash(&raw)).bind(raw)
let inserted = 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) ON CONFLICT DO NOTHING")
.bind(t).bind(m.release_id).bind(platform_name(m.platform)).bind(sequence).bind(&manifest_sha).bind(hash(&raw)).bind(&raw)
.bind(m.artifacts[0].artifact_id).bind(&m.artifacts[0].sha256).bind(m.artifacts[0].bytes as i64)
.bind(m.artifacts[1].artifact_id).bind(&m.artifacts[1].sha256).bind(m.artifacts[1].bytes as i64).execute(&mut *tx).await?;
if inserted.rows_affected() == 0 {
let stored: Option<Vec<u8>> = sqlx::query_scalar(
"SELECT envelope FROM agent_update_releases WHERE release_id=$1 AND platform=$2 AND release_sequence=$3",
)
.bind(m.release_id)
.bind(platform_name(m.platform))
.bind(sequence)
.fetch_optional(&mut *tx)
.await?;
if stored.as_deref() != Some(raw.as_slice()) {
return Err(fail("AGENT_UPDATE_RELEASE_CONFLICT"));
}
} else {
sqlx::query("INSERT INTO audit_events VALUES($1,$2,$3,'agent_update_release_imported',$4,now())").bind(t).bind(Uuid::new_v4()).bind(p.name)
.bind(json!({"release_id":m.release_id,"manifest_sha256":manifest_sha,"testsimulation":p.testsimulation})).execute(&mut *tx).await?;
}
tx.commit().await?;
Ok(Json(
json!({"release_id":m.release_id,"manifest_sha256":manifest_sha,"release_envelope":envelope,"manifest":m}),
@@ -496,6 +537,86 @@ async fn device(
.await
.map_err(|status| Error(status, "UNAUTHENTICATED"))
}
async fn installed(State(s): State<crate::State>, Extension(peer): Extension<crate::Peer>, headers: HeaderMap) -> Result<Response, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let row = sqlx::query("SELECT reported_agent_version,connection_generation,last_contact_at FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL").bind(agent).fetch_one(&mut *tx).await?;
tx.commit().await?;
Ok(([("cache-control","private, no-store")], Json(json!({"agent_id":agent,
"agent_version":row.get::<Option<String>,_>("reported_agent_version"),
"connection_generation":row.get::<i64,_>("connection_generation"),
"last_contact_at":row.get::<Option<chrono::DateTime<chrono::Utc>>,_>("last_contact_at")}))).into_response())
}
async fn check_device_platform(
tx: &mut Transaction<'_, Postgres>,
agent: Uuid,
platform: Platform,
) -> Result<(), Error> {
let caps: Value = sqlx::query_scalar(
"SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL",
)
.bind(agent)
.fetch_one(&mut **tx)
.await?;
let caps: Vec<String> = serde_json::from_value(caps)?;
let expected = match platform {
Platform::LinuxX64 => "linux.base/1",
Platform::WindowsX64 if caps.iter().any(|c| c == "agent.release.windows.gnu/1") => return Err(missing()),
Platform::WindowsX64 => "windows.base/1",
Platform::WindowsGnuX64 => "agent.release.windows.gnu/1",
};
if !caps.iter().any(|c| c == expected) {
return Err(missing());
}
Ok(())
}
/// A published release grants access to its two fixed binaries for authenticated
/// devices of its own tenant and platform. A catalog write first verifies both
/// objects. Fetching rechecks the live signing trust and the actual object.
async fn release_artifact(
State(s): State<crate::State>,
Extension(peer): Extension<crate::Peer>,
headers: HeaderMap,
Path((release, artifact)): Path<(Uuid, Uuid)>,
) -> Result<Response, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let (_, manifest) = checked_release(&mut tx, release).await?;
check_device_platform(&mut tx, agent, manifest.platform).await?;
let descriptor = manifest.artifacts.into_iter()
.find(|entry| entry.artifact_id == artifact).ok_or_else(missing)?;
tx.commit().await?;
verified_binary(tenant, descriptor.sha256, descriptor.bytes).await
}
async fn verified_binary(tenant: Uuid, sha256: String, size: u64) -> Result<Response, Error> {
use tokio::io::AsyncReadExt;
let digest = sha256.clone();
let file = tokio::task::spawn_blocking(move || -> Result<std::fs::File, Error> {
Ok(store()?.verified_file(tenant, &digest, size)?)
})
.await
.map_err(|_| fail("AGENT_UPDATE_ARTIFACT_UNAVAILABLE"))??;
let reader = tokio::fs::File::from_std(file).take(size);
let stream = futures_util::stream::try_unfold(reader, |mut reader| async move {
let mut chunk = vec![0; 64 * 1024];
let count = reader.read(&mut chunk).await?;
chunk.truncate(count);
Ok::<_, std::io::Error>((count != 0).then_some((chunk, reader)))
});
let mut response = Response::new(Body::from_stream(stream));
let headers = response.headers_mut();
headers.insert("content-type", HeaderValue::from_static("application/octet-stream"));
headers.insert("content-length", HeaderValue::from(size));
headers.insert("content-disposition", HeaderValue::from_static("attachment"));
headers.insert("x-content-type-options", HeaderValue::from_static("nosniff"));
headers.insert("cache-control", HeaderValue::from_static("private, no-store"));
headers.insert("x-artifact-sha256", HeaderValue::from_str(&sha256).map_err(|_| invalid())?);
Ok(response)
}
async fn current(
State(s): State<crate::State>,
Extension(peer): Extension<crate::Peer>,
@@ -504,20 +625,7 @@ async fn current(
) -> Result<Json<Value>, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?;
let caps: Value = sqlx::query_scalar(
"SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL",
)
.bind(agent)
.fetch_one(&mut *tx)
.await?;
let caps: Vec<String> = serde_json::from_value(caps)?;
let expected = match q.platform {
Platform::LinuxX64 => "linux.base/1",
Platform::WindowsX64 => "windows.base/1",
};
if !caps.iter().any(|c| c == expected) {
return Err(missing());
}
check_device_platform(&mut tx, agent, q.platform).await?;
let ids:Vec<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_all(&mut *tx).await?;
let release = if let Some(id) = ids.first() {
let (envelope, manifest) = checked_release(&mut tx, *id).await?;