From 2358ba1b66586ba8b6cb5473bce0214803692288 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Tue, 17 Nov 2026 22:07:14 +0100 Subject: [PATCH] Verify signed starter packages for first enrollment in empty customer catalogs --- crates/server/src/agent_updates.rs | 10 ++ crates/server/src/bootstrap/starter.rs | 126 +++++++++++++++++++------ tools/dev_customer_starters.py | 29 ++++-- 3 files changed, 128 insertions(+), 37 deletions(-) diff --git a/crates/server/src/agent_updates.rs b/crates/server/src/agent_updates.rs index fb30b02..dc3a2e9 100644 --- a/crates/server/src/agent_updates.rs +++ b/crates/server/src/agent_updates.rs @@ -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 { let raw = keyring_bytes(platform)?; verify_envelope_with_keyring( envelope, diff --git a/crates/server/src/bootstrap/starter.rs b/crates/server/src/bootstrap/starter.rs index 6931cd6..3d12ebf 100644 --- a/crates/server/src/bootstrap/starter.rs +++ b/crates/server/src/bootstrap/starter.rs @@ -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(()) } diff --git a/tools/dev_customer_starters.py b/tools/dev_customer_starters.py index dc2a502..01aac8c 100644 --- a/tools/dev_customer_starters.py +++ b/tools/dev_customer_starters.py @@ -15,29 +15,37 @@ import uuid from dev_stage import ssh_prefix -def publish(tenant, platform, release): - root = Path('/opt/rust-discovery/devstate/mvp-releases') +def publish(tenant, platform, release, *, root=Path('/opt/rust-discovery/devstate/mvp-releases'), + database_container='rust-discovery-server-postgres-1', service_uid=10001): labels = {'x86_64-pc-windows-gnu': 'windows-gnu', 'x86_64-unknown-linux-gnu': 'linux'} label = labels[platform] source = root / 'objects' / tenant config = root / 'config' dest = config / 'customer-starters' sql = """SELECT json_build_object('envelope',convert_from(envelope,'UTF8')::json, - 'agent',agent_sha256,'agent_size',agent_bytes,'helper',helper_sha256,'helper_size',helper_bytes) + 'agent',agent_sha256,'agent_size',agent_bytes,'helper',helper_sha256,'helper_size',helper_bytes, + 'starter_worker',(SELECT json_build_object('sha256',sha256,'bytes',size_bytes) + FROM customer_starter_workers WHERE tenant_id=:'customer' AND platform=:'platform')) FROM agent_update_releases WHERE tenant_id=:'customer' AND platform=:'platform' AND release_id=:'release';""" - row = json.loads(subprocess.check_output(['docker','exec','-i','rust-discovery-server-postgres-1', + raw = subprocess.check_output(['docker','exec','-i',database_container, 'psql','-XqtA','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm','-v','customer='+tenant, - '-v','platform='+platform,'-v','release='+release],input=sql.encode())) + '-v','platform='+platform,'-v','release='+release],input=sql.encode()) + if not raw.strip(): + raise ValueError('Selected release is missing from the source customer catalog') + row = json.loads(raw) local_pin = config / (label+'-bootstrap.'+tenant+'.json') if local_pin.exists(): worker = json.loads(local_pin.read_bytes())['current'] + elif row['starter_worker']: + worker = row['starter_worker'] else: default = json.loads((config / (label+'-bootstrap.json')).read_bytes()) worker = {'sha256': default['updater_sha256'], 'bytes': default['updater_bytes']} desc = {'envelope': row['envelope'], 'worker': worker} dest.mkdir(mode=0o700,exist_ok=True) - assert dest.is_dir() and not dest.is_symlink() - os.chown(dest,10001,10001) + if not dest.is_dir() or dest.is_symlink(): + raise ValueError('Protected starter directory required') + os.chown(dest,service_uid,service_uid) os.chmod(dest,0o700) def write(name, blocks): with tempfile.NamedTemporaryFile(dir=dest,delete=False) as out: @@ -50,7 +58,7 @@ def publish(tenant, platform, release): if len(name)==64 and digest.hexdigest()!=name: raise ValueError('Package object digest mismatch') out.flush() - os.fchown(out.fileno(),10001,10001) + os.fchown(out.fileno(),service_uid,service_uid) os.fsync(out.fileno()) os.replace(temp,dest/name) finally: @@ -64,6 +72,11 @@ def publish(tenant, platform, release): raise ValueError('Missing regular package file') write(digest,iter(lambda:f.read(1024*1024),b'')) write(platform+'.json',[json.dumps(desc,separators=(',',':')).encode()]) + directory_fd = os.open(dest, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(directory_fd) + finally: + os.close(directory_fd) print(json.dumps({'starter_platform':platform,'release_id':release}))