Verify signed starter packages for first enrollment in empty customer catalogs

This commit is contained in:
2026-11-17 22:07:14 +01:00
parent 312da6f39e
commit 2358ba1b66
3 changed files with 128 additions and 37 deletions
+10
View File
@@ -176,6 +176,16 @@ pub fn verify_envelope(
{
return Err(fail("AGENT_UPDATE_DEVELOPMENT_CHANNEL_REQUIRED"));
}
verify_signed_envelope(envelope, platform, binding)
}
// The public management process can copy an operator-selected release into an empty
// catalog. Network-supplied publications additionally go through the profile check above.
fn verify_signed_envelope(
envelope: &ReleaseEnvelope,
platform: Platform,
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
) -> Result<ReleaseManifest, Error> {
let raw = keyring_bytes(platform)?;
verify_envelope_with_keyring(
envelope,
+97 -29
View File
@@ -10,51 +10,114 @@ struct Starter {
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()) };
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] {
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 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; }
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; }
.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 manifest = verify_signed_envelope(&package.envelope, platform, 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();
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 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; }
let n = file
.read(&mut buffer)
.map_err(|_| fail("STARTER_OBJECT_READ"))?;
if n == 0 {
break;
}
staged.append(&buffer[..n])?;
}
staged.finish(&store,tenant)?;
staged.finish(&store, tenant)?;
}
Ok(())
}).await.map_err(|_| fail("STARTER_OBJECT_COPY"))??;
})
.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?;
@@ -67,7 +130,12 @@ pub(super) async fn publish_missing(tx: &mut Transaction<'_, Postgres>, tenant:
.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?;
.bind(tenant)
.bind(name)
.bind(package.worker.sha256)
.bind(package.worker.bytes as i64)
.execute(&mut **tx)
.await?;
}
Ok(())
}