Implement guarded Linux updater runtime and compatible baseline tooling
Rust development slice / linux (push) Failing after 8s
Rust development slice / linux (push) Failing after 8s
This commit is contained in:
@@ -38,6 +38,13 @@ pub trait SyncClock {
|
||||
upper: own_wall,
|
||||
})
|
||||
}
|
||||
/// Full trusted UTC interval for crypto validity. Existing point-clock
|
||||
/// providers retain their contract; interval providers override atomically.
|
||||
fn bounds(&self) -> Result<(DateTime<Utc>,DateTime<Utc>)> {
|
||||
let reading=self.reading()?;
|
||||
ensure!(reading.own_wall<=reading.upper,"CLOCK_INTERVAL_ORDER");
|
||||
Ok((reading.own_wall,reading.upper))
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub struct Channel {
|
||||
|
||||
@@ -38,6 +38,7 @@ pub enum Participant {
|
||||
OriginalHelper,
|
||||
StableUpdater,
|
||||
NewHelper,
|
||||
RestoredHelper,
|
||||
}
|
||||
pub trait UpdateParticipantGuard: ExecutorLedgerGuard {
|
||||
fn participant(&self) -> Participant;
|
||||
@@ -50,6 +51,18 @@ pub trait UpdateParticipantGuard: ExecutorLedgerGuard {
|
||||
) -> Result<()> {
|
||||
anyhow::bail!("UPDATE_NATIVE_EFFECT_NOT_QUALIFIED")
|
||||
}
|
||||
/// A retained native START/conditional STOP witness must be independently
|
||||
/// bound to the original once-only source/held handles. No caller hash or
|
||||
/// current service-name/PID lookup is an attestation of a past operation.
|
||||
fn native_observation_sha256(
|
||||
&self,
|
||||
_handoff: &Handoff,
|
||||
_delegation: &UpdateDelegation,
|
||||
_effect: &NativeEffect,
|
||||
_stage: NativeEffectStage,
|
||||
) -> Result<String> {
|
||||
anyhow::bail!("UPDATE_RETAINED_NATIVE_OBSERVATION_NOT_QUALIFIED")
|
||||
}
|
||||
/// Recheck fixed service/PID/birth/image, original boot, SAME file IDs,
|
||||
/// current clock/deadline and evidence-specific protected observations.
|
||||
/// Health additionally compares receipt contents with the actually applied
|
||||
@@ -91,7 +104,11 @@ pub fn initialize(db: &Connection, guard: &impl ExecutorLedgerGuard) -> Result<(
|
||||
FOREIGN KEY(grant_id,effect_key) REFERENCES agent_update_native_claims(grant_id,effect_key));
|
||||
CREATE TABLE IF NOT EXISTS agent_update_sync_applied(
|
||||
grant_id TEXT NOT NULL REFERENCES agent_update_handoffs(grant_id),decision_id TEXT NOT NULL,
|
||||
witness BLOB NOT NULL,witness_sha256 TEXT NOT NULL,PRIMARY KEY(grant_id,decision_id));",
|
||||
witness BLOB NOT NULL,witness_sha256 TEXT NOT NULL,PRIMARY KEY(grant_id,decision_id));
|
||||
CREATE TABLE IF NOT EXISTS agent_update_native_nonstarts(
|
||||
grant_id TEXT NOT NULL,effect_key TEXT NOT NULL,claim_sha256 TEXT NOT NULL,
|
||||
observation_sha256 TEXT NOT NULL,observed_at TEXT NOT NULL,PRIMARY KEY(grant_id,effect_key),
|
||||
FOREIGN KEY(grant_id,effect_key) REFERENCES agent_update_native_claims(grant_id,effect_key));",
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -300,7 +317,7 @@ pub(crate) fn read_locked(db: &Connection, grant: Uuid) -> Result<Journal> {
|
||||
let (effect_key, raw, digest) = row?;
|
||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw)?;
|
||||
ensure!(
|
||||
native_count <= 17
|
||||
native_count <= if handoff.schema_version == 2 { 32 } else { 17 }
|
||||
&& raw.len() <= 2048
|
||||
&& hash(&raw) == digest
|
||||
&& serde_json::to_vec(&claim)? == raw
|
||||
@@ -313,6 +330,10 @@ pub(crate) fn read_locked(db: &Connection, grant: Uuid) -> Result<Journal> {
|
||||
}
|
||||
let invalid:u64=db.query_row("SELECT count(*) FROM agent_update_native_observations o LEFT JOIN agent_update_native_claims c ON c.grant_id=o.grant_id AND c.effect_key=o.effect_key WHERE o.grant_id=?1 AND (c.claim_sha256 IS NULL OR c.claim_sha256<>o.claim_sha256)",[grant.to_string()],|r|r.get(0))?;
|
||||
ensure!(invalid == 0, "UPDATE_NATIVE_OBSERVATION_BINDING");
|
||||
if handoff.schema_version == 2 {
|
||||
let invalid:u64=db.query_row("SELECT count(*) FROM agent_update_native_nonstarts n LEFT JOIN agent_update_native_claims c ON c.grant_id=n.grant_id AND c.effect_key=n.effect_key LEFT JOIN agent_update_native_observations o ON o.grant_id=n.grant_id AND o.effect_key=n.effect_key WHERE n.grant_id=?1 AND (c.claim_sha256 IS NULL OR c.claim_sha256<>n.claim_sha256 OR o.claim_sha256 IS NOT NULL OR length(n.observation_sha256)<>64)",[grant.to_string()],|r|r.get(0))?;
|
||||
ensure!(invalid == 0, "UPDATE_NATIVE_NONSTART_BINDING");
|
||||
}
|
||||
let mut journal = Journal::open(
|
||||
&record,
|
||||
key.try_into()
|
||||
@@ -337,7 +358,9 @@ pub(crate) fn read_locked(db: &Connection, grant: Uuid) -> Result<Journal> {
|
||||
);
|
||||
journal.replay(&event)?;
|
||||
let parsed: Event = serde_json::from_slice(&event)?;
|
||||
if let Evidence::OutcomePersisted { outcome_sha256 } = parsed.evidence {
|
||||
if let Evidence::OutcomePersisted { outcome_sha256 }
|
||||
| Evidence::RollbackOutcomePersisted { outcome_sha256 } = parsed.evidence
|
||||
{
|
||||
stored_outcome_hash = Some(outcome_sha256);
|
||||
}
|
||||
}
|
||||
@@ -440,7 +463,11 @@ pub fn append(
|
||||
ensure!(
|
||||
!matches!(
|
||||
parsed.evidence,
|
||||
Evidence::OutcomePersisted { .. } | Evidence::Unknown { .. }
|
||||
Evidence::OutcomePersisted { .. }
|
||||
| Evidence::RollbackOutcomePersisted { .. }
|
||||
| Evidence::RollbackIntent { .. }
|
||||
| Evidence::RollbackLedgerReturnIntent
|
||||
| Evidence::Unknown { .. }
|
||||
),
|
||||
"UPDATE_TERMINAL_REQUIRES_OUTCOME_CAS"
|
||||
);
|
||||
@@ -481,6 +508,16 @@ fn verify_writer(
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
let handoff: Handoff = serde_json::from_slice(&raw)?;
|
||||
let native_services =
|
||||
if handoff.pin_transition == rmm_updater_handoff::PinTransition::WindowsCodePairClockV1 {
|
||||
vec![NativeService::WindowsAgent, NativeService::WindowsHelper]
|
||||
} else {
|
||||
vec![
|
||||
NativeService::Agent,
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
]
|
||||
};
|
||||
let expected = match event.evidence {
|
||||
Evidence::AllStopped { .. }
|
||||
| Evidence::UpdaterOwnsLedger { .. }
|
||||
@@ -491,6 +528,25 @@ fn verify_writer(
|
||||
Evidence::ServicesStarted { .. }
|
||||
| Evidence::HealthVerified { .. }
|
||||
| Evidence::OutcomePersisted { .. } => Participant::NewHelper,
|
||||
Evidence::RollbackStopped { .. }
|
||||
| Evidence::RestoreIntent { .. }
|
||||
| Evidence::CandidatePreserved { .. }
|
||||
| Evidence::PredecessorRestored { .. }
|
||||
| Evidence::PredecessorVerified { .. }
|
||||
| Evidence::RollbackLedgerReturnIntent => Participant::StableUpdater,
|
||||
Evidence::RollbackServicesStarted { .. }
|
||||
| Evidence::RollbackHealthVerified { .. }
|
||||
| Evidence::RollbackOutcomePersisted { .. } => Participant::RestoredHelper,
|
||||
Evidence::RollbackIntent { .. } => {
|
||||
ensure!(
|
||||
matches!(
|
||||
guard.participant(),
|
||||
Participant::StableUpdater | Participant::NewHelper
|
||||
),
|
||||
"UPDATE_ROLLBACK_INTENT_WRITER"
|
||||
);
|
||||
guard.participant()
|
||||
}
|
||||
Evidence::Unknown { .. } => guard.participant(),
|
||||
Evidence::StopIntent => anyhow::bail!("UPDATE_STOP_ALREADY_ATOMICALLY_STORED"),
|
||||
};
|
||||
@@ -502,11 +558,7 @@ fn verify_writer(
|
||||
};
|
||||
match &event.evidence {
|
||||
Evidence::AllStopped { .. } => {
|
||||
for service in [
|
||||
NativeService::Agent,
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
] {
|
||||
for service in native_services {
|
||||
if handoff.stop_set.contains(&native_service(service)) {
|
||||
require_observed(NativeEffect::StopService { service })?;
|
||||
}
|
||||
@@ -518,19 +570,64 @@ fn verify_writer(
|
||||
rmm_updater_handoff::FileRole::HelperBinary => NativeFileRole::HelperBinary,
|
||||
rmm_updater_handoff::FileRole::LinuxFullConfig => NativeFileRole::FullConfig,
|
||||
rmm_updater_handoff::FileRole::LinuxFullPin => NativeFileRole::FullPin,
|
||||
rmm_updater_handoff::FileRole::WindowsSettings
|
||||
if handoff.pin_transition
|
||||
== rmm_updater_handoff::PinTransition::WindowsCodePairClockV1 =>
|
||||
{
|
||||
NativeFileRole::WindowsSettings
|
||||
}
|
||||
rmm_updater_handoff::FileRole::WindowsPin
|
||||
if handoff.pin_transition
|
||||
== rmm_updater_handoff::PinTransition::WindowsCodePairClockV1 =>
|
||||
{
|
||||
NativeFileRole::WindowsPin
|
||||
}
|
||||
rmm_updater_handoff::FileRole::WindowsTimeProfile
|
||||
if handoff.pin_transition
|
||||
== rmm_updater_handoff::PinTransition::WindowsCodePairClockV1 =>
|
||||
{
|
||||
NativeFileRole::WindowsTimeProfile
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_NATIVE_PLATFORM_UNQUALIFIED"),
|
||||
};
|
||||
require_observed(NativeEffect::PublishReplacement { role })?;
|
||||
}
|
||||
Evidence::ServicesStarted { .. } => {
|
||||
for service in [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
] {
|
||||
for service in native_services {
|
||||
require_observed(NativeEffect::StartService { service })?;
|
||||
}
|
||||
}
|
||||
Evidence::RollbackStopped { .. } => {
|
||||
for service in native_services {
|
||||
let key = native_key(&NativeEffect::RollbackStopService { service })?;
|
||||
let observed:u64=db.query_row("SELECT count(*) FROM agent_update_native_observations WHERE grant_id=?1 AND effect_key=?2",params![grant.to_string(),key],|r|r.get(0))?;
|
||||
let nonstart:u64=db.query_row("SELECT count(*) FROM agent_update_native_nonstarts WHERE grant_id=?1 AND effect_key=?2",params![grant.to_string(),key],|r|r.get(0))?;
|
||||
let conditional = if service == NativeService::General {
|
||||
db.query_row("SELECT count(*) FROM agent_update_native_observations WHERE grant_id=?1 AND effect_key=?2",params![grant.to_string(),native_key(&NativeEffect::ConditionalRollbackStopGeneral)?],|r|r.get::<_,u64>(0))?
|
||||
} else {
|
||||
0
|
||||
};
|
||||
ensure!(
|
||||
observed + nonstart + conditional == 1,
|
||||
"UPDATE_ROLLBACK_STOP_NOT_PROVED"
|
||||
);
|
||||
}
|
||||
}
|
||||
Evidence::CandidatePreserved { role, .. } => {
|
||||
require_observed(NativeEffect::SaveRejectedCandidate {
|
||||
role: to_native_file(*role),
|
||||
})?
|
||||
}
|
||||
Evidence::PredecessorRestored { role, .. } => {
|
||||
require_observed(NativeEffect::RestorePredecessor {
|
||||
role: to_native_file(*role),
|
||||
})?
|
||||
}
|
||||
Evidence::RollbackServicesStarted { .. } => {
|
||||
for service in native_services {
|
||||
require_observed(NativeEffect::RollbackStartService { service })?;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
guard.verify_update_event(&handoff, &read_delegation(db, grant)?, event)
|
||||
@@ -597,6 +694,54 @@ pub fn finalize(
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
/// A recovered predecessor is a FAILED candidate update, never success for the
|
||||
/// requested target. Existing consumption/outcome/PKI/floor are not reset.
|
||||
pub fn finalize_rollback(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
permit: &ExecutionPermitPayload,
|
||||
expected_head: &str,
|
||||
observed_at: u64,
|
||||
outcome: &Outcome,
|
||||
) -> Result<()> {
|
||||
ensure!(
|
||||
guard.participant() == Participant::RestoredHelper
|
||||
&& outcome.state == "failed"
|
||||
&& outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR"
|
||||
&& !outcome.reboot_required,
|
||||
"UPDATE_ROLLBACK_FINAL_OUTCOME"
|
||||
);
|
||||
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||
let mut journal = read(&tx, guard, permit.grant_id)?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::RollbackHealthVerified && journal.head_sha256() == expected_head,
|
||||
"UPDATE_ROLLBACK_FINAL_HEAD"
|
||||
);
|
||||
let records:u64=tx.query_row("SELECT count(*) FROM agent_update_native_claims WHERE grant_id=?1 AND effect_key IN ('save_installed_record','publish_installed_record')",
|
||||
[permit.grant_id.to_string()],|r|r.get(0))?;
|
||||
ensure!(records == 0, "UPDATE_ROLLBACK_RECORD_ALREADY_CHANGED");
|
||||
let bytes = ledger::persist_outcome_in(&tx, permit, outcome)?;
|
||||
let event = journal.prepare(
|
||||
observed_at,
|
||||
Evidence::RollbackOutcomePersisted {
|
||||
outcome_sha256: hash(&bytes),
|
||||
},
|
||||
)?;
|
||||
let parsed: Event = serde_json::from_slice(&event)?;
|
||||
verify_writer(&tx, guard, permit.grant_id, &parsed)?;
|
||||
journal.replay(&event)?;
|
||||
append_in(
|
||||
&tx,
|
||||
permit.grant_id,
|
||||
expected_head,
|
||||
&event,
|
||||
&parsed,
|
||||
&journal,
|
||||
)?;
|
||||
guard.check(&tx)?;
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Persist uncertainty once under the same original consumption. No release,
|
||||
/// new start, result rewrite or transition back out of Unknown is provided.
|
||||
@@ -666,6 +811,15 @@ fn phase_name(phase: Phase) -> &'static str {
|
||||
Phase::LedgerReturnIntent => "ledger_return_intent",
|
||||
Phase::ServicesStarted => "services_started",
|
||||
Phase::HealthVerified => "health_verified",
|
||||
Phase::RollbackIntent => "rollback_intent",
|
||||
Phase::RollbackStopped => "rollback_stopped",
|
||||
Phase::RestoreIntent => "restore_intent",
|
||||
Phase::CandidatePreserved => "candidate_preserved",
|
||||
Phase::PredecessorRestored => "predecessor_restored",
|
||||
Phase::PredecessorVerified => "predecessor_verified",
|
||||
Phase::RollbackLedgerReturnIntent => "rollback_ledger_return_intent",
|
||||
Phase::RollbackServicesStarted => "rollback_services_started",
|
||||
Phase::RollbackHealthVerified => "rollback_health_verified",
|
||||
Phase::OutcomePersisted => "outcome_persisted",
|
||||
Phase::Unknown => "unknown",
|
||||
}
|
||||
@@ -699,6 +853,17 @@ pub enum NativeEffect {
|
||||
old_sha256: String,
|
||||
new_sha256: String,
|
||||
},
|
||||
RollbackStopService {
|
||||
service: NativeService,
|
||||
},
|
||||
SaveRejectedCandidate {
|
||||
role: NativeFileRole,
|
||||
},
|
||||
RollbackStartService {
|
||||
service: NativeService,
|
||||
},
|
||||
RollbackReturnLedger,
|
||||
ConditionalRollbackStopGeneral,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
@@ -725,6 +890,9 @@ pub enum NativeEffectStage {
|
||||
Claim,
|
||||
Observe,
|
||||
ReserveFutureStart,
|
||||
ObserveNonstart,
|
||||
ReserveConditionalStop,
|
||||
ObserveRetainedStart,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
@@ -755,6 +923,12 @@ impl NativeEffectClaim {
|
||||
pub struct PreparedReturnClaims<const N: usize = 3> {
|
||||
pub return_ledger: NativeEffectClaim,
|
||||
pub starts: [NativeEffectClaim; N],
|
||||
conditional_rollback_stop_general: Option<NativeEffectClaim>,
|
||||
}
|
||||
impl<const N: usize> PreparedReturnClaims<N> {
|
||||
pub fn conditional_rollback_stop_general(&self) -> Option<&NativeEffectClaim> {
|
||||
self.conditional_rollback_stop_general.as_ref()
|
||||
}
|
||||
}
|
||||
fn native_context(
|
||||
db: &Connection,
|
||||
@@ -791,6 +965,18 @@ fn native_role(role: NativeFileRole) -> rmm_updater_handoff::FileRole {
|
||||
NativeFileRole::WindowsTimeProfile => F::WindowsTimeProfile,
|
||||
}
|
||||
}
|
||||
fn to_native_file(role: rmm_updater_handoff::FileRole) -> NativeFileRole {
|
||||
use rmm_updater_handoff::FileRole as F;
|
||||
match role {
|
||||
F::AgentBinary => NativeFileRole::AgentBinary,
|
||||
F::HelperBinary => NativeFileRole::HelperBinary,
|
||||
F::LinuxFullConfig => NativeFileRole::FullConfig,
|
||||
F::LinuxFullPin => NativeFileRole::FullPin,
|
||||
F::WindowsSettings => NativeFileRole::WindowsSettings,
|
||||
F::WindowsPin => NativeFileRole::WindowsPin,
|
||||
F::WindowsTimeProfile => NativeFileRole::WindowsTimeProfile,
|
||||
}
|
||||
}
|
||||
fn native_service(service: NativeService) -> rmm_updater_handoff::Service {
|
||||
use rmm_updater_handoff::Service as S;
|
||||
match service {
|
||||
@@ -820,7 +1006,10 @@ fn insert_native_claim(
|
||||
[h.attempt.grant_id.to_string()],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(count < 17, "UPDATE_NATIVE_EFFECT_LIMIT");
|
||||
ensure!(
|
||||
count < if h.schema_version == 2 { 32 } else { 17 },
|
||||
"UPDATE_NATIVE_EFFECT_LIMIT"
|
||||
);
|
||||
let claim = NativeEffectClaim {
|
||||
grant_id: h.attempt.grant_id,
|
||||
owner_nonce: h.owner_nonce,
|
||||
@@ -890,6 +1079,12 @@ pub fn claim_native_effect(
|
||||
&& old_sha256 != new_sha256,
|
||||
"UPDATE_NATIVE_INSTALLED_RECORD_BINDING"
|
||||
);
|
||||
if h.schema_version == 2
|
||||
&& h.pin_transition == rmm_updater_handoff::PinTransition::LinuxGeneralFullV1
|
||||
{
|
||||
let denied:u64=tx.query_row("SELECT count(*) FROM agent_update_native_nonstarts WHERE grant_id=?1 AND effect_key=?2",params![grant.to_string(),native_key(&NativeEffect::ConditionalRollbackStopGeneral)?],|r|r.get(0))?;
|
||||
ensure!(denied == 1, "UPDATE_CONDITIONAL_STOP_NOT_CLOSED");
|
||||
}
|
||||
if matches!(effect, NativeEffect::PublishInstalledRecord { .. }) {
|
||||
let save = native_key(&NativeEffect::SaveInstalledRecord {
|
||||
old_sha256: old_sha256.clone(),
|
||||
@@ -900,11 +1095,60 @@ pub fn claim_native_effect(
|
||||
require_matching_record_save(&tx, grant, old_sha256, new_sha256)?;
|
||||
}
|
||||
}
|
||||
NativeEffect::RollbackStopService { service } => {
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& j.phase() == Phase::RollbackIntent
|
||||
&& matches!(
|
||||
guard.participant(),
|
||||
Participant::NewHelper | Participant::StableUpdater
|
||||
)
|
||||
&& h.stop_set.contains(&native_service(*service)),
|
||||
"UPDATE_ROLLBACK_STOP_ROLE"
|
||||
);
|
||||
}
|
||||
NativeEffect::SaveRejectedCandidate { role } => {
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& j.phase() == Phase::RestoreIntent,
|
||||
"UPDATE_ROLLBACK_SAVE_ROLE"
|
||||
);
|
||||
let last:Vec<u8>=tx.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1",[grant.to_string()],|r|r.get(0))?;
|
||||
ensure!(
|
||||
serde_json::from_slice::<Event>(&last)?.evidence
|
||||
== Evidence::RestoreIntent {
|
||||
role: native_role(*role)
|
||||
},
|
||||
"UPDATE_ROLLBACK_SAVE_FILE"
|
||||
);
|
||||
}
|
||||
NativeEffect::RestorePredecessor { role } => {
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& j.phase() == Phase::CandidatePreserved,
|
||||
"UPDATE_ROLLBACK_RESTORE_ROLE"
|
||||
);
|
||||
let last:Vec<u8>=tx.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1",[grant.to_string()],|r|r.get(0))?;
|
||||
ensure!(
|
||||
matches!(serde_json::from_slice::<Event>(&last)?.evidence,
|
||||
Evidence::CandidatePreserved{role:r,..} if r==native_role(*role)),
|
||||
"UPDATE_ROLLBACK_RESTORE_FILE"
|
||||
);
|
||||
let save = native_key(&NativeEffect::SaveRejectedCandidate { role: *role })?;
|
||||
let observed:u64=tx.query_row("SELECT count(*) FROM agent_update_native_observations WHERE grant_id=?1 AND effect_key=?2",params![grant.to_string(),save],|r|r.get(0))?;
|
||||
ensure!(observed == 1, "UPDATE_ROLLBACK_CANDIDATE_NOT_PRESERVED");
|
||||
}
|
||||
// Rollback needs its own qualified event transition; never infer it
|
||||
// from an uncertain replacement or silently restart the predecessor.
|
||||
NativeEffect::RestorePredecessor { .. }
|
||||
| NativeEffect::StartService { .. }
|
||||
| NativeEffect::ReturnLedger => anyhow::bail!("UPDATE_NATIVE_SPECIAL_TRANSITION_REQUIRED"),
|
||||
NativeEffect::StartService { .. }
|
||||
| NativeEffect::ReturnLedger
|
||||
| NativeEffect::RollbackStartService { .. }
|
||||
| NativeEffect::RollbackReturnLedger
|
||||
| NativeEffect::ConditionalRollbackStopGeneral => {
|
||||
anyhow::bail!("UPDATE_NATIVE_SPECIAL_TRANSITION_REQUIRED")
|
||||
}
|
||||
}
|
||||
guard.verify_native_effect(&h, &d, effect, NativeEffectStage::Claim)?;
|
||||
let result = insert_native_claim(&tx, &h, expected_head, effect.clone(), now)?;
|
||||
@@ -912,6 +1156,281 @@ pub fn claim_native_effect(
|
||||
tx.commit()?;
|
||||
Ok(result)
|
||||
}
|
||||
/// Known startup/health failure only, still the original consumed attempt.
|
||||
/// Nonstarts are separately attested under the actual guard; no failed start
|
||||
/// is mislabeled a successful service observation and no old claim is erased.
|
||||
pub fn begin_rollback(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
expected_head: &str,
|
||||
cause: &rmm_updater_handoff::RollbackCause,
|
||||
failure_observation: &str,
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<()> {
|
||||
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||
begin_rollback_in(
|
||||
&tx,
|
||||
guard,
|
||||
grant,
|
||||
expected_head,
|
||||
cause,
|
||||
failure_observation,
|
||||
now,
|
||||
)?;
|
||||
guard.check(&tx)?;
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
fn begin_rollback_in(
|
||||
tx: &Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
expected_head: &str,
|
||||
cause: &rmm_updater_handoff::RollbackCause,
|
||||
failure_observation: &str,
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<()> {
|
||||
ensure!(
|
||||
rmm_domain::agent_update::digest(failure_observation),
|
||||
"UPDATE_ROLLBACK_FAILURE_OBSERVATION"
|
||||
);
|
||||
let (handoff, delegation, mut journal) = native_context(tx, guard, grant, now)?;
|
||||
ensure!(
|
||||
handoff.schema_version == 2
|
||||
&& journal.head_sha256() == expected_head
|
||||
&& matches!(
|
||||
guard.participant(),
|
||||
Participant::NewHelper | Participant::StableUpdater
|
||||
),
|
||||
"UPDATE_ROLLBACK_ORIGINAL_ROLE"
|
||||
);
|
||||
let raw = journal.prepare(
|
||||
u64::try_from(now.timestamp())?,
|
||||
Evidence::RollbackIntent {
|
||||
cause: cause.clone(),
|
||||
failure_observation_sha256: failure_observation.into(),
|
||||
},
|
||||
)?;
|
||||
let event: Event = serde_json::from_slice(&raw)?;
|
||||
verify_writer(tx, guard, grant, &event)?;
|
||||
let mut query=tx.prepare("SELECT c.effect_key,c.claim,c.claim_sha256 FROM agent_update_native_claims c LEFT JOIN agent_update_native_observations o ON o.grant_id=c.grant_id AND o.effect_key=c.effect_key LEFT JOIN agent_update_native_nonstarts n ON n.grant_id=c.grant_id AND n.effect_key=c.effect_key WHERE c.grant_id=?1 AND o.claim_sha256 IS NULL AND n.claim_sha256 IS NULL")?;
|
||||
let rows = query
|
||||
.query_map([grant.to_string()], |r| {
|
||||
Ok((
|
||||
r.get::<_, String>(0)?,
|
||||
r.get::<_, Vec<u8>>(1)?,
|
||||
r.get::<_, String>(2)?,
|
||||
))
|
||||
})?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
drop(query);
|
||||
let mut actual_failed = false;
|
||||
for (effect_key, raw_claim, claim_sha) in rows {
|
||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw_claim)?;
|
||||
match &claim.effect {
|
||||
NativeEffect::ReturnLedger => {}
|
||||
NativeEffect::ConditionalRollbackStopGeneral => {
|
||||
guard.verify_native_effect(
|
||||
&handoff,
|
||||
&delegation,
|
||||
&claim.effect,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
let observation = guard.native_observation_sha256(
|
||||
&handoff,
|
||||
&delegation,
|
||||
&claim.effect,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
ensure!(
|
||||
rmm_domain::agent_update::digest(&observation),
|
||||
"UPDATE_ROLLBACK_NONSTART_OBSERVATION"
|
||||
);
|
||||
tx.execute("INSERT INTO agent_update_native_nonstarts(grant_id,effect_key,claim_sha256,observation_sha256,observed_at) VALUES(?1,?2,?3,?4,?5)",params![grant.to_string(),effect_key,claim_sha,observation,now.to_rfc3339()])?;
|
||||
}
|
||||
NativeEffect::StartService { service } => {
|
||||
ensure!(
|
||||
matches!(
|
||||
cause,
|
||||
rmm_updater_handoff::RollbackCause::StartupFailed { .. }
|
||||
) && native_key(&claim.effect)? == effect_key
|
||||
&& hash(&raw_claim) == claim_sha,
|
||||
"UPDATE_ROLLBACK_UNOBSERVED_START"
|
||||
);
|
||||
guard.verify_native_effect(
|
||||
&handoff,
|
||||
&delegation,
|
||||
&claim.effect,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
let observation = guard.native_observation_sha256(
|
||||
&handoff,
|
||||
&delegation,
|
||||
&claim.effect,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
ensure!(
|
||||
rmm_domain::agent_update::digest(&observation),
|
||||
"UPDATE_ROLLBACK_NONSTART_OBSERVATION"
|
||||
);
|
||||
if matches!(cause,rmm_updater_handoff::RollbackCause::StartupFailed{service:s} if *s==native_service(*service))
|
||||
{
|
||||
actual_failed = true;
|
||||
}
|
||||
tx.execute("INSERT INTO agent_update_native_nonstarts(grant_id,effect_key,claim_sha256,observation_sha256,observed_at) VALUES(?1,?2,?3,?4,?5)",params![grant.to_string(),effect_key,claim_sha,observation,now.to_rfc3339()])?;
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_ROLLBACK_UNCERTAIN_NATIVE_EFFECT"),
|
||||
}
|
||||
}
|
||||
ensure!(
|
||||
matches!(cause, rmm_updater_handoff::RollbackCause::HealthRejected) || actual_failed,
|
||||
"UPDATE_ROLLBACK_KNOWN_FAILURE_REQUIRED"
|
||||
);
|
||||
journal.replay(&raw)?;
|
||||
append_in(tx, grant, expected_head, &raw, &event, &journal)?;
|
||||
// A service whose original once-only start is independently known not to
|
||||
// have happened needs NO STOP effect. Close an exact deny-only subordinate
|
||||
// claim, not a fabricated successful ControlService/systemctl observation.
|
||||
let mut query=tx.prepare("SELECT claim FROM agent_update_native_claims c JOIN agent_update_native_nonstarts n ON n.grant_id=c.grant_id AND n.effect_key=c.effect_key WHERE c.grant_id=?1")?;
|
||||
let nonstarts = query
|
||||
.query_map([grant.to_string()], |r| r.get::<_, Vec<u8>>(0))?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
drop(query);
|
||||
for raw_claim in nonstarts {
|
||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw_claim)?;
|
||||
if let NativeEffect::StartService { service } = claim.effect {
|
||||
let effect = NativeEffect::RollbackStopService { service };
|
||||
guard.verify_native_effect(
|
||||
&handoff,
|
||||
&delegation,
|
||||
&effect,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
let observation = guard.native_observation_sha256(
|
||||
&handoff,
|
||||
&delegation,
|
||||
&effect,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
ensure!(
|
||||
rmm_domain::agent_update::digest(&observation),
|
||||
"UPDATE_ROLLBACK_STOP_NONSTART_HASH"
|
||||
);
|
||||
let tombstone =
|
||||
insert_native_claim(tx, &handoff, journal.head_sha256(), effect.clone(), now)?;
|
||||
tx.execute("INSERT INTO agent_update_native_nonstarts(grant_id,effect_key,claim_sha256,observation_sha256,observed_at) VALUES(?1,?2,?3,?4,?5)",params![grant.to_string(),native_key(&effect)?,hash(&serde_json::to_vec(&tombstone)?),observation,now.to_rfc3339()])?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub struct ReservedGeneralStop<'a> {
|
||||
pub grant_id: Uuid,
|
||||
pub expected_head: &'a str,
|
||||
pub general_start_observation_sha256: &'a str,
|
||||
pub general_stop_observation_sha256: &'a str,
|
||||
pub failure_observation_sha256: &'a str,
|
||||
pub now: DateTime<Utc>,
|
||||
}
|
||||
/// Early Full startup failure: the concrete started General process was
|
||||
/// stopped using the conditional intent reserved BEFORE the original return.
|
||||
/// Only the same still-live updater may record retained original START + STOP
|
||||
/// observations after all readers stopped and the original lock was acquired.
|
||||
pub fn begin_rollback_after_reserved_stop(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
input: ReservedGeneralStop<'_>,
|
||||
) -> Result<()> {
|
||||
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||
let (h, d, journal) = native_context(&tx, guard, input.grant_id, input.now)?;
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& h.pin_transition == rmm_updater_handoff::PinTransition::LinuxGeneralFullV1
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& journal.phase() == Phase::LedgerReturnIntent
|
||||
&& journal.head_sha256() == input.expected_head,
|
||||
"UPDATE_CONDITIONAL_ROLLBACK_CONTEXT"
|
||||
);
|
||||
for (effect, stage, observation) in [
|
||||
(
|
||||
NativeEffect::StartService {
|
||||
service: NativeService::General,
|
||||
},
|
||||
NativeEffectStage::ObserveRetainedStart,
|
||||
input.general_start_observation_sha256,
|
||||
),
|
||||
(
|
||||
NativeEffect::ConditionalRollbackStopGeneral,
|
||||
NativeEffectStage::Observe,
|
||||
input.general_stop_observation_sha256,
|
||||
),
|
||||
] {
|
||||
ensure!(
|
||||
rmm_domain::agent_update::digest(observation),
|
||||
"UPDATE_CONDITIONAL_OBSERVATION_HASH"
|
||||
);
|
||||
let claim = read_native_claim(&tx, guard, input.grant_id, &effect)?;
|
||||
ensure!(
|
||||
claim.head_sha256 == journal.head_sha256()
|
||||
&& claim.owner_nonce == h.owner_nonce
|
||||
&& input.now >= claim.claimed_at,
|
||||
"UPDATE_CONDITIONAL_ORIGINAL_CLAIM"
|
||||
);
|
||||
guard.verify_native_effect(&h, &d, &effect, stage)?;
|
||||
ensure!(
|
||||
guard.native_observation_sha256(&h, &d, &effect, stage)? == observation,
|
||||
"UPDATE_CONDITIONAL_RETAINED_OBSERVATION_CHANGED"
|
||||
);
|
||||
tx.execute("INSERT INTO agent_update_native_observations(grant_id,effect_key,claim_sha256,observation_sha256,observed_at) VALUES(?1,?2,?3,?4,?5)",params![input.grant_id.to_string(),native_key(&effect)?,hash(&serde_json::to_vec(&claim)?),observation,input.now.to_rfc3339()])?;
|
||||
}
|
||||
begin_rollback_in(
|
||||
&tx,
|
||||
guard,
|
||||
input.grant_id,
|
||||
input.expected_head,
|
||||
&rmm_updater_handoff::RollbackCause::StartupFailed {
|
||||
service: rmm_updater_handoff::Service::LinuxFullHelper,
|
||||
},
|
||||
input.failure_observation_sha256,
|
||||
input.now,
|
||||
)?;
|
||||
guard.check(&tx)?;
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
/// Deny-only close of a conditional reserve after actual new Full startup.
|
||||
/// It is not a STOP observation and never dispatches/resumes the reservation.
|
||||
pub fn deny_conditional_stop(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
observation: &str,
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<()> {
|
||||
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||
let (h, d, journal) = native_context(&tx, guard, grant, now)?;
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::NewHelper
|
||||
&& matches!(
|
||||
journal.phase(),
|
||||
Phase::ServicesStarted | Phase::HealthVerified
|
||||
),
|
||||
"UPDATE_CONDITIONAL_DENY_ROLE"
|
||||
);
|
||||
let effect = NativeEffect::ConditionalRollbackStopGeneral;
|
||||
let claim = read_native_claim(&tx, guard, grant, &effect)?;
|
||||
guard.verify_native_effect(&h, &d, &effect, NativeEffectStage::ObserveNonstart)?;
|
||||
ensure!(
|
||||
guard.native_observation_sha256(&h, &d, &effect, NativeEffectStage::ObserveNonstart)?
|
||||
== observation,
|
||||
"UPDATE_CONDITIONAL_DENY_OBSERVATION"
|
||||
);
|
||||
tx.execute("INSERT INTO agent_update_native_nonstarts(grant_id,effect_key,claim_sha256,observation_sha256,observed_at) VALUES(?1,?2,?3,?4,?5)",params![grant.to_string(),native_key(&effect)?,hash(&serde_json::to_vec(&claim)?),observation,now.to_rfc3339()])?;
|
||||
guard.check(&tx)?;
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn observe_native_effect(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
@@ -966,8 +1485,43 @@ pub fn observe_native_effect(
|
||||
)
|
||||
}
|
||||
NativeEffect::ReturnLedger | NativeEffect::RestorePredecessor { .. } => {
|
||||
if matches!(claim.effect, NativeEffect::RestorePredecessor { .. }) {
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& j.phase() == Phase::CandidatePreserved
|
||||
&& j.head_sha256() == claim.head_sha256,
|
||||
"UPDATE_ROLLBACK_FILE_OBSERVER"
|
||||
);
|
||||
} else {
|
||||
anyhow::bail!("UPDATE_NATIVE_OBSERVATION_NOT_SUPPORTED");
|
||||
}
|
||||
}
|
||||
NativeEffect::RollbackStopService { .. } => ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& j.phase() == Phase::RollbackIntent,
|
||||
"UPDATE_ROLLBACK_STOP_OBSERVER"
|
||||
),
|
||||
NativeEffect::SaveRejectedCandidate { .. } => ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& j.phase() == Phase::RestoreIntent
|
||||
&& j.head_sha256() == claim.head_sha256,
|
||||
"UPDATE_ROLLBACK_FILE_OBSERVER"
|
||||
),
|
||||
NativeEffect::RollbackStartService { .. } => ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::RestoredHelper
|
||||
&& j.phase() == Phase::RollbackLedgerReturnIntent,
|
||||
"UPDATE_ROLLBACK_START_OBSERVER"
|
||||
),
|
||||
NativeEffect::RollbackReturnLedger => {
|
||||
anyhow::bail!("UPDATE_NATIVE_OBSERVATION_NOT_SUPPORTED")
|
||||
}
|
||||
NativeEffect::ConditionalRollbackStopGeneral => {
|
||||
anyhow::bail!("UPDATE_NATIVE_SPECIAL_TRANSITION_REQUIRED")
|
||||
}
|
||||
}
|
||||
guard.verify_native_effect(&h, &d, &claim.effect, NativeEffectStage::Observe)?;
|
||||
tx.execute("INSERT INTO agent_update_native_observations(grant_id,effect_key,claim_sha256,observation_sha256,observed_at) VALUES(?1,?2,?3,?4,?5)",params![claim.grant_id.to_string(),native_key(&claim.effect)?,hash(&raw),observation_sha256,now.to_rfc3339()])?;
|
||||
@@ -1079,6 +1633,16 @@ fn prepare_return_for<const N: usize>(
|
||||
NativeEffectStage::ReserveFutureStart,
|
||||
)?;
|
||||
}
|
||||
let conditional = h.schema_version == 2
|
||||
&& h.pin_transition == rmm_updater_handoff::PinTransition::LinuxGeneralFullV1;
|
||||
if conditional {
|
||||
guard.verify_native_effect(
|
||||
&h,
|
||||
&d,
|
||||
&NativeEffect::ConditionalRollbackStopGeneral,
|
||||
NativeEffectStage::ReserveConditionalStop,
|
||||
)?;
|
||||
}
|
||||
j.replay(return_event)?;
|
||||
append_in(&tx, grant, expected_head, return_event, &parsed, &j)?;
|
||||
let return_ledger =
|
||||
@@ -1093,13 +1657,148 @@ fn prepare_return_for<const N: usize>(
|
||||
now,
|
||||
)?);
|
||||
}
|
||||
let conditional_rollback_stop_general = if conditional {
|
||||
Some(insert_native_claim(
|
||||
&tx,
|
||||
&h,
|
||||
j.head_sha256(),
|
||||
NativeEffect::ConditionalRollbackStopGeneral,
|
||||
now,
|
||||
)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
guard.check(&tx)?;
|
||||
tx.commit()?;
|
||||
Ok(PreparedReturnClaims {
|
||||
return_ledger,
|
||||
conditional_rollback_stop_general,
|
||||
starts: starts
|
||||
.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_NATIVE_START_COUNT"))?,
|
||||
})
|
||||
}
|
||||
pub fn prepare_rollback_return_and_starts(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
expected_head: &str,
|
||||
return_event: &[u8],
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<PreparedReturnClaims> {
|
||||
prepare_rollback_return_for(
|
||||
db,
|
||||
guard,
|
||||
grant,
|
||||
expected_head,
|
||||
return_event,
|
||||
now,
|
||||
[
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
],
|
||||
)
|
||||
}
|
||||
pub fn prepare_windows_rollback_return_and_starts(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
expected_head: &str,
|
||||
return_event: &[u8],
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<PreparedReturnClaims<2>> {
|
||||
prepare_rollback_return_for(
|
||||
db,
|
||||
guard,
|
||||
grant,
|
||||
expected_head,
|
||||
return_event,
|
||||
now,
|
||||
[NativeService::WindowsHelper, NativeService::WindowsAgent],
|
||||
)
|
||||
}
|
||||
fn prepare_rollback_return_for<const N: usize>(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
expected_head: &str,
|
||||
return_event: &[u8],
|
||||
now: DateTime<Utc>,
|
||||
sequence: [NativeService; N],
|
||||
) -> Result<PreparedReturnClaims<N>> {
|
||||
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||
let (h, d, mut journal) = native_context(&tx, guard, grant, now)?;
|
||||
ensure!(
|
||||
h.schema_version == 2
|
||||
&& guard.participant() == Participant::StableUpdater
|
||||
&& journal.phase() == Phase::PredecessorVerified
|
||||
&& journal.head_sha256() == expected_head,
|
||||
"UPDATE_ROLLBACK_RETURN_ROLE"
|
||||
);
|
||||
ensure!(
|
||||
(sequence.as_slice()
|
||||
== [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent
|
||||
]
|
||||
&& h.pin_transition == rmm_updater_handoff::PinTransition::LinuxGeneralFullV1)
|
||||
|| (sequence.as_slice() == [NativeService::WindowsHelper, NativeService::WindowsAgent]
|
||||
&& h.pin_transition == rmm_updater_handoff::PinTransition::WindowsCodePairClockV1),
|
||||
"UPDATE_ROLLBACK_RETURN_SERVICE_SET"
|
||||
);
|
||||
let missing:u64=tx.query_row("SELECT count(*) FROM agent_update_native_claims c LEFT JOIN agent_update_native_observations o ON o.grant_id=c.grant_id AND o.effect_key=c.effect_key LEFT JOIN agent_update_native_nonstarts n ON n.grant_id=c.grant_id AND n.effect_key=c.effect_key WHERE c.grant_id=?1 AND o.claim_sha256 IS NULL AND n.claim_sha256 IS NULL AND c.effect_key<>?2",
|
||||
params![grant.to_string(),native_key(&NativeEffect::ReturnLedger)?],|r|r.get(0))?;
|
||||
ensure!(missing == 0, "UPDATE_ROLLBACK_UNOBSERVED_EFFECT");
|
||||
let event: Event = serde_json::from_slice(return_event)?;
|
||||
ensure!(
|
||||
event.evidence == Evidence::RollbackLedgerReturnIntent
|
||||
&& event.observed_at == u64::try_from(now.timestamp())?,
|
||||
"UPDATE_ROLLBACK_RETURN_EVENT"
|
||||
);
|
||||
verify_writer(&tx, guard, grant, &event)?;
|
||||
guard.verify_native_effect(
|
||||
&h,
|
||||
&d,
|
||||
&NativeEffect::RollbackReturnLedger,
|
||||
NativeEffectStage::Claim,
|
||||
)?;
|
||||
for service in sequence {
|
||||
guard.verify_native_effect(
|
||||
&h,
|
||||
&d,
|
||||
&NativeEffect::RollbackStartService { service },
|
||||
NativeEffectStage::ReserveFutureStart,
|
||||
)?;
|
||||
}
|
||||
journal.replay(return_event)?;
|
||||
append_in(&tx, grant, expected_head, return_event, &event, &journal)?;
|
||||
let return_ledger = insert_native_claim(
|
||||
&tx,
|
||||
&h,
|
||||
journal.head_sha256(),
|
||||
NativeEffect::RollbackReturnLedger,
|
||||
now,
|
||||
)?;
|
||||
let mut starts = Vec::new();
|
||||
for service in sequence {
|
||||
starts.push(insert_native_claim(
|
||||
&tx,
|
||||
&h,
|
||||
journal.head_sha256(),
|
||||
NativeEffect::RollbackStartService { service },
|
||||
now,
|
||||
)?);
|
||||
}
|
||||
guard.check(&tx)?;
|
||||
tx.commit()?;
|
||||
Ok(PreparedReturnClaims {
|
||||
return_ledger,
|
||||
starts: starts
|
||||
.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_NATIVE_START_COUNT"))?,
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_ROLLBACK_START_COUNT"))?,
|
||||
conditional_rollback_stop_general: None,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1158,6 +1857,14 @@ pub struct NativeControlReply {
|
||||
/// Only ReadOriginal; exact retained execution_evidence.start bytes,
|
||||
/// bounded to 512KiB before canonical Base64url encoding, never rewritten.
|
||||
pub original_start_base64url: Option<String>,
|
||||
/// ReadOriginal only: exact applied helper_sync_decisions.request protobuf
|
||||
/// and response JSON SignedResponse bytes. Both absent until that actual
|
||||
/// ORIGINAL inflight control acknowledgement has been applied. Evidence
|
||||
/// only: never a caller ready bit, replacement request or new authority.
|
||||
#[serde(default,skip_serializing_if="Option::is_none")]
|
||||
pub pre_stop_sync_request_base64url:Option<String>,
|
||||
#[serde(default,skip_serializing_if="Option::is_none")]
|
||||
pub pre_stop_sync_response_base64url:Option<String>,
|
||||
}
|
||||
|
||||
fn require_matching_record_save(
|
||||
|
||||
@@ -251,7 +251,10 @@ fn services_prefix(
|
||||
let (observed, journal) = verify_inflight_proof(&proof, key).map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
observed.bytes()? == header.bytes()?
|
||||
&& journal.phase() == Phase::ServicesStarted
|
||||
&& matches!(
|
||||
journal.phase(),
|
||||
Phase::ServicesStarted | Phase::RollbackServicesStarted
|
||||
)
|
||||
&& local.grant_id == header.attempt.grant_id.to_string()
|
||||
&& local.consumption == "consumed"
|
||||
&& local.state == "running"
|
||||
|
||||
@@ -0,0 +1,392 @@
|
||||
//! Approved artifact prefetch before a grant; Full independently admits the handoff.
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use rmm_domain::{
|
||||
agent_update::{
|
||||
APPLY_CAPABILITY, ArtifactDescriptor, ArtifactRole, CHECK_CAPABILITY, Platform,
|
||||
},
|
||||
jobs::{Action, JobPayload},
|
||||
};
|
||||
use rmm_privileged_helper::{Binding, Request, control, update_admission::Accepted};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
fs::{self, File, OpenOptions},
|
||||
io::{Read, Write},
|
||||
os::unix::fs::{MetadataExt, OpenOptionsExt},
|
||||
path::{Path, PathBuf},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
const MAXIMUM: u64 = 256 * 1024 * 1024;
|
||||
const CHUNK: u64 = 512 * 1024;
|
||||
pub struct Prefetch(pub tokio::task::JoinHandle<Result<()>>);
|
||||
impl Drop for Prefetch {
|
||||
fn drop(&mut self) {
|
||||
self.0.abort();
|
||||
}
|
||||
}
|
||||
fn directory(path: &Path, create: bool) -> Result<()> {
|
||||
if create && !path.try_exists()? {
|
||||
std::fs::DirBuilder::new().mode(0o700).create(path)?;
|
||||
}
|
||||
let m = fs::symlink_metadata(path)?;
|
||||
ensure!(
|
||||
m.is_dir() && !m.file_type().is_symlink() && m.uid() == 993 && m.mode() & 0o777 == 0o700,
|
||||
"UPDATE_PREFETCH_DIRECTORY"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
use std::os::unix::fs::DirBuilderExt;
|
||||
fn parent(job: &JobPayload) -> Result<PathBuf> {
|
||||
ensure!(
|
||||
unsafe { libc::geteuid() } == 993,
|
||||
"UPDATE_PREFETCH_AGENT_UID"
|
||||
);
|
||||
let base = Path::new("/var/lib/rmm-agent-remote");
|
||||
directory(base, false)?;
|
||||
let base = base.join("update-downloads");
|
||||
directory(&base, true)?;
|
||||
let base = base.join(job.job_id.to_string());
|
||||
directory(&base, true)?;
|
||||
let base = base.join(job.attempt_id.to_string());
|
||||
directory(&base, true)?;
|
||||
Ok(base)
|
||||
}
|
||||
fn label(a: &ArtifactDescriptor) -> &'static str {
|
||||
match a.role {
|
||||
ArtifactRole::Agent => "agent.bin",
|
||||
ArtifactRole::Helper => "helper.bin",
|
||||
}
|
||||
}
|
||||
fn checked(path: &Path, a: &ArtifactDescriptor) -> Result<()> {
|
||||
let mut f = OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
|
||||
.open(path)?;
|
||||
let m = f.metadata()?;
|
||||
ensure!(
|
||||
m.is_file()
|
||||
&& m.uid() == 993
|
||||
&& m.mode() & 0o777 == 0o600
|
||||
&& m.nlink() == 1
|
||||
&& m.len() == a.bytes,
|
||||
"UPDATE_PREFETCH_FILE"
|
||||
);
|
||||
let mut h = Sha256::new();
|
||||
let mut n = 0;
|
||||
let mut buf = [0; 65536];
|
||||
loop {
|
||||
let size = f.read(&mut buf)?;
|
||||
if size == 0 {
|
||||
break;
|
||||
}
|
||||
n += size as u64;
|
||||
ensure!(n <= a.bytes, "UPDATE_PREFETCH_LENGTH");
|
||||
h.update(&buf[..size]);
|
||||
}
|
||||
ensure!(
|
||||
n == a.bytes && format!("{:x}", h.finalize()) == a.sha256,
|
||||
"UPDATE_PREFETCH_DIGEST"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub async fn prefetch(client: reqwest::Client, base: String, job: JobPayload) -> Result<()> {
|
||||
let Action::UpdateAgent { update } = &job.action else {
|
||||
anyhow::bail!("UPDATE_ACTION_REQUIRED")
|
||||
};
|
||||
let manifest = update.manifest().map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
manifest.validate() && manifest.platform == Platform::LinuxX64,
|
||||
"UPDATE_PREFETCH_MANIFEST"
|
||||
);
|
||||
let pjob = job.clone();
|
||||
let folder = tokio::task::spawn_blocking(move || parent(&pjob)).await??;
|
||||
let deadline = Instant::now() + Duration::from_secs(600);
|
||||
for artifact in manifest.artifacts {
|
||||
ensure!(
|
||||
artifact.bytes > 0 && artifact.bytes <= MAXIMUM,
|
||||
"UPDATE_PREFETCH_LIMIT"
|
||||
);
|
||||
let path = folder.join(label(&artifact));
|
||||
let existing = path.clone();
|
||||
let desc = artifact.clone();
|
||||
if tokio::task::spawn_blocking(move || -> Result<bool> {
|
||||
if existing.try_exists()? {
|
||||
checked(&existing, &desc)?;
|
||||
Ok(true)
|
||||
} else {
|
||||
Ok(false)
|
||||
}
|
||||
})
|
||||
.await??
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let stage = folder.join(format!("{}.partial", label(&artifact)));
|
||||
let stage_path = stage.clone();
|
||||
let mut file = tokio::task::spawn_blocking(move || {
|
||||
OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.mode(0o600)
|
||||
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
|
||||
.open(stage_path)
|
||||
})
|
||||
.await??;
|
||||
let mut offset = 0;
|
||||
let mut hash = Sha256::new();
|
||||
while offset < artifact.bytes {
|
||||
ensure!(
|
||||
Instant::now() < deadline && chrono::Utc::now() < job.start_before,
|
||||
"UPDATE_PREFETCH_EXPIRED"
|
||||
);
|
||||
let length = CHUNK.min(artifact.bytes - offset);
|
||||
let url = format!(
|
||||
"{base}/agent/v1/update-artifacts/{}?job_id={}&attempt_id={}&offset={offset}&length={length}",
|
||||
artifact.artifact_id, job.job_id, job.attempt_id
|
||||
);
|
||||
let mut response = client.get(&url).send().await?;
|
||||
let partial = offset != 0 || length != artifact.bytes;
|
||||
ensure!(
|
||||
response.url().as_str() == url
|
||||
&& response.status()
|
||||
== if partial {
|
||||
reqwest::StatusCode::PARTIAL_CONTENT
|
||||
} else {
|
||||
reqwest::StatusCode::OK
|
||||
},
|
||||
"UPDATE_PREFETCH_HTTP"
|
||||
);
|
||||
let h = response.headers();
|
||||
ensure!(
|
||||
h.get("x-artifact-sha256").and_then(|v| v.to_str().ok())
|
||||
== Some(artifact.sha256.as_str())
|
||||
&& h.get("content-type").and_then(|v| v.to_str().ok())
|
||||
== Some("application/octet-stream")
|
||||
&& !h.contains_key("content-encoding")
|
||||
&& response.content_length() == Some(length),
|
||||
"UPDATE_PREFETCH_HEADERS"
|
||||
);
|
||||
if partial {
|
||||
ensure!(
|
||||
h.get("content-range").and_then(|v| v.to_str().ok())
|
||||
== Some(
|
||||
format!(
|
||||
"bytes {}-{}/{}",
|
||||
offset,
|
||||
offset + length - 1,
|
||||
artifact.bytes
|
||||
)
|
||||
.as_str()
|
||||
),
|
||||
"UPDATE_PREFETCH_RANGE"
|
||||
);
|
||||
} else {
|
||||
ensure!(!h.contains_key("content-range"), "UPDATE_PREFETCH_RANGE");
|
||||
}
|
||||
let mut bytes = Vec::with_capacity(length as usize);
|
||||
while let Some(chunk) = response.chunk().await? {
|
||||
ensure!(
|
||||
bytes.len() + chunk.len() <= length as usize,
|
||||
"UPDATE_PREFETCH_BODY_LIMIT"
|
||||
);
|
||||
bytes.extend_from_slice(&chunk);
|
||||
}
|
||||
ensure!(
|
||||
bytes.len() == length as usize && Instant::now() < deadline,
|
||||
"UPDATE_PREFETCH_BODY_LENGTH"
|
||||
);
|
||||
hash.update(&bytes);
|
||||
file = tokio::task::spawn_blocking(move || -> Result<File> {
|
||||
file.write_all(&bytes)?;
|
||||
Ok(file)
|
||||
})
|
||||
.await??;
|
||||
offset += length;
|
||||
}
|
||||
ensure!(
|
||||
format!("{:x}", hash.finalize()) == artifact.sha256,
|
||||
"UPDATE_PREFETCH_DIGEST"
|
||||
);
|
||||
let dir = folder.clone();
|
||||
tokio::task::spawn_blocking(move || -> Result<()> {
|
||||
file.sync_all()?;
|
||||
drop(file);
|
||||
fs::hard_link(&stage, &path)?;
|
||||
fs::remove_file(stage)?;
|
||||
File::open(dir)?.sync_all()?;
|
||||
checked(&path, &artifact)
|
||||
})
|
||||
.await??;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// No Outcome is invented on acceptance; loss after write stays ambiguous.
|
||||
pub fn handoff(binding: &Binding, request: &Request, grant: uuid::Uuid) -> Result<Accepted> {
|
||||
let socket = std::env::var_os("RMM_FULL_MAINTENANCE_HELPER_SOCKET")
|
||||
.context("UPDATE_FULL_SOCKET_REQUIRED")?;
|
||||
let pin =
|
||||
std::env::var_os("RMM_FULL_MAINTENANCE_POLICY_FILE").context("UPDATE_FULL_PIN_REQUIRED")?;
|
||||
let pin = control::GeneralPin::read(Path::new(&pin), binding)?;
|
||||
ensure!(
|
||||
pin.profile == "full_maintenance_v1",
|
||||
"UPDATE_FULL_PROFILE_REQUIRED"
|
||||
);
|
||||
control::general_probe(Path::new(&socket), binding, &pin)?;
|
||||
let ack: Accepted =
|
||||
control::exchange(Path::new(&socket), request, Duration::from_secs(50), 4096)?;
|
||||
ack.matches(request, grant)?;
|
||||
Ok(ack)
|
||||
}
|
||||
|
||||
/// Opaque public metadata authenticated by the current protected Full peer,
|
||||
/// with complete guarded history verified there. No caller JSON constructor.
|
||||
#[derive(Clone)]
|
||||
pub struct GuardedRecord {
|
||||
raw: Vec<u8>,
|
||||
observation: rmm_domain::agent_update::AgentUpdateObservation,
|
||||
}
|
||||
impl GuardedRecord {
|
||||
pub fn bytes(&self, policy_raw: &[u8], keys_raw: &[u8]) -> Result<&[u8]> {
|
||||
use rmm_domain::agent_update::ObservationQuality;
|
||||
let o = &self.observation;
|
||||
let age = chrono::Utc::now() - o.observed_at;
|
||||
let p = o
|
||||
.predecessor
|
||||
.as_ref()
|
||||
.context("UPDATE_CATALOG_PREDECESSOR")?;
|
||||
let u = o.updater.as_ref().context("UPDATE_CATALOG_UPDATER")?;
|
||||
ensure!(
|
||||
o.validate()
|
||||
&& o.quality == ObservationQuality::Valid
|
||||
&& o.platform == Platform::LinuxX64
|
||||
&& age >= chrono::Duration::zero()
|
||||
&& age <= chrono::Duration::seconds(90)
|
||||
&& rmm_domain::jobs::hash(policy_raw) == u.policy_sha256
|
||||
&& rmm_domain::jobs::hash(keys_raw) == u.keyring_sha256
|
||||
&& rmm_domain::jobs::hash(&self.raw) == p.installed_record_sha256,
|
||||
"UPDATE_CATALOG_GUARDED_RECORD"
|
||||
);
|
||||
Ok(&self.raw)
|
||||
}
|
||||
}
|
||||
/// Passive cached Full observations only; never a live MCP collection.
|
||||
type Observation = rmm_domain::agent_update::AgentUpdateObservation;
|
||||
struct Observing {
|
||||
receiver: tokio::sync::oneshot::Receiver<Result<(Observation, Vec<u8>)>>,
|
||||
task: tokio::task::JoinHandle<()>,
|
||||
}
|
||||
impl Drop for Observing {
|
||||
fn drop(&mut self) {
|
||||
self.task.abort();
|
||||
}
|
||||
}
|
||||
#[derive(Default)]
|
||||
pub struct Observer {
|
||||
current: Option<Observation>,
|
||||
record: Option<GuardedRecord>,
|
||||
pending: Option<Observing>,
|
||||
}
|
||||
impl Observer {
|
||||
pub fn cached(&self) -> Option<&Observation> {
|
||||
let value = self.current.as_ref()?;
|
||||
let age = chrono::Utc::now() - value.observed_at;
|
||||
(value.validate()
|
||||
&& age >= chrono::Duration::zero()
|
||||
&& age <= chrono::Duration::seconds(90))
|
||||
.then_some(value)
|
||||
}
|
||||
pub fn poll(
|
||||
&mut self,
|
||||
binding: Option<&Binding>,
|
||||
candidate: Option<(rmm_domain::agent_update::ReleaseEnvelope, u64)>,
|
||||
) -> Observation {
|
||||
if let Some(pending) = &mut self.pending {
|
||||
match pending.receiver.try_recv() {
|
||||
Ok(Ok((value, raw))) if value.validate() => {
|
||||
self.record = Some(GuardedRecord {
|
||||
raw,
|
||||
observation: value.clone(),
|
||||
});
|
||||
self.current = Some(value);
|
||||
self.pending = None;
|
||||
}
|
||||
Ok(_) | Err(tokio::sync::oneshot::error::TryRecvError::Closed) => {
|
||||
self.current = None;
|
||||
self.record = None;
|
||||
self.pending = None;
|
||||
}
|
||||
Err(tokio::sync::oneshot::error::TryRecvError::Empty) => {}
|
||||
}
|
||||
}
|
||||
if self.pending.is_none()
|
||||
&& let Some(binding) = binding.cloned()
|
||||
{
|
||||
let (sender, receiver) = tokio::sync::oneshot::channel();
|
||||
let task = tokio::task::spawn_blocking(move || {
|
||||
let (envelope, generation) =
|
||||
candidate.map_or((None, None), |(e, g)| (Some(e), Some(g)));
|
||||
let value = rmm_privileged_helper::update_admission::observe_record(
|
||||
Path::new("/run/rmm-helper-maintenance/control.sock"),
|
||||
&binding,
|
||||
envelope,
|
||||
generation,
|
||||
);
|
||||
let _ = sender.send(value);
|
||||
});
|
||||
self.pending = Some(Observing { receiver, task });
|
||||
}
|
||||
self.cached()
|
||||
.cloned()
|
||||
.unwrap_or_else(|| Observation::not_configured(Platform::LinuxX64, chrono::Utc::now()))
|
||||
}
|
||||
pub fn catalog_record(&self) -> Option<GuardedRecord> {
|
||||
self.cached()?;
|
||||
self.record.clone()
|
||||
}
|
||||
pub fn capabilities(&self) -> Vec<String> {
|
||||
let Some(value) = self
|
||||
.cached()
|
||||
.filter(|v| v.quality == rmm_domain::agent_update::ObservationQuality::Valid)
|
||||
else {
|
||||
return vec![];
|
||||
};
|
||||
let (Some(updater), Some(predecessor)) = (&value.updater, &value.predecessor) else {
|
||||
return vec![];
|
||||
};
|
||||
vec![
|
||||
APPLY_CAPABILITY.into(),
|
||||
CHECK_CAPABILITY.into(),
|
||||
"update_agent".into(),
|
||||
"root:update_agent".into(),
|
||||
"helper.root.v1".into(),
|
||||
format!("updater.binary.sha256:{}", updater.binary_sha256),
|
||||
format!("updater.policy.sha256:{}", updater.policy_sha256),
|
||||
format!("helper.binary.sha256:{}", predecessor.helper_sha256),
|
||||
]
|
||||
}
|
||||
}
|
||||
pub fn supported(binding: &Binding, job: &JobPayload) -> bool {
|
||||
(|| -> Result<bool> {
|
||||
ensure!(
|
||||
unsafe { libc::geteuid() } == 993 && job.execution_identity == "root",
|
||||
"UPDATE_AGENT_PRINCIPAL"
|
||||
);
|
||||
let Action::UpdateAgent { update } = &job.action else {
|
||||
return Ok(false);
|
||||
};
|
||||
let observation = rmm_privileged_helper::update_admission::observe(
|
||||
Path::new("/run/rmm-helper-maintenance/control.sock"),
|
||||
binding,
|
||||
Some(update.release_envelope.clone()),
|
||||
Some(update.updater.keyring_generation),
|
||||
)?;
|
||||
Ok(observation.validate()
|
||||
&& observation.quality == rmm_domain::agent_update::ObservationQuality::Valid
|
||||
&& observation.predecessor.as_ref() == Some(&update.predecessor)
|
||||
&& observation.updater.as_ref() == Some(&update.updater)
|
||||
&& observation.candidate_previews.iter().any(|c| {
|
||||
c.manifest_sha256 == update.manifest_sha256
|
||||
&& c.peer_pin_transition == update.peer_pin_transition
|
||||
}))
|
||||
})()
|
||||
.unwrap_or(false)
|
||||
}
|
||||
@@ -62,7 +62,7 @@ pub fn observation(report: Report, collected_at: DateTime<Utc>) -> serde_json::V
|
||||
"error_code":error,"data":report})
|
||||
}
|
||||
struct Pending {
|
||||
receiver: oneshot::Receiver<Report>,
|
||||
receiver: oneshot::Receiver<(Report, Option<ReleaseEnvelope>)>,
|
||||
task: tokio::task::JoinHandle<()>,
|
||||
}
|
||||
impl Drop for Pending {
|
||||
@@ -73,10 +73,21 @@ impl Drop for Pending {
|
||||
#[derive(Default)]
|
||||
pub struct Checker {
|
||||
report: Option<Report>,
|
||||
release: Option<ReleaseEnvelope>,
|
||||
started: Option<Instant>,
|
||||
pending: Option<Pending>,
|
||||
}
|
||||
impl Checker {
|
||||
/// Exact authenticated envelope, for the independent read-only Full
|
||||
/// verifier. This cache never confers admission or a capability itself.
|
||||
pub fn candidate_envelope(&self, now: DateTime<Utc>) -> Option<(ReleaseEnvelope, u64)> {
|
||||
let report = self.cached(now)?;
|
||||
let candidate = report.candidate?;
|
||||
let envelope = self.release.as_ref()?;
|
||||
let decoded = envelope.decode().ok()?;
|
||||
(hash(&decoded.payload_bytes) == candidate.manifest_sha256)
|
||||
.then(|| (envelope.clone(), candidate.keyring_generation))
|
||||
}
|
||||
pub fn cached(&self, now: DateTime<Utc>) -> Option<Report> {
|
||||
self.report
|
||||
.as_ref()
|
||||
@@ -90,17 +101,20 @@ impl Checker {
|
||||
binding: Option<&Binding>,
|
||||
clock: TrustedClock,
|
||||
address: SocketAddr,
|
||||
guarded: Option<crate::agent_update_apply::GuardedRecord>,
|
||||
client: impl FnOnce() -> Result<reqwest::Client>,
|
||||
) -> Report {
|
||||
if let Some(pending) = &mut self.pending {
|
||||
match pending.receiver.try_recv() {
|
||||
Ok(report) => {
|
||||
Ok((report, release)) => {
|
||||
self.report = Some(report);
|
||||
self.release = release;
|
||||
self.pending.take();
|
||||
}
|
||||
Err(oneshot::error::TryRecvError::Empty) => {}
|
||||
Err(oneshot::error::TryRecvError::Closed) => {
|
||||
self.report = Some(empty(Status::Unavailable));
|
||||
self.release = None;
|
||||
self.pending.take();
|
||||
}
|
||||
}
|
||||
@@ -123,6 +137,7 @@ impl Checker {
|
||||
Path::new(POLICY),
|
||||
Path::new(KEYRING),
|
||||
Path::new(RECORD),
|
||||
guarded.as_ref(),
|
||||
)
|
||||
})
|
||||
.transpose();
|
||||
@@ -148,7 +163,7 @@ impl Checker {
|
||||
let report = result
|
||||
.ok()
|
||||
.and_then(Result::ok)
|
||||
.unwrap_or_else(|| empty(Status::Unavailable));
|
||||
.unwrap_or_else(|| (empty(Status::Unavailable), None));
|
||||
let _ = sender.send(report);
|
||||
});
|
||||
self.pending = Some(Pending { receiver, task });
|
||||
@@ -254,7 +269,13 @@ struct Trust {
|
||||
generation: u64,
|
||||
}
|
||||
impl Trust {
|
||||
fn load(binding: &Binding, policy: &Path, keys: &Path, record: &Path) -> Result<Option<Self>> {
|
||||
fn load(
|
||||
binding: &Binding,
|
||||
policy: &Path,
|
||||
keys: &Path,
|
||||
record: &Path,
|
||||
guarded: Option<&crate::agent_update_apply::GuardedRecord>,
|
||||
) -> Result<Option<Self>> {
|
||||
let result = (|| -> Result<Self> {
|
||||
let policy = Protected::read(policy, 65536)?;
|
||||
let (local, _) =
|
||||
@@ -264,12 +285,22 @@ impl Trust {
|
||||
"UPDATE_CATALOG_FIXED_ANCHOR_PATHS"
|
||||
);
|
||||
let keys = Protected::read(keys, 16384)?;
|
||||
let record = Protected::read(record, 32768)?;
|
||||
let result = Self::verify(binding, &policy.raw, &keys.raw, &record.raw)?;
|
||||
Ok(Self {
|
||||
files: vec![policy, keys, record],
|
||||
..result
|
||||
})
|
||||
if let Some(guarded) = guarded {
|
||||
let raw = guarded.bytes(&policy.raw, &keys.raw)?;
|
||||
let result =
|
||||
Self::verify_guarded(binding, &policy.raw, &keys.raw, raw, Some(guarded))?;
|
||||
Ok(Self {
|
||||
files: vec![policy, keys],
|
||||
..result
|
||||
})
|
||||
} else {
|
||||
let record = Protected::read(record, 32768)?;
|
||||
let result = Self::verify(binding, &policy.raw, &keys.raw, &record.raw)?;
|
||||
Ok(Self {
|
||||
files: vec![policy, keys, record],
|
||||
..result
|
||||
})
|
||||
}
|
||||
})();
|
||||
match result {
|
||||
Ok(value) => Ok(Some(value)),
|
||||
@@ -288,6 +319,15 @@ impl Trust {
|
||||
policy_raw: &[u8],
|
||||
keys_raw: &[u8],
|
||||
record_raw: &[u8],
|
||||
) -> Result<Self> {
|
||||
Self::verify_guarded(binding, policy_raw, keys_raw, record_raw, None)
|
||||
}
|
||||
fn verify_guarded(
|
||||
binding: &Binding,
|
||||
policy_raw: &[u8],
|
||||
keys_raw: &[u8],
|
||||
record_raw: &[u8],
|
||||
guarded: Option<&crate::agent_update_apply::GuardedRecord>,
|
||||
) -> Result<Self> {
|
||||
let (policy, _) = LocalUpdatePolicy::from_bytes(policy_raw).map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
@@ -322,14 +362,23 @@ impl Trust {
|
||||
.initial_baseline
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
// Only the independently signed bootstrap can currently authenticate
|
||||
// the floor here. Later Updated records require the separate guarded
|
||||
// Full history observer; do not guess a floor from parsed root JSON.
|
||||
ensure!(
|
||||
baseline.payload_bytes == record_raw
|
||||
&& hash(record_raw) == policy.initial_record_sha256,
|
||||
"UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED"
|
||||
hash(&baseline.payload_bytes) == policy.initial_record_sha256,
|
||||
"UPDATE_CATALOG_BASELINE_BYTES"
|
||||
);
|
||||
if let Some(guarded) = guarded {
|
||||
ensure!(
|
||||
guarded.bytes(policy_raw, keys_raw)? == record_raw,
|
||||
"UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED"
|
||||
);
|
||||
} else {
|
||||
ensure!(
|
||||
baseline.payload_bytes == record_raw,
|
||||
"UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED"
|
||||
);
|
||||
}
|
||||
let installed =
|
||||
InstalledReleaseRecord::from_bytes(record_raw).map_err(anyhow::Error::msg)?;
|
||||
let signer = keys
|
||||
.keys
|
||||
.iter()
|
||||
@@ -347,8 +396,7 @@ impl Trust {
|
||||
Verifier::new_without_digest(&public)?.verify_oneshot(&baseline.signature, &signed)?,
|
||||
"UPDATE_CATALOG_BASELINE_SIGNATURE"
|
||||
);
|
||||
let decoded = baseline
|
||||
.record
|
||||
let decoded = installed
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
@@ -358,7 +406,7 @@ impl Trust {
|
||||
protocol: decoded.manifest.protocol_major,
|
||||
state: decoded.manifest.state_schema,
|
||||
generation: keys.generation,
|
||||
record: baseline.record,
|
||||
record: installed,
|
||||
};
|
||||
result.release(&result.record.release_envelope, result.record.activated_at)?;
|
||||
Ok(result)
|
||||
@@ -458,14 +506,17 @@ async fn request(
|
||||
address: SocketAddr,
|
||||
trust: &Trust,
|
||||
clock: &TrustedClock,
|
||||
) -> Result<Report> {
|
||||
) -> Result<(Report, Option<ReleaseEnvelope>)> {
|
||||
ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED");
|
||||
let bytes = fetch(client, address).await?;
|
||||
ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED");
|
||||
for file in &trust.files {
|
||||
file.recheck()?;
|
||||
}
|
||||
trust.response(&bytes, Utc::now())
|
||||
let report = trust.response(&bytes, Utc::now())?;
|
||||
let response: CatalogResponse = serde_json::from_slice(&bytes)?;
|
||||
let release = response.release.map(|r| r.release_envelope);
|
||||
Ok((report, release))
|
||||
}
|
||||
|
||||
async fn fetch(client: &reqwest::Client, address: SocketAddr) -> Result<Vec<u8>> {
|
||||
@@ -750,6 +801,7 @@ mod tests {
|
||||
None,
|
||||
TrustedClock::new(),
|
||||
"127.0.0.1:1".parse().unwrap(),
|
||||
None,
|
||||
|| panic!("missing anchor must not load device TLS keys"),
|
||||
);
|
||||
assert_eq!(report.status, Status::NotConfigured);
|
||||
@@ -757,6 +809,7 @@ mod tests {
|
||||
None,
|
||||
TrustedClock::new(),
|
||||
"127.0.0.1:1".parse().unwrap(),
|
||||
None,
|
||||
|| panic!("cadence must not create client"),
|
||||
);
|
||||
assert_eq!(report.checked_at, again.checked_at);
|
||||
|
||||
@@ -222,7 +222,8 @@ pub fn context(
|
||||
let key = update::job_health_public_key(&job).map_err(anyhow::Error::msg)?;
|
||||
let (header, journal) =
|
||||
update::verify_inflight_proof(proof, key).map_err(anyhow::Error::msg)?;
|
||||
if journal.phase() != Phase::ServicesStarted {
|
||||
let rollback = journal.phase() == Phase::RollbackServicesStarted;
|
||||
if journal.phase() != Phase::ServicesStarted && !rollback {
|
||||
return Ok(None);
|
||||
}
|
||||
ensure!(
|
||||
@@ -241,7 +242,8 @@ pub fn context(
|
||||
.context("UPDATE_HEALTH_SERVICES_STARTED")?,
|
||||
)?;
|
||||
ensure!(
|
||||
matches!(event.evidence, Evidence::ServicesStarted { .. }),
|
||||
matches!(event.evidence, Evidence::ServicesStarted { .. }) && !rollback
|
||||
|| matches!(event.evidence, Evidence::RollbackServicesStarted { .. }) && rollback,
|
||||
"UPDATE_HEALTH_SERVICES_STARTED"
|
||||
);
|
||||
let (last, generation, fault, pending): (Option<String>, u64, Option<String>, Option<String>) =
|
||||
@@ -424,8 +426,14 @@ pub async fn request(
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
journal.prepare(
|
||||
u64::try_from(now.timestamp())?,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed.clone(),
|
||||
if journal.phase() == Phase::RollbackServicesStarted {
|
||||
Evidence::RollbackHealthVerified {
|
||||
receipt: signed.clone(),
|
||||
}
|
||||
} else {
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed.clone(),
|
||||
}
|
||||
},
|
||||
)?;
|
||||
ensure!(Instant::now() < context.deadline, "UPDATE_HEALTH_EXPIRED");
|
||||
|
||||
@@ -24,6 +24,9 @@ pub fn supported(job: &JobPayload) -> bool {
|
||||
)
|
||||
}
|
||||
pub fn supported_with_binding(job: &JobPayload, binding: Option<&Binding>) -> bool {
|
||||
if matches!(job.action, Action::UpdateAgent { .. }) {
|
||||
return binding.is_some_and(|b| crate::agent_update_apply::supported(b, job));
|
||||
}
|
||||
if rmm_privileged_helper::apt::is_apt_action(job) {
|
||||
// SAFETY: geteuid has no preconditions.
|
||||
return unsafe { libc::geteuid() } != 0
|
||||
|
||||
+51
-18
@@ -1,3 +1,4 @@
|
||||
mod agent_update_apply;
|
||||
mod agent_update_catalog;
|
||||
mod agent_update_health;
|
||||
mod apt;
|
||||
@@ -62,6 +63,7 @@ struct Agent<C: reconcile::SyncClock = reconcile::NativeClock> {
|
||||
certificates: certificate_rotation::RotationStore,
|
||||
rotation_policy: certificate_rotation::RotationPolicy,
|
||||
catalog: agent_update_catalog::Checker,
|
||||
update_observer: agent_update_apply::Observer,
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct EffectFence {
|
||||
@@ -428,6 +430,13 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
|| binding.verify(&request, Utc::now()).is_err()
|
||||
{
|
||||
jobs::no_start("failed", "START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT")
|
||||
} else if matches!(job.action, rmm_domain::jobs::Action::UpdateAgent { .. }) {
|
||||
match agent_update_apply::handoff(&binding, &request, grant.grant_id) {
|
||||
// Full now owns this original. The stable updater may
|
||||
// stop us. Reconciliation alone supplies its final result.
|
||||
Ok(_) => return,
|
||||
Err(_) => rmm_privileged_helper::Outcome::unknown("UPDATE_HANDOFF_UNCONFIRMED"),
|
||||
}
|
||||
} else if job.execution_identity == "root" {
|
||||
apt::invoke_with_control(&binding, &job, &request, || {
|
||||
ensure!(
|
||||
@@ -483,6 +492,9 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
}
|
||||
capabilities.extend(apt::capabilities(binding));
|
||||
capabilities.extend(helper_sync::general_capabilities(binding));
|
||||
if self.clock.trusted() {
|
||||
capabilities.extend(self.update_observer.capabilities());
|
||||
}
|
||||
}
|
||||
capabilities.sort();
|
||||
capabilities.dedup();
|
||||
@@ -530,18 +542,15 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
if !storage::passive_collection_ready(&self.db)? {
|
||||
return Ok(());
|
||||
}
|
||||
// Until the separately qualified protected updater/helper observer is
|
||||
// provisioned, report its real absence; never infer apply readiness from
|
||||
// this schema support or the agent's own code/build version.
|
||||
let observation = rmm_domain::agent_update::AgentUpdateObservation::not_configured(
|
||||
rmm_domain::agent_update::Platform::LinuxX64,
|
||||
Utc::now(),
|
||||
);
|
||||
let address = self.address;
|
||||
let ca = &self.ca;
|
||||
let certificates = &self.certificates;
|
||||
self.catalog
|
||||
.poll(self.binding.as_ref(), self.clock.clone(), address, || {
|
||||
self.catalog.poll(
|
||||
self.binding.as_ref(),
|
||||
self.clock.clone(),
|
||||
address,
|
||||
self.update_observer.catalog_record(),
|
||||
|| {
|
||||
let identity = certificates.current(Utc::now().timestamp())?;
|
||||
https_channel::mtls_client(
|
||||
address,
|
||||
@@ -549,7 +558,12 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
&identity.certificate_pem,
|
||||
&identity.private_key_pem,
|
||||
)
|
||||
});
|
||||
},
|
||||
);
|
||||
let observation = self.update_observer.poll(
|
||||
self.binding.as_ref(),
|
||||
self.catalog.candidate_envelope(Utc::now()),
|
||||
);
|
||||
let data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?;
|
||||
let envelope = self.envelope(
|
||||
generation,
|
||||
@@ -660,6 +674,8 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
let mut first_heartbeat = true;
|
||||
let mut health_task: Option<PendingUpdateHealth> = None;
|
||||
let mut health_inventory_prefix: Option<String> = None;
|
||||
let mut update_prefetch: Option<(JobOffer, agent_update_apply::Prefetch)> = None;
|
||||
let mut prefetched = std::collections::HashSet::new();
|
||||
loop {
|
||||
tokio::select! {
|
||||
Some(result) = self.inventory_rx.recv() => {
|
||||
@@ -742,6 +758,13 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
}
|
||||
_ = tick.tick() => {
|
||||
self.replay(&ws, generation).await?;
|
||||
if update_prefetch.as_ref().is_some_and(|(_,task)|task.0.is_finished()) {
|
||||
let (offer, mut task)=update_prefetch.take().context("UPDATE_PREFETCH_REQUIRED")?;
|
||||
match (&mut task.0).await {
|
||||
Ok(Ok(())) => {prefetched.insert((offer.job_id.clone(),offer.attempt_id.clone()));},
|
||||
_ => {self.record(generation,&offer,"",jobs::no_start("failed","UPDATE_ARTIFACT_PREFETCH_FAILED"))?;needs_sync=true;}
|
||||
}
|
||||
}
|
||||
let busy:bool=self.db.query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get(0))?;
|
||||
let update=self.update_proof()?;
|
||||
let pending_update=self.binding.as_ref().map(|binding|rmm_agent_core::jobs::needs_update_control(&self.db,&self.ledger,binding)).transpose()?.unwrap_or(false);
|
||||
@@ -749,7 +772,7 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
if let Some(proof)=&update {
|
||||
let decoded=proof.decode().map_err(anyhow::Error::msg)?;
|
||||
let event:Option<rmm_updater_handoff::Event>=decoded.events.last().map(|raw|serde_json::from_slice(raw)).transpose()?;
|
||||
if event.is_some_and(|event|matches!(event.evidence,rmm_updater_handoff::Evidence::ServicesStarted{..})) {
|
||||
if event.is_some_and(|event|matches!(event.evidence,rmm_updater_handoff::Evidence::ServicesStarted{..}|rmm_updater_handoff::Evidence::RollbackServicesStarted{..})) {
|
||||
if health_inventory_prefix.as_deref()!=Some(proof.head_sha256.as_str()) {
|
||||
// Fixed update health includes one genuinely new
|
||||
// normal base sample, never a fresh timestamp on old data.
|
||||
@@ -760,6 +783,13 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
}
|
||||
}
|
||||
}
|
||||
// Planning pins must be refreshed before the 90-second stored-data
|
||||
// planning limit. One inflight blocking collector bounds pressure;
|
||||
// heartbeats never perform this metadata work.
|
||||
if update_at.elapsed() >= Duration::from_secs(60) {
|
||||
self.queue_update_observation(generation)?;
|
||||
update_at = Instant::now();
|
||||
}
|
||||
if !busy && capability_at.elapsed()>=Duration::from_secs(60) {capability_at=Instant::now();if self.capabilities()!=advertised{return Ok(());}}
|
||||
if self.prepared.is_some() && (!busy||own_update) && health_task.is_none() && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;}
|
||||
if self.prepared.is_none() && self.sync.is_some() && (!busy||own_update) && health_task.is_none() && (needs_sync||sync_at.elapsed()>=Duration::from_secs(40)||!self.ready(generation,false)) {
|
||||
@@ -773,6 +803,15 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
} else if !self.ready(generation,job.execution_identity=="root") {
|
||||
needs_sync=true;
|
||||
} else if Utc::now() >= job.not_before {
|
||||
if matches!(job.action,rmm_domain::jobs::Action::UpdateAgent{..}) && !prefetched.contains(&(offer.job_id.clone(),offer.attempt_id.clone())) {
|
||||
if update_prefetch.is_none() {
|
||||
let identity=self.certificates.current(Utc::now().timestamp())?;
|
||||
let client=https_channel::mtls_client(self.address,&self.ca,&identity.certificate_pem,&identity.private_key_pem)?;
|
||||
let base=format!("https://{}:{}",https_channel::server_name()?,self.address.port());
|
||||
update_prefetch=Some((offer.clone(),agent_update_apply::Prefetch(tokio::spawn(agent_update_apply::prefetch(client,base,job)))));
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// Reserve before send. A lost response must never cause
|
||||
// a second permit request for this attempt.
|
||||
jobs::reserve_request(&self.db, &offer)?;
|
||||
@@ -808,13 +847,6 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
||||
heartbeat_at = Instant::now();
|
||||
heartbeat_after = Duration::from_millis(rand::random_range(27_000..33_000));
|
||||
}
|
||||
// Planning pins must be refreshed before the 90-second stored-data
|
||||
// planning limit. One inflight blocking collector bounds pressure;
|
||||
// heartbeats never perform this metadata work.
|
||||
if update_at.elapsed() >= Duration::from_secs(60) {
|
||||
self.queue_update_observation(generation)?;
|
||||
update_at = Instant::now();
|
||||
}
|
||||
if inventory_at.elapsed() >= Duration::from_secs(60) {
|
||||
self.queue_inventory();
|
||||
inventory_at = Instant::now();
|
||||
@@ -1017,6 +1049,7 @@ async fn main() -> Result<()> {
|
||||
certificates,
|
||||
rotation_policy,
|
||||
catalog: agent_update_catalog::Checker::default(),
|
||||
update_observer: agent_update_apply::Observer::default(),
|
||||
};
|
||||
agent.recover_interrupted()?;
|
||||
let mut backoff = 1_u64;
|
||||
|
||||
@@ -151,6 +151,7 @@ fn new_process_persists_interruption_before_helper_io_without_unlock_or_repeat()
|
||||
certificates,
|
||||
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
||||
catalog: agent_update_catalog::Checker::default(),
|
||||
update_observer: agent_update_apply::Observer::default(),
|
||||
};
|
||||
// A forged local consumption/start cannot become a purported grant result.
|
||||
agent
|
||||
@@ -539,6 +540,7 @@ async fn run(mode: wire_channel::Mode, trusted: bool, forged: bool, rounds: u64)
|
||||
certificates,
|
||||
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
||||
catalog: agent_update_catalog::Checker::default(),
|
||||
update_observer: agent_update_apply::Observer::default(),
|
||||
};
|
||||
for _ in 0..rounds {
|
||||
assert!(
|
||||
|
||||
@@ -9,8 +9,10 @@ pub mod readiness;
|
||||
pub mod reconcile;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
pub mod update_admission;
|
||||
pub mod update_control;
|
||||
pub mod update_guard;
|
||||
pub mod update_observer;
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::{DateTime, Utc};
|
||||
use openssl::pkey::{Id, PKey};
|
||||
|
||||
@@ -15,7 +15,7 @@ use std::{
|
||||
net::{UnixListener, UnixStream},
|
||||
},
|
||||
},
|
||||
path::PathBuf,
|
||||
path::{Path, PathBuf},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
@@ -133,6 +133,7 @@ impl Config {
|
||||
#[derive(Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum Incoming {
|
||||
UpdateObserve(rmm_privileged_helper::update_observer::Request),
|
||||
NativeUpdate(rmm_agent_core::update_handoff::NativeControlRequest),
|
||||
Control(control::Request),
|
||||
Probe(rmm_privileged_helper::readiness::Request),
|
||||
@@ -170,6 +171,17 @@ fn policy(config: &Config, job: &rmm_domain::jobs::JobPayload) -> Result<()> {
|
||||
job.execution_identity == "root",
|
||||
"HELPER_REQUIRES_EXPLICIT_ROOT_IDENTITY"
|
||||
);
|
||||
if matches!(job.action, Action::UpdateAgent { .. }) {
|
||||
ensure!(
|
||||
config.profile == HelperProfile::FullMaintenanceV1
|
||||
&& config.agent_uid == 993
|
||||
&& config.socket
|
||||
== std::path::Path::new("/run/rmm-helper-maintenance/control.sock")
|
||||
&& std::path::Path::new("/etc/rmm-agent-updater/policy.json").try_exists()?,
|
||||
"UPDATE_REQUIRES_SEPARATELY_PROVISIONED_FULL"
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
if rmm_privileged_helper::apt::is_apt_action(job) {
|
||||
ensure!(
|
||||
config.profile == HelperProfile::AptOnly,
|
||||
@@ -386,6 +398,44 @@ fn handle(
|
||||
ensure!(size <= 512 * 1024, "JOB_REQUEST_SIZE");
|
||||
request
|
||||
}
|
||||
Incoming::UpdateObserve(request) => {
|
||||
peer_allowed(stream, config.agent_uid)?;
|
||||
ensure!(
|
||||
size <= 65536
|
||||
&& config.profile == HelperProfile::FullMaintenanceV1
|
||||
&& config.agent_uid == 993
|
||||
&& config.socket == Path::new("/run/rmm-helper-maintenance/control.sock"),
|
||||
"UPDATE_OBSERVER_ONLY_FULL"
|
||||
);
|
||||
let guard = reconcile::ExecutorGuard::acquire(&config.state, 0)?;
|
||||
let key_path = config
|
||||
.signing_key_file
|
||||
.as_deref()
|
||||
.unwrap_or(Path::new("/etc/rmm-agent-updater/job-signing-key.json"));
|
||||
let policy = config.general_policy()?.sha256()?;
|
||||
let response = rmm_privileged_helper::update_observer::collect(
|
||||
db,
|
||||
rmm_privileged_helper::update_observer::Local {
|
||||
executor: &guard,
|
||||
binding: &config.binding,
|
||||
clock: update_clock.ok_or_else(|| anyhow::anyhow!("UPDATE_NOT_CONFIGURED"))?,
|
||||
sync,
|
||||
sync_clock,
|
||||
key_path,
|
||||
policy_sha256: &policy,
|
||||
helper_sha256: binary_sha256
|
||||
.as_deref()
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_FULL_BINARY_PIN_REQUIRED"))?,
|
||||
},
|
||||
&request,
|
||||
)?;
|
||||
peer_allowed(stream, config.agent_uid)?;
|
||||
let bytes = serde_json::to_vec(&response)?;
|
||||
ensure!(bytes.len() <= 192 * 1024, "UPDATE_OBSERVER_REPLY_LIMIT");
|
||||
stream.write_all(&u32::try_from(bytes.len())?.to_be_bytes())?;
|
||||
stream.write_all(&bytes)?;
|
||||
return Ok(());
|
||||
}
|
||||
Incoming::Control(request) => {
|
||||
peer_allowed(stream, config.agent_uid)?;
|
||||
let (challenge, identity) = request.binding();
|
||||
@@ -534,6 +584,65 @@ fn handle(
|
||||
// Both profiles use these exact same inodes, locked per effect rather than
|
||||
// daemon lifetime so the dedicated and general helper can coexist.
|
||||
let resource = reconcile::ExecutorGuard::acquire(&config.state, 0)?;
|
||||
if matches!(job.action, Action::UpdateAgent { .. }) {
|
||||
let consumed: bool = db.query_row("SELECT EXISTS(SELECT 1 FROM consumed WHERE grant_id=?1 OR (agent=?2 AND generation=?3 AND job=?4 AND attempt=?5))",
|
||||
rusqlite::params![permit.grant_id.to_string(),permit.agent_id.to_string(),permit.enrollment_generation,permit.job_id.to_string(),permit.attempt_id.to_string()],|r|r.get(0))?;
|
||||
ensure!(!consumed, "UPDATE_ALREADY_CONSUMED_NO_REDISPATCH");
|
||||
let key_path = config
|
||||
.signing_key_file
|
||||
.clone()
|
||||
.unwrap_or_else(|| PathBuf::from("/etc/rmm-agent-updater/job-signing-key.json"));
|
||||
private_path(&key_path, 0, false)?;
|
||||
ensure!(
|
||||
fs::metadata(&key_path)?.len() <= 4096,
|
||||
"UPDATE_JOB_KEY_RECORD_LIMIT"
|
||||
);
|
||||
let key = rmm_privileged_helper::SigningKey::read(&key_path, 0)?;
|
||||
ensure!(
|
||||
key.public_key_hex == config.binding.public_key_hex,
|
||||
"UPDATE_LOCAL_JOB_KEY_CHANGED"
|
||||
);
|
||||
let key_hash = rmm_domain::jobs::hash(&fs::read(&key_path)?);
|
||||
let prepared = rmm_privileged_helper::update_admission::Prepared::new(
|
||||
db,
|
||||
rmm_privileged_helper::update_admission::Local {
|
||||
executor: &resource,
|
||||
binding: &config.binding,
|
||||
clock: update_clock.ok_or_else(|| anyhow::anyhow!("UPDATE_NOT_CONFIGURED"))?,
|
||||
job_key_path: &key_path,
|
||||
job_key_raw_sha256: &key_hash,
|
||||
},
|
||||
&request,
|
||||
)?;
|
||||
peer_allowed(stream, config.agent_uid)?;
|
||||
let mut probe = 0u8;
|
||||
// Preparation may copy sizeable exact artifacts. Recheck the actual
|
||||
// caller at the original consumption boundary without consuming bytes.
|
||||
// SAFETY: live socket and a writable byte; MSG_PEEK leaves input intact.
|
||||
let available = unsafe {
|
||||
libc::recv(
|
||||
stream.as_raw_fd(),
|
||||
(&mut probe as *mut u8).cast(),
|
||||
1,
|
||||
libc::MSG_PEEK | libc::MSG_DONTWAIT,
|
||||
)
|
||||
};
|
||||
ensure!(
|
||||
available < 0
|
||||
&& std::io::Error::last_os_error().kind() == std::io::ErrorKind::WouldBlock,
|
||||
"UPDATE_CALLER_CANCELLED_OR_DISCONNECTED"
|
||||
);
|
||||
let accepted = prepared.consume(db, sync, sync_clock)?;
|
||||
let bytes = serde_json::to_vec(&accepted)?;
|
||||
ensure!(bytes.len() <= 4096, "UPDATE_HANDOFF_ACK_LIMIT");
|
||||
stream.write_all(&u32::try_from(bytes.len())?.to_be_bytes())?;
|
||||
stream.write_all(&bytes)?;
|
||||
stream.flush()?;
|
||||
// Full resumes its listener immediately after this once-only Activate
|
||||
// reply. The worker then reads this same original ledger via Full before
|
||||
// it may stop Agent/General/Full. This is never a final job Outcome.
|
||||
return prepared.dispatch_after_reply();
|
||||
}
|
||||
let previous: Option<Option<Vec<u8>>> = db
|
||||
.query_row(
|
||||
"SELECT COALESCE(result,(SELECT outcome FROM execution_evidence WHERE execution_evidence.grant_id=consumed.grant_id)) FROM consumed WHERE grant_id=?1",
|
||||
|
||||
@@ -0,0 +1,767 @@
|
||||
//! PRE-consumption Full admission. Protected local provisioning and exact
|
||||
//! approved artifact bytes are verified before the ordinary HelperSync gate
|
||||
//! atomically writes the original consumption/start/handoff/delegation.
|
||||
use crate::{
|
||||
Binding, Request,
|
||||
reconcile::{self, ExecutorGuard},
|
||||
};
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::{DateTime, Utc};
|
||||
use rmm_agent_core::{
|
||||
helper_reconcile::ExecutorLedgerGuard,
|
||||
reconcile::SyncClock,
|
||||
update_handoff::{PreparedHandoff, UpdateAdmissionGuard},
|
||||
};
|
||||
use rmm_domain::{
|
||||
agent_update::{
|
||||
ParticipantIdentity, ParticipantRole, PeerPinTransition, ResolvedAgentUpdate,
|
||||
UpdateDelegation,
|
||||
},
|
||||
jobs::{Action, JobPayload, hash},
|
||||
};
|
||||
use rmm_updater_handoff::{
|
||||
AttemptBinding, CodePair, FileRole, FileTransition, Handoff, PinTransition,
|
||||
};
|
||||
use rmm_updater_linux::{
|
||||
Budget,
|
||||
files::{Directory, HeldFile, Identity, LedgerIdentity, Role, StageDescriptor, Staged},
|
||||
ipc,
|
||||
services::{HeldService, Service, ServicePolicy, Systemd},
|
||||
};
|
||||
use rmm_updater_worker::{
|
||||
bundle,
|
||||
clock::NativeClock,
|
||||
files::FileWitnesses,
|
||||
full::FullFiles,
|
||||
reader_registry::QualifiedRegistry,
|
||||
retained::{RetainedFileSpec, RetainedSet, Retention},
|
||||
trust::TrustState,
|
||||
};
|
||||
use rusqlite::Connection;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
ffi::OsStr,
|
||||
fs::{File, OpenOptions},
|
||||
os::unix::{
|
||||
fs::{MetadataExt, OpenOptionsExt},
|
||||
net::UnixStream,
|
||||
},
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
use uuid::Uuid;
|
||||
|
||||
/// Nonterminal acknowledgement only. Agent must keep the original job running
|
||||
/// without storing an Outcome; the worker may now stop the Agent and Full.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Accepted {
|
||||
pub schema_version: u32,
|
||||
pub operation: String,
|
||||
pub grant_id: Uuid,
|
||||
pub owner_nonce: Uuid,
|
||||
pub handoff_sha256: String,
|
||||
pub original_request_sha256: String,
|
||||
pub ready: bool,
|
||||
pub terminal: bool,
|
||||
}
|
||||
impl Accepted {
|
||||
pub fn matches(&self, request: &Request, grant: Uuid) -> Result<()> {
|
||||
ensure!(
|
||||
self.schema_version == 1
|
||||
&& self.operation == "agent_update_handoff_accepted_v1"
|
||||
&& self.grant_id == grant
|
||||
&& !self.owner_nonce.is_nil()
|
||||
&& rmm_domain::agent_update::digest(&self.handoff_sha256)
|
||||
&& self.original_request_sha256 == hash(&serde_json::to_vec(request)?)
|
||||
&& !self.ready
|
||||
&& !self.terminal,
|
||||
"UPDATE_TYPED_HANDOFF_ACK"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
struct Protected {
|
||||
directory: Directory,
|
||||
file: HeldFile,
|
||||
path: PathBuf,
|
||||
maximum: u64,
|
||||
}
|
||||
impl Protected {
|
||||
fn read(path: &Path, maximum: u64) -> Result<(Self, Vec<u8>)> {
|
||||
let directory =
|
||||
Directory::open(path.parent().context("UPDATE_ADMISSION_PARENT")?, 0, false)?;
|
||||
let mut file = directory.inspect(
|
||||
path.file_name().context("UPDATE_ADMISSION_NAME")?,
|
||||
0,
|
||||
maximum,
|
||||
)?;
|
||||
let bytes = file.bytes(maximum)?;
|
||||
Ok((
|
||||
Self {
|
||||
directory,
|
||||
file,
|
||||
path: path.into(),
|
||||
maximum,
|
||||
},
|
||||
bytes,
|
||||
))
|
||||
}
|
||||
fn verify(&self) -> Result<()> {
|
||||
self.directory.file(
|
||||
self.path.file_name().context("UPDATE_ADMISSION_NAME")?,
|
||||
self.file.proof(),
|
||||
self.maximum,
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
fn identity(m: &std::fs::Metadata) -> Identity {
|
||||
Identity {
|
||||
device: m.dev(),
|
||||
inode: m.ino(),
|
||||
uid: m.uid(),
|
||||
gid: m.gid(),
|
||||
mode: m.mode(),
|
||||
links: m.nlink(),
|
||||
}
|
||||
}
|
||||
fn participant(service: &HeldService) -> Result<ParticipantIdentity> {
|
||||
let p = service.proof();
|
||||
ensure!(p.process.uid == 0, "UPDATE_ADMISSION_ROOT_PARTICIPANT");
|
||||
if p.service == Service::Updater {
|
||||
ensure!(p.process.gid == 0, "UPDATE_STABLE_UPDATER_GROUP");
|
||||
}
|
||||
let role = match p.service {
|
||||
Service::Full => ParticipantRole::LinuxFullHelper,
|
||||
Service::Updater => ParticipantRole::LinuxUpdater,
|
||||
_ => anyhow::bail!("UPDATE_ADMISSION_PARTICIPANT_ROLE"),
|
||||
};
|
||||
Ok(ParticipantIdentity {
|
||||
role,
|
||||
pid: p.process.pid,
|
||||
birth: p.process.birth,
|
||||
image_sha256: p.process.image_sha256.clone(),
|
||||
security_principal: "uid:0".into(),
|
||||
service_instance_sha256: hash(&serde_json::to_vec(p)?),
|
||||
})
|
||||
}
|
||||
pub struct Local<'a> {
|
||||
pub executor: &'a ExecutorGuard,
|
||||
pub binding: &'a Binding,
|
||||
pub clock: &'a NativeClock,
|
||||
pub job_key_path: &'a Path,
|
||||
pub job_key_raw_sha256: &'a str,
|
||||
}
|
||||
pub struct Prepared<'a> {
|
||||
local: Local<'a>,
|
||||
request: Request,
|
||||
update: ResolvedAgentUpdate,
|
||||
header: Handoff,
|
||||
delegation: UpdateDelegation,
|
||||
trust: TrustState,
|
||||
registry: QualifiedRegistry,
|
||||
files: FileWitnesses,
|
||||
retained: RetainedSet,
|
||||
ledger: LedgerIdentity,
|
||||
ledger_file: File,
|
||||
ledger_directory: Directory,
|
||||
sqlite_handle: usize,
|
||||
full: HeldService,
|
||||
updater: HeldService,
|
||||
full_files: RefCell<FullFiles>,
|
||||
_stages: [Staged; 4],
|
||||
protected: Vec<Protected>,
|
||||
budget: Budget,
|
||||
}
|
||||
impl<'a> Prepared<'a> {
|
||||
pub fn new(db: &Connection, local: Local<'a>, request: &Request) -> Result<Self> {
|
||||
local.executor.check(db)?;
|
||||
let (job, permit) = local.binding.verify(request, local.clock.now()?)?;
|
||||
let Action::UpdateAgent { update } = &job.action else {
|
||||
anyhow::bail!("UPDATE_ACTION_REQUIRED")
|
||||
};
|
||||
ensure!(
|
||||
job.execution_identity == "root" && update.validate() && job.max_runtime_seconds == 600,
|
||||
"UPDATE_ADMISSION_ACTION"
|
||||
);
|
||||
let trust = TrustState::load_prepared(update, local.binding, local.clock)?;
|
||||
trust.qualify_history(db, local.executor, local.binding)?;
|
||||
let boot: Uuid = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?
|
||||
.trim()
|
||||
.parse()?;
|
||||
// This is preparation time within the existing start window, not a new
|
||||
// 600s execution lease. The immutable 600s handoff is stamped last.
|
||||
let budget = Budget::new(boot, (permit.start_before - local.clock.now()?).to_std()?)?;
|
||||
let registry = QualifiedRegistry::load(trust.policy())?;
|
||||
registry.verify_admission(trust.policy(), &budget)?;
|
||||
let policies = trust
|
||||
.policy()
|
||||
.services
|
||||
.iter()
|
||||
.zip([
|
||||
Service::Agent,
|
||||
Service::General,
|
||||
Service::Full,
|
||||
Service::Apt,
|
||||
])
|
||||
.map(|(pin, service)| ServicePolicy {
|
||||
service,
|
||||
unit_sha256: pin.unit_sha256.clone(),
|
||||
image_sha256: if service == Service::Agent {
|
||||
update.predecessor.agent_sha256.clone()
|
||||
} else {
|
||||
update.predecessor.helper_sha256.clone()
|
||||
},
|
||||
})
|
||||
.collect();
|
||||
let services = Systemd::new(policies)?;
|
||||
let full = services.observe(Service::Full, &budget)?;
|
||||
ensure!(
|
||||
full.proof().process.pid == std::process::id(),
|
||||
"UPDATE_ACTUAL_FULL_PROCESS_REQUIRED"
|
||||
);
|
||||
let updater = Systemd::observe_updater(
|
||||
ServicePolicy {
|
||||
service: Service::Updater,
|
||||
image_sha256: update.updater.binary_sha256.clone(),
|
||||
unit_sha256: trust.policy().updater_service.unit_sha256.clone(),
|
||||
},
|
||||
&budget,
|
||||
)?;
|
||||
let description = ipc::exchange(
|
||||
UnixStream::connect("/run/rmm-agent-updater/control.sock")?,
|
||||
&updater,
|
||||
&budget,
|
||||
&ipc::Request::Describe {},
|
||||
)?;
|
||||
ensure!(
|
||||
matches!(description.state, ipc::State::Described)
|
||||
&& description.updater == participant(&updater)?
|
||||
&& description.head_sha256.is_none(),
|
||||
"UPDATE_ADMISSION_LIVE_UPDATER"
|
||||
);
|
||||
let nonce = Uuid::new_v4();
|
||||
let manifest = update.manifest().map_err(anyhow::Error::msg)?;
|
||||
let agent = stage_download(
|
||||
&job,
|
||||
Role::Agent,
|
||||
&manifest.artifacts[0].sha256,
|
||||
manifest.artifacts[0].bytes,
|
||||
nonce,
|
||||
&budget,
|
||||
)?;
|
||||
let helper = stage_download(
|
||||
&job,
|
||||
Role::Helper,
|
||||
&manifest.artifacts[1].sha256,
|
||||
manifest.artifacts[1].bytes,
|
||||
nonce,
|
||||
&budget,
|
||||
)?;
|
||||
let mut full_files = FullFiles::open(
|
||||
update,
|
||||
local.job_key_path,
|
||||
local.job_key_raw_sha256,
|
||||
&budget,
|
||||
)?;
|
||||
let [full_config, full_pin] = full_files.stage(nonce, &budget)?;
|
||||
let stages = [agent, helper, full_config, full_pin];
|
||||
let files = FileWitnesses::capture(&stages, nonce, &budget)?;
|
||||
let (retained_config, raw) = Protected::read(
|
||||
Path::new("/etc/rmm-agent-updater/retained-files.json"),
|
||||
65536,
|
||||
)?;
|
||||
let mut specs: Vec<RetainedFileSpec> = serde_json::from_slice(&raw)?;
|
||||
for (path, retention) in [
|
||||
(
|
||||
"/var/lib/rmm-agent-remote/journal.sqlite",
|
||||
Retention::MutableDatabase,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-agent-remote/consumption.sqlite",
|
||||
Retention::MutableDatabase,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-agent-remote/agent.lock",
|
||||
Retention::ImmutableMetadata,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-helper/consumption.sqlite",
|
||||
Retention::MutableDatabase,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-helper/executor.lock",
|
||||
Retention::ImmutableMetadata,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-agent-remote/identity.json",
|
||||
Retention::ImmutableMetadata,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-agent-remote/device.key",
|
||||
Retention::ImmutableMetadata,
|
||||
),
|
||||
(
|
||||
"/var/lib/rmm-agent-remote/device.pem",
|
||||
Retention::ImmutableMetadata,
|
||||
),
|
||||
] {
|
||||
ensure!(
|
||||
specs
|
||||
.iter()
|
||||
.any(|s| s.path == Path::new(path) && s.retention == retention),
|
||||
"UPDATE_MANDATORY_RETAINED_STATE"
|
||||
);
|
||||
}
|
||||
ensure!(
|
||||
specs.iter().any(
|
||||
|s| s.path == local.job_key_path && s.retention == Retention::ImmutableMetadata
|
||||
),
|
||||
"UPDATE_RETAINED_JOB_KEY_REQUIRED"
|
||||
);
|
||||
retain_active_tls(&mut specs, local.binding)?;
|
||||
let retained = RetainedSet::capture(specs)?;
|
||||
let ledger_directory = Directory::open(Path::new("/var/lib/rmm-helper"), 0, true)?;
|
||||
let ledger_file = OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_CLOEXEC)
|
||||
.open("/var/lib/rmm-helper/consumption.sqlite")?;
|
||||
let ledger = LedgerIdentity {
|
||||
ledger: identity(&ledger_file.metadata()?),
|
||||
lock: identity(&local.executor._file.metadata()?),
|
||||
};
|
||||
ensure!(
|
||||
ledger.ledger
|
||||
== identity(&std::fs::symlink_metadata(
|
||||
"/var/lib/rmm-helper/consumption.sqlite"
|
||||
)?)
|
||||
&& ledger.lock
|
||||
== identity(&std::fs::symlink_metadata(
|
||||
"/var/lib/rmm-helper/executor.lock"
|
||||
)?),
|
||||
"UPDATE_ADMISSION_LEDGER_IDENTITIES"
|
||||
);
|
||||
let (general, raw) =
|
||||
Protected::read(Path::new("/etc/rmm-remote/general-helper-proof.json"), 8192)?;
|
||||
let PeerPinTransition::LinuxGeneralFullV1 {
|
||||
general_pin_sha256,
|
||||
full: transition,
|
||||
} = &update.peer_pin_transition
|
||||
else {
|
||||
anyhow::bail!("UPDATE_FULL_TRANSITION_REQUIRED")
|
||||
};
|
||||
ensure!(
|
||||
hash(&raw) == *general_pin_sha256,
|
||||
"UPDATE_GENERAL_PIN_CHANGED"
|
||||
);
|
||||
let (helper_journal,checkpoint,decision,agent_journal,generation):(String,u64,String,String,u64)=db.query_row(
|
||||
"SELECT journal_id,checkpoint,last_decision,agent_journal_id,generation FROM helper_sync_meta WHERE id=1 AND fault IS NULL",[],
|
||||
|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?)))?;
|
||||
let mut stop_set = vec![
|
||||
rmm_updater_handoff::Service::LinuxAgent,
|
||||
rmm_updater_handoff::Service::LinuxGeneralHelper,
|
||||
rmm_updater_handoff::Service::LinuxFullHelper,
|
||||
];
|
||||
if trust
|
||||
.policy()
|
||||
.services
|
||||
.iter()
|
||||
.any(|pin| pin.unit == Service::Apt.unit())
|
||||
{
|
||||
stop_set.push(rmm_updater_handoff::Service::LinuxAptHelper);
|
||||
}
|
||||
let now = local.clock.now()?;
|
||||
let consumed_at = u64::try_from(now.timestamp())?;
|
||||
let start = rmm_agent_core::ledger::start_witness_bytes(&permit, request, boot, now)?;
|
||||
let header = Handoff {
|
||||
schema_version: 2,
|
||||
attempt: AttemptBinding {
|
||||
tenant_id: permit.tenant_id,
|
||||
asset_id: permit.asset_id,
|
||||
agent_id: permit.agent_id,
|
||||
enrollment_generation: permit.enrollment_generation,
|
||||
assignment_version: permit.assignment_version,
|
||||
plan_id: permit
|
||||
.agent_update_plan_id
|
||||
.context("UPDATE_PLAN_ID_REQUIRED")?,
|
||||
plan_sha256: permit.plan_hash.clone(),
|
||||
job_id: permit.job_id,
|
||||
attempt_id: permit.attempt_id,
|
||||
job_payload_sha256: permit.job_payload_hash.clone(),
|
||||
grant_id: permit.grant_id,
|
||||
authorization_id: permit.authorization_id,
|
||||
original_request_sha256: hash(&serde_json::to_vec(request)?),
|
||||
original_start_witness_sha256: hash(&start),
|
||||
},
|
||||
agent_journal_id: agent_journal.parse()?,
|
||||
helper_journal_id: helper_journal.parse()?,
|
||||
helper_checkpoint: checkpoint,
|
||||
previous_decision_id: decision.parse()?,
|
||||
boot_id: boot,
|
||||
connection_generation: generation,
|
||||
owner_nonce: nonce,
|
||||
updater_sha256: update.updater.binary_sha256.clone(),
|
||||
updater_policy_sha256: update.updater.policy_sha256.clone(),
|
||||
predecessor_record_sha256: update.predecessor.installed_record_sha256.clone(),
|
||||
retained_state_sha256: retained.sha256().into(),
|
||||
ledger_identity_sha256: ledger.sha256()?,
|
||||
staged_files_sha256: files.sha256().into(),
|
||||
predecessor: CodePair {
|
||||
manifest_sha256: update.predecessor.manifest_sha256.clone(),
|
||||
agent_sha256: update.predecessor.agent_sha256.clone(),
|
||||
helper_sha256: update.predecessor.helper_sha256.clone(),
|
||||
pin_sha256: transition.old_pin_sha256.clone(),
|
||||
},
|
||||
target: CodePair {
|
||||
manifest_sha256: update.manifest_sha256.clone(),
|
||||
agent_sha256: manifest.artifacts[0].sha256.clone(),
|
||||
helper_sha256: manifest.artifacts[1].sha256.clone(),
|
||||
pin_sha256: transition.new_pin_sha256.clone(),
|
||||
},
|
||||
pin_transition: PinTransition::LinuxGeneralFullV1,
|
||||
pin_transition_sha256: hash(&serde_json::to_vec(&update.peer_pin_transition)?),
|
||||
files: vec![
|
||||
FileTransition {
|
||||
role: FileRole::AgentBinary,
|
||||
old_sha256: update.predecessor.agent_sha256.clone(),
|
||||
new_sha256: manifest.artifacts[0].sha256.clone(),
|
||||
},
|
||||
FileTransition {
|
||||
role: FileRole::HelperBinary,
|
||||
old_sha256: update.predecessor.helper_sha256.clone(),
|
||||
new_sha256: manifest.artifacts[1].sha256.clone(),
|
||||
},
|
||||
FileTransition {
|
||||
role: FileRole::LinuxFullConfig,
|
||||
old_sha256: transition.old_config_sha256.clone(),
|
||||
new_sha256: transition.new_config_sha256.clone(),
|
||||
},
|
||||
FileTransition {
|
||||
role: FileRole::LinuxFullPin,
|
||||
old_sha256: transition.old_pin_sha256.clone(),
|
||||
new_sha256: transition.new_pin_sha256.clone(),
|
||||
},
|
||||
],
|
||||
stop_set,
|
||||
consumed_at,
|
||||
finish_before: consumed_at
|
||||
.checked_add(600)
|
||||
.context("UPDATE_FINISH_OVERFLOW")?,
|
||||
};
|
||||
let delegation = UpdateDelegation {
|
||||
schema_version: 1,
|
||||
boot_id: boot,
|
||||
owner_nonce: nonce,
|
||||
handoff_sha256: hash(&header.bytes()?),
|
||||
original_helper: participant(&full)?,
|
||||
updater: participant(&updater)?,
|
||||
prepared_at: now,
|
||||
};
|
||||
bundle::write_before_handoff(
|
||||
&header,
|
||||
&files,
|
||||
&retained,
|
||||
&ledger,
|
||||
bundle::Participants {
|
||||
delegation: &delegation,
|
||||
original_full: &full,
|
||||
updater: &updater,
|
||||
budget: &budget,
|
||||
},
|
||||
)?;
|
||||
let prepared = Self {
|
||||
local,
|
||||
request: request.clone(),
|
||||
update: update.as_ref().clone(),
|
||||
header,
|
||||
delegation,
|
||||
trust,
|
||||
registry,
|
||||
files,
|
||||
retained,
|
||||
ledger,
|
||||
ledger_file,
|
||||
ledger_directory,
|
||||
sqlite_handle: unsafe { db.handle() } as usize,
|
||||
full,
|
||||
updater,
|
||||
full_files: RefCell::new(full_files),
|
||||
_stages: stages,
|
||||
protected: vec![retained_config, general],
|
||||
budget,
|
||||
};
|
||||
prepared.check(db)?;
|
||||
Ok(prepared)
|
||||
}
|
||||
pub fn consume(
|
||||
&self,
|
||||
db: &mut Connection,
|
||||
sync: &mut reconcile::HelperSync,
|
||||
clock: &reconcile::NativeClock,
|
||||
) -> Result<Accepted> {
|
||||
let prepared = PreparedHandoff {
|
||||
request: &self.request,
|
||||
handoff: &self.header,
|
||||
delegation: &self.delegation,
|
||||
recorded_at: self.delegation.prepared_at,
|
||||
};
|
||||
sync.begin_update_handoff(
|
||||
db,
|
||||
self,
|
||||
self.header.connection_generation,
|
||||
&prepared,
|
||||
clock,
|
||||
&reconcile::NativeBoot,
|
||||
)?;
|
||||
Ok(Accepted {
|
||||
schema_version: 1,
|
||||
operation: "agent_update_handoff_accepted_v1".into(),
|
||||
grant_id: self.header.attempt.grant_id,
|
||||
owner_nonce: self.header.owner_nonce,
|
||||
handoff_sha256: hash(&self.header.bytes()?),
|
||||
original_request_sha256: self.header.attempt.original_request_sha256.clone(),
|
||||
ready: false,
|
||||
terminal: false,
|
||||
})
|
||||
}
|
||||
/// Exactly once, AFTER the caller flushed Accepted and before returning to
|
||||
/// Full's listener. A transport error is not retried and creates no Outcome.
|
||||
pub fn dispatch_after_reply(self) -> Result<()> {
|
||||
let response = ipc::exchange(
|
||||
UnixStream::connect("/run/rmm-agent-updater/control.sock")?,
|
||||
&self.updater,
|
||||
&self.budget,
|
||||
&ipc::Request::Activate {
|
||||
grant_id: self.header.attempt.grant_id,
|
||||
owner_nonce: self.header.owner_nonce,
|
||||
handoff_sha256: hash(&self.header.bytes()?),
|
||||
},
|
||||
)?;
|
||||
ensure!(
|
||||
matches!(response.state, ipc::State::Inflight),
|
||||
"UPDATE_ACTIVATION_ACK_REQUIRED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl ExecutorLedgerGuard for Prepared<'_> {
|
||||
fn check(&self, db: &Connection) -> Result<()> {
|
||||
self.local.executor.check(db)?;
|
||||
ensure!(
|
||||
unsafe { db.handle() } as usize == self.sqlite_handle,
|
||||
"UPDATE_PREPARED_SAME_CONNECTION"
|
||||
);
|
||||
self.ledger_directory.verify()?;
|
||||
ensure!(
|
||||
identity(&self.ledger_file.metadata()?) == self.ledger.ledger
|
||||
&& identity(&std::fs::symlink_metadata(
|
||||
"/var/lib/rmm-helper/consumption.sqlite"
|
||||
)?) == self.ledger.ledger
|
||||
&& identity(&self.local.executor._file.metadata()?) == self.ledger.lock
|
||||
&& identity(&std::fs::symlink_metadata(
|
||||
"/var/lib/rmm-helper/executor.lock"
|
||||
)?) == self.ledger.lock,
|
||||
"UPDATE_PREPARED_SAME_LEDGER_AND_LOCK"
|
||||
);
|
||||
self.budget.check()
|
||||
}
|
||||
}
|
||||
impl UpdateAdmissionGuard for Prepared<'_> {
|
||||
fn health_public_key(&self) -> Result<[u8; 32]> {
|
||||
Ok(self.trust.health_public_key())
|
||||
}
|
||||
fn verify_prepared_update(
|
||||
&self,
|
||||
request: &Request,
|
||||
handoff: &Handoff,
|
||||
delegation: &UpdateDelegation,
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<()> {
|
||||
ensure!(
|
||||
serde_json::to_vec(request)? == serde_json::to_vec(&self.request)?
|
||||
&& handoff.bytes()? == self.header.bytes()?
|
||||
&& serde_json::to_vec(delegation)? == serde_json::to_vec(&self.delegation)?
|
||||
&& now == self.delegation.prepared_at,
|
||||
"UPDATE_PREPARED_ORIGINAL_BYTES_CHANGED"
|
||||
);
|
||||
self.budget.check()?;
|
||||
self.local
|
||||
.binding
|
||||
.verify(request, self.local.clock.now()?)?;
|
||||
self.trust
|
||||
.recheck_prepared(&self.update, self.local.clock)?;
|
||||
self.registry.verify_protected()?;
|
||||
self.full.verify(&self.budget)?;
|
||||
self.updater.verify(&self.budget)?;
|
||||
ensure!(
|
||||
participant(&self.full)? == delegation.original_helper
|
||||
&& participant(&self.updater)? == delegation.updater,
|
||||
"UPDATE_PREPARED_PARTICIPANTS_CHANGED"
|
||||
);
|
||||
self.full_files.borrow_mut().verify_original(&self.budget)?;
|
||||
self.files.reopen_stages(&self.header, &self.budget)?;
|
||||
self.retained.verify()?;
|
||||
for protected in &self.protected {
|
||||
protected.verify()?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
/// Metadata only for the currently selected TLS pair. Never read or export key
|
||||
/// bytes, and never require a bootstrap rewrite after normal TLS rotation.
|
||||
fn retain_active_tls(specs: &mut Vec<RetainedFileSpec>, binding: &Binding) -> Result<()> {
|
||||
let base = Path::new("/var/lib/rmm-agent-remote/certificates");
|
||||
let dir = Directory::open_agent_state(base)?;
|
||||
let mut selector = dir.inspect(OsStr::new("current.json"), 993, 4096)?;
|
||||
let raw = selector.bytes(4096)?;
|
||||
let value: serde_json::Value = serde_json::from_slice(&raw)?;
|
||||
ensure!(
|
||||
value["schema_version"] == 1
|
||||
&& value["agent_id"] == binding.agent_id.to_string()
|
||||
&& value["enrollment_generation"] == binding.enrollment_generation,
|
||||
"UPDATE_TLS_SELECTOR_IDENTITY"
|
||||
);
|
||||
let version: Uuid = value["version"]
|
||||
.as_str()
|
||||
.context("UPDATE_TLS_SELECTOR_VERSION")?
|
||||
.parse()?;
|
||||
for path in [
|
||||
base.join("current.json"),
|
||||
base.join("versions")
|
||||
.join(version.to_string())
|
||||
.join("device.key"),
|
||||
base.join("versions")
|
||||
.join(version.to_string())
|
||||
.join("device.pem"),
|
||||
] {
|
||||
let parent = path.parent().context("UPDATE_TLS_PARENT")?;
|
||||
Directory::open_agent_state(parent)?.verify()?;
|
||||
let m = std::fs::symlink_metadata(&path)?;
|
||||
ensure!(
|
||||
m.is_file()
|
||||
&& !m.file_type().is_symlink()
|
||||
&& m.uid() == 993
|
||||
&& m.mode() & 0o777 == 0o600
|
||||
&& m.nlink() == 1,
|
||||
"UPDATE_TLS_RETAINED_METADATA"
|
||||
);
|
||||
let spec = RetainedFileSpec {
|
||||
path,
|
||||
parent_uid: 993,
|
||||
identity: identity(&m),
|
||||
retention: Retention::ImmutableMetadata,
|
||||
};
|
||||
if let Some(existing) = specs.iter().find(|s| s.path == spec.path) {
|
||||
ensure!(existing == &spec, "UPDATE_TLS_RETAINED_SELECTOR_CHANGED");
|
||||
} else {
|
||||
specs.push(spec);
|
||||
}
|
||||
}
|
||||
dir.file(OsStr::new("current.json"), selector.proof(), 4096)?;
|
||||
Ok(())
|
||||
}
|
||||
fn stage_download(
|
||||
job: &JobPayload,
|
||||
role: Role,
|
||||
expected: &str,
|
||||
length: u64,
|
||||
nonce: Uuid,
|
||||
budget: &Budget,
|
||||
) -> Result<Staged> {
|
||||
let label = match role {
|
||||
Role::Agent => "agent.bin",
|
||||
Role::Helper => "helper.bin",
|
||||
_ => anyhow::bail!("UPDATE_DOWNLOAD_ROLE"),
|
||||
};
|
||||
let parent = Path::new("/var/lib/rmm-agent-remote/update-downloads")
|
||||
.join(job.job_id.to_string())
|
||||
.join(job.attempt_id.to_string());
|
||||
let source_directory = Directory::open_agent_state(&parent)?;
|
||||
let mut source = source_directory.inspect(OsStr::new(label), 993, 256 * 1024 * 1024)?;
|
||||
ensure!(
|
||||
source.proof().bytes == length
|
||||
&& source.proof().sha256 == expected
|
||||
&& source.proof().identity.links == 1
|
||||
&& source.proof().identity.mode & 0o777 == 0o600,
|
||||
"UPDATE_PREFETCH_BYTES_REQUIRED"
|
||||
);
|
||||
let target = Path::new(role.target());
|
||||
let directory = Directory::open(target.parent().context("UPDATE_TARGET_PARENT")?, 0, false)?;
|
||||
let original = directory.inspect(
|
||||
target.file_name().context("UPDATE_TARGET_NAME")?,
|
||||
0,
|
||||
256 * 1024 * 1024,
|
||||
)?;
|
||||
let Action::UpdateAgent { update } = &job.action else {
|
||||
anyhow::bail!("UPDATE_ACTION_REQUIRED")
|
||||
};
|
||||
ensure!(
|
||||
original.proof().sha256.as_str()
|
||||
== match role {
|
||||
Role::Agent => update.predecessor.agent_sha256.as_str(),
|
||||
Role::Helper => update.predecessor.helper_sha256.as_str(),
|
||||
_ => unreachable!(),
|
||||
},
|
||||
"UPDATE_PREDECESSOR_IMAGE_CHANGED"
|
||||
);
|
||||
let staged = Staged::write(
|
||||
&directory,
|
||||
StageDescriptor {
|
||||
role,
|
||||
nonce,
|
||||
original: original.proof(),
|
||||
expected_sha: expected,
|
||||
length,
|
||||
},
|
||||
source.reader()?,
|
||||
budget,
|
||||
)?;
|
||||
source_directory.file(OsStr::new(label), source.proof(), 256 * 1024 * 1024)?;
|
||||
Ok(staged)
|
||||
}
|
||||
|
||||
// Passive helper RPC client; it never creates a handoff.
|
||||
pub use crate::update_observer::{observe, observe_record};
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn typed_handoff_ack_is_not_an_outcome_or_a_new_start_lease() {
|
||||
let request = Request {
|
||||
job_bytes: b"bound original job".to_vec(),
|
||||
permit_bytes: b"bound original permit".to_vec(),
|
||||
signature: vec![0; 64],
|
||||
plan_hash: "a".repeat(64),
|
||||
authorization_id: Uuid::new_v4(),
|
||||
};
|
||||
let grant = Uuid::new_v4();
|
||||
let accepted = Accepted {
|
||||
schema_version: 1,
|
||||
operation: "agent_update_handoff_accepted_v1".into(),
|
||||
grant_id: grant,
|
||||
owner_nonce: Uuid::new_v4(),
|
||||
handoff_sha256: "b".repeat(64),
|
||||
original_request_sha256: hash(&serde_json::to_vec(&request).unwrap()),
|
||||
ready: false,
|
||||
terminal: false,
|
||||
};
|
||||
let raw = serde_json::to_vec(&accepted).unwrap();
|
||||
serde_json::from_slice::<Accepted>(&raw)
|
||||
.unwrap()
|
||||
.matches(&request, grant)
|
||||
.unwrap();
|
||||
assert!(serde_json::from_slice::<crate::Outcome>(&raw).is_err());
|
||||
let mut next = request.clone();
|
||||
next.job_bytes.push(0);
|
||||
assert!(accepted.matches(&next, grant).is_err());
|
||||
assert!(accepted.matches(&request, Uuid::new_v4()).is_err());
|
||||
let mut false_result = accepted.clone();
|
||||
false_result.terminal = true;
|
||||
assert!(false_result.matches(&request, grant).is_err());
|
||||
false_result.terminal = false;
|
||||
false_result.ready = true;
|
||||
assert!(false_result.matches(&request, grant).is_err());
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,7 @@ use rmm_agent_core::{
|
||||
reconcile::SyncClock,
|
||||
update_handoff::{
|
||||
self as core, NativeControlOperation, NativeControlReply, NativeControlRequest,
|
||||
NativeEffect, NativeService,
|
||||
NativeEffect, NativeEffectStage, NativeService, UpdateParticipantGuard,
|
||||
},
|
||||
};
|
||||
use rmm_updater_handoff::{Evidence, Phase};
|
||||
@@ -21,7 +21,7 @@ pub fn active_grant(db: &Connection) -> Result<Option<Uuid>> {
|
||||
if !exists {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut query=db.prepare("SELECT grant_id FROM agent_update_handoffs WHERE phase NOT IN ('unknown','outcome_persisted') ORDER BY grant_id LIMIT 2")?;
|
||||
let mut query=db.prepare("SELECT grant_id FROM agent_update_handoffs WHERE phase NOT IN ('unknown','outcome_persisted','rollback_outcome_persisted') ORDER BY grant_id LIMIT 2")?;
|
||||
let rows = query
|
||||
.query_map([], |r| r.get::<_, String>(0))?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
@@ -90,7 +90,10 @@ pub fn handle(
|
||||
} => {
|
||||
let journal = core::read(db, &guard, request.grant_id)?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::LedgerReturnIntent,
|
||||
matches!(
|
||||
journal.phase(),
|
||||
Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent
|
||||
),
|
||||
"UPDATE_START_ALREADY_OBSERVED_OR_PHASE"
|
||||
);
|
||||
let (actual, actual_hash) = guard.started()?;
|
||||
@@ -103,7 +106,11 @@ pub fn handle(
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
] {
|
||||
let effect = NativeEffect::StartService { service };
|
||||
let effect = if guard.restored() {
|
||||
NativeEffect::RollbackStartService { service }
|
||||
} else {
|
||||
NativeEffect::StartService { service }
|
||||
};
|
||||
let reserved = core::read_native_claim(db, &guard, request.grant_id, &effect)?;
|
||||
let already:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_native_observations WHERE grant_id=?1 AND claim_sha256=?2)",rusqlite::params![request.grant_id.to_string(),rmm_domain::jobs::hash(&serde_json::to_vec(&reserved)?)],|r|r.get(0))?;
|
||||
// One control request performs one sequence, never retries an
|
||||
@@ -119,28 +126,60 @@ pub fn handle(
|
||||
}
|
||||
let event = journal.prepare(
|
||||
u64::try_from(clock.now()?.timestamp())?,
|
||||
Evidence::ServicesStarted {
|
||||
services: actual,
|
||||
ledger_identity_sha256: header.ledger_identity_sha256.clone(),
|
||||
observation_sha256: actual_hash,
|
||||
if guard.restored() {
|
||||
Evidence::RollbackServicesStarted {
|
||||
services: actual,
|
||||
ledger_identity_sha256: header.ledger_identity_sha256.clone(),
|
||||
observation_sha256: actual_hash,
|
||||
}
|
||||
} else {
|
||||
Evidence::ServicesStarted {
|
||||
services: actual,
|
||||
ledger_identity_sha256: header.ledger_identity_sha256.clone(),
|
||||
observation_sha256: actual_hash,
|
||||
}
|
||||
},
|
||||
)?;
|
||||
core::append(db, &guard, request.grant_id, journal.head_sha256(), &event)?;
|
||||
if header.schema_version == 2 && !guard.restored() {
|
||||
let observation = guard.native_observation_sha256(
|
||||
&header,
|
||||
guard.original().delegation(),
|
||||
&NativeEffect::ConditionalRollbackStopGeneral,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
)?;
|
||||
core::deny_conditional_stop(
|
||||
db,
|
||||
&guard,
|
||||
request.grant_id,
|
||||
&observation,
|
||||
clock.now()?,
|
||||
)?;
|
||||
}
|
||||
}
|
||||
NativeControlOperation::Health { receipt } => {
|
||||
guard.qualify_health(db, receipt)?;
|
||||
let journal = core::read(db, &guard, request.grant_id)?;
|
||||
let event = journal.prepare(
|
||||
u64::try_from(clock.now()?.timestamp())?,
|
||||
Evidence::HealthVerified {
|
||||
receipt: receipt.clone(),
|
||||
if guard.restored() {
|
||||
Evidence::RollbackHealthVerified {
|
||||
receipt: receipt.clone(),
|
||||
}
|
||||
} else {
|
||||
Evidence::HealthVerified {
|
||||
receipt: receipt.clone(),
|
||||
}
|
||||
},
|
||||
)?;
|
||||
core::append(db, &guard, request.grant_id, journal.head_sha256(), &event)?;
|
||||
}
|
||||
NativeControlOperation::Finalize => {
|
||||
original_outcome_base64url =
|
||||
Some(URL_SAFE_NO_PAD.encode(guard.publish_record_and_finalize(db)?));
|
||||
original_outcome_base64url = Some(URL_SAFE_NO_PAD.encode(if guard.restored() {
|
||||
guard.finalize_restored(db)?
|
||||
} else {
|
||||
guard.publish_record_and_finalize(db)?
|
||||
}));
|
||||
}
|
||||
}
|
||||
let proof = if original_outcome_base64url.is_some() {
|
||||
@@ -151,6 +190,18 @@ pub fn handle(
|
||||
.context("UPDATE_ACTIVE_PROOF_REQUIRED")?,
|
||||
)
|
||||
};
|
||||
let pre_stop = if matches!(request.method, NativeControlOperation::ReadOriginal) {
|
||||
guard.pre_stop_signed_sync(db)?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let (pre_stop_sync_request_base64url, pre_stop_sync_response_base64url) = match pre_stop {
|
||||
Some((request, response)) => (
|
||||
Some(URL_SAFE_NO_PAD.encode(request)),
|
||||
Some(URL_SAFE_NO_PAD.encode(response)),
|
||||
),
|
||||
None => (None, None),
|
||||
};
|
||||
Ok(NativeControlReply {
|
||||
schema_version: 1,
|
||||
challenge: request.challenge,
|
||||
@@ -167,5 +218,7 @@ pub fn handle(
|
||||
claim,
|
||||
original_start_base64url,
|
||||
original_outcome_base64url,
|
||||
pre_stop_sync_request_base64url,
|
||||
pre_stop_sync_response_base64url,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -133,6 +133,12 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
journal.phase(),
|
||||
Phase::LedgerReturnIntent | Phase::ServicesStarted | Phase::HealthVerified
|
||||
);
|
||||
let restored = matches!(
|
||||
journal.phase(),
|
||||
Phase::RollbackLedgerReturnIntent
|
||||
| Phase::RollbackServicesStarted
|
||||
| Phase::RollbackHealthVerified
|
||||
);
|
||||
let services = service_policies(&original, &trust, target)?;
|
||||
let own = services.observe(Service::Full, &budget)?;
|
||||
ensure!(
|
||||
@@ -148,6 +154,8 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
"UPDATE_ORIGINAL_FULL_CHANGED"
|
||||
);
|
||||
Participant::OriginalHelper
|
||||
} else if restored && header.boot_id == Uuid::parse_str(&rmm_agent_linux::boot_id()?)? {
|
||||
Participant::RestoredHelper
|
||||
} else if target && header.boot_id == Uuid::parse_str(&rmm_agent_linux::boot_id()?)? {
|
||||
Participant::NewHelper
|
||||
} else {
|
||||
@@ -227,8 +235,11 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
}
|
||||
self.check_effect_window()?;
|
||||
ensure!(
|
||||
self.participant == Participant::NewHelper,
|
||||
"UPDATE_NEW_FULL_REQUIRED"
|
||||
matches!(
|
||||
self.participant,
|
||||
Participant::NewHelper | Participant::RestoredHelper
|
||||
),
|
||||
"UPDATE_NEW_OR_RESTORED_FULL_REQUIRED"
|
||||
);
|
||||
let agent = self.services.observe(Service::Agent, &self.budget)?;
|
||||
let mut peer = std::mem::MaybeUninit::<libc::ucred>::uninit();
|
||||
@@ -264,18 +275,30 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
) -> Result<()> {
|
||||
self.check_effect_window()?;
|
||||
ensure!(
|
||||
self.participant == Participant::NewHelper,
|
||||
"UPDATE_NEW_FULL_REQUIRED"
|
||||
matches!(
|
||||
self.participant,
|
||||
Participant::NewHelper | Participant::RestoredHelper
|
||||
),
|
||||
"UPDATE_NEW_OR_RESTORED_FULL_REQUIRED"
|
||||
);
|
||||
let mut journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::ServicesStarted,
|
||||
matches!(
|
||||
journal.phase(),
|
||||
Phase::ServicesStarted | Phase::RollbackServicesStarted
|
||||
),
|
||||
"UPDATE_HEALTH_PHASE"
|
||||
);
|
||||
let event = journal.prepare(
|
||||
u64::try_from(self.clock.now()?.timestamp())?,
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed.clone(),
|
||||
if self.participant == Participant::RestoredHelper {
|
||||
Evidence::RollbackHealthVerified {
|
||||
receipt: signed.clone(),
|
||||
}
|
||||
} else {
|
||||
Evidence::HealthVerified {
|
||||
receipt: signed.clone(),
|
||||
}
|
||||
},
|
||||
)?;
|
||||
journal.replay(&event)?; // ORIGINAL pinned health signature and all kernel fields.
|
||||
@@ -286,7 +309,10 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
self.check_effect_window()?;
|
||||
let journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::HealthVerified,
|
||||
matches!(
|
||||
journal.phase(),
|
||||
Phase::HealthVerified | Phase::RollbackHealthVerified
|
||||
),
|
||||
"UPDATE_ORIGINAL_STORED_HEALTH_REQUIRED"
|
||||
);
|
||||
let event_raw:Vec<u8>=db.query_row("SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence DESC LIMIT 1",[self.original.permit().grant_id.to_string()],|r|r.get(0))?;
|
||||
@@ -295,8 +321,16 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
hash(&event_raw) == journal.head_sha256(),
|
||||
"UPDATE_STORED_HEALTH_HEAD_CHANGED"
|
||||
);
|
||||
let Evidence::HealthVerified { receipt } = &event.evidence else {
|
||||
anyhow::bail!("UPDATE_STORED_HEALTH_EVENT_REQUIRED")
|
||||
let receipt = match &event.evidence {
|
||||
Evidence::HealthVerified { receipt } if self.participant == Participant::NewHelper => {
|
||||
receipt
|
||||
}
|
||||
Evidence::RollbackHealthVerified { receipt }
|
||||
if self.participant == Participant::RestoredHelper =>
|
||||
{
|
||||
receipt
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_STORED_HEALTH_EVENT_REQUIRED"),
|
||||
};
|
||||
self.health = Some(self.health_evidence(db, receipt)?);
|
||||
Ok(event_raw)
|
||||
@@ -354,8 +388,11 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
pub fn started(&self) -> Result<(Vec<rmm_updater_handoff::StartedService>, String)> {
|
||||
self.check_effect_window()?;
|
||||
ensure!(
|
||||
self.participant == Participant::NewHelper,
|
||||
"UPDATE_NEW_FULL_REQUIRED"
|
||||
matches!(
|
||||
self.participant,
|
||||
Participant::NewHelper | Participant::RestoredHelper
|
||||
),
|
||||
"UPDATE_NEW_OR_RESTORED_FULL_REQUIRED"
|
||||
);
|
||||
let mut raw = Vec::new();
|
||||
let mut proofs = Vec::new();
|
||||
@@ -415,7 +452,13 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
Ok(())
|
||||
}
|
||||
fn verify_owner(&self, phase: Phase, events: &[Event]) -> Result<()> {
|
||||
if !matches!(phase, Phase::ServicesStarted | Phase::HealthVerified) {
|
||||
if !matches!(
|
||||
phase,
|
||||
Phase::ServicesStarted
|
||||
| Phase::HealthVerified
|
||||
| Phase::RollbackServicesStarted
|
||||
| Phase::RollbackHealthVerified
|
||||
) {
|
||||
let updater = self
|
||||
.updater
|
||||
.as_ref()
|
||||
@@ -431,15 +474,30 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
"UPDATE_ORIGINAL_UPDATER_OWNER_CHANGED"
|
||||
);
|
||||
}
|
||||
if matches!(phase, Phase::ServicesStarted | Phase::HealthVerified) {
|
||||
if matches!(
|
||||
phase,
|
||||
Phase::ServicesStarted
|
||||
| Phase::HealthVerified
|
||||
| Phase::RollbackServicesStarted
|
||||
| Phase::RollbackHealthVerified
|
||||
) {
|
||||
let started = events
|
||||
.iter()
|
||||
.find_map(|event| {
|
||||
if let Evidence::ServicesStarted { services, .. } = &event.evidence {
|
||||
.find_map(|event| match &event.evidence {
|
||||
Evidence::ServicesStarted { services, .. }
|
||||
if matches!(phase, Phase::ServicesStarted | Phase::HealthVerified) =>
|
||||
{
|
||||
Some(services)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
Evidence::RollbackServicesStarted { services, .. }
|
||||
if matches!(
|
||||
phase,
|
||||
Phase::RollbackServicesStarted | Phase::RollbackHealthVerified
|
||||
) =>
|
||||
{
|
||||
Some(services)
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.context("UPDATE_STARTED_PROOF_MISSING")?;
|
||||
self.verify_current_services(started)?;
|
||||
@@ -486,16 +544,39 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
||||
);
|
||||
self.check_effect_window()?;
|
||||
ensure!(
|
||||
self.participant == Participant::NewHelper,
|
||||
"UPDATE_NEW_FULL_REQUIRED"
|
||||
matches!(
|
||||
self.participant,
|
||||
Participant::NewHelper | Participant::RestoredHelper
|
||||
),
|
||||
"UPDATE_NEW_OR_RESTORED_FULL_REQUIRED"
|
||||
);
|
||||
self.witnesses.files.verify_pair(&self.budget)?;
|
||||
if self.participant == Participant::RestoredHelper {
|
||||
self.witnesses.files.verify_predecessor_pair(&self.budget)?;
|
||||
} else {
|
||||
self.witnesses.files.verify_pair(&self.budget)?;
|
||||
}
|
||||
match &event.evidence {
|
||||
Evidence::ServicesStarted {
|
||||
services,
|
||||
ledger_identity_sha256,
|
||||
observation_sha256,
|
||||
}
|
||||
| Evidence::RollbackServicesStarted {
|
||||
services,
|
||||
ledger_identity_sha256,
|
||||
observation_sha256,
|
||||
} => {
|
||||
ensure!(
|
||||
matches!(
|
||||
(&event.evidence, self.participant),
|
||||
(Evidence::ServicesStarted { .. }, Participant::NewHelper)
|
||||
| (
|
||||
Evidence::RollbackServicesStarted { .. },
|
||||
Participant::RestoredHelper
|
||||
)
|
||||
),
|
||||
"UPDATE_STARTED_ROLE"
|
||||
);
|
||||
let mut held = Vec::new();
|
||||
let mut proofs = Vec::new();
|
||||
for service in [Service::Agent, Service::General, Service::Full] {
|
||||
@@ -511,7 +592,18 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
||||
"UPDATE_ACTUAL_STARTED_PROOFS_REQUIRED"
|
||||
);
|
||||
}
|
||||
Evidence::HealthVerified { receipt } => {
|
||||
Evidence::HealthVerified { receipt } | Evidence::RollbackHealthVerified { receipt } => {
|
||||
ensure!(
|
||||
matches!(
|
||||
(&event.evidence, self.participant),
|
||||
(Evidence::HealthVerified { .. }, Participant::NewHelper)
|
||||
| (
|
||||
Evidence::RollbackHealthVerified { .. },
|
||||
Participant::RestoredHelper
|
||||
)
|
||||
),
|
||||
"UPDATE_HEALTH_ROLE"
|
||||
);
|
||||
let health = self
|
||||
.health
|
||||
.as_ref()
|
||||
@@ -521,6 +613,14 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
||||
"UPDATE_LOCAL_HEALTH_RECEIPT_CHANGED"
|
||||
);
|
||||
}
|
||||
Evidence::RollbackOutcomePersisted { .. }
|
||||
if self.participant == Participant::RestoredHelper =>
|
||||
{
|
||||
ensure!(
|
||||
self.health.is_some(),
|
||||
"UPDATE_ROLLBACK_LOCAL_HEALTH_REQUIRED"
|
||||
);
|
||||
}
|
||||
// InstalledRecord/Outcome have a separate original-record CAS.
|
||||
_ => anyhow::bail!("UPDATE_FULL_EVENT_NOT_YET_QUALIFIED"),
|
||||
}
|
||||
@@ -578,10 +678,63 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
||||
.observe(service, &self.budget)?
|
||||
.verify(&self.budget)?;
|
||||
}
|
||||
(
|
||||
Participant::NewHelper,
|
||||
NativeEffect::ConditionalRollbackStopGeneral,
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => {
|
||||
// The retained new Full proves the early-Full-failure branch
|
||||
// was never entered. Closing this reservation records NO stop.
|
||||
ensure!(
|
||||
handoff.schema_version == 2,
|
||||
"UPDATE_CONDITIONAL_STOP_PROFILE"
|
||||
);
|
||||
for service in [Service::General, Service::Full] {
|
||||
self.services
|
||||
.observe(service, &self.budget)?
|
||||
.verify(&self.budget)?;
|
||||
}
|
||||
}
|
||||
(
|
||||
Participant::RestoredHelper,
|
||||
NativeEffect::RollbackStartService { service },
|
||||
NativeEffectStage::Observe,
|
||||
) => {
|
||||
let service = match service {
|
||||
NativeService::Agent => Service::Agent,
|
||||
NativeService::General => Service::General,
|
||||
NativeService::Full => Service::Full,
|
||||
_ => anyhow::bail!("UPDATE_WINDOWS_SERVICE_ON_LINUX"),
|
||||
};
|
||||
self.witnesses.files.verify_predecessor_pair(&self.budget)?;
|
||||
self.services
|
||||
.observe(service, &self.budget)?
|
||||
.verify(&self.budget)?;
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_FULL_NATIVE_EFFECT_NOT_QUALIFIED"),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn native_observation_sha256(
|
||||
&self,
|
||||
handoff: &Handoff,
|
||||
delegation: &UpdateDelegation,
|
||||
effect: &NativeEffect,
|
||||
stage: NativeEffectStage,
|
||||
) -> Result<String> {
|
||||
self.verify_native_effect(handoff, delegation, effect, stage)?;
|
||||
ensure!(
|
||||
*effect == NativeEffect::ConditionalRollbackStopGeneral
|
||||
&& stage == NativeEffectStage::ObserveNonstart,
|
||||
"UPDATE_FULL_NATIVE_HASH_NOT_QUALIFIED"
|
||||
);
|
||||
Ok(hash(&serde_json::to_vec(&(
|
||||
"conditional_general_stop_unused_v1",
|
||||
handoff.owner_nonce,
|
||||
handoff.attempt.grant_id,
|
||||
self.services.observe(Service::Full, &self.budget)?.proof(),
|
||||
))?))
|
||||
}
|
||||
}
|
||||
|
||||
struct VerifiedHealth {
|
||||
@@ -985,3 +1138,157 @@ impl FullUpdateGuard<'_> {
|
||||
Ok(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
impl FullUpdateGuard<'_> {
|
||||
pub fn finalize_restored(&mut self, db: &mut Connection) -> Result<Vec<u8>> {
|
||||
ensure!(
|
||||
self.participant == Participant::RestoredHelper,
|
||||
"UPDATE_RESTORED_FULL_REQUIRED"
|
||||
);
|
||||
self.qualify_effects(db)?;
|
||||
self.qualify_stored_health(db)?;
|
||||
self.witnesses.files.verify_predecessor_pair(&self.budget)?;
|
||||
// TrustState still pins the SAME original record and activation floor.
|
||||
self.trust.recheck(&self.original, self.clock)?;
|
||||
let journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
||||
let health = self
|
||||
.health
|
||||
.as_ref()
|
||||
.context("UPDATE_ROLLBACK_HEALTH_REQUIRED")?;
|
||||
let outcome = crate::Outcome {
|
||||
state: "failed".into(),
|
||||
stdout: vec![],
|
||||
stderr: vec![],
|
||||
exit_code: None,
|
||||
output_truncated: false,
|
||||
reboot_required: false,
|
||||
error_code: "AGENT_UPDATE_RETURNED_TO_PREDECESSOR".into(),
|
||||
evidence: serde_json::json!({"postconditions_passed":false,"previous_boot_id":self.original.handoff().boot_id,
|
||||
"agent_update":{"schema_version":2,"handoff_sha256":journal.handoff_sha256(),
|
||||
"manifest_sha256":self.original.handoff().target.manifest_sha256,
|
||||
"predecessor_record_sha256":self.original.handoff().predecessor_record_sha256,
|
||||
"installed_record_sha256":self.original.handoff().predecessor_record_sha256,
|
||||
"signed_health_sha256":health.signed_sha256,"rolled_back":true}}),
|
||||
};
|
||||
update_handoff::finalize_rollback(
|
||||
db,
|
||||
self,
|
||||
self.original.permit(),
|
||||
journal.head_sha256(),
|
||||
u64::try_from(self.clock.now()?.timestamp())?,
|
||||
&outcome,
|
||||
)?;
|
||||
Ok(db.query_row(
|
||||
"SELECT outcome FROM execution_evidence WHERE grant_id=?1",
|
||||
[self.original.permit().grant_id.to_string()],
|
||||
|r| r.get(0),
|
||||
)?)
|
||||
}
|
||||
pub fn restored(&self) -> bool {
|
||||
self.participant == Participant::RestoredHelper
|
||||
}
|
||||
/// Exact ORIGINAL bytes from a signed inflight decision already applied
|
||||
/// by this actual Full process under the same existing guarded ledger.
|
||||
/// Missing evidence keeps the worker waiting; it never becomes readiness.
|
||||
pub fn pre_stop_signed_sync(&self, db: &Connection) -> Result<Option<(Vec<u8>, Vec<u8>)>> {
|
||||
use prost::Message;
|
||||
use rusqlite::OptionalExtension;
|
||||
self.check(db)?;
|
||||
if self.participant != Participant::OriginalHelper {
|
||||
return Ok(None);
|
||||
}
|
||||
let journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
||||
if journal.phase() != Phase::StopIntent {
|
||||
return Ok(None);
|
||||
}
|
||||
let id: Option<String> = db
|
||||
.query_row(
|
||||
"SELECT last_decision FROM helper_sync_meta WHERE id=1 AND fault IS NULL",
|
||||
[],
|
||||
|r| r.get(0),
|
||||
)
|
||||
.optional()?
|
||||
.flatten();
|
||||
let Some(id) = id else { return Ok(None) };
|
||||
let id: Uuid = id.parse()?;
|
||||
let applied:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM agent_update_sync_applied WHERE grant_id=?1 AND decision_id=?2)",
|
||||
rusqlite::params![self.original.permit().grant_id.to_string(),id.to_string()],|r|r.get(0))?;
|
||||
if !applied {
|
||||
return Ok(None);
|
||||
}
|
||||
self.qualify_effects(db)?;
|
||||
let round = rmm_agent_core::update_health_sync::read_round(
|
||||
db,
|
||||
self,
|
||||
self.binding,
|
||||
self.original.permit().grant_id,
|
||||
id,
|
||||
)?;
|
||||
let decision = round.decision();
|
||||
let h = self.original.handoff();
|
||||
let now = self.clock.now()?;
|
||||
let proof = update_handoff::current_proof(db, self, self.original.permit().grant_id)?
|
||||
.context("UPDATE_PRESTOP_ORIGINAL_PROOF_REQUIRED")?;
|
||||
let expected =
|
||||
rmm_domain::agent_update::inflight_decision(&proof, self.trust.health_public_key())
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let attempts = decision
|
||||
.attempts
|
||||
.iter()
|
||||
.filter(|a| a.job_id == h.attempt.job_id && a.attempt_id == h.attempt.attempt_id)
|
||||
.collect::<Vec<_>>();
|
||||
ensure!(attempts.len() == 1, "UPDATE_PRESTOP_ONE_ORIGINAL_ACK");
|
||||
let ack = attempts[0];
|
||||
ensure!(
|
||||
decision.valid_profile(now)
|
||||
&& !decision.ready
|
||||
&& !decision.helper_ready
|
||||
&& decision.boot_id == h.boot_id
|
||||
&& decision.connection_generation == h.connection_generation
|
||||
&& decision.journal_id == h.agent_journal_id
|
||||
&& decision.helper_journal_id == Some(h.helper_journal_id)
|
||||
&& ack.update_inflight.as_ref() == Some(&expected)
|
||||
&& ack.grant_id == Some(h.attempt.grant_id)
|
||||
&& ack.authorization_id == Some(h.attempt.authorization_id)
|
||||
&& ack.plan_hash.as_deref() == Some(h.attempt.plan_sha256.as_str())
|
||||
&& ack.job_payload_hash == h.attempt.job_payload_sha256
|
||||
&& ack.original_boot_id == Some(h.boot_id)
|
||||
&& ack.action == "update_agent"
|
||||
&& ack.execution_identity == "root"
|
||||
&& !ack.unlock
|
||||
&& ack.outcome_state == "running"
|
||||
&& ack.outcome_bytes.is_empty()
|
||||
&& ack.outcome_sha256.is_none()
|
||||
&& round.applied().applied_at >= decision.issued_at
|
||||
&& round.applied().applied_at < decision.valid_until,
|
||||
"UPDATE_PRESTOP_APPLIED_ORIGINAL_ACK"
|
||||
);
|
||||
let (raw, response): (Vec<u8>, Vec<u8>) = db.query_row(
|
||||
"SELECT request,response FROM helper_sync_decisions WHERE decision_id=?1",
|
||||
[id.to_string()],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
raw.len() <= 256 * 1024 && response.len() <= 256 * 1024,
|
||||
"UPDATE_PRESTOP_WIRE_LIMIT"
|
||||
);
|
||||
let request = rmm_protocol::SyncRequest::decode(raw.as_slice())?;
|
||||
let local = request
|
||||
.attempts
|
||||
.iter()
|
||||
.find(|a| {
|
||||
a.job_id == h.attempt.job_id.to_string()
|
||||
&& a.attempt_id == h.attempt.attempt_id.to_string()
|
||||
})
|
||||
.context("UPDATE_PRESTOP_REQUEST_ATTEMPT")?;
|
||||
ensure!(
|
||||
request.journal_complete
|
||||
&& local.state == "running"
|
||||
&& local.consumption == "consumed"
|
||||
&& local.update_handoff_bytes == proof.bytes().map_err(anyhow::Error::msg)?,
|
||||
"UPDATE_PRESTOP_REQUEST_ORIGINAL_PREFIX"
|
||||
);
|
||||
self.check_effect_window()?;
|
||||
Ok(Some((raw, response)))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,386 @@
|
||||
//! Passive Full-only updater observation. This path cannot stage, consume,
|
||||
//! start/stop a service, append a handoff, repair state or grant readiness.
|
||||
use crate::{
|
||||
Binding, control,
|
||||
readiness::Identity,
|
||||
reconcile::{self, ExecutorGuard},
|
||||
};
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use rmm_agent_core::{helper_reconcile::HelperSync, reconcile::SyncClock};
|
||||
use rmm_domain::{
|
||||
agent_update::{
|
||||
AgentUpdateObservation, CandidatePreview, ObservationQuality, PeerPinTransition, Platform,
|
||||
ReleaseEnvelope,
|
||||
},
|
||||
jobs::hash,
|
||||
};
|
||||
use rmm_updater_linux::{
|
||||
Budget,
|
||||
files::Directory,
|
||||
ipc,
|
||||
services::{Service, ServicePolicy, Systemd},
|
||||
};
|
||||
use rmm_updater_worker::{
|
||||
clock::NativeClock, full::FullFiles, reader_registry::QualifiedRegistry, trust::TrustState,
|
||||
};
|
||||
use rusqlite::Connection;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
ffi::OsStr,
|
||||
os::unix::{fs::MetadataExt, net::UnixStream},
|
||||
path::Path,
|
||||
time::Duration,
|
||||
};
|
||||
use uuid::Uuid;
|
||||
const SOCKET: &str = "/run/rmm-helper-maintenance/control.sock";
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Request {
|
||||
pub operation: String,
|
||||
pub schema_version: u32,
|
||||
pub challenge: Uuid,
|
||||
pub identity: Identity,
|
||||
pub candidate: Option<ReleaseEnvelope>,
|
||||
pub keyring_generation: Option<u64>,
|
||||
}
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Response {
|
||||
pub schema_version: u32,
|
||||
pub challenge: Uuid,
|
||||
pub identity: Identity,
|
||||
pub profile: String,
|
||||
pub policy_sha256: String,
|
||||
pub helper_binary_sha256: String,
|
||||
pub ledger_device: u64,
|
||||
pub ledger_inode: u64,
|
||||
pub lock_device: u64,
|
||||
pub lock_inode: u64,
|
||||
pub observation: AgentUpdateObservation,
|
||||
pub installed_record: Vec<u8>,
|
||||
pub installed_record_sha256: String,
|
||||
}
|
||||
pub fn observe(
|
||||
socket: &Path,
|
||||
binding: &Binding,
|
||||
candidate: Option<ReleaseEnvelope>,
|
||||
keyring_generation: Option<u64>,
|
||||
) -> Result<AgentUpdateObservation> {
|
||||
observe_record(socket, binding, candidate, keyring_generation)
|
||||
.map(|(observation, _)| observation)
|
||||
}
|
||||
/// Exact public release/evidence metadata, returned only from the same
|
||||
/// authenticated Full response as the independently measured observation.
|
||||
/// The private Root record directory and file permissions remain unchanged.
|
||||
pub fn observe_record(
|
||||
socket: &Path,
|
||||
binding: &Binding,
|
||||
candidate: Option<ReleaseEnvelope>,
|
||||
keyring_generation: Option<u64>,
|
||||
) -> Result<(AgentUpdateObservation, Vec<u8>)> {
|
||||
ensure!(
|
||||
socket == Path::new(SOCKET) && candidate.is_some() == keyring_generation.is_some(),
|
||||
"UPDATE_OBSERVER_INPUT"
|
||||
);
|
||||
let pin = control::GeneralPin::read(
|
||||
Path::new("/etc/rmm-remote/full-maintenance-helper-proof.json"),
|
||||
binding,
|
||||
)?;
|
||||
ensure!(
|
||||
pin.profile == "full_maintenance_v1",
|
||||
"UPDATE_OBSERVER_FULL_PIN"
|
||||
);
|
||||
let request = Request {
|
||||
operation: "update_observe_v1".into(),
|
||||
schema_version: 1,
|
||||
challenge: Uuid::new_v4(),
|
||||
identity: Identity::from_binding(binding)?,
|
||||
candidate,
|
||||
keyring_generation,
|
||||
};
|
||||
let response: Response =
|
||||
control::exchange(socket, &request, Duration::from_secs(15), 192 * 1024)?;
|
||||
ensure!(
|
||||
response.schema_version == 1
|
||||
&& response.challenge == request.challenge
|
||||
&& response.identity == request.identity
|
||||
&& response.profile == pin.profile
|
||||
&& response.policy_sha256 == pin.policy_sha256
|
||||
&& Some(&response.helper_binary_sha256) == pin.helper_binary_sha256.as_ref()
|
||||
&& response.ledger_inode != 0
|
||||
&& response.lock_inode != 0
|
||||
&& response.observation.validate()
|
||||
&& response.observation.platform == Platform::LinuxX64,
|
||||
"UPDATE_OBSERVER_RESPONSE_BINDING"
|
||||
);
|
||||
let record = rmm_domain::agent_update_provisioning::InstalledReleaseRecord::from_bytes(
|
||||
&response.installed_record,
|
||||
)
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let predecessor = response
|
||||
.observation
|
||||
.predecessor
|
||||
.as_ref()
|
||||
.context("UPDATE_OBSERVER_RECORD_PREDECESSOR")?;
|
||||
let manifest = record
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?
|
||||
.manifest;
|
||||
ensure!(
|
||||
response.installed_record_sha256 == hash(&response.installed_record)
|
||||
&& response.installed_record_sha256 == predecessor.installed_record_sha256
|
||||
&& record.platform == response.observation.platform
|
||||
&& record.manifest_sha256 == predecessor.manifest_sha256
|
||||
&& manifest.release_id == predecessor.release_id
|
||||
&& manifest.release_sequence == predecessor.release_sequence
|
||||
&& manifest.artifacts[0].sha256 == predecessor.agent_sha256
|
||||
&& manifest.artifacts[1].sha256 == predecessor.helper_sha256
|
||||
&& Some(record.activation_floor) == response.observation.activation_floor
|
||||
&& record.rolled_back == response.observation.rolled_back,
|
||||
"UPDATE_OBSERVER_RECORD_BINDING"
|
||||
);
|
||||
Ok((response.observation, response.installed_record))
|
||||
}
|
||||
pub struct Local<'a> {
|
||||
pub executor: &'a ExecutorGuard,
|
||||
pub binding: &'a Binding,
|
||||
pub clock: &'a NativeClock,
|
||||
pub sync: &'a HelperSync,
|
||||
pub sync_clock: &'a reconcile::NativeClock,
|
||||
pub key_path: &'a Path,
|
||||
pub policy_sha256: &'a str,
|
||||
pub helper_sha256: &'a str,
|
||||
}
|
||||
pub fn collect(db: &Connection, local: Local<'_>, request: &Request) -> Result<Response> {
|
||||
ensure!(
|
||||
request.operation == "update_observe_v1"
|
||||
&& request.schema_version == 1
|
||||
&& !request.challenge.is_nil()
|
||||
&& request.identity == Identity::from_binding(local.binding)?
|
||||
&& request.candidate.is_some() == request.keyring_generation.is_some(),
|
||||
"UPDATE_OBSERVER_REQUEST_BINDING"
|
||||
);
|
||||
local.executor.check(db)?;
|
||||
ensure!(
|
||||
crate::update_control::active_grant(db)?.is_none(),
|
||||
"UPDATE_OBSERVER_ACTIVE_HANDOFF"
|
||||
);
|
||||
let generation = local
|
||||
.sync
|
||||
.active_generation()
|
||||
.context("UPDATE_OBSERVER_CURRENT_SYNC_REQUIRED")?;
|
||||
ensure!(
|
||||
local.sync.can_start(
|
||||
db,
|
||||
local.executor,
|
||||
generation,
|
||||
local.sync_clock,
|
||||
&reconcile::NativeBoot
|
||||
),
|
||||
"UPDATE_OBSERVER_CONFIRMED_SYNC_REQUIRED"
|
||||
);
|
||||
let decision: String = db.query_row(
|
||||
"SELECT last_decision FROM helper_sync_meta WHERE id=1 AND fault IS NULL AND generation=?1",
|
||||
[generation],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
let decision = Uuid::parse_str(&decision)?;
|
||||
let trust = TrustState::load_observed(local.binding, local.clock)?;
|
||||
trust.qualify_history(db, local.executor, local.binding)?;
|
||||
let boot = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?
|
||||
.trim()
|
||||
.parse()?;
|
||||
let budget = Budget::new(boot, Duration::from_secs(15))?;
|
||||
let registry = QualifiedRegistry::load(trust.policy())?;
|
||||
registry.verify_admission(trust.policy(), &budget)?;
|
||||
let policies = trust
|
||||
.policy()
|
||||
.services
|
||||
.iter()
|
||||
.zip([
|
||||
Service::Agent,
|
||||
Service::General,
|
||||
Service::Full,
|
||||
Service::Apt,
|
||||
])
|
||||
.map(|(pin, service)| ServicePolicy {
|
||||
service,
|
||||
unit_sha256: pin.unit_sha256.clone(),
|
||||
image_sha256: if service == Service::Agent {
|
||||
trust.predecessor().agent_sha256.clone()
|
||||
} else {
|
||||
trust.predecessor().helper_sha256.clone()
|
||||
},
|
||||
})
|
||||
.collect();
|
||||
let services = Systemd::new(policies)?;
|
||||
let mut held = Vec::new();
|
||||
for service in [Service::Agent, Service::General, Service::Full] {
|
||||
held.push(services.observe(service, &budget)?);
|
||||
}
|
||||
ensure!(
|
||||
held[2].proof().process.pid == std::process::id()
|
||||
&& held[2].proof().process.image_sha256 == local.helper_sha256,
|
||||
"UPDATE_OBSERVER_ACTUAL_FULL"
|
||||
);
|
||||
let updater = Systemd::observe_updater(
|
||||
ServicePolicy {
|
||||
service: Service::Updater,
|
||||
image_sha256: trust.updater_binding().binary_sha256.clone(),
|
||||
unit_sha256: trust.policy().updater_service.unit_sha256.clone(),
|
||||
},
|
||||
&budget,
|
||||
)?;
|
||||
let description = ipc::exchange(
|
||||
UnixStream::connect("/run/rmm-agent-updater/control.sock")?,
|
||||
&updater,
|
||||
&budget,
|
||||
&ipc::Request::Describe {},
|
||||
)?;
|
||||
let updater_proof = updater.proof();
|
||||
ensure!(
|
||||
matches!(description.state, ipc::State::Described)
|
||||
&& !description.ready
|
||||
&& description.head_sha256.is_none()
|
||||
&& description.updater.pid == updater_proof.process.pid
|
||||
&& description.updater.birth == updater_proof.process.birth
|
||||
&& description.updater.image_sha256 == updater_proof.process.image_sha256
|
||||
&& description.updater.service_instance_sha256
|
||||
== hash(&serde_json::to_vec(updater_proof)?),
|
||||
"UPDATE_OBSERVER_LIVE_UPDATER"
|
||||
);
|
||||
let key_directory = Directory::open(
|
||||
local
|
||||
.key_path
|
||||
.parent()
|
||||
.context("UPDATE_OBSERVER_KEY_PARENT")?,
|
||||
0,
|
||||
false,
|
||||
)?;
|
||||
let mut key = key_directory.inspect(
|
||||
local
|
||||
.key_path
|
||||
.file_name()
|
||||
.context("UPDATE_OBSERVER_KEY_NAME")?,
|
||||
0,
|
||||
4096,
|
||||
)?;
|
||||
let record: crate::SigningKey = serde_json::from_slice(&key.bytes(4096)?)?;
|
||||
record.validate()?;
|
||||
ensure!(
|
||||
record.public_key_hex == local.binding.public_key_hex,
|
||||
"UPDATE_OBSERVER_JOB_KEY_BINDING"
|
||||
);
|
||||
let general = Directory::open(Path::new("/etc/rmm-remote"), 0, false)?;
|
||||
let general_pin = general.inspect(OsStr::new("general-helper-proof.json"), 0, 8192)?;
|
||||
let mut previews = Vec::new();
|
||||
if let Some(candidate) = &request.candidate {
|
||||
ensure!(
|
||||
request.keyring_generation == Some(trust.updater_binding().keyring_generation),
|
||||
"UPDATE_OBSERVER_KEYRING_GENERATION"
|
||||
);
|
||||
trust.verify_candidate(candidate, local.clock)?;
|
||||
let manifest = candidate.decode().map_err(anyhow::Error::msg)?.manifest;
|
||||
if manifest.release_id != trust.predecessor().release_id {
|
||||
let full = FullFiles::preview(
|
||||
&manifest.artifacts[1].sha256,
|
||||
local.key_path,
|
||||
&key.proof().sha256,
|
||||
&budget,
|
||||
)?;
|
||||
let transition = PeerPinTransition::LinuxGeneralFullV1 {
|
||||
general_pin_sha256: general_pin.proof().sha256.clone(),
|
||||
full,
|
||||
};
|
||||
// Validate the exact renderer result against the actual verified
|
||||
// future manifest/predecessor, using the ordinary immutable codec.
|
||||
let resolved = rmm_domain::agent_update::ResolvedAgentUpdate {
|
||||
schema_version: 1,
|
||||
profile: rmm_domain::agent_update::UpdateProfile::FixedCodePairV1,
|
||||
release_envelope: candidate.clone(),
|
||||
release_envelope_sha256: candidate.sha256().map_err(anyhow::Error::msg)?,
|
||||
manifest_sha256: hash(
|
||||
&candidate
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?
|
||||
.payload_bytes,
|
||||
),
|
||||
predecessor: trust.predecessor().clone(),
|
||||
updater: trust.updater_binding().clone(),
|
||||
peer_pin_transition: transition.clone(),
|
||||
recovery: rmm_domain::agent_update::Recovery::RestoreExactPredecessorOnce,
|
||||
health_profile: rmm_domain::agent_update::HealthProfile::MtlsInventorySyncV1,
|
||||
health_timeout_seconds: 180,
|
||||
no_reboot: true,
|
||||
};
|
||||
ensure!(resolved.validate(), "UPDATE_OBSERVER_RENDERED_CANDIDATE");
|
||||
previews.push(CandidatePreview {
|
||||
release_id: manifest.release_id,
|
||||
manifest_sha256: resolved.manifest_sha256,
|
||||
peer_pin_transition: transition,
|
||||
});
|
||||
}
|
||||
}
|
||||
for service in &held {
|
||||
service.verify(&budget)?;
|
||||
}
|
||||
updater.verify(&budget)?;
|
||||
trust.recheck_observed()?;
|
||||
registry.verify_admission(trust.policy(), &budget)?;
|
||||
local.executor.check(db)?;
|
||||
ensure!(
|
||||
local.sync.can_start(
|
||||
db,
|
||||
local.executor,
|
||||
generation,
|
||||
local.sync_clock,
|
||||
&reconcile::NativeBoot
|
||||
),
|
||||
"UPDATE_OBSERVER_SYNC_EXPIRED"
|
||||
);
|
||||
let observed_at = local.clock.now()?;
|
||||
let observed_at = observed_at
|
||||
- chrono::Duration::nanoseconds(i64::from(
|
||||
observed_at.timestamp_subsec_nanos() % 1_000_000,
|
||||
));
|
||||
let observation = AgentUpdateObservation {
|
||||
schema_version: 1,
|
||||
platform: Platform::LinuxX64,
|
||||
observed_at,
|
||||
quality: ObservationQuality::Valid,
|
||||
predecessor: Some(trust.predecessor().clone()),
|
||||
updater: Some(trust.updater_binding().clone()),
|
||||
activation_floor: Some(trust.activation_floor()),
|
||||
rolled_back: false,
|
||||
helper_observation_sha256: Some(hash(&serde_json::to_vec(&(
|
||||
held.iter().map(|h| h.proof()).collect::<Vec<_>>(),
|
||||
updater.proof(),
|
||||
decision,
|
||||
generation,
|
||||
key.proof(),
|
||||
general_pin.proof(),
|
||||
&previews,
|
||||
))?)),
|
||||
signed_sync_decision_id: Some(decision),
|
||||
candidate_previews: previews,
|
||||
};
|
||||
ensure!(observation.validate(), "UPDATE_OBSERVER_OBSERVATION_SHAPE");
|
||||
let ledger = std::fs::metadata("/var/lib/rmm-helper/consumption.sqlite")?;
|
||||
let lock = std::fs::metadata("/var/lib/rmm-helper/executor.lock")?;
|
||||
Ok(Response {
|
||||
schema_version: 1,
|
||||
challenge: request.challenge,
|
||||
identity: request.identity.clone(),
|
||||
profile: "full_maintenance_v1".into(),
|
||||
policy_sha256: local.policy_sha256.into(),
|
||||
helper_binary_sha256: local.helper_sha256.into(),
|
||||
ledger_device: ledger.dev(),
|
||||
ledger_inode: ledger.ino(),
|
||||
lock_device: lock.dev(),
|
||||
lock_inode: lock.ino(),
|
||||
observation,
|
||||
installed_record: trust.installed_raw().to_vec(),
|
||||
installed_record_sha256: hash(trust.installed_raw()),
|
||||
})
|
||||
}
|
||||
@@ -134,19 +134,61 @@ fn verifier_platform(platform: Platform) -> rmm_updater::Platform {
|
||||
Platform::WindowsX64 => rmm_updater::Platform::WindowsX64,
|
||||
}
|
||||
}
|
||||
/// Network input can choose only one of two statically named protected
|
||||
/// configuration slots. It never supplies a path or introduces update trust.
|
||||
fn keyring_path_with(
|
||||
platform: Platform,
|
||||
lookup: impl Fn(&str) -> Result<Option<String>, Error>,
|
||||
) -> Result<std::path::PathBuf, Error> {
|
||||
let name = match platform {
|
||||
Platform::LinuxX64 => "RMM_AGENT_UPDATE_LINUX_KEYRING_FILE",
|
||||
Platform::WindowsX64 => "RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE",
|
||||
};
|
||||
if let Some(path) = lookup(name)? {
|
||||
if path.is_empty() || !FsPath::new(&path).is_absolute() {
|
||||
return Err(fail("AGENT_UPDATE_NOT_CONFIGURED"));
|
||||
}
|
||||
return Ok(path.into());
|
||||
}
|
||||
// Exact legacy compatibility only when the platform-specific slot is
|
||||
// absent. An invalid explicit slot must never silently choose other trust.
|
||||
lookup("RMM_AGENT_UPDATE_KEYRING_FILE")?
|
||||
.map(Into::into)
|
||||
.ok_or_else(|| fail("AGENT_UPDATE_NOT_CONFIGURED"))
|
||||
}
|
||||
pub fn verify_envelope(
|
||||
envelope: &ReleaseEnvelope,
|
||||
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)?;
|
||||
verify_envelope_with_keyring(
|
||||
envelope,
|
||||
binding,
|
||||
&raw,
|
||||
chrono::Utc::now()
|
||||
.timestamp()
|
||||
.try_into()
|
||||
.map_err(|_| invalid())?,
|
||||
)
|
||||
}
|
||||
fn verify_envelope_with_keyring(
|
||||
envelope: &ReleaseEnvelope,
|
||||
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
|
||||
raw: &[u8],
|
||||
now_utc_seconds: u64,
|
||||
) -> Result<ReleaseManifest, Error> {
|
||||
let decoded = envelope.decode().map_err(|_| invalid())?;
|
||||
let path = std::env::var("RMM_AGENT_UPDATE_KEYRING_FILE")
|
||||
.map_err(|_| fail("AGENT_UPDATE_NOT_CONFIGURED"))?;
|
||||
let raw = protected_file(FsPath::new(&path), 16384)?;
|
||||
let config: rmm_domain::agent_update::UpdateKeyringFile =
|
||||
serde_json::from_slice(&raw).map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?;
|
||||
serde_json::from_slice(raw).map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?;
|
||||
if !config.validate()
|
||||
|| binding.is_some_and(|b| {
|
||||
b.keyring_generation != config.generation || b.keyring_sha256 != hash(&raw)
|
||||
b.keyring_generation != config.generation || b.keyring_sha256 != hash(raw)
|
||||
})
|
||||
{
|
||||
return Err(fail("AGENT_UPDATE_TRUST_INVALID"));
|
||||
@@ -174,10 +216,7 @@ pub fn verify_envelope(
|
||||
.map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?;
|
||||
let context = rmm_updater::TrustedContext {
|
||||
platform: verifier_platform(decoded.manifest.platform),
|
||||
now_utc_seconds: chrono::Utc::now()
|
||||
.timestamp()
|
||||
.try_into()
|
||||
.map_err(|_| invalid())?,
|
||||
now_utc_seconds,
|
||||
keyring_generation: config.generation,
|
||||
protocol_major: 1,
|
||||
state_schema: 1,
|
||||
@@ -826,6 +865,164 @@ pub async fn validate_current_target(
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn protected_keyring_slots_are_platform_specific_with_exact_legacy_fallback() {
|
||||
use std::collections::BTreeMap;
|
||||
let paths = BTreeMap::from([
|
||||
("RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", "/trust/linux.json"),
|
||||
(
|
||||
"RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE",
|
||||
"/trust/windows.json",
|
||||
),
|
||||
("RMM_AGENT_UPDATE_KEYRING_FILE", "/trust/legacy.json"),
|
||||
]);
|
||||
let choose = |platform, map: &BTreeMap<&str, &str>| {
|
||||
keyring_path_with(platform, |name| Ok(map.get(name).map(|v| v.to_string())))
|
||||
};
|
||||
assert_eq!(
|
||||
choose(Platform::LinuxX64, &paths).unwrap(),
|
||||
FsPath::new("/trust/linux.json")
|
||||
);
|
||||
assert_eq!(
|
||||
choose(Platform::WindowsX64, &paths).unwrap(),
|
||||
FsPath::new("/trust/windows.json")
|
||||
);
|
||||
let legacy = BTreeMap::from([("RMM_AGENT_UPDATE_KEYRING_FILE", "legacy-relative.json")]);
|
||||
for platform in [Platform::LinuxX64, Platform::WindowsX64] {
|
||||
assert_eq!(
|
||||
choose(platform, &legacy).unwrap(),
|
||||
FsPath::new("legacy-relative.json")
|
||||
);
|
||||
}
|
||||
let only_linux =
|
||||
BTreeMap::from([("RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", "/trust/linux.json")]);
|
||||
assert!(choose(Platform::WindowsX64, &only_linux).is_err());
|
||||
for invalid in ["", "relative.json"] {
|
||||
let wrong = BTreeMap::from([
|
||||
("RMM_AGENT_UPDATE_LINUX_KEYRING_FILE", invalid),
|
||||
("RMM_AGENT_UPDATE_KEYRING_FILE", "/trust/legacy.json"),
|
||||
]);
|
||||
assert!(choose(Platform::LinuxX64, &wrong).is_err());
|
||||
}
|
||||
assert!(
|
||||
keyring_path_with(Platform::WindowsX64, |_| Err(fail(
|
||||
"AGENT_UPDATE_NOT_CONFIGURED"
|
||||
)))
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn selected_platform_keyring_still_enforces_real_signatures_revocation_generation_and_raw_hash()
|
||||
{
|
||||
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
||||
use openssl::{pkey::PKey, sign::Signer};
|
||||
use rmm_domain::agent_update::{
|
||||
ArtifactRole, UpdateKeyringEntry, UpdateKeyringFile, UpdaterBinding,
|
||||
};
|
||||
let make = |platform| {
|
||||
let key = PKey::generate_ed25519().unwrap();
|
||||
let public = key.raw_public_key().unwrap();
|
||||
let manifest = ReleaseManifest {
|
||||
schema_version: 1,
|
||||
release_id: Uuid::new_v4(),
|
||||
release_sequence: 2,
|
||||
version: "0.1.1".into(),
|
||||
platform,
|
||||
published_at: 90,
|
||||
expires_at: 200,
|
||||
protocol_major: 1,
|
||||
state_schema: 1,
|
||||
minimum_updater_version: 1,
|
||||
artifacts: [
|
||||
ArtifactDescriptor {
|
||||
role: ArtifactRole::Agent,
|
||||
artifact_id: Uuid::new_v4(),
|
||||
sha256: hash(b"agent"),
|
||||
bytes: 10,
|
||||
},
|
||||
ArtifactDescriptor {
|
||||
role: ArtifactRole::Helper,
|
||||
artifact_id: Uuid::new_v4(),
|
||||
sha256: hash(b"helper"),
|
||||
bytes: 20,
|
||||
},
|
||||
],
|
||||
};
|
||||
let raw = encode(&manifest).unwrap();
|
||||
let mut message = rmm_updater::RELEASE_SIGNATURE_DOMAIN.to_vec();
|
||||
message.extend_from_slice(&raw);
|
||||
let signature = Signer::new_without_digest(&key)
|
||||
.unwrap()
|
||||
.sign_oneshot_to_vec(&message)
|
||||
.unwrap();
|
||||
let envelope = ReleaseEnvelope {
|
||||
schema_version: 1,
|
||||
key_id: hash(&public),
|
||||
payload_bytes: URL_SAFE_NO_PAD.encode(&raw),
|
||||
signature: URL_SAFE_NO_PAD.encode(signature),
|
||||
};
|
||||
let keys = UpdateKeyringFile {
|
||||
schema_version: 1,
|
||||
generation: 7,
|
||||
keys: vec![UpdateKeyringEntry {
|
||||
public_key_hex: hex::encode(public),
|
||||
platform,
|
||||
first_sequence: 1,
|
||||
last_sequence: 4,
|
||||
revoked: false,
|
||||
}],
|
||||
};
|
||||
(envelope, keys)
|
||||
};
|
||||
let (linux, linux_keys) = make(Platform::LinuxX64);
|
||||
let (windows, windows_keys) = make(Platform::WindowsX64);
|
||||
let linux_raw = encode(&linux_keys).unwrap();
|
||||
let windows_raw = encode(&windows_keys).unwrap();
|
||||
assert_eq!(
|
||||
verify_envelope_with_keyring(&linux, None, &linux_raw, 100)
|
||||
.unwrap()
|
||||
.platform,
|
||||
Platform::LinuxX64
|
||||
);
|
||||
assert_eq!(
|
||||
verify_envelope_with_keyring(&windows, None, &windows_raw, 100)
|
||||
.unwrap()
|
||||
.platform,
|
||||
Platform::WindowsX64
|
||||
);
|
||||
assert!(verify_envelope_with_keyring(&windows, None, &linux_raw, 100).is_err());
|
||||
assert!(verify_envelope_with_keyring(&linux, None, &windows_raw, 100).is_err());
|
||||
let fixture: Value = serde_json::from_str(include_str!(
|
||||
"../../../tests/agent_update/codec-golden.json"
|
||||
))
|
||||
.unwrap();
|
||||
let mut binding: UpdaterBinding = serde_json::from_value(
|
||||
fixture["linux_full"]["payload"]["jobs"][0]["payload"]["action"]["update"]["updater"]
|
||||
.clone(),
|
||||
)
|
||||
.unwrap();
|
||||
binding.keyring_generation = 7;
|
||||
binding.keyring_sha256 = hash(&linux_raw);
|
||||
assert!(verify_envelope_with_keyring(&linux, Some(&binding), &linux_raw, 100).is_ok());
|
||||
binding.keyring_generation = 8;
|
||||
assert!(verify_envelope_with_keyring(&linux, Some(&binding), &linux_raw, 100).is_err());
|
||||
binding.keyring_generation = 7;
|
||||
binding.keyring_sha256 = hash(b"different raw bytes");
|
||||
assert!(verify_envelope_with_keyring(&linux, Some(&binding), &linux_raw, 100).is_err());
|
||||
let mut forged = linux.clone();
|
||||
forged.signature = URL_SAFE_NO_PAD.encode([0u8; 64]);
|
||||
assert!(verify_envelope_with_keyring(&forged, None, &linux_raw, 100).is_err());
|
||||
let mut revoked = linux_keys;
|
||||
revoked.keys[0].revoked = true;
|
||||
assert!(
|
||||
verify_envelope_with_keyring(&linux, None, &encode(&revoked).unwrap(), 100).is_err()
|
||||
);
|
||||
let mut changed = linux.decode().unwrap().manifest;
|
||||
changed.platform = Platform::WindowsX64;
|
||||
let mut forged = linux;
|
||||
forged.payload_bytes = URL_SAFE_NO_PAD.encode(encode(&changed).unwrap());
|
||||
assert!(verify_envelope_with_keyring(&forged, None, &linux_raw, 100).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn actual_codec_pair_plan_requires_exact_per_attempt_artifact_authority() {
|
||||
let fixtures: Value = serde_json::from_str(include_str!(
|
||||
"../../../tests/agent_update/codec-golden.json"
|
||||
|
||||
@@ -113,6 +113,7 @@ pub struct Directory {
|
||||
fd: File,
|
||||
path: PathBuf,
|
||||
identity: Identity,
|
||||
agent_state: bool,
|
||||
}
|
||||
impl Directory {
|
||||
/// All ancestors are held while opening their child with O_NOFOLLOW. A
|
||||
@@ -143,13 +144,46 @@ impl Directory {
|
||||
identity: Identity::of(&m),
|
||||
fd,
|
||||
path: path.to_path_buf(),
|
||||
agent_state: false,
|
||||
})
|
||||
}
|
||||
/// Read/stage-input traversal only, rooted at the fixed private agent state.
|
||||
/// Install roots continue using the stricter root-ancestor constructor.
|
||||
/// Every descendant is opened relative to a held fd, without symlinks, and
|
||||
/// must remain private UID993 state; no network-selected ancestor is trusted.
|
||||
pub fn open_agent_state(path: &Path) -> Result<Self> {
|
||||
let base = Path::new("/var/lib/rmm-agent-remote");
|
||||
let suffix = path.strip_prefix(base).context("UPDATE_AGENT_STATE_ROOT")?;
|
||||
let root = Self::open(base, 993, true)?;
|
||||
let mut fd = root.fd.try_clone()?;
|
||||
for component in suffix.components() {
|
||||
let Component::Normal(name) = component else {
|
||||
anyhow::bail!("UPDATE_AGENT_STATE_COMPONENT")
|
||||
};
|
||||
fd = openat(&fd, name, libc::O_RDONLY | libc::O_DIRECTORY, 0)?;
|
||||
let m = fd.metadata()?;
|
||||
ensure!(
|
||||
m.is_dir() && m.uid() == 993 && m.mode() & 0o077 == 0,
|
||||
"UPDATE_AGENT_STATE_PRIVATE_DIRECTORY"
|
||||
);
|
||||
}
|
||||
root.verify()?;
|
||||
Ok(Self {
|
||||
identity: Identity::of(&fd.metadata()?),
|
||||
fd,
|
||||
path: path.into(),
|
||||
agent_state: true,
|
||||
})
|
||||
}
|
||||
pub fn identity(&self) -> &Identity {
|
||||
&self.identity
|
||||
}
|
||||
pub fn verify(&self) -> Result<()> {
|
||||
let current = Self::open(&self.path, self.identity.uid, false)?;
|
||||
let current = if self.agent_state {
|
||||
Self::open_agent_state(&self.path)?
|
||||
} else {
|
||||
Self::open(&self.path, self.identity.uid, false)?
|
||||
};
|
||||
ensure!(
|
||||
current.identity == self.identity
|
||||
&& Identity::of(&self.fd.metadata()?) == self.identity,
|
||||
@@ -198,7 +232,7 @@ impl Directory {
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn absent(&self, basename: &OsStr) -> Result<()> {
|
||||
pub fn absent(&self, basename: &OsStr) -> Result<()> {
|
||||
let value = name(basename)?;
|
||||
let mut m = std::mem::MaybeUninit::<libc::stat>::uninit();
|
||||
// SAFETY: live dirfd, valid basename, properly sized writable stat.
|
||||
@@ -251,6 +285,13 @@ impl HeldFile {
|
||||
pub fn proof(&self) -> &FileProof {
|
||||
&self.proof
|
||||
}
|
||||
/// A held read-only, hash-verified fd for bounded streaming into a stage.
|
||||
/// The destination independently verifies the final length/hash/EOF again.
|
||||
pub fn reader(&mut self) -> Result<&mut File> {
|
||||
self.verify(self.proof.bytes)?;
|
||||
self.fd.seek(SeekFrom::Start(0))?;
|
||||
Ok(&mut self.fd)
|
||||
}
|
||||
pub fn verify(&mut self, max: u64) -> Result<()> {
|
||||
let m = self.fd.metadata()?;
|
||||
ensure!(
|
||||
@@ -544,6 +585,9 @@ pub struct Installed {
|
||||
new: FileProof,
|
||||
}
|
||||
impl Installed {
|
||||
pub fn role(&self) -> Role {
|
||||
self.role
|
||||
}
|
||||
pub fn old(&self) -> &FileProof {
|
||||
&self.old
|
||||
}
|
||||
@@ -564,10 +608,14 @@ impl Installed {
|
||||
dir.file(OsStr::new(&self.backup), &self.old, 256 * 1024 * 1024)?;
|
||||
let displaced = self.backup.replace(".previous", ".rejected");
|
||||
dir.absent(OsStr::new(&displaced))?;
|
||||
let effect = Effect::RestorePredecessor { role: self.role };
|
||||
fence.before_effect(&effect)?;
|
||||
let save = Effect::SaveRejectedCandidate { role: self.role };
|
||||
fence.before_effect(&save)?;
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.rename_new(OsStr::new(&self.target), OsStr::new(&displaced))?;
|
||||
dir.file(OsStr::new(&displaced), &self.new, 256 * 1024 * 1024)?;
|
||||
fence.after_effect(&save, &digest(&serde_json::to_vec(&self.new)?))?;
|
||||
let effect = Effect::RestorePredecessor { role: self.role };
|
||||
fence.before_effect(&effect)?;
|
||||
// No existing target can be overwritten; both code generations remain.
|
||||
guard.verify_for_effect(budget)?;
|
||||
dir.rename_new(OsStr::new(&self.backup), OsStr::new(&self.target))?;
|
||||
|
||||
@@ -64,6 +64,7 @@ pub enum Effect {
|
||||
PublishReplacement { role: files::Role },
|
||||
StartService { service: services::Service },
|
||||
RestorePredecessor { role: files::Role },
|
||||
SaveRejectedCandidate { role: files::Role },
|
||||
ReturnLedger,
|
||||
}
|
||||
|
||||
|
||||
@@ -150,22 +150,117 @@ impl Systemd {
|
||||
],
|
||||
budget,
|
||||
)?;
|
||||
let text = std::str::from_utf8(&output)?;
|
||||
let mut fields = BTreeMap::new();
|
||||
for row in text.lines() {
|
||||
let (k, v) = row
|
||||
parse_service_status(&output)
|
||||
}
|
||||
fn failure_status(service: Service, budget: &Budget) -> Result<BTreeMap<String, String>> {
|
||||
let bytes = command(
|
||||
&[
|
||||
"show",
|
||||
service.unit(),
|
||||
"-p",
|
||||
"SubState",
|
||||
"-p",
|
||||
"ControlPID",
|
||||
"-p",
|
||||
"Result",
|
||||
"-p",
|
||||
"ExecMainCode",
|
||||
"-p",
|
||||
"ExecMainStatus",
|
||||
"-p",
|
||||
"Job",
|
||||
"-p",
|
||||
"ControlGroup",
|
||||
],
|
||||
budget,
|
||||
)?;
|
||||
let mut status = BTreeMap::new();
|
||||
for line in std::str::from_utf8(&bytes)?.lines() {
|
||||
let (k, v) = line
|
||||
.split_once('=')
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_SYSTEMD_RESPONSE"))?;
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_FAILED_STATUS"))?;
|
||||
ensure!(
|
||||
fields.insert(k.into(), v.into()).is_none(),
|
||||
"UPDATE_SYSTEMD_DUPLICATE"
|
||||
status.insert(k.to_owned(), v.to_owned()).is_none(),
|
||||
"UPDATE_FAILED_STATUS_DUPLICATE"
|
||||
);
|
||||
}
|
||||
ensure!(status.len() == 7, "UPDATE_FAILED_STATUS_FIELDS");
|
||||
Ok(status)
|
||||
}
|
||||
fn failed_start(&self, service: Service, budget: &Budget) -> Result<FailedStartProof> {
|
||||
let pin = self
|
||||
.policies
|
||||
.iter()
|
||||
.find(|p| p.service == service)
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_SERVICE_NOT_PINNED"))?;
|
||||
let first = Self::status(service, budget)?;
|
||||
let extra = Self::failure_status(service, budget)?;
|
||||
ensure!(
|
||||
fields.len() == 8 && fields.get("LoadState").is_some_and(|v| v == "loaded"),
|
||||
"UPDATE_SYSTEMD_LOADED"
|
||||
first["ActiveState"] == "failed"
|
||||
&& first["MainPID"] == "0"
|
||||
&& extra["SubState"] == "failed"
|
||||
&& extra["ControlPID"] == "0"
|
||||
&& extra["Job"].is_empty()
|
||||
&& extra["ControlGroup"].is_empty()
|
||||
&& matches!(
|
||||
extra["Result"].as_str(),
|
||||
"exit-code"
|
||||
| "signal"
|
||||
| "core-dump"
|
||||
| "timeout"
|
||||
| "protocol"
|
||||
| "resources"
|
||||
| "start-limit-hit"
|
||||
)
|
||||
&& first["InvocationID"].len() == 32
|
||||
&& first["InvocationID"].bytes().any(|b| b != b'0')
|
||||
&& first["InvocationID"].bytes().all(|b| b.is_ascii_hexdigit())
|
||||
&& unit_composition(&first)? == pin.unit_sha256,
|
||||
"UPDATE_START_FAILURE_NOT_CLOSED"
|
||||
);
|
||||
Ok(fields)
|
||||
ensure!(
|
||||
Self::status(service, budget)? == first
|
||||
&& Self::failure_status(service, budget)? == extra,
|
||||
"UPDATE_START_FAILURE_CHANGED"
|
||||
);
|
||||
let mut status = first;
|
||||
status.extend(extra);
|
||||
Ok(FailedStartProof {
|
||||
service,
|
||||
unit_sha256: pin.unit_sha256.clone(),
|
||||
status,
|
||||
})
|
||||
}
|
||||
pub fn verify_failed_start(&self, expected: &FailedStartProof, budget: &Budget) -> Result<()> {
|
||||
ensure!(
|
||||
self.failed_start(expected.service, budget)? == *expected,
|
||||
"UPDATE_FAILED_START_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn verify_inactive(&self, service: Service, budget: &Budget) -> Result<()> {
|
||||
let pin = self
|
||||
.policies
|
||||
.iter()
|
||||
.find(|p| p.service == service)
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_SERVICE_NOT_PINNED"))?;
|
||||
let status = Self::status(service, budget)?;
|
||||
let extra = Self::failure_status(service, budget)?;
|
||||
ensure!(
|
||||
status["ActiveState"] == "inactive"
|
||||
&& status["MainPID"] == "0"
|
||||
&& extra["ControlPID"] == "0"
|
||||
&& extra["Job"].is_empty()
|
||||
&& extra["ControlGroup"].is_empty()
|
||||
&& unit_composition(&status)? == pin.unit_sha256,
|
||||
"UPDATE_SERVICE_NOT_CLOSED_INACTIVE"
|
||||
);
|
||||
ensure!(
|
||||
Self::status(service, budget)? == status
|
||||
&& Self::failure_status(service, budget)? == extra,
|
||||
"UPDATE_INACTIVE_SERVICE_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn observe(&self, service: Service, budget: &Budget) -> Result<HeldService> {
|
||||
let pin = self
|
||||
@@ -265,6 +360,9 @@ impl Systemd {
|
||||
let result = StoppedServices {
|
||||
systemd: self,
|
||||
original,
|
||||
failed: None,
|
||||
subsequently_exited: Vec::new(),
|
||||
early_full_failure: None,
|
||||
};
|
||||
result.verify_still_stopped(budget)?;
|
||||
Ok(result)
|
||||
@@ -356,17 +454,170 @@ impl HeldService {
|
||||
pub struct StoppedServices {
|
||||
systemd: Systemd,
|
||||
original: Vec<HeldService>,
|
||||
failed: Option<FailedStartProof>,
|
||||
subsequently_exited: Vec<HeldService>,
|
||||
early_full_failure: Option<EarlyFullFailure>,
|
||||
}
|
||||
/// Concrete systemd failure of our acknowledged once-only start. A timeout,
|
||||
/// lost command reply, activating/auto-restart or residual control process is
|
||||
/// never represented by this value.
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct FailedStartProof {
|
||||
pub service: Service,
|
||||
pub unit_sha256: String,
|
||||
pub status: BTreeMap<String, String>,
|
||||
}
|
||||
pub enum Startup {
|
||||
Complete {
|
||||
started: Vec<HeldService>,
|
||||
stopped: StoppedServices,
|
||||
},
|
||||
KnownFailed(KnownStartupFailure),
|
||||
}
|
||||
/// Retained only by the live worker that actually started and stopped the new
|
||||
/// General under the original conditional reservation. Not deserializable.
|
||||
pub struct EarlyFullFailure {
|
||||
general_start: ServiceProof,
|
||||
general_stop_sha256: String,
|
||||
failure: FailedStartProof,
|
||||
}
|
||||
impl EarlyFullFailure {
|
||||
pub fn general_start(&self) -> &ServiceProof {
|
||||
&self.general_start
|
||||
}
|
||||
pub fn general_stop_sha256(&self) -> &str {
|
||||
&self.general_stop_sha256
|
||||
}
|
||||
pub fn failure(&self) -> &FailedStartProof {
|
||||
&self.failure
|
||||
}
|
||||
pub fn failure_sha256(&self) -> Result<String> {
|
||||
Ok(digest(&serde_json::to_vec(&self.failure)?))
|
||||
}
|
||||
}
|
||||
pub struct KnownStartupFailure {
|
||||
stopped: StoppedServices,
|
||||
target: Systemd,
|
||||
started: Vec<HeldService>,
|
||||
failure: FailedStartProof,
|
||||
}
|
||||
impl KnownStartupFailure {
|
||||
pub fn failure(&self) -> &FailedStartProof {
|
||||
&self.failure
|
||||
}
|
||||
pub fn started(&self) -> &[HeldService] {
|
||||
&self.started
|
||||
}
|
||||
pub fn verify(&self, budget: &Budget) -> Result<()> {
|
||||
budget.check()?;
|
||||
self.target.verify_failed_start(&self.failure, budget)?;
|
||||
for held in &self.started {
|
||||
held.verify(budget)?;
|
||||
}
|
||||
for service in [Service::General, Service::Full, Service::Agent] {
|
||||
if service == self.failure.service
|
||||
|| self.started.iter().any(|s| s.proof.service == service)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
self.target.verify_inactive(service, budget)?;
|
||||
}
|
||||
ensure!(
|
||||
self.stopped
|
||||
.original
|
||||
.iter()
|
||||
.all(|s| s.process.exited().unwrap_or(false)),
|
||||
"UPDATE_OLD_PROCESS_STILL_LIVE"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
/// An early Full failure leaves only the newly started General reader.
|
||||
/// The embedding fence must hold its original first-return conditional
|
||||
/// reservation. No SQLite may be opened until this exact held PID exits.
|
||||
pub fn stop_reserved_general(
|
||||
mut self,
|
||||
budget: &Budget,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<(StoppedServices, ServiceProof, String)> {
|
||||
self.verify(budget)?;
|
||||
ensure!(
|
||||
self.failure.service == Service::Full
|
||||
&& self.started.len() == 1
|
||||
&& self.started[0].proof.service == Service::General,
|
||||
"UPDATE_CONDITIONAL_STOP_ONLY_EARLY_FULL_FAILURE"
|
||||
);
|
||||
let held = &self.started[0];
|
||||
let proof = held.proof.clone();
|
||||
let effect = Effect::StopService {
|
||||
service: Service::General,
|
||||
};
|
||||
fence.before_effect(&effect)?;
|
||||
command(&["--no-block", "stop", Service::General.unit()], budget)?;
|
||||
loop {
|
||||
budget.check()?;
|
||||
self.target.verify_failed_start(&self.failure, budget)?;
|
||||
self.target.verify_inactive(Service::Agent, budget)?;
|
||||
let state = Systemd::status(Service::General, budget)?;
|
||||
ensure!(
|
||||
state["MainPID"] == "0" || state["MainPID"] == proof.process.pid.to_string(),
|
||||
"UPDATE_CONDITIONAL_STOP_PID_CHANGED"
|
||||
);
|
||||
if state["ActiveState"] == "inactive"
|
||||
&& state["MainPID"] == "0"
|
||||
&& held.process.exited()?
|
||||
{
|
||||
break;
|
||||
}
|
||||
thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
let observation = digest(&serde_json::to_vec(&(
|
||||
"reserved_general_stop_v1",
|
||||
&proof,
|
||||
&self.failure,
|
||||
))?);
|
||||
fence.after_effect(&effect, &observation)?;
|
||||
self.stopped.subsequently_exited.append(&mut self.started);
|
||||
self.stopped.failed = Some(self.failure.clone());
|
||||
self.stopped.early_full_failure = Some(EarlyFullFailure {
|
||||
general_start: proof.clone(),
|
||||
general_stop_sha256: observation.clone(),
|
||||
failure: self.failure,
|
||||
});
|
||||
self.stopped.verify_still_stopped(budget)?;
|
||||
Ok((self.stopped, proof, observation))
|
||||
}
|
||||
}
|
||||
impl StoppedServices {
|
||||
pub fn early_full_failure(&self, budget: &Budget) -> Result<&EarlyFullFailure> {
|
||||
self.verify_still_stopped(budget)?;
|
||||
let proof = self
|
||||
.early_full_failure
|
||||
.as_ref()
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_NO_RETAINED_EARLY_FAILURE"))?;
|
||||
ensure!(
|
||||
self.subsequently_exited.len() == 1
|
||||
&& self.subsequently_exited[0].proof == proof.general_start
|
||||
&& self.subsequently_exited[0].process.exited()?,
|
||||
"UPDATE_RETAINED_GENERAL_STOP_CHANGED"
|
||||
);
|
||||
Ok(proof)
|
||||
}
|
||||
pub fn verify_still_stopped(&self, budget: &Budget) -> Result<()> {
|
||||
for pin in &self.systemd.policies {
|
||||
let s = Systemd::status(pin.service, budget)?;
|
||||
ensure!(
|
||||
s["ActiveState"] == "inactive"
|
||||
&& s["MainPID"] == "0"
|
||||
&& unit_composition(&s)? == pin.unit_sha256,
|
||||
"UPDATE_READER_NOT_STOPPED"
|
||||
);
|
||||
if let Some(failed) = self.failed.as_ref().filter(|f| f.service == pin.service) {
|
||||
// Unit composition is still the provisioned original unit;
|
||||
// only code/config files were part of the approved transition.
|
||||
self.systemd.verify_failed_start(failed, budget)?;
|
||||
} else {
|
||||
ensure!(
|
||||
s["ActiveState"] == "inactive"
|
||||
&& s["MainPID"] == "0"
|
||||
&& unit_composition(&s)? == pin.unit_sha256,
|
||||
"UPDATE_READER_NOT_STOPPED"
|
||||
);
|
||||
}
|
||||
if pin.service == Service::Apt {
|
||||
ensure!(
|
||||
s["UnitFileState"] == "disabled",
|
||||
@@ -377,6 +628,7 @@ impl StoppedServices {
|
||||
ensure!(
|
||||
self.original
|
||||
.iter()
|
||||
.chain(self.subsequently_exited.iter())
|
||||
.all(|s| s.process.exited().unwrap_or(false)),
|
||||
"UPDATE_OLD_PROCESS_STILL_LIVE"
|
||||
);
|
||||
@@ -393,6 +645,17 @@ impl StoppedServices {
|
||||
budget: &Budget,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Vec<HeldService>> {
|
||||
match self.start_once_observed(new, budget, fence)? {
|
||||
Startup::Complete { started, .. } => Ok(started),
|
||||
Startup::KnownFailed(_) => anyhow::bail!("UPDATE_START_KNOWN_FAILED"),
|
||||
}
|
||||
}
|
||||
pub fn start_once_observed(
|
||||
self,
|
||||
new: Systemd,
|
||||
budget: &Budget,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Startup> {
|
||||
self.verify_still_stopped(budget)?;
|
||||
ensure!(
|
||||
self.systemd
|
||||
@@ -424,6 +687,17 @@ impl StoppedServices {
|
||||
started.push(held);
|
||||
break;
|
||||
}
|
||||
if state["ActiveState"] == "failed" {
|
||||
let failure = new.failed_start(service, budget)?;
|
||||
let result = KnownStartupFailure {
|
||||
stopped: self,
|
||||
target: new,
|
||||
started,
|
||||
failure,
|
||||
};
|
||||
result.verify(budget)?;
|
||||
return Ok(Startup::KnownFailed(result));
|
||||
}
|
||||
ensure!(
|
||||
state["ActiveState"] == "activating" || state["ActiveState"] == "active",
|
||||
"UPDATE_START_UNPROVEN"
|
||||
@@ -433,10 +707,40 @@ impl StoppedServices {
|
||||
}
|
||||
// Return in the canonical Handoff stop-set order, not actual start order.
|
||||
started.sort_by_key(|s| s.proof.service);
|
||||
Ok(started)
|
||||
Ok(Startup::Complete {
|
||||
started,
|
||||
stopped: self,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_service_status(raw: &[u8]) -> Result<BTreeMap<String, String>> {
|
||||
const FIELDS: [&str; 7] = [
|
||||
"LoadState",
|
||||
"ActiveState",
|
||||
"MainPID",
|
||||
"InvocationID",
|
||||
"UnitFileState",
|
||||
"FragmentPath",
|
||||
"DropInPaths",
|
||||
];
|
||||
let mut fields = BTreeMap::new();
|
||||
for row in std::str::from_utf8(raw)?.lines() {
|
||||
let (k, v) = row
|
||||
.split_once('=')
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_SYSTEMD_RESPONSE"))?;
|
||||
ensure!(
|
||||
FIELDS.contains(&k) && fields.insert(k.into(), v.into()).is_none(),
|
||||
"UPDATE_SYSTEMD_PROPERTIES"
|
||||
);
|
||||
}
|
||||
ensure!(
|
||||
fields.len() == FIELDS.len() && fields.get("LoadState").is_some_and(|s| s == "loaded"),
|
||||
"UPDATE_SYSTEMD_LOADED"
|
||||
);
|
||||
Ok(fields)
|
||||
}
|
||||
|
||||
fn unit_composition(fields: &BTreeMap<String, String>) -> Result<String> {
|
||||
use crate::files::Directory;
|
||||
use std::{ffi::OsStr, path::Path};
|
||||
@@ -550,3 +854,20 @@ fn command(args: &[&str], budget: &Budget) -> Result<Vec<u8>> {
|
||||
thread::sleep(Duration::from_millis(5));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod status_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn accepts_actual_seven_property_shape_and_denies_missing_or_extra_properties() {
|
||||
let status=b"LoadState=loaded\nActiveState=active\nMainPID=123\nInvocationID=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nUnitFileState=enabled\nFragmentPath=/etc/systemd/system/rmm-agent-remote.service\nDropInPaths=\n";
|
||||
assert_eq!(parse_service_status(status).unwrap().len(), 7);
|
||||
let mut extra = status.to_vec();
|
||||
extra.extend_from_slice(b"Unexpected=1\n");
|
||||
assert!(parse_service_status(&extra).is_err());
|
||||
assert!(parse_service_status(b"LoadState=loaded\nActiveState=active\n").is_err());
|
||||
let mut duplicate = status.to_vec();
|
||||
duplicate.extend_from_slice(b"MainPID=321\n");
|
||||
assert!(parse_service_status(&duplicate).is_err());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,355 @@
|
||||
//! Administrative public metadata only. No files, keys, services or jobs written.
|
||||
use anyhow::{Result, ensure};
|
||||
use ed25519_dalek::VerifyingKey;
|
||||
use rmm_domain::{
|
||||
agent_update::{ReleaseEnvelope, ReleaseManifest, UpdateKeyringFile},
|
||||
agent_update_provisioning::{HealthKeyPin, InstalledReleaseRecord, LocalUpdatePolicy},
|
||||
jobs::hash,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use std::io::Read;
|
||||
use uuid::Uuid;
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)]
|
||||
enum Input {
|
||||
RenderFull {
|
||||
config: Vec<u8>,
|
||||
pin: Vec<u8>,
|
||||
job_public_key_hex: String,
|
||||
new_helper_sha256: String,
|
||||
},
|
||||
Registry {
|
||||
qualification_sha256: String,
|
||||
},
|
||||
QualifyPair {
|
||||
minimum_generation: u64,
|
||||
expected_agent_sha256: String,
|
||||
expected_helper_sha256: String,
|
||||
unit_pins: Vec<rmm_domain::agent_update_provisioning::LocalServicePin>,
|
||||
},
|
||||
ValidatePublicBundle {
|
||||
record: Vec<u8>,
|
||||
policy: Vec<u8>,
|
||||
keyring: Vec<u8>,
|
||||
health_pin: Vec<u8>,
|
||||
},
|
||||
CanonicalRelease {
|
||||
manifest: ReleaseManifest,
|
||||
},
|
||||
CanonicalRecord {
|
||||
record: InstalledReleaseRecord,
|
||||
},
|
||||
CanonicalPolicy {
|
||||
policy: Box<LocalUpdatePolicy>,
|
||||
},
|
||||
ValidateRelease {
|
||||
envelope: ReleaseEnvelope,
|
||||
},
|
||||
}
|
||||
/// Independent, read-only administrator sample after the coordinated pair
|
||||
/// bootstrap. Fresh normal server signatures are checked at the CURRENT native
|
||||
/// clock; neither old historical rows nor bootstrap metadata create a lease.
|
||||
fn qualify_pair(
|
||||
minimum_generation: u64,
|
||||
agent_sha256: &str,
|
||||
helper_sha256: &str,
|
||||
pins: &[rmm_domain::agent_update_provisioning::LocalServicePin],
|
||||
) -> Result<serde_json::Value> {
|
||||
use prost::Message;
|
||||
use rmm_agent_core::{
|
||||
auth::Binding,
|
||||
auth::HelperIdentity,
|
||||
crypto::DalekVerifier,
|
||||
helper_reconcile::{SignedResponse, verify_checkpoint_repair_history_with},
|
||||
reconcile::{Channel, SyncClock, verify_response_with},
|
||||
};
|
||||
use rmm_protocol::{SyncRequest, SyncResponse};
|
||||
use rmm_updater_linux::{
|
||||
Budget,
|
||||
services::{Service, ServicePolicy, Systemd},
|
||||
};
|
||||
use rusqlite::{Connection, OpenFlags};
|
||||
use std::os::{fd::AsRawFd, unix::fs::MetadataExt};
|
||||
ensure!(
|
||||
unsafe { libc::geteuid() } == 0
|
||||
&& minimum_generation > 0
|
||||
&& [agent_sha256, helper_sha256]
|
||||
.iter()
|
||||
.all(|v| rmm_domain::agent_update::digest(v)),
|
||||
"BOOTSTRAP_QUALIFICATION_SCOPE"
|
||||
);
|
||||
let boot: Uuid = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?
|
||||
.trim()
|
||||
.parse()?;
|
||||
let budget = Budget::new(boot, std::time::Duration::from_secs(30))?;
|
||||
let clock = rmm_updater_worker::clock::NativeClock::new()?;
|
||||
let mut policies = Vec::new();
|
||||
for (index, pin) in pins.iter().enumerate() {
|
||||
let service = match index {
|
||||
0 => Service::Agent,
|
||||
1 => Service::General,
|
||||
2 => Service::Full,
|
||||
3 => Service::Apt,
|
||||
_ => anyhow::bail!("BOOTSTRAP_UNIT_PIN_SET"),
|
||||
};
|
||||
ensure!(pin.unit == service.unit(), "BOOTSTRAP_UNIT_PIN_SET");
|
||||
policies.push(ServicePolicy {
|
||||
service,
|
||||
image_sha256: if index == 0 {
|
||||
agent_sha256
|
||||
} else {
|
||||
helper_sha256
|
||||
}
|
||||
.into(),
|
||||
unit_sha256: pin.unit_sha256.clone(),
|
||||
});
|
||||
}
|
||||
let system = Systemd::new(policies)?;
|
||||
let held = [
|
||||
system.observe(Service::Agent, &budget)?,
|
||||
system.observe(Service::General, &budget)?,
|
||||
system.observe(Service::Full, &budget)?,
|
||||
];
|
||||
if pins.len() == 4 {
|
||||
system.verify_inactive(Service::Apt, &budget)?;
|
||||
}
|
||||
let binding_path = std::path::Path::new("/var/lib/rmm-agent-remote/binding.json");
|
||||
let metadata = std::fs::symlink_metadata(binding_path)?;
|
||||
ensure!(
|
||||
metadata.is_file()
|
||||
&& !metadata.file_type().is_symlink()
|
||||
&& metadata.uid() == 993
|
||||
&& metadata.nlink() == 1
|
||||
&& metadata.mode() & 0o077 == 0,
|
||||
"BOOTSTRAP_AGENT_PUBLIC_BINDING"
|
||||
);
|
||||
let binding_raw = std::fs::read(binding_path)?;
|
||||
ensure!(binding_raw.len() <= 8192, "BOOTSTRAP_BINDING_LIMIT");
|
||||
let mut binding: Binding = serde_json::from_slice(&binding_raw)?;
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct PublicKeyRecord { key_id:String, algorithm:String, schema_version:u32, public_key_hex:String }
|
||||
let mut effective = None;
|
||||
for (path,owner) in [("/var/lib/rmm-agent-remote/job-signing-key.json",993),("/etc/rmm-remote/helper-signing-key.json",0)] {
|
||||
let path=std::path::Path::new(path);let info=std::fs::symlink_metadata(path)?;
|
||||
ensure!(info.is_file()&&!info.file_type().is_symlink()&&info.uid()==owner&&info.nlink()==1&&info.mode()&0o022==0&&info.len()<=4096,"BOOTSTRAP_PROTECTED_PUBLIC_KEY_RECORD");
|
||||
let raw=std::fs::read(path)?;let key:PublicKeyRecord=serde_json::from_slice(&raw)?;let public:[u8;32]=hex::decode(&key.public_key_hex)?.try_into().map_err(|_|anyhow::anyhow!("BOOTSTRAP_PUBLIC_KEY_SIZE"))?;
|
||||
ensure!(key.schema_version==1&&key.algorithm=="Ed25519"&&key.key_id==hash(&public)&&!VerifyingKey::from_bytes(&public)?.is_weak(),"BOOTSTRAP_PUBLIC_KEY_RECORD");
|
||||
if let Some(old)=&effective{ensure!(old==&key.public_key_hex,"BOOTSTRAP_INDEPENDENT_KEY_PINS_DIFFER");}else{effective=Some(key.public_key_hex);}
|
||||
ensure!(std::fs::read(path)?==raw,"BOOTSTRAP_PUBLIC_KEY_RECORD_CHANGED");
|
||||
}
|
||||
let effective=effective.ok_or_else(||anyhow::anyhow!("BOOTSTRAP_PUBLIC_KEY_REQUIRED"))?;
|
||||
ensure!(binding.public_key_hex.is_empty()||binding.public_key_hex==effective,"BOOTSTRAP_BINDING_PUBLIC_KEY");binding.public_key_hex=effective;
|
||||
let lock = std::fs::File::open("/var/lib/rmm-helper/executor.lock")?;
|
||||
ensure!(
|
||||
unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0,
|
||||
"BOOTSTRAP_HELPER_BUSY"
|
||||
);
|
||||
let open = |path: &str| -> Result<Connection> {
|
||||
ensure!(
|
||||
!std::path::Path::new(&format!("{path}-wal")).exists()
|
||||
&& !std::path::Path::new(&format!("{path}-shm")).exists(),
|
||||
"BOOTSTRAP_DELETE_JOURNAL_REQUIRED"
|
||||
);
|
||||
let db = Connection::open_with_flags(
|
||||
path,
|
||||
OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
|
||||
)?;
|
||||
db.busy_timeout(std::time::Duration::from_millis(250))?;
|
||||
db.execute_batch("PRAGMA query_only=ON;")?;
|
||||
ensure!(
|
||||
db.query_row("PRAGMA journal_mode", [], |r| r.get::<_, String>(0))? == "delete"
|
||||
&& db.query_row("PRAGMA integrity_check", [], |r| r.get::<_, String>(0))? == "ok",
|
||||
"BOOTSTRAP_JOURNAL_INTEGRITY"
|
||||
);
|
||||
Ok(db)
|
||||
};
|
||||
let agent = open("/var/lib/rmm-agent-remote/journal.sqlite")?;
|
||||
let consumption = open("/var/lib/rmm-agent-remote/consumption.sqlite")?;
|
||||
let helper = open("/var/lib/rmm-helper/consumption.sqlite")?;
|
||||
ensure!(agent.query_row("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')",[],|r|r.get::<_,u64>(0))?==0,"BOOTSTRAP_OPEN_AGENT_JOB");
|
||||
for db in [&consumption, &helper] {
|
||||
ensure!(
|
||||
db.query_row(
|
||||
"SELECT count(*) FROM consumed WHERE result IS NULL",
|
||||
[],
|
||||
|r| r.get::<_, u64>(0)
|
||||
)? == 0,
|
||||
"BOOTSTRAP_UNRESOLVED_CONSUMPTION"
|
||||
);
|
||||
}
|
||||
let (generation,decision):(u64,String)=agent.query_row("SELECT generation,last_decision FROM reconcile_meta WHERE id=1 AND fault IS NULL AND pending_request IS NULL",[],|r|Ok((r.get(0)?,r.get(1)?)))?;
|
||||
ensure!(
|
||||
generation > minimum_generation,
|
||||
"BOOTSTRAP_NEW_GENERATION_REQUIRED"
|
||||
);
|
||||
let (h_generation, h_decision): (u64, String) = helper.query_row(
|
||||
"SELECT generation,last_decision FROM helper_sync_meta WHERE id=1 AND fault IS NULL",
|
||||
[],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
generation == h_generation && decision == h_decision,
|
||||
"BOOTSTRAP_PAIR_NORMAL_SYNC_NOT_ALIGNED"
|
||||
);
|
||||
let (hrequest, hresponse): (Vec<u8>, Vec<u8>) = helper.query_row(
|
||||
"SELECT request,response FROM helper_sync_decisions WHERE decision_id=?1",
|
||||
[&decision],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
let signed: SignedResponse = serde_json::from_slice(&hresponse)?;
|
||||
let request = SyncRequest::decode(hrequest.as_slice())?;
|
||||
ensure!(
|
||||
request.encode_to_vec() == hrequest,
|
||||
"BOOTSTRAP_SYNC_REQUEST_CANONICAL"
|
||||
);
|
||||
let response = SyncResponse {
|
||||
decision_bytes: signed.decision_bytes.clone(),
|
||||
signature: signed.signature.clone(),
|
||||
};
|
||||
let applied = verify_response_with(
|
||||
&DalekVerifier,
|
||||
&binding,
|
||||
&request,
|
||||
&Channel {
|
||||
connection_generation: generation,
|
||||
boot_id: boot,
|
||||
},
|
||||
&response,
|
||||
clock.now()?,
|
||||
)?;
|
||||
ensure!(
|
||||
applied.decision_id.to_string() == decision
|
||||
&& applied.ready
|
||||
&& applied.helper_ready
|
||||
&& applied
|
||||
.attempts
|
||||
.iter()
|
||||
.all(|a| a.update_inflight.is_none() && a.outcome_state != "unknown"),
|
||||
"BOOTSTRAP_FRESH_NORMAL_SYNC_REQUIRED"
|
||||
);
|
||||
let stored: Vec<u8> = agent.query_row(
|
||||
"SELECT response FROM reconcile_requests WHERE id=?1 AND generation=?2",
|
||||
rusqlite::params![request.request_id, generation],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(
|
||||
SyncResponse::decode(stored.as_slice())? == response,
|
||||
"BOOTSTRAP_BOTH_NORMAL_ORIGINAL_RESPONSES"
|
||||
);
|
||||
verify_checkpoint_repair_history_with(
|
||||
&helper,
|
||||
&binding,
|
||||
None,
|
||||
HelperIdentity::Root,
|
||||
&DalekVerifier,
|
||||
)?;
|
||||
for service in &held {
|
||||
service.verify(&budget)?;
|
||||
}
|
||||
ensure!(
|
||||
std::fs::read(binding_path)? == binding_raw,
|
||||
"BOOTSTRAP_BINDING_CHANGED"
|
||||
);
|
||||
clock.now()?;
|
||||
budget.check()?;
|
||||
Ok(
|
||||
serde_json::json!({"schema_version":1,"profile":"linux_compatible_baseline_qualification_v1","boot_id":boot,"tenant_id":binding.tenant_id,"asset_id":binding.asset_id,"agent_id":binding.agent_id,"enrollment_generation":binding.enrollment_generation,"assignment_version":binding.assignment_version,
|
||||
"services":held.iter().map(|v|v.proof()).collect::<Vec<_>>(),"normal_signed_sync_observed":true,"generation":generation,"decision_id":decision,"request_sha256":hash(&hrequest),"decision_sha256":hash(&signed.decision_bytes),"signature_sha256":hash(&signed.signature),"observed_at":clock.now()?,"ready":false,"helper_ready":false,"unlock":false,"job_authority":false,"apt_native_runtime_qualified":false}),
|
||||
)
|
||||
}
|
||||
|
||||
fn run() -> Result<()> {
|
||||
ensure!(std::env::args().count() == 1, "BOOTSTRAP_NO_ARGUMENTS");
|
||||
let mut raw = Vec::new();
|
||||
std::io::stdin()
|
||||
.take(512 * 1024 + 1)
|
||||
.read_to_end(&mut raw)?;
|
||||
ensure!(raw.len() <= 512 * 1024, "BOOTSTRAP_INPUT_LIMIT");
|
||||
let output = match serde_json::from_slice::<Input>(&raw)? {
|
||||
Input::RenderFull {
|
||||
config,
|
||||
pin,
|
||||
job_public_key_hex,
|
||||
new_helper_sha256,
|
||||
} => {
|
||||
let key: [u8; 32] = hex::decode(job_public_key_hex)?
|
||||
.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("BOOTSTRAP_PUBLIC_KEY_SIZE"))?;
|
||||
let key = VerifyingKey::from_bytes(&key)?;
|
||||
let value =
|
||||
rmm_updater_handoff::render_linux_full(&config, &pin, &new_helper_sha256, &key)?;
|
||||
serde_json::json!({"proof":value.proof(),"config":value.new_config_bytes(),"pin":value.new_pin_bytes()})
|
||||
}
|
||||
Input::QualifyPair {
|
||||
minimum_generation,
|
||||
expected_agent_sha256,
|
||||
expected_helper_sha256,
|
||||
unit_pins,
|
||||
} => qualify_pair(
|
||||
minimum_generation,
|
||||
&expected_agent_sha256,
|
||||
&expected_helper_sha256,
|
||||
&unit_pins,
|
||||
)?,
|
||||
Input::Registry {
|
||||
qualification_sha256,
|
||||
} => {
|
||||
let boot: Uuid = std::fs::read_to_string("/proc/sys/kernel/random/boot_id")?
|
||||
.trim()
|
||||
.parse()?;
|
||||
let budget = rmm_updater_linux::Budget::new(boot, std::time::Duration::from_secs(30))?;
|
||||
serde_json::to_value(rmm_updater_worker::reader_registry::bootstrap_metadata(
|
||||
&qualification_sha256,
|
||||
&budget,
|
||||
)?)?
|
||||
}
|
||||
Input::CanonicalRelease { manifest } => {
|
||||
ensure!(manifest.validate(), "BOOTSTRAP_RELEASE_SHAPE");
|
||||
let bytes = serde_json::to_vec(&manifest)?;
|
||||
serde_json::json!({"bytes":bytes,"sha256":hash(&bytes)})
|
||||
}
|
||||
Input::CanonicalRecord { record } => {
|
||||
let bytes = record.bytes().map_err(anyhow::Error::msg)?;
|
||||
serde_json::json!({"bytes":bytes,"sha256":hash(&bytes)})
|
||||
}
|
||||
Input::CanonicalPolicy { policy } => {
|
||||
ensure!(policy.validate(), "BOOTSTRAP_POLICY_SHAPE");
|
||||
let bytes = serde_json::to_vec(&policy)?;
|
||||
serde_json::json!({"bytes":bytes,"sha256":hash(&bytes)})
|
||||
}
|
||||
Input::ValidateRelease { envelope } => {
|
||||
let decoded = envelope.decode().map_err(anyhow::Error::msg)?;
|
||||
serde_json::json!({"manifest":decoded.manifest,"manifest_sha256":hash(&decoded.payload_bytes),"shape_only_not_signature_verified":true})
|
||||
}
|
||||
Input::ValidatePublicBundle {
|
||||
record,
|
||||
policy,
|
||||
keyring,
|
||||
health_pin,
|
||||
} => {
|
||||
let installed =
|
||||
InstalledReleaseRecord::from_bytes(&record).map_err(anyhow::Error::msg)?;
|
||||
let (local, policy_sha256) =
|
||||
LocalUpdatePolicy::from_bytes(&policy).map_err(anyhow::Error::msg)?;
|
||||
let keys: UpdateKeyringFile = serde_json::from_slice(&keyring)?;
|
||||
let health: HealthKeyPin = serde_json::from_slice(&health_pin)?;
|
||||
ensure!(
|
||||
keys.validate()
|
||||
&& health.validate()
|
||||
&& local.initial_record_sha256 == hash(&record)
|
||||
&& local.initial_activation_floor == installed.activation_floor,
|
||||
"BOOTSTRAP_PUBLIC_BUNDLE_SHAPE"
|
||||
);
|
||||
serde_json::json!({"record_sha256":hash(&record),"policy_sha256":policy_sha256,"keyring_sha256":hash(&keyring),"health_pin_sha256":hash(&health_pin),"shape_only_not_signature_verified":true})
|
||||
}
|
||||
};
|
||||
println!("{}", serde_json::to_string(&output)?);
|
||||
Ok(())
|
||||
}
|
||||
fn main() {
|
||||
if run().is_err() {
|
||||
eprintln!("LINUX_BOOTSTRAP_METADATA_FAILED");
|
||||
std::process::exit(1)
|
||||
}
|
||||
}
|
||||
@@ -40,8 +40,10 @@ const MAX_REPLY: usize = 1536 * 1024;
|
||||
pub enum Generation {
|
||||
Original,
|
||||
Replacement,
|
||||
Restored,
|
||||
}
|
||||
pub struct BridgeContext<'a> {
|
||||
pub binding: &'a rmm_agent_core::auth::Binding,
|
||||
pub handoff: &'a Handoff,
|
||||
pub delegation: &'a UpdateDelegation,
|
||||
pub services: &'a Systemd,
|
||||
@@ -62,6 +64,7 @@ pub struct Reply {
|
||||
pub original_start: Option<Vec<u8>>,
|
||||
pub claim: Option<NativeEffectClaim>,
|
||||
pub original_outcome: Option<Vec<u8>>,
|
||||
pub pre_stop_sync: Option<(Vec<u8>, Vec<u8>)>,
|
||||
}
|
||||
impl<'a> FullBridge<'a> {
|
||||
/// Prefix is either the exact initial atomic StopIntent or a complete
|
||||
@@ -137,18 +140,20 @@ impl<'a> FullBridge<'a> {
|
||||
"UPDATE_BRIDGE_CLAIM_PHASE"
|
||||
),
|
||||
NativeControlOperation::ObserveStarts { .. } => ensure!(
|
||||
context.generation == Generation::Replacement
|
||||
&& journal
|
||||
.as_ref()
|
||||
.is_some_and(|j| j.phase() == Phase::LedgerReturnIntent),
|
||||
journal.as_ref().is_some_and(|j| matches!(
|
||||
(context.generation, j.phase()),
|
||||
(Generation::Replacement, Phase::LedgerReturnIntent)
|
||||
| (Generation::Restored, Phase::RollbackLedgerReturnIntent)
|
||||
)),
|
||||
"UPDATE_BRIDGE_START_PHASE"
|
||||
),
|
||||
NativeControlOperation::Health { receipt } => {
|
||||
ensure!(
|
||||
context.generation == Generation::Replacement
|
||||
&& journal
|
||||
.as_ref()
|
||||
.is_some_and(|j| j.phase() == Phase::ServicesStarted),
|
||||
journal.as_ref().is_some_and(|j| matches!(
|
||||
(context.generation, j.phase()),
|
||||
(Generation::Replacement, Phase::ServicesStarted)
|
||||
| (Generation::Restored, Phase::RollbackServicesStarted)
|
||||
)),
|
||||
"UPDATE_BRIDGE_HEALTH_PHASE"
|
||||
);
|
||||
journal
|
||||
@@ -156,16 +161,23 @@ impl<'a> FullBridge<'a> {
|
||||
.context("UPDATE_BRIDGE_ORIGINAL_READ_REQUIRED")?
|
||||
.prepare(
|
||||
u64::try_from(context.clock.now()?.timestamp())?,
|
||||
rmm_updater_handoff::Evidence::HealthVerified {
|
||||
receipt: receipt.clone(),
|
||||
if context.generation == Generation::Restored {
|
||||
rmm_updater_handoff::Evidence::RollbackHealthVerified {
|
||||
receipt: receipt.clone(),
|
||||
}
|
||||
} else {
|
||||
rmm_updater_handoff::Evidence::HealthVerified {
|
||||
receipt: receipt.clone(),
|
||||
}
|
||||
},
|
||||
)?;
|
||||
}
|
||||
NativeControlOperation::Finalize => ensure!(
|
||||
context.generation == Generation::Replacement
|
||||
&& journal
|
||||
.as_ref()
|
||||
.is_some_and(|j| j.phase() == Phase::HealthVerified),
|
||||
journal.as_ref().is_some_and(|j| matches!(
|
||||
(context.generation, j.phase()),
|
||||
(Generation::Replacement, Phase::HealthVerified)
|
||||
| (Generation::Restored, Phase::RollbackHealthVerified)
|
||||
)),
|
||||
"UPDATE_BRIDGE_FINAL_PHASE"
|
||||
),
|
||||
}
|
||||
@@ -227,6 +239,11 @@ impl<'a> FullBridge<'a> {
|
||||
&& peer.pid != context.delegation.original_helper.pid,
|
||||
"UPDATE_BRIDGE_REPLACEMENT_HELPER_CHANGED"
|
||||
),
|
||||
Generation::Restored => ensure!(
|
||||
peer.image_sha256 == context.handoff.predecessor.helper_sha256
|
||||
&& peer.pid != context.delegation.original_helper.pid,
|
||||
"UPDATE_BRIDGE_RESTORED_HELPER_CHANGED"
|
||||
),
|
||||
}
|
||||
let request = NativeControlRequest {
|
||||
operation: "agent_update_control_v1".into(),
|
||||
@@ -276,6 +293,21 @@ impl<'a> FullBridge<'a> {
|
||||
&& reply.handoff_sha256 == request.handoff_sha256,
|
||||
"UPDATE_BRIDGE_REPLY_BINDING"
|
||||
);
|
||||
let pre_stop_sync = match (
|
||||
&reply.pre_stop_sync_request_base64url,
|
||||
&reply.pre_stop_sync_response_base64url,
|
||||
) {
|
||||
(None, None) => None,
|
||||
(Some(raw_request), Some(response))
|
||||
if matches!(request.method, NativeControlOperation::ReadOriginal) =>
|
||||
{
|
||||
Some((
|
||||
decode(raw_request, 256 * 1024)?,
|
||||
decode(response, 256 * 1024)?,
|
||||
))
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_BRIDGE_PRESTOP_FIELDS_DENIED"),
|
||||
};
|
||||
let original_start = reply
|
||||
.original_start_base64url
|
||||
.as_deref()
|
||||
@@ -297,8 +329,13 @@ impl<'a> FullBridge<'a> {
|
||||
let outcome: ReconciledOutcome = serde_json::from_slice(raw)?;
|
||||
ensure!(
|
||||
canonical_outcome_bytes(&outcome)? == *raw
|
||||
&& outcome.state == "succeeded"
|
||||
&& !outcome.reboot_required,
|
||||
&& if context.generation == Generation::Restored {
|
||||
outcome.state == "failed"
|
||||
&& outcome.error_code == "AGENT_UPDATE_RETURNED_TO_PREDECESSOR"
|
||||
&& !outcome.reboot_required
|
||||
} else {
|
||||
outcome.state == "succeeded" && !outcome.reboot_required
|
||||
},
|
||||
"UPDATE_BRIDGE_NONCANONICAL_OR_UNSUCCESSFUL_OUTCOME"
|
||||
);
|
||||
} else {
|
||||
@@ -322,6 +359,58 @@ impl<'a> FullBridge<'a> {
|
||||
&& proof.events[..prior.events.len()] == prior.events),
|
||||
"UPDATE_BRIDGE_PROOF_ROLLBACK_OR_CHANGED"
|
||||
);
|
||||
if let Some((raw, response)) = &pre_stop_sync {
|
||||
use prost::Message;
|
||||
let req = rmm_protocol::SyncRequest::decode(raw.as_slice())?;
|
||||
let signed: rmm_agent_core::helper_reconcile::SignedResponse =
|
||||
serde_json::from_slice(response)?;
|
||||
let response = rmm_protocol::SyncResponse {
|
||||
decision_bytes: signed.decision_bytes,
|
||||
signature: signed.signature,
|
||||
};
|
||||
let decision = rmm_agent_core::reconcile::verify_response(
|
||||
context.binding,
|
||||
&req,
|
||||
&rmm_agent_core::reconcile::Channel {
|
||||
boot_id: context.handoff.boot_id,
|
||||
connection_generation: context.handoff.connection_generation,
|
||||
},
|
||||
&response,
|
||||
context.clock.now()?,
|
||||
)?;
|
||||
let expected =
|
||||
rmm_domain::agent_update::inflight_decision(proof, context.health_public_key)
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let matching = decision
|
||||
.attempts
|
||||
.iter()
|
||||
.filter(|a| {
|
||||
a.job_id == context.handoff.attempt.job_id
|
||||
&& a.attempt_id == context.handoff.attempt.attempt_id
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
ensure!(matching.len() == 1, "UPDATE_BRIDGE_PRESTOP_ACK_ATTEMPT");
|
||||
let ack = matching[0];
|
||||
ensure!(
|
||||
context.generation == Generation::Original
|
||||
&& journal.phase() == Phase::StopIntent
|
||||
&& req.encode_to_vec() == *raw
|
||||
&& !decision.ready
|
||||
&& !decision.helper_ready
|
||||
&& ack.update_inflight.as_ref() == Some(&expected)
|
||||
&& !ack.unlock
|
||||
&& ack.outcome_state == "running"
|
||||
&& ack.outcome_bytes.is_empty()
|
||||
&& ack.outcome_sha256.is_none()
|
||||
&& ack.grant_id == Some(context.handoff.attempt.grant_id)
|
||||
&& ack.authorization_id == Some(context.handoff.attempt.authorization_id)
|
||||
&& ack.plan_hash.as_deref()
|
||||
== Some(context.handoff.attempt.plan_sha256.as_str())
|
||||
&& ack.job_payload_hash == context.handoff.attempt.job_payload_sha256
|
||||
&& ack.original_boot_id == Some(context.handoff.boot_id),
|
||||
"UPDATE_BRIDGE_SIGNED_PRESTOP_ACK"
|
||||
);
|
||||
}
|
||||
match request.method {
|
||||
NativeControlOperation::ReadOriginal => ensure!(
|
||||
reply.claim.is_none() && original_start.is_some(),
|
||||
@@ -348,16 +437,20 @@ impl<'a> FullBridge<'a> {
|
||||
);
|
||||
}
|
||||
NativeControlOperation::ObserveStarts { .. } => ensure!(
|
||||
context.generation == Generation::Replacement
|
||||
&& journal.phase() == Phase::ServicesStarted
|
||||
&& reply.claim.is_none()
|
||||
matches!(
|
||||
(context.generation, journal.phase()),
|
||||
(Generation::Replacement, Phase::ServicesStarted)
|
||||
| (Generation::Restored, Phase::RollbackServicesStarted)
|
||||
) && reply.claim.is_none()
|
||||
&& original_start.is_none(),
|
||||
"UPDATE_BRIDGE_STARTS_REPLY"
|
||||
),
|
||||
NativeControlOperation::Health { .. } => ensure!(
|
||||
context.generation == Generation::Replacement
|
||||
&& journal.phase() == Phase::HealthVerified
|
||||
&& reply.claim.is_none()
|
||||
matches!(
|
||||
(context.generation, journal.phase()),
|
||||
(Generation::Replacement, Phase::HealthVerified)
|
||||
| (Generation::Restored, Phase::RollbackHealthVerified)
|
||||
) && reply.claim.is_none()
|
||||
&& original_start.is_none(),
|
||||
"UPDATE_BRIDGE_HEALTH_REPLY"
|
||||
),
|
||||
@@ -377,6 +470,7 @@ impl<'a> FullBridge<'a> {
|
||||
claim: reply.claim,
|
||||
original_start,
|
||||
original_outcome,
|
||||
pre_stop_sync,
|
||||
})
|
||||
}
|
||||
pub fn head_sha256(&self) -> Result<&str> {
|
||||
@@ -422,8 +516,21 @@ impl<'a> FullBridge<'a> {
|
||||
.context("UPDATE_BRIDGE_STARTED_EVENT_MISSING")?,
|
||||
)?;
|
||||
ensure!(
|
||||
matches!(last.evidence,rmm_updater_handoff::Evidence::ServicesStarted {services:actual,observation_sha256:hash,..}
|
||||
if actual==services && hash==observation_sha256),
|
||||
match last.evidence {
|
||||
rmm_updater_handoff::Evidence::ServicesStarted {
|
||||
services: actual,
|
||||
observation_sha256: hash,
|
||||
..
|
||||
} if self.context.generation == Generation::Replacement =>
|
||||
actual == services && hash == observation_sha256,
|
||||
rmm_updater_handoff::Evidence::RollbackServicesStarted {
|
||||
services: actual,
|
||||
observation_sha256: hash,
|
||||
..
|
||||
} if self.context.generation == Generation::Restored =>
|
||||
actual == services && hash == observation_sha256,
|
||||
_ => false,
|
||||
},
|
||||
"UPDATE_BRIDGE_STARTED_RESULT_CHANGED"
|
||||
);
|
||||
Ok(reply)
|
||||
|
||||
@@ -6,7 +6,7 @@ use crate::{
|
||||
bridge::{BridgeContext, FullBridge, Generation},
|
||||
bundle, census,
|
||||
clock::NativeClock,
|
||||
fence::LedgerFence,
|
||||
fence::{LedgerFence, RollbackFence},
|
||||
ledger::{OwnedInputs, OwnedLedger},
|
||||
original::Original,
|
||||
participants::{StableParticipant, verify_original_helper},
|
||||
@@ -31,7 +31,7 @@ use rmm_updater_linux::{
|
||||
Budget, DurableEffectFence, Effect,
|
||||
files::{Directory, HeldFile, LedgerGuard, Role},
|
||||
ipc::{self, Request, Response, State},
|
||||
services::{Service, ServicePolicy, ServiceProof, Systemd},
|
||||
services::{Service, ServicePolicy, ServiceProof, Startup, Systemd},
|
||||
};
|
||||
use std::{ffi::OsStr, path::Path, time::Duration};
|
||||
use uuid::Uuid;
|
||||
@@ -97,6 +97,12 @@ struct Queued {
|
||||
budget: Budget,
|
||||
}
|
||||
impl Runtime {
|
||||
pub fn failed(&self) -> bool {
|
||||
self.failed
|
||||
}
|
||||
pub fn terminal(&self) -> bool {
|
||||
self.terminal
|
||||
}
|
||||
pub fn new(binding: Binding) -> Result<Self> {
|
||||
let clock = NativeClock::new()?;
|
||||
let budget = observation_budget()?;
|
||||
@@ -155,7 +161,7 @@ impl Runtime {
|
||||
let services = Systemd::new(self.old_policies.clone())?;
|
||||
let budget = observation_budget()?;
|
||||
if let Err(error) = listener.serve_one(&services, &budget, self) {
|
||||
if self.queued.take().is_some() {
|
||||
if self.queued.take().is_some() || self.accepted {
|
||||
self.failed = true;
|
||||
}
|
||||
return Err(error);
|
||||
@@ -226,6 +232,7 @@ impl Runtime {
|
||||
.verify_delegation(&header.delegation, &budget)?;
|
||||
let reply = {
|
||||
let mut bridge = FullBridge::original(BridgeContext {
|
||||
binding: &self.binding,
|
||||
handoff: &header.handoff,
|
||||
delegation: &header.delegation,
|
||||
services: &services,
|
||||
@@ -235,7 +242,19 @@ impl Runtime {
|
||||
health_public_key: self.health_key,
|
||||
generation: Generation::Original,
|
||||
})?;
|
||||
bridge.call(NativeControlOperation::ReadOriginal)?
|
||||
loop {
|
||||
let reply = bridge.call(NativeControlOperation::ReadOriginal)?;
|
||||
if reply.pre_stop_sync.is_some() {
|
||||
break reply;
|
||||
}
|
||||
// Passive read only, under the ORIGINAL boot/deadline/owner.
|
||||
// Do not stop a reader before the server has retained and the
|
||||
// actual Full has applied this exact signed inflight context.
|
||||
budget.check()?;
|
||||
self.updater
|
||||
.verify_delegation(&header.delegation, &budget)?;
|
||||
std::thread::sleep(Duration::from_millis(50));
|
||||
}
|
||||
};
|
||||
let proof = reply.proof.context("UPDATE_ENGINE_ORIGINAL_PROOF")?;
|
||||
let original = Original::verify(
|
||||
@@ -281,6 +300,7 @@ impl Runtime {
|
||||
census::scan_admission(&targets, &known, self.registry.host_context(), &budget)?;
|
||||
let mut bridge = FullBridge::new(
|
||||
BridgeContext {
|
||||
binding: &self.binding,
|
||||
handoff: original.handoff(),
|
||||
delegation: original.delegation(),
|
||||
services: &services,
|
||||
@@ -381,9 +401,10 @@ impl Runtime {
|
||||
ledger_identity_sha256: witnesses.ledger.sha256()?,
|
||||
})?;
|
||||
// Do not hold a second connection before all readers really stopped.
|
||||
let swap = (|| -> Result<()> {
|
||||
let swap = (|| -> Result<Vec<rmm_updater_linux::files::Installed>> {
|
||||
let stages = witnesses.files.reopen_stages(original.handoff(), &budget)?;
|
||||
let mut fence = LedgerFence::new(&mut ledger)?;
|
||||
let mut installed = Vec::new();
|
||||
for (stage, role) in
|
||||
stages
|
||||
.into_iter()
|
||||
@@ -396,23 +417,27 @@ impl Runtime {
|
||||
0,
|
||||
false,
|
||||
)?;
|
||||
stage.install(&directory, &os, &budget, &mut fence)?;
|
||||
installed.push(stage.install(&directory, &os, &budget, &mut fence)?);
|
||||
}
|
||||
fence.finish()?;
|
||||
ledger.append_observed(Evidence::PairVerified {
|
||||
pair: original.handoff().target.clone(),
|
||||
retained_state_sha256: original.handoff().retained_state_sha256.clone(),
|
||||
})
|
||||
})?;
|
||||
Ok(installed)
|
||||
})();
|
||||
if let Err(error) = swap {
|
||||
// Exactly one best-effort ORIGINAL Unknown CAS while we still own
|
||||
// the real guard. Failure is preserved; no restoration or retry.
|
||||
let _ = ledger.mark_unknown(
|
||||
u64::try_from(self.clock.now()?.timestamp())?,
|
||||
rmm_updater_handoff::UnknownReason::ReplaceUncertain,
|
||||
);
|
||||
return Err(error);
|
||||
}
|
||||
let installed = match swap {
|
||||
Ok(installed) => installed,
|
||||
Err(error) => {
|
||||
// Exactly one best-effort ORIGINAL Unknown CAS while we still own
|
||||
// the real guard. Failure is preserved; no restoration or retry.
|
||||
let _ = ledger.mark_unknown(
|
||||
u64::try_from(self.clock.now()?.timestamp())?,
|
||||
rmm_updater_handoff::UnknownReason::ReplaceUncertain,
|
||||
);
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let prepared = ledger.prepare_return_and_close()?;
|
||||
// The original DB is actually closed. End the continuous census/lock
|
||||
// borrow before the same concrete guard can be consumed by Return.
|
||||
@@ -432,6 +457,7 @@ impl Runtime {
|
||||
let observer = Systemd::new(target_policies)?;
|
||||
let mut bridge = FullBridge::new(
|
||||
BridgeContext {
|
||||
binding: &self.binding,
|
||||
handoff: original.handoff(),
|
||||
delegation: original.delegation(),
|
||||
services: &observer,
|
||||
@@ -447,8 +473,139 @@ impl Runtime {
|
||||
agent_startup.verify()?;
|
||||
os.release(&budget, &mut fence)?;
|
||||
agent_startup.return_after_root_release(&budget)?;
|
||||
let started = stopped.start_once(target, &budget, &mut fence)?;
|
||||
fence.finish()?;
|
||||
let started = match stopped.start_once_observed(target, &budget, &mut fence)? {
|
||||
Startup::Complete { started, .. } => {
|
||||
fence.finish()?;
|
||||
started
|
||||
}
|
||||
Startup::KnownFailed(failed) => {
|
||||
let mut conditional = fence.early_full_failure(&failed)?;
|
||||
let expected_head = conditional.proof().head_sha256.clone();
|
||||
let (stopped, _, _) = failed.stop_reserved_general(&budget, &mut conditional)?;
|
||||
conditional.finish()?;
|
||||
drop(bridge);
|
||||
let agent_startup =
|
||||
BoundAgentLock::bind(&witnesses.retained)?.acquire(&stopped, &budget)?;
|
||||
let os = LedgerGuard::acquire(&stopped, &witnesses.ledger, &budget)?;
|
||||
self.registry
|
||||
.verify_known_failure_stopped(&self.policy, &stopped, &budget)?;
|
||||
let readers = census::scan_stopped(
|
||||
&targets,
|
||||
&admission,
|
||||
&os,
|
||||
&agent_startup,
|
||||
&stopped,
|
||||
self.updater.held_service(),
|
||||
&budget,
|
||||
)?;
|
||||
let readers = readers.bind(
|
||||
census::ClosureInputs {
|
||||
targets: &targets,
|
||||
root: &os,
|
||||
agent: &agent_startup,
|
||||
stopped: &stopped,
|
||||
updater: self.updater.held_service(),
|
||||
registry: &self.registry,
|
||||
},
|
||||
&budget,
|
||||
)?;
|
||||
let mut ledger = OwnedLedger::open(OwnedInputs {
|
||||
os: &os,
|
||||
readers: &readers,
|
||||
original: &original,
|
||||
binding: &self.binding,
|
||||
clock: &self.clock,
|
||||
budget: &budget,
|
||||
updater: &self.updater,
|
||||
retained: &witnesses.retained,
|
||||
files: &witnesses.files,
|
||||
stopped: &stopped,
|
||||
trust: &trust,
|
||||
})?;
|
||||
ledger.begin_rollback_after_early_full_failure(&expected_head)?;
|
||||
ledger.append_rollback_stopped()?;
|
||||
{
|
||||
let mut rollback = RollbackFence::new(&mut ledger)?;
|
||||
for installed in installed.into_iter().rev() {
|
||||
let directory = Directory::open(
|
||||
Path::new(installed.role().target())
|
||||
.parent()
|
||||
.context("UPDATE_ROLLBACK_PARENT")?,
|
||||
0,
|
||||
false,
|
||||
)?;
|
||||
installed.restore(&directory, &os, &budget, &mut rollback)?;
|
||||
}
|
||||
rollback.finish()?;
|
||||
}
|
||||
ledger.append_observed(Evidence::PredecessorVerified {
|
||||
pair: original.handoff().predecessor.clone(),
|
||||
retained_state_sha256: original.handoff().retained_state_sha256.clone(),
|
||||
predecessor_record_sha256: original.handoff().predecessor_record_sha256.clone(),
|
||||
})?;
|
||||
let prepared = ledger.prepare_rollback_return_and_close()?;
|
||||
drop(readers);
|
||||
let reservation = prepared.bind(returned::Inputs {
|
||||
original: &original,
|
||||
binding: &self.binding,
|
||||
clock: &self.clock,
|
||||
budget: &budget,
|
||||
updater: &self.updater,
|
||||
retained: &witnesses.retained,
|
||||
files: &witnesses.files,
|
||||
trust: &trust,
|
||||
})?;
|
||||
let predecessor = Systemd::new(self.old_policies.clone())?;
|
||||
let observer = Systemd::new(self.old_policies.clone())?;
|
||||
let mut restored = FullBridge::new(
|
||||
BridgeContext {
|
||||
binding: &self.binding,
|
||||
handoff: original.handoff(),
|
||||
delegation: original.delegation(),
|
||||
services: &observer,
|
||||
updater: &self.updater,
|
||||
clock: &self.clock,
|
||||
budget: &budget,
|
||||
health_public_key: self.health_key,
|
||||
generation: Generation::Restored,
|
||||
},
|
||||
reservation.proof().clone(),
|
||||
)?;
|
||||
let mut fence = reservation.start_fence(&observer, &mut restored);
|
||||
agent_startup.verify()?;
|
||||
os.release(&budget, &mut fence)?;
|
||||
agent_startup.return_after_root_release(&budget)?;
|
||||
let started = stopped.start_once(predecessor, &budget, &mut fence)?;
|
||||
fence.finish()?;
|
||||
restored.observe_starts(&started)?;
|
||||
loop {
|
||||
original.check_current(&self.binding, &self.clock, &budget)?;
|
||||
self.updater
|
||||
.verify_delegation(original.delegation(), &budget)?;
|
||||
witnesses.retained.verify()?;
|
||||
for service in &started {
|
||||
service.verify(&budget)?;
|
||||
}
|
||||
let reply = restored.call(NativeControlOperation::ReadOriginal)?;
|
||||
let proof = reply.proof.context("UPDATE_ROLLBACK_HEALTH_PROOF")?;
|
||||
self.head = Some(proof.head_sha256.clone());
|
||||
let (_, journal) =
|
||||
rmm_domain::agent_update::verify_inflight_proof(&proof, self.health_key)
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
match journal.phase() {
|
||||
Phase::RollbackServicesStarted => {
|
||||
std::thread::sleep(Duration::from_millis(100))
|
||||
}
|
||||
Phase::RollbackHealthVerified => {
|
||||
restored.call(NativeControlOperation::Finalize)?;
|
||||
self.head = None;
|
||||
return Ok(());
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_ROLLBACK_HEALTH_PREFIX_CHANGED"),
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
bridge.observe_starts(&started)?;
|
||||
loop {
|
||||
original.check_current(&self.binding, &self.clock, &budget)?;
|
||||
|
||||
@@ -118,3 +118,107 @@ impl DurableEffectFence for LedgerFence<'_, '_, '_> {
|
||||
self.observe(effect, observation_sha256)
|
||||
}
|
||||
}
|
||||
|
||||
/// Reverse only a completely verified forward pair after the original
|
||||
/// guarded journal entered known-failure RollbackStopped. A partial rename or
|
||||
/// lost reply poisons this fence; it never resumes/restores an Unknown.
|
||||
pub struct RollbackFence<'w, 'a, 's> {
|
||||
ledger: &'w mut OwnedLedger<'a, 's>,
|
||||
pending: Option<(Effect, NativeEffectClaim)>,
|
||||
preserved: Option<Role>,
|
||||
poisoned: bool,
|
||||
}
|
||||
impl<'w, 'a, 's> RollbackFence<'w, 'a, 's> {
|
||||
pub fn new(ledger: &'w mut OwnedLedger<'a, 's>) -> Result<Self> {
|
||||
ledger.qualify_for_effects()?;
|
||||
ensure!(
|
||||
ledger.journal()?.phase() == Phase::RollbackStopped,
|
||||
"UPDATE_ROLLBACK_NO_RESUME"
|
||||
);
|
||||
Ok(Self {
|
||||
ledger,
|
||||
pending: None,
|
||||
preserved: None,
|
||||
poisoned: false,
|
||||
})
|
||||
}
|
||||
pub fn finish(self) -> Result<()> {
|
||||
ensure!(
|
||||
!self.poisoned
|
||||
&& self.pending.is_none()
|
||||
&& self.preserved.is_none()
|
||||
&& self.ledger.journal()?.phase() == Phase::PredecessorRestored,
|
||||
"UPDATE_ROLLBACK_FENCE_INCOMPLETE"
|
||||
);
|
||||
self.ledger.verify_predecessor_pair()
|
||||
}
|
||||
}
|
||||
impl DurableEffectFence for RollbackFence<'_, '_, '_> {
|
||||
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
|
||||
ensure!(
|
||||
!self.poisoned && self.pending.is_none(),
|
||||
"UPDATE_ROLLBACK_NO_RETRY"
|
||||
);
|
||||
self.poisoned = true;
|
||||
let native = match *effect {
|
||||
Effect::SaveRejectedCandidate { role } => {
|
||||
ensure!(self.preserved.is_none(), "UPDATE_ROLLBACK_SAVE_ORDER");
|
||||
self.ledger.append_observed(Evidence::RestoreIntent {
|
||||
role: role.handoff_role(),
|
||||
})?;
|
||||
NativeEffect::SaveRejectedCandidate {
|
||||
role: native_role(role),
|
||||
}
|
||||
}
|
||||
Effect::RestorePredecessor { role } => {
|
||||
ensure!(
|
||||
self.preserved == Some(role),
|
||||
"UPDATE_ROLLBACK_RESTORE_WITHOUT_SAVE"
|
||||
);
|
||||
NativeEffect::RestorePredecessor {
|
||||
role: native_role(role),
|
||||
}
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_ROLLBACK_EFFECT_DENIED"),
|
||||
};
|
||||
self.pending = Some((effect.clone(), self.ledger.claim_native(&native)?));
|
||||
Ok(())
|
||||
}
|
||||
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
|
||||
let (expected, claim) = self
|
||||
.pending
|
||||
.take()
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_ROLLBACK_NOT_CLAIMED"))?;
|
||||
ensure!(
|
||||
self.poisoned && *effect == expected,
|
||||
"UPDATE_ROLLBACK_CALLBACK_CHANGED"
|
||||
);
|
||||
let (role, preserved) = match *effect {
|
||||
Effect::SaveRejectedCandidate { role } => (role, true),
|
||||
Effect::RestorePredecessor { role } => (role, false),
|
||||
_ => anyhow::bail!("UPDATE_ROLLBACK_EFFECT_DENIED"),
|
||||
};
|
||||
ensure!(
|
||||
self.ledger
|
||||
.native_observation_sha256(role.handoff_role(), preserved)?
|
||||
== observation,
|
||||
"UPDATE_ROLLBACK_OBSERVATION_CHANGED"
|
||||
);
|
||||
self.ledger.observe_native(&claim, observation)?;
|
||||
if preserved {
|
||||
self.ledger.append_observed(Evidence::CandidatePreserved {
|
||||
role: role.handoff_role(),
|
||||
observation_sha256: observation.into(),
|
||||
})?;
|
||||
self.preserved = Some(role);
|
||||
} else {
|
||||
self.ledger.append_observed(Evidence::PredecessorRestored {
|
||||
role: role.handoff_role(),
|
||||
observed_sha256: self.ledger.predecessor_sha256(role.handoff_role())?,
|
||||
})?;
|
||||
self.preserved = None;
|
||||
}
|
||||
self.poisoned = false;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -283,6 +283,72 @@ impl FileWitnesses {
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn verify_candidate_saved(&self, which: FileRole, budget: &Budget) -> Result<()> {
|
||||
budget.check()?;
|
||||
let file = self.file(which)?;
|
||||
let path = Path::new(file.role.target());
|
||||
let directory = Directory::open(path.parent().context("UPDATE_TARGET_PARENT")?, 0, false)?;
|
||||
directory.file(
|
||||
OsStr::new(&format!(
|
||||
".rmm-update-{}-{}.rejected",
|
||||
self.nonce,
|
||||
label(file.role)
|
||||
)),
|
||||
&file.staged,
|
||||
256 * 1024 * 1024,
|
||||
)?;
|
||||
directory.file(
|
||||
OsStr::new(&format!(
|
||||
".rmm-update-{}-{}.previous",
|
||||
self.nonce,
|
||||
label(file.role)
|
||||
)),
|
||||
&file.original,
|
||||
256 * 1024 * 1024,
|
||||
)?;
|
||||
directory.absent(path.file_name().context("UPDATE_TARGET_NAME")?)?;
|
||||
directory.absent(OsStr::new(&format!(
|
||||
".rmm-update-{}-{}.stage",
|
||||
self.nonce,
|
||||
label(file.role)
|
||||
)))?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn verify_restored(&self, which: FileRole, budget: &Budget) -> Result<()> {
|
||||
budget.check()?;
|
||||
let file = self.file(which)?;
|
||||
let path = Path::new(file.role.target());
|
||||
let directory = Directory::open(path.parent().context("UPDATE_TARGET_PARENT")?, 0, false)?;
|
||||
directory.file(
|
||||
path.file_name().context("UPDATE_TARGET_NAME")?,
|
||||
&file.original,
|
||||
256 * 1024 * 1024,
|
||||
)?;
|
||||
directory.file(
|
||||
OsStr::new(&format!(
|
||||
".rmm-update-{}-{}.rejected",
|
||||
self.nonce,
|
||||
label(file.role)
|
||||
)),
|
||||
&file.staged,
|
||||
256 * 1024 * 1024,
|
||||
)?;
|
||||
for suffix in ["previous", "stage"] {
|
||||
directory.absent(OsStr::new(&format!(
|
||||
".rmm-update-{}-{}.{}",
|
||||
self.nonce,
|
||||
label(file.role),
|
||||
suffix
|
||||
)))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn verify_predecessor_pair(&self, budget: &Budget) -> Result<()> {
|
||||
for file in &self.files {
|
||||
self.verify_restored(file.role.handoff_role(), budget)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn file(&self, which: FileRole) -> Result<&Proof> {
|
||||
let role = role(which)?;
|
||||
self.files
|
||||
|
||||
@@ -36,6 +36,81 @@ pub struct FullFiles {
|
||||
rendered: LinuxFullTransition,
|
||||
}
|
||||
impl FullFiles {
|
||||
/// Pure read/render of the fixed protected Full transition. No staging,
|
||||
/// download, grant, ledger intent, service control or filesystem mutation.
|
||||
pub fn preview(
|
||||
new_helper_sha256: &str,
|
||||
job_key_path: &Path,
|
||||
job_key_raw_sha256: &str,
|
||||
budget: &Budget,
|
||||
) -> Result<rmm_domain::agent_update::LinuxFullTransition> {
|
||||
budget.check()?;
|
||||
let key_directory = Directory::open(
|
||||
job_key_path.parent().context("UPDATE_FULL_KEY_PARENT")?,
|
||||
0,
|
||||
false,
|
||||
)?;
|
||||
let mut key_file = key_directory.inspect(
|
||||
job_key_path.file_name().context("UPDATE_FULL_KEY_NAME")?,
|
||||
0,
|
||||
4096,
|
||||
)?;
|
||||
ensure!(
|
||||
key_file.proof().sha256 == job_key_raw_sha256,
|
||||
"UPDATE_FULL_KEY_RAW_HASH"
|
||||
);
|
||||
let key_record: SigningKeyRecord = serde_json::from_slice(&key_file.bytes(4096)?)?;
|
||||
let raw = hex::decode(&key_record.public_key_hex)?;
|
||||
ensure!(
|
||||
key_record.schema_version == 1
|
||||
&& key_record.algorithm == "Ed25519"
|
||||
&& key_record.key_id == hash(&raw),
|
||||
"UPDATE_FULL_KEY_IDENTITY"
|
||||
);
|
||||
let key = VerifyingKey::from_bytes(
|
||||
&raw.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_FULL_KEY_SIZE"))?,
|
||||
)?;
|
||||
ensure!(!key.is_weak(), "UPDATE_FULL_WEAK_KEY");
|
||||
let directory = Directory::open(Path::new("/etc/rmm-remote"), 0, false)?;
|
||||
let mut config = directory.inspect(OsStr::new("helper-full-maintenance.json"), 0, 16384)?;
|
||||
let mut pin =
|
||||
directory.inspect(OsStr::new("full-maintenance-helper-proof.json"), 0, 8192)?;
|
||||
let config_bytes = config.bytes(16384)?;
|
||||
let value: serde_json::Value = serde_json::from_slice(&config_bytes)?;
|
||||
if let Some(path) = value.get("signing_key_file").and_then(|v| v.as_str()) {
|
||||
ensure!(
|
||||
Path::new(path) == job_key_path,
|
||||
"UPDATE_FULL_KEY_PATH_CHANGED"
|
||||
);
|
||||
} else {
|
||||
ensure!(
|
||||
value["binding"]["public_key_hex"].as_str() == Some(&hex::encode(key.as_bytes())),
|
||||
"UPDATE_FULL_INLINE_KEY_CHANGED"
|
||||
);
|
||||
}
|
||||
let rendered =
|
||||
render_linux_full(&config_bytes, &pin.bytes(8192)?, new_helper_sha256, &key)?;
|
||||
directory.file(
|
||||
OsStr::new("helper-full-maintenance.json"),
|
||||
config.proof(),
|
||||
16384,
|
||||
)?;
|
||||
directory.file(
|
||||
OsStr::new("full-maintenance-helper-proof.json"),
|
||||
pin.proof(),
|
||||
8192,
|
||||
)?;
|
||||
key_directory.file(
|
||||
job_key_path.file_name().context("UPDATE_FULL_KEY_NAME")?,
|
||||
key_file.proof(),
|
||||
4096,
|
||||
)?;
|
||||
budget.check()?;
|
||||
Ok(serde_json::from_slice(&serde_json::to_vec(
|
||||
rendered.proof(),
|
||||
)?)?)
|
||||
}
|
||||
/// `job_key_path` and `job_key_raw_sha256` come from independently protected
|
||||
/// LOCAL policy, not an update job, IPC request or manifest. The exact key
|
||||
/// identity is additionally bound to the approved Full transition proof.
|
||||
|
||||
@@ -1,757 +1,28 @@
|
||||
//! Read-only current-version history verification under the actual retained
|
||||
//! executor guard. Every input file must already have been independently opened
|
||||
//! and authenticated by the local adapter. No request supplies trusted keys.
|
||||
//!
|
||||
//! This is admission-oriented verification: current release-key revocations
|
||||
//! apply. It must NOT gate an Unknown-only historical adjudication. A changed
|
||||
//! job-signing key needs an independently retained historical Binding; keys are
|
||||
//! never learned from a job. There is no clock, dispatch, repair or resume here.
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::{DateTime, Utc};
|
||||
use ed25519_dalek::{Signature, VerifyingKey};
|
||||
use rmm_agent_core::{
|
||||
auth::{Binding, Outcome, Request},
|
||||
helper_reconcile::ExecutorLedgerGuard,
|
||||
ledger,
|
||||
update_handoff::{self, NativeEffect, NativeEffectClaim},
|
||||
};
|
||||
use rmm_domain::{
|
||||
agent_update::{self, Platform, ReleaseEnvelope, UpdateKeyringFile},
|
||||
agent_update_provisioning::{
|
||||
ActivationEvidence, BASELINE_SIGNATURE_DOMAIN, InstalledReleaseRecord, MAX_RECORD_BYTES,
|
||||
SignedBaselineRecord,
|
||||
},
|
||||
jobs::{Action, hash},
|
||||
};
|
||||
use rmm_updater::{
|
||||
ActiveRelease, Platform as ReleasePlatform, SignedRelease, TrustedContext, TrustedUpdateKey,
|
||||
UpdateKeyring, verify_release,
|
||||
};
|
||||
use rmm_updater_handoff::{Event, Evidence, Handoff, HealthReceipt, Phase, SignedHealth};
|
||||
use rusqlite::{Connection, OptionalExtension, params};
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use uuid::Uuid;
|
||||
|
||||
const MAX_RECORDS: usize = 64;
|
||||
const MAX_TOTAL_BYTES: usize = 2 * 1024 * 1024;
|
||||
|
||||
/// `predecessor_records` is an unordered exact set of intermediate records.
|
||||
/// The signed initial record may optionally appear once. Missing, duplicate,
|
||||
/// unused/forked or completed-but-omitted records are denied. V1 rollback and
|
||||
/// historical job-key rotation without its trusted binding are unsupported.
|
||||
pub fn verify_history(
|
||||
db: &Connection,
|
||||
guard: &impl ExecutorLedgerGuard,
|
||||
binding: &Binding,
|
||||
protected_keyring: &UpdateKeyringFile,
|
||||
baseline: &SignedBaselineRecord,
|
||||
predecessor_records: &[Vec<u8>],
|
||||
active_raw: &[u8],
|
||||
) -> Result<InstalledReleaseRecord> {
|
||||
guard.check(db)?;
|
||||
ensure!(protected_keyring.validate(), "UPDATE_HISTORY_KEYRING");
|
||||
let initial = baseline.decode().map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
initial.record.platform == Platform::LinuxX64,
|
||||
"UPDATE_HISTORY_PLATFORM"
|
||||
);
|
||||
let keyring = current_keyring(protected_keyring)?;
|
||||
let initial_release = initial
|
||||
.record
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let entry = protected_keyring
|
||||
.keys
|
||||
.iter()
|
||||
.find(|key| hex::decode(&key.public_key_hex).is_ok_and(|raw| hash(&raw) == baseline.key_id))
|
||||
.context("UPDATE_HISTORY_BASELINE_KEY_MISSING")?;
|
||||
ensure!(
|
||||
!entry.revoked
|
||||
&& entry.platform == initial.record.platform
|
||||
&& (entry.first_sequence..=entry.last_sequence)
|
||||
.contains(&initial_release.manifest.release_sequence),
|
||||
"UPDATE_HISTORY_BASELINE_KEY_REVOKED_OR_RANGE"
|
||||
);
|
||||
let public: [u8; 32] = hex::decode(&entry.public_key_hex)?
|
||||
.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_HISTORY_KEY_SIZE"))?;
|
||||
let verifier = VerifyingKey::from_bytes(&public)?;
|
||||
ensure!(!verifier.is_weak(), "UPDATE_HISTORY_WEAK_BASELINE_KEY");
|
||||
let mut signed = BASELINE_SIGNATURE_DOMAIN.to_vec();
|
||||
signed.extend_from_slice(&initial.payload_bytes);
|
||||
verifier.verify_strict(&signed, &Signature::from_bytes(&initial.signature))?;
|
||||
verify_record_release(
|
||||
&keyring,
|
||||
protected_keyring.generation,
|
||||
&initial.record,
|
||||
initial_release.manifest.protocol_major,
|
||||
initial_release.manifest.state_schema,
|
||||
)?;
|
||||
|
||||
ensure!(
|
||||
predecessor_records.len() < MAX_RECORDS
|
||||
&& !active_raw.is_empty()
|
||||
&& active_raw.len() <= MAX_RECORD_BYTES,
|
||||
"UPDATE_HISTORY_RECORD_LIMIT"
|
||||
);
|
||||
let mut total = active_raw
|
||||
.len()
|
||||
.checked_add(initial.payload_bytes.len())
|
||||
.context("UPDATE_HISTORY_SIZE")?;
|
||||
let active = InstalledReleaseRecord::from_bytes(active_raw).map_err(anyhow::Error::msg)?;
|
||||
let active_hash = hash(active_raw);
|
||||
let baseline_hash = hash(&initial.payload_bytes);
|
||||
let mut previous = BTreeMap::new();
|
||||
for raw in predecessor_records {
|
||||
total = total
|
||||
.checked_add(raw.len())
|
||||
.context("UPDATE_HISTORY_SIZE")?;
|
||||
ensure!(
|
||||
!raw.is_empty() && raw.len() <= MAX_RECORD_BYTES && total <= MAX_TOTAL_BYTES,
|
||||
"UPDATE_HISTORY_SIZE"
|
||||
);
|
||||
let digest = hash(raw);
|
||||
ensure!(
|
||||
digest != active_hash && previous.insert(digest, raw.as_slice()).is_none(),
|
||||
"UPDATE_HISTORY_DUPLICATE"
|
||||
);
|
||||
}
|
||||
ensure!(total <= MAX_TOTAL_BYTES, "UPDATE_HISTORY_SIZE");
|
||||
let mut chain = vec![(active_hash, active_raw, active.clone())];
|
||||
while chain.last().context("UPDATE_HISTORY_EMPTY")?.0 != baseline_hash {
|
||||
ensure!(chain.len() < MAX_RECORDS, "UPDATE_HISTORY_DEPTH");
|
||||
let current = &chain.last().context("UPDATE_HISTORY_EMPTY")?.2;
|
||||
let digest = current
|
||||
.previous_record_sha256
|
||||
.as_ref()
|
||||
.context("UPDATE_HISTORY_PARENT_MISSING")?;
|
||||
let raw = if *digest == baseline_hash {
|
||||
if let Some(copy) = previous.remove(digest) {
|
||||
ensure!(
|
||||
copy == initial.payload_bytes,
|
||||
"UPDATE_HISTORY_BASELINE_CHANGED"
|
||||
);
|
||||
}
|
||||
initial.payload_bytes.as_slice()
|
||||
} else {
|
||||
previous
|
||||
.remove(digest)
|
||||
.context("UPDATE_HISTORY_PARENT_MISSING")?
|
||||
};
|
||||
ensure!(
|
||||
!chain.iter().any(|(seen, _, _)| seen == digest),
|
||||
"UPDATE_HISTORY_CYCLE"
|
||||
);
|
||||
let record = InstalledReleaseRecord::from_bytes(raw).map_err(anyhow::Error::msg)?;
|
||||
chain.push((digest.clone(), raw, record));
|
||||
}
|
||||
ensure!(
|
||||
previous.is_empty()
|
||||
&& chain.last().context("UPDATE_HISTORY_EMPTY")?.1 == initial.payload_bytes,
|
||||
"UPDATE_HISTORY_UNUSED_OR_WRONG_ANCHOR"
|
||||
);
|
||||
let mut grants = BTreeSet::new();
|
||||
for pair in chain.windows(2) {
|
||||
let (digest, raw, record) = &pair[0];
|
||||
let (parent_digest, _, parent) = &pair[1];
|
||||
ensure!(
|
||||
!record.rolled_back
|
||||
&& record.platform == parent.platform
|
||||
&& record.activation_floor > parent.activation_floor
|
||||
&& record.activated_at >= parent.activated_at,
|
||||
"UPDATE_HISTORY_FLOOR_OR_ROLLBACK"
|
||||
);
|
||||
verify_record_release(
|
||||
&keyring,
|
||||
protected_keyring.generation,
|
||||
record,
|
||||
initial_release.manifest.protocol_major,
|
||||
initial_release.manifest.state_schema,
|
||||
)?;
|
||||
let grant = verify_update(db, guard, binding, raw, record, parent_digest, parent)?;
|
||||
ensure!(grants.insert(grant), "UPDATE_HISTORY_REUSED_GRANT");
|
||||
ensure!(*digest == hash(raw), "UPDATE_HISTORY_RECORD_CHANGED");
|
||||
}
|
||||
// Detect a record-file-only rollback/fork: every completed publication in
|
||||
// this same device ledger must be present in the verified chain.
|
||||
ensure!(
|
||||
completed_update_grants(db, binding)? == grants,
|
||||
"UPDATE_HISTORY_OMITTED_CONSUMPTION"
|
||||
);
|
||||
let exists: bool = db.query_row("SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='agent_update_handoffs')", [], |r| r.get(0))?;
|
||||
if exists {
|
||||
let mut query = db.prepare("SELECT h.grant_id,c.claim FROM agent_update_handoffs h LEFT JOIN agent_update_native_claims c ON c.grant_id=h.grant_id AND c.effect_key='publish_installed_record' WHERE h.phase='outcome_persisted' ORDER BY h.grant_id LIMIT 65")?;
|
||||
let mut rows = query.query([])?;
|
||||
let mut seen = BTreeSet::new();
|
||||
while let Some(row) = rows.next()? {
|
||||
let grant: String = row.get(0)?;
|
||||
let raw: Option<Vec<u8>> = row.get(1)?;
|
||||
let raw = raw.context("UPDATE_HISTORY_PUBLICATION_MISSING")?;
|
||||
ensure!(
|
||||
raw.len() <= 2048 && seen.len() < MAX_RECORDS,
|
||||
"UPDATE_HISTORY_PUBLICATION_LIMIT"
|
||||
);
|
||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw)?;
|
||||
let grant = Uuid::parse_str(&grant)?;
|
||||
ensure!(
|
||||
claim.grant_id() == grant && grants.contains(&grant) && seen.insert(grant),
|
||||
"UPDATE_HISTORY_OMITTED_PUBLICATION"
|
||||
);
|
||||
}
|
||||
ensure!(seen == grants, "UPDATE_HISTORY_MISSING_PUBLICATION");
|
||||
} else {
|
||||
ensure!(grants.is_empty(), "UPDATE_HISTORY_MISSING_LEDGER");
|
||||
}
|
||||
guard.check(db)?;
|
||||
Ok(active)
|
||||
}
|
||||
|
||||
fn current_keyring(file: &UpdateKeyringFile) -> Result<UpdateKeyring> {
|
||||
let mut keys = Vec::new();
|
||||
for key in &file.keys {
|
||||
let public: [u8; 32] = hex::decode(&key.public_key_hex)?
|
||||
.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_HISTORY_KEY_SIZE"))?;
|
||||
keys.push(TrustedUpdateKey::new(
|
||||
public,
|
||||
match key.platform {
|
||||
Platform::LinuxX64 => ReleasePlatform::LinuxX64,
|
||||
Platform::WindowsX64 => ReleasePlatform::WindowsX64,
|
||||
},
|
||||
key.first_sequence,
|
||||
key.last_sequence,
|
||||
key.revoked,
|
||||
)?);
|
||||
}
|
||||
UpdateKeyring::new(file.generation, keys)
|
||||
}
|
||||
|
||||
/// The authoritative completed set starts at ORIGINAL consumptions, not at an
|
||||
/// optional successor proof row. Stream a bounded local history, including old
|
||||
/// non-update jobs, without exposing any request/script bytes outside here.
|
||||
fn completed_update_grants(db: &Connection, binding: &Binding) -> Result<BTreeSet<Uuid>> {
|
||||
let mut query=db.prepare("SELECT c.grant_id,e.start,e.outcome,c.result FROM consumed c LEFT JOIN execution_evidence e USING(grant_id) WHERE c.result IS NOT NULL OR e.outcome IS NOT NULL ORDER BY c.grant_id LIMIT 4097")?;
|
||||
let mut rows = query.query([])?;
|
||||
let mut count = 0;
|
||||
let mut bytes = 0usize;
|
||||
let mut grants = BTreeSet::new();
|
||||
while let Some(row) = rows.next()? {
|
||||
count += 1;
|
||||
ensure!(count <= 4096, "UPDATE_HISTORY_CONSUMPTION_LIMIT");
|
||||
let grant: String = row.get(0)?;
|
||||
let start: Option<Vec<u8>> = row.get(1)?;
|
||||
let outcome: Option<Vec<u8>> = row.get(2)?;
|
||||
let finished: Option<Vec<u8>> = row.get(3)?;
|
||||
for raw in [&start, &outcome, &finished].into_iter().flatten() {
|
||||
bytes = bytes
|
||||
.checked_add(raw.len())
|
||||
.context("UPDATE_HISTORY_CONSUMPTION_SIZE")?;
|
||||
ensure!(
|
||||
raw.len() <= 512 * 1024 && bytes <= 16 * 1024 * 1024,
|
||||
"UPDATE_HISTORY_CONSUMPTION_SIZE"
|
||||
);
|
||||
}
|
||||
let raw = outcome
|
||||
.as_ref()
|
||||
.or(finished.as_ref())
|
||||
.context("UPDATE_HISTORY_COMPLETION_MISSING")?;
|
||||
if let (Some(a), Some(b)) = (&outcome, &finished) {
|
||||
let a: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(a)?;
|
||||
let b: rmm_domain::reconciliation::ReconciledOutcome = serde_json::from_slice(b)?;
|
||||
ensure!(
|
||||
rmm_domain::reconciliation::canonical_outcome_bytes(&a)?
|
||||
== rmm_domain::reconciliation::canonical_outcome_bytes(&b)?,
|
||||
"UPDATE_HISTORY_COMPLETION_CHANGED"
|
||||
);
|
||||
}
|
||||
let value: Outcome = serde_json::from_slice(raw)?;
|
||||
if value.state != "succeeded" {
|
||||
continue;
|
||||
}
|
||||
let start = start.context("UPDATE_HISTORY_START_MISSING")?;
|
||||
let start: serde_json::Value = serde_json::from_slice(&start)?;
|
||||
let request: Request = serde_json::from_value(start["request"].clone())?;
|
||||
let reserved_at: DateTime<Utc> = serde_json::from_value(start["reserved_at"].clone())?;
|
||||
let (job, permit) = binding.verify(&request, reserved_at)?;
|
||||
ensure!(
|
||||
permit.grant_id.to_string() == grant,
|
||||
"UPDATE_HISTORY_CONSUMPTION_CHANGED"
|
||||
);
|
||||
if matches!(job.action, Action::UpdateAgent { .. }) {
|
||||
ensure!(
|
||||
grants.len() < MAX_RECORDS && grants.insert(permit.grant_id),
|
||||
"UPDATE_HISTORY_COMPLETION_LIMIT"
|
||||
);
|
||||
}
|
||||
}
|
||||
Ok(grants)
|
||||
}
|
||||
|
||||
fn verify_record_release(
|
||||
keys: &UpdateKeyring,
|
||||
generation: u64,
|
||||
record: &InstalledReleaseRecord,
|
||||
baseline_protocol_major: u32,
|
||||
baseline_state_schema: u32,
|
||||
) -> Result<()> {
|
||||
ensure!(
|
||||
!record.rolled_back,
|
||||
"UPDATE_HISTORY_V1_ROLLBACK_UNSUPPORTED"
|
||||
);
|
||||
let decoded = record
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let platform = match record.platform {
|
||||
Platform::LinuxX64 => ReleasePlatform::LinuxX64,
|
||||
Platform::WindowsX64 => ReleasePlatform::WindowsX64,
|
||||
};
|
||||
let envelope: &ReleaseEnvelope = &record.release_envelope;
|
||||
verify_release(
|
||||
SignedRelease {
|
||||
schema_version: envelope.schema_version,
|
||||
key_id: &envelope.key_id,
|
||||
payload_bytes: &decoded.payload_bytes,
|
||||
signature: &decoded.signature,
|
||||
},
|
||||
keys,
|
||||
&TrustedContext {
|
||||
platform,
|
||||
now_utc_seconds: record.activated_at,
|
||||
keyring_generation: generation,
|
||||
// Anchor compatibility to the separately signed, qualified
|
||||
// bootstrap. A signed successor cannot attest its own decoder
|
||||
// compatibility by supplying both sides of this comparison.
|
||||
protocol_major: baseline_protocol_major,
|
||||
state_schema: baseline_state_schema,
|
||||
updater_version: 1,
|
||||
minimum_release_sequence: record.activation_floor,
|
||||
active_release: Some(ActiveRelease {
|
||||
sequence: decoded.manifest.release_sequence,
|
||||
manifest_sha256: record.manifest_sha256.clone(),
|
||||
}),
|
||||
},
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn verify_update(
|
||||
db: &Connection,
|
||||
guard: &impl ExecutorLedgerGuard,
|
||||
binding: &Binding,
|
||||
raw_record: &[u8],
|
||||
record: &InstalledReleaseRecord,
|
||||
parent_hash: &str,
|
||||
parent: &InstalledReleaseRecord,
|
||||
) -> Result<Uuid> {
|
||||
let ActivationEvidence::Updated {
|
||||
handoff_sha256,
|
||||
signed_health_sha256,
|
||||
} = &record.activation_evidence
|
||||
else {
|
||||
anyhow::bail!("UPDATE_HISTORY_BOOTSTRAP_FORK");
|
||||
};
|
||||
let mut query = db.prepare("SELECT h.grant_id,h.record,e.start,e.outcome,c.result FROM agent_update_handoffs h JOIN execution_evidence e USING(grant_id) JOIN consumed c USING(grant_id) WHERE h.record_sha256=?1 LIMIT 2")?;
|
||||
let values = query
|
||||
.query_map([handoff_sha256], |r| {
|
||||
Ok((
|
||||
r.get::<_, String>(0)?,
|
||||
r.get::<_, Vec<u8>>(1)?,
|
||||
r.get::<_, Vec<u8>>(2)?,
|
||||
r.get::<_, Option<Vec<u8>>>(3)?,
|
||||
r.get::<_, Option<Vec<u8>>>(4)?,
|
||||
))
|
||||
})?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
ensure!(
|
||||
values.len() == 1,
|
||||
"UPDATE_HISTORY_ORIGINAL_MISSING_OR_DUPLICATE"
|
||||
);
|
||||
let (grant, raw_handoff, start, outcome, finished) = &values[0];
|
||||
ensure!(
|
||||
raw_handoff.len() <= rmm_updater_handoff::MAX_RECORD_BYTES && start.len() <= 512 * 1024,
|
||||
"UPDATE_HISTORY_ORIGINAL_LIMIT"
|
||||
);
|
||||
let grant = Uuid::parse_str(grant)?;
|
||||
let header: Handoff = serde_json::from_slice(raw_handoff)?;
|
||||
ensure!(
|
||||
header.bytes()? == *raw_handoff
|
||||
&& hash(raw_handoff) == *handoff_sha256
|
||||
&& header.attempt.grant_id == grant
|
||||
&& header.predecessor_record_sha256 == parent_hash,
|
||||
"UPDATE_HISTORY_ORIGINAL_BINDING"
|
||||
);
|
||||
let start_value: serde_json::Value = serde_json::from_slice(start)?;
|
||||
let reserved_at: DateTime<Utc> = serde_json::from_value(start_value["reserved_at"].clone())?;
|
||||
let request: Request = serde_json::from_value(start_value["request"].clone())?;
|
||||
// Historical identity/signature/window verification only. Never a live
|
||||
// execution verifier or a replacement start grant.
|
||||
let (job, permit) = binding.verify(&request, reserved_at)?;
|
||||
let Action::UpdateAgent { update } = &job.action else {
|
||||
anyhow::bail!("UPDATE_HISTORY_JOB_ACTION");
|
||||
};
|
||||
let previous = parent
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
job.execution_identity == "root"
|
||||
&& update.release_envelope == record.release_envelope
|
||||
&& agent_update::handoff_matches_job(&header, &job)
|
||||
&& header.attempt.grant_id == permit.grant_id
|
||||
&& header.attempt.job_payload_sha256 == permit.job_payload_hash
|
||||
&& header.attempt.plan_id
|
||||
== permit.agent_update_plan_id.context("UPDATE_HISTORY_PLAN")?
|
||||
&& header.attempt.authorization_id == permit.authorization_id
|
||||
&& header.attempt.plan_sha256 == permit.plan_hash
|
||||
&& header.attempt.original_start_witness_sha256 == hash(start)
|
||||
&& header.attempt.original_request_sha256 == hash(&serde_json::to_vec(&request)?)
|
||||
&& header.consumed_at == u64::try_from(reserved_at.timestamp())?
|
||||
&& header.finish_before
|
||||
== header
|
||||
.consumed_at
|
||||
.checked_add(600)
|
||||
.context("UPDATE_HISTORY_DEADLINE")?
|
||||
&& ledger::start_witness_bytes(&permit, &request, header.boot_id, reserved_at)?
|
||||
== *start
|
||||
&& update.predecessor.installed_record_sha256 == parent_hash
|
||||
&& update.predecessor.manifest_sha256 == parent.manifest_sha256
|
||||
&& update.predecessor.release_id == previous.manifest.release_id
|
||||
&& update.predecessor.release_sequence == previous.manifest.release_sequence
|
||||
&& header.predecessor.manifest_sha256 == parent.manifest_sha256
|
||||
&& header.predecessor.agent_sha256 == previous.manifest.artifacts[0].sha256
|
||||
&& header.predecessor.helper_sha256 == previous.manifest.artifacts[1].sha256
|
||||
&& header.target.manifest_sha256 == record.manifest_sha256,
|
||||
"UPDATE_HISTORY_SIGNED_ORIGINAL_CHANGED"
|
||||
);
|
||||
let (count,size):(u64,u64)=db.query_row("SELECT count(*),COALESCE(sum(length(event)),0) FROM (SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence LIMIT 17)", [grant.to_string()], |r|Ok((r.get(0)?,r.get(1)?)))?;
|
||||
ensure!(
|
||||
count <= 16 && size <= 16 * 16384,
|
||||
"UPDATE_HISTORY_EVENT_LIMIT"
|
||||
);
|
||||
let journal = update_handoff::read(db, guard, grant)?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::OutcomePersisted,
|
||||
"UPDATE_HISTORY_INCOMPLETE_OR_UNKNOWN"
|
||||
);
|
||||
let (helper, agent): (String, Option<String>) = db.query_row(
|
||||
"SELECT journal_id,agent_journal_id FROM helper_sync_meta WHERE id=1",
|
||||
[],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
helper == header.helper_journal_id.to_string()
|
||||
&& agent.as_deref() == Some(header.agent_journal_id.to_string().as_str()),
|
||||
"UPDATE_HISTORY_LEDGER_LINEAGE"
|
||||
);
|
||||
let mut events = db.prepare(
|
||||
"SELECT event FROM agent_update_handoff_events WHERE grant_id=?1 ORDER BY sequence",
|
||||
)?;
|
||||
let events = events
|
||||
.query_map([grant.to_string()], |r| r.get::<_, Vec<u8>>(0))?
|
||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||
complete_native_history(db, &header, &events, parent_hash, &hash(raw_record))?;
|
||||
let mut health: Option<(SignedHealth, u64)> = None;
|
||||
let mut final_at = None;
|
||||
for raw in &events {
|
||||
let event: Event = serde_json::from_slice(raw)?;
|
||||
match event.evidence {
|
||||
Evidence::HealthVerified { receipt } => {
|
||||
ensure!(health.is_none(), "UPDATE_HISTORY_DOUBLE_HEALTH");
|
||||
health = Some((receipt, event.observed_at));
|
||||
}
|
||||
Evidence::OutcomePersisted { outcome_sha256 } => {
|
||||
let original = outcome.as_ref().context("UPDATE_HISTORY_OUTCOME_MISSING")?;
|
||||
ensure!(
|
||||
original.len() <= 512 * 1024 && hash(original) == outcome_sha256,
|
||||
"UPDATE_HISTORY_OUTCOME_CHANGED"
|
||||
);
|
||||
let value: Outcome = serde_json::from_slice(original)?;
|
||||
ensure!(
|
||||
value.state == "succeeded"
|
||||
&& !value.reboot_required
|
||||
&& finished.as_ref().is_none_or(|v| v == original),
|
||||
"UPDATE_HISTORY_OUTCOME_NOT_SUCCESS"
|
||||
);
|
||||
final_at = Some(event.observed_at);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let (health, verified_at) = health.context("UPDATE_HISTORY_HEALTH_MISSING")?;
|
||||
let receipt: HealthReceipt = serde_json::from_slice(&health.payload)?;
|
||||
ensure!(
|
||||
hash(&serde_json::to_vec(&health)?) == *signed_health_sha256
|
||||
&& record.activated_at == receipt.issued_at
|
||||
&& final_at.context("UPDATE_HISTORY_FINAL_MISSING")? >= verified_at,
|
||||
"UPDATE_HISTORY_HEALTH_OR_ACTIVATION_CHANGED"
|
||||
);
|
||||
// Journal replay already independently verified the health signature with
|
||||
// the public key bound by this ORIGINAL signed job and checked its deadline.
|
||||
let record_hash = hash(raw_record);
|
||||
let saved = publication(
|
||||
db,
|
||||
grant,
|
||||
"save_installed_record",
|
||||
parent_hash,
|
||||
&record_hash,
|
||||
)?;
|
||||
let published = publication(
|
||||
db,
|
||||
grant,
|
||||
"publish_installed_record",
|
||||
parent_hash,
|
||||
&record_hash,
|
||||
)?;
|
||||
ensure!(
|
||||
saved.0.timestamp() >= i64::try_from(verified_at)?
|
||||
&& published.0 >= saved.1
|
||||
&& published.1.timestamp()
|
||||
<= i64::try_from(final_at.context("UPDATE_HISTORY_FINAL_MISSING")?)?,
|
||||
"UPDATE_HISTORY_PUBLICATION_ORDER"
|
||||
);
|
||||
guard.check(db)?;
|
||||
Ok(grant)
|
||||
}
|
||||
|
||||
fn complete_native_history(
|
||||
db: &Connection,
|
||||
header: &Handoff,
|
||||
events: &[Vec<u8>],
|
||||
old: &str,
|
||||
new: &str,
|
||||
) -> Result<()> {
|
||||
use rmm_agent_core::update_handoff::{NativeFileRole as F, NativeService as S};
|
||||
let mut expected = BTreeSet::new();
|
||||
for service in [S::Agent, S::General, S::Full] {
|
||||
expected.insert(serde_json::to_string(&NativeEffect::StopService {
|
||||
service,
|
||||
})?);
|
||||
expected.insert(serde_json::to_string(&NativeEffect::StartService {
|
||||
service,
|
||||
})?);
|
||||
}
|
||||
for role in [F::AgentBinary, F::HelperBinary, F::FullConfig, F::FullPin] {
|
||||
expected.insert(serde_json::to_string(&NativeEffect::SavePredecessor {
|
||||
role,
|
||||
})?);
|
||||
expected.insert(serde_json::to_string(&NativeEffect::PublishReplacement {
|
||||
role,
|
||||
})?);
|
||||
}
|
||||
expected.insert(serde_json::to_string(&NativeEffect::ReturnLedger)?);
|
||||
expected.insert("save_installed_record".into());
|
||||
expected.insert("publish_installed_record".into());
|
||||
let parsed = events
|
||||
.iter()
|
||||
.map(|raw| Ok((hash(raw), serde_json::from_slice::<Event>(raw)?)))
|
||||
.collect::<Result<BTreeMap<_, _>>>()?;
|
||||
let time = |predicate: &dyn Fn(&Evidence) -> bool| -> Result<u64> {
|
||||
let entries = parsed
|
||||
.values()
|
||||
.filter(|event| predicate(&event.evidence))
|
||||
.collect::<Vec<_>>();
|
||||
ensure!(entries.len() == 1, "UPDATE_HISTORY_NATIVE_PHASE_MISSING");
|
||||
Ok(entries[0].observed_at)
|
||||
};
|
||||
let grant = header.attempt.grant_id.to_string();
|
||||
let mut query=db.prepare("SELECT c.effect_key,c.claim,c.claim_sha256,o.claim_sha256,o.observation_sha256,o.observed_at FROM agent_update_native_claims c LEFT JOIN agent_update_native_observations o USING(grant_id,effect_key) WHERE c.grant_id=?1 ORDER BY c.effect_key LIMIT 18")?;
|
||||
let mut rows = query.query([grant])?;
|
||||
let mut seen = BTreeSet::new();
|
||||
let mut return_group: Option<(String, DateTime<Utc>)> = None;
|
||||
while let Some(row) = rows.next()? {
|
||||
let key: String = row.get(0)?;
|
||||
let raw: Vec<u8> = row.get(1)?;
|
||||
let digest: String = row.get(2)?;
|
||||
ensure!(
|
||||
seen.len() < 17
|
||||
&& raw.len() <= 2048
|
||||
&& hash(&raw) == digest
|
||||
&& expected.contains(&key)
|
||||
&& seen.insert(key.clone()),
|
||||
"UPDATE_HISTORY_NATIVE_SET"
|
||||
);
|
||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw)?;
|
||||
let expected_key = match claim.effect() {
|
||||
NativeEffect::SaveInstalledRecord {
|
||||
old_sha256,
|
||||
new_sha256,
|
||||
} => {
|
||||
ensure!(
|
||||
old_sha256 == old && new_sha256 == new,
|
||||
"UPDATE_HISTORY_RECORD_PAIR"
|
||||
);
|
||||
"save_installed_record".into()
|
||||
}
|
||||
NativeEffect::PublishInstalledRecord {
|
||||
old_sha256,
|
||||
new_sha256,
|
||||
} => {
|
||||
ensure!(
|
||||
old_sha256 == old && new_sha256 == new,
|
||||
"UPDATE_HISTORY_RECORD_PAIR"
|
||||
);
|
||||
"publish_installed_record".into()
|
||||
}
|
||||
effect => serde_json::to_string(effect)?,
|
||||
};
|
||||
let head = parsed
|
||||
.get(claim.head_sha256())
|
||||
.context("UPDATE_HISTORY_NATIVE_HEAD_MISSING")?;
|
||||
let expected_head = match claim.effect() {
|
||||
NativeEffect::StopService { .. } => matches!(head.evidence, Evidence::StopIntent),
|
||||
NativeEffect::StartService { .. } | NativeEffect::ReturnLedger => {
|
||||
matches!(head.evidence, Evidence::LedgerReturnIntent)
|
||||
}
|
||||
NativeEffect::SaveInstalledRecord { .. }
|
||||
| NativeEffect::PublishInstalledRecord { .. } => {
|
||||
matches!(head.evidence, Evidence::HealthVerified { .. })
|
||||
}
|
||||
NativeEffect::SavePredecessor { role } | NativeEffect::PublishReplacement { role } => {
|
||||
let expected = match role {
|
||||
F::AgentBinary => rmm_updater_handoff::FileRole::AgentBinary,
|
||||
F::HelperBinary => rmm_updater_handoff::FileRole::HelperBinary,
|
||||
F::FullConfig => rmm_updater_handoff::FileRole::LinuxFullConfig,
|
||||
F::FullPin => rmm_updater_handoff::FileRole::LinuxFullPin,
|
||||
F::WindowsSettings => rmm_updater_handoff::FileRole::WindowsSettings,
|
||||
F::WindowsPin => rmm_updater_handoff::FileRole::WindowsPin,
|
||||
F::WindowsTimeProfile => rmm_updater_handoff::FileRole::WindowsTimeProfile,
|
||||
};
|
||||
matches!(head.evidence,Evidence::ReplaceIntent{role} if role==expected)
|
||||
}
|
||||
_ => false,
|
||||
};
|
||||
ensure!(
|
||||
key == expected_key
|
||||
&& expected_head
|
||||
&& serde_json::to_vec(&claim)? == raw
|
||||
&& claim.grant_id() == header.attempt.grant_id
|
||||
&& claim.owner_nonce() == header.owner_nonce
|
||||
&& u64::try_from(claim.claimed_at().timestamp())? >= head.observed_at
|
||||
&& u64::try_from(claim.claimed_at().timestamp())? >= header.consumed_at
|
||||
&& u64::try_from(claim.claimed_at().timestamp())? < header.finish_before,
|
||||
"UPDATE_HISTORY_NATIVE_CLAIM_CHANGED"
|
||||
);
|
||||
if matches!(
|
||||
claim.effect(),
|
||||
NativeEffect::ReturnLedger | NativeEffect::StartService { .. }
|
||||
) {
|
||||
let group = (claim.head_sha256().to_owned(), claim.claimed_at());
|
||||
ensure!(
|
||||
u64::try_from(group.1.timestamp())? == head.observed_at
|
||||
&& return_group.as_ref().is_none_or(|prior| prior == &group),
|
||||
"UPDATE_HISTORY_RETURN_STARTS_NOT_ATOMIC"
|
||||
);
|
||||
return_group = Some(group);
|
||||
}
|
||||
let observed: Option<String> = row.get(3)?;
|
||||
let observation: Option<String> = row.get(4)?;
|
||||
let when: Option<String> = row.get(5)?;
|
||||
if matches!(claim.effect(), NativeEffect::ReturnLedger) {
|
||||
ensure!(
|
||||
observed.is_none() && observation.is_none() && when.is_none(),
|
||||
"UPDATE_HISTORY_FALSE_RETURN_OBSERVATION"
|
||||
);
|
||||
} else {
|
||||
ensure!(
|
||||
observed.as_ref() == Some(&digest)
|
||||
&& observation
|
||||
.as_ref()
|
||||
.is_some_and(|v| agent_update::digest(v)),
|
||||
"UPDATE_HISTORY_NATIVE_OBSERVATION"
|
||||
);
|
||||
let when: DateTime<Utc> = when.context("UPDATE_HISTORY_NATIVE_OBSERVATION")?.parse()?;
|
||||
ensure!(
|
||||
when >= claim.claimed_at()
|
||||
&& u64::try_from(when.timestamp())? < header.finish_before,
|
||||
"UPDATE_HISTORY_NATIVE_OBSERVATION_TIME"
|
||||
);
|
||||
let end = match claim.effect() {
|
||||
NativeEffect::StopService { .. } => {
|
||||
time(&|e| matches!(e, Evidence::AllStopped { .. }))?
|
||||
}
|
||||
NativeEffect::StartService { .. } => {
|
||||
time(&|e| matches!(e, Evidence::ServicesStarted { .. }))?
|
||||
}
|
||||
NativeEffect::SaveInstalledRecord { .. }
|
||||
| NativeEffect::PublishInstalledRecord { .. } => {
|
||||
time(&|e| matches!(e, Evidence::OutcomePersisted { .. }))?
|
||||
}
|
||||
NativeEffect::SavePredecessor { role }
|
||||
| NativeEffect::PublishReplacement { role } => {
|
||||
let expected = match role {
|
||||
F::AgentBinary => rmm_updater_handoff::FileRole::AgentBinary,
|
||||
F::HelperBinary => rmm_updater_handoff::FileRole::HelperBinary,
|
||||
F::FullConfig => rmm_updater_handoff::FileRole::LinuxFullConfig,
|
||||
F::FullPin => rmm_updater_handoff::FileRole::LinuxFullPin,
|
||||
F::WindowsSettings => rmm_updater_handoff::FileRole::WindowsSettings,
|
||||
F::WindowsPin => rmm_updater_handoff::FileRole::WindowsPin,
|
||||
F::WindowsTimeProfile => rmm_updater_handoff::FileRole::WindowsTimeProfile,
|
||||
};
|
||||
time(&|e| matches!(e,Evidence::Replaced{role,..} if *role==expected))?
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_HISTORY_NATIVE_PHASE"),
|
||||
};
|
||||
ensure!(
|
||||
u64::try_from(when.timestamp())? <= end,
|
||||
"UPDATE_HISTORY_NATIVE_LATE_OBSERVATION"
|
||||
);
|
||||
if let NativeEffect::PublishReplacement { role } = claim.effect() {
|
||||
let save = serde_json::to_string(&NativeEffect::SavePredecessor { role: *role })?;
|
||||
let saved:String=db.query_row("SELECT observed_at FROM agent_update_native_observations WHERE grant_id=?1 AND effect_key=?2",params![header.attempt.grant_id.to_string(),save],|r|r.get(0))?;
|
||||
let saved: DateTime<Utc> = saved.parse()?;
|
||||
ensure!(
|
||||
saved <= claim.claimed_at(),
|
||||
"UPDATE_HISTORY_NATIVE_PUBLISH_BEFORE_SAVE"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
ensure!(seen == expected, "UPDATE_HISTORY_NATIVE_HISTORY_MISSING");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn publication(
|
||||
db: &Connection,
|
||||
grant: Uuid,
|
||||
effect: &str,
|
||||
old: &str,
|
||||
new: &str,
|
||||
) -> Result<(DateTime<Utc>, DateTime<Utc>)> {
|
||||
let value: Option<(Vec<u8>,String,String,String)> = db.query_row(
|
||||
"SELECT c.claim,c.claim_sha256,o.claim_sha256,o.observed_at FROM agent_update_native_claims c JOIN agent_update_native_observations o USING(grant_id,effect_key) WHERE c.grant_id=?1 AND c.effect_key=?2",
|
||||
params![grant.to_string(),effect], |r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?))).optional()?;
|
||||
let (raw, digest, observed, at) = value.context("UPDATE_HISTORY_PUBLICATION_MISSING")?;
|
||||
ensure!(
|
||||
raw.len() <= 2048 && hash(&raw) == digest && digest == observed,
|
||||
"UPDATE_HISTORY_PUBLICATION_CHANGED"
|
||||
);
|
||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw)?;
|
||||
let expected = if effect == "save_installed_record" {
|
||||
NativeEffect::SaveInstalledRecord {
|
||||
old_sha256: old.into(),
|
||||
new_sha256: new.into(),
|
||||
}
|
||||
} else {
|
||||
NativeEffect::PublishInstalledRecord {
|
||||
old_sha256: old.into(),
|
||||
new_sha256: new.into(),
|
||||
}
|
||||
};
|
||||
let observed: DateTime<Utc> = at.parse()?;
|
||||
ensure!(
|
||||
serde_json::to_vec(&claim)? == raw
|
||||
&& claim.grant_id() == grant
|
||||
&& claim.effect() == &expected
|
||||
&& observed >= claim.claimed_at(),
|
||||
"UPDATE_HISTORY_PUBLICATION_PAIR"
|
||||
);
|
||||
Ok((claim.claimed_at(), observed))
|
||||
}
|
||||
//! Shared admission history; native Linux fixtures remain here.
|
||||
pub use rmm_update_history::verify_history;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use anyhow::{Result, ensure};
|
||||
use chrono::{DateTime, Utc};
|
||||
use rmm_agent_core::{
|
||||
auth::{Binding, Outcome, Request},
|
||||
helper_reconcile::ExecutorLedgerGuard,
|
||||
ledger,
|
||||
update_handoff::{self, NativeEffect, NativeEffectClaim},
|
||||
};
|
||||
use rmm_domain::{
|
||||
agent_update::{self, Platform, ReleaseEnvelope, UpdateKeyringFile},
|
||||
agent_update_provisioning::{
|
||||
ActivationEvidence, BASELINE_SIGNATURE_DOMAIN, InstalledReleaseRecord,
|
||||
SignedBaselineRecord,
|
||||
},
|
||||
jobs::{Action, hash},
|
||||
};
|
||||
use rmm_updater_handoff::{Event, Evidence, Handoff, HealthReceipt, SignedHealth};
|
||||
use rusqlite::{Connection, params};
|
||||
use uuid::Uuid;
|
||||
|
||||
// Historical in-memory bytes only: no service, filesystem, real operation,
|
||||
// current authority or simulated WebUI approval is created by this fixture.
|
||||
use super::*;
|
||||
|
||||
@@ -212,6 +212,12 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
||||
NativeEffect::PublishReplacement { role } => {
|
||||
self.native_observation_sha256(file_role(*role), true)?
|
||||
}
|
||||
NativeEffect::SaveRejectedCandidate { role } => {
|
||||
self.native_observation_sha256(file_role(*role), true)?
|
||||
}
|
||||
NativeEffect::RestorePredecessor { role } => {
|
||||
self.native_observation_sha256(file_role(*role), false)?
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_OWNED_OBSERVATION_NOT_ALLOWED"),
|
||||
};
|
||||
ensure!(expected == observation, "UPDATE_NATIVE_OBSERVATION_CHANGED");
|
||||
@@ -243,6 +249,19 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
||||
pub fn verify_pair(&self) -> Result<()> {
|
||||
self.guard.files.verify_pair(self.guard.budget)
|
||||
}
|
||||
pub fn verify_predecessor_pair(&self) -> Result<()> {
|
||||
self.guard.files.verify_predecessor_pair(self.guard.budget)
|
||||
}
|
||||
pub fn predecessor_sha256(&self, role: rmm_updater_handoff::FileRole) -> Result<String> {
|
||||
self.guard
|
||||
.original
|
||||
.handoff()
|
||||
.files
|
||||
.iter()
|
||||
.find(|f| f.role == role)
|
||||
.map(|f| f.old_sha256.clone())
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_OLD_FILE_NOT_BOUND"))
|
||||
}
|
||||
pub fn inflight_proof(&self) -> Result<rmm_domain::agent_update::UpdateInflightProof> {
|
||||
let journal = self.journal()?;
|
||||
let mut statement = self.db.prepare(
|
||||
@@ -291,6 +310,71 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
||||
old_services,
|
||||
})
|
||||
}
|
||||
pub fn prepare_rollback_return_and_close(mut self) -> Result<PreparedReservation> {
|
||||
let journal = self.journal()?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::PredecessorVerified,
|
||||
"UPDATE_ROLLBACK_RETURN_REQUIRES_PREDECESSOR"
|
||||
);
|
||||
let now = self.guard.clock.now()?;
|
||||
let event = journal.prepare(
|
||||
u64::try_from(now.timestamp())?,
|
||||
Evidence::RollbackLedgerReturnIntent,
|
||||
)?;
|
||||
let claims = update_handoff::prepare_rollback_return_and_starts(
|
||||
&mut self.db,
|
||||
&self.guard,
|
||||
self.guard.original.permit().grant_id,
|
||||
journal.head_sha256(),
|
||||
&event,
|
||||
now,
|
||||
)?;
|
||||
let proof = self.inflight_proof()?;
|
||||
let ledger = self.guard.os.identity().clone();
|
||||
let old_services = self.guard.stopped.proofs();
|
||||
self.close()?;
|
||||
Ok(PreparedReservation {
|
||||
claims,
|
||||
proof,
|
||||
ledger,
|
||||
old_services,
|
||||
})
|
||||
}
|
||||
pub fn begin_rollback_after_early_full_failure(&mut self, expected_head: &str) -> Result<()> {
|
||||
let source = self.guard.stopped.early_full_failure(self.guard.budget)?;
|
||||
let start = hash(&serde_json::to_vec(source.general_start())?);
|
||||
let failure = source.failure_sha256()?;
|
||||
update_handoff::begin_rollback_after_reserved_stop(
|
||||
&mut self.db,
|
||||
&self.guard,
|
||||
update_handoff::ReservedGeneralStop {
|
||||
grant_id: self.guard.original.permit().grant_id,
|
||||
expected_head,
|
||||
general_start_observation_sha256: &start,
|
||||
general_stop_observation_sha256: source.general_stop_sha256(),
|
||||
failure_observation_sha256: &failure,
|
||||
now: self.guard.clock.now()?,
|
||||
},
|
||||
)
|
||||
}
|
||||
pub fn append_rollback_stopped(&mut self) -> Result<()> {
|
||||
let source = self.guard.stopped.early_full_failure(self.guard.budget)?;
|
||||
let observation = hash(&serde_json::to_vec(&(
|
||||
source.general_start(),
|
||||
source.general_stop_sha256(),
|
||||
source.failure(),
|
||||
))?);
|
||||
let owner = self.guard.updater.identity();
|
||||
self.append_observed(Evidence::RollbackStopped {
|
||||
process: rmm_updater_handoff::Process {
|
||||
pid: owner.pid,
|
||||
birth: owner.birth,
|
||||
image_sha256: owner.image_sha256.clone(),
|
||||
},
|
||||
ledger_identity_sha256: self.guard.os.identity().sha256()?,
|
||||
observation_sha256: observation,
|
||||
})
|
||||
}
|
||||
/// Close the actual SQLite connection BEFORE returning the OS flock. An
|
||||
/// open/failed-close connection never produces a released-ledger witness.
|
||||
pub fn close(self) -> Result<()> {
|
||||
@@ -443,6 +527,81 @@ impl UpdateParticipantGuard for OwnedGuard<'_, '_> {
|
||||
);
|
||||
}
|
||||
Evidence::LedgerReturnIntent => self.files.verify_pair(self.budget)?,
|
||||
Evidence::RollbackIntent {
|
||||
cause:
|
||||
rmm_updater_handoff::RollbackCause::StartupFailed {
|
||||
service: rmm_updater_handoff::Service::LinuxFullHelper,
|
||||
},
|
||||
failure_observation_sha256,
|
||||
} => {
|
||||
let source = self.stopped.early_full_failure(self.budget)?;
|
||||
ensure!(
|
||||
*failure_observation_sha256 == source.failure_sha256()?,
|
||||
"UPDATE_ROLLBACK_FAILURE_CHANGED"
|
||||
);
|
||||
self.files.verify_pair(self.budget)?;
|
||||
}
|
||||
Evidence::RollbackStopped {
|
||||
process,
|
||||
ledger_identity_sha256,
|
||||
observation_sha256,
|
||||
} => {
|
||||
let source = self.stopped.early_full_failure(self.budget)?;
|
||||
let owner = self.updater.identity();
|
||||
ensure!(
|
||||
process.pid == owner.pid
|
||||
&& process.birth == owner.birth
|
||||
&& process.image_sha256 == owner.image_sha256
|
||||
&& *ledger_identity_sha256 == self.os.identity().sha256()?
|
||||
&& *observation_sha256
|
||||
== hash(&serde_json::to_vec(&(
|
||||
source.general_start(),
|
||||
source.general_stop_sha256(),
|
||||
source.failure()
|
||||
))?),
|
||||
"UPDATE_ROLLBACK_STOPPED_WITNESS"
|
||||
);
|
||||
}
|
||||
Evidence::RestoreIntent { role } => self.files.verify_replaced(*role, self.budget)?,
|
||||
Evidence::CandidatePreserved {
|
||||
role,
|
||||
observation_sha256,
|
||||
} => {
|
||||
self.files.verify_candidate_saved(*role, self.budget)?;
|
||||
ensure!(
|
||||
*observation_sha256 == self.files.native_observation_sha256(*role, true)?,
|
||||
"UPDATE_REJECTED_CANDIDATE_HASH"
|
||||
);
|
||||
}
|
||||
Evidence::PredecessorRestored {
|
||||
role,
|
||||
observed_sha256,
|
||||
} => {
|
||||
self.files.verify_restored(*role, self.budget)?;
|
||||
ensure!(
|
||||
handoff
|
||||
.files
|
||||
.iter()
|
||||
.any(|f| f.role == *role && f.old_sha256 == *observed_sha256),
|
||||
"UPDATE_RESTORED_PREDECESSOR_HASH"
|
||||
);
|
||||
}
|
||||
Evidence::PredecessorVerified {
|
||||
pair,
|
||||
retained_state_sha256,
|
||||
predecessor_record_sha256,
|
||||
} => {
|
||||
self.files.verify_predecessor_pair(self.budget)?;
|
||||
ensure!(
|
||||
*pair == handoff.predecessor
|
||||
&& *retained_state_sha256 == handoff.retained_state_sha256
|
||||
&& *predecessor_record_sha256 == handoff.predecessor_record_sha256,
|
||||
"UPDATE_PREDECESSOR_BINDING"
|
||||
);
|
||||
}
|
||||
Evidence::RollbackLedgerReturnIntent => {
|
||||
self.files.verify_predecessor_pair(self.budget)?
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_EVENT_WRITER_NOT_ALLOWED"),
|
||||
}
|
||||
Ok(())
|
||||
@@ -492,8 +651,123 @@ impl UpdateParticipantGuard for OwnedGuard<'_, '_> {
|
||||
| (NativeEffect::StartService { .. }, NativeEffectStage::ReserveFutureStart) => {
|
||||
self.files.verify_pair(self.budget)?
|
||||
}
|
||||
(
|
||||
NativeEffect::ConditionalRollbackStopGeneral,
|
||||
NativeEffectStage::ReserveConditionalStop,
|
||||
) => {
|
||||
ensure!(
|
||||
handoff.schema_version == 2
|
||||
&& delegation.original_helper.role
|
||||
== rmm_domain::agent_update::ParticipantRole::LinuxFullHelper,
|
||||
"UPDATE_CONDITIONAL_STOP_PROFILE"
|
||||
);
|
||||
self.stopped.verify_still_stopped(self.budget)?;
|
||||
self.files.verify_pair(self.budget)?;
|
||||
}
|
||||
(
|
||||
NativeEffect::StartService {
|
||||
service: update_handoff::NativeService::General,
|
||||
},
|
||||
NativeEffectStage::ObserveRetainedStart,
|
||||
)
|
||||
| (NativeEffect::ConditionalRollbackStopGeneral, NativeEffectStage::Observe)
|
||||
| (
|
||||
NativeEffect::StartService {
|
||||
service:
|
||||
update_handoff::NativeService::Full | update_handoff::NativeService::Agent,
|
||||
},
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => {
|
||||
self.stopped.early_full_failure(self.budget)?;
|
||||
self.files.verify_pair(self.budget)?;
|
||||
}
|
||||
(
|
||||
NativeEffect::RollbackStopService {
|
||||
service:
|
||||
update_handoff::NativeService::Full | update_handoff::NativeService::Agent,
|
||||
},
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => {
|
||||
self.stopped.early_full_failure(self.budget)?;
|
||||
self.files.verify_pair(self.budget)?;
|
||||
}
|
||||
(NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Claim) => {
|
||||
self.files.verify_replaced(role(r), self.budget)?
|
||||
}
|
||||
(NativeEffect::SaveRejectedCandidate { role: r }, NativeEffectStage::Observe)
|
||||
| (NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Claim) => {
|
||||
self.files.verify_candidate_saved(role(r), self.budget)?
|
||||
}
|
||||
(NativeEffect::RestorePredecessor { role: r }, NativeEffectStage::Observe) => {
|
||||
self.files.verify_restored(role(r), self.budget)?
|
||||
}
|
||||
(NativeEffect::RollbackReturnLedger, NativeEffectStage::Claim)
|
||||
| (NativeEffect::RollbackStartService { .. }, NativeEffectStage::ReserveFutureStart) => {
|
||||
self.files.verify_predecessor_pair(self.budget)?
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_NATIVE_OWNED_EFFECT_DENIED"),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn native_observation_sha256(
|
||||
&self,
|
||||
h: &Handoff,
|
||||
d: &UpdateDelegation,
|
||||
effect: &NativeEffect,
|
||||
stage: NativeEffectStage,
|
||||
) -> Result<String> {
|
||||
self.verify_native_effect(h, d, effect, stage)?;
|
||||
let source = self.stopped.early_full_failure(self.budget)?;
|
||||
match (effect, stage) {
|
||||
(
|
||||
NativeEffect::StartService {
|
||||
service: update_handoff::NativeService::General,
|
||||
},
|
||||
NativeEffectStage::ObserveRetainedStart,
|
||||
) => Ok(hash(&serde_json::to_vec(source.general_start())?)),
|
||||
(NativeEffect::ConditionalRollbackStopGeneral, NativeEffectStage::Observe) => {
|
||||
Ok(source.general_stop_sha256().into())
|
||||
}
|
||||
(
|
||||
NativeEffect::StartService {
|
||||
service: update_handoff::NativeService::Full,
|
||||
},
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => source.failure_sha256(),
|
||||
(
|
||||
NativeEffect::RollbackStopService {
|
||||
service: update_handoff::NativeService::Full,
|
||||
},
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => Ok(hash(&serde_json::to_vec(&(
|
||||
"failed_full_stop_not_needed_v1",
|
||||
h.owner_nonce,
|
||||
h.attempt.grant_id,
|
||||
source.failure_sha256()?,
|
||||
))?)),
|
||||
(
|
||||
NativeEffect::RollbackStopService {
|
||||
service: update_handoff::NativeService::Agent,
|
||||
},
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => Ok(hash(&serde_json::to_vec(&(
|
||||
"unstarted_agent_stop_not_needed_v1",
|
||||
h.owner_nonce,
|
||||
h.attempt.grant_id,
|
||||
source.failure_sha256()?,
|
||||
))?)),
|
||||
(
|
||||
NativeEffect::StartService {
|
||||
service: update_handoff::NativeService::Agent,
|
||||
},
|
||||
NativeEffectStage::ObserveNonstart,
|
||||
) => Ok(hash(&serde_json::to_vec(&(
|
||||
"agent_start_not_dispatched_v1",
|
||||
h.owner_nonce,
|
||||
h.attempt.grant_id,
|
||||
source.failure_sha256()?,
|
||||
))?)),
|
||||
_ => anyhow::bail!("UPDATE_OWNED_NATIVE_HASH_NOT_QUALIFIED"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
//! Stable local service entrypoint. No network endpoint, command arguments,
|
||||
//! approval API or startup replay of a previously admitted update.
|
||||
#[cfg(target_os = "linux")]
|
||||
mod linux {
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use rmm_agent_core::auth::Binding;
|
||||
use rmm_updater_linux::{files::Directory, ipc::Listener};
|
||||
use rmm_updater_worker::engine::Runtime;
|
||||
use std::{
|
||||
ffi::OsStr,
|
||||
path::Path,
|
||||
sync::atomic::{AtomicBool, Ordering},
|
||||
};
|
||||
|
||||
static STOP: AtomicBool = AtomicBool::new(false);
|
||||
extern "C" fn stop(_: libc::c_int) {
|
||||
STOP.store(true, Ordering::SeqCst);
|
||||
}
|
||||
fn binding() -> Result<Binding> {
|
||||
let directory = Directory::open(Path::new("/etc/rmm-agent-updater"), 0, false)?;
|
||||
let name = OsStr::new("binding.json");
|
||||
let mut file = directory.inspect(name, 0, 32768)?;
|
||||
ensure!(
|
||||
file.proof().identity.mode & 0o777 == 0o600 && file.proof().identity.links == 1,
|
||||
"UPDATE_DAEMON_PRIVATE_BINDING"
|
||||
);
|
||||
let bytes = file.bytes(32768)?;
|
||||
let binding: Binding = serde_json::from_slice(&bytes)?;
|
||||
let public: [u8; 32] = hex::decode(&binding.public_key_hex)?
|
||||
.try_into()
|
||||
.map_err(|_| anyhow::anyhow!("UPDATE_DAEMON_SIGNING_PIN"))?;
|
||||
ensure!(
|
||||
!binding.tenant_id.is_nil()
|
||||
&& !binding.asset_id.is_nil()
|
||||
&& !binding.agent_id.is_nil()
|
||||
&& binding.enrollment_generation > 0
|
||||
&& binding.assignment_version > 0
|
||||
&& !ed25519_dalek::VerifyingKey::from_bytes(&public)?.is_weak(),
|
||||
"UPDATE_DAEMON_BINDING"
|
||||
);
|
||||
directory.file(name, file.proof(), 32768)?;
|
||||
Ok(binding)
|
||||
}
|
||||
pub fn run() -> Result<()> {
|
||||
let args: Vec<_> = std::env::args_os().skip(1).collect();
|
||||
if args == [OsStr::new("--help")] {
|
||||
println!(
|
||||
"rmm-agent-updater --serve\nFixed protected local binding/policy and authenticated Fullhelper IPC only. No automatic activation or startup replay. A failed/ambiguous pass stops closed; operator recovery must inspect the original handoff."
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
ensure!(args == [OsStr::new("--serve")], "UPDATE_DAEMON_ARGUMENTS");
|
||||
// SAFETY: geteuid/getegid have no pointer arguments or preconditions.
|
||||
ensure!(
|
||||
unsafe { libc::geteuid() } == 0 && unsafe { libc::getegid() } == 0,
|
||||
"UPDATE_DAEMON_ROOT_SERVICE_REQUIRED"
|
||||
);
|
||||
// SAFETY: handlers only set a lock-free atomic and hold no borrowed state.
|
||||
unsafe {
|
||||
let mut action: libc::sigaction = std::mem::zeroed();
|
||||
action.sa_sigaction = stop as *const () as usize;
|
||||
libc::sigemptyset(&mut action.sa_mask);
|
||||
ensure!(
|
||||
libc::sigaction(libc::SIGTERM, &action, std::ptr::null_mut()) == 0
|
||||
&& libc::sigaction(libc::SIGINT, &action, std::ptr::null_mut()) == 0,
|
||||
"UPDATE_DAEMON_SIGNALS"
|
||||
);
|
||||
}
|
||||
let binding = binding()?;
|
||||
let mut runtime = Runtime::new(binding.clone())?;
|
||||
let listener = Listener::bind()?;
|
||||
while !STOP.load(Ordering::SeqCst) {
|
||||
if let Err(error) = runtime.serve_one(&listener) {
|
||||
// A short idle poll is normal. Other failed handshakes do not
|
||||
// become an activation; after possible dispatch the runtime's
|
||||
// fuse closes permanently and this process must stop.
|
||||
if runtime.failed() {
|
||||
anyhow::bail!("UPDATE_DAEMON_ORIGINAL_PASS_FAILED");
|
||||
}
|
||||
if error.to_string() != "UPDATE_IPC_NO_REQUEST" {
|
||||
eprintln!("UPDATE_DAEMON_REQUEST_REJECTED");
|
||||
}
|
||||
}
|
||||
if runtime.terminal() {
|
||||
// A successful ORIGINAL finalization permits the service to
|
||||
// observe its new installed record for a later, separately
|
||||
// approved attempt. No old handoff is resumed by construction.
|
||||
runtime = Runtime::new(binding.clone()).context("UPDATE_DAEMON_NEW_BASELINE")?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
fn main() {
|
||||
if linux::run().is_err() {
|
||||
eprintln!("UPDATE_DAEMON_CLOSED");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
fn main() {
|
||||
eprintln!("Native Linux updater service only");
|
||||
std::process::exit(1);
|
||||
}
|
||||
@@ -231,16 +231,28 @@ impl QualifiedRegistry {
|
||||
Ok(())
|
||||
}
|
||||
pub fn verify_admission(&self, policy: &LocalUpdatePolicy, budget: &Budget) -> Result<()> {
|
||||
self.verify_phase(policy, budget, false)
|
||||
self.verify_phase(policy, budget, false, None)
|
||||
}
|
||||
pub fn verify_stopped(&self, policy: &LocalUpdatePolicy, budget: &Budget) -> Result<()> {
|
||||
self.verify_phase(policy, budget, true)
|
||||
self.verify_phase(policy, budget, true, None)
|
||||
}
|
||||
pub fn verify_known_failure_stopped(
|
||||
&self,
|
||||
policy: &LocalUpdatePolicy,
|
||||
stopped: &rmm_updater_linux::services::StoppedServices,
|
||||
budget: &Budget,
|
||||
) -> Result<()> {
|
||||
let source = stopped.early_full_failure(budget)?;
|
||||
self.verify_phase(policy, budget, true, Some(source.failure()))?;
|
||||
stopped.early_full_failure(budget)?;
|
||||
Ok(())
|
||||
}
|
||||
fn verify_phase(
|
||||
&self,
|
||||
policy: &LocalUpdatePolicy,
|
||||
budget: &Budget,
|
||||
stopped: bool,
|
||||
failed: Option<&rmm_updater_linux::services::FailedStartProof>,
|
||||
) -> Result<()> {
|
||||
budget.check()?;
|
||||
self.verify_protected()?;
|
||||
@@ -269,7 +281,15 @@ impl QualifiedRegistry {
|
||||
for (index, unit) in self.registry.units.iter().enumerate() {
|
||||
let active = index < 4 && (!stopped || index == 3);
|
||||
let status = observe(unit, budget)?;
|
||||
status.verify(unit, active, index < 4)?;
|
||||
if let Some(failure) = failed.filter(|f| f.service.unit() == unit.unit) {
|
||||
ensure!(
|
||||
stopped && index < 3 && !active,
|
||||
"UPDATE_FAILED_READER_SCOPE"
|
||||
);
|
||||
status.verify_known_failed(unit, failure)?;
|
||||
} else {
|
||||
status.verify(unit, active, index < 4)?;
|
||||
}
|
||||
first.insert(unit.unit.clone(), status);
|
||||
}
|
||||
for unit in &self.registry.rollback_timers {
|
||||
@@ -586,6 +606,41 @@ impl Status {
|
||||
&& self.connections.is_none_or(|n| n == 0)
|
||||
&& self.fields["Job"].is_empty()
|
||||
}
|
||||
fn verify_known_failed(
|
||||
&self,
|
||||
unit: &Unit,
|
||||
failure: &rmm_updater_linux::services::FailedStartProof,
|
||||
) -> Result<()> {
|
||||
let f = &self.fields;
|
||||
ensure!(
|
||||
!unit.composition.is_empty()
|
||||
&& failure.service.unit() == unit.unit
|
||||
&& f["ActiveState"] == "failed"
|
||||
&& f["SubState"] == "failed"
|
||||
&& self.main_pid == Some(0)
|
||||
&& self.control_pid == Some(0)
|
||||
&& f["Job"].is_empty()
|
||||
&& f["LoadState"] == "loaded"
|
||||
&& f["UnitFileState"] == unit.unit_file_state
|
||||
&& relations(&f["Triggers"])? == unit.triggers
|
||||
&& relations(&f["TriggeredBy"])? == unit.triggered_by,
|
||||
"UPDATE_FAILED_READER_NOT_CLOSED"
|
||||
);
|
||||
let mut paths = vec![f["FragmentPath"].as_str()];
|
||||
paths.extend(f["DropInPaths"].split_ascii_whitespace());
|
||||
ensure!(
|
||||
paths
|
||||
.into_iter()
|
||||
.eq(unit.composition.iter().map(|(p, _)| p.as_str())),
|
||||
"UPDATE_FAILED_READER_UNIT_CHANGED"
|
||||
);
|
||||
for (key, value) in &failure.status {
|
||||
if let Some(actual) = f.get(key) {
|
||||
ensure!(actual == value, "UPDATE_FAILED_READER_STATUS_CHANGED");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn verify(&self, unit: &Unit, active: bool, original_reader: bool) -> Result<()> {
|
||||
let fields = &self.fields;
|
||||
ensure!(
|
||||
@@ -796,6 +851,145 @@ fn command(args: &[&str], budget: &Budget) -> Result<Vec<u8>> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Public bootstrap metadata only. This does not publish policy, qualify a
|
||||
/// reader, start the updater or grant any update/job authority. The operator
|
||||
/// must bind the qualification receipt to actual freshly verified code/sync.
|
||||
#[derive(Serialize)]
|
||||
pub struct BootstrapMetadata {
|
||||
pub registry_bytes: Vec<u8>,
|
||||
pub reader_registry_sha256: String,
|
||||
pub services: Vec<rmm_domain::agent_update_provisioning::LocalServicePin>,
|
||||
pub updater_service: rmm_domain::agent_update_provisioning::LocalServicePin,
|
||||
}
|
||||
/// Read the actual fixed 21-unit closure AFTER compatible pair startup and
|
||||
/// installation of the still-stopped stable updater unit. Never invent file IDs
|
||||
/// or infer a registry from source unit text; retain each measured file until
|
||||
/// the second identical actual observation. No filesystem/SCM mutations.
|
||||
pub fn bootstrap_metadata(
|
||||
qualification_sha256: &str,
|
||||
budget: &Budget,
|
||||
) -> Result<BootstrapMetadata> {
|
||||
ensure!(
|
||||
digest(qualification_sha256) && unsafe { libc::geteuid() } == 0,
|
||||
"UPDATE_BOOTSTRAP_METADATA_SCOPE"
|
||||
);
|
||||
let host_context = current_host_context()?;
|
||||
let first_rollback = rollback_names(budget)?;
|
||||
let names = fixed_units()
|
||||
.into_iter()
|
||||
.chain(first_rollback.iter().cloned())
|
||||
.collect::<Vec<_>>();
|
||||
let mut retained = Vec::new();
|
||||
let mut units = Vec::new();
|
||||
let mut first = Vec::new();
|
||||
for (index, name) in names.iter().enumerate() {
|
||||
let mut unit = Unit {
|
||||
unit: name.clone(),
|
||||
unit_file_state: String::new(),
|
||||
composition: Vec::new(),
|
||||
triggers: Vec::new(),
|
||||
triggered_by: Vec::new(),
|
||||
};
|
||||
let status = observe(&unit, budget)?;
|
||||
let fields = &status.fields;
|
||||
unit.unit_file_state = fields["UnitFileState"].clone();
|
||||
unit.triggers = relations(&fields["Triggers"])?;
|
||||
unit.triggered_by = relations(&fields["TriggeredBy"])?;
|
||||
ensure!(
|
||||
unit.triggers
|
||||
.iter()
|
||||
.chain(&unit.triggered_by)
|
||||
.all(|n| names.contains(n)),
|
||||
"UPDATE_BOOTSTRAP_UNKNOWN_ACTIVATION_RELATION"
|
||||
);
|
||||
if fields["LoadState"] == "loaded" {
|
||||
let mut paths = vec![fields["FragmentPath"].as_str()];
|
||||
paths.extend(fields["DropInPaths"].split_ascii_whitespace());
|
||||
ensure!(
|
||||
!paths[0].is_empty() && paths.len() <= 17,
|
||||
"UPDATE_BOOTSTRAP_UNIT_PATHS"
|
||||
);
|
||||
for (position, path) in paths.into_iter().enumerate() {
|
||||
let leaf = Path::new(path).file_name().and_then(|v| v.to_str());
|
||||
ensure!(
|
||||
unit_path(path)
|
||||
&& if position == 0 {
|
||||
leaf == Some(name.as_str())
|
||||
} else {
|
||||
leaf.is_some_and(|v| v.ends_with(".conf"))
|
||||
},
|
||||
"UPDATE_BOOTSTRAP_UNIT_PATH"
|
||||
);
|
||||
let held = Protected::open(Path::new(path))?;
|
||||
unit.composition.push((path.into(), held.proof.clone()));
|
||||
retained.push(held);
|
||||
}
|
||||
}
|
||||
// The prospective updater is deliberately inactive until ALL protected
|
||||
// trust/baseline/retained material has been independently provisioned.
|
||||
status.verify(&unit, index < 3, index < 4)?;
|
||||
if index >= 4 && !unit.composition.is_empty() {
|
||||
ensure!(
|
||||
unit.unit_file_state == "disabled",
|
||||
"UPDATE_BOOTSTRAP_CLOSED_UNIT_AUTOSTART"
|
||||
);
|
||||
}
|
||||
ensure!(retained.len() <= MAX_FILES, "UPDATE_BOOTSTRAP_FILE_LIMIT");
|
||||
first.push(status);
|
||||
units.push(unit);
|
||||
}
|
||||
ensure!(
|
||||
units.len() == 21 + first_rollback.len() && !units[3].composition.is_empty(),
|
||||
"UPDATE_BOOTSTRAP_UPDATER_UNIT_REQUIRED"
|
||||
);
|
||||
for (unit, status) in units.iter().zip(&first) {
|
||||
ensure!(
|
||||
observe(unit, budget)? == *status,
|
||||
"UPDATE_BOOTSTRAP_UNIT_CHANGED"
|
||||
);
|
||||
}
|
||||
for held in &retained {
|
||||
held.verify()?;
|
||||
}
|
||||
ensure!(
|
||||
rollback_names(budget)? == first_rollback && current_host_context()? == host_context,
|
||||
"UPDATE_BOOTSTRAP_HOST_OR_TIMER_CHANGED"
|
||||
);
|
||||
let pin = |unit: &Unit| -> Result<rmm_domain::agent_update_provisioning::LocalServicePin> {
|
||||
Ok(rmm_domain::agent_update_provisioning::LocalServicePin {
|
||||
unit: unit.unit.clone(),
|
||||
unit_sha256: hash(&serde_json::to_vec(&unit.composition)?),
|
||||
})
|
||||
};
|
||||
let mut services = units[..3].iter().map(pin).collect::<Result<Vec<_>>>()?;
|
||||
if !units[4].composition.is_empty() {
|
||||
services.push(pin(&units[4])?);
|
||||
}
|
||||
let updater_service = pin(&units[3])?;
|
||||
let rollback_timers = units.split_off(21);
|
||||
let registry = Registry {
|
||||
schema_version: 1,
|
||||
profile: "linux_shared_readers_v1".into(),
|
||||
bootstrap_receipt_sha256: qualification_sha256.into(),
|
||||
reader_contract_sha256: reader_contract_sha256(),
|
||||
host_context,
|
||||
units,
|
||||
rollback_timers,
|
||||
};
|
||||
let registry_bytes = serde_json::to_vec(®istry)?;
|
||||
ensure!(
|
||||
registry_bytes.len() <= MAX_BYTES as usize,
|
||||
"UPDATE_BOOTSTRAP_REGISTRY_LIMIT"
|
||||
);
|
||||
budget.check()?;
|
||||
Ok(BootstrapMetadata {
|
||||
reader_registry_sha256: hash(®istry_bytes),
|
||||
registry_bytes,
|
||||
services,
|
||||
updater_service,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -8,7 +8,7 @@ use ed25519_dalek::{Signature, VerifyingKey};
|
||||
use rmm_agent_core::update_handoff::NativeEffect;
|
||||
use rmm_domain::{
|
||||
agent_update::ResolvedAgentUpdate,
|
||||
agent_update_provisioning::{ActivationEvidence, InstalledReleaseRecord, MAX_RECORD_BYTES},
|
||||
agent_update_provisioning::{InstalledReleaseRecord, MAX_RECORD_BYTES},
|
||||
jobs::hash,
|
||||
};
|
||||
use rmm_updater_handoff::{
|
||||
@@ -131,41 +131,15 @@ impl BuiltRecord {
|
||||
update.validate() && !grant_id.is_nil() && !owner_nonce.is_nil(),
|
||||
"UPDATE_RECORD_INPUT"
|
||||
);
|
||||
let prior = InstalledReleaseRecord::from_bytes(prior_raw).map_err(anyhow::Error::msg)?;
|
||||
let parent = prior
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let target = update.manifest().map_err(anyhow::Error::msg)?;
|
||||
let record = rmm_domain::agent_update_provisioning::assemble_updated_record(
|
||||
update,
|
||||
prior_raw,
|
||||
handoff_sha256,
|
||||
signed,
|
||||
receipt,
|
||||
)
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
let old_sha256 = hash(prior_raw);
|
||||
ensure!(
|
||||
!prior.rolled_back
|
||||
&& old_sha256 == update.predecessor.installed_record_sha256
|
||||
&& prior.manifest_sha256 == update.predecessor.manifest_sha256
|
||||
&& parent.manifest.release_id == update.predecessor.release_id
|
||||
&& parent.manifest.release_sequence == update.predecessor.release_sequence
|
||||
&& parent.manifest.artifacts[0].sha256 == update.predecessor.agent_sha256
|
||||
&& parent.manifest.artifacts[1].sha256 == update.predecessor.helper_sha256
|
||||
&& prior.platform == target.platform
|
||||
&& target.release_sequence > prior.activation_floor
|
||||
&& receipt.issued_at >= prior.activated_at,
|
||||
"UPDATE_RECORD_PREDECESSOR_OR_FLOOR"
|
||||
);
|
||||
let record = InstalledReleaseRecord {
|
||||
schema_version: 1,
|
||||
profile: "decoder_compatible_handoff_v1".into(),
|
||||
platform: target.platform,
|
||||
release_envelope: update.release_envelope.clone(),
|
||||
manifest_sha256: update.manifest_sha256.clone(),
|
||||
activation_floor: target.release_sequence,
|
||||
activated_at: receipt.issued_at,
|
||||
previous_record_sha256: Some(old_sha256.clone()),
|
||||
activation_evidence: ActivationEvidence::Updated {
|
||||
handoff_sha256: handoff_sha256.into(),
|
||||
signed_health_sha256: hash(&serde_json::to_vec(signed)?),
|
||||
},
|
||||
rolled_back: false,
|
||||
};
|
||||
let raw = record.bytes().map_err(anyhow::Error::msg)?;
|
||||
let sha256 = hash(&raw);
|
||||
ensure!(sha256 != old_sha256, "UPDATE_RECORD_SAME_BYTES");
|
||||
@@ -667,6 +641,7 @@ mod tests {
|
||||
// method, never a real release/Health/approval or a simulated target job.
|
||||
use super::*;
|
||||
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
||||
use rmm_domain::agent_update_provisioning::ActivationEvidence;
|
||||
use std::{fs, os::unix::fs::DirBuilderExt, path::PathBuf, time::Duration};
|
||||
|
||||
struct Fixture(PathBuf);
|
||||
|
||||
@@ -87,7 +87,12 @@ impl RetainedSet {
|
||||
"UPDATE_RETAINED_CODE_PATH"
|
||||
);
|
||||
let parent = spec.path.parent().context("UPDATE_RETAINED_PARENT")?;
|
||||
let directory = Directory::open(parent, spec.parent_uid, false)?;
|
||||
let directory = if parent.starts_with("/var/lib/rmm-agent-remote") {
|
||||
ensure!(spec.parent_uid == 993, "UPDATE_RETAINED_AGENT_OWNER");
|
||||
Directory::open_agent_state(parent)?
|
||||
} else {
|
||||
Directory::open(parent, spec.parent_uid, false)?
|
||||
};
|
||||
let file = std::fs::OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_CLOEXEC)
|
||||
|
||||
@@ -13,7 +13,7 @@ use rmm_domain::{agent_update::UpdateInflightProof, jobs::hash};
|
||||
use rmm_updater_linux::{
|
||||
Budget, DurableEffectFence, Effect,
|
||||
files::{Directory, Identity, LedgerIdentity},
|
||||
services::{Service, ServiceProof, Systemd},
|
||||
services::{FailedStartProof, KnownStartupFailure, Service, ServiceProof, Systemd},
|
||||
};
|
||||
use std::{
|
||||
fs::OpenOptions,
|
||||
@@ -103,7 +103,13 @@ impl<'a> Reservation<'a> {
|
||||
.updater
|
||||
.verify_delegation(self.context.original.delegation(), self.context.budget)?;
|
||||
self.context.retained.verify()?;
|
||||
self.context.files.verify_pair(self.context.budget)?;
|
||||
if self.rollback()? {
|
||||
self.context
|
||||
.files
|
||||
.verify_predecessor_pair(self.context.budget)?;
|
||||
} else {
|
||||
self.context.files.verify_pair(self.context.budget)?;
|
||||
}
|
||||
self.context
|
||||
.trust
|
||||
.recheck(self.context.original, self.context.clock)?;
|
||||
@@ -121,22 +127,31 @@ impl<'a> Reservation<'a> {
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
observed.bytes()? == h.bytes()?
|
||||
&& journal.phase() == rmm_updater_handoff::Phase::LedgerReturnIntent
|
||||
&& self.claims.return_ledger.effect() == &NativeEffect::ReturnLedger,
|
||||
&& matches!(
|
||||
journal.phase(),
|
||||
rmm_updater_handoff::Phase::LedgerReturnIntent
|
||||
| rmm_updater_handoff::Phase::RollbackLedgerReturnIntent
|
||||
)
|
||||
&& self.claims.return_ledger.effect()
|
||||
== &if self.rollback()? {
|
||||
NativeEffect::RollbackReturnLedger
|
||||
} else {
|
||||
NativeEffect::ReturnLedger
|
||||
},
|
||||
"UPDATE_RETURN_RESERVATION_BINDING"
|
||||
);
|
||||
for (index, claim) in self.claims.starts.iter().enumerate() {
|
||||
ensure!(
|
||||
claim.effect()
|
||||
== &NativeEffect::StartService {
|
||||
service: [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent
|
||||
][index]
|
||||
},
|
||||
"UPDATE_RETURN_START_ORDER"
|
||||
);
|
||||
let service = [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
][index];
|
||||
let expected = if self.rollback()? {
|
||||
NativeEffect::RollbackStartService { service }
|
||||
} else {
|
||||
NativeEffect::StartService { service }
|
||||
};
|
||||
ensure!(claim.effect() == &expected, "UPDATE_RETURN_START_ORDER");
|
||||
}
|
||||
for claim in std::iter::once(&self.claims.return_ledger).chain(self.claims.starts.iter()) {
|
||||
ensure!(
|
||||
@@ -151,6 +166,14 @@ impl<'a> Reservation<'a> {
|
||||
verify_identity_files(&self.context.ledger)?;
|
||||
Ok(())
|
||||
}
|
||||
fn rollback(&self) -> Result<bool> {
|
||||
let (_, journal) = rmm_domain::agent_update::verify_inflight_proof(
|
||||
&self.proof,
|
||||
self.context.trust.health_public_key(),
|
||||
)
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
Ok(journal.phase() == rmm_updater_handoff::Phase::RollbackLedgerReturnIntent)
|
||||
}
|
||||
/// The OS release primitive consumes its real guard, and the borrow on
|
||||
/// StoppedServices then ends. This fence never closes/unlocks another PID.
|
||||
pub fn start_fence<'b>(
|
||||
@@ -181,7 +204,7 @@ pub struct StartFence<'a, 'b> {
|
||||
pending: Option<Service>,
|
||||
poisoned: bool,
|
||||
}
|
||||
impl StartFence<'_, '_> {
|
||||
impl<'a, 'b> StartFence<'a, 'b> {
|
||||
pub fn finish(self) -> Result<()> {
|
||||
ensure!(
|
||||
!self.poisoned && self.return_checked && self.next == 3 && self.pending.is_none(),
|
||||
@@ -189,6 +212,121 @@ impl StartFence<'_, '_> {
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn early_full_failure(
|
||||
self,
|
||||
failed: &KnownStartupFailure,
|
||||
) -> Result<ConditionalStopFence<'a, 'b>> {
|
||||
failed.verify(self.reservation.context.budget)?;
|
||||
ensure!(
|
||||
self.return_checked
|
||||
&& self.next == 1
|
||||
&& self.poisoned
|
||||
&& self.pending == Some(Service::Full)
|
||||
&& failed.failure().service == Service::Full
|
||||
&& failed.started().len() == 1
|
||||
&& failed.started()[0].proof().service == Service::General,
|
||||
"UPDATE_CONDITIONAL_STOP_START_LINEAGE"
|
||||
);
|
||||
let claim = self
|
||||
.reservation
|
||||
.claims
|
||||
.conditional_rollback_stop_general()
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_CONDITIONAL_STOP_NOT_RESERVED"))?;
|
||||
ensure!(
|
||||
claim.effect() == &NativeEffect::ConditionalRollbackStopGeneral
|
||||
&& claim.grant_id() == self.reservation.context.original.permit().grant_id
|
||||
&& claim.owner_nonce() == self.reservation.context.original.handoff().owner_nonce
|
||||
&& claim.head_sha256() == self.reservation.proof.head_sha256,
|
||||
"UPDATE_CONDITIONAL_STOP_RESERVATION_CHANGED"
|
||||
);
|
||||
Ok(ConditionalStopFence {
|
||||
reservation: self.reservation,
|
||||
new: self.new,
|
||||
failure: failed.failure().clone(),
|
||||
general: failed.started()[0].proof().clone(),
|
||||
pending: false,
|
||||
finished: false,
|
||||
})
|
||||
}
|
||||
}
|
||||
/// The one precommitted exceptional stop. It cannot be constructed from JSON,
|
||||
/// reused for another service, or used after losing the original live attempt.
|
||||
pub struct ConditionalStopFence<'a, 'b> {
|
||||
reservation: Reservation<'a>,
|
||||
new: &'b Systemd,
|
||||
failure: FailedStartProof,
|
||||
general: ServiceProof,
|
||||
pending: bool,
|
||||
finished: bool,
|
||||
}
|
||||
impl ConditionalStopFence<'_, '_> {
|
||||
pub fn proof(&self) -> &UpdateInflightProof {
|
||||
self.reservation.proof()
|
||||
}
|
||||
pub fn finish(self) -> Result<()> {
|
||||
ensure!(
|
||||
self.pending && self.finished,
|
||||
"UPDATE_CONDITIONAL_STOP_INCOMPLETE"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl DurableEffectFence for ConditionalStopFence<'_, '_> {
|
||||
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
|
||||
ensure!(
|
||||
!self.pending
|
||||
&& !self.finished
|
||||
&& *effect
|
||||
== Effect::StopService {
|
||||
service: Service::General
|
||||
},
|
||||
"UPDATE_CONDITIONAL_STOP_NO_RETRY"
|
||||
);
|
||||
self.pending = true;
|
||||
self.reservation.check()?;
|
||||
verify_lock_released(&self.reservation.context.ledger)?;
|
||||
self.new
|
||||
.verify_failed_start(&self.failure, self.reservation.context.budget)?;
|
||||
self.new
|
||||
.verify_inactive(Service::Agent, self.reservation.context.budget)?;
|
||||
let held = self
|
||||
.new
|
||||
.observe(Service::General, self.reservation.context.budget)?;
|
||||
ensure!(
|
||||
*held.proof() == self.general,
|
||||
"UPDATE_CONDITIONAL_STOP_GENERAL_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
|
||||
ensure!(
|
||||
self.pending
|
||||
&& !self.finished
|
||||
&& *effect
|
||||
== Effect::StopService {
|
||||
service: Service::General
|
||||
},
|
||||
"UPDATE_CONDITIONAL_STOP_CALLBACK_CHANGED"
|
||||
);
|
||||
self.reservation.check()?;
|
||||
self.new
|
||||
.verify_failed_start(&self.failure, self.reservation.context.budget)?;
|
||||
self.new
|
||||
.verify_inactive(Service::Agent, self.reservation.context.budget)?;
|
||||
self.new
|
||||
.verify_inactive(Service::General, self.reservation.context.budget)?;
|
||||
ensure!(
|
||||
observation
|
||||
== hash(&serde_json::to_vec(&(
|
||||
"reserved_general_stop_v1",
|
||||
&self.general,
|
||||
&self.failure
|
||||
))?),
|
||||
"UPDATE_CONDITIONAL_STOP_OBSERVATION_CHANGED"
|
||||
);
|
||||
self.finished = true;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl DurableEffectFence for StartFence<'_, '_> {
|
||||
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
|
||||
|
||||
@@ -73,19 +73,98 @@ impl TrustState {
|
||||
/// EXACT ORIGINAL evidence only. The separate historical keyring below
|
||||
/// never supplies current admission, Health, Finalize or effect authority.
|
||||
pub fn load_retained(original: &Original, binding: &Binding) -> Result<Self> {
|
||||
let update = original.update();
|
||||
Self::load_inputs(
|
||||
Some(original.update()),
|
||||
binding,
|
||||
original.delegation().prepared_at,
|
||||
)
|
||||
}
|
||||
/// Explicit PRE-consumption verification. No Original/start/consumption is
|
||||
/// fabricated to reuse a retained-evidence API. Caller still needs fresh
|
||||
/// independent HelperSync admission and atomic durable handoff afterwards.
|
||||
pub fn load_prepared(
|
||||
update: &rmm_domain::agent_update::ResolvedAgentUpdate,
|
||||
binding: &Binding,
|
||||
clock: &NativeClock,
|
||||
) -> Result<Self> {
|
||||
ensure!(
|
||||
update.validate() && update.execution_identity() == Some("root"),
|
||||
"UPDATE_PREPARED_ACTION"
|
||||
);
|
||||
let state = Self::load_inputs(Some(update), binding, clock.now()?)?;
|
||||
state.recheck_prepared(update, clock)?;
|
||||
Ok(state)
|
||||
}
|
||||
pub fn load_observed(binding: &Binding, clock: &NativeClock) -> Result<Self> {
|
||||
let state = Self::load_inputs(None, binding, clock.now()?)?;
|
||||
state.recheck_observed()?;
|
||||
Ok(state)
|
||||
}
|
||||
pub fn recheck_observed(&self) -> Result<()> {
|
||||
self.recheck_protected()?;
|
||||
ensure!(
|
||||
!self.baseline_signer_revoked,
|
||||
"UPDATE_BASELINE_SIGNER_REVOKED"
|
||||
);
|
||||
verify_installed_release(
|
||||
&self.keyring,
|
||||
&self.installed,
|
||||
self.updater_binding.keyring_generation,
|
||||
)
|
||||
}
|
||||
pub fn updater_binding(&self) -> &rmm_domain::agent_update::UpdaterBinding {
|
||||
&self.updater_binding
|
||||
}
|
||||
pub fn predecessor(&self) -> &rmm_domain::agent_update::Predecessor {
|
||||
&self.predecessor
|
||||
}
|
||||
pub fn activation_floor(&self) -> u64 {
|
||||
self.installed.activation_floor
|
||||
}
|
||||
pub fn verify_candidate(
|
||||
&self,
|
||||
envelope: &rmm_domain::agent_update::ReleaseEnvelope,
|
||||
clock: &NativeClock,
|
||||
) -> Result<()> {
|
||||
self.recheck_observed()?;
|
||||
let active = self
|
||||
.installed
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
verify(
|
||||
&self.keyring,
|
||||
envelope,
|
||||
&TrustedContext {
|
||||
platform: ReleasePlatform::LinuxX64,
|
||||
now_utc_seconds: u64::try_from(clock.now()?.timestamp())?,
|
||||
keyring_generation: self.updater_binding.keyring_generation,
|
||||
protocol_major: active.manifest.protocol_major,
|
||||
state_schema: active.manifest.state_schema,
|
||||
updater_version: 1,
|
||||
minimum_release_sequence: self.installed.activation_floor,
|
||||
active_release: Some(ActiveRelease {
|
||||
sequence: active.manifest.release_sequence,
|
||||
manifest_sha256: self.installed.manifest_sha256.clone(),
|
||||
}),
|
||||
},
|
||||
)
|
||||
}
|
||||
fn load_inputs(
|
||||
update: Option<&rmm_domain::agent_update::ResolvedAgentUpdate>,
|
||||
binding: &Binding,
|
||||
prepared_at: chrono::DateTime<chrono::Utc>,
|
||||
) -> Result<Self> {
|
||||
let mut protected = Vec::new();
|
||||
let (file, raw) = Protected::read(Path::new("/etc/rmm-agent-updater/policy.json"), 65536)?;
|
||||
let (policy, policy_hash) =
|
||||
LocalUpdatePolicy::from_bytes(&raw).map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
policy_hash == update.updater.policy_sha256
|
||||
&& policy.tenant_id == binding.tenant_id
|
||||
policy.tenant_id == binding.tenant_id
|
||||
&& policy.asset_id == binding.asset_id
|
||||
&& policy.agent_id == binding.agent_id
|
||||
&& policy.enrollment_generation == binding.enrollment_generation
|
||||
&& policy.assignment_version == binding.assignment_version
|
||||
&& policy.updater_binary_sha256 == update.updater.binary_sha256,
|
||||
&& policy.assignment_version == binding.assignment_version,
|
||||
"UPDATE_PROTECTED_POLICY_CHANGED"
|
||||
);
|
||||
protected.push(file);
|
||||
@@ -97,12 +176,8 @@ impl TrustState {
|
||||
protected.push(file);
|
||||
let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?;
|
||||
let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?;
|
||||
ensure!(
|
||||
keys.validate()
|
||||
&& keys.generation == update.updater.keyring_generation
|
||||
&& hash(&raw) == update.updater.keyring_sha256,
|
||||
"UPDATE_PROTECTED_KEYRING_CHANGED"
|
||||
);
|
||||
ensure!(keys.validate(), "UPDATE_PROTECTED_KEYRING_CHANGED");
|
||||
let keyring_sha256 = hash(&raw);
|
||||
protected.push(file);
|
||||
let job_key = hex::decode(&binding.public_key_hex)?;
|
||||
let mut trusted = Vec::new();
|
||||
@@ -171,8 +246,6 @@ impl TrustState {
|
||||
let health_public_key = health.public_key().map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
!VerifyingKey::from_bytes(&health_public_key)?.is_weak()
|
||||
&& hash(&raw) == update.updater.health_key_pin_sha256
|
||||
&& hex::encode(health_public_key) == update.updater.health_public_key_hex
|
||||
&& health_public_key.as_slice() != job_key
|
||||
&& keys
|
||||
.keys
|
||||
@@ -180,17 +253,14 @@ impl TrustState {
|
||||
.all(|key| key.public_key_hex != hex::encode(health_public_key)),
|
||||
"UPDATE_HEALTH_KEY_NOT_SEPARATE_OR_CHANGED"
|
||||
);
|
||||
let health_key_pin_sha256 = hash(&raw);
|
||||
protected.push(file);
|
||||
let (file, raw) = Protected::read(Path::new(&policy.installed_record_path), 32768)?;
|
||||
ensure!(
|
||||
hash(&raw) == update.predecessor.installed_record_sha256,
|
||||
"UPDATE_INSTALLED_RECORD_CHANGED"
|
||||
);
|
||||
let installed = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
!installed.rolled_back
|
||||
&& installed.activation_floor >= policy.initial_activation_floor
|
||||
&& installed.activated_at <= original.handoff().consumed_at,
|
||||
&& installed.activated_at <= u64::try_from(prepared_at.timestamp())?,
|
||||
"UPDATE_INSTALLED_FLOOR_OR_TIME"
|
||||
);
|
||||
if matches!(
|
||||
@@ -208,37 +278,53 @@ impl TrustState {
|
||||
.release_envelope
|
||||
.decode()
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
ensure!(
|
||||
active.manifest.release_id == update.predecessor.release_id
|
||||
&& active.manifest.release_sequence == update.predecessor.release_sequence
|
||||
&& installed.manifest_sha256 == update.predecessor.manifest_sha256
|
||||
&& active.manifest.artifacts[0].sha256 == update.predecessor.agent_sha256
|
||||
&& active.manifest.artifacts[1].sha256 == update.predecessor.helper_sha256,
|
||||
"UPDATE_INSTALLED_PREDECESSOR_BINDING"
|
||||
);
|
||||
let predecessor = rmm_domain::agent_update::Predecessor {
|
||||
release_id: active.manifest.release_id,
|
||||
release_sequence: active.manifest.release_sequence,
|
||||
manifest_sha256: installed.manifest_sha256.clone(),
|
||||
installed_record_sha256: hash(&raw),
|
||||
agent_sha256: active.manifest.artifacts[0].sha256.clone(),
|
||||
helper_sha256: active.manifest.artifacts[1].sha256.clone(),
|
||||
};
|
||||
let updater_binding = rmm_domain::agent_update::UpdaterBinding {
|
||||
binary_sha256: policy.updater_binary_sha256.clone(),
|
||||
policy_sha256: policy_hash,
|
||||
keyring_generation: keys.generation,
|
||||
keyring_sha256,
|
||||
health_public_key_hex: hex::encode(health_public_key),
|
||||
health_key_pin_sha256,
|
||||
};
|
||||
if let Some(update) = update {
|
||||
ensure!(
|
||||
update.predecessor == predecessor && update.updater == updater_binding,
|
||||
"UPDATE_PROTECTED_INPUT_BINDING"
|
||||
);
|
||||
}
|
||||
verify_installed_release(&historical, &installed, keys.generation)?;
|
||||
verify(
|
||||
&historical,
|
||||
&update.release_envelope,
|
||||
&TrustedContext {
|
||||
platform: ReleasePlatform::LinuxX64,
|
||||
now_utc_seconds: u64::try_from(original.delegation().prepared_at.timestamp())?,
|
||||
keyring_generation: keys.generation,
|
||||
protocol_major: active.manifest.protocol_major,
|
||||
state_schema: active.manifest.state_schema,
|
||||
updater_version: 1,
|
||||
minimum_release_sequence: installed.activation_floor,
|
||||
active_release: Some(ActiveRelease {
|
||||
sequence: active.manifest.release_sequence,
|
||||
manifest_sha256: installed.manifest_sha256.clone(),
|
||||
}),
|
||||
},
|
||||
)?;
|
||||
if let Some(update) = update {
|
||||
verify(
|
||||
&historical,
|
||||
&update.release_envelope,
|
||||
&TrustedContext {
|
||||
platform: ReleasePlatform::LinuxX64,
|
||||
now_utc_seconds: u64::try_from(prepared_at.timestamp())?,
|
||||
keyring_generation: keys.generation,
|
||||
protocol_major: active.manifest.protocol_major,
|
||||
state_schema: active.manifest.state_schema,
|
||||
updater_version: 1,
|
||||
minimum_release_sequence: installed.activation_floor,
|
||||
active_release: Some(ActiveRelease {
|
||||
sequence: active.manifest.release_sequence,
|
||||
manifest_sha256: installed.manifest_sha256.clone(),
|
||||
}),
|
||||
},
|
||||
)?;
|
||||
}
|
||||
protected.push(file);
|
||||
let baseline_signer_revoked = baseline_entry.revoked;
|
||||
Ok(Self {
|
||||
updater_binding: update.updater.clone(),
|
||||
predecessor: update.predecessor.clone(),
|
||||
updater_binding,
|
||||
predecessor,
|
||||
protected,
|
||||
policy,
|
||||
installed,
|
||||
@@ -255,6 +341,25 @@ impl TrustState {
|
||||
self.recheck_crypto(original, clock)
|
||||
}
|
||||
fn recheck_crypto(&self, original: &Original, clock: &NativeClock) -> Result<()> {
|
||||
self.recheck_crypto_inputs(original.update(), clock)
|
||||
}
|
||||
pub fn recheck_prepared(
|
||||
&self,
|
||||
update: &rmm_domain::agent_update::ResolvedAgentUpdate,
|
||||
clock: &NativeClock,
|
||||
) -> Result<()> {
|
||||
ensure!(
|
||||
update.updater == self.updater_binding && update.predecessor == self.predecessor,
|
||||
"UPDATE_PREPARED_CONTEXT_CHANGED"
|
||||
);
|
||||
self.recheck_protected()?;
|
||||
self.recheck_crypto_inputs(update, clock)
|
||||
}
|
||||
fn recheck_crypto_inputs(
|
||||
&self,
|
||||
update: &rmm_domain::agent_update::ResolvedAgentUpdate,
|
||||
clock: &NativeClock,
|
||||
) -> Result<()> {
|
||||
ensure!(
|
||||
!self.baseline_signer_revoked,
|
||||
"UPDATE_BASELINE_SIGNER_REVOKED"
|
||||
@@ -262,7 +367,7 @@ impl TrustState {
|
||||
verify_installed_release(
|
||||
&self.keyring,
|
||||
&self.installed,
|
||||
original.update().updater.keyring_generation,
|
||||
update.updater.keyring_generation,
|
||||
)?;
|
||||
let active = self
|
||||
.installed
|
||||
@@ -271,11 +376,11 @@ impl TrustState {
|
||||
.map_err(anyhow::Error::msg)?;
|
||||
verify(
|
||||
&self.keyring,
|
||||
&original.update().release_envelope,
|
||||
&update.release_envelope,
|
||||
&TrustedContext {
|
||||
platform: ReleasePlatform::LinuxX64,
|
||||
now_utc_seconds: u64::try_from(clock.now()?.timestamp())?,
|
||||
keyring_generation: original.update().updater.keyring_generation,
|
||||
keyring_generation: update.updater.keyring_generation,
|
||||
protocol_major: active.manifest.protocol_major,
|
||||
state_schema: active.manifest.state_schema,
|
||||
updater_version: 1,
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
[Unit]
|
||||
Description=RMM stable updater for individually approved original code-pair jobs
|
||||
After=time-sync.target
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=root
|
||||
Group=root
|
||||
UMask=0077
|
||||
RuntimeDirectory=rmm-agent-updater
|
||||
RuntimeDirectoryMode=0700
|
||||
ExecStart=/usr/local/libexec/rmm-agent-updater --serve
|
||||
# An ambiguous handoff must be inspected, never automatically resumed by a
|
||||
# replacement updater process. A successful pass reloads its new record in the
|
||||
# same still-authenticated process for the next independently approved job.
|
||||
Restart=no
|
||||
NoNewPrivileges=yes
|
||||
PrivateTmp=yes
|
||||
PrivateNetwork=yes
|
||||
ProtectHome=yes
|
||||
ProtectSystem=strict
|
||||
ReadWritePaths=/usr/local/libexec /etc/rmm-remote /var/lib/rmm-agent-updater /var/lib/rmm-helper /var/lib/rmm-agent-remote
|
||||
RestrictAddressFamilies=AF_UNIX
|
||||
KillMode=control-group
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -0,0 +1,225 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Read-only prerequisite snapshot for preserving Linux updater bootstrap.
|
||||
|
||||
No apply/start/stop/reenroll/package/policy operation is implemented here.
|
||||
Credentials use the existing strict parser and independently pinned SSH host.
|
||||
Private keys are stat'ed only; no private key or environment bytes are read.
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import uuid
|
||||
import remote_client_bootstrap as transport
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
|
||||
def inspect_vm(payload):
|
||||
import contextlib
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import sqlite3
|
||||
import stat
|
||||
import subprocess
|
||||
import time
|
||||
import uuid
|
||||
require(payload=={'operation':'linux_updater_bootstrap_inspect_v1'} and os.geteuid()==0
|
||||
and os.uname().machine=='x86_64','fixed read-only Linux target')
|
||||
def digest(raw):return hashlib.sha256(raw).hexdigest()
|
||||
def encode(value):return json.dumps(value,separators=(',',':'),ensure_ascii=False).encode()
|
||||
def identity(s):return dict(device=s.st_dev,inode=s.st_ino,uid=s.st_uid,gid=s.st_gid,mode=s.st_mode,links=s.st_nlink)
|
||||
def metadata(path):
|
||||
path=Path(path)
|
||||
try:s=path.lstat()
|
||||
except FileNotFoundError:return None
|
||||
require(not stat.S_ISLNK(s.st_mode),'no metadata symlink')
|
||||
return dict(identity=identity(s),bytes=s.st_size)
|
||||
def public(path,limit=65536):
|
||||
path=Path(path);s=path.lstat()
|
||||
require(stat.S_ISREG(s.st_mode) and s.st_uid==0 and s.st_nlink==1
|
||||
and not s.st_mode&0o022 and s.st_size<=limit,'bounded protected public input')
|
||||
with path.open('rb') as stream:raw=stream.read(limit+1)
|
||||
after=path.lstat()
|
||||
require(len(raw)==s.st_size and identity(after)==identity(s) and after.st_size==s.st_size
|
||||
and after.st_mtime_ns==s.st_mtime_ns and after.st_ctime_ns==s.st_ctime_ns,'stable public input')
|
||||
return raw
|
||||
def proof(path):
|
||||
raw=public(path,256*1024*1024);s=Path(path).lstat()
|
||||
return dict(identity=identity(s),bytes=len(raw),sha256=digest(raw))
|
||||
def run(args):
|
||||
result=subprocess.run(args,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,
|
||||
timeout=10,env={'PATH':'/usr/bin:/bin','LC_ALL':'C'})
|
||||
require(result.returncode in (0,1) and len(result.stdout)<=65536,'bounded read-only systemd response')
|
||||
return result.stdout.decode()
|
||||
services=('rmm-agent-remote.service','rmm-helper-cloud.service','rmm-full-maintenance-helper.service',
|
||||
'rmm-agent-updater.service','rmm-apt-helper.service','rmm-agent.service','rmm-helper-dev-test.service')
|
||||
names=list(services)
|
||||
for name in services:
|
||||
names.extend((name[:-8]+'.socket',name[:-8]+'.timer'))
|
||||
timers=run(['systemctl','list-units','--all','--no-legend','--plain','--no-pager','rmm-general-startup-rollback-*.timer'])
|
||||
rollback_names=[]
|
||||
for line in timers.splitlines():
|
||||
name=line.split()[0]
|
||||
require(name.startswith('rmm-general-startup-rollback-') and name.endswith('.timer'),'fixed rollback timer')
|
||||
uuid.UUID(name[len('rmm-general-startup-rollback-'):-len('.timer')])
|
||||
rollback_names.append(name)
|
||||
names.extend(sorted(rollback_names))
|
||||
properties=['Id','LoadState','ActiveState','SubState','MainPID','ControlPID','InvocationID','UnitFileState',
|
||||
'FragmentPath','DropInPaths','Triggers','TriggeredBy','Job','ControlGroup']
|
||||
units={}
|
||||
for name in names:
|
||||
output=run(['systemctl','show','--all','--property='+','.join(properties),'--',name])
|
||||
fields={}
|
||||
for line in output.splitlines():
|
||||
key,value=line.split('=',1);require(key in properties and key not in fields,'exact service properties')
|
||||
fields[key]=value
|
||||
require(fields.get('Id')==name,'exact queried unit')
|
||||
composition=[]
|
||||
if fields.get('LoadState')=='loaded':
|
||||
paths=[fields['FragmentPath']]+fields.get('DropInPaths','').split()
|
||||
for path in paths:composition.append((path,proof(path)))
|
||||
units[name]=dict(status=fields,composition=composition,unit_sha256=digest(encode(composition)))
|
||||
binaries={}
|
||||
for path in ('/usr/local/libexec/rmm-agent-remote','/usr/local/libexec/rmm-privileged-helper','/usr/local/libexec/rmm-agent-updater'):
|
||||
binaries[path]=proof(path) if Path(path).exists() else None
|
||||
configs={}
|
||||
for name in ('helper-general.json','helper-full-maintenance.json'):
|
||||
path=Path('/etc/rmm-remote')/name
|
||||
if not path.exists():configs[name]=None;continue
|
||||
raw=public(path);value=json.loads(raw)
|
||||
configs[name]=dict(sha256=digest(raw),fields={key:value.get(key) for key in (
|
||||
'profile','agent_uid','socket_gid','socket','state','signing_key_file','allow_reboot','allow_root_scripts',
|
||||
'allowed_script_profiles','helper_binary_sha256')},binding={key:value['binding'][key] for key in (
|
||||
'tenant_id','asset_id','agent_id','enrollment_generation','assignment_version')})
|
||||
public_pins={}
|
||||
for name in ('general-helper-proof.json','full-maintenance-helper-proof.json','helper-signing-key.json'):
|
||||
path=Path('/etc/rmm-remote')/name
|
||||
public_pins[name]=proof(path) if path.exists() else None
|
||||
state_paths=[
|
||||
'/var/lib/rmm-agent-remote','/var/lib/rmm-agent-remote/journal.sqlite',
|
||||
'/var/lib/rmm-agent-remote/consumption.sqlite','/var/lib/rmm-agent-remote/agent.lock',
|
||||
'/var/lib/rmm-agent-remote/binding.json','/var/lib/rmm-agent-remote/identity.json',
|
||||
'/var/lib/rmm-agent-remote/job-signing-key.json','/var/lib/rmm-agent-remote/device.key',
|
||||
'/var/lib/rmm-agent-remote/device.pem','/var/lib/rmm-agent-remote/certificates',
|
||||
'/var/lib/rmm-helper','/var/lib/rmm-helper/consumption.sqlite','/var/lib/rmm-helper/executor.lock',
|
||||
'/etc/rmm-agent-updater','/var/lib/rmm-agent-updater','/etc/rmm-remote/agent.env']
|
||||
selector=Path('/var/lib/rmm-agent-remote/certificates/current.json')
|
||||
if selector.exists():
|
||||
# Public selector only; active private key is metadata-only below.
|
||||
s=selector.lstat();require(stat.S_ISREG(s.st_mode) and s.st_size<=4096,'public TLS selector')
|
||||
current=json.loads(selector.read_bytes());version=str(uuid.UUID(current['version']))
|
||||
state_paths.extend((str(selector),str(selector.parent/'versions'/version),
|
||||
str(selector.parent/'versions'/version/'device.key'),str(selector.parent/'versions'/version/'device.pem')))
|
||||
state={path:metadata(path) for path in state_paths}
|
||||
databases={}
|
||||
for path in ('/var/lib/rmm-agent-remote/journal.sqlite','/var/lib/rmm-agent-remote/consumption.sqlite','/var/lib/rmm-helper/consumption.sqlite'):
|
||||
require(not Path(path+'-wal').exists() and not Path(path+'-shm').exists(),'existing DELETE journals required')
|
||||
with contextlib.closing(sqlite3.connect('file:'+path+'?mode=ro',uri=True,timeout=2)) as db:
|
||||
db.execute('PRAGMA query_only=ON')
|
||||
require(db.execute('PRAGMA journal_mode').fetchone()[0]=='delete','read-only DELETE journal')
|
||||
tables={row[0] for row in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
|
||||
counts={name:db.execute('SELECT count(*) FROM '+name).fetchone()[0] for name in (
|
||||
'consumed','execution_evidence','helper_sync_decisions','job_attempts','reconcile_decisions') if name in tables}
|
||||
unresolved={}
|
||||
if 'consumed' in tables:unresolved['consumed']=db.execute('SELECT count(*) FROM consumed WHERE result IS NULL').fetchone()[0]
|
||||
if 'job_attempts' in tables:unresolved['job_attempts']=db.execute("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')").fetchone()[0]
|
||||
faults={name:db.execute('SELECT count(*) FROM '+name+' WHERE fault IS NOT NULL').fetchone()[0]
|
||||
for name in ('helper_sync_meta','reconcile_meta') if name in tables}
|
||||
# Hash original evidence bytes inside the target; no stdout/script
|
||||
# body or reconciliation request/signature is exported.
|
||||
evidence=[]
|
||||
if 'execution_evidence' in tables:
|
||||
columns={r[1] for r in db.execute('PRAGMA table_info(execution_evidence)')}
|
||||
for grant,start,outcome in db.execute('SELECT grant_id,start,outcome FROM execution_evidence'):
|
||||
evidence.append(dict(grant_id=grant,start_sha256=digest(start),outcome_sha256=None if outcome is None else digest(outcome)))
|
||||
databases[path]=dict(counts=counts,unresolved=unresolved,faults=faults,
|
||||
evidence_sha256=digest(encode(sorted(evidence,key=lambda r:r['grant_id']))),
|
||||
integrity=db.execute('PRAGMA integrity_check').fetchone()[0])
|
||||
require(not Path(path+'-wal').exists() and not Path(path+'-shm').exists(),'no SQLite sidecars introduced')
|
||||
host={}
|
||||
for label,path in (('proc','/proc'),('user_namespace','/proc/1/ns/user'),('pid_namespace','/proc/1/ns/pid'),('cgroup_namespace','/proc/1/ns/cgroup')):
|
||||
s=Path(path).stat();host[label+'_device']=s.st_dev;host[label+'_inode']=s.st_ino
|
||||
return dict(schema_version=1,operation=payload['operation'],read_only=True,utc_seconds=int(time.time()),
|
||||
boot_id=Path('/proc/sys/kernel/random/boot_id').read_text().strip(),units=units,binaries=binaries,
|
||||
configs=configs,public_pins=public_pins,state=state,databases=databases,host_context=host,
|
||||
rollback_timers=rollback_names,updater_provisioned=Path('/etc/rmm-agent-updater/policy.json').exists())
|
||||
|
||||
def prepare(snapshot_path,agent,helper,updater,qualification):
|
||||
import stat
|
||||
def require(ok,code):
|
||||
if not ok:raise RuntimeError(code)
|
||||
def input_file(path,limit):
|
||||
path=Path(path);meta=path.lstat()
|
||||
require(stat.S_ISREG(meta.st_mode) and not path.is_symlink() and meta.st_nlink==1
|
||||
and meta.st_uid==os.getuid() and not meta.st_mode&0o022 and 0<meta.st_size<=limit,
|
||||
'bounded owned preparation input')
|
||||
raw=path.read_bytes()
|
||||
require(len(raw)==meta.st_size,'stable preparation input size')
|
||||
return raw
|
||||
snapshot_raw=input_file(snapshot_path,1024*1024);snapshot=json.loads(snapshot_raw)
|
||||
require(snapshot['operation']=='linux_updater_bootstrap_inspect_v1' and snapshot['read_only'] is True
|
||||
and snapshot['updater_provisioned'] is False,'actual unprovisioned read-only snapshot')
|
||||
require(all(not any(db['unresolved'].values()) and not any(db['faults'].values())
|
||||
and db['integrity']=='ok' for db in snapshot['databases'].values()),'closed preserved original state')
|
||||
receipt=input_file(qualification,1024*1024)
|
||||
folder=ROOT/'devstate/linux-updater-bootstrap'/str(uuid.uuid4());folder.mkdir(mode=0o700,parents=True)
|
||||
artifacts={}
|
||||
for label,path in (('agent',agent),('helper',helper),('updater',updater)):
|
||||
raw=input_file(path,256*1024*1024)
|
||||
require(raw[:6]==b'\x7fELF\x02\x01' and raw[18:20]==b'\x3e\x00','Linux x86-64 ELF only')
|
||||
target=folder/(label+'.bin')
|
||||
fd=os.open(target,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
||||
artifacts[label]=dict(file=target.name,bytes=len(raw),sha256=hashlib.sha256(raw).hexdigest())
|
||||
manifest=dict(schema_version=1,profile='linux_updater_compatible_bootstrap_preparation_v1',
|
||||
target='116.203.20.85',server='discovery.ease-technologies.de',boot_id=snapshot['boot_id'],
|
||||
snapshot_sha256=hashlib.sha256(snapshot_raw).hexdigest(),
|
||||
provided_qualification_document_sha256=hashlib.sha256(receipt).hexdigest(),
|
||||
artifacts=artifacts,updater_unit_sha256=hashlib.sha256((ROOT/'deploy/linux/rmm-agent-updater.service').read_bytes()).hexdigest(),
|
||||
bootstrap_installed=False,apply_executed=False,keys_generated=False,
|
||||
original_evidence={path:dict(identity=snapshot['state'][path]['identity'],**value)
|
||||
for path,value in snapshot['databases'].items()},
|
||||
phases=['fresh_exact_read_only_CAS','close_central_test_scope_without_approval',
|
||||
'stop_Agent_General_Full_only','hold_same_root_and_agent_locks',
|
||||
'retain_original_DB_PKI_identity_and_history','install_compatible_baseline_images_and_Full_pins',
|
||||
'start_General_Full_Agent_once_and_verify_signed_sync',
|
||||
'record_actual_compatible_baseline_qualification','provision_separate_public_trust_and_stable_updater',
|
||||
'bind_actual_unit_inode_registry_then_signed_baseline_and_local_policy',
|
||||
'start_updater_once_and_verify_passive_full_observer',
|
||||
'publish_distinct_signed_candidate','MCP_pending_plan_then_actual_WebUI_approval',
|
||||
'verify_original_once_only_Apply_and_independent_health'],
|
||||
notes=['Preparation performs no target mutation and grants no RMM job authority.',
|
||||
'Qualification document hash is provenance only; root must review actual contents.',
|
||||
'Baseline is compatible newly installed source; old currently installed binaries are historical backup only.',
|
||||
'All actual file IDs/merged-unit hashes and registry are recaptured after installation.',
|
||||
'APT remains inactive/disabled with old proof/config/history; no APT enable, package operation or reboot.'])
|
||||
for name,raw in (('snapshot.json',snapshot_raw),('qualification.json',receipt),
|
||||
('manifest.json',json.dumps(manifest,sort_keys=True,indent=2).encode()+b'\n')):
|
||||
fd=os.open(folder/name,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
||||
fd=os.open(folder,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW)
|
||||
try:os.fsync(fd)
|
||||
finally:os.close(fd)
|
||||
return folder
|
||||
|
||||
def main():
|
||||
parser=argparse.ArgumentParser(description=__doc__)
|
||||
commands=parser.add_subparsers(dest='operation',required=True)
|
||||
commands.add_parser('inspect')
|
||||
package=commands.add_parser('prepare')
|
||||
for name in ('snapshot','agent','helper','updater','qualification'):package.add_argument('--'+name,required=True,type=Path)
|
||||
args=parser.parse_args()
|
||||
if args.operation=='prepare':
|
||||
folder=prepare(args.snapshot,args.agent,args.helper,args.updater,args.qualification)
|
||||
print(json.dumps(dict(package=str(folder),target_mutations=False)))
|
||||
return
|
||||
result=transport.rpc('linux-vm.conf',inspect_vm,{'operation':'linux_updater_bootstrap_inspect_v1'})
|
||||
folder=ROOT/'devstate/linux-updater-bootstrap'/str(uuid.uuid4());folder.mkdir(mode=0o700,parents=True)
|
||||
target=folder/'read-only.json'
|
||||
fd=os.open(target,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'w') as output:json.dump(result,output,sort_keys=True,indent=2);output.write('\n')
|
||||
print(json.dumps(dict(report=str(target),read_only=True,boot_id=result['boot_id'],
|
||||
updater_provisioned=result['updater_provisioned'],databases=result['databases'])))
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Seal the read-only/bootstrap public metadata SDK; no target operations."""
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import uuid
|
||||
import linux_updater_qualification as q
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
def main():
|
||||
os.umask(0o077);folder=ROOT/'devstate/linux-updater-bootstrap-sdk'/str(uuid.uuid4());folder.mkdir(mode=0o700,parents=True)
|
||||
names=q.public_files();before=q.capture(ROOT,names);source=folder/'source';source.mkdir(mode=0o700)
|
||||
for name in names:q.write(source/name,(ROOT/name).read_bytes())
|
||||
assert q.capture(source,names)==before and q.capture(ROOT,names)==before and q.public_files()==names,'SDK source drift'
|
||||
q.readonly(source);q.write(folder/'inputs.json',q.encode(before))
|
||||
cache=ROOT/'devstate/updater-integration-target'
|
||||
q.run(folder,source,cache,'sdk-clippy',['cargo','clippy','--locked','--offline','--jobs','2','-p','rmm-updater-worker','--all-targets','--','-D','warnings'])
|
||||
q.run(folder,source,cache,'sdk-release',['cargo','build','--locked','--offline','--jobs','2','--release','-p','rmm-updater-worker','--example','linux_updater_bootstrap'])
|
||||
assert q.capture(source,names)==before
|
||||
binary=q.copy_artifact(cache/'release/examples/linux_updater_bootstrap',folder/'sdk.bin')
|
||||
manifest={'schema_version':1,'profile':'linux_updater_bootstrap_metadata_sdk_v1','builder':q.BUILDER,'inputs_sha256':q.sha((folder/'inputs.json').read_bytes()),'source_files_count':len(names),'binary':binary,'clippy_all_targets_passed':True,'release_built':True,'native_vm_executed':False,'target_mutated':False,'baseline_runtime_binaries_unchanged':True,'windows_copied_only_not_qualified':True}
|
||||
q.write(folder/'manifest.json',q.encode(manifest));print(json.dumps({'manifest':str(folder/'manifest.json'),'manifest_sha256':q.sha((folder/'manifest.json').read_bytes()),'binary':binary}))
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,68 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Derive only qualified-observer capability markers from the original Linux pack.
|
||||
|
||||
Original sources/artifacts/units/cache are never modified. Only agent programs
|
||||
are rebuilt. Helper/updater/native contract executables remain exact originals.
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import uuid
|
||||
import linux_updater_qualification as q
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
BASE=ROOT/'devstate/linux-updater-qualification/21d20391-6102-4996-8a7a-efbd3e78bd7d'
|
||||
BASE_MANIFEST='9ed5f153fe76665150aaab298c4b21d74d7199b2312a28fa23aa9e30b13ddd08'
|
||||
MODULE='crates/agent/src/agent_update_apply.rs'
|
||||
MAIN='crates/agent/src/main.rs'
|
||||
|
||||
def main():
|
||||
os.umask(0o077)
|
||||
assert q.sha((BASE/'manifest.json').read_bytes())==BASE_MANIFEST
|
||||
old=json.loads((BASE/'manifest.json').read_text());case=ROOT/'devstate/linux-updater-capability-build'/str(uuid.uuid4());case.mkdir(mode=0o700,parents=True)
|
||||
fixed=(ROOT/MODULE).read_bytes();old_module=(BASE/'source0'/MODULE).read_bytes()
|
||||
# Closed byte transformation only, including the normal formatter's import wrap.
|
||||
source=old_module.decode().replace('agent_update::{ArtifactDescriptor, ArtifactRole, Platform},','agent_update::{\n APPLY_CAPABILITY, ArtifactDescriptor, ArtifactRole, CHECK_CAPABILITY, Platform,\n },')
|
||||
source=source.replace(' vec![\n "update_agent".into(),',' vec![\n APPLY_CAPABILITY.into(),\n CHECK_CAPABILITY.into(),\n "update_agent".into(),')
|
||||
assert source.encode()==fixed,'exact minimal agent capability transformation required'
|
||||
main=(ROOT/MAIN).read_bytes();old_main=(BASE/'source0'/MAIN).read_text()
|
||||
block=''' // Planning pins must be refreshed before the 90-second stored-data
|
||||
// planning limit. One inflight blocking collector bounds pressure;
|
||||
// heartbeats never perform this metadata work.
|
||||
if update_at.elapsed() >= Duration::from_secs(60) {
|
||||
self.queue_update_observation(generation)?;
|
||||
update_at = Instant::now();
|
||||
}
|
||||
'''
|
||||
needle=' if !busy && capability_at.elapsed()>=Duration::from_secs(60) {capability_at=Instant::now();if self.capabilities()!=advertised{return Ok(());}}'
|
||||
assert old_main.count(block)==1 and old_main.count(needle)==1
|
||||
moved='\n'.join(' '+line if line else line for line in block.splitlines())+'\n'
|
||||
assert old_main.replace(block,'').replace(needle,moved+needle).encode()==main,'exact existing observer poll move before capability check required'
|
||||
q.write(case/'entered.json',q.encode({'base_manifest_sha256':BASE_MANIFEST,'module_sha256':q.sha(fixed),'main_sha256':q.sha(main),'no_target_mutations':True,'original_case_unchanged':True}))
|
||||
cache=case/'cache';cache.mkdir(mode=0o700)
|
||||
# Copy, never hardlink: compiler output cannot change the original cache.
|
||||
shutil.copytree(BASE/'cache/release',cache/'release')
|
||||
artifacts={};input_hashes={}
|
||||
for version in ('source0','source1'):
|
||||
expected=json.loads((BASE/(version+'-inputs.json')).read_text());names=sorted(expected)
|
||||
assert q.capture(BASE/version,names)==expected
|
||||
target=case/version;shutil.copytree(BASE/version,target)
|
||||
module=target/MODULE;module.chmod(0o600);assert module.read_bytes()==old_module;module.write_bytes(fixed);module.chmod(0o444)
|
||||
entry=target/MAIN;entry.chmod(0o600);assert entry.read_bytes()==old_main.encode();entry.write_bytes(main);entry.chmod(0o444)
|
||||
actual=q.capture(target,names);assert {n for n in names if actual[n]!=expected[n]}=={MODULE,MAIN}
|
||||
q.readonly(target);q.write(case/(version+'-inputs.json'),q.encode(actual));input_hashes[version]=q.sha((case/(version+'-inputs.json')).read_bytes())
|
||||
q.run(case,target,cache,version+'-clippy',['cargo','clippy','--locked','--offline','--release','--jobs','2','-p','rmm-agent','--all-targets','--','-D','warnings'])
|
||||
q.run(case,target,cache,version+'-agent-release',['cargo','build','--locked','--offline','--release','--jobs','2','-p','rmm-agent','--bin','rmm-agent'])
|
||||
output=case/'artifacts'/version;output.mkdir(mode=0o700,parents=True)
|
||||
agent=q.copy_artifact(cache/'release/rmm-agent',output/'rmm-agent');assert agent['sha256']!=old['artifacts'][version]['agent']['sha256']
|
||||
artifacts[version]={**old['artifacts'][version],'agent':agent}
|
||||
assert q.capture(target,names)==actual
|
||||
assert artifacts['source0']['agent']['sha256']!=artifacts['source1']['agent']['sha256']
|
||||
for label,item in [('helper0',old['artifacts']['source0']['helper']),('helper1',old['artifacts']['source1']['helper']),('updater',old['stable_updater'])]:
|
||||
assert q.sha(Path(item['path']).read_bytes())==item['sha256'],label
|
||||
for unit in old['units'].values():assert q.sha(Path(unit['path']).read_bytes())==unit['sha256']
|
||||
manifest={'schema_version':1,'profile':'linux_compatible_updater_capability_derivative_v2','base_manifest_sha256':BASE_MANIFEST,'base_manifest':str(BASE/'manifest.json'),'changed_modules':{MODULE:q.sha(fixed),MAIN:q.sha(main)},'poll_harvest_before_capability_check':True,'sampler_frequency_unchanged':True,'source0_version':'0.1.0','source1_version':'0.1.1','source_input_hashes':input_hashes,'builder':q.BUILDER,'artifacts':artifacts,'stable_updater':old['stable_updater'],'units':old['units'],'old_sources_artifacts_units_unchanged':True,'only_agents_rebuilt':True,'source0_and_source1_clippy_passed':True,'native_vm_tested':False,'actual_qualified_capability_still_requires_native_baseline':True,'bootstrap_installed':False,'apply_executed':False}
|
||||
q.write(case/'manifest.json',q.encode(manifest));q.write(case/'completed.json',q.encode({'manifest_sha256':q.sha((case/'manifest.json').read_bytes())}))
|
||||
print(json.dumps({'case':str(case),'manifest_sha256':q.sha((case/'manifest.json').read_bytes()),'artifacts':artifacts}))
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,375 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Guarded compatible Linux bootstrap, explicitly coordinated separate phases.
|
||||
|
||||
No job approval, package operation, reenrollment or private-key transfer. This
|
||||
controller is prepared source; invoking mutations requires Root coordination.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import hashlib
|
||||
import inspect
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shlex
|
||||
import subprocess
|
||||
import tarfile
|
||||
import uuid
|
||||
import linux_updater_bootstrap as prerequisite
|
||||
import remote_client_bootstrap as transport
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
BASE=ROOT/'devstate/linux-updater-capability-build/9923a97f-4c8c-4e0a-bbad-4f1d88f0d43a/manifest.json'
|
||||
BASE_SHA='a41ad700b4b7527bf911bf00f2745914188760c631af0c3255364c05f1ef4fbc'
|
||||
BOOT='45aba743-be1d-4ae5-ba00-139fb9363bfe'
|
||||
|
||||
def sha(raw):return hashlib.sha256(raw).hexdigest()
|
||||
def once(path,raw):
|
||||
path.parent.mkdir(mode=0o700,parents=True,exist_ok=True)
|
||||
with path.open('xb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
||||
path.chmod(0o600)
|
||||
def native_rpc(function,payload,config='linux-vm.conf',timeout=80):
|
||||
# Same strict credential parser and already-confirmed host as existing tooling.
|
||||
cfg=transport.access.load_config(ROOT/'credentials'/config)
|
||||
code='import json,os,subprocess\nfrom pathlib import Path\n'+inspect.getsource(transport.require)+'\n'+inspect.getsource(function)+'\ntry:\n print(json.dumps('+function.__name__+'('+repr(payload)+')))\nexcept Exception as error:\n import traceback\n print(json.dumps({"error_class":type(error).__name__,"frames":[{"function":f.name,"line":f.lineno}for f in traceback.extract_tb(error.__traceback__)]}))\n'
|
||||
ssh=['ssh','-F','/dev/null','-T','-p',cfg.get('port','22'),'-o','StrictHostKeyChecking=yes','-o','BatchMode=yes','-o','IdentitiesOnly=yes','-o','ForwardAgent=no','-o','ClearAllForwardings=yes','-o','ConnectTimeout=7','-i',str(Path(cfg['ssh_key_path']).expanduser()),cfg['username']+'@'+cfg['address'],'python3 -I -']
|
||||
result=subprocess.run(ssh,input=code.encode(),capture_output=True,timeout=timeout)
|
||||
if result.returncode:raise RuntimeError('Bootstrap transport failed; no private diagnostics printed')
|
||||
value=json.loads(result.stdout)
|
||||
if 'error_class'in value:raise RuntimeError('Bootstrap incomplete; retained native intent needs inspection: '+json.dumps(value))
|
||||
return value
|
||||
|
||||
def public_inputs(payload):
|
||||
import stat,json,hashlib,os
|
||||
from pathlib import Path
|
||||
require(payload=={'operation':'linux_compatible_public_inputs_v1'}and os.geteuid()==0,'fixed public inputs')
|
||||
result={}
|
||||
for name in ('helper-general.json','general-helper-proof.json','helper-full-maintenance.json','full-maintenance-helper-proof.json','helper-signing-key.json'):
|
||||
path=Path('/etc/rmm-remote')/name;meta=path.lstat();require(stat.S_ISREG(meta.st_mode)and meta.st_uid==0 and meta.st_nlink==1 and not meta.st_mode&0o022 and meta.st_size<=16384,'protected public input')
|
||||
raw=path.read_bytes();require(path.lstat().st_ino==meta.st_ino and path.lstat().st_mtime_ns==meta.st_mtime_ns,'public input changed');result[name]={'bytes':list(raw),'sha256':hashlib.sha256(raw).hexdigest()}
|
||||
general=json.loads(bytes(result['helper-general.json']['bytes']));pin=json.loads(bytes(result['general-helper-proof.json']['bytes']))
|
||||
require(general['profile']=='general'and general.get('helper_binary_sha256')is None and pin['schema_version']==1 and pin['profile']=='general'and pin.get('helper_binary_sha256')is None,'exact non-binary General identity/policy profile')
|
||||
return result
|
||||
|
||||
def central_closed(payload):
|
||||
import json,subprocess,datetime,uuid,hashlib
|
||||
from pathlib import Path
|
||||
agent=str(uuid.UUID(payload['agent_id']));tenant=str(uuid.UUID(payload['tenant_id']))
|
||||
def run(a):return subprocess.check_output(a,text=True,stderr=subprocess.DEVNULL,timeout=15)
|
||||
flags={}
|
||||
for role in ('api','gateway'):
|
||||
container=json.loads(run(['docker','inspect','rust-discovery-server-'+role+'-1']))[0];env=dict(row.split('=',1)for row in container['Config']['Env']);flag=env.get('RMM_DEV_ROOT_ENABLED','false')
|
||||
require(flag in ('true','false'),'known Root gate')
|
||||
expired=False
|
||||
if flag=='true':
|
||||
path=env.get('RMM_DEV_ROOT_POLICY_FILE');require(path=='/root-policy/policy.json','fixed public Root policy')
|
||||
mount=next(m for m in container['Mounts']if m['Destination']=='/root-policy');require(mount['RW']is False,'readonly protected policy')
|
||||
doc=json.loads((Path(mount['Source'])/'policy.json').read_text());expiry=datetime.datetime.fromisoformat(doc['expires_at'].replace('Z','+00:00'));require(expiry.tzinfo is not None,'absolute policy expiry');expired=expiry<=datetime.datetime.now(datetime.timezone.utc)
|
||||
require(flag=='false'or expired,'central Root scope must be closed before compatible bootstrap')
|
||||
require('RMM_AGENT_UPDATE_POLICY_FILE'not in env,'initial updater scope must remain absent')
|
||||
flags[role]={'root_enabled':flag=='true','root_policy_expired':expired,'container_id':container['Id']}
|
||||
query="BEGIN READ ONLY; SELECT count(*) FROM jobs WHERE tenant_id='"+tenant+"' AND agent_id='"+agent+"' AND state NOT IN ('succeeded','failed','cancelled','expired'); COMMIT;"
|
||||
rows=run(['docker','exec','rust-discovery-server-postgres-1','psql','-XqAt','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm','-c',query]).splitlines();require(rows==['0'],'no open or unknown Linux job')
|
||||
return {'operation':'linux_compatible_closed_scope_v1','tenant_id':tenant,'agent_id':agent,'observed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'roles':flags,'open_jobs':0,'job_authority':False}
|
||||
|
||||
def passive_check(payload):
|
||||
import datetime,json,subprocess,uuid
|
||||
tenant=str(uuid.UUID(payload['tenant_id']));agent=str(uuid.UUID(payload['agent_id']))
|
||||
query="BEGIN READ ONLY; SELECT json_build_object('connection_generation',i.connection_generation,'capabilities',i.capabilities,'last_contact_at',i.last_contact_at,'observed_at',o.observed_at,'received_at',o.received_at,'data',o.data,'payload_sha256',o.payload_sha256) FROM agent_installations i JOIN LATERAL (SELECT * FROM observations WHERE tenant_id=i.tenant_id AND agent_id=i.agent_id AND source_id='agent.update' ORDER BY sequence DESC LIMIT 1)o ON true WHERE i.tenant_id='"+tenant+"' AND i.agent_id='"+agent+"' AND i.revoked_at IS NULL; COMMIT;"
|
||||
output=subprocess.check_output(['docker','exec','rust-discovery-server-postgres-1','psql','-XqAt','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm','-c',query],stderr=subprocess.DEVNULL,text=True,timeout=15).splitlines();require(len(output)==1,'one actual current installation/passive observation')
|
||||
observed=json.loads(output[0]);sample=observed['data']['agent_update'];now=datetime.datetime.now(datetime.timezone.utc)
|
||||
for text in (observed['last_contact_at'],observed['received_at'],sample['observed_at']):
|
||||
age=(now-datetime.datetime.fromisoformat(text.replace('Z','+00:00'))).total_seconds();require(0<=age<90,'fresh actual persisted passive evidence')
|
||||
require(sample['quality']=='valid'and sample['platform']=='x86_64-unknown-linux-gnu'and sample['activation_floor']==1 and not sample['rolled_back']and sample['helper_observation_sha256']and sample['signed_sync_decision_id'],'actual Full verified passive baseline')
|
||||
require(sample['predecessor']['installed_record_sha256']==payload['record_sha256']and sample['predecessor']['agent_sha256']==payload['agent_sha256']and sample['predecessor']['helper_sha256']==payload['helper_sha256'],'actual current predecessor')
|
||||
require(sample['updater']['binary_sha256']==payload['updater_sha256']and sample['updater']['policy_sha256']==payload['policy_sha256']and sample['updater']['keyring_sha256']==payload['keyring_sha256']and sample['updater']['health_key_pin_sha256']==payload['health_pin_sha256'],'actual protected updater trust bindings')
|
||||
required=['agent.update.apply/1','agent.update.check/1','update_agent','root:update_agent','helper.root.v1','rmm.sync.v1','helper.binary.sha256:'+payload['helper_sha256'],'helper.policy.sha256:'+payload['helper_policy_sha256'],'updater.binary.sha256:'+payload['updater_sha256'],'updater.policy.sha256:'+payload['policy_sha256']]
|
||||
require(all(cap in observed['capabilities']for cap in required),'actual current qualified runtime capabilities, no SQL override')
|
||||
return {'operation':'linux_compatible_passive_qualification_v1','tenant_id':tenant,'agent_id':agent,'sample':sample,'connection_generation':observed['connection_generation'],'capabilities':observed['capabilities'],'observation_payload_sha256':observed['payload_sha256'],'actual_passive_path':True,'database_written':False,'job_authority':False}
|
||||
|
||||
def stage(payload):
|
||||
import base64,hashlib,json,os,stat,uuid
|
||||
from pathlib import Path
|
||||
require(os.geteuid()==0 and os.uname().machine=='x86_64','root x86 Linux only')
|
||||
ident=str(uuid.UUID(payload['case_id']));base=Path('/var/lib/rmm-updater-bootstrap')
|
||||
if not base.exists():base.mkdir(mode=0o700)
|
||||
meta=base.lstat();require(stat.S_ISDIR(meta.st_mode)and meta.st_uid==0 and stat.S_IMODE(meta.st_mode)==0o700,'protected bootstrap root')
|
||||
folder=base/ident;folder.mkdir(mode=0o700)
|
||||
files=payload['files'];require(set(files)=={'agent.bin','helper.bin','updater.bin','sdk.bin','full-config.json','full-pin.json','updater.service'},'closed bootstrap artifact set')
|
||||
for name,entry in files.items():
|
||||
raw=base64.b64decode(entry['base64'],validate=True);require(len(raw)==entry['bytes']and hashlib.sha256(raw).hexdigest()==entry['sha256'],'exact public artifact')
|
||||
if name.endswith('.bin'):require(raw[:6]==b'\x7fELF\x02\x01'and raw[18:20]==b'\x3e\x00','Linux x86-64 ELF')
|
||||
fd=os.open(folder/name,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o500 if name.endswith('.bin') else 0o600)
|
||||
with os.fdopen(fd,'wb')as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
||||
manifest={k:v for k,v in payload.items()if k!='files'};manifest['files']={n:{k:v for k,v in e.items()if k!='base64'}for n,e in files.items()}
|
||||
with(folder/'manifest.json').open('x')as stream:json.dump(manifest,stream,sort_keys=True);stream.flush();os.fsync(stream.fileno())
|
||||
return {'case_id':ident,'folder':str(folder),'staged':True,'services_changed':False,'job_authority':False}
|
||||
|
||||
def pair(payload):
|
||||
import base64,contextlib,fcntl,hashlib,json,os,select,sqlite3,stat,subprocess,time,uuid,datetime
|
||||
from pathlib import Path
|
||||
require(os.geteuid()==0 and os.uname().machine=='x86_64','root x86 Linux only')
|
||||
ident=str(uuid.UUID(payload['case_id']));folder=Path('/var/lib/rmm-updater-bootstrap')/ident;manifest=json.loads((folder/'manifest.json').read_text())
|
||||
require(Path('/proc/sys/kernel/random/boot_id').read_text().strip()==manifest['boot_id'],'original boot')
|
||||
def sha(raw):return hashlib.sha256(raw).hexdigest()
|
||||
def run(a,timeout=20):return subprocess.check_output(a,text=True,stderr=subprocess.DEVNULL,timeout=timeout).strip()
|
||||
def syncdir(path):
|
||||
fd=os.open(path,os.O_RDONLY|os.O_DIRECTORY)
|
||||
try:os.fsync(fd)
|
||||
finally:os.close(fd)
|
||||
def record(name,value):
|
||||
with(folder/name).open('x')as stream:json.dump(value,stream,sort_keys=True);stream.flush();os.fsync(stream.fileno())
|
||||
syncdir(folder)
|
||||
def public(path,maximum):
|
||||
path=Path(path);meta=path.lstat();require(stat.S_ISREG(meta.st_mode)and meta.st_uid==0 and meta.st_nlink==1 and not meta.st_mode&0o022 and meta.st_size<=maximum,'protected original public file');return path.read_bytes(),meta
|
||||
def identity(path):
|
||||
m=Path(path).lstat();require(not stat.S_ISLNK(m.st_mode),'no substituted path');return [m.st_dev,m.st_ino,m.st_uid,m.st_gid,m.st_mode,m.st_nlink]
|
||||
def status(unit):
|
||||
fields={k:v for k,v in(line.split('=',1)for line in run(['systemctl','show','--all','--property=Id,ActiveState,SubState,MainPID,ControlPID,InvocationID,Job,ControlGroup,UnitFileState','--',unit]).splitlines())};require(fields['Id']==unit,'exact service');return fields
|
||||
units=['rmm-agent-remote.service','rmm-helper-cloud.service','rmm-full-maintenance-helper.service']
|
||||
def databases():
|
||||
result={}
|
||||
for path in ('/var/lib/rmm-agent-remote/journal.sqlite','/var/lib/rmm-agent-remote/consumption.sqlite','/var/lib/rmm-helper/consumption.sqlite'):
|
||||
require(not Path(path+'-wal').exists()and not Path(path+'-shm').exists(),'existing DELETE journals')
|
||||
with contextlib.closing(sqlite3.connect('file:'+path+'?mode=ro',uri=True,timeout=.5))as db:
|
||||
db.execute('PRAGMA query_only=ON');require(db.execute('PRAGMA integrity_check').fetchone()[0]=='ok','original journal integrity')
|
||||
tables={r[0]for r in db.execute("SELECT name FROM sqlite_master WHERE type='table'")};evidence=[]
|
||||
if 'consumed'in tables:
|
||||
require(db.execute('SELECT count(*) FROM consumed WHERE result IS NULL').fetchone()[0]==0,'no unresolved original effect')
|
||||
for row in db.execute('SELECT c.grant_id,c.agent,c.generation,c.job,c.attempt,c.result,e.start,e.outcome FROM consumed c LEFT JOIN execution_evidence e USING(grant_id) ORDER BY c.grant_id'):
|
||||
evidence.append([v if isinstance(v,(str,int))or v is None else sha(v)for v in row])
|
||||
if 'job_attempts'in tables:require(db.execute("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')").fetchone()[0]==0,'no open original agent job')
|
||||
for name in ('helper_sync_meta','reconcile_meta'):
|
||||
if name in tables:require(db.execute('SELECT count(*) FROM '+name+' WHERE fault IS NOT NULL').fetchone()[0]==0,'no original journal fault')
|
||||
generation=db.execute('SELECT generation FROM reconcile_meta WHERE id=1').fetchone()[0]if 'reconcile_meta'in tables else None
|
||||
result[path]={'file_id':identity(path),'evidence_sha256':sha(json.dumps(evidence,separators=(',',':')).encode()),'consumptions':len(evidence),'generation':generation}
|
||||
return result
|
||||
def retained_metadata():
|
||||
result={}
|
||||
fixed=['/var/lib/rmm-agent-remote/binding.json','/var/lib/rmm-agent-remote/identity.json','/var/lib/rmm-agent-remote/job-signing-key.json','/var/lib/rmm-agent-remote/device.key','/var/lib/rmm-agent-remote/device.pem','/etc/rmm-remote/agent.env','/etc/rmm-remote/helper-general.json','/etc/rmm-remote/general-helper-proof.json','/etc/rmm-remote/helper-signing-key.json']
|
||||
cert=Path('/var/lib/rmm-agent-remote/certificates')
|
||||
if cert.exists():fixed.extend(str(p)for p in cert.rglob('*')if p.is_file())
|
||||
for path in fixed:
|
||||
m=Path(path).lstat();require(stat.S_ISREG(m.st_mode)and m.st_nlink==1,'retained original metadata');result[path]=identity(path)+[m.st_size,m.st_mtime_ns,m.st_ctime_ns]
|
||||
return result
|
||||
for name,entry in manifest['files'].items():require(sha((folder/name).read_bytes())==entry['sha256'],'staged artifact changed')
|
||||
for unit in ('rmm-apt-helper.service','rmm-agent.service','rmm-helper-dev-test.service'):
|
||||
s=status(unit);require(s['ActiveState']=='inactive'and s['MainPID']in('','0')and s['ControlPID']in('','0')and s['Job']==''and s['UnitFileState']in('','disabled'),'APT and legacy remain closed')
|
||||
if payload['action']=='install':
|
||||
require(not(folder/'pair-install-intent.json').exists(),'existing intent means readback, never repeat')
|
||||
fence=payload['central_fence'];require(fence['operation']=='linux_compatible_closed_scope_v1'and fence['open_jobs']==0 and not fence['job_authority']and fence['tenant_id']==manifest['tenant_id']and fence['agent_id']==manifest['agent_id'],'closed central scope')
|
||||
at=datetime.datetime.fromisoformat(fence['observed_at']);require(0<=(datetime.datetime.now(datetime.timezone.utc)-at).total_seconds()<30,'fresh closed-scope readback')
|
||||
before={u:status(u)for u in units};pids=[]
|
||||
for u,s in before.items():
|
||||
require(s['ActiveState']=='active'and int(s['MainPID'])>1 and s['ControlPID']=='0'and s['Job']=='','exact active original pair')
|
||||
pid=int(s['MainPID']);fd=os.pidfd_open(pid);pids.append(fd)
|
||||
original=databases();retained=retained_metadata()
|
||||
for source,target,oldsha in [('agent.bin','/usr/local/libexec/rmm-agent-remote',manifest['old_agent_sha256']),('helper.bin','/usr/local/libexec/rmm-privileged-helper',manifest['old_helper_sha256']),('full-config.json','/etc/rmm-remote/helper-full-maintenance.json',manifest['old_config_sha256']),('full-pin.json','/etc/rmm-remote/full-maintenance-helper-proof.json',manifest['old_pin_sha256'])]:
|
||||
raw,_=public(target,256*1024*1024);require(sha(raw)==oldsha,'original target CAS')
|
||||
record('pair-install-intent.json',{'before':before,'databases':original,'retained':retained,'central_fence':fence,'files':manifest['files']})
|
||||
run(['systemctl','stop','--',units[0],units[2],units[1]],30)
|
||||
for fd in pids:
|
||||
poll=select.poll();poll.register(fd,select.POLLIN);require(poll.poll(1000),'original process not exited');os.close(fd)
|
||||
for u in units:
|
||||
s=status(u);require(s['ActiveState']=='inactive'and s['MainPID']=='0'and s['ControlPID']=='0'and not s['Job']and not s['ControlGroup'],'all original processes stopped')
|
||||
with contextlib.ExitStack()as held:
|
||||
for path in ('/var/lib/rmm-agent-remote/agent.lock','/var/lib/rmm-helper/executor.lock'):
|
||||
f=held.enter_context(open(path,'rb'));fcntl.flock(f,fcntl.LOCK_EX|fcntl.LOCK_NB)
|
||||
closed=databases()
|
||||
require(all(closed[p]['file_id']==v['file_id']and closed[p]['evidence_sha256']==v['evidence_sha256']for p,v in original.items()),'original effect history changed during stop')
|
||||
for source,target,oldsha in [('agent.bin','/usr/local/libexec/rmm-agent-remote',manifest['old_agent_sha256']),('helper.bin','/usr/local/libexec/rmm-privileged-helper',manifest['old_helper_sha256']),('full-config.json','/etc/rmm-remote/helper-full-maintenance.json',manifest['old_config_sha256']),('full-pin.json','/etc/rmm-remote/full-maintenance-helper-proof.json',manifest['old_pin_sha256'])]:
|
||||
target=Path(target);old,meta=public(target,256*1024*1024);require(sha(old)==oldsha,'stopped target CAS')
|
||||
previous=target.with_name(target.name+'.bootstrap-'+ident+'.previous');candidate=target.with_name(target.name+'.bootstrap-'+ident+'.candidate');require(not previous.exists()and not candidate.exists(),'create-once bootstrap names')
|
||||
fd=os.open(candidate,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,stat.S_IMODE(meta.st_mode))
|
||||
with os.fdopen(fd,'wb')as stream:os.fchown(stream.fileno(),meta.st_uid,meta.st_gid);stream.write((folder/source).read_bytes());stream.flush();os.fsync(stream.fileno())
|
||||
record(source+'-save-intent.json',{'target':str(target),'previous':str(previous),'old_sha256':oldsha});os.rename(target,previous);syncdir(target.parent)
|
||||
record(source+'-publish-intent.json',{'candidate':str(candidate),'target':str(target),'sha256':manifest['files'][source]['sha256']});os.rename(candidate,target);syncdir(target.parent)
|
||||
syncdir(target.parent)
|
||||
require(sha(target.read_bytes())==manifest['files'][source]['sha256']and sha(previous.read_bytes())==oldsha,'exact predecessor and replacement retained')
|
||||
require(retained_metadata()==retained,'original key identity General policy or PKI changed')
|
||||
record('pair-installed.json',{'databases':closed,'retained':retained,'old_generation':original['/var/lib/rmm-agent-remote/journal.sqlite']['generation'],'services_stopped':True,'job_authority':False})
|
||||
return {'case_id':ident,'compatible_files_installed':True,'services_stopped':True,'next':'separate reviewed unit setup and start phase','job_authority':False}
|
||||
elif payload['action']=='units':
|
||||
installed=json.loads((folder/'pair-installed.json').read_text());require(not(folder/'unit-install-intent.json').exists(),'existing unit intent means readback only')
|
||||
require(retained_metadata()==installed['retained'],'original metadata changed')
|
||||
for u in units:
|
||||
row=status(u);require(row['ActiveState']=='inactive'and row['MainPID']=='0'and row['ControlPID']=='0'and not row['Job'],'pair remains stopped before unit setup')
|
||||
paths={'/usr/local/libexec/rmm-agent-updater':('updater.bin',0o755),'/etc/systemd/system/rmm-agent-updater.service':('updater.service',0o644)}
|
||||
require(all(not Path(path).exists()for path in paths),'stable updater is create-only')
|
||||
require(not Path('/etc/rmm-agent-updater').exists()and not Path('/var/lib/rmm-agent-updater').exists(),'initial trust namespace only')
|
||||
override=Path('/etc/systemd/system/rmm-full-maintenance-helper.service.d/99-rmm-update-closed-start.conf');require(not override.exists(),'create-only closed restart override')
|
||||
record('unit-install-intent.json',{'paths':list(paths),'override':str(override),'restart':'no','services_started':False})
|
||||
for path,(name,mode)in paths.items():
|
||||
fd=os.open(path,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,mode)
|
||||
with os.fdopen(fd,'wb')as stream:stream.write((folder/name).read_bytes());stream.flush();os.fsync(stream.fileno())
|
||||
if not override.parent.exists():override.parent.mkdir(mode=0o755)
|
||||
require(override.parent.lstat().st_uid==0 and not override.parent.is_symlink()and not override.parent.lstat().st_mode&0o022,'protected Full override parent')
|
||||
with override.open('xb')as stream:stream.write(b'[Service]\nRestart=no\n');stream.flush();os.fsync(stream.fileno())
|
||||
override.chmod(0o644)
|
||||
for path,mode in [('/etc/rmm-agent-updater',0o755),('/var/lib/rmm-agent-updater',0o700),('/var/lib/rmm-agent-updater/records',0o700),('/var/lib/rmm-agent-updater/handoffs',0o700)]:Path(path).mkdir(mode=mode)
|
||||
binding=json.loads(Path('/var/lib/rmm-agent-remote/binding.json').read_text());key=json.loads(Path('/etc/rmm-remote/helper-signing-key.json').read_text())
|
||||
require(binding.get('public_key_hex')in('',key['public_key_hex']),'independent effective public key pin');binding['public_key_hex']=key['public_key_hex']
|
||||
fd=os.open('/etc/rmm-agent-updater/binding.json',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'w')as stream:json.dump(binding,stream,separators=(',',':'));stream.flush();os.fsync(stream.fileno())
|
||||
run(['systemctl','daemon-reload'])
|
||||
require(run(['systemctl','show','--value','--property=Restart','--',units[2]])=='no','actual closed Full restart contract')
|
||||
updater=status('rmm-agent-updater.service');require(updater['ActiveState']=='inactive'and updater['MainPID']=='0'and updater['ControlPID']=='0'and not updater['Job']and updater['UnitFileState']=='disabled','updater remains stopped and disabled')
|
||||
record('units-installed.json',{'updater':updater,'restart_override_sha256':sha(override.read_bytes()),'namespace_provisioned':True,'updater_started':False})
|
||||
return {'case_id':ident,'updater_unit_installed_not_started':True,'full_restart_no_bound':True,'job_authority':False}
|
||||
elif payload['action']=='start':
|
||||
installed=json.loads((folder/'pair-installed.json').read_text());require((folder/'units-installed.json').is_file(),'separate reviewed unit setup required');require(not(folder/'pair-start-intent.json').exists(),'existing start means readback only')
|
||||
require(retained_metadata()==installed['retained'],'original metadata changed')
|
||||
for u in units:
|
||||
s=status(u);require(s['ActiveState']=='inactive'and s['MainPID']=='0'and s['ControlPID']=='0'and not s['Job'],'pair remains stopped')
|
||||
record('pair-start-intent.json',{'units':[units[1],units[2],units[0]],'only_once':True})
|
||||
for u in (units[1],units[2],units[0]):
|
||||
record(u+'-start-intent.json',{'unit':u});run(['systemctl','start','--',u],20);s=status(u);require(s['ActiveState']=='active'and int(s['MainPID'])>1,'single compatible start')
|
||||
record('pair-started.json',{'status':{u:status(u)for u in units},'job_authority':False})
|
||||
return {'case_id':ident,'compatible_services_started_once':True,'job_authority':False,'normal_signed_sync_qualification_still_required':True}
|
||||
elif payload['action']=='qualify':
|
||||
installed=json.loads((folder/'pair-installed.json').read_text());require((folder/'pair-started.json').is_file(),'compatible starts required')
|
||||
def pin(unit):
|
||||
raw=run(['systemctl','show','--all','--property=FragmentPath,DropInPaths','--',unit]);fields=dict(line.split('=',1)for line in raw.splitlines());paths=[fields['FragmentPath']]+fields['DropInPaths'].split();require(bool(paths[0]),'actual unit composition')
|
||||
composition=[]
|
||||
for path in paths:
|
||||
data,m=public(path,65536);composition.append([path,{'identity':dict(zip(('device','inode','uid','gid','mode','links'),identity(path))),'bytes':len(data),'sha256':sha(data)}])
|
||||
return {'unit':unit,'unit_sha256':sha(json.dumps(composition,separators=(',',':'),ensure_ascii=False).encode())}
|
||||
pins=[pin(u)for u in units]
|
||||
if run(['systemctl','show','--value','--property=LoadState','--','rmm-apt-helper.service'])=='loaded':pins.append(pin('rmm-apt-helper.service'))
|
||||
request={'operation':'qualify_pair','minimum_generation':installed['old_generation'],'expected_agent_sha256':manifest['files']['agent.bin']['sha256'],'expected_helper_sha256':manifest['files']['helper.bin']['sha256'],'unit_pins':pins}
|
||||
raw=subprocess.check_output([str(folder/'sdk.bin')],input=json.dumps(request).encode(),stderr=subprocess.DEVNULL,timeout=35);value=json.loads(raw)
|
||||
require(value['profile']=='linux_compatible_baseline_qualification_v1'and value['normal_signed_sync_observed']and value['ready']is False and value['helper_ready']is False and value['unlock']is False and value['job_authority']is False,'actual fresh normal qualification')
|
||||
after=databases();require(all(after[p]['file_id']==v['file_id']and after[p]['evidence_sha256']==v['evidence_sha256']for p,v in installed['databases'].items()),'all original consumption and evidence retained')
|
||||
require(retained_metadata()==installed['retained'],'original General identity key or PKI changed')
|
||||
with(folder/'qualification.json').open('xb')as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
||||
record('pair-qualified.json',{'qualification_sha256':sha(raw),'unit_pins':pins,'databases':after,'job_authority':False})
|
||||
return {'case_id':ident,'qualification_sha256':sha(raw),'qualification_base64url':base64.urlsafe_b64encode(raw).rstrip(b'=').decode(),'sample':value,'services_restarted':False,'job_authority':False}
|
||||
elif payload['action']=='registry':
|
||||
receipt=json.loads((folder/'pair-qualified.json').read_text());raw=(folder/'qualification.json').read_bytes();require(sha(raw)==receipt['qualification_sha256'],'actual qualification bytes unchanged')
|
||||
require(not(folder/'registry.json').exists(),'create-only actual registry')
|
||||
request={'operation':'registry','qualification_sha256':receipt['qualification_sha256']}
|
||||
output=subprocess.check_output([str(folder/'sdk.bin')],input=json.dumps(request).encode(),stderr=subprocess.DEVNULL,timeout=35);value=json.loads(output)
|
||||
registry=bytes(value['registry_bytes']);require(sha(registry)==value['reader_registry_sha256'],'actual typed registry hash')
|
||||
with(folder/'registry.json').open('xb')as stream:stream.write(registry);stream.flush();os.fsync(stream.fileno())
|
||||
record('registry-prepared.json',value)
|
||||
return {'case_id':ident,'registry':value,'services_changed':False,'job_authority':False}
|
||||
elif payload['action']=='trust':
|
||||
import tempfile
|
||||
trust=payload['trust'];require(trust['operation']=='linux_compatible_trust_install_v1'and trust['case_id']==ident and trust['job_authority']is False,'fixed public trust package')
|
||||
receipt=json.loads((folder/'pair-qualified.json').read_text());require(trust['qualification_sha256']==receipt['qualification_sha256'],'original native qualification')
|
||||
require(not(folder/'trust-install-intent.json').exists(),'existing trust intent means readback only')
|
||||
expected={'policy.json','keyring.json','health-key.json','reader-registry.json','installed-record.json'};require(set(trust['files'])==expected,'closed trust document set')
|
||||
raw={}
|
||||
for name,entry in trust['files'].items():
|
||||
raw[name]=base64.b64decode(entry['base64'],validate=True);require(len(raw[name])==entry['bytes']and len(raw[name])<=65536 and sha(raw[name])==entry['sha256'],'exact bounded public trust bytes')
|
||||
require(raw['reader-registry.json']==(folder/'registry.json').read_bytes(),'actual measured reader registry')
|
||||
request={'operation':'validate_public_bundle','record':list(raw['installed-record.json']),'policy':list(raw['policy.json']),'keyring':list(raw['keyring.json']),'health_pin':list(raw['health-key.json'])}
|
||||
checked=json.loads(subprocess.check_output([str(folder/'sdk.bin')],input=json.dumps(request).encode(),stderr=subprocess.DEVNULL,timeout=20));require(checked==trust['shape_checks']and checked['shape_only_not_signature_verified']is True,'independent native typed shape check')
|
||||
policy=json.loads(raw['policy.json']);keys=json.loads(raw['keyring.json']);health=json.loads(raw['health-key.json']);baseline=policy['initial_baseline'];record_doc=json.loads(raw['installed-record.json']);envelope=record_doc['release_envelope']
|
||||
require(keys['generation']==1 and len(keys['keys'])==1 and keys['keys'][0]['platform']=='x86_64-unknown-linux-gnu'and keys['keys'][0]['first_sequence']==1 and keys['keys'][0]['last_sequence']==2 and not keys['keys'][0]['revoked'],'initial two-release trust scope')
|
||||
public_key=bytes.fromhex(keys['keys'][0]['public_key_hex']);job_key=json.loads(Path('/etc/rmm-remote/helper-signing-key.json').read_text())['public_key_hex'];require(len(public_key)==32 and public_key.hex()!=job_key and public_key.hex()!=health['public_key_hex']and health['public_key_hex']!=job_key,'separate updater release health and Job keys')
|
||||
require(sha(public_key)==baseline['key_id']==envelope['key_id'],'exact independently provisioned release key identity')
|
||||
def decode(value):
|
||||
decoded=base64.urlsafe_b64decode(value+'='*((-len(value))%4));require(base64.urlsafe_b64encode(decoded).rstrip(b'=').decode()==value,'canonical signed public bytes');return decoded
|
||||
with tempfile.TemporaryDirectory(prefix='rmm-bootstrap-verify-')as tmp:
|
||||
temp=Path(tmp);(temp/'public.der').write_bytes(bytes.fromhex('302a300506032b6570032100')+public_key)
|
||||
for role,document,prefix in [('baseline',baseline,b'rmm.agent-update-baseline.v1\0'),('release',envelope,b'rmm.agent-release.v1\0')]:
|
||||
message=decode(document['payload_bytes']);signature=decode(document['signature']);require(len(signature)==64,'original Ed25519 signature')
|
||||
(temp/'message').write_bytes(prefix+message);(temp/'signature').write_bytes(signature)
|
||||
subprocess.run(['openssl','pkeyutl','-verify','-rawin','-pubin','-keyform','DER','-inkey',str(temp/'public.der'),'-in',str(temp/'message'),'-sigfile',str(temp/'signature')],check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=10)
|
||||
if role=='baseline':require(message==raw['installed-record.json'],'exact initial signed record')
|
||||
else:
|
||||
release=json.loads(message);require(sha(message)==record_doc['manifest_sha256']and release['release_sequence']==1 and release['version']=='0.1.0'and release['platform']=='x86_64-unknown-linux-gnu','exact initial signed manifest')
|
||||
require([(a['role'],a['sha256'],a['bytes'])for a in release['artifacts']]==[(role,manifest['files'][name]['sha256'],manifest['files'][name]['bytes'])for role,name in [('agent','agent.bin'),('helper','helper.bin')]],'signed release binds exact installed compatible code pair')
|
||||
require(record_doc['activation_evidence']=={'kind':'bootstrap','qualification_receipt_sha256':receipt['qualification_sha256']}and policy['updater_binary_sha256']==manifest['files']['updater.bin']['sha256'],'actual qualification and stable updater')
|
||||
require(all(policy[k]==manifest[k]for k in ('tenant_id','asset_id','agent_id','enrollment_generation','assignment_version'))and policy['services']==json.loads((folder/'registry-prepared.json').read_text())['services'],'exact local identity and actual unit pins')
|
||||
retained=retained_metadata();specs=[]
|
||||
mutable={'/var/lib/rmm-agent-remote/journal.sqlite','/var/lib/rmm-agent-remote/consumption.sqlite','/var/lib/rmm-helper/consumption.sqlite'}
|
||||
paths=sorted(set(retained)|mutable|{'/var/lib/rmm-agent-remote/agent.lock','/var/lib/rmm-helper/executor.lock'})
|
||||
for path in paths:
|
||||
m=Path(path).lstat();require(stat.S_ISREG(m.st_mode)and not Path(path).is_symlink(),'retained state original regular file');parent=Path(path).parent.lstat();owner=993 if path.startswith('/var/lib/rmm-agent-remote/')else 0;require(parent.st_uid==owner and not parent.st_mode&0o022,'retained state protected parent')
|
||||
specs.append({'path':path,'parent_uid':owner,'identity':dict(zip(('device','inode','uid','gid','mode','links'),identity(path))),'retention':'mutable_database'if path in mutable else'immutable_metadata'})
|
||||
require(0<len(specs)<=64,'bounded retained metadata set');raw['retained-files.json']=json.dumps(specs,separators=(',',':')).encode()
|
||||
targets={name:Path('/var/lib/rmm-agent-updater/installed-record.json')if name=='installed-record.json'else Path('/etc/rmm-agent-updater')/name for name in raw}
|
||||
require(all(not p.exists()for p in targets.values()),'create-only trust installation')
|
||||
updater=status('rmm-agent-updater.service');require(updater['ActiveState']=='inactive'and updater['MainPID']=='0'and updater['ControlPID']=='0'and not updater['Job'],'updater remains stopped before trust')
|
||||
record('trust-install-intent.json',{'files':{n:sha(b)for n,b in raw.items()},'qualification_sha256':receipt['qualification_sha256'],'public_signatures_verified':True,'updater_started':False})
|
||||
for name,data in raw.items():
|
||||
target=targets[name];mode=0o600 if name=='installed-record.json'else 0o644;fd=os.open(target,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,mode)
|
||||
with os.fdopen(fd,'wb')as stream:stream.write(data);stream.flush();os.fsync(stream.fileno())
|
||||
os.chmod(target,mode);syncdir(target.parent)
|
||||
require(retained_metadata()==retained,'original identity metadata retained through public trust install')
|
||||
record('trust-installed.json',{'files':{n:sha(b)for n,b in raw.items()},'public_signatures_verified':True,'job_authority':False})
|
||||
return {'case_id':ident,'protected_trust_installed':True,'release_and_baseline_signatures_verified':True,'updater_started':False,'job_authority':False}
|
||||
elif payload['action']=='updater-start':
|
||||
trust=json.loads((folder/'trust-installed.json').read_text());require(not(folder/'updater-start-intent.json').exists(),'existing start intent means readback only')
|
||||
for name,wanted in trust['files'].items():
|
||||
target=Path('/var/lib/rmm-agent-updater/installed-record.json')if name=='installed-record.json'else Path('/etc/rmm-agent-updater')/name;require(sha(target.read_bytes())==wanted,'protected trust unchanged before single start')
|
||||
updater=status('rmm-agent-updater.service');require(updater['ActiveState']=='inactive'and updater['MainPID']=='0'and updater['ControlPID']=='0'and not updater['Job'],'fixed stopped updater before start')
|
||||
record('updater-start-intent.json',{'unit':'rmm-agent-updater.service','only_once':True,'job_authority':False});run(['systemctl','start','--','rmm-agent-updater.service'],20)
|
||||
updater=status('rmm-agent-updater.service');pid=int(updater['MainPID']);require(updater['ActiveState']=='active'and pid>1 and updater['ControlPID']=='0'and not updater['Job'],'actual stable updater started')
|
||||
fd=os.pidfd_open(pid)
|
||||
try:
|
||||
start=Path('/proc/'+str(pid)+'/stat').read_text().rsplit(') ',1)[1].split()[19];image=Path('/proc/'+str(pid)+'/exe').read_bytes();require(sha(image)==manifest['files']['updater.bin']['sha256'],'actual original stable updater image')
|
||||
require(status('rmm-agent-updater.service')==updater,'same updater process held through observation')
|
||||
finally:os.close(fd)
|
||||
record('updater-started.json',{'status':updater,'process_start_ticks':start,'image_sha256':sha(image),'job_authority':False})
|
||||
return {'case_id':ident,'stable_updater_started_once':True,'pid':pid,'image_sha256':sha(image),'actual_agent_passive_observation_still_required':True,'job_authority':False}
|
||||
elif payload['action']=='readback':
|
||||
names=[p.name for p in folder.glob('*')if p.name.endswith('.json')and p.name!='manifest.json'];public={}
|
||||
for name in ('qualification.json','registry-prepared.json','pair-qualified.json','trust-installed.json','updater-started.json'):
|
||||
path=folder/name
|
||||
if path.exists():
|
||||
raw=path.read_bytes();require(len(raw)<=192*1024,'bounded public readback');public[name]={'sha256':sha(raw),'base64url':base64.urlsafe_b64encode(raw).rstrip(b'=').decode()}
|
||||
return {'case_id':ident,'records':names,'public_evidence':public,'status':{u:status(u)for u in units+['rmm-agent-updater.service']},'databases':databases(),'job_authority':False}
|
||||
else:raise RuntimeError('unknown fixed pair action')
|
||||
|
||||
def prepare(sdk_manifest):
|
||||
require=lambda ok,msg:None if ok else(_ for _ in()).throw(RuntimeError(msg))
|
||||
require(sha(BASE.read_bytes())==BASE_SHA,'exact capability derivative V2 manifest')
|
||||
build=json.loads(BASE.read_text());sdk=json.loads(sdk_manifest.read_text());require(sdk['profile']=='linux_updater_bootstrap_metadata_sdk_v1'and sdk['release_built']and sdk['clippy_all_targets_passed']and not sdk['target_mutated'],'sealed metadata SDK')
|
||||
inputs=native_rpc(public_inputs,{'operation':'linux_compatible_public_inputs_v1'})
|
||||
snapshot=transport.rpc('linux-vm.conf',prerequisite.inspect_vm,{'operation':'linux_updater_bootstrap_inspect_v1'})
|
||||
require(snapshot['boot_id']==BOOT and not snapshot['updater_provisioned'],'original initial target')
|
||||
full=json.loads(bytes(inputs['helper-full-maintenance.json']['bytes']));key=json.loads(bytes(inputs['helper-signing-key.json']['bytes']))
|
||||
require(full['signing_key_file']=='/etc/rmm-remote/helper-signing-key.json','independent fixed Full keyfile')
|
||||
binary=Path(sdk['binary']['path']);require(sha(binary.read_bytes())==sdk['binary']['sha256'],'sealed SDK bytes')
|
||||
request={'operation':'render_full','config':inputs['helper-full-maintenance.json']['bytes'],'pin':inputs['full-maintenance-helper-proof.json']['bytes'],'job_public_key_hex':key['public_key_hex'],'new_helper_sha256':build['artifacts']['source0']['helper']['sha256']}
|
||||
command=['docker','run','--rm','-i','--network','none','--read-only','--tmpfs','/tmp:rw,size=64m','-v',str(binary)+':/sdk:ro','--entrypoint','/sdk','sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6']
|
||||
rendered=subprocess.run(command,input=json.dumps(request).encode(),capture_output=True,check=True,timeout=30);transition=json.loads(rendered.stdout)
|
||||
ident=str(uuid.uuid4());folder=ROOT/'devstate/linux-updater-compatible'/ident;folder.mkdir(mode=0o700,parents=True)
|
||||
files={}
|
||||
for name,item in [('agent.bin',build['artifacts']['source0']['agent']),('helper.bin',build['artifacts']['source0']['helper']),('updater.bin',build['stable_updater']),('sdk.bin',sdk['binary'])]:
|
||||
raw=Path(item['path']).read_bytes();require(sha(raw)==item['sha256']and len(raw)==item['bytes'],'sealed exact code artifact');files[name]=raw
|
||||
files['full-config.json']=bytes(transition['config']);files['full-pin.json']=bytes(transition['pin'])
|
||||
unit=ROOT/'devstate/linux-updater-qualification/21d20391-6102-4996-8a7a-efbd3e78bd7d/source0/deploy/linux/rmm-agent-updater.service';files['updater.service']=unit.read_bytes()
|
||||
proof=transition['proof'];require(proof['new_helper_sha256']==build['artifacts']['source0']['helper']['sha256']and proof['old_config_sha256']==inputs['helper-full-maintenance.json']['sha256']and proof['old_pin_sha256']==inputs['full-maintenance-helper-proof.json']['sha256'],'typed exact Full transition')
|
||||
for name,raw in files.items():once(folder/name,raw)
|
||||
binding=full['binding'];payload={'schema_version':1,'profile':'linux_compatible_bootstrap_package_v1','case_id':ident,'boot_id':BOOT,'tenant_id':binding['tenant_id'],'agent_id':binding['agent_id'],'asset_id':binding['asset_id'],'enrollment_generation':binding['enrollment_generation'],'assignment_version':binding['assignment_version'],'build_manifest_sha256':BASE_SHA,'sdk_manifest_sha256':sha(sdk_manifest.read_bytes()),'old_agent_sha256':snapshot['binaries']['/usr/local/libexec/rmm-agent-remote']['sha256'],'old_helper_sha256':snapshot['binaries']['/usr/local/libexec/rmm-privileged-helper']['sha256'],'old_config_sha256':proof['old_config_sha256'],'old_pin_sha256':proof['old_pin_sha256'],'full_transition':proof,'files':{n:{'sha256':sha(raw),'bytes':len(raw),'base64':base64.b64encode(raw).decode()}for n,raw in files.items()},'job_authority':False}
|
||||
once(folder/'package.json',json.dumps(payload,sort_keys=True,separators=(',',':')).encode());once(folder/'readonly-before.json',json.dumps(snapshot,sort_keys=True,indent=2).encode());once(folder/'public-inputs.json',json.dumps(inputs,sort_keys=True,indent=2).encode())
|
||||
summary={k:v for k,v in payload.items()if k!='files'};summary['files']={n:{k:v for k,v in e.items()if k!='base64'}for n,e in payload['files'].items()};once(folder/'manifest.json',json.dumps(summary,sort_keys=True,indent=2).encode())
|
||||
print(json.dumps({'package':str(folder/'package.json'),'manifest':str(folder/'manifest.json'),'case_id':ident,'local_only_preparation':True,'target_staged':False,'services_changed':False,'full_policy_sha256':proof['new_policy_sha256']}))
|
||||
|
||||
def main():
|
||||
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('prepare','public-inputs','central-check','stage','install','units','start','qualify','registry','trust','updater-start','passive-check','readback'));parser.add_argument('--package',type=Path);parser.add_argument('--sdk-manifest',type=Path);parser.add_argument('--trust-package',type=Path);args=parser.parse_args()
|
||||
if args.action=='prepare':
|
||||
if args.sdk_manifest is None:parser.error('--sdk-manifest required for preparation')
|
||||
prepare(args.sdk_manifest);return
|
||||
if args.package is None:parser.error('--package required for fixed native phases')
|
||||
p=json.loads(args.package.read_text());require=lambda ok,msg:None if ok else(_ for _ in()).throw(RuntimeError(msg))
|
||||
require(p['schema_version']==1 and p['profile']=='linux_compatible_bootstrap_package_v1'and p['boot_id']==BOOT,'reviewed exact package')
|
||||
if args.action=='public-inputs':value=native_rpc(public_inputs,{'operation':'linux_compatible_public_inputs_v1'})
|
||||
elif args.action=='central-check':value=native_rpc(central_closed,{'agent_id':p['agent_id'],'tenant_id':p['tenant_id']},config='server.conf')
|
||||
elif args.action=='stage':value=native_rpc(stage,p,timeout=120)
|
||||
elif args.action=='passive-check':
|
||||
if args.trust_package is None:parser.error('--trust-package required for exact passive comparison')
|
||||
trust=json.loads(args.trust_package.read_text());files=trust['files'];value=native_rpc(passive_check,{'tenant_id':p['tenant_id'],'agent_id':p['agent_id'],'record_sha256':files['installed-record.json']['sha256'],'policy_sha256':files['policy.json']['sha256'],'keyring_sha256':files['keyring.json']['sha256'],'health_pin_sha256':files['health-key.json']['sha256'],'agent_sha256':p['files']['agent.bin']['sha256'],'helper_sha256':p['files']['helper.bin']['sha256'],'updater_sha256':p['files']['updater.bin']['sha256'],'helper_policy_sha256':p['full_transition']['new_policy_sha256']},config='server.conf')
|
||||
else:
|
||||
payload={'case_id':p['case_id'],'action':args.action}
|
||||
if args.action=='install':payload['central_fence']=native_rpc(central_closed,{'agent_id':p['agent_id'],'tenant_id':p['tenant_id']},config='server.conf')
|
||||
if args.action=='trust':
|
||||
if args.trust_package is None:parser.error('--trust-package required for protected trust installation')
|
||||
payload['trust']=json.loads(args.trust_package.read_text())
|
||||
value=native_rpc(pair,payload,timeout=120)
|
||||
print(json.dumps(value))
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,82 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Prepare public updater metadata using the sealed Rust codecs; never signs.
|
||||
|
||||
Every input is public evidence. A locally prepared document is neither a native
|
||||
qualification nor trusted until the existing native verifier accepts it.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import datetime
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import uuid
|
||||
import linux_updater_compatible_apply as bootstrap
|
||||
|
||||
SDK = bootstrap.ROOT / 'devstate/linux-updater-bootstrap-sdk/d309c949-3a70-4448-88da-49c710093221/sdk.bin'
|
||||
SDK_SHA = '6fcc543d538fca30ceb499364880e4dc3689700d50597f18bd11bfe3559a0021'
|
||||
|
||||
def require(condition):
|
||||
if not condition: raise RuntimeError('Public updater preparation contract failed')
|
||||
def digest(raw): return hashlib.sha256(raw).hexdigest()
|
||||
def encode(value): return json.dumps(value, separators=(',', ':'), ensure_ascii=False).encode()
|
||||
def b64(raw): return base64.urlsafe_b64encode(raw).rstrip(b'=').decode()
|
||||
def unb64(value):
|
||||
raw = base64.urlsafe_b64decode(value + '=' * (-len(value) % 4))
|
||||
require(b64(raw) == value)
|
||||
return raw
|
||||
def typed(value):
|
||||
require(digest(SDK.read_bytes()) == SDK_SHA)
|
||||
result = subprocess.run(['docker', 'run', '--rm', '-i', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=64m', '-v', str(SDK)+':/sdk:ro', '--entrypoint', '/sdk', 'sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6'], input=encode(value), capture_output=True, check=True, timeout=30)
|
||||
return json.loads(result.stdout)
|
||||
def prepare(action, data):
|
||||
signer = data['signer']
|
||||
require(signer['platform'] == 'linux' and signer['profile'] == 'agent_updater_separate_signers_v1')
|
||||
common = {'case_id': signer['case_id'], 'platform': 'linux', 'job_authority': False}
|
||||
if action == 'release-input':
|
||||
build = json.loads(bootstrap.BASE.read_text())
|
||||
require(digest(bootstrap.BASE.read_bytes()) == bootstrap.BASE_SHA)
|
||||
seq = data['sequence']; require(seq in (1, 2))
|
||||
published = int(datetime.datetime.now(datetime.timezone.utc).timestamp())
|
||||
manifest = {'schema_version': 1, 'release_id': str(uuid.uuid4()), 'release_sequence': seq, 'version': '0.1.0' if seq == 1 else '0.1.1', 'platform': 'x86_64-unknown-linux-gnu', 'published_at': published, 'expires_at': published + 604800, 'protocol_major': 1, 'state_schema': 1, 'minimum_updater_version': 1, 'artifacts': []}
|
||||
for role in ('agent', 'helper'):
|
||||
item = build['artifacts']['source'+str(seq-1)][role]
|
||||
manifest['artifacts'].append({'role': role, 'artifact_id': str(uuid.uuid4()), 'sha256': item['sha256'], 'bytes': item['bytes']})
|
||||
result = typed({'operation': 'canonical_release', 'manifest': manifest})
|
||||
raw = bytes(result['bytes'])
|
||||
return {**common, 'canonical_payload_base64url': b64(raw), 'payload_sha256': digest(raw)}
|
||||
qualification = unb64(data['qualification_base64url']); q = json.loads(qualification)
|
||||
require(q['profile'] == 'linux_compatible_baseline_qualification_v1' and q['normal_signed_sync_observed'])
|
||||
require(all(q[n] is False for n in ('ready', 'helper_ready', 'unlock', 'job_authority')))
|
||||
if action == 'record-input':
|
||||
release = data['signed_release']; manifest = json.loads(unb64(release['envelope']['payload_bytes']))
|
||||
require(manifest['release_sequence'] == 1 and manifest['version'] == '0.1.0')
|
||||
record = {'schema_version': 1, 'profile': 'decoder_compatible_handoff_v1', 'platform': manifest['platform'], 'release_envelope': release['envelope'], 'manifest_sha256': release['payload_sha256'], 'activation_floor': 1, 'activated_at': int(datetime.datetime.fromisoformat(q['observed_at'].replace('Z', '+00:00')).timestamp()), 'previous_record_sha256': None, 'activation_evidence': {'kind': 'bootstrap', 'qualification_receipt_sha256': digest(qualification)}, 'rolled_back': False}
|
||||
raw = bytes(typed({'operation': 'canonical_record', 'record': record})['bytes'])
|
||||
return {**common, 'canonical_payload_base64url': b64(raw), 'payload_sha256': digest(raw), 'qualification_base64url': b64(qualification)}
|
||||
require(action == 'trust-package')
|
||||
package = data['bootstrap_package']; registry = data['registry']; baseline = data['signed_baseline']
|
||||
record_raw = unb64(baseline['envelope']['payload_bytes']); record = json.loads(record_raw)
|
||||
require(record['activation_evidence'] == {'kind': 'bootstrap', 'qualification_receipt_sha256': digest(qualification)})
|
||||
registry_raw = bytes(registry['registry_bytes']); require(digest(registry_raw) == registry['reader_registry_sha256'])
|
||||
policy = {'schema_version': 1, 'profile': 'linux_general_full_v1', **{n: package[n] for n in ('tenant_id', 'asset_id', 'agent_id', 'enrollment_generation', 'assignment_version')}, 'ledger_path': '/var/lib/rmm-helper/consumption.sqlite', 'lock_path': '/var/lib/rmm-helper/executor.lock', 'installed_record_path': '/var/lib/rmm-agent-updater/installed-record.json', 'keyring_path': '/etc/rmm-agent-updater/keyring.json', 'health_pin_path': '/etc/rmm-agent-updater/health-key.json', 'registry_path': '/etc/rmm-agent-updater/reader-registry.json', 'reader_registry_sha256': registry['reader_registry_sha256'], 'services': registry['services'], 'updater_service': registry['updater_service'], 'updater_binary_sha256': package['files']['updater.bin']['sha256'], 'initial_baseline': baseline['envelope'], 'initial_record_sha256': digest(record_raw), 'initial_manifest_sha256': record['manifest_sha256'], 'initial_activation_floor': 1}
|
||||
policy_raw = bytes(typed({'operation': 'canonical_policy', 'policy': policy})['bytes'])
|
||||
keyring_raw = encode({'schema_version': 1, 'generation': 1, 'keys': [{'public_key_hex': signer['release_public_key_hex'], 'platform': 'x86_64-unknown-linux-gnu', 'first_sequence': 1, 'last_sequence': 2, 'revoked': False}]})
|
||||
require(keyring_raw == unb64(signer['keyring_base64url']) and digest(keyring_raw) == signer['keyring_sha256'])
|
||||
health_raw = encode(signer['health_pin'])
|
||||
shape = typed({'operation': 'validate_public_bundle', 'record': list(record_raw), 'policy': list(policy_raw), 'keyring': list(keyring_raw), 'health_pin': list(health_raw)})
|
||||
require(shape['shape_only_not_signature_verified'] is True)
|
||||
files = {'policy.json': policy_raw, 'keyring.json': keyring_raw, 'health-key.json': health_raw, 'reader-registry.json': registry_raw, 'installed-record.json': record_raw}
|
||||
return {'operation': 'linux_compatible_trust_install_v1', 'case_id': package['case_id'], 'signer_case_id': signer['case_id'], 'qualification_sha256': digest(qualification), 'files': {n: {'base64': base64.b64encode(raw).decode(), 'sha256': digest(raw), 'bytes': len(raw)} for n, raw in files.items()}, 'shape_checks': shape, 'signature_verified': False, 'job_authority': False}
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('action', choices=('release-input', 'record-input', 'trust-package'))
|
||||
parser.add_argument('--input', required=True, type=Path)
|
||||
parser.add_argument('--output', required=True, type=Path)
|
||||
args = parser.parse_args()
|
||||
result = prepare(args.action, json.loads(args.input.read_text()))
|
||||
bootstrap.once(args.output, encode(result))
|
||||
print(json.dumps({'output': str(args.output), 'sha256': digest(args.output.read_bytes()), 'local_only': True, 'target_changed': False}))
|
||||
if __name__ == '__main__': main()
|
||||
@@ -0,0 +1,211 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Freeze and build the Linux compatible baseline and version-only successor.
|
||||
|
||||
Offline read-only Docker source mounts, independent local cache, no credentials,
|
||||
VM/server command, job, daemon, signing-key generation or deployment. Windows
|
||||
sources are retained as provenance only, never qualified by this Linux run.
|
||||
"""
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shutil
|
||||
import stat
|
||||
import subprocess
|
||||
import tarfile
|
||||
import time
|
||||
import uuid
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
STATE=ROOT/'devstate/linux-updater-qualification'
|
||||
BUILDER='sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6'
|
||||
PACKAGES=['rmm-agent','rmm-agent-core','rmm-domain','rmm-privileged-helper','rmm-updater-linux','rmm-updater-worker','rmm-updater-handoff','rmm-update-history']
|
||||
UNIT_TARGETS=[('agent','rmm-agent',['--bin','rmm-agent']),('helper','rmm-privileged-helper',['--lib']),
|
||||
('core','rmm-agent-core',['--lib']),('helper-reconcile','rmm-agent-core',['--test','helper_reconcile']),
|
||||
('domain','rmm-domain',['--lib']),('updater-linux','rmm-updater-linux',['--lib']),
|
||||
('worker','rmm-updater-worker',['--lib']),('handoff','rmm-updater-handoff',['--test','handoff_contract'])]
|
||||
SAFE_FILTERS={
|
||||
'updater-linux':['services::status_tests::accepts_actual_seven_property_shape_and_denies_missing_or_extra_properties'],
|
||||
'helper':['update_admission::tests::typed_handoff_ack_is_not_an_outcome_or_a_new_start_lease'],
|
||||
'core':['update_health_sync::tests::same_floor_does_not_admit_a_one_nanosecond_early_or_late_apply'],
|
||||
'helper-reconcile':['update_handoff_consumption_start_and_stop_intent_are_one_transaction',
|
||||
'update_inflight_negative_control_keeps_every_start_closed_and_owner_loss_is_terminal',
|
||||
'native_stop_intent_is_original_head_bound_create_once_and_transactional',
|
||||
'restarted_update_can_only_schedule_control_from_its_verified_original_not_unknown'],
|
||||
}
|
||||
|
||||
def require(ok,code):
|
||||
if not ok:raise RuntimeError(code)
|
||||
|
||||
def sha(raw):return hashlib.sha256(raw).hexdigest()
|
||||
def encode(value):return json.dumps(value,sort_keys=True,indent=2).encode()+b'\n'
|
||||
def write(path,raw):
|
||||
path=Path(path);path.parent.mkdir(mode=0o700,parents=True,exist_ok=True)
|
||||
fd=os.open(path,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'wb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
||||
|
||||
def public_files():
|
||||
names=subprocess.run(['git','ls-files','--cached','--others','--exclude-standard','-z'],cwd=ROOT,capture_output=True,check=True).stdout.split(b'\0')
|
||||
prefixes=('crates/','proto/','migrations/','deploy/','tools/','tests/')
|
||||
fixed={'Cargo.toml','Cargo.lock','rust-toolchain.toml','Rust_RMM_Implementierungsspezifikation.md','AGENTS.md'}
|
||||
result=[]
|
||||
for raw in names:
|
||||
if not raw:continue
|
||||
name=os.fsdecode(raw);path=Path(name)
|
||||
if name not in fixed and not name.startswith(prefixes):continue
|
||||
require(not path.is_absolute() and '..' not in path.parts,'source relative path')
|
||||
if '__pycache__' in path.parts or path.suffix in ('.pyc','.pyo') or path.name=='.env':continue
|
||||
full=ROOT/path
|
||||
require(not full.is_symlink() and full.is_file(),'public regular source only')
|
||||
meta=full.stat();require(meta.st_size<=16*1024*1024,'bounded compiler/public fixture')
|
||||
result.append(name)
|
||||
require({'Cargo.toml','Cargo.lock','crates/agent/src/main.rs','crates/privileged-helper/src/main.rs','crates/updater-worker/src/main.rs'}<=set(result),'complete Linux entrypoints')
|
||||
return sorted(set(result))
|
||||
|
||||
def capture(root,names):
|
||||
result={}
|
||||
for name in names:
|
||||
file=root/name;before=file.stat();raw=file.read_bytes();after=file.stat()
|
||||
require((before.st_dev,before.st_ino,before.st_size,before.st_mtime_ns,before.st_ctime_ns)==
|
||||
(after.st_dev,after.st_ino,after.st_size,after.st_mtime_ns,after.st_ctime_ns),'source changed while reading')
|
||||
result[name]=dict(bytes=len(raw),sha256=sha(raw))
|
||||
return result
|
||||
|
||||
def readonly(root):
|
||||
for path in root.rglob('*'):
|
||||
path.chmod(0o555 if path.is_dir() else 0o444)
|
||||
root.chmod(0o555)
|
||||
|
||||
def freeze(folder):
|
||||
names=public_files();before=capture(ROOT,names);source0=folder/'source0'
|
||||
source0.mkdir(mode=0o700)
|
||||
for name in names:write(source0/name,(ROOT/name).read_bytes())
|
||||
require(capture(source0,names)==before and public_files()==names and capture(ROOT,names)==before,'whole source input snapshot drift; preserve failed case, do not build')
|
||||
require(re.search(r'(?ms)^\[workspace\.package\]\s*version = "0\.1\.0"$',(source0/'Cargo.toml').read_text()),'exact baseline version0.1.0')
|
||||
readonly(source0);write(folder/'source0-inputs.json',encode(before))
|
||||
source1=folder/'source1';shutil.copytree(source0,source1)
|
||||
cargo=source1/'Cargo.toml';lock=source1/'Cargo.lock';cargo.chmod(0o600);lock.chmod(0o600)
|
||||
original=cargo.read_text();require(original.count('version = "0.1.0"')==1,'one workspace version field')
|
||||
cargo.write_text(original.replace('version = "0.1.0"','version = "0.1.1"',1))
|
||||
match=re.search(r'(?ms)^members\s*=\s*(\[.*?\])',original)
|
||||
require(match is not None,'literal workspace member list')
|
||||
members=json.loads(match[1]);internal=[]
|
||||
require(all(isinstance(member,str) and member.startswith('crates/') and '..' not in Path(member).parts for member in members),'closed workspace member paths')
|
||||
for member in members:
|
||||
package=(source1/member/'Cargo.toml').read_text()
|
||||
if re.search(r'(?m)^version\.workspace\s*=\s*true$',package):
|
||||
name=re.search(r'(?m)^name\s*=\s*"([a-z0-9-]+)"$',package)
|
||||
require(name is not None,'literal inherited package name');internal.append(name[1])
|
||||
text=lock.read_text()
|
||||
for name in internal:
|
||||
pattern='name = "'+name+'"\nversion = "0.1.0"'
|
||||
require(text.count(pattern)==1,'one inherited internal lock package')
|
||||
text=text.replace(pattern,'name = "'+name+'"\nversion = "0.1.1"',1)
|
||||
lock.write_text(text)
|
||||
# External crate packages and the excluded independent oidc-auth version
|
||||
# remain exact; only inherited workspace package versions change.
|
||||
inverse=text
|
||||
for name in internal:inverse=inverse.replace('name = "'+name+'"\nversion = "0.1.1"','name = "'+name+'"\nversion = "0.1.0"',1)
|
||||
require(inverse==(source0/'Cargo.lock').read_text(),'no change outside exact inherited internal version lines')
|
||||
cargo.chmod(0o444);lock.chmod(0o444);readonly(source1)
|
||||
after=capture(source1,names)
|
||||
require({name for name in names if before[name]!=after[name]}=={'Cargo.toml','Cargo.lock'},'successor only differs in version/lock metadata')
|
||||
write(folder/'source1-inputs.json',encode(after))
|
||||
return names,before,after,internal
|
||||
|
||||
def run(folder,source,cache,label,args):
|
||||
logfile=folder/'logs'/(label+'.log');logfile.parent.mkdir(mode=0o700,exist_ok=True)
|
||||
command=['docker','run','--rm','--network','none','--read-only','--tmpfs','/tmp:rw,size=512m',
|
||||
'--tmpfs','/run:rw,size=128m','--tmpfs','/var/lib:rw,size=128m',
|
||||
'-v',str(source)+':/src:ro','-v',str(cache)+':/target','-e','CARGO_TARGET_DIR=/target',
|
||||
'-w','/src','--entrypoint','/bin/sh',BUILDER,'-c','mkdir -p /tmp/opencode\nexec '+__import__('shlex').join(args)]
|
||||
write(folder/'logs'/(label+'-command.json'),encode(command))
|
||||
started=time.time();print(json.dumps(dict(stage=label,started=True)),flush=True)
|
||||
with logfile.open('xb') as stream:
|
||||
result=subprocess.run(command,stdout=stream,stderr=subprocess.STDOUT,timeout=1800)
|
||||
logfile.chmod(0o600)
|
||||
result_record=dict(command=command,exit_code=result.returncode,elapsed_seconds=round(time.time()-started,3),log_sha256=sha(logfile.read_bytes()))
|
||||
write(folder/'logs'/(label+'-result.json'),encode(result_record))
|
||||
require(result.returncode==0,'build/check failed: '+label+'; original log preserved')
|
||||
return logfile.read_bytes()
|
||||
|
||||
def copy_artifact(path,target):
|
||||
raw=path.read_bytes();require(raw[:6]==b'\x7fELF\x02\x01' and raw[18:20]==b'\x3e\x00','native Linux x86-64 ELF')
|
||||
write(target,raw);target.chmod(0o500)
|
||||
return dict(path=str(target),sha256=sha(raw),bytes=len(raw),platform='x86_64-unknown-linux-gnu')
|
||||
|
||||
def cargo_packages():
|
||||
return [part for package in PACKAGES for part in ('-p',package)]
|
||||
|
||||
def build():
|
||||
os.umask(0o077);ident=str(uuid.uuid4());folder=STATE/ident;folder.mkdir(mode=0o700,parents=True)
|
||||
write(folder/'entered.json',encode(dict(schema_version=1,case_id=ident,root=str(ROOT),builder=BUILDER,
|
||||
git_head=subprocess.run(['git','rev-parse','HEAD'],cwd=ROOT,capture_output=True,check=True,text=True).stdout.strip(),
|
||||
no_target_mutations=True,windows_not_qualified=True)))
|
||||
names,input0,input1,internal=freeze(folder)
|
||||
cache=folder/'cache';cache.mkdir(mode=0o700)
|
||||
results={};units={}
|
||||
for version,inputs in (('source0',input0),('source1',input1)):
|
||||
source=folder/version
|
||||
run(folder,source,cache,version+'-metadata',['cargo','metadata','--locked','--offline','--no-deps','--format-version=1'])
|
||||
run(folder,source,cache,version+'-clippy',['cargo','clippy','--locked','--offline',*cargo_packages(),'--all-targets','--','-D','warnings'])
|
||||
packages=['-p','rmm-agent','-p','rmm-privileged-helper']+(['-p','rmm-updater-worker'] if version=='source0' else [])
|
||||
run(folder,source,cache,version+'-release',['cargo','build','--locked','--offline','--release',*packages,'--bins'])
|
||||
output=folder/'artifacts'/version;output.mkdir(mode=0o700,parents=True)
|
||||
results[version]={}
|
||||
for label,binary in [('agent','rmm-agent'),('helper','rmm-privileged-helper')]+([('updater','rmm-agent-updater')] if version=='source0' else []):
|
||||
results[version][label]=copy_artifact(cache/'release'/binary,output/binary)
|
||||
require(capture(source,names)==inputs,'frozen source changed during build')
|
||||
if version=='source1':continue
|
||||
for label,package,selector in UNIT_TARGETS:
|
||||
raw=run(folder,source,cache,'units-'+label,['cargo','test','--locked','--offline','--no-run','--message-format=json','-p',package,*selector])
|
||||
found=[]
|
||||
for line in raw.splitlines():
|
||||
try:record=json.loads(line)
|
||||
except ValueError:continue
|
||||
if record.get('reason')=='compiler-artifact' and record.get('profile',{}).get('test') and record.get('executable'):
|
||||
found.append(record['executable'])
|
||||
require(len(found)==1,'one linked unit executable '+label)
|
||||
relative=Path(found[0]).relative_to('/target')
|
||||
artifact=copy_artifact(cache/relative,output/(label+'-tests'))
|
||||
listing=run(folder,source,cache,'list-'+label,[str(Path('/target')/relative),'--list','--format','terse']).decode()
|
||||
tests=[line[:-6] for line in listing.splitlines() if line.endswith(': test')]
|
||||
require(tests and len(set(tests))==len(tests),'complete unique native test names')
|
||||
allowed=SAFE_FILTERS.get(label,[])
|
||||
if label=='handoff':allowed=tests
|
||||
require(set(allowed)<=set(tests),'exact safe filter exists')
|
||||
artifact.update(all_tests=tests,allowed_native_tests=allowed,
|
||||
other_tests_not_authorized_by_this_pack=True,
|
||||
safety='Pure handoff/codec or own temporary portable SQLite fixture only; no product service/database/keys.' if allowed else 'Linked only; no VM execution authorized.')
|
||||
units[label]=artifact
|
||||
for index,name in enumerate(allowed):
|
||||
run(folder,source,cache,'focused-'+label+'-'+str(index),[str(Path('/target')/relative),'--exact',name,'--nocapture'])
|
||||
require(capture(source,names)==inputs,'frozen source changed during unit qualification')
|
||||
require(results['source0']['agent']['sha256']!=results['source1']['agent']['sha256']
|
||||
and results['source0']['helper']['sha256']!=results['source1']['helper']['sha256'],'real new codepair bytes required')
|
||||
manifest=dict(schema_version=1,case_id=ident,profile='linux_compatible_updater_buildpack_v1',
|
||||
builder=BUILDER,network='none',source_mount='read_only',cache=str(cache),
|
||||
source0_version='0.1.0',source1_version='0.1.1',changed_source1_files=['Cargo.toml','Cargo.lock'],
|
||||
inherited_packages=internal,external_dependencies_unchanged=True,
|
||||
source0_inputs_sha256=sha((folder/'source0-inputs.json').read_bytes()),
|
||||
source1_inputs_sha256=sha((folder/'source1-inputs.json').read_bytes()),
|
||||
source_files_count=len(names),artifacts=results,units=units,
|
||||
stable_updater=results['source0']['updater'],checks=dict(linux_source0_clippy=True,linux_source1_clippy=True,
|
||||
release_links=True,exact_test_lists=True,focused_local_contracts=True,frozen_inputs_after_build=True),
|
||||
windows_copied_only_not_qualified=True,native_vm_tested=False,
|
||||
bootstrap_installed=False,apply_executed=False,keys_generated=False,approvals_performed=False)
|
||||
write(folder/'manifest.json',encode(manifest))
|
||||
for version in ('source0','source1'):
|
||||
archive=folder/(version+'.tar.gz')
|
||||
with tarfile.open(archive,'w:gz') as output:
|
||||
for name in names:output.add(folder/version/name,arcname=name,recursive=False)
|
||||
archive.chmod(0o400)
|
||||
write(folder/'archive-hashes.json',encode({version:sha((folder/(version+'.tar.gz')).read_bytes()) for version in ('source0','source1')}))
|
||||
write(folder/'completed.json',encode(dict(manifest_sha256=sha((folder/'manifest.json').read_bytes()),native_vm_tested=False)))
|
||||
print(json.dumps(dict(completed=True,manifest=str(folder/'manifest.json'),manifest_sha256=sha((folder/'manifest.json').read_bytes()),artifacts=results)),flush=True)
|
||||
|
||||
def main():
|
||||
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=['build'])
|
||||
parser.parse_args();build()
|
||||
if __name__=='__main__':main()
|
||||
@@ -0,0 +1,120 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Explicit server-only release/baseline signing bootstrap; never installs policy.
|
||||
|
||||
Private release and Health keys remain on the server. No job/time key reuse,
|
||||
service restart, catalog mutation, grant or approval is performed by this tool.
|
||||
Prepared source: mutation phases require coordination by the owning Root task.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
from pathlib import Path
|
||||
import linux_updater_compatible_apply as bootstrap
|
||||
|
||||
def server(payload):
|
||||
import base64,datetime,hashlib,json,os,stat,subprocess,uuid
|
||||
from pathlib import Path
|
||||
require(os.geteuid()==0 and os.uname().machine=='aarch64','fixed Root ARM64 server')
|
||||
root=Path('/opt/rust-discovery/devstate');platform=payload.get('platform','linux');require(platform in('linux','windows'),'closed release key platform');release_dir=root/('agent-update-release-'+platform+'-v1');health_dir=root/'agent-update-health-v1'
|
||||
release_key=release_dir/'release.pem';health_key=health_dir/'health.pem';trust_dir=root/('agent-update-public-'+platform+'-v1')
|
||||
ident=str(uuid.UUID(payload['case_id']));case=root/('updater-signing-'+ident)
|
||||
def digest(raw):return hashlib.sha256(raw).hexdigest()
|
||||
def encode(value):return json.dumps(value,separators=(',',':'),ensure_ascii=False).encode()
|
||||
def run(args):return subprocess.check_output(args,stderr=subprocess.DEVNULL,timeout=10)
|
||||
def syncdir(path):
|
||||
fd=os.open(path,os.O_RDONLY|os.O_DIRECTORY)
|
||||
try:os.fsync(fd)
|
||||
finally:os.close(fd)
|
||||
def metadata(path):
|
||||
m=path.lstat();require(stat.S_ISREG(m.st_mode)and m.st_nlink==1 and stat.S_IMODE(m.st_mode)==0o600,'single protected key file');return [m.st_dev,m.st_ino,m.st_uid,m.st_gid,m.st_mode,m.st_nlink,m.st_size,m.st_mtime_ns,m.st_ctime_ns]
|
||||
def public(key):
|
||||
raw=run(['openssl','pkey','-in',str(key),'-pubout','-outform','DER']);require(len(raw)==44 and raw[:12]==bytes.fromhex('302a300506032b6570032100'),'Ed25519 public DER');return raw[12:]
|
||||
def store(name,value):
|
||||
path=case/name
|
||||
with path.open('xb')as stream:stream.write(encode(value));stream.flush();os.fsync(stream.fileno())
|
||||
syncdir(case)
|
||||
def b64(raw):return base64.urlsafe_b64encode(raw).rstrip(b'=').decode()
|
||||
def decode(text):
|
||||
raw=base64.urlsafe_b64decode(text+'='*((-len(text))%4));require(b64(raw)==text,'canonical Base64url');return raw
|
||||
if payload['action']=='public-separation':
|
||||
pin=Path('/etc/rmm-time-source/time-public-key.json');before=metadata(pin);require(before[2]==0 and before[6]<=8192,'original Root public time pin');raw=pin.read_bytes();require(metadata(pin)==before,'public time pin unchanged')
|
||||
time_key=json.loads(raw)['public_key_hex'];job_key=payload['job_public_key_hex'];require(all(len(v)==64 and set(v)<=set('0123456789abcdef')for v in(time_key,job_key))and time_key!=job_key,'independent actual Job/time public keys')
|
||||
return {'operation':'updater_signer_public_separation_v1','forbidden_public_key_sha256':sorted([digest(bytes.fromhex(v))for v in(time_key,job_key)]),'time_public_pin_sha256':digest(raw),'private_key_read':False,'services_changed':False,'job_authority':False}
|
||||
if payload['action']=='provision':
|
||||
forbidden=payload['forbidden_public_key_sha256'];require(len(forbidden)>=2 and len(forbidden)<=16 and len(set(forbidden))==len(forbidden)and all(len(v)==64 and set(v)<=set('0123456789abcdef')for v in forbidden),'independent Job/time public-key SHA256 values required, never role aliases')
|
||||
require(not release_dir.exists()and not trust_dir.exists()and not case.exists(),'create-only independent release signer namespace')
|
||||
owner=(root/'jobs/ed25519.pem').lstat().st_uid;require(owner==10001,'actual existing signer owner contract')
|
||||
case.mkdir(mode=0o700);store('provision-intent.json',{'release_dir':str(release_dir),'health_dir':str(health_dir),'forbidden_public_key_sha256':forbidden,'job_authority':False})
|
||||
health_origin=health_dir/'public-origin.json'
|
||||
reuse_health=health_dir.exists()
|
||||
if reuse_health:
|
||||
directory=health_dir.lstat();origin_meta=health_origin.lstat();require(stat.S_ISDIR(directory.st_mode)and directory.st_uid==owner and stat.S_IMODE(directory.st_mode)==0o700 and stat.S_ISREG(origin_meta.st_mode)and origin_meta.st_uid==0 and origin_meta.st_nlink==1 and stat.S_IMODE(origin_meta.st_mode)==0o600 and origin_meta.st_size<=4096,'original protected shared Health provenance')
|
||||
origin=json.loads(health_origin.read_text());require(origin['profile']=='shared_agent_update_health_v1'and metadata(health_key)==origin['private_metadata']and public(health_key).hex()==origin['public_key_hex'],'exact original shared Health key')
|
||||
for directory,key,uid in [(release_dir,release_key,0)]+([]if reuse_health else[(health_dir,health_key,owner)]):
|
||||
directory.mkdir(mode=0o700);fd=os.open(key,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600);os.close(fd)
|
||||
run(['openssl','genpkey','-algorithm','Ed25519','-out',str(key)]);os.chmod(key,0o600);os.chown(key,uid,uid);os.chown(directory,uid,uid)
|
||||
fd=os.open(key,os.O_RDONLY|os.O_NOFOLLOW)
|
||||
try:os.fsync(fd)
|
||||
finally:os.close(fd)
|
||||
syncdir(directory);syncdir(root)
|
||||
release=public(release_key);health=public(health_key);require(release!=health and digest(release)not in forbidden and digest(health)not in forbidden,'independent key domains')
|
||||
if not reuse_health:
|
||||
with health_origin.open('x')as stream:json.dump({'profile':'shared_agent_update_health_v1','public_key_hex':health.hex(),'private_metadata':metadata(health_key)},stream,sort_keys=True);stream.flush();os.fsync(stream.fileno())
|
||||
health_origin.chmod(0o600)
|
||||
syncdir(health_dir)
|
||||
other=root/('agent-update-release-'+('windows'if platform=='linux'else'linux')+'-v1/release-public.json')
|
||||
if other.exists():
|
||||
other_meta=other.lstat();require(stat.S_ISREG(other_meta.st_mode)and other_meta.st_uid==0 and stat.S_IMODE(other_meta.st_mode)==0o600 and other_meta.st_nlink==1 and other_meta.st_size<=4096,'other platform original public provenance');require(json.loads(other.read_text())['public_key_hex']!=release.hex(),'distinct platform release keys')
|
||||
with(release_dir/'release-public.json').open('x')as stream:json.dump({'platform':platform,'public_key_hex':release.hex(),'key_id':digest(release)},stream,sort_keys=True);stream.flush();os.fsync(stream.fileno())
|
||||
os.chmod(release_dir/'release-public.json',0o600)
|
||||
syncdir(release_dir)
|
||||
keyring=encode({'schema_version':1,'generation':1,'keys':[{'public_key_hex':release.hex(),'platform':'x86_64-unknown-linux-gnu'if platform=='linux'else'x86_64-pc-windows-msvc','first_sequence':1,'last_sequence':2,'revoked':False}]})
|
||||
trust_dir.mkdir(mode=0o700);os.chown(trust_dir,owner,owner)
|
||||
fd=os.open(trust_dir/'keyring.json',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
||||
with os.fdopen(fd,'wb')as stream:os.fchown(stream.fileno(),owner,owner);stream.write(keyring);stream.flush();os.fsync(stream.fileno())
|
||||
syncdir(trust_dir);syncdir(root)
|
||||
result={'schema_version':1,'profile':'agent_updater_separate_signers_v1','platform':platform,'shared_health_key_reused':reuse_health,'case_id':ident,'release_key_id':digest(release),'release_public_key_hex':release.hex(),'keyring_base64url':b64(keyring),'keyring_sha256':digest(keyring),'public_keyring_host_path':str(trust_dir/'keyring.json'),'public_keyring_metadata':metadata(trust_dir/'keyring.json'),'keyring_recipient_roles':['api','gateway'],'health_pin':{'schema_version':1,'key_id':digest(health),'public_key_hex':health.hex()},'release_private_metadata':metadata(release_key),'health_private_metadata':metadata(health_key),'health_recipient_role':'gateway','health_recipient_uid':owner,'gateway_mount_pending':True,'services_changed':False,'job_authority':False}
|
||||
store('provision-result.json',result);return result
|
||||
require(case.is_dir(),'existing explicit signer case')
|
||||
provision=json.loads((case/'provision-result.json').read_text());require(provision['case_id']==ident and provision['platform']==platform and public(release_key).hex()==provision['release_public_key_hex']and public(health_key).hex()==provision['health_pin']['public_key_hex'],'original independent keys')
|
||||
require(metadata(release_key)==provision['release_private_metadata']and metadata(health_key)==provision['health_private_metadata'],'protected private key metadata unchanged')
|
||||
require(metadata(trust_dir/'keyring.json')==provision['public_keyring_metadata']and digest((trust_dir/'keyring.json').read_bytes())==provision['keyring_sha256'],'original protected public keyring')
|
||||
if payload['action']=='readback':return provision
|
||||
require(payload['action']in('sign-release','sign-baseline'),'fixed signing purpose only')
|
||||
require(platform=='linux','Windows signing awaits a separately qualified actual MSVC source pair; never relabel GNU')
|
||||
raw=decode(payload['canonical_payload_base64url']);require(len(raw)<=32768 and digest(raw)==payload['payload_sha256'],'exact typed public payload')
|
||||
doc=json.loads(raw)
|
||||
artifacts={1:[('7fef8d0f1e2bcf5cd6c373e567a0c17bfb08d8c780cd4d1925b6c1355e572547',16275360),('8fdc6ded02278eb18e64003d0bc7bf45d452cd48ded0450e6e900ca66e44d449',13325104)],2:[('4d212066bef226af3fa679ffe95f69c43a9668cbef7e665d53328f4e41aa3799',16273896),('89b28db3afe870c667297dff97ad7a042c550ccce1f712d69108e8de672ad450',13322944)]}
|
||||
if payload['action']=='sign-release':
|
||||
sequence=doc['release_sequence'];require(sequence in(1,2)and doc['schema_version']==1 and doc['version']==('0.1.0'if sequence==1 else'0.1.1')and doc['platform']=='x86_64-unknown-linux-gnu'and doc['protocol_major']==1 and doc['state_schema']==1 and doc['minimum_updater_version']==1,'exact compatible release profile')
|
||||
require(str(uuid.UUID(doc['release_id']))==doc['release_id']and doc['release_id']!='00000000-0000-0000-0000-000000000000','release identity')
|
||||
require(abs(int(datetime.datetime.now(datetime.timezone.utc).timestamp())-doc['published_at'])<300 and doc['expires_at']-doc['published_at']==604800,'bounded initial release dates')
|
||||
require(len(doc['artifacts'])==2 and [a['role']for a in doc['artifacts']]==['agent','helper']and [(a['sha256'],a['bytes'])for a in doc['artifacts']]==artifacts[sequence],'exact frozen source artifact hashes')
|
||||
ids=[str(uuid.UUID(a['artifact_id']))for a in doc['artifacts']];require(len(set(ids))==2 and all(v!='00000000-0000-0000-0000-000000000000'for v in ids),'distinct artifact identities')
|
||||
prefix=b'rmm.agent-release.v1\0';name='release-'+str(sequence)
|
||||
else:
|
||||
require(doc['schema_version']==1 and doc['profile']=='decoder_compatible_handoff_v1'and doc['platform']=='x86_64-unknown-linux-gnu'and doc['activation_floor']==1 and doc['previous_record_sha256']is None and doc['rolled_back']is False,'initial compatible baseline only')
|
||||
prior=json.loads((case/'release-1-result.json').read_text());require(doc['release_envelope']==prior['envelope']and doc['manifest_sha256']==prior['payload_sha256'],'exact original signed baseline release')
|
||||
qualification=decode(payload['qualification_base64url']);q=json.loads(qualification)
|
||||
require(q['profile']=='linux_compatible_baseline_qualification_v1'and q['normal_signed_sync_observed']and q['ready']is False and q['helper_ready']is False and q['unlock']is False and q['job_authority']is False,'independent actual compatible qualification, never a lease')
|
||||
require([s['service']for s in q['services']]==['agent','general','full']and [s['process']['image_sha256']for s in q['services']]==[artifacts[1][0][0],artifacts[1][1][0],artifacts[1][1][0]],'actual compatible initial code pair')
|
||||
require(doc['activation_evidence']=={'kind':'bootstrap','qualification_receipt_sha256':digest(qualification)},'exact public qualification hash')
|
||||
observed=datetime.datetime.fromisoformat(q['observed_at'].replace('Z','+00:00'));require(observed.tzinfo is not None and int(observed.timestamp())==doc['activated_at'],'actual baseline activation time')
|
||||
prefix=b'rmm.agent-update-baseline.v1\0';name='baseline'
|
||||
require(not(case/(name+'-intent.json')).exists(),'existing signing intent means readback only')
|
||||
store(name+'-intent.json',{'payload_sha256':digest(raw),'purpose':payload['action'],'job_authority':False})
|
||||
message=case/(name+'.message');signature=case/(name+'.signature')
|
||||
with message.open('xb')as stream:stream.write(prefix+raw);stream.flush();os.fsync(stream.fileno())
|
||||
run(['openssl','pkeyutl','-sign','-rawin','-inkey',str(release_key),'-in',str(message),'-out',str(signature)])
|
||||
signed=signature.read_bytes();require(len(signed)==64,'Ed25519 signature')
|
||||
public_der=case/(name+'.public.der')
|
||||
with public_der.open('xb')as stream:stream.write(bytes.fromhex('302a300506032b6570032100')+bytes.fromhex(provision['release_public_key_hex']));stream.flush();os.fsync(stream.fileno())
|
||||
run(['openssl','pkeyutl','-verify','-rawin','-pubin','-keyform','DER','-inkey',str(public_der),'-in',str(message),'-sigfile',str(signature)])
|
||||
result={'schema_version':1,'key_id':provision['release_key_id'],'payload_sha256':digest(raw),'envelope':{'schema_version':1,'key_id':provision['release_key_id'],'payload_bytes':b64(raw),'signature':b64(signed)},'job_authority':False}
|
||||
store(name+'-result.json',result);return result
|
||||
|
||||
def main():
|
||||
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('public-separation','provision','readback','sign-release','sign-baseline'));parser.add_argument('--input',type=Path,required=True);args=parser.parse_args()
|
||||
p=json.loads(args.input.read_text());p['action']=args.action
|
||||
print(json.dumps(bootstrap.native_rpc(server,p,config='server.conf')))
|
||||
if __name__=='__main__':main()
|
||||
@@ -160,3 +160,93 @@ Ein eigener Runner ist ausschließlich für zwei eigene native Prozessfixtures
|
||||
vorbereitet; er ist noch nicht ausgeführt. Details, frühere fehlgeschlagene
|
||||
Fixtureprüfung und verbleibende MVP-Gates stehen im
|
||||
[Readercensusnachweis](agent-updater-reader-census-results.md).
|
||||
|
||||
## Quellenfortschreibung 2026-11-16: Full-Admission und stabiler Linux-Daemon
|
||||
|
||||
Die zuvor fehlende Quellverbindung enthält jetzt einen getrennten festen
|
||||
`rmm-agent-updater --serve`-Einstieg und eine Systemd-Vorlage. Der Dienst erhält
|
||||
keine Jobfreigabe-API. Die vorhandene Full-Helperstrecke prüft die vollständig
|
||||
vorab geladenen Agent-/Helperdateien unabhängig vom Netzwerkagenten und legt
|
||||
vier exakt gebundene Root-Stages an. Erst danach speichert die bestehende
|
||||
HelperSync-Transaktion unter derselben Original-Executorsperre Consumption,
|
||||
Startzeuge, Handoff, Delegation und StopIntent atomar. Die Antwort
|
||||
`agent_update_handoff_accepted_v1` ist ausdrücklich kein Outcome und enthält
|
||||
`ready=false` und `terminal=false`. Der Helper antwortet zuerst dem Agenten;
|
||||
erst anschließend aktiviert er einmal den tatsächlich gebundenen Updater.
|
||||
Die Cloud-VM wurde dadurch noch nicht aktualisiert.
|
||||
|
||||
Die Quellstrecke erhält auch den aktuellen TLS-Selektor und die tatsächlich
|
||||
aktive Zertifikatsversion anhand von Dateimetadaten. Sie liest dabei keine
|
||||
privaten Schlüsselbytes. Ein fester, descriptor-relativ geöffneter
|
||||
Agent-Cachepfad bleibt auf UID 993 und den bestehenden privaten Agent-Statebaum
|
||||
beschränkt; die Root-Installationsverzeichnisse behalten ihre eigene strenge
|
||||
Root-Pfadauflösung.
|
||||
|
||||
Der zusätzliche Full-Aufruf `update_observe_v1` ist ausschließlich lesend.
|
||||
Er prüft die tatsächliche HelperSync-Lease, Baseline/Release-Trust, Historie,
|
||||
Floor, feste Dienstgenerationen, Readerregistry und den laufenden Updater.
|
||||
Ein optionaler Kandidat wird als ursprünglicher ReleaseEnvelope mit eigener
|
||||
Keyringgeneration entgegengenommen und unabhängig geprüft. Erst danach rendert
|
||||
Full die genaue Kandidaten-Konfiguration und den Pin für die spätere
|
||||
WebUI-Anzeige. Katalogmetadaten allein liefern keinen CandidatePreview. Der
|
||||
Aufruf lädt keine Binärdateien, legt keine Stage an und schreibt keine
|
||||
Start-/Handoff-/Ready-Zeile.
|
||||
|
||||
Der V2-Rückweg ist im Linux-Worker für den konkret unterscheidbaren Fall eines
|
||||
nach einmal bestätigt dispatchtem Start gescheiterten neuen Full-Helfers
|
||||
verbunden. Ein vorher im ersten LedgerReturnIntent reservierter bedingter Stop
|
||||
beendet ausschließlich die tatsächlich gehaltene neue General-Generation.
|
||||
Agent/Full ohne erfolgreichen Start erhalten getrennte negative Belege und
|
||||
keine erfundenen erfolgreichen Stops. Erst nach beendetem Reader, beiden
|
||||
ursprünglichen Sperren und erneutem vollständigen FD-/maps-Census öffnet der
|
||||
Updater wieder das Originalledger. Die vier Dateien werden in Gegenrichtung
|
||||
über getrennte create-once Intents zurückgeführt; Kandidat und Vorgänger bleiben
|
||||
erhalten. Ein tatsächlich neu gestarteter Vorgänger-Full muss die ursprüngliche
|
||||
signierte Healthstrecke erneut bestehen. Sein abschließendes Updateergebnis ist
|
||||
`failed / AGENT_UPDATE_RETURNED_TO_PREDECESSOR`; der ursprüngliche aktive Record
|
||||
und Floor werden nicht neu publiziert. Verlorene Antworten, unklare Renames,
|
||||
automatischer Restart und nicht nachgewiesene Dienstzustände bleiben gesperrt.
|
||||
Andere Startup-/Healthfehlerpfade sind durch diese Quellenfortschreibung noch
|
||||
nicht als real ausgeführte Wiederherstellung qualifiziert.
|
||||
|
||||
Bei der Verbindung wurde ein konkreter Dienstbeobachtungsfehler korrigiert:
|
||||
der Systemd-Aufruf fragt sieben Eigenschaften ab, der bisherige Parser verlangte
|
||||
acht. Der Parser verlangt jetzt genau die tatsächlich angefragten sieben Namen
|
||||
und verweigert fehlende, zusätzliche und doppelte Eigenschaften.
|
||||
|
||||
Lokal tatsächlich ausgeführt: Helperbibliothek 42/42 bestanden, einschließlich
|
||||
des neuen typisierten Handoff-Acknowledgement-Gegenfalls. Der erste breite Lauf
|
||||
hatte sechs APT-Fixturefehler wegen des fehlenden privaten Verzeichnisses
|
||||
`/tmp/opencode`; mit diesem Fixtureverzeichnis bestanden alle 42. Ein erster
|
||||
Updater-Linux-Lauf bestand 5/7 und scheiterte bei zwei Dateifixtures am absichtlich
|
||||
schreibgeschützten Container-`/run`. Diese Fehlversuche sind kein nativer
|
||||
Zielnachweis. Der weitere Quellencheck und die getrennte reale Linux-first-
|
||||
Abnahme werden separat ergänzt. Keine Applycapability und kein erfolgreicher
|
||||
Cloud-Apply werden aus diesen lokalen Ergebnissen abgeleitet.
|
||||
|
||||
Mit privaten Container-Tmpfs für `/tmp`, `/run` und `/var/lib` bestand anschließend
|
||||
der vollständige betroffene Lauf: Helper 42, Updater-Linux 7, Worker 12, insgesamt
|
||||
61 bestanden, 0 Fehler, 0 ignoriert. Zuvor scheiterte zusätzlich ein Workerfixture am
|
||||
schreibgeschützten Container-`/var/lib`; auch diese Ursache wurde durch die
|
||||
korrekte eigene Fixtureumgebung beseitigt. Der abschließende all-targets-Clippy-
|
||||
Lauf für Helper und Worker mit `-D warnings` und `git diff --check` bestand.
|
||||
Diese Tests enthalten ausdrücklich Containerfixtures mit festen privaten
|
||||
Statepfaden; die vollständigen Testbinaries dürfen deshalb nicht gegen die
|
||||
bestehenden installierten Statepfade der Cloud-VM gestartet werden. Der reine
|
||||
Sieben-Eigenschaften-Parsertest benötigt keine Systemd-/Dateieffekte.
|
||||
|
||||
Die zusätzliche ursprüngliche Updater-Zeitgeneration und der tatsächlich
|
||||
angewandte Pre-Stop-Syncbeleg sind separat in
|
||||
[Originalzeitgeneration](updater-original-time-generation.md) beschrieben.
|
||||
Auch diese Quellverbindung ist noch keine reale Applyabnahme.
|
||||
|
||||
Am 16. November wurde die öffentliche deterministische Recordzusammensetzung
|
||||
in `rmm-domain::agent_update_provisioning::assemble_updated_record` gemeinsam
|
||||
genutzt. Sie liefert ausschließlich bereits öffentliche Recordmetadaten;
|
||||
die privaten nativen BuiltRecord-Konstruktoren behalten ihre unabhängigen
|
||||
Original-/Healthsignatur- und Guardprüfungen. Der Linux-Namespacevertrag
|
||||
bleibt unverändert. Tatsächliche isolierte Nachprüfung: Agent und Worker
|
||||
mit allen Targets/Clippy `-D warnings` bestanden; beide bestehenden
|
||||
Record-Namespaceprüfungen (Originalinode/Archive sowie Ablehnung fremder
|
||||
Dateiidentitäten) bestanden, 2/2, keine ignoriert. Dafür wurde ausschließlich
|
||||
der private Container-`/run`-Scratch verwendet, keine VM-Datei verändert.
|
||||
|
||||
@@ -0,0 +1,237 @@
|
||||
# Linux-Updater: erhaltender Bootstrap und erste reale Abnahme
|
||||
|
||||
Stand 16. November 2026. **Plan und tatsächliche lesende Vorprüfung; noch keine
|
||||
Installation, kein Dienstwechsel und kein Apply.** Der koordinierende
|
||||
Rootprozess führt Zieländerungen und WebUI-Abnahmen durch. Die neue Datei
|
||||
`deploy/linux_updater_bootstrap.py` besitzt ausschließlich `inspect` und lokale
|
||||
Paketvorbereitung `prepare`; sie implementiert keinen versteckten Applymodus.
|
||||
|
||||
## Tatsächlich gelesen
|
||||
|
||||
`python3 deploy/linux_updater_bootstrap.py inspect` las die bestehende
|
||||
Cloud-Linux-VM über den vorhandenen streng geparsten SSH-Zugang mit bestätigtem
|
||||
Hostschlüssel. Der private Originalbeleg liegt in
|
||||
`devstate/linux-updater-bootstrap/eb9ad00e-0229-4ebf-8ba4-09861bb246c5/read-only.json`.
|
||||
Boot: `45aba743-be1d-4ae5-ba00-139fb9363bfe`.
|
||||
|
||||
| Gegenstand | Tatsächlicher Zustand |
|
||||
|---|---|
|
||||
| Agent | aktiv/enabled, SHA256 `0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f` |
|
||||
| General/Full | beide aktiv, gemeinsame Binary `79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf`; General enabled, Full disabled |
|
||||
| Updater | Unit, Binary, Konfigurations- und Stateverzeichnis fehlen |
|
||||
| APT/Legacy | inaktiv/disabled, keine beobachteten General-Rollbacktimer |
|
||||
| Agentjournal | 30 Aufträge, kein offener Auftrag, kein Fault, Integrität ok |
|
||||
| Agentverbrauch | 27 Verbräuche und 27 Startzeugen, kein offener Verbrauch |
|
||||
| Rootverbrauch | 19 Verbräuche und 19 Startzeugen, kein offener Verbrauch/Fault |
|
||||
|
||||
Die Root-Evidenzaggregate blieben lesend gebunden an
|
||||
`def53ce39f60ebe6815352df2ef1980d5170569519bbca0a9e132d3eecb470d1`,
|
||||
die Agent-Evidenz an
|
||||
`61e54815aecb8b5625ff7a8e5b09a5a509ba39d23f3682ad5c969bcb93ff7836`.
|
||||
Dies sind Hashes der auf dem Ziel gehashten Originalstart-/Outcomebytes mit
|
||||
Grantbezug, kein Export von Jobausgaben. Die Vorprüfung exportiert ausschließlich
|
||||
öffentliche Konfigurationsfelder, feste Unit-/Binärhashes und Dateimetadaten.
|
||||
Private Schlüssel und Agentumgebungsdatei wurden ausschließlich `stat`-geprüft.
|
||||
Die vorhandenen Datenbanken wurden read-only im tatsächlich vorhandenen
|
||||
DELETE-Journalmodus geöffnet; es entstanden keine WAL-/SHM-Sidecars.
|
||||
|
||||
Der erste lesende Versuch stoppte beim Stabilitätsvergleich einer öffentlichen
|
||||
Datei, weil der Vergleich auch die durch Lesen veränderliche atime einschloss.
|
||||
Die Korrektur vergleicht Identität, Größe, mtime und ctime; der nächste vollständige
|
||||
Read bestand. Der TLS-Selektor wird anhand seines tatsächlichen Felds `version`
|
||||
behandelt. Kein fehlgeschlagener Read wurde als Bootstraperfolg ausgegeben.
|
||||
|
||||
## Verbindliche Reihenfolge
|
||||
|
||||
Die bisherigen Images sind kein geeigneter Rückfall für den neuen Updater:
|
||||
ihnen fehlen Decoder-/Owner-/Healthteile. Deshalb zunächst **kompatible neue
|
||||
Baseline**, erst anschließend ein separat genehmigtes Update auf andere Bytes.
|
||||
„Release 0“ bezeichnet unten die Baselinegeneration mit positiver Sequenz 1;
|
||||
Sequenz 0 ist im Releasecodec ungültig.
|
||||
|
||||
1. Den gemeinsamen Quellsatz einfrieren. Agent, Helper und stabilen Updater für
|
||||
Linux x86-64 bauen, genaue Quellen-/Listen-/Hashbelege aufbewahren und die
|
||||
dafür vorgesehenen nicht destruktiven Vertragsprüfungen zuerst auf der
|
||||
tatsächlichen Cloud-Linux-VM ausführen. Containerfixtures, die feste vorhandene
|
||||
Agent-Statepfade voraussetzen, dort ausdrücklich nicht starten.
|
||||
2. Einen frischen Ziel-CAS und den zentral geschlossenen Devtestscope prüfen.
|
||||
Agent, General und Full in einem begrenzten administrativen Dienstwechsel
|
||||
stoppen; APT/Legacy bleiben geschlossen. Beide ursprünglichen Sperren halten.
|
||||
DB-Dateien, Identität, PKI und sämtliche Originalzeilen/Outcomebytes erhalten.
|
||||
Alte Binaries create-only als historische Bootstrapbelege aufbewahren.
|
||||
3. Die kompatiblen neuen Agent-/Helperbytes an den bisherigen festen Zielpfaden
|
||||
bereitstellen und den Full-Konfigurations-/Policy-/Binärpin auf genau diese
|
||||
Helperbytes binden. Generalpolicy und Generalpin bleiben erhalten. Keine
|
||||
APT-Rezept-/Proofanpassung und kein Paketjob. Eine geänderte gemeinsame
|
||||
Helperbinary ist **kein** neuer APT-Laufzeitqualifikationsnachweis.
|
||||
4. General, Full und Agent genau einmal starten, tatsächliche neue PID/Birth/
|
||||
Image-/Unitzeugen lesen, normale signierte Agent-/Helpersynchronisierung und
|
||||
passives Inventar nachweisen. Erst daraus den öffentlichen tatsächlichen
|
||||
Baselinequalifikationsbeleg bilden; er enthält keinen Hash einer noch zu
|
||||
erzeugenden Baseline/Registry/Policy, sodass keine Hashzirkularität entsteht.
|
||||
5. Auf dem Server getrennte Release-/Baselinesignier- und Healthschlüssel
|
||||
erzeugen. Keine privaten Schlüssel verlassen den Server. Der Releasekey
|
||||
bleibt Root vorbehalten; der separate Healthkey wird ausschließlich dem
|
||||
vorhandenen unprivilegierten Gateway-Dienst als geschützte PEM-Datei zugänglich
|
||||
gemacht. Der tatsächliche Handler `/agent/v1/update-health` läuft im Gateway.
|
||||
Job- und Zeitsignierer werden nicht wiederverwendet.
|
||||
6. Release-0-Manifest exakt für die kompatibel installierten Agent-/Helperbytes
|
||||
signieren, daraus den kanonischen Initialrecord mit Sequenz/Floor 1,
|
||||
tatsächlicher Aktivierungszeit, Bootstrapqualifikationshash und
|
||||
`rolled_back=false` bilden und separat signieren. Identität und bestehende
|
||||
Journale werden nicht durch diese Recorddatei ersetzt.
|
||||
7. Die neue feste Updaterunit installieren, reale Unit-Inodes/Kompositionen
|
||||
nachlesen und die vollständige 21-Unit-Registry plus tatsächliche etwaige
|
||||
Rollbacktimer erzeugen. Geschützte Registry enthält den Baselinebeleg und
|
||||
den unveränderten Readervertrag; dazu die tatsächlichen PID-/User-/Cgroup-
|
||||
Namespace-/Procidentitäten. Erst dann Registryhash und signierte Baseline
|
||||
in der lokalen Policy binden. Keine Unit-Pins aus einem Quelltext statt der
|
||||
tatsächlich installierten Dateien übernehmen.
|
||||
8. Den Updater einmal als eigenes Root-Systemd-Programm starten; sein eigener
|
||||
PID/Birth/Image/Unitbeleg muss passen. Danach den Full-Aufruf
|
||||
`update_observe_v1` als tatsächlicher UID-993-Agent prüfen. Nur daraus
|
||||
gültige Apply-/Checkcapabilities und CandidatePreview veröffentlichen.
|
||||
9. Release 1 als tatsächlich neue Codepaarbytes bauen, beispielsweise aus
|
||||
demselben eingefrorenen Runtimequellsatz mit sauberer Version 0.1.1 und
|
||||
eigener nachvollziehbarer Buildprovenienz. Der bereits gebundene stabile
|
||||
Updater bleibt unverändert. Full rendert den neuen Konfigurations-/Pinwechsel
|
||||
aus dem unabhängig geprüften Kandidaten. Veröffentlichung im bestehenden
|
||||
Tenantkatalog erzeugt noch keinen ausführbaren Job.
|
||||
10. MCP muss einen persistenten `pending_approval`-Plan für genau diese Bytes
|
||||
erstellen. Der tatsächliche sichtbar simulierte Devtest-WebUIprincipal
|
||||
genehmigt interaktiv. Vorher keine Jobwirkung oder Startgrants. Danach
|
||||
genau einen ursprünglichen Verbrauch, Staging, Stop/Lock/Census/Swap/Start,
|
||||
neuen unabhängigen signierten Sync-/Baseinventar-Healthbeleg und endgültigen
|
||||
Originalrecord-/Floor-/Outcomestand prüfen. Nach diesem Abnahmeschritt
|
||||
Dokumentation und Code nach Gitea pushen.
|
||||
|
||||
## Pfade und Berechtigungen
|
||||
|
||||
| Pfad | Geplante Bindung |
|
||||
|---|---|
|
||||
| `/usr/local/libexec/rmm-agent-updater` | qualifiziertes stabiles ELF, Root:Root, 0755; nie Teil des Job-Codepaars |
|
||||
| `/etc/systemd/system/rmm-agent-updater.service` | feste geprüfte Rootunit, 0644, kein automatischer Wiederanlauf eines unsicheren Handoffs |
|
||||
| `/etc/rmm-agent-updater` | Root:Root, 0755; keine Schreibrechte für Agent/Gruppe/Andere |
|
||||
| `binding.json` dort | vorhandenes öffentliches Binding, Root:Root 0600 |
|
||||
| `policy.json`, `keyring.json`, `health-key.json` dort | öffentliche geschützte Trustmetadaten, Root:Root 0644 |
|
||||
| `reader-registry.json`, `retained-files.json` dort | feste lokal provisionierte tatsächliche Belege; Root besitzt die Schreibautorität |
|
||||
| `/var/lib/rmm-agent-updater` | ursprünglicher privater Record-FS-Vertrag: Root:Root 0700 |
|
||||
| `installed-record.json`, Recordarchive/Handoffs | private Rootdateien/-verzeichnisse, 0600/0700; keine öffentliche Projektion |
|
||||
| Agentcache | fester vorhandener UID-993-Statebaum; neue Unterverzeichnisse 0700, Prefetchdateien 0600 |
|
||||
|
||||
Der Agent erhält die **öffentlichen Recordbytes** über dieselbe authentisierte
|
||||
Full-Antwort wie den aktuellen gemessenen Zustand. Hash, Binding und exakte
|
||||
Predecessor-/Floorwerte werden geprüft. Der bestehende private Recordport wird
|
||||
hierfür nicht auf öffentliche Dateirechte umgestellt. Full schreibt dabei nichts.
|
||||
|
||||
Die Retainedliste bindet mindestens die drei bestehenden DB-Dateien, zwei
|
||||
ursprünglichen Locks, öffentliche Binding-/Identitäts-/Jobkeydateien, die
|
||||
Original-PKI-Dateien sowie den tatsächlichen TLS-Selektor und die aktuell aktive
|
||||
TLS-Version. Für Schlüssel ausschließlich Dateimetadaten, nie Schlüsselbytes.
|
||||
Unit-/Binär-/Trustdateien erhalten ihre getrennten eigenen Hash-/FD-Pins.
|
||||
|
||||
## Bekannter kontrollierter Fehlerfall
|
||||
|
||||
Der vorbereitete Linuxrückweg qualifiziert zunächst einen tatsächlich gescheiterten
|
||||
neuen Fullstart nach bereits erfolgreichem Generalstart. Ein allgemeines
|
||||
`exit 1`-Helperfixture genügt dafür nicht: dieselbe Binary bedient beide Rollen
|
||||
und würde bereits General scheitern lassen. Ein separater privater, signierter
|
||||
Fixturequellsatz muss General normal bedienen und ausschließlich den neuen
|
||||
Fullstart vor Arbeitsaufnahme eindeutig beenden; kein Produktions-Failureflag
|
||||
oder versteckter ausführbarer Sonderkanal wird dafür eingeführt.
|
||||
|
||||
Die derzeitige Fullunit hat `Restart=on-failure` mit 5 Sekunden. Ein solcher
|
||||
weiter geplanter automatischer Wiederanlauf ist kein bekannter geschlossener
|
||||
Fehler. Für diesen Test muss bereits **vor Baseline/Registry** ein ausdrücklich
|
||||
geprüfter `Restart=no`-Full-Override zum qualifizierten kompatiblen Setup gehören,
|
||||
oder ein tatsächlich terminaler Startlimitfall unabhängig bewiesen sein.
|
||||
Eine nachträgliche ungepinnte Unitänderung während des Updatejobs ist verboten.
|
||||
Die tatsächlichen negativen Start-/Stopbelege, Rückführung beider Codeversionen,
|
||||
Originalfristen sowie frisch signierte Vorgänger-Health müssen anschließend
|
||||
nativ bestehen. Unklare Rename-/Socket-/Startantworten bleiben Unknown und
|
||||
werden weder wiederholt noch als bekannte Rückführung ausgegeben.
|
||||
|
||||
## Stand der Ausführung
|
||||
|
||||
Tatsächlich abgeschlossen sind der lesende Zielbeleg, lokale
|
||||
Python-Syntaxprüfung der Vorbereitung und das unten abgegrenzte lokale Buildpack.
|
||||
Quell- und Containerprüfungen der Runtime
|
||||
stehen separat in [Runtimequellen](agent-updater-runtime-source.md). Bootstrap,
|
||||
Schlüsselprovisionierung, neuer Dienststart, passiver qualifizierter Fullbeleg,
|
||||
WebUI-genehmigter Apply und native Rückführung sind **geplant, nicht ausgeführt**.
|
||||
|
||||
## Eingefrorenes Linux-Buildpack, tatsächlich lokal gebaut
|
||||
|
||||
`deploy/linux_updater_qualification.py build` erstellte den unveränderten Fall
|
||||
`devstate/linux-updater-qualification/21d20391-6102-4996-8a7a-efbd3e78bd7d`.
|
||||
615 öffentliche Eingabedateien wurden mit vorherigem/nachherigem Hashvergleich
|
||||
eingefroren; Zugangsdaten, Devstate und Schlüssel gehören nicht zum Paket.
|
||||
Source0 verwendet Workspaceversion 0.1.0. Source1 unterscheidet sich ausschließlich
|
||||
in `Cargo.toml` und den erbenden internen Paketversionen in `Cargo.lock` (0.1.1).
|
||||
Externe Abhängigkeiten bleiben exakt gleich. Windowsquellen wurden ausschließlich
|
||||
als Provenienz mitkopiert; dieser Linuxlauf qualifiziert sie nicht.
|
||||
|
||||
Beide Quellsätze bestanden `cargo clippy --locked --offline` mit `--all-targets
|
||||
-- -D warnings` für Agent, Agentcore, Domain, Helper, Linuxupdater, Worker,
|
||||
Handoff und Updatehistory. Source0 linkte Agent, Helper und stabilen Updater als
|
||||
Release; Source1 Agent und Helper. Beide neuen Paarbytes unterscheiden sich
|
||||
tatsächlich von Source0. Der stabile Updater wird ausschließlich aus Source0
|
||||
verwendet. Alle Befehle liefen ohne Netzwerk in Docker mit schreibgeschütztem
|
||||
Sourcebaum, eigenem Targetcache und gepinntem Builder
|
||||
`sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6`.
|
||||
|
||||
| Artefakt unter `artifacts/` im Fall | SHA-256 |
|
||||
|---|---|
|
||||
| `source0/rmm-agent` | `61a073f44be95a9e2a9edf816104fa198452f9512bc099b59b4931000fc98b1e` |
|
||||
| `source0/rmm-privileged-helper` | `8fdc6ded02278eb18e64003d0bc7bf45d452cd48ded0450e6e900ca66e44d449` |
|
||||
| `source0/rmm-agent-updater` | `dec6336728eac8af1e0d84d4921c7c9ecbcc45bc4619d357d346b716336be90a` |
|
||||
| `source1/rmm-agent` | `c27319f312294f96583a2ecb14c9b1ed0b54e205c70dcd156ae511a1dc254e63` |
|
||||
| `source1/rmm-privileged-helper` | `89b28db3afe870c667297dff97ad7a042c550ccce1f712d69108e8de672ad450` |
|
||||
|
||||
Manifesthash: `9ed5f153fe76665150aaab298c4b21d74d7199b2312a28fa23aa9e30b13ddd08`.
|
||||
Source0-Archiv: `9b9e16c754f233c8675057aa44f89f86c2574ced0ba9d85d60157402363008de`;
|
||||
Source1-Archiv: `b2bdf4962a1beacf27903263952f4db025dbadfd7705fecc0b02dea3b32dde61`.
|
||||
Die vollständigen Einzeldateimanifeste und exakten Docker-/Cargoargumente samt
|
||||
Exitcodes und Loghashes liegen im Fall. Acht Unit-/Integrationsexecutables
|
||||
wurden gebaut und ihre tatsächlichen Testnamen aufgezeichnet. Nur die im
|
||||
Manifest explizit aufgeführten 18 Filter sind für den nächsten VM-Schritt
|
||||
vorgesehen: sieben zielgerichtete Parser-/Ack-/Sync-/SQLiteverträge und elf reine
|
||||
Handoffverträge. Diese 18 liefen im isolierten lokalen Container erfolgreich.
|
||||
Andere gelinkte Tests sind durch dieses Paket nicht zur Zielausführung vorgesehen.
|
||||
Noch keines dieser Programme wurde durch diesen Buildschritt auf der Cloud-VM
|
||||
ausgeführt; kein Produktdienst oder Zieljournal wurde geändert.
|
||||
|
||||
Diese Aussage beschreibt ausschließlich den damaligen Buildschritt. Der spätere
|
||||
koordinierte native Lauf aller 18 vorgesehenen Filter auf der Cloud-Linux-VM
|
||||
bestand; dessen Originalbelege und Abgrenzung stehen in
|
||||
[Compatible-Linux-Vertragsprüfungen](updater-compatible-linux-contracts.md).
|
||||
Er ersetzt weiterhin keinen tatsächlichen Updaterjob.
|
||||
|
||||
Der erste erhaltene Fall `7c030441-81e0-4235-9565-0b413b0cedae` scheiterte
|
||||
an `items_after_test_module` im Linuxunit-Testtarget. Das Parser-Testmodul wurde
|
||||
ohne Verhaltensänderung ans Dateiende verschoben; der erfolgreiche Fall entstand
|
||||
anschließend aus einem neuen Snapshot. Der fehlgeschlagene Originalbeleg bleibt
|
||||
erhalten.
|
||||
|
||||
## ARM64-Serverbuild, geplant und nicht ausgeführt
|
||||
|
||||
Der Source0-Quellsatz enthält auch den aktuellen Server-/Zeitbrokerquellcode.
|
||||
Für die später separat koordinierte Serverbereitstellung muss dieser exakte
|
||||
Archivhash auf dem ARM64-Server geprüft und jede reguläre Archivdatei gegen
|
||||
`source0-inputs.json` geprüft werden. Der vorhandene ARM64-Rustbuilder wird erst
|
||||
mit `docker image inspect` auf Architektur/OS/Image-ID geprüft und danach über
|
||||
seine tatsächliche Image-ID angesprochen. In einem neuen eigenen Targetcache
|
||||
und ohne Netzwerk sind dort geplant:
|
||||
|
||||
```text
|
||||
cargo clippy --locked --offline -p rmm-server -p rmm-time-broker-linux --all-targets -- -D warnings
|
||||
cargo build --locked --offline --release -p rmm-server -p rmm-time-broker-linux --bins
|
||||
```
|
||||
|
||||
Der Container erhält den verifizierten Quellsatz ausschließlich lesend sowie
|
||||
private temporäre Verzeichnisse. Artefakte müssen anschließend als tatsächliche
|
||||
AArch64-ELFs, mit Hash/Buildlog/Image-ID und unverändertem Eingabemanifest
|
||||
nachgewiesen werden. Keine Dockerfile-APT-Schritte, Netzwerkdownloads oder
|
||||
Abhängigkeitsänderungen sind Teil dieses Plans. Serverdienste, bestehende
|
||||
Ingress-/Broker-/Zeitpins und private Signierschlüssel werden durch einen
|
||||
Build nicht geändert. Der lokale x86-64-Lauf ist kein ARM64-Buildnachweis.
|
||||
@@ -0,0 +1,174 @@
|
||||
# Kompatibler Linux-Updater: konkrete administrative Controller
|
||||
|
||||
Stand 16. November 2026. Die nachstehenden Quellen sind vorbereitet und lokal
|
||||
geprüft. **Kein erhaltender Dienstwechsel, kein Signierschlüssel, kein neuer
|
||||
Updaterdienst und kein Updatejob wurden durch diese Vorbereitung auf einem Ziel
|
||||
ausgeführt.** Die Zielphasen koordiniert der Rootprozess; RMM-Aufträge brauchen
|
||||
weiterhin den tatsächlichen Weg MCP → `pending_approval` → WebUI → Originalgrant.
|
||||
|
||||
## Genau verwendbare Artefakte
|
||||
|
||||
Das unveränderte ursprüngliche Buildpack `21d20391-6102-4996-8a7a-efbd3e78bd7d`
|
||||
bleibt erhalten. Der neue Agent muss zusätzlich die beiden bereits bestehenden
|
||||
Domaincapabilities `agent.update.apply/1` und `agent.update.check/1` nach einem
|
||||
gültigen geschützten Fullobserver melden. Außerdem muss der bestehende
|
||||
60-Sekunden-Tick das fertige Observerergebnis vor seinem Capabilityvergleich
|
||||
abholen. Andernfalls wurde die alte Probe erst nach dem Vergleich geerntet und
|
||||
konnte beim nächsten Vergleich bereits älter als die erlaubten 90 Sekunden sein.
|
||||
Der Tickaufruf wurde verschoben, ohne Samplerate oder Gültigkeitsgrenze zu ändern.
|
||||
|
||||
Beide Änderungen sind in der eigenständigen Derivation
|
||||
`devstate/linux-updater-capability-build/9923a97f-4c8c-4e0a-bbad-4f1d88f0d43a`
|
||||
eingefroren. Manifest-SHA256:
|
||||
`a41ad700b4b7527bf911bf00f2745914188760c631af0c3255364c05f1ef4fbc`.
|
||||
Source0/Source1 verwenden unverändert 0.1.0/0.1.1.
|
||||
|
||||
| Artefakt | SHA256 |
|
||||
|---|---|
|
||||
| Source0 Agent | `7fef8d0f1e2bcf5cd6c373e567a0c17bfb08d8c780cd4d1925b6c1355e572547` |
|
||||
| Source1 Agent | `4d212066bef226af3fa679ffe95f69c43a9668cbef7e665d53328f4e41aa3799` |
|
||||
| Source0 Helper, unverändert aus 21D | `8fdc6ded02278eb18e64003d0bc7bf45d452cd48ded0450e6e900ca66e44d449` |
|
||||
| Source1 Helper, unverändert aus 21D | `89b28db3afe870c667297dff97ad7a042c550ccce1f712d69108e8de672ad450` |
|
||||
| Stabiler Updater, unverändert aus 21D | `dec6336728eac8af1e0d84d4921c7c9ecbcc45bc4619d357d346b716336be90a` |
|
||||
|
||||
Die Derivation verwendet einen eigenen kopierten Buildcache. Beide Agenten
|
||||
bestanden all-targets Clippy mit `-D warnings` und den Releasebuild im gepinnten
|
||||
Offlinebuilder. Alle 18 zuvor nativ geprüften Contractexecutables, Helper und
|
||||
Updater wurden nicht neu gebaut und ihre Originalhashes erneut verglichen.
|
||||
Der frühere reine Capabilitymarker-Fall `f89fbb79-…` bleibt historisch erhalten;
|
||||
er enthält die Tickkorrektur noch nicht und ist hier nicht die Baseline.
|
||||
|
||||
Der separate öffentliche Metadaten-SDK liegt im eingefrorenen Fall
|
||||
`devstate/linux-updater-bootstrap-sdk/d309c949-3a70-4448-88da-49c710093221`.
|
||||
Manifest-SHA256 `cf9464ff21b48b28903369692e3bb63148b2c488297ec709e8fd9c9881448528`,
|
||||
Binary-SHA256 `6fcc543d538fca30ceb499364880e4dc3689700d50597f18bd11bfe3559a0021`.
|
||||
Sein Worker-all-targets-Clippy und Releasebuild bestanden. Er schreibt keine
|
||||
Zieldateien und startet keine Dienste. Er rendert Full über die bestehenden
|
||||
Rusttypen, erzeugt kanonische öffentliche Manifest-/Record-/Policybytes und
|
||||
misst bei `qualify_pair`/`registry` ausschließlich die wirklichen Zielzeugen.
|
||||
Die Bundlecodecoperation kennzeichnet ausdrücklich nur die Formprüfung.
|
||||
|
||||
## Vorbereitete erhaltende Phasen
|
||||
|
||||
`deploy/linux_updater_compatible_apply.py` trennt folgende explizite Phasen;
|
||||
keine Fehlerantwort startet einen bereits begonnenen Schritt erneut:
|
||||
|
||||
1. `prepare`: Nur lesender Original-CAS auf der VM und lokale Paketvorbereitung.
|
||||
Diese Phase wurde tatsächlich ausgeführt. Der lokale Fall
|
||||
`devstate/linux-updater-compatible/ac6cf439-e0a6-4323-82e1-c55df96b2441`
|
||||
enthält `package.json`, den lesenden Vorbeleg und Manifest-SHA256
|
||||
`d3917236c03b93273b4f43f1df3b6773cc04873018262567d3d31510c993c082`.
|
||||
Es wurde noch kein Paket auf der VM bereitgestellt.
|
||||
2. `stage`: Ausschließlich create-only sieben feste geprüfte öffentliche
|
||||
Artefakte in einem neuen Root-700-Fallverzeichnis bereitstellen.
|
||||
3. `install`: Frischen geschlossenen zentralen Scope und null offene Jobs prüfen;
|
||||
echte Original-PIDs halten, Agent/General/Full stoppen, beide Originalflocks
|
||||
halten und alle ursprünglichen DB-Inodes/Start-/Outcomeaggregate bewahren.
|
||||
Vier feste Dateien mit create-only Vorgänger- und Kandidatennamen ersetzen.
|
||||
Alle drei Dienste bleiben danach gestoppt. Bei bestehendem Intent nur lesen.
|
||||
4. `units`: Den stabilen Updater und die feste Unit create-only installieren,
|
||||
Full-Override `Restart=no` vor der Registry bereitstellen, daemon-reload und
|
||||
tatsächlichen inaktiven Updater/Restartzustand prüfen. Keine Dienststarts.
|
||||
5. `start`: General, Full, Agent jeweils genau einmal starten. Das ist zunächst
|
||||
nur ein Dienststart, noch kein Baselinequalifikationsnachweis.
|
||||
6. `qualify`: Der SDK prüft echte PID/Birth/Image-/Unitzeugen und dieselbe frisch
|
||||
signierte normale Agent-/Helpersynchronisierung mit aktuellem NativeClock,
|
||||
unabhängig gepinnten öffentlichen Jobkeys und erhaltener History. Kein
|
||||
vergangener Clockwert und kein administrativer Ready-Ersatz. Die ausgegebene
|
||||
Qualifikation enthält `ready/helper_ready/unlock/job_authority=false`.
|
||||
7. `registry`: Die wirkliche feste 21-Unit-Schließung, etwaige Rollbacktimer,
|
||||
Host-/Namespaceidentitäten und tatsächliche Dateipins zweimal messen. Ein
|
||||
geladener APTdienst verlangt seinen vierten lokalen Servicepin, bleibt aber
|
||||
inaktiv/disabled und erhält keine neue APT-Laufzeitqualifikation.
|
||||
8. `trust`: Kanonische Form nativ mit dem SDK prüfen, Release- und separate
|
||||
Baselinesignatur über genau diese Bytes zusätzlich mit OpenSSL prüfen,
|
||||
aktuelle Artefakt-/Identitäts-/Registrybindungen vergleichen und die festen
|
||||
Trustdateien create-only anlegen. Private Originalkeys werden nur per
|
||||
Metadaten in die Retainedliste aufgenommen, niemals gelesen oder exportiert.
|
||||
9. `updater-start`: Nach vollständiger Trustinstallation den stabilen Dienst
|
||||
genau einmal starten und seinen echten gehaltenen PID/Imagezeugen prüfen.
|
||||
10. `passive-check`: Nur serverseitig lesen. Die wirkliche normale Agentmeldung
|
||||
muss weniger als 90 Sekunden alt sein, gültige Fullobserver-/Syncbezüge,
|
||||
den exakten Vorgänger/Updater/Policy/Keyring/Healthpin und die benötigten
|
||||
Runtimecapabilities enthalten. Es gibt keinen SQL-Schreibersatz für eine
|
||||
fehlende Capability. `readback` holt nach einem verlorenen Transport nur
|
||||
feste öffentliche Belege ab.
|
||||
|
||||
Der vorhandene Generalpin Schema 1 enthält ausdrücklich keinen Binarypin; der
|
||||
Produktcode verlangt hier `helper_binary_sha256=None`. Seine exakten Bytes und
|
||||
Policy bleiben erhalten. Das erlaubt keine Umdeutung des alten Pins zu einem
|
||||
Native-Abnahmenachweis für die neuen Helperbytes. Dafür ist Schritt 6 getrennt
|
||||
notwendig. Der alte APTproof bleibt unverändert und weiterhin geschlossen.
|
||||
|
||||
## Servertrust und Signieren
|
||||
|
||||
`deploy/updater_server_signing_bootstrap.py` ist ein separat aufzurufender
|
||||
Server-Rootbootstrap. Der reine Read `public-separation` wurde tatsächlich
|
||||
ausgeführt: Er las ausschließlich den bestehenden öffentlichen Timepin und
|
||||
verglich ihn mit dem unabhängig geschützten öffentlichen Jobkey. Timepin-Rawhash
|
||||
`c31d31d2d61f881d04f55f704abbbf98f4822650c016f39e39d4d2318bc3f6e2`;
|
||||
die beiden tatsächlichen Publickey-SHA256-Werte sind
|
||||
`1d9b8f83191a99d69b435dc69e8c9b52650680e8e02025f3e338e5083924def8` und
|
||||
`4338aabe7e7ba77428e969750a7a5323d7b7349aa52ef7e1a5f24c90be12ca7a`.
|
||||
Der Read erzeugte keine Schlüssel und änderte keinen Dienst. Der öffentliche
|
||||
Beleg und der noch nicht ausgeführte `signer-provision-input.json` liegen im
|
||||
lokalen kompatiblen Bootstrapfall `ac6cf439-…`.
|
||||
|
||||
`provision` erzeugt für Linux und Windows jeweils einen
|
||||
eigenen Release-/Baselineschlüssel. Der globale Healthschlüssel wird nur beim
|
||||
ersten Aufruf erzeugt und später ausschließlich nach unveränderter öffentlicher
|
||||
Provenienz und Schlüsselmetadaten wiederverwendet. Der Aufruf verlangt echte
|
||||
Job-/Zeit-Publickey-SHA256-Werte als Ausschlussliste; Rollenalias-IDs genügen
|
||||
nicht. Kein privater Schlüssel verlässt den Server oder erscheint im Output.
|
||||
|
||||
Releasekeys bleiben Root in 0700/0600. Der tatsächliche Server-Trustreader
|
||||
verlangt den bestehenden Jobkey-Dateiowner 10001 auch für Keyring/Healthdatei,
|
||||
Datei 0600/ein Link und geschützten Elternpfad. Deshalb erhält jede Plattform
|
||||
ein eigenes öffentliches Verzeichnis 10001/0700 mit `keyring.json` 0600.
|
||||
Dieses wird später read-only in API **und** Gateway gemountet; der separate
|
||||
Healthkey wird read-only ausschließlich in das Gateway gemountet. Der Container
|
||||
behält seine vorhandene UID und schreibgeschützte Root-FS. Private Releasekeys
|
||||
werden überhaupt nicht in Anwendungscontainer gemountet.
|
||||
|
||||
Neue statische Serverkonfiguration:
|
||||
|
||||
| Einstellung | Zweck |
|
||||
|---|---|
|
||||
| `RMM_AGENT_UPDATE_LINUX_KEYRING_FILE` | ausschließlich geschützter Linux-Keyring |
|
||||
| `RMM_AGENT_UPDATE_WINDOWS_KEYRING_FILE` | ausschließlich geschützter Windows-Keyring |
|
||||
| `RMM_AGENT_UPDATE_KEYRING_FILE` | unveränderter Legacyfallback, nur wenn der Plattformslot fehlt |
|
||||
| `RMM_AGENT_UPDATE_HEALTH_KEY_FILE` | separater Gateway-Healthsignierer |
|
||||
|
||||
Ein vom Netz empfangener Plattformenum wählt ausschließlich einen dieser zwei
|
||||
fest konfigurierten Pfade. Ein leerer/relativer expliziter Plattformslot wird
|
||||
verweigert. Danach gelten weiterhin sämtliche Signatur-, Plattform-, Revocation-,
|
||||
Generation- und Original-Rawhashprüfungen. Ein gemeinsamer Mehrplattformkeyring
|
||||
würde die bestehenden streng plattformgebundenen Clients nicht erfüllen;
|
||||
deshalb wird deren Trustvertrag nicht gelockert. Die beiden gezielten
|
||||
Serververträge bestanden mit echten lokalen Ed25519-Signaturen für beide
|
||||
Plattformen und negativen Kreuzkeyring-/Signatur-/Revocation-/Generation-/
|
||||
Rawhashfällen; Server-all-targets-Clippy bestand ebenfalls. Diese Quellen
|
||||
brauchen noch einen neuen, getrennt koordinierten ARM64-Imagebuild/Deploy.
|
||||
|
||||
`deploy/linux_updater_public_materials.py` verwendet den sealed SDK für
|
||||
`release-input`, `record-input`, `trust-package`. Es signiert nichts. Der Server
|
||||
signiert ausschließlich die zwei fest qualifizierten Linux-Codepaare und die
|
||||
Initialbaseline mit dem tatsächlichen Qualifikationshash. Ein Ausgabe-JSON ist
|
||||
keine lokale Vertrauensquelle. Die kanonischen Manifestcodec-Rundläufe für beide
|
||||
wirklichen Linux-Artefaktpaare und Python-Syntaxprüfung aller drei Controller
|
||||
bestanden lokal; dabei wurden weder Schlüssel noch Signaturen erzeugt.
|
||||
|
||||
Windows-GNU-Artefakte werden ausdrücklich nicht als kanonische Windows-MSVC-
|
||||
Releases signiert. Die tatsächliche MSVC-Qualifikation ist ein eigener offener
|
||||
Schritt. Das ändert weder das Linux-first-Gate noch einen Plattformvertrag.
|
||||
|
||||
## Danach noch tatsächlich abzunehmen
|
||||
|
||||
Die beschriebenen Zielphasen sind weiterhin auszuführen. Neue Servermounts,
|
||||
plattformbezogener Keyring, Gateway-Healthkey, enger Update-Denyscope und
|
||||
Tenantkatalog müssen anschließend konkret und mit erhaltenen Composepins
|
||||
bereitgestellt werden. Erst dann folgen der tatsächlich über MCP beantragte
|
||||
und in der WebUI genehmigte Linux-Updatejob, dessen Originalverbrauch,
|
||||
Codepaarwechsel, signierte Health und endgültiger Record/Floor sowie der
|
||||
bekannte geschlossene Fullstart-Fehlerfall mit erhaltender Rückführung. Lokale
|
||||
Codec-/Build-/Syntaxbelege ersetzen diese nativen Abnahmen nicht.
|
||||
Reference in New Issue
Block a user