Keep installed admin helpers usable after release expiry
Rust development slice / linux (push) Failing after 13s

This commit is contained in:
2026-11-18 13:07:19 +01:00
parent bb4e7cbad7
commit 1d58f2e704
5 changed files with 99 additions and 10 deletions
+87 -6
View File
@@ -14,6 +14,7 @@ use axum::{
response::{IntoResponse, Response},
routing::{get, post},
};
use chrono::{DateTime, Utc};
use futures_util::StreamExt;
use rmm_domain::{
agent_update::{ArtifactDescriptor, Platform, ReleaseEnvelope, ReleaseManifest},
@@ -186,6 +187,13 @@ fn keyring_path_with(
pub fn verify_envelope(
envelope: &ReleaseEnvelope,
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
) -> Result<ReleaseManifest, Error> {
verify_envelope_at(envelope, binding, Utc::now())
}
fn verify_envelope_at(
envelope: &ReleaseEnvelope,
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
time: DateTime<Utc>,
) -> Result<ReleaseManifest, Error> {
let platform = envelope.decode().map_err(|_| invalid())?.manifest.platform;
let raw = keyring_bytes(platform)?;
@@ -193,10 +201,7 @@ pub fn verify_envelope(
envelope,
binding,
&raw,
chrono::Utc::now()
.timestamp()
.try_into()
.map_err(|_| invalid())?,
time.timestamp().try_into().map_err(|_| invalid())?,
)
}
fn keyring_bytes(platform: Platform) -> Result<Vec<u8>, Error> {
@@ -420,15 +425,53 @@ pub async fn upload(
json!({"artifact_id":input.artifact_id,"sha256":input.sha256,"size_bytes":input.size_bytes}),
))
}
enum CatalogReleaseCheck {
Current,
InstalledHelper,
}
impl CatalogReleaseCheck {
fn verification_time(
self,
registered: DateTime<Utc>,
now: DateTime<Utc>,
) -> Result<DateTime<Utc>, Error> {
match self {
Self::Current => Ok(now),
Self::InstalledHelper if registered <= now => Ok(registered),
Self::InstalledHelper => Err(invalid()),
}
}
}
pub async fn checked_release(
tx: &mut Transaction<'_, Postgres>,
id: Uuid,
) -> Result<(ReleaseEnvelope, ReleaseManifest), Error> {
let row = sqlx::query("SELECT envelope,envelope_sha256,manifest_sha256 FROM agent_update_releases WHERE release_id=$1")
checked_catalog_release(tx, id, CatalogReleaseCheck::Current).await
}
/// Used only to attest an enrolled, running helper against its registered release.
/// The immutable catalog timestamp proves that the release was valid when registered.
pub(crate) async fn checked_installed_helper_release(
tx: &mut Transaction<'_, Postgres>,
id: Uuid,
) -> Result<ReleaseManifest, Error> {
let (_, manifest) = checked_catalog_release(tx, id, CatalogReleaseCheck::InstalledHelper).await?;
Ok(manifest)
}
async fn checked_catalog_release(
tx: &mut Transaction<'_, Postgres>,
id: Uuid,
check: CatalogReleaseCheck,
) -> Result<(ReleaseEnvelope, ReleaseManifest), Error> {
let row = sqlx::query("SELECT envelope,envelope_sha256,manifest_sha256,created_at FROM agent_update_releases WHERE release_id=$1")
.bind(id).fetch_optional(&mut **tx).await?.ok_or_else(missing)?;
let raw: Vec<u8> = row.get("envelope");
let envelope: ReleaseEnvelope = serde_json::from_slice(&raw)?;
let manifest = verify_envelope(&envelope, None)?;
let time = check.verification_time(row.get("created_at"), Utc::now())?;
let manifest = verify_envelope_at(&envelope, None, time)?;
if encode(&envelope)? != raw
|| hash(&raw) != row.get::<String, _>("envelope_sha256")
|| hash(&envelope.decode().map_err(|_| invalid())?.payload_bytes)
@@ -1180,6 +1223,44 @@ mod tests {
let official_ring = encode(&official_keys).unwrap();
assert!(verify_envelope_with_keyring(&official, None, &official_ring, 100).is_ok());
assert!(verify_envelope_with_keyring(&development, None, &official_ring, 100).is_err());
// At the expiry boundary, installed helpers still use the immutable
// registration time. Bootstrap and update checks use the current time.
let registered = DateTime::from_timestamp(100, 0).unwrap();
let now = DateTime::from_timestamp(200, 0).unwrap();
let check_catalog = |check: CatalogReleaseCheck,
registered: DateTime<Utc>,
envelope: &ReleaseEnvelope,
keyring: &[u8]| {
let at = check.verification_time(registered, now)?.timestamp() as u64;
verify_envelope_with_keyring(envelope, None, keyring, at)
};
let installed = CatalogReleaseCheck::InstalledHelper;
assert!(check_catalog(installed, registered, &official, &official_ring).is_ok());
assert!(
check_catalog(CatalogReleaseCheck::Current, registered, &official, &official_ring)
.is_err()
);
assert!(check_catalog(CatalogReleaseCheck::InstalledHelper, now, &official, &official_ring).is_err());
assert!(
CatalogReleaseCheck::InstalledHelper
.verification_time(now + chrono::Duration::seconds(1), now)
.is_err()
);
assert!(
check_catalog(CatalogReleaseCheck::InstalledHelper, registered, &development, &official_ring)
.is_err()
);
let mut revoked_official = official_keys;
revoked_official.keys[0].revoked = true;
assert!(
check_catalog(
CatalogReleaseCheck::InstalledHelper,
registered,
&official,
&encode(&revoked_official).unwrap()
)
.is_err()
);
let (linux, linux_keys) = make(Platform::LinuxX64);
let (windows, windows_keys) = make(Platform::WindowsX64);
let linux_raw = encode(&linux_keys).unwrap();