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,
|
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)]
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||||
pub struct Channel {
|
pub struct Channel {
|
||||||
|
|||||||
@@ -38,6 +38,7 @@ pub enum Participant {
|
|||||||
OriginalHelper,
|
OriginalHelper,
|
||||||
StableUpdater,
|
StableUpdater,
|
||||||
NewHelper,
|
NewHelper,
|
||||||
|
RestoredHelper,
|
||||||
}
|
}
|
||||||
pub trait UpdateParticipantGuard: ExecutorLedgerGuard {
|
pub trait UpdateParticipantGuard: ExecutorLedgerGuard {
|
||||||
fn participant(&self) -> Participant;
|
fn participant(&self) -> Participant;
|
||||||
@@ -50,6 +51,18 @@ pub trait UpdateParticipantGuard: ExecutorLedgerGuard {
|
|||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
anyhow::bail!("UPDATE_NATIVE_EFFECT_NOT_QUALIFIED")
|
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,
|
/// Recheck fixed service/PID/birth/image, original boot, SAME file IDs,
|
||||||
/// current clock/deadline and evidence-specific protected observations.
|
/// current clock/deadline and evidence-specific protected observations.
|
||||||
/// Health additionally compares receipt contents with the actually applied
|
/// 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));
|
FOREIGN KEY(grant_id,effect_key) REFERENCES agent_update_native_claims(grant_id,effect_key));
|
||||||
CREATE TABLE IF NOT EXISTS agent_update_sync_applied(
|
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,
|
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(())
|
Ok(())
|
||||||
}
|
}
|
||||||
@@ -300,7 +317,7 @@ pub(crate) fn read_locked(db: &Connection, grant: Uuid) -> Result<Journal> {
|
|||||||
let (effect_key, raw, digest) = row?;
|
let (effect_key, raw, digest) = row?;
|
||||||
let claim: NativeEffectClaim = serde_json::from_slice(&raw)?;
|
let claim: NativeEffectClaim = serde_json::from_slice(&raw)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
native_count <= 17
|
native_count <= if handoff.schema_version == 2 { 32 } else { 17 }
|
||||||
&& raw.len() <= 2048
|
&& raw.len() <= 2048
|
||||||
&& hash(&raw) == digest
|
&& hash(&raw) == digest
|
||||||
&& serde_json::to_vec(&claim)? == raw
|
&& 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))?;
|
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");
|
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(
|
let mut journal = Journal::open(
|
||||||
&record,
|
&record,
|
||||||
key.try_into()
|
key.try_into()
|
||||||
@@ -337,7 +358,9 @@ pub(crate) fn read_locked(db: &Connection, grant: Uuid) -> Result<Journal> {
|
|||||||
);
|
);
|
||||||
journal.replay(&event)?;
|
journal.replay(&event)?;
|
||||||
let parsed: Event = serde_json::from_slice(&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);
|
stored_outcome_hash = Some(outcome_sha256);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -440,7 +463,11 @@ pub fn append(
|
|||||||
ensure!(
|
ensure!(
|
||||||
!matches!(
|
!matches!(
|
||||||
parsed.evidence,
|
parsed.evidence,
|
||||||
Evidence::OutcomePersisted { .. } | Evidence::Unknown { .. }
|
Evidence::OutcomePersisted { .. }
|
||||||
|
| Evidence::RollbackOutcomePersisted { .. }
|
||||||
|
| Evidence::RollbackIntent { .. }
|
||||||
|
| Evidence::RollbackLedgerReturnIntent
|
||||||
|
| Evidence::Unknown { .. }
|
||||||
),
|
),
|
||||||
"UPDATE_TERMINAL_REQUIRES_OUTCOME_CAS"
|
"UPDATE_TERMINAL_REQUIRES_OUTCOME_CAS"
|
||||||
);
|
);
|
||||||
@@ -481,6 +508,16 @@ fn verify_writer(
|
|||||||
|r| r.get(0),
|
|r| r.get(0),
|
||||||
)?;
|
)?;
|
||||||
let handoff: Handoff = serde_json::from_slice(&raw)?;
|
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 {
|
let expected = match event.evidence {
|
||||||
Evidence::AllStopped { .. }
|
Evidence::AllStopped { .. }
|
||||||
| Evidence::UpdaterOwnsLedger { .. }
|
| Evidence::UpdaterOwnsLedger { .. }
|
||||||
@@ -491,6 +528,25 @@ fn verify_writer(
|
|||||||
Evidence::ServicesStarted { .. }
|
Evidence::ServicesStarted { .. }
|
||||||
| Evidence::HealthVerified { .. }
|
| Evidence::HealthVerified { .. }
|
||||||
| Evidence::OutcomePersisted { .. } => Participant::NewHelper,
|
| 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::Unknown { .. } => guard.participant(),
|
||||||
Evidence::StopIntent => anyhow::bail!("UPDATE_STOP_ALREADY_ATOMICALLY_STORED"),
|
Evidence::StopIntent => anyhow::bail!("UPDATE_STOP_ALREADY_ATOMICALLY_STORED"),
|
||||||
};
|
};
|
||||||
@@ -502,11 +558,7 @@ fn verify_writer(
|
|||||||
};
|
};
|
||||||
match &event.evidence {
|
match &event.evidence {
|
||||||
Evidence::AllStopped { .. } => {
|
Evidence::AllStopped { .. } => {
|
||||||
for service in [
|
for service in native_services {
|
||||||
NativeService::Agent,
|
|
||||||
NativeService::General,
|
|
||||||
NativeService::Full,
|
|
||||||
] {
|
|
||||||
if handoff.stop_set.contains(&native_service(service)) {
|
if handoff.stop_set.contains(&native_service(service)) {
|
||||||
require_observed(NativeEffect::StopService { service })?;
|
require_observed(NativeEffect::StopService { service })?;
|
||||||
}
|
}
|
||||||
@@ -518,19 +570,64 @@ fn verify_writer(
|
|||||||
rmm_updater_handoff::FileRole::HelperBinary => NativeFileRole::HelperBinary,
|
rmm_updater_handoff::FileRole::HelperBinary => NativeFileRole::HelperBinary,
|
||||||
rmm_updater_handoff::FileRole::LinuxFullConfig => NativeFileRole::FullConfig,
|
rmm_updater_handoff::FileRole::LinuxFullConfig => NativeFileRole::FullConfig,
|
||||||
rmm_updater_handoff::FileRole::LinuxFullPin => NativeFileRole::FullPin,
|
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"),
|
_ => anyhow::bail!("UPDATE_NATIVE_PLATFORM_UNQUALIFIED"),
|
||||||
};
|
};
|
||||||
require_observed(NativeEffect::PublishReplacement { role })?;
|
require_observed(NativeEffect::PublishReplacement { role })?;
|
||||||
}
|
}
|
||||||
Evidence::ServicesStarted { .. } => {
|
Evidence::ServicesStarted { .. } => {
|
||||||
for service in [
|
for service in native_services {
|
||||||
NativeService::General,
|
|
||||||
NativeService::Full,
|
|
||||||
NativeService::Agent,
|
|
||||||
] {
|
|
||||||
require_observed(NativeEffect::StartService { service })?;
|
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)
|
guard.verify_update_event(&handoff, &read_delegation(db, grant)?, event)
|
||||||
@@ -597,6 +694,54 @@ pub fn finalize(
|
|||||||
tx.commit()?;
|
tx.commit()?;
|
||||||
Ok(())
|
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,
|
/// Persist uncertainty once under the same original consumption. No release,
|
||||||
/// new start, result rewrite or transition back out of Unknown is provided.
|
/// 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::LedgerReturnIntent => "ledger_return_intent",
|
||||||
Phase::ServicesStarted => "services_started",
|
Phase::ServicesStarted => "services_started",
|
||||||
Phase::HealthVerified => "health_verified",
|
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::OutcomePersisted => "outcome_persisted",
|
||||||
Phase::Unknown => "unknown",
|
Phase::Unknown => "unknown",
|
||||||
}
|
}
|
||||||
@@ -699,6 +853,17 @@ pub enum NativeEffect {
|
|||||||
old_sha256: String,
|
old_sha256: String,
|
||||||
new_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)]
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||||
#[serde(rename_all = "snake_case")]
|
#[serde(rename_all = "snake_case")]
|
||||||
@@ -725,6 +890,9 @@ pub enum NativeEffectStage {
|
|||||||
Claim,
|
Claim,
|
||||||
Observe,
|
Observe,
|
||||||
ReserveFutureStart,
|
ReserveFutureStart,
|
||||||
|
ObserveNonstart,
|
||||||
|
ReserveConditionalStop,
|
||||||
|
ObserveRetainedStart,
|
||||||
}
|
}
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||||
#[serde(deny_unknown_fields)]
|
#[serde(deny_unknown_fields)]
|
||||||
@@ -755,6 +923,12 @@ impl NativeEffectClaim {
|
|||||||
pub struct PreparedReturnClaims<const N: usize = 3> {
|
pub struct PreparedReturnClaims<const N: usize = 3> {
|
||||||
pub return_ledger: NativeEffectClaim,
|
pub return_ledger: NativeEffectClaim,
|
||||||
pub starts: [NativeEffectClaim; N],
|
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(
|
fn native_context(
|
||||||
db: &Connection,
|
db: &Connection,
|
||||||
@@ -791,6 +965,18 @@ fn native_role(role: NativeFileRole) -> rmm_updater_handoff::FileRole {
|
|||||||
NativeFileRole::WindowsTimeProfile => F::WindowsTimeProfile,
|
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 {
|
fn native_service(service: NativeService) -> rmm_updater_handoff::Service {
|
||||||
use rmm_updater_handoff::Service as S;
|
use rmm_updater_handoff::Service as S;
|
||||||
match service {
|
match service {
|
||||||
@@ -820,7 +1006,10 @@ fn insert_native_claim(
|
|||||||
[h.attempt.grant_id.to_string()],
|
[h.attempt.grant_id.to_string()],
|
||||||
|r| r.get(0),
|
|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 {
|
let claim = NativeEffectClaim {
|
||||||
grant_id: h.attempt.grant_id,
|
grant_id: h.attempt.grant_id,
|
||||||
owner_nonce: h.owner_nonce,
|
owner_nonce: h.owner_nonce,
|
||||||
@@ -890,6 +1079,12 @@ pub fn claim_native_effect(
|
|||||||
&& old_sha256 != new_sha256,
|
&& old_sha256 != new_sha256,
|
||||||
"UPDATE_NATIVE_INSTALLED_RECORD_BINDING"
|
"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 { .. }) {
|
if matches!(effect, NativeEffect::PublishInstalledRecord { .. }) {
|
||||||
let save = native_key(&NativeEffect::SaveInstalledRecord {
|
let save = native_key(&NativeEffect::SaveInstalledRecord {
|
||||||
old_sha256: old_sha256.clone(),
|
old_sha256: old_sha256.clone(),
|
||||||
@@ -900,11 +1095,60 @@ pub fn claim_native_effect(
|
|||||||
require_matching_record_save(&tx, grant, old_sha256, new_sha256)?;
|
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
|
// Rollback needs its own qualified event transition; never infer it
|
||||||
// from an uncertain replacement or silently restart the predecessor.
|
// from an uncertain replacement or silently restart the predecessor.
|
||||||
NativeEffect::RestorePredecessor { .. }
|
NativeEffect::StartService { .. }
|
||||||
| NativeEffect::StartService { .. }
|
| NativeEffect::ReturnLedger
|
||||||
| NativeEffect::ReturnLedger => anyhow::bail!("UPDATE_NATIVE_SPECIAL_TRANSITION_REQUIRED"),
|
| NativeEffect::RollbackStartService { .. }
|
||||||
|
| NativeEffect::RollbackReturnLedger
|
||||||
|
| NativeEffect::ConditionalRollbackStopGeneral => {
|
||||||
|
anyhow::bail!("UPDATE_NATIVE_SPECIAL_TRANSITION_REQUIRED")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
guard.verify_native_effect(&h, &d, effect, NativeEffectStage::Claim)?;
|
guard.verify_native_effect(&h, &d, effect, NativeEffectStage::Claim)?;
|
||||||
let result = insert_native_claim(&tx, &h, expected_head, effect.clone(), now)?;
|
let result = insert_native_claim(&tx, &h, expected_head, effect.clone(), now)?;
|
||||||
@@ -912,6 +1156,281 @@ pub fn claim_native_effect(
|
|||||||
tx.commit()?;
|
tx.commit()?;
|
||||||
Ok(result)
|
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(
|
pub fn observe_native_effect(
|
||||||
db: &mut Connection,
|
db: &mut Connection,
|
||||||
guard: &impl UpdateParticipantGuard,
|
guard: &impl UpdateParticipantGuard,
|
||||||
@@ -966,8 +1485,43 @@ pub fn observe_native_effect(
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
NativeEffect::ReturnLedger | NativeEffect::RestorePredecessor { .. } => {
|
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")
|
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)?;
|
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()])?;
|
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,
|
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)?;
|
j.replay(return_event)?;
|
||||||
append_in(&tx, grant, expected_head, return_event, &parsed, &j)?;
|
append_in(&tx, grant, expected_head, return_event, &parsed, &j)?;
|
||||||
let return_ledger =
|
let return_ledger =
|
||||||
@@ -1093,13 +1657,148 @@ fn prepare_return_for<const N: usize>(
|
|||||||
now,
|
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)?;
|
guard.check(&tx)?;
|
||||||
tx.commit()?;
|
tx.commit()?;
|
||||||
Ok(PreparedReturnClaims {
|
Ok(PreparedReturnClaims {
|
||||||
return_ledger,
|
return_ledger,
|
||||||
starts: starts
|
starts: starts
|
||||||
.try_into()
|
.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,
|
/// Only ReadOriginal; exact retained execution_evidence.start bytes,
|
||||||
/// bounded to 512KiB before canonical Base64url encoding, never rewritten.
|
/// bounded to 512KiB before canonical Base64url encoding, never rewritten.
|
||||||
pub original_start_base64url: Option<String>,
|
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(
|
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)?;
|
let (observed, journal) = verify_inflight_proof(&proof, key).map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
observed.bytes()? == header.bytes()?
|
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.grant_id == header.attempt.grant_id.to_string()
|
||||||
&& local.consumption == "consumed"
|
&& local.consumption == "consumed"
|
||||||
&& local.state == "running"
|
&& 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})
|
"error_code":error,"data":report})
|
||||||
}
|
}
|
||||||
struct Pending {
|
struct Pending {
|
||||||
receiver: oneshot::Receiver<Report>,
|
receiver: oneshot::Receiver<(Report, Option<ReleaseEnvelope>)>,
|
||||||
task: tokio::task::JoinHandle<()>,
|
task: tokio::task::JoinHandle<()>,
|
||||||
}
|
}
|
||||||
impl Drop for Pending {
|
impl Drop for Pending {
|
||||||
@@ -73,10 +73,21 @@ impl Drop for Pending {
|
|||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
pub struct Checker {
|
pub struct Checker {
|
||||||
report: Option<Report>,
|
report: Option<Report>,
|
||||||
|
release: Option<ReleaseEnvelope>,
|
||||||
started: Option<Instant>,
|
started: Option<Instant>,
|
||||||
pending: Option<Pending>,
|
pending: Option<Pending>,
|
||||||
}
|
}
|
||||||
impl Checker {
|
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> {
|
pub fn cached(&self, now: DateTime<Utc>) -> Option<Report> {
|
||||||
self.report
|
self.report
|
||||||
.as_ref()
|
.as_ref()
|
||||||
@@ -90,17 +101,20 @@ impl Checker {
|
|||||||
binding: Option<&Binding>,
|
binding: Option<&Binding>,
|
||||||
clock: TrustedClock,
|
clock: TrustedClock,
|
||||||
address: SocketAddr,
|
address: SocketAddr,
|
||||||
|
guarded: Option<crate::agent_update_apply::GuardedRecord>,
|
||||||
client: impl FnOnce() -> Result<reqwest::Client>,
|
client: impl FnOnce() -> Result<reqwest::Client>,
|
||||||
) -> Report {
|
) -> Report {
|
||||||
if let Some(pending) = &mut self.pending {
|
if let Some(pending) = &mut self.pending {
|
||||||
match pending.receiver.try_recv() {
|
match pending.receiver.try_recv() {
|
||||||
Ok(report) => {
|
Ok((report, release)) => {
|
||||||
self.report = Some(report);
|
self.report = Some(report);
|
||||||
|
self.release = release;
|
||||||
self.pending.take();
|
self.pending.take();
|
||||||
}
|
}
|
||||||
Err(oneshot::error::TryRecvError::Empty) => {}
|
Err(oneshot::error::TryRecvError::Empty) => {}
|
||||||
Err(oneshot::error::TryRecvError::Closed) => {
|
Err(oneshot::error::TryRecvError::Closed) => {
|
||||||
self.report = Some(empty(Status::Unavailable));
|
self.report = Some(empty(Status::Unavailable));
|
||||||
|
self.release = None;
|
||||||
self.pending.take();
|
self.pending.take();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -123,6 +137,7 @@ impl Checker {
|
|||||||
Path::new(POLICY),
|
Path::new(POLICY),
|
||||||
Path::new(KEYRING),
|
Path::new(KEYRING),
|
||||||
Path::new(RECORD),
|
Path::new(RECORD),
|
||||||
|
guarded.as_ref(),
|
||||||
)
|
)
|
||||||
})
|
})
|
||||||
.transpose();
|
.transpose();
|
||||||
@@ -148,7 +163,7 @@ impl Checker {
|
|||||||
let report = result
|
let report = result
|
||||||
.ok()
|
.ok()
|
||||||
.and_then(Result::ok)
|
.and_then(Result::ok)
|
||||||
.unwrap_or_else(|| empty(Status::Unavailable));
|
.unwrap_or_else(|| (empty(Status::Unavailable), None));
|
||||||
let _ = sender.send(report);
|
let _ = sender.send(report);
|
||||||
});
|
});
|
||||||
self.pending = Some(Pending { receiver, task });
|
self.pending = Some(Pending { receiver, task });
|
||||||
@@ -254,7 +269,13 @@ struct Trust {
|
|||||||
generation: u64,
|
generation: u64,
|
||||||
}
|
}
|
||||||
impl Trust {
|
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 result = (|| -> Result<Self> {
|
||||||
let policy = Protected::read(policy, 65536)?;
|
let policy = Protected::read(policy, 65536)?;
|
||||||
let (local, _) =
|
let (local, _) =
|
||||||
@@ -264,12 +285,22 @@ impl Trust {
|
|||||||
"UPDATE_CATALOG_FIXED_ANCHOR_PATHS"
|
"UPDATE_CATALOG_FIXED_ANCHOR_PATHS"
|
||||||
);
|
);
|
||||||
let keys = Protected::read(keys, 16384)?;
|
let keys = Protected::read(keys, 16384)?;
|
||||||
let record = Protected::read(record, 32768)?;
|
if let Some(guarded) = guarded {
|
||||||
let result = Self::verify(binding, &policy.raw, &keys.raw, &record.raw)?;
|
let raw = guarded.bytes(&policy.raw, &keys.raw)?;
|
||||||
Ok(Self {
|
let result =
|
||||||
files: vec![policy, keys, record],
|
Self::verify_guarded(binding, &policy.raw, &keys.raw, raw, Some(guarded))?;
|
||||||
..result
|
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 {
|
match result {
|
||||||
Ok(value) => Ok(Some(value)),
|
Ok(value) => Ok(Some(value)),
|
||||||
@@ -288,6 +319,15 @@ impl Trust {
|
|||||||
policy_raw: &[u8],
|
policy_raw: &[u8],
|
||||||
keys_raw: &[u8],
|
keys_raw: &[u8],
|
||||||
record_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> {
|
) -> Result<Self> {
|
||||||
let (policy, _) = LocalUpdatePolicy::from_bytes(policy_raw).map_err(anyhow::Error::msg)?;
|
let (policy, _) = LocalUpdatePolicy::from_bytes(policy_raw).map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
@@ -322,14 +362,23 @@ impl Trust {
|
|||||||
.initial_baseline
|
.initial_baseline
|
||||||
.decode()
|
.decode()
|
||||||
.map_err(anyhow::Error::msg)?;
|
.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!(
|
ensure!(
|
||||||
baseline.payload_bytes == record_raw
|
hash(&baseline.payload_bytes) == policy.initial_record_sha256,
|
||||||
&& hash(record_raw) == policy.initial_record_sha256,
|
"UPDATE_CATALOG_BASELINE_BYTES"
|
||||||
"UPDATE_CATALOG_GUARDED_HISTORY_REQUIRED"
|
|
||||||
);
|
);
|
||||||
|
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
|
let signer = keys
|
||||||
.keys
|
.keys
|
||||||
.iter()
|
.iter()
|
||||||
@@ -347,8 +396,7 @@ impl Trust {
|
|||||||
Verifier::new_without_digest(&public)?.verify_oneshot(&baseline.signature, &signed)?,
|
Verifier::new_without_digest(&public)?.verify_oneshot(&baseline.signature, &signed)?,
|
||||||
"UPDATE_CATALOG_BASELINE_SIGNATURE"
|
"UPDATE_CATALOG_BASELINE_SIGNATURE"
|
||||||
);
|
);
|
||||||
let decoded = baseline
|
let decoded = installed
|
||||||
.record
|
|
||||||
.release_envelope
|
.release_envelope
|
||||||
.decode()
|
.decode()
|
||||||
.map_err(anyhow::Error::msg)?;
|
.map_err(anyhow::Error::msg)?;
|
||||||
@@ -358,7 +406,7 @@ impl Trust {
|
|||||||
protocol: decoded.manifest.protocol_major,
|
protocol: decoded.manifest.protocol_major,
|
||||||
state: decoded.manifest.state_schema,
|
state: decoded.manifest.state_schema,
|
||||||
generation: keys.generation,
|
generation: keys.generation,
|
||||||
record: baseline.record,
|
record: installed,
|
||||||
};
|
};
|
||||||
result.release(&result.record.release_envelope, result.record.activated_at)?;
|
result.release(&result.record.release_envelope, result.record.activated_at)?;
|
||||||
Ok(result)
|
Ok(result)
|
||||||
@@ -458,14 +506,17 @@ async fn request(
|
|||||||
address: SocketAddr,
|
address: SocketAddr,
|
||||||
trust: &Trust,
|
trust: &Trust,
|
||||||
clock: &TrustedClock,
|
clock: &TrustedClock,
|
||||||
) -> Result<Report> {
|
) -> Result<(Report, Option<ReleaseEnvelope>)> {
|
||||||
ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED");
|
ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED");
|
||||||
let bytes = fetch(client, address).await?;
|
let bytes = fetch(client, address).await?;
|
||||||
ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED");
|
ensure!(clock.trusted(), "UPDATE_CATALOG_CLOCK_UNTRUSTED");
|
||||||
for file in &trust.files {
|
for file in &trust.files {
|
||||||
file.recheck()?;
|
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>> {
|
async fn fetch(client: &reqwest::Client, address: SocketAddr) -> Result<Vec<u8>> {
|
||||||
@@ -750,6 +801,7 @@ mod tests {
|
|||||||
None,
|
None,
|
||||||
TrustedClock::new(),
|
TrustedClock::new(),
|
||||||
"127.0.0.1:1".parse().unwrap(),
|
"127.0.0.1:1".parse().unwrap(),
|
||||||
|
None,
|
||||||
|| panic!("missing anchor must not load device TLS keys"),
|
|| panic!("missing anchor must not load device TLS keys"),
|
||||||
);
|
);
|
||||||
assert_eq!(report.status, Status::NotConfigured);
|
assert_eq!(report.status, Status::NotConfigured);
|
||||||
@@ -757,6 +809,7 @@ mod tests {
|
|||||||
None,
|
None,
|
||||||
TrustedClock::new(),
|
TrustedClock::new(),
|
||||||
"127.0.0.1:1".parse().unwrap(),
|
"127.0.0.1:1".parse().unwrap(),
|
||||||
|
None,
|
||||||
|| panic!("cadence must not create client"),
|
|| panic!("cadence must not create client"),
|
||||||
);
|
);
|
||||||
assert_eq!(report.checked_at, again.checked_at);
|
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 key = update::job_health_public_key(&job).map_err(anyhow::Error::msg)?;
|
||||||
let (header, journal) =
|
let (header, journal) =
|
||||||
update::verify_inflight_proof(proof, key).map_err(anyhow::Error::msg)?;
|
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);
|
return Ok(None);
|
||||||
}
|
}
|
||||||
ensure!(
|
ensure!(
|
||||||
@@ -241,7 +242,8 @@ pub fn context(
|
|||||||
.context("UPDATE_HEALTH_SERVICES_STARTED")?,
|
.context("UPDATE_HEALTH_SERVICES_STARTED")?,
|
||||||
)?;
|
)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
matches!(event.evidence, Evidence::ServicesStarted { .. }),
|
matches!(event.evidence, Evidence::ServicesStarted { .. }) && !rollback
|
||||||
|
|| matches!(event.evidence, Evidence::RollbackServicesStarted { .. }) && rollback,
|
||||||
"UPDATE_HEALTH_SERVICES_STARTED"
|
"UPDATE_HEALTH_SERVICES_STARTED"
|
||||||
);
|
);
|
||||||
let (last, generation, fault, pending): (Option<String>, u64, Option<String>, Option<String>) =
|
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)?;
|
.map_err(anyhow::Error::msg)?;
|
||||||
journal.prepare(
|
journal.prepare(
|
||||||
u64::try_from(now.timestamp())?,
|
u64::try_from(now.timestamp())?,
|
||||||
Evidence::HealthVerified {
|
if journal.phase() == Phase::RollbackServicesStarted {
|
||||||
receipt: signed.clone(),
|
Evidence::RollbackHealthVerified {
|
||||||
|
receipt: signed.clone(),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Evidence::HealthVerified {
|
||||||
|
receipt: signed.clone(),
|
||||||
|
}
|
||||||
},
|
},
|
||||||
)?;
|
)?;
|
||||||
ensure!(Instant::now() < context.deadline, "UPDATE_HEALTH_EXPIRED");
|
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 {
|
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) {
|
if rmm_privileged_helper::apt::is_apt_action(job) {
|
||||||
// SAFETY: geteuid has no preconditions.
|
// SAFETY: geteuid has no preconditions.
|
||||||
return unsafe { libc::geteuid() } != 0
|
return unsafe { libc::geteuid() } != 0
|
||||||
|
|||||||
+51
-18
@@ -1,3 +1,4 @@
|
|||||||
|
mod agent_update_apply;
|
||||||
mod agent_update_catalog;
|
mod agent_update_catalog;
|
||||||
mod agent_update_health;
|
mod agent_update_health;
|
||||||
mod apt;
|
mod apt;
|
||||||
@@ -62,6 +63,7 @@ struct Agent<C: reconcile::SyncClock = reconcile::NativeClock> {
|
|||||||
certificates: certificate_rotation::RotationStore,
|
certificates: certificate_rotation::RotationStore,
|
||||||
rotation_policy: certificate_rotation::RotationPolicy,
|
rotation_policy: certificate_rotation::RotationPolicy,
|
||||||
catalog: agent_update_catalog::Checker,
|
catalog: agent_update_catalog::Checker,
|
||||||
|
update_observer: agent_update_apply::Observer,
|
||||||
}
|
}
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
struct EffectFence {
|
struct EffectFence {
|
||||||
@@ -428,6 +430,13 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
|| binding.verify(&request, Utc::now()).is_err()
|
|| binding.verify(&request, Utc::now()).is_err()
|
||||||
{
|
{
|
||||||
jobs::no_start("failed", "START_WINDOW_OR_CLOCK_INVALID_BEFORE_EFFECT")
|
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" {
|
} else if job.execution_identity == "root" {
|
||||||
apt::invoke_with_control(&binding, &job, &request, || {
|
apt::invoke_with_control(&binding, &job, &request, || {
|
||||||
ensure!(
|
ensure!(
|
||||||
@@ -483,6 +492,9 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
}
|
}
|
||||||
capabilities.extend(apt::capabilities(binding));
|
capabilities.extend(apt::capabilities(binding));
|
||||||
capabilities.extend(helper_sync::general_capabilities(binding));
|
capabilities.extend(helper_sync::general_capabilities(binding));
|
||||||
|
if self.clock.trusted() {
|
||||||
|
capabilities.extend(self.update_observer.capabilities());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
capabilities.sort();
|
capabilities.sort();
|
||||||
capabilities.dedup();
|
capabilities.dedup();
|
||||||
@@ -530,18 +542,15 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
if !storage::passive_collection_ready(&self.db)? {
|
if !storage::passive_collection_ready(&self.db)? {
|
||||||
return Ok(());
|
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 address = self.address;
|
||||||
let ca = &self.ca;
|
let ca = &self.ca;
|
||||||
let certificates = &self.certificates;
|
let certificates = &self.certificates;
|
||||||
self.catalog
|
self.catalog.poll(
|
||||||
.poll(self.binding.as_ref(), self.clock.clone(), address, || {
|
self.binding.as_ref(),
|
||||||
|
self.clock.clone(),
|
||||||
|
address,
|
||||||
|
self.update_observer.catalog_record(),
|
||||||
|
|| {
|
||||||
let identity = certificates.current(Utc::now().timestamp())?;
|
let identity = certificates.current(Utc::now().timestamp())?;
|
||||||
https_channel::mtls_client(
|
https_channel::mtls_client(
|
||||||
address,
|
address,
|
||||||
@@ -549,7 +558,12 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
&identity.certificate_pem,
|
&identity.certificate_pem,
|
||||||
&identity.private_key_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 data = serde_json::to_vec(&serde_json::json!({"agent_update":observation}))?;
|
||||||
let envelope = self.envelope(
|
let envelope = self.envelope(
|
||||||
generation,
|
generation,
|
||||||
@@ -660,6 +674,8 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
let mut first_heartbeat = true;
|
let mut first_heartbeat = true;
|
||||||
let mut health_task: Option<PendingUpdateHealth> = None;
|
let mut health_task: Option<PendingUpdateHealth> = None;
|
||||||
let mut health_inventory_prefix: Option<String> = 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 {
|
loop {
|
||||||
tokio::select! {
|
tokio::select! {
|
||||||
Some(result) = self.inventory_rx.recv() => {
|
Some(result) = self.inventory_rx.recv() => {
|
||||||
@@ -742,6 +758,13 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
}
|
}
|
||||||
_ = tick.tick() => {
|
_ = tick.tick() => {
|
||||||
self.replay(&ws, generation).await?;
|
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 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 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);
|
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 {
|
if let Some(proof)=&update {
|
||||||
let decoded=proof.decode().map_err(anyhow::Error::msg)?;
|
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()?;
|
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()) {
|
if health_inventory_prefix.as_deref()!=Some(proof.head_sha256.as_str()) {
|
||||||
// Fixed update health includes one genuinely new
|
// Fixed update health includes one genuinely new
|
||||||
// normal base sample, never a fresh timestamp on old data.
|
// 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 !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_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)) {
|
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") {
|
} else if !self.ready(generation,job.execution_identity=="root") {
|
||||||
needs_sync=true;
|
needs_sync=true;
|
||||||
} else if Utc::now() >= job.not_before {
|
} 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
|
// Reserve before send. A lost response must never cause
|
||||||
// a second permit request for this attempt.
|
// a second permit request for this attempt.
|
||||||
jobs::reserve_request(&self.db, &offer)?;
|
jobs::reserve_request(&self.db, &offer)?;
|
||||||
@@ -808,13 +847,6 @@ impl<C: reconcile::SyncClock> Agent<C> {
|
|||||||
heartbeat_at = Instant::now();
|
heartbeat_at = Instant::now();
|
||||||
heartbeat_after = Duration::from_millis(rand::random_range(27_000..33_000));
|
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) {
|
if inventory_at.elapsed() >= Duration::from_secs(60) {
|
||||||
self.queue_inventory();
|
self.queue_inventory();
|
||||||
inventory_at = Instant::now();
|
inventory_at = Instant::now();
|
||||||
@@ -1017,6 +1049,7 @@ async fn main() -> Result<()> {
|
|||||||
certificates,
|
certificates,
|
||||||
rotation_policy,
|
rotation_policy,
|
||||||
catalog: agent_update_catalog::Checker::default(),
|
catalog: agent_update_catalog::Checker::default(),
|
||||||
|
update_observer: agent_update_apply::Observer::default(),
|
||||||
};
|
};
|
||||||
agent.recover_interrupted()?;
|
agent.recover_interrupted()?;
|
||||||
let mut backoff = 1_u64;
|
let mut backoff = 1_u64;
|
||||||
|
|||||||
@@ -151,6 +151,7 @@ fn new_process_persists_interruption_before_helper_io_without_unlock_or_repeat()
|
|||||||
certificates,
|
certificates,
|
||||||
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
||||||
catalog: agent_update_catalog::Checker::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.
|
// A forged local consumption/start cannot become a purported grant result.
|
||||||
agent
|
agent
|
||||||
@@ -539,6 +540,7 @@ async fn run(mode: wire_channel::Mode, trusted: bool, forged: bool, rounds: u64)
|
|||||||
certificates,
|
certificates,
|
||||||
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
rotation_policy: certificate_rotation::RotationPolicy::default(),
|
||||||
catalog: agent_update_catalog::Checker::default(),
|
catalog: agent_update_catalog::Checker::default(),
|
||||||
|
update_observer: agent_update_apply::Observer::default(),
|
||||||
};
|
};
|
||||||
for _ in 0..rounds {
|
for _ in 0..rounds {
|
||||||
assert!(
|
assert!(
|
||||||
|
|||||||
@@ -9,8 +9,10 @@ pub mod readiness;
|
|||||||
pub mod reconcile;
|
pub mod reconcile;
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests;
|
mod tests;
|
||||||
|
pub mod update_admission;
|
||||||
pub mod update_control;
|
pub mod update_control;
|
||||||
pub mod update_guard;
|
pub mod update_guard;
|
||||||
|
pub mod update_observer;
|
||||||
use anyhow::{Context, Result, ensure};
|
use anyhow::{Context, Result, ensure};
|
||||||
use chrono::{DateTime, Utc};
|
use chrono::{DateTime, Utc};
|
||||||
use openssl::pkey::{Id, PKey};
|
use openssl::pkey::{Id, PKey};
|
||||||
|
|||||||
@@ -15,7 +15,7 @@ use std::{
|
|||||||
net::{UnixListener, UnixStream},
|
net::{UnixListener, UnixStream},
|
||||||
},
|
},
|
||||||
},
|
},
|
||||||
path::PathBuf,
|
path::{Path, PathBuf},
|
||||||
time::Duration,
|
time::Duration,
|
||||||
};
|
};
|
||||||
|
|
||||||
@@ -133,6 +133,7 @@ impl Config {
|
|||||||
#[derive(Deserialize)]
|
#[derive(Deserialize)]
|
||||||
#[serde(untagged)]
|
#[serde(untagged)]
|
||||||
enum Incoming {
|
enum Incoming {
|
||||||
|
UpdateObserve(rmm_privileged_helper::update_observer::Request),
|
||||||
NativeUpdate(rmm_agent_core::update_handoff::NativeControlRequest),
|
NativeUpdate(rmm_agent_core::update_handoff::NativeControlRequest),
|
||||||
Control(control::Request),
|
Control(control::Request),
|
||||||
Probe(rmm_privileged_helper::readiness::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",
|
job.execution_identity == "root",
|
||||||
"HELPER_REQUIRES_EXPLICIT_ROOT_IDENTITY"
|
"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) {
|
if rmm_privileged_helper::apt::is_apt_action(job) {
|
||||||
ensure!(
|
ensure!(
|
||||||
config.profile == HelperProfile::AptOnly,
|
config.profile == HelperProfile::AptOnly,
|
||||||
@@ -386,6 +398,44 @@ fn handle(
|
|||||||
ensure!(size <= 512 * 1024, "JOB_REQUEST_SIZE");
|
ensure!(size <= 512 * 1024, "JOB_REQUEST_SIZE");
|
||||||
request
|
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) => {
|
Incoming::Control(request) => {
|
||||||
peer_allowed(stream, config.agent_uid)?;
|
peer_allowed(stream, config.agent_uid)?;
|
||||||
let (challenge, identity) = request.binding();
|
let (challenge, identity) = request.binding();
|
||||||
@@ -534,6 +584,65 @@ fn handle(
|
|||||||
// Both profiles use these exact same inodes, locked per effect rather than
|
// Both profiles use these exact same inodes, locked per effect rather than
|
||||||
// daemon lifetime so the dedicated and general helper can coexist.
|
// daemon lifetime so the dedicated and general helper can coexist.
|
||||||
let resource = reconcile::ExecutorGuard::acquire(&config.state, 0)?;
|
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
|
let previous: Option<Option<Vec<u8>>> = db
|
||||||
.query_row(
|
.query_row(
|
||||||
"SELECT COALESCE(result,(SELECT outcome FROM execution_evidence WHERE execution_evidence.grant_id=consumed.grant_id)) FROM consumed WHERE grant_id=?1",
|
"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,
|
reconcile::SyncClock,
|
||||||
update_handoff::{
|
update_handoff::{
|
||||||
self as core, NativeControlOperation, NativeControlReply, NativeControlRequest,
|
self as core, NativeControlOperation, NativeControlReply, NativeControlRequest,
|
||||||
NativeEffect, NativeService,
|
NativeEffect, NativeEffectStage, NativeService, UpdateParticipantGuard,
|
||||||
},
|
},
|
||||||
};
|
};
|
||||||
use rmm_updater_handoff::{Evidence, Phase};
|
use rmm_updater_handoff::{Evidence, Phase};
|
||||||
@@ -21,7 +21,7 @@ pub fn active_grant(db: &Connection) -> Result<Option<Uuid>> {
|
|||||||
if !exists {
|
if !exists {
|
||||||
return Ok(None);
|
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
|
let rows = query
|
||||||
.query_map([], |r| r.get::<_, String>(0))?
|
.query_map([], |r| r.get::<_, String>(0))?
|
||||||
.collect::<rusqlite::Result<Vec<_>>>()?;
|
.collect::<rusqlite::Result<Vec<_>>>()?;
|
||||||
@@ -90,7 +90,10 @@ pub fn handle(
|
|||||||
} => {
|
} => {
|
||||||
let journal = core::read(db, &guard, request.grant_id)?;
|
let journal = core::read(db, &guard, request.grant_id)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
journal.phase() == Phase::LedgerReturnIntent,
|
matches!(
|
||||||
|
journal.phase(),
|
||||||
|
Phase::LedgerReturnIntent | Phase::RollbackLedgerReturnIntent
|
||||||
|
),
|
||||||
"UPDATE_START_ALREADY_OBSERVED_OR_PHASE"
|
"UPDATE_START_ALREADY_OBSERVED_OR_PHASE"
|
||||||
);
|
);
|
||||||
let (actual, actual_hash) = guard.started()?;
|
let (actual, actual_hash) = guard.started()?;
|
||||||
@@ -103,7 +106,11 @@ pub fn handle(
|
|||||||
NativeService::Full,
|
NativeService::Full,
|
||||||
NativeService::Agent,
|
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 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))?;
|
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
|
// One control request performs one sequence, never retries an
|
||||||
@@ -119,28 +126,60 @@ pub fn handle(
|
|||||||
}
|
}
|
||||||
let event = journal.prepare(
|
let event = journal.prepare(
|
||||||
u64::try_from(clock.now()?.timestamp())?,
|
u64::try_from(clock.now()?.timestamp())?,
|
||||||
Evidence::ServicesStarted {
|
if guard.restored() {
|
||||||
services: actual,
|
Evidence::RollbackServicesStarted {
|
||||||
ledger_identity_sha256: header.ledger_identity_sha256.clone(),
|
services: actual,
|
||||||
observation_sha256: actual_hash,
|
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)?;
|
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 } => {
|
NativeControlOperation::Health { receipt } => {
|
||||||
guard.qualify_health(db, receipt)?;
|
guard.qualify_health(db, receipt)?;
|
||||||
let journal = core::read(db, &guard, request.grant_id)?;
|
let journal = core::read(db, &guard, request.grant_id)?;
|
||||||
let event = journal.prepare(
|
let event = journal.prepare(
|
||||||
u64::try_from(clock.now()?.timestamp())?,
|
u64::try_from(clock.now()?.timestamp())?,
|
||||||
Evidence::HealthVerified {
|
if guard.restored() {
|
||||||
receipt: receipt.clone(),
|
Evidence::RollbackHealthVerified {
|
||||||
|
receipt: receipt.clone(),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Evidence::HealthVerified {
|
||||||
|
receipt: receipt.clone(),
|
||||||
|
}
|
||||||
},
|
},
|
||||||
)?;
|
)?;
|
||||||
core::append(db, &guard, request.grant_id, journal.head_sha256(), &event)?;
|
core::append(db, &guard, request.grant_id, journal.head_sha256(), &event)?;
|
||||||
}
|
}
|
||||||
NativeControlOperation::Finalize => {
|
NativeControlOperation::Finalize => {
|
||||||
original_outcome_base64url =
|
original_outcome_base64url = Some(URL_SAFE_NO_PAD.encode(if guard.restored() {
|
||||||
Some(URL_SAFE_NO_PAD.encode(guard.publish_record_and_finalize(db)?));
|
guard.finalize_restored(db)?
|
||||||
|
} else {
|
||||||
|
guard.publish_record_and_finalize(db)?
|
||||||
|
}));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
let proof = if original_outcome_base64url.is_some() {
|
let proof = if original_outcome_base64url.is_some() {
|
||||||
@@ -151,6 +190,18 @@ pub fn handle(
|
|||||||
.context("UPDATE_ACTIVE_PROOF_REQUIRED")?,
|
.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 {
|
Ok(NativeControlReply {
|
||||||
schema_version: 1,
|
schema_version: 1,
|
||||||
challenge: request.challenge,
|
challenge: request.challenge,
|
||||||
@@ -167,5 +218,7 @@ pub fn handle(
|
|||||||
claim,
|
claim,
|
||||||
original_start_base64url,
|
original_start_base64url,
|
||||||
original_outcome_base64url,
|
original_outcome_base64url,
|
||||||
|
pre_stop_sync_request_base64url,
|
||||||
|
pre_stop_sync_response_base64url,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -133,6 +133,12 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
journal.phase(),
|
journal.phase(),
|
||||||
Phase::LedgerReturnIntent | Phase::ServicesStarted | Phase::HealthVerified
|
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 services = service_policies(&original, &trust, target)?;
|
||||||
let own = services.observe(Service::Full, &budget)?;
|
let own = services.observe(Service::Full, &budget)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
@@ -148,6 +154,8 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
"UPDATE_ORIGINAL_FULL_CHANGED"
|
"UPDATE_ORIGINAL_FULL_CHANGED"
|
||||||
);
|
);
|
||||||
Participant::OriginalHelper
|
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()?)? {
|
} else if target && header.boot_id == Uuid::parse_str(&rmm_agent_linux::boot_id()?)? {
|
||||||
Participant::NewHelper
|
Participant::NewHelper
|
||||||
} else {
|
} else {
|
||||||
@@ -227,8 +235,11 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
}
|
}
|
||||||
self.check_effect_window()?;
|
self.check_effect_window()?;
|
||||||
ensure!(
|
ensure!(
|
||||||
self.participant == Participant::NewHelper,
|
matches!(
|
||||||
"UPDATE_NEW_FULL_REQUIRED"
|
self.participant,
|
||||||
|
Participant::NewHelper | Participant::RestoredHelper
|
||||||
|
),
|
||||||
|
"UPDATE_NEW_OR_RESTORED_FULL_REQUIRED"
|
||||||
);
|
);
|
||||||
let agent = self.services.observe(Service::Agent, &self.budget)?;
|
let agent = self.services.observe(Service::Agent, &self.budget)?;
|
||||||
let mut peer = std::mem::MaybeUninit::<libc::ucred>::uninit();
|
let mut peer = std::mem::MaybeUninit::<libc::ucred>::uninit();
|
||||||
@@ -264,18 +275,30 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
self.check_effect_window()?;
|
self.check_effect_window()?;
|
||||||
ensure!(
|
ensure!(
|
||||||
self.participant == Participant::NewHelper,
|
matches!(
|
||||||
"UPDATE_NEW_FULL_REQUIRED"
|
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)?;
|
let mut journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
journal.phase() == Phase::ServicesStarted,
|
matches!(
|
||||||
|
journal.phase(),
|
||||||
|
Phase::ServicesStarted | Phase::RollbackServicesStarted
|
||||||
|
),
|
||||||
"UPDATE_HEALTH_PHASE"
|
"UPDATE_HEALTH_PHASE"
|
||||||
);
|
);
|
||||||
let event = journal.prepare(
|
let event = journal.prepare(
|
||||||
u64::try_from(self.clock.now()?.timestamp())?,
|
u64::try_from(self.clock.now()?.timestamp())?,
|
||||||
Evidence::HealthVerified {
|
if self.participant == Participant::RestoredHelper {
|
||||||
receipt: signed.clone(),
|
Evidence::RollbackHealthVerified {
|
||||||
|
receipt: signed.clone(),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
Evidence::HealthVerified {
|
||||||
|
receipt: signed.clone(),
|
||||||
|
}
|
||||||
},
|
},
|
||||||
)?;
|
)?;
|
||||||
journal.replay(&event)?; // ORIGINAL pinned health signature and all kernel fields.
|
journal.replay(&event)?; // ORIGINAL pinned health signature and all kernel fields.
|
||||||
@@ -286,7 +309,10 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
self.check_effect_window()?;
|
self.check_effect_window()?;
|
||||||
let journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
let journal = update_handoff::read(db, self, self.original.permit().grant_id)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
journal.phase() == Phase::HealthVerified,
|
matches!(
|
||||||
|
journal.phase(),
|
||||||
|
Phase::HealthVerified | Phase::RollbackHealthVerified
|
||||||
|
),
|
||||||
"UPDATE_ORIGINAL_STORED_HEALTH_REQUIRED"
|
"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))?;
|
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(),
|
hash(&event_raw) == journal.head_sha256(),
|
||||||
"UPDATE_STORED_HEALTH_HEAD_CHANGED"
|
"UPDATE_STORED_HEALTH_HEAD_CHANGED"
|
||||||
);
|
);
|
||||||
let Evidence::HealthVerified { receipt } = &event.evidence else {
|
let receipt = match &event.evidence {
|
||||||
anyhow::bail!("UPDATE_STORED_HEALTH_EVENT_REQUIRED")
|
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)?);
|
self.health = Some(self.health_evidence(db, receipt)?);
|
||||||
Ok(event_raw)
|
Ok(event_raw)
|
||||||
@@ -354,8 +388,11 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
pub fn started(&self) -> Result<(Vec<rmm_updater_handoff::StartedService>, String)> {
|
pub fn started(&self) -> Result<(Vec<rmm_updater_handoff::StartedService>, String)> {
|
||||||
self.check_effect_window()?;
|
self.check_effect_window()?;
|
||||||
ensure!(
|
ensure!(
|
||||||
self.participant == Participant::NewHelper,
|
matches!(
|
||||||
"UPDATE_NEW_FULL_REQUIRED"
|
self.participant,
|
||||||
|
Participant::NewHelper | Participant::RestoredHelper
|
||||||
|
),
|
||||||
|
"UPDATE_NEW_OR_RESTORED_FULL_REQUIRED"
|
||||||
);
|
);
|
||||||
let mut raw = Vec::new();
|
let mut raw = Vec::new();
|
||||||
let mut proofs = Vec::new();
|
let mut proofs = Vec::new();
|
||||||
@@ -415,7 +452,13 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
fn verify_owner(&self, phase: Phase, events: &[Event]) -> Result<()> {
|
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
|
let updater = self
|
||||||
.updater
|
.updater
|
||||||
.as_ref()
|
.as_ref()
|
||||||
@@ -431,15 +474,30 @@ impl<'a> FullUpdateGuard<'a> {
|
|||||||
"UPDATE_ORIGINAL_UPDATER_OWNER_CHANGED"
|
"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
|
let started = events
|
||||||
.iter()
|
.iter()
|
||||||
.find_map(|event| {
|
.find_map(|event| match &event.evidence {
|
||||||
if let Evidence::ServicesStarted { services, .. } = &event.evidence {
|
Evidence::ServicesStarted { services, .. }
|
||||||
|
if matches!(phase, Phase::ServicesStarted | Phase::HealthVerified) =>
|
||||||
|
{
|
||||||
Some(services)
|
Some(services)
|
||||||
} else {
|
|
||||||
None
|
|
||||||
}
|
}
|
||||||
|
Evidence::RollbackServicesStarted { services, .. }
|
||||||
|
if matches!(
|
||||||
|
phase,
|
||||||
|
Phase::RollbackServicesStarted | Phase::RollbackHealthVerified
|
||||||
|
) =>
|
||||||
|
{
|
||||||
|
Some(services)
|
||||||
|
}
|
||||||
|
_ => None,
|
||||||
})
|
})
|
||||||
.context("UPDATE_STARTED_PROOF_MISSING")?;
|
.context("UPDATE_STARTED_PROOF_MISSING")?;
|
||||||
self.verify_current_services(started)?;
|
self.verify_current_services(started)?;
|
||||||
@@ -486,16 +544,39 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
|||||||
);
|
);
|
||||||
self.check_effect_window()?;
|
self.check_effect_window()?;
|
||||||
ensure!(
|
ensure!(
|
||||||
self.participant == Participant::NewHelper,
|
matches!(
|
||||||
"UPDATE_NEW_FULL_REQUIRED"
|
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 {
|
match &event.evidence {
|
||||||
Evidence::ServicesStarted {
|
Evidence::ServicesStarted {
|
||||||
services,
|
services,
|
||||||
ledger_identity_sha256,
|
ledger_identity_sha256,
|
||||||
observation_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 held = Vec::new();
|
||||||
let mut proofs = Vec::new();
|
let mut proofs = Vec::new();
|
||||||
for service in [Service::Agent, Service::General, Service::Full] {
|
for service in [Service::Agent, Service::General, Service::Full] {
|
||||||
@@ -511,7 +592,18 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
|||||||
"UPDATE_ACTUAL_STARTED_PROOFS_REQUIRED"
|
"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
|
let health = self
|
||||||
.health
|
.health
|
||||||
.as_ref()
|
.as_ref()
|
||||||
@@ -521,6 +613,14 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
|||||||
"UPDATE_LOCAL_HEALTH_RECEIPT_CHANGED"
|
"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.
|
// InstalledRecord/Outcome have a separate original-record CAS.
|
||||||
_ => anyhow::bail!("UPDATE_FULL_EVENT_NOT_YET_QUALIFIED"),
|
_ => anyhow::bail!("UPDATE_FULL_EVENT_NOT_YET_QUALIFIED"),
|
||||||
}
|
}
|
||||||
@@ -578,10 +678,63 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
|||||||
.observe(service, &self.budget)?
|
.observe(service, &self.budget)?
|
||||||
.verify(&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"),
|
_ => anyhow::bail!("UPDATE_FULL_NATIVE_EFFECT_NOT_QUALIFIED"),
|
||||||
}
|
}
|
||||||
Ok(())
|
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 {
|
struct VerifiedHealth {
|
||||||
@@ -985,3 +1138,157 @@ impl FullUpdateGuard<'_> {
|
|||||||
Ok(bytes)
|
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,
|
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(
|
pub fn verify_envelope(
|
||||||
envelope: &ReleaseEnvelope,
|
envelope: &ReleaseEnvelope,
|
||||||
binding: Option<&rmm_domain::agent_update::UpdaterBinding>,
|
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> {
|
) -> Result<ReleaseManifest, Error> {
|
||||||
let decoded = envelope.decode().map_err(|_| invalid())?;
|
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 =
|
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()
|
if !config.validate()
|
||||||
|| binding.is_some_and(|b| {
|
|| 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"));
|
return Err(fail("AGENT_UPDATE_TRUST_INVALID"));
|
||||||
@@ -174,10 +216,7 @@ pub fn verify_envelope(
|
|||||||
.map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?;
|
.map_err(|_| fail("AGENT_UPDATE_TRUST_INVALID"))?;
|
||||||
let context = rmm_updater::TrustedContext {
|
let context = rmm_updater::TrustedContext {
|
||||||
platform: verifier_platform(decoded.manifest.platform),
|
platform: verifier_platform(decoded.manifest.platform),
|
||||||
now_utc_seconds: chrono::Utc::now()
|
now_utc_seconds,
|
||||||
.timestamp()
|
|
||||||
.try_into()
|
|
||||||
.map_err(|_| invalid())?,
|
|
||||||
keyring_generation: config.generation,
|
keyring_generation: config.generation,
|
||||||
protocol_major: 1,
|
protocol_major: 1,
|
||||||
state_schema: 1,
|
state_schema: 1,
|
||||||
@@ -826,6 +865,164 @@ pub async fn validate_current_target(
|
|||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
#[test]
|
#[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() {
|
fn actual_codec_pair_plan_requires_exact_per_attempt_artifact_authority() {
|
||||||
let fixtures: Value = serde_json::from_str(include_str!(
|
let fixtures: Value = serde_json::from_str(include_str!(
|
||||||
"../../../tests/agent_update/codec-golden.json"
|
"../../../tests/agent_update/codec-golden.json"
|
||||||
|
|||||||
@@ -113,6 +113,7 @@ pub struct Directory {
|
|||||||
fd: File,
|
fd: File,
|
||||||
path: PathBuf,
|
path: PathBuf,
|
||||||
identity: Identity,
|
identity: Identity,
|
||||||
|
agent_state: bool,
|
||||||
}
|
}
|
||||||
impl Directory {
|
impl Directory {
|
||||||
/// All ancestors are held while opening their child with O_NOFOLLOW. A
|
/// All ancestors are held while opening their child with O_NOFOLLOW. A
|
||||||
@@ -143,13 +144,46 @@ impl Directory {
|
|||||||
identity: Identity::of(&m),
|
identity: Identity::of(&m),
|
||||||
fd,
|
fd,
|
||||||
path: path.to_path_buf(),
|
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 {
|
pub fn identity(&self) -> &Identity {
|
||||||
&self.identity
|
&self.identity
|
||||||
}
|
}
|
||||||
pub fn verify(&self) -> Result<()> {
|
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!(
|
ensure!(
|
||||||
current.identity == self.identity
|
current.identity == self.identity
|
||||||
&& Identity::of(&self.fd.metadata()?) == self.identity,
|
&& Identity::of(&self.fd.metadata()?) == self.identity,
|
||||||
@@ -198,7 +232,7 @@ impl Directory {
|
|||||||
);
|
);
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
fn absent(&self, basename: &OsStr) -> Result<()> {
|
pub fn absent(&self, basename: &OsStr) -> Result<()> {
|
||||||
let value = name(basename)?;
|
let value = name(basename)?;
|
||||||
let mut m = std::mem::MaybeUninit::<libc::stat>::uninit();
|
let mut m = std::mem::MaybeUninit::<libc::stat>::uninit();
|
||||||
// SAFETY: live dirfd, valid basename, properly sized writable stat.
|
// SAFETY: live dirfd, valid basename, properly sized writable stat.
|
||||||
@@ -251,6 +285,13 @@ impl HeldFile {
|
|||||||
pub fn proof(&self) -> &FileProof {
|
pub fn proof(&self) -> &FileProof {
|
||||||
&self.proof
|
&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<()> {
|
pub fn verify(&mut self, max: u64) -> Result<()> {
|
||||||
let m = self.fd.metadata()?;
|
let m = self.fd.metadata()?;
|
||||||
ensure!(
|
ensure!(
|
||||||
@@ -544,6 +585,9 @@ pub struct Installed {
|
|||||||
new: FileProof,
|
new: FileProof,
|
||||||
}
|
}
|
||||||
impl Installed {
|
impl Installed {
|
||||||
|
pub fn role(&self) -> Role {
|
||||||
|
self.role
|
||||||
|
}
|
||||||
pub fn old(&self) -> &FileProof {
|
pub fn old(&self) -> &FileProof {
|
||||||
&self.old
|
&self.old
|
||||||
}
|
}
|
||||||
@@ -564,10 +608,14 @@ impl Installed {
|
|||||||
dir.file(OsStr::new(&self.backup), &self.old, 256 * 1024 * 1024)?;
|
dir.file(OsStr::new(&self.backup), &self.old, 256 * 1024 * 1024)?;
|
||||||
let displaced = self.backup.replace(".previous", ".rejected");
|
let displaced = self.backup.replace(".previous", ".rejected");
|
||||||
dir.absent(OsStr::new(&displaced))?;
|
dir.absent(OsStr::new(&displaced))?;
|
||||||
let effect = Effect::RestorePredecessor { role: self.role };
|
let save = Effect::SaveRejectedCandidate { role: self.role };
|
||||||
fence.before_effect(&effect)?;
|
fence.before_effect(&save)?;
|
||||||
guard.verify_for_effect(budget)?;
|
guard.verify_for_effect(budget)?;
|
||||||
dir.rename_new(OsStr::new(&self.target), OsStr::new(&displaced))?;
|
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.
|
// No existing target can be overwritten; both code generations remain.
|
||||||
guard.verify_for_effect(budget)?;
|
guard.verify_for_effect(budget)?;
|
||||||
dir.rename_new(OsStr::new(&self.backup), OsStr::new(&self.target))?;
|
dir.rename_new(OsStr::new(&self.backup), OsStr::new(&self.target))?;
|
||||||
|
|||||||
@@ -64,6 +64,7 @@ pub enum Effect {
|
|||||||
PublishReplacement { role: files::Role },
|
PublishReplacement { role: files::Role },
|
||||||
StartService { service: services::Service },
|
StartService { service: services::Service },
|
||||||
RestorePredecessor { role: files::Role },
|
RestorePredecessor { role: files::Role },
|
||||||
|
SaveRejectedCandidate { role: files::Role },
|
||||||
ReturnLedger,
|
ReturnLedger,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -150,22 +150,117 @@ impl Systemd {
|
|||||||
],
|
],
|
||||||
budget,
|
budget,
|
||||||
)?;
|
)?;
|
||||||
let text = std::str::from_utf8(&output)?;
|
parse_service_status(&output)
|
||||||
let mut fields = BTreeMap::new();
|
}
|
||||||
for row in text.lines() {
|
fn failure_status(service: Service, budget: &Budget) -> Result<BTreeMap<String, String>> {
|
||||||
let (k, v) = row
|
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('=')
|
.split_once('=')
|
||||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_SYSTEMD_RESPONSE"))?;
|
.ok_or_else(|| anyhow::anyhow!("UPDATE_FAILED_STATUS"))?;
|
||||||
ensure!(
|
ensure!(
|
||||||
fields.insert(k.into(), v.into()).is_none(),
|
status.insert(k.to_owned(), v.to_owned()).is_none(),
|
||||||
"UPDATE_SYSTEMD_DUPLICATE"
|
"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!(
|
ensure!(
|
||||||
fields.len() == 8 && fields.get("LoadState").is_some_and(|v| v == "loaded"),
|
first["ActiveState"] == "failed"
|
||||||
"UPDATE_SYSTEMD_LOADED"
|
&& 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> {
|
pub fn observe(&self, service: Service, budget: &Budget) -> Result<HeldService> {
|
||||||
let pin = self
|
let pin = self
|
||||||
@@ -265,6 +360,9 @@ impl Systemd {
|
|||||||
let result = StoppedServices {
|
let result = StoppedServices {
|
||||||
systemd: self,
|
systemd: self,
|
||||||
original,
|
original,
|
||||||
|
failed: None,
|
||||||
|
subsequently_exited: Vec::new(),
|
||||||
|
early_full_failure: None,
|
||||||
};
|
};
|
||||||
result.verify_still_stopped(budget)?;
|
result.verify_still_stopped(budget)?;
|
||||||
Ok(result)
|
Ok(result)
|
||||||
@@ -356,17 +454,170 @@ impl HeldService {
|
|||||||
pub struct StoppedServices {
|
pub struct StoppedServices {
|
||||||
systemd: Systemd,
|
systemd: Systemd,
|
||||||
original: Vec<HeldService>,
|
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 {
|
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<()> {
|
pub fn verify_still_stopped(&self, budget: &Budget) -> Result<()> {
|
||||||
for pin in &self.systemd.policies {
|
for pin in &self.systemd.policies {
|
||||||
let s = Systemd::status(pin.service, budget)?;
|
let s = Systemd::status(pin.service, budget)?;
|
||||||
ensure!(
|
if let Some(failed) = self.failed.as_ref().filter(|f| f.service == pin.service) {
|
||||||
s["ActiveState"] == "inactive"
|
// Unit composition is still the provisioned original unit;
|
||||||
&& s["MainPID"] == "0"
|
// only code/config files were part of the approved transition.
|
||||||
&& unit_composition(&s)? == pin.unit_sha256,
|
self.systemd.verify_failed_start(failed, budget)?;
|
||||||
"UPDATE_READER_NOT_STOPPED"
|
} else {
|
||||||
);
|
ensure!(
|
||||||
|
s["ActiveState"] == "inactive"
|
||||||
|
&& s["MainPID"] == "0"
|
||||||
|
&& unit_composition(&s)? == pin.unit_sha256,
|
||||||
|
"UPDATE_READER_NOT_STOPPED"
|
||||||
|
);
|
||||||
|
}
|
||||||
if pin.service == Service::Apt {
|
if pin.service == Service::Apt {
|
||||||
ensure!(
|
ensure!(
|
||||||
s["UnitFileState"] == "disabled",
|
s["UnitFileState"] == "disabled",
|
||||||
@@ -377,6 +628,7 @@ impl StoppedServices {
|
|||||||
ensure!(
|
ensure!(
|
||||||
self.original
|
self.original
|
||||||
.iter()
|
.iter()
|
||||||
|
.chain(self.subsequently_exited.iter())
|
||||||
.all(|s| s.process.exited().unwrap_or(false)),
|
.all(|s| s.process.exited().unwrap_or(false)),
|
||||||
"UPDATE_OLD_PROCESS_STILL_LIVE"
|
"UPDATE_OLD_PROCESS_STILL_LIVE"
|
||||||
);
|
);
|
||||||
@@ -393,6 +645,17 @@ impl StoppedServices {
|
|||||||
budget: &Budget,
|
budget: &Budget,
|
||||||
fence: &mut impl DurableEffectFence,
|
fence: &mut impl DurableEffectFence,
|
||||||
) -> Result<Vec<HeldService>> {
|
) -> 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)?;
|
self.verify_still_stopped(budget)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
self.systemd
|
self.systemd
|
||||||
@@ -424,6 +687,17 @@ impl StoppedServices {
|
|||||||
started.push(held);
|
started.push(held);
|
||||||
break;
|
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!(
|
ensure!(
|
||||||
state["ActiveState"] == "activating" || state["ActiveState"] == "active",
|
state["ActiveState"] == "activating" || state["ActiveState"] == "active",
|
||||||
"UPDATE_START_UNPROVEN"
|
"UPDATE_START_UNPROVEN"
|
||||||
@@ -433,10 +707,40 @@ impl StoppedServices {
|
|||||||
}
|
}
|
||||||
// Return in the canonical Handoff stop-set order, not actual start order.
|
// Return in the canonical Handoff stop-set order, not actual start order.
|
||||||
started.sort_by_key(|s| s.proof.service);
|
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> {
|
fn unit_composition(fields: &BTreeMap<String, String>) -> Result<String> {
|
||||||
use crate::files::Directory;
|
use crate::files::Directory;
|
||||||
use std::{ffi::OsStr, path::Path};
|
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));
|
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 {
|
pub enum Generation {
|
||||||
Original,
|
Original,
|
||||||
Replacement,
|
Replacement,
|
||||||
|
Restored,
|
||||||
}
|
}
|
||||||
pub struct BridgeContext<'a> {
|
pub struct BridgeContext<'a> {
|
||||||
|
pub binding: &'a rmm_agent_core::auth::Binding,
|
||||||
pub handoff: &'a Handoff,
|
pub handoff: &'a Handoff,
|
||||||
pub delegation: &'a UpdateDelegation,
|
pub delegation: &'a UpdateDelegation,
|
||||||
pub services: &'a Systemd,
|
pub services: &'a Systemd,
|
||||||
@@ -62,6 +64,7 @@ pub struct Reply {
|
|||||||
pub original_start: Option<Vec<u8>>,
|
pub original_start: Option<Vec<u8>>,
|
||||||
pub claim: Option<NativeEffectClaim>,
|
pub claim: Option<NativeEffectClaim>,
|
||||||
pub original_outcome: Option<Vec<u8>>,
|
pub original_outcome: Option<Vec<u8>>,
|
||||||
|
pub pre_stop_sync: Option<(Vec<u8>, Vec<u8>)>,
|
||||||
}
|
}
|
||||||
impl<'a> FullBridge<'a> {
|
impl<'a> FullBridge<'a> {
|
||||||
/// Prefix is either the exact initial atomic StopIntent or a complete
|
/// Prefix is either the exact initial atomic StopIntent or a complete
|
||||||
@@ -137,18 +140,20 @@ impl<'a> FullBridge<'a> {
|
|||||||
"UPDATE_BRIDGE_CLAIM_PHASE"
|
"UPDATE_BRIDGE_CLAIM_PHASE"
|
||||||
),
|
),
|
||||||
NativeControlOperation::ObserveStarts { .. } => ensure!(
|
NativeControlOperation::ObserveStarts { .. } => ensure!(
|
||||||
context.generation == Generation::Replacement
|
journal.as_ref().is_some_and(|j| matches!(
|
||||||
&& journal
|
(context.generation, j.phase()),
|
||||||
.as_ref()
|
(Generation::Replacement, Phase::LedgerReturnIntent)
|
||||||
.is_some_and(|j| j.phase() == Phase::LedgerReturnIntent),
|
| (Generation::Restored, Phase::RollbackLedgerReturnIntent)
|
||||||
|
)),
|
||||||
"UPDATE_BRIDGE_START_PHASE"
|
"UPDATE_BRIDGE_START_PHASE"
|
||||||
),
|
),
|
||||||
NativeControlOperation::Health { receipt } => {
|
NativeControlOperation::Health { receipt } => {
|
||||||
ensure!(
|
ensure!(
|
||||||
context.generation == Generation::Replacement
|
journal.as_ref().is_some_and(|j| matches!(
|
||||||
&& journal
|
(context.generation, j.phase()),
|
||||||
.as_ref()
|
(Generation::Replacement, Phase::ServicesStarted)
|
||||||
.is_some_and(|j| j.phase() == Phase::ServicesStarted),
|
| (Generation::Restored, Phase::RollbackServicesStarted)
|
||||||
|
)),
|
||||||
"UPDATE_BRIDGE_HEALTH_PHASE"
|
"UPDATE_BRIDGE_HEALTH_PHASE"
|
||||||
);
|
);
|
||||||
journal
|
journal
|
||||||
@@ -156,16 +161,23 @@ impl<'a> FullBridge<'a> {
|
|||||||
.context("UPDATE_BRIDGE_ORIGINAL_READ_REQUIRED")?
|
.context("UPDATE_BRIDGE_ORIGINAL_READ_REQUIRED")?
|
||||||
.prepare(
|
.prepare(
|
||||||
u64::try_from(context.clock.now()?.timestamp())?,
|
u64::try_from(context.clock.now()?.timestamp())?,
|
||||||
rmm_updater_handoff::Evidence::HealthVerified {
|
if context.generation == Generation::Restored {
|
||||||
receipt: receipt.clone(),
|
rmm_updater_handoff::Evidence::RollbackHealthVerified {
|
||||||
|
receipt: receipt.clone(),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
rmm_updater_handoff::Evidence::HealthVerified {
|
||||||
|
receipt: receipt.clone(),
|
||||||
|
}
|
||||||
},
|
},
|
||||||
)?;
|
)?;
|
||||||
}
|
}
|
||||||
NativeControlOperation::Finalize => ensure!(
|
NativeControlOperation::Finalize => ensure!(
|
||||||
context.generation == Generation::Replacement
|
journal.as_ref().is_some_and(|j| matches!(
|
||||||
&& journal
|
(context.generation, j.phase()),
|
||||||
.as_ref()
|
(Generation::Replacement, Phase::HealthVerified)
|
||||||
.is_some_and(|j| j.phase() == Phase::HealthVerified),
|
| (Generation::Restored, Phase::RollbackHealthVerified)
|
||||||
|
)),
|
||||||
"UPDATE_BRIDGE_FINAL_PHASE"
|
"UPDATE_BRIDGE_FINAL_PHASE"
|
||||||
),
|
),
|
||||||
}
|
}
|
||||||
@@ -227,6 +239,11 @@ impl<'a> FullBridge<'a> {
|
|||||||
&& peer.pid != context.delegation.original_helper.pid,
|
&& peer.pid != context.delegation.original_helper.pid,
|
||||||
"UPDATE_BRIDGE_REPLACEMENT_HELPER_CHANGED"
|
"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 {
|
let request = NativeControlRequest {
|
||||||
operation: "agent_update_control_v1".into(),
|
operation: "agent_update_control_v1".into(),
|
||||||
@@ -276,6 +293,21 @@ impl<'a> FullBridge<'a> {
|
|||||||
&& reply.handoff_sha256 == request.handoff_sha256,
|
&& reply.handoff_sha256 == request.handoff_sha256,
|
||||||
"UPDATE_BRIDGE_REPLY_BINDING"
|
"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
|
let original_start = reply
|
||||||
.original_start_base64url
|
.original_start_base64url
|
||||||
.as_deref()
|
.as_deref()
|
||||||
@@ -297,8 +329,13 @@ impl<'a> FullBridge<'a> {
|
|||||||
let outcome: ReconciledOutcome = serde_json::from_slice(raw)?;
|
let outcome: ReconciledOutcome = serde_json::from_slice(raw)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
canonical_outcome_bytes(&outcome)? == *raw
|
canonical_outcome_bytes(&outcome)? == *raw
|
||||||
&& outcome.state == "succeeded"
|
&& if context.generation == Generation::Restored {
|
||||||
&& !outcome.reboot_required,
|
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"
|
"UPDATE_BRIDGE_NONCANONICAL_OR_UNSUCCESSFUL_OUTCOME"
|
||||||
);
|
);
|
||||||
} else {
|
} else {
|
||||||
@@ -322,6 +359,58 @@ impl<'a> FullBridge<'a> {
|
|||||||
&& proof.events[..prior.events.len()] == prior.events),
|
&& proof.events[..prior.events.len()] == prior.events),
|
||||||
"UPDATE_BRIDGE_PROOF_ROLLBACK_OR_CHANGED"
|
"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 {
|
match request.method {
|
||||||
NativeControlOperation::ReadOriginal => ensure!(
|
NativeControlOperation::ReadOriginal => ensure!(
|
||||||
reply.claim.is_none() && original_start.is_some(),
|
reply.claim.is_none() && original_start.is_some(),
|
||||||
@@ -348,16 +437,20 @@ impl<'a> FullBridge<'a> {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
NativeControlOperation::ObserveStarts { .. } => ensure!(
|
NativeControlOperation::ObserveStarts { .. } => ensure!(
|
||||||
context.generation == Generation::Replacement
|
matches!(
|
||||||
&& journal.phase() == Phase::ServicesStarted
|
(context.generation, journal.phase()),
|
||||||
&& reply.claim.is_none()
|
(Generation::Replacement, Phase::ServicesStarted)
|
||||||
|
| (Generation::Restored, Phase::RollbackServicesStarted)
|
||||||
|
) && reply.claim.is_none()
|
||||||
&& original_start.is_none(),
|
&& original_start.is_none(),
|
||||||
"UPDATE_BRIDGE_STARTS_REPLY"
|
"UPDATE_BRIDGE_STARTS_REPLY"
|
||||||
),
|
),
|
||||||
NativeControlOperation::Health { .. } => ensure!(
|
NativeControlOperation::Health { .. } => ensure!(
|
||||||
context.generation == Generation::Replacement
|
matches!(
|
||||||
&& journal.phase() == Phase::HealthVerified
|
(context.generation, journal.phase()),
|
||||||
&& reply.claim.is_none()
|
(Generation::Replacement, Phase::HealthVerified)
|
||||||
|
| (Generation::Restored, Phase::RollbackHealthVerified)
|
||||||
|
) && reply.claim.is_none()
|
||||||
&& original_start.is_none(),
|
&& original_start.is_none(),
|
||||||
"UPDATE_BRIDGE_HEALTH_REPLY"
|
"UPDATE_BRIDGE_HEALTH_REPLY"
|
||||||
),
|
),
|
||||||
@@ -377,6 +470,7 @@ impl<'a> FullBridge<'a> {
|
|||||||
claim: reply.claim,
|
claim: reply.claim,
|
||||||
original_start,
|
original_start,
|
||||||
original_outcome,
|
original_outcome,
|
||||||
|
pre_stop_sync,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
pub fn head_sha256(&self) -> Result<&str> {
|
pub fn head_sha256(&self) -> Result<&str> {
|
||||||
@@ -422,8 +516,21 @@ impl<'a> FullBridge<'a> {
|
|||||||
.context("UPDATE_BRIDGE_STARTED_EVENT_MISSING")?,
|
.context("UPDATE_BRIDGE_STARTED_EVENT_MISSING")?,
|
||||||
)?;
|
)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
matches!(last.evidence,rmm_updater_handoff::Evidence::ServicesStarted {services:actual,observation_sha256:hash,..}
|
match last.evidence {
|
||||||
if actual==services && hash==observation_sha256),
|
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"
|
"UPDATE_BRIDGE_STARTED_RESULT_CHANGED"
|
||||||
);
|
);
|
||||||
Ok(reply)
|
Ok(reply)
|
||||||
|
|||||||
@@ -6,7 +6,7 @@ use crate::{
|
|||||||
bridge::{BridgeContext, FullBridge, Generation},
|
bridge::{BridgeContext, FullBridge, Generation},
|
||||||
bundle, census,
|
bundle, census,
|
||||||
clock::NativeClock,
|
clock::NativeClock,
|
||||||
fence::LedgerFence,
|
fence::{LedgerFence, RollbackFence},
|
||||||
ledger::{OwnedInputs, OwnedLedger},
|
ledger::{OwnedInputs, OwnedLedger},
|
||||||
original::Original,
|
original::Original,
|
||||||
participants::{StableParticipant, verify_original_helper},
|
participants::{StableParticipant, verify_original_helper},
|
||||||
@@ -31,7 +31,7 @@ use rmm_updater_linux::{
|
|||||||
Budget, DurableEffectFence, Effect,
|
Budget, DurableEffectFence, Effect,
|
||||||
files::{Directory, HeldFile, LedgerGuard, Role},
|
files::{Directory, HeldFile, LedgerGuard, Role},
|
||||||
ipc::{self, Request, Response, State},
|
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 std::{ffi::OsStr, path::Path, time::Duration};
|
||||||
use uuid::Uuid;
|
use uuid::Uuid;
|
||||||
@@ -97,6 +97,12 @@ struct Queued {
|
|||||||
budget: Budget,
|
budget: Budget,
|
||||||
}
|
}
|
||||||
impl Runtime {
|
impl Runtime {
|
||||||
|
pub fn failed(&self) -> bool {
|
||||||
|
self.failed
|
||||||
|
}
|
||||||
|
pub fn terminal(&self) -> bool {
|
||||||
|
self.terminal
|
||||||
|
}
|
||||||
pub fn new(binding: Binding) -> Result<Self> {
|
pub fn new(binding: Binding) -> Result<Self> {
|
||||||
let clock = NativeClock::new()?;
|
let clock = NativeClock::new()?;
|
||||||
let budget = observation_budget()?;
|
let budget = observation_budget()?;
|
||||||
@@ -155,7 +161,7 @@ impl Runtime {
|
|||||||
let services = Systemd::new(self.old_policies.clone())?;
|
let services = Systemd::new(self.old_policies.clone())?;
|
||||||
let budget = observation_budget()?;
|
let budget = observation_budget()?;
|
||||||
if let Err(error) = listener.serve_one(&services, &budget, self) {
|
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;
|
self.failed = true;
|
||||||
}
|
}
|
||||||
return Err(error);
|
return Err(error);
|
||||||
@@ -226,6 +232,7 @@ impl Runtime {
|
|||||||
.verify_delegation(&header.delegation, &budget)?;
|
.verify_delegation(&header.delegation, &budget)?;
|
||||||
let reply = {
|
let reply = {
|
||||||
let mut bridge = FullBridge::original(BridgeContext {
|
let mut bridge = FullBridge::original(BridgeContext {
|
||||||
|
binding: &self.binding,
|
||||||
handoff: &header.handoff,
|
handoff: &header.handoff,
|
||||||
delegation: &header.delegation,
|
delegation: &header.delegation,
|
||||||
services: &services,
|
services: &services,
|
||||||
@@ -235,7 +242,19 @@ impl Runtime {
|
|||||||
health_public_key: self.health_key,
|
health_public_key: self.health_key,
|
||||||
generation: Generation::Original,
|
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 proof = reply.proof.context("UPDATE_ENGINE_ORIGINAL_PROOF")?;
|
||||||
let original = Original::verify(
|
let original = Original::verify(
|
||||||
@@ -281,6 +300,7 @@ impl Runtime {
|
|||||||
census::scan_admission(&targets, &known, self.registry.host_context(), &budget)?;
|
census::scan_admission(&targets, &known, self.registry.host_context(), &budget)?;
|
||||||
let mut bridge = FullBridge::new(
|
let mut bridge = FullBridge::new(
|
||||||
BridgeContext {
|
BridgeContext {
|
||||||
|
binding: &self.binding,
|
||||||
handoff: original.handoff(),
|
handoff: original.handoff(),
|
||||||
delegation: original.delegation(),
|
delegation: original.delegation(),
|
||||||
services: &services,
|
services: &services,
|
||||||
@@ -381,9 +401,10 @@ impl Runtime {
|
|||||||
ledger_identity_sha256: witnesses.ledger.sha256()?,
|
ledger_identity_sha256: witnesses.ledger.sha256()?,
|
||||||
})?;
|
})?;
|
||||||
// Do not hold a second connection before all readers really stopped.
|
// 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 stages = witnesses.files.reopen_stages(original.handoff(), &budget)?;
|
||||||
let mut fence = LedgerFence::new(&mut ledger)?;
|
let mut fence = LedgerFence::new(&mut ledger)?;
|
||||||
|
let mut installed = Vec::new();
|
||||||
for (stage, role) in
|
for (stage, role) in
|
||||||
stages
|
stages
|
||||||
.into_iter()
|
.into_iter()
|
||||||
@@ -396,23 +417,27 @@ impl Runtime {
|
|||||||
0,
|
0,
|
||||||
false,
|
false,
|
||||||
)?;
|
)?;
|
||||||
stage.install(&directory, &os, &budget, &mut fence)?;
|
installed.push(stage.install(&directory, &os, &budget, &mut fence)?);
|
||||||
}
|
}
|
||||||
fence.finish()?;
|
fence.finish()?;
|
||||||
ledger.append_observed(Evidence::PairVerified {
|
ledger.append_observed(Evidence::PairVerified {
|
||||||
pair: original.handoff().target.clone(),
|
pair: original.handoff().target.clone(),
|
||||||
retained_state_sha256: original.handoff().retained_state_sha256.clone(),
|
retained_state_sha256: original.handoff().retained_state_sha256.clone(),
|
||||||
})
|
})?;
|
||||||
|
Ok(installed)
|
||||||
})();
|
})();
|
||||||
if let Err(error) = swap {
|
let installed = match swap {
|
||||||
// Exactly one best-effort ORIGINAL Unknown CAS while we still own
|
Ok(installed) => installed,
|
||||||
// the real guard. Failure is preserved; no restoration or retry.
|
Err(error) => {
|
||||||
let _ = ledger.mark_unknown(
|
// Exactly one best-effort ORIGINAL Unknown CAS while we still own
|
||||||
u64::try_from(self.clock.now()?.timestamp())?,
|
// the real guard. Failure is preserved; no restoration or retry.
|
||||||
rmm_updater_handoff::UnknownReason::ReplaceUncertain,
|
let _ = ledger.mark_unknown(
|
||||||
);
|
u64::try_from(self.clock.now()?.timestamp())?,
|
||||||
return Err(error);
|
rmm_updater_handoff::UnknownReason::ReplaceUncertain,
|
||||||
}
|
);
|
||||||
|
return Err(error);
|
||||||
|
}
|
||||||
|
};
|
||||||
let prepared = ledger.prepare_return_and_close()?;
|
let prepared = ledger.prepare_return_and_close()?;
|
||||||
// The original DB is actually closed. End the continuous census/lock
|
// The original DB is actually closed. End the continuous census/lock
|
||||||
// borrow before the same concrete guard can be consumed by Return.
|
// borrow before the same concrete guard can be consumed by Return.
|
||||||
@@ -432,6 +457,7 @@ impl Runtime {
|
|||||||
let observer = Systemd::new(target_policies)?;
|
let observer = Systemd::new(target_policies)?;
|
||||||
let mut bridge = FullBridge::new(
|
let mut bridge = FullBridge::new(
|
||||||
BridgeContext {
|
BridgeContext {
|
||||||
|
binding: &self.binding,
|
||||||
handoff: original.handoff(),
|
handoff: original.handoff(),
|
||||||
delegation: original.delegation(),
|
delegation: original.delegation(),
|
||||||
services: &observer,
|
services: &observer,
|
||||||
@@ -447,8 +473,139 @@ impl Runtime {
|
|||||||
agent_startup.verify()?;
|
agent_startup.verify()?;
|
||||||
os.release(&budget, &mut fence)?;
|
os.release(&budget, &mut fence)?;
|
||||||
agent_startup.return_after_root_release(&budget)?;
|
agent_startup.return_after_root_release(&budget)?;
|
||||||
let started = stopped.start_once(target, &budget, &mut fence)?;
|
let started = match stopped.start_once_observed(target, &budget, &mut fence)? {
|
||||||
fence.finish()?;
|
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)?;
|
bridge.observe_starts(&started)?;
|
||||||
loop {
|
loop {
|
||||||
original.check_current(&self.binding, &self.clock, &budget)?;
|
original.check_current(&self.binding, &self.clock, &budget)?;
|
||||||
|
|||||||
@@ -118,3 +118,107 @@ impl DurableEffectFence for LedgerFence<'_, '_, '_> {
|
|||||||
self.observe(effect, observation_sha256)
|
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(())
|
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> {
|
fn file(&self, which: FileRole) -> Result<&Proof> {
|
||||||
let role = role(which)?;
|
let role = role(which)?;
|
||||||
self.files
|
self.files
|
||||||
|
|||||||
@@ -36,6 +36,81 @@ pub struct FullFiles {
|
|||||||
rendered: LinuxFullTransition,
|
rendered: LinuxFullTransition,
|
||||||
}
|
}
|
||||||
impl FullFiles {
|
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
|
/// `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
|
/// LOCAL policy, not an update job, IPC request or manifest. The exact key
|
||||||
/// identity is additionally bound to the approved Full transition proof.
|
/// identity is additionally bound to the approved Full transition proof.
|
||||||
|
|||||||
@@ -1,757 +1,28 @@
|
|||||||
//! Read-only current-version history verification under the actual retained
|
//! Shared admission history; native Linux fixtures remain here.
|
||||||
//! executor guard. Every input file must already have been independently opened
|
pub use rmm_update_history::verify_history;
|
||||||
//! 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))
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
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,
|
// Historical in-memory bytes only: no service, filesystem, real operation,
|
||||||
// current authority or simulated WebUI approval is created by this fixture.
|
// current authority or simulated WebUI approval is created by this fixture.
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|||||||
@@ -212,6 +212,12 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
|||||||
NativeEffect::PublishReplacement { role } => {
|
NativeEffect::PublishReplacement { role } => {
|
||||||
self.native_observation_sha256(file_role(*role), true)?
|
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"),
|
_ => anyhow::bail!("UPDATE_OWNED_OBSERVATION_NOT_ALLOWED"),
|
||||||
};
|
};
|
||||||
ensure!(expected == observation, "UPDATE_NATIVE_OBSERVATION_CHANGED");
|
ensure!(expected == observation, "UPDATE_NATIVE_OBSERVATION_CHANGED");
|
||||||
@@ -243,6 +249,19 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
|||||||
pub fn verify_pair(&self) -> Result<()> {
|
pub fn verify_pair(&self) -> Result<()> {
|
||||||
self.guard.files.verify_pair(self.guard.budget)
|
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> {
|
pub fn inflight_proof(&self) -> Result<rmm_domain::agent_update::UpdateInflightProof> {
|
||||||
let journal = self.journal()?;
|
let journal = self.journal()?;
|
||||||
let mut statement = self.db.prepare(
|
let mut statement = self.db.prepare(
|
||||||
@@ -291,6 +310,71 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
|||||||
old_services,
|
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
|
/// Close the actual SQLite connection BEFORE returning the OS flock. An
|
||||||
/// open/failed-close connection never produces a released-ledger witness.
|
/// open/failed-close connection never produces a released-ledger witness.
|
||||||
pub fn close(self) -> Result<()> {
|
pub fn close(self) -> Result<()> {
|
||||||
@@ -443,6 +527,81 @@ impl UpdateParticipantGuard for OwnedGuard<'_, '_> {
|
|||||||
);
|
);
|
||||||
}
|
}
|
||||||
Evidence::LedgerReturnIntent => self.files.verify_pair(self.budget)?,
|
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"),
|
_ => anyhow::bail!("UPDATE_EVENT_WRITER_NOT_ALLOWED"),
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
@@ -492,8 +651,123 @@ impl UpdateParticipantGuard for OwnedGuard<'_, '_> {
|
|||||||
| (NativeEffect::StartService { .. }, NativeEffectStage::ReserveFutureStart) => {
|
| (NativeEffect::StartService { .. }, NativeEffectStage::ReserveFutureStart) => {
|
||||||
self.files.verify_pair(self.budget)?
|
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"),
|
_ => anyhow::bail!("UPDATE_NATIVE_OWNED_EFFECT_DENIED"),
|
||||||
}
|
}
|
||||||
Ok(())
|
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(())
|
Ok(())
|
||||||
}
|
}
|
||||||
pub fn verify_admission(&self, policy: &LocalUpdatePolicy, budget: &Budget) -> Result<()> {
|
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<()> {
|
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(
|
fn verify_phase(
|
||||||
&self,
|
&self,
|
||||||
policy: &LocalUpdatePolicy,
|
policy: &LocalUpdatePolicy,
|
||||||
budget: &Budget,
|
budget: &Budget,
|
||||||
stopped: bool,
|
stopped: bool,
|
||||||
|
failed: Option<&rmm_updater_linux::services::FailedStartProof>,
|
||||||
) -> Result<()> {
|
) -> Result<()> {
|
||||||
budget.check()?;
|
budget.check()?;
|
||||||
self.verify_protected()?;
|
self.verify_protected()?;
|
||||||
@@ -269,7 +281,15 @@ impl QualifiedRegistry {
|
|||||||
for (index, unit) in self.registry.units.iter().enumerate() {
|
for (index, unit) in self.registry.units.iter().enumerate() {
|
||||||
let active = index < 4 && (!stopped || index == 3);
|
let active = index < 4 && (!stopped || index == 3);
|
||||||
let status = observe(unit, budget)?;
|
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);
|
first.insert(unit.unit.clone(), status);
|
||||||
}
|
}
|
||||||
for unit in &self.registry.rollback_timers {
|
for unit in &self.registry.rollback_timers {
|
||||||
@@ -586,6 +606,41 @@ impl Status {
|
|||||||
&& self.connections.is_none_or(|n| n == 0)
|
&& self.connections.is_none_or(|n| n == 0)
|
||||||
&& self.fields["Job"].is_empty()
|
&& 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<()> {
|
fn verify(&self, unit: &Unit, active: bool, original_reader: bool) -> Result<()> {
|
||||||
let fields = &self.fields;
|
let fields = &self.fields;
|
||||||
ensure!(
|
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)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|||||||
@@ -8,7 +8,7 @@ use ed25519_dalek::{Signature, VerifyingKey};
|
|||||||
use rmm_agent_core::update_handoff::NativeEffect;
|
use rmm_agent_core::update_handoff::NativeEffect;
|
||||||
use rmm_domain::{
|
use rmm_domain::{
|
||||||
agent_update::ResolvedAgentUpdate,
|
agent_update::ResolvedAgentUpdate,
|
||||||
agent_update_provisioning::{ActivationEvidence, InstalledReleaseRecord, MAX_RECORD_BYTES},
|
agent_update_provisioning::{InstalledReleaseRecord, MAX_RECORD_BYTES},
|
||||||
jobs::hash,
|
jobs::hash,
|
||||||
};
|
};
|
||||||
use rmm_updater_handoff::{
|
use rmm_updater_handoff::{
|
||||||
@@ -131,41 +131,15 @@ impl BuiltRecord {
|
|||||||
update.validate() && !grant_id.is_nil() && !owner_nonce.is_nil(),
|
update.validate() && !grant_id.is_nil() && !owner_nonce.is_nil(),
|
||||||
"UPDATE_RECORD_INPUT"
|
"UPDATE_RECORD_INPUT"
|
||||||
);
|
);
|
||||||
let prior = InstalledReleaseRecord::from_bytes(prior_raw).map_err(anyhow::Error::msg)?;
|
let record = rmm_domain::agent_update_provisioning::assemble_updated_record(
|
||||||
let parent = prior
|
update,
|
||||||
.release_envelope
|
prior_raw,
|
||||||
.decode()
|
handoff_sha256,
|
||||||
.map_err(anyhow::Error::msg)?;
|
signed,
|
||||||
let target = update.manifest().map_err(anyhow::Error::msg)?;
|
receipt,
|
||||||
|
)
|
||||||
|
.map_err(anyhow::Error::msg)?;
|
||||||
let old_sha256 = hash(prior_raw);
|
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 raw = record.bytes().map_err(anyhow::Error::msg)?;
|
||||||
let sha256 = hash(&raw);
|
let sha256 = hash(&raw);
|
||||||
ensure!(sha256 != old_sha256, "UPDATE_RECORD_SAME_BYTES");
|
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.
|
// method, never a real release/Health/approval or a simulated target job.
|
||||||
use super::*;
|
use super::*;
|
||||||
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
|
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};
|
use std::{fs, os::unix::fs::DirBuilderExt, path::PathBuf, time::Duration};
|
||||||
|
|
||||||
struct Fixture(PathBuf);
|
struct Fixture(PathBuf);
|
||||||
|
|||||||
@@ -87,7 +87,12 @@ impl RetainedSet {
|
|||||||
"UPDATE_RETAINED_CODE_PATH"
|
"UPDATE_RETAINED_CODE_PATH"
|
||||||
);
|
);
|
||||||
let parent = spec.path.parent().context("UPDATE_RETAINED_PARENT")?;
|
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()
|
let file = std::fs::OpenOptions::new()
|
||||||
.read(true)
|
.read(true)
|
||||||
.custom_flags(libc::O_NOFOLLOW | libc::O_NONBLOCK | libc::O_CLOEXEC)
|
.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::{
|
use rmm_updater_linux::{
|
||||||
Budget, DurableEffectFence, Effect,
|
Budget, DurableEffectFence, Effect,
|
||||||
files::{Directory, Identity, LedgerIdentity},
|
files::{Directory, Identity, LedgerIdentity},
|
||||||
services::{Service, ServiceProof, Systemd},
|
services::{FailedStartProof, KnownStartupFailure, Service, ServiceProof, Systemd},
|
||||||
};
|
};
|
||||||
use std::{
|
use std::{
|
||||||
fs::OpenOptions,
|
fs::OpenOptions,
|
||||||
@@ -103,7 +103,13 @@ impl<'a> Reservation<'a> {
|
|||||||
.updater
|
.updater
|
||||||
.verify_delegation(self.context.original.delegation(), self.context.budget)?;
|
.verify_delegation(self.context.original.delegation(), self.context.budget)?;
|
||||||
self.context.retained.verify()?;
|
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
|
self.context
|
||||||
.trust
|
.trust
|
||||||
.recheck(self.context.original, self.context.clock)?;
|
.recheck(self.context.original, self.context.clock)?;
|
||||||
@@ -121,22 +127,31 @@ impl<'a> Reservation<'a> {
|
|||||||
.map_err(anyhow::Error::msg)?;
|
.map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
observed.bytes()? == h.bytes()?
|
observed.bytes()? == h.bytes()?
|
||||||
&& journal.phase() == rmm_updater_handoff::Phase::LedgerReturnIntent
|
&& matches!(
|
||||||
&& self.claims.return_ledger.effect() == &NativeEffect::ReturnLedger,
|
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"
|
"UPDATE_RETURN_RESERVATION_BINDING"
|
||||||
);
|
);
|
||||||
for (index, claim) in self.claims.starts.iter().enumerate() {
|
for (index, claim) in self.claims.starts.iter().enumerate() {
|
||||||
ensure!(
|
let service = [
|
||||||
claim.effect()
|
NativeService::General,
|
||||||
== &NativeEffect::StartService {
|
NativeService::Full,
|
||||||
service: [
|
NativeService::Agent,
|
||||||
NativeService::General,
|
][index];
|
||||||
NativeService::Full,
|
let expected = if self.rollback()? {
|
||||||
NativeService::Agent
|
NativeEffect::RollbackStartService { service }
|
||||||
][index]
|
} else {
|
||||||
},
|
NativeEffect::StartService { service }
|
||||||
"UPDATE_RETURN_START_ORDER"
|
};
|
||||||
);
|
ensure!(claim.effect() == &expected, "UPDATE_RETURN_START_ORDER");
|
||||||
}
|
}
|
||||||
for claim in std::iter::once(&self.claims.return_ledger).chain(self.claims.starts.iter()) {
|
for claim in std::iter::once(&self.claims.return_ledger).chain(self.claims.starts.iter()) {
|
||||||
ensure!(
|
ensure!(
|
||||||
@@ -151,6 +166,14 @@ impl<'a> Reservation<'a> {
|
|||||||
verify_identity_files(&self.context.ledger)?;
|
verify_identity_files(&self.context.ledger)?;
|
||||||
Ok(())
|
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
|
/// The OS release primitive consumes its real guard, and the borrow on
|
||||||
/// StoppedServices then ends. This fence never closes/unlocks another PID.
|
/// StoppedServices then ends. This fence never closes/unlocks another PID.
|
||||||
pub fn start_fence<'b>(
|
pub fn start_fence<'b>(
|
||||||
@@ -181,7 +204,7 @@ pub struct StartFence<'a, 'b> {
|
|||||||
pending: Option<Service>,
|
pending: Option<Service>,
|
||||||
poisoned: bool,
|
poisoned: bool,
|
||||||
}
|
}
|
||||||
impl StartFence<'_, '_> {
|
impl<'a, 'b> StartFence<'a, 'b> {
|
||||||
pub fn finish(self) -> Result<()> {
|
pub fn finish(self) -> Result<()> {
|
||||||
ensure!(
|
ensure!(
|
||||||
!self.poisoned && self.return_checked && self.next == 3 && self.pending.is_none(),
|
!self.poisoned && self.return_checked && self.next == 3 && self.pending.is_none(),
|
||||||
@@ -189,6 +212,121 @@ impl StartFence<'_, '_> {
|
|||||||
);
|
);
|
||||||
Ok(())
|
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<'_, '_> {
|
impl DurableEffectFence for StartFence<'_, '_> {
|
||||||
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
|
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
|
||||||
|
|||||||
@@ -73,19 +73,98 @@ impl TrustState {
|
|||||||
/// EXACT ORIGINAL evidence only. The separate historical keyring below
|
/// EXACT ORIGINAL evidence only. The separate historical keyring below
|
||||||
/// never supplies current admission, Health, Finalize or effect authority.
|
/// never supplies current admission, Health, Finalize or effect authority.
|
||||||
pub fn load_retained(original: &Original, binding: &Binding) -> Result<Self> {
|
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 mut protected = Vec::new();
|
||||||
let (file, raw) = Protected::read(Path::new("/etc/rmm-agent-updater/policy.json"), 65536)?;
|
let (file, raw) = Protected::read(Path::new("/etc/rmm-agent-updater/policy.json"), 65536)?;
|
||||||
let (policy, policy_hash) =
|
let (policy, policy_hash) =
|
||||||
LocalUpdatePolicy::from_bytes(&raw).map_err(anyhow::Error::msg)?;
|
LocalUpdatePolicy::from_bytes(&raw).map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
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.asset_id == binding.asset_id
|
||||||
&& policy.agent_id == binding.agent_id
|
&& policy.agent_id == binding.agent_id
|
||||||
&& policy.enrollment_generation == binding.enrollment_generation
|
&& policy.enrollment_generation == binding.enrollment_generation
|
||||||
&& policy.assignment_version == binding.assignment_version
|
&& policy.assignment_version == binding.assignment_version,
|
||||||
&& policy.updater_binary_sha256 == update.updater.binary_sha256,
|
|
||||||
"UPDATE_PROTECTED_POLICY_CHANGED"
|
"UPDATE_PROTECTED_POLICY_CHANGED"
|
||||||
);
|
);
|
||||||
protected.push(file);
|
protected.push(file);
|
||||||
@@ -97,12 +176,8 @@ impl TrustState {
|
|||||||
protected.push(file);
|
protected.push(file);
|
||||||
let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?;
|
let (file, raw) = Protected::read(Path::new(&policy.keyring_path), 16384)?;
|
||||||
let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?;
|
let keys: UpdateKeyringFile = serde_json::from_slice(&raw)?;
|
||||||
ensure!(
|
ensure!(keys.validate(), "UPDATE_PROTECTED_KEYRING_CHANGED");
|
||||||
keys.validate()
|
let keyring_sha256 = hash(&raw);
|
||||||
&& keys.generation == update.updater.keyring_generation
|
|
||||||
&& hash(&raw) == update.updater.keyring_sha256,
|
|
||||||
"UPDATE_PROTECTED_KEYRING_CHANGED"
|
|
||||||
);
|
|
||||||
protected.push(file);
|
protected.push(file);
|
||||||
let job_key = hex::decode(&binding.public_key_hex)?;
|
let job_key = hex::decode(&binding.public_key_hex)?;
|
||||||
let mut trusted = Vec::new();
|
let mut trusted = Vec::new();
|
||||||
@@ -171,8 +246,6 @@ impl TrustState {
|
|||||||
let health_public_key = health.public_key().map_err(anyhow::Error::msg)?;
|
let health_public_key = health.public_key().map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
!VerifyingKey::from_bytes(&health_public_key)?.is_weak()
|
!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
|
&& health_public_key.as_slice() != job_key
|
||||||
&& keys
|
&& keys
|
||||||
.keys
|
.keys
|
||||||
@@ -180,17 +253,14 @@ impl TrustState {
|
|||||||
.all(|key| key.public_key_hex != hex::encode(health_public_key)),
|
.all(|key| key.public_key_hex != hex::encode(health_public_key)),
|
||||||
"UPDATE_HEALTH_KEY_NOT_SEPARATE_OR_CHANGED"
|
"UPDATE_HEALTH_KEY_NOT_SEPARATE_OR_CHANGED"
|
||||||
);
|
);
|
||||||
|
let health_key_pin_sha256 = hash(&raw);
|
||||||
protected.push(file);
|
protected.push(file);
|
||||||
let (file, raw) = Protected::read(Path::new(&policy.installed_record_path), 32768)?;
|
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)?;
|
let installed = InstalledReleaseRecord::from_bytes(&raw).map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
ensure!(
|
||||||
!installed.rolled_back
|
!installed.rolled_back
|
||||||
&& installed.activation_floor >= policy.initial_activation_floor
|
&& 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"
|
"UPDATE_INSTALLED_FLOOR_OR_TIME"
|
||||||
);
|
);
|
||||||
if matches!(
|
if matches!(
|
||||||
@@ -208,37 +278,53 @@ impl TrustState {
|
|||||||
.release_envelope
|
.release_envelope
|
||||||
.decode()
|
.decode()
|
||||||
.map_err(anyhow::Error::msg)?;
|
.map_err(anyhow::Error::msg)?;
|
||||||
ensure!(
|
let predecessor = rmm_domain::agent_update::Predecessor {
|
||||||
active.manifest.release_id == update.predecessor.release_id
|
release_id: active.manifest.release_id,
|
||||||
&& active.manifest.release_sequence == update.predecessor.release_sequence
|
release_sequence: active.manifest.release_sequence,
|
||||||
&& installed.manifest_sha256 == update.predecessor.manifest_sha256
|
manifest_sha256: installed.manifest_sha256.clone(),
|
||||||
&& active.manifest.artifacts[0].sha256 == update.predecessor.agent_sha256
|
installed_record_sha256: hash(&raw),
|
||||||
&& active.manifest.artifacts[1].sha256 == update.predecessor.helper_sha256,
|
agent_sha256: active.manifest.artifacts[0].sha256.clone(),
|
||||||
"UPDATE_INSTALLED_PREDECESSOR_BINDING"
|
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_installed_release(&historical, &installed, keys.generation)?;
|
||||||
verify(
|
if let Some(update) = update {
|
||||||
&historical,
|
verify(
|
||||||
&update.release_envelope,
|
&historical,
|
||||||
&TrustedContext {
|
&update.release_envelope,
|
||||||
platform: ReleasePlatform::LinuxX64,
|
&TrustedContext {
|
||||||
now_utc_seconds: u64::try_from(original.delegation().prepared_at.timestamp())?,
|
platform: ReleasePlatform::LinuxX64,
|
||||||
keyring_generation: keys.generation,
|
now_utc_seconds: u64::try_from(prepared_at.timestamp())?,
|
||||||
protocol_major: active.manifest.protocol_major,
|
keyring_generation: keys.generation,
|
||||||
state_schema: active.manifest.state_schema,
|
protocol_major: active.manifest.protocol_major,
|
||||||
updater_version: 1,
|
state_schema: active.manifest.state_schema,
|
||||||
minimum_release_sequence: installed.activation_floor,
|
updater_version: 1,
|
||||||
active_release: Some(ActiveRelease {
|
minimum_release_sequence: installed.activation_floor,
|
||||||
sequence: active.manifest.release_sequence,
|
active_release: Some(ActiveRelease {
|
||||||
manifest_sha256: installed.manifest_sha256.clone(),
|
sequence: active.manifest.release_sequence,
|
||||||
}),
|
manifest_sha256: installed.manifest_sha256.clone(),
|
||||||
},
|
}),
|
||||||
)?;
|
},
|
||||||
|
)?;
|
||||||
|
}
|
||||||
protected.push(file);
|
protected.push(file);
|
||||||
let baseline_signer_revoked = baseline_entry.revoked;
|
let baseline_signer_revoked = baseline_entry.revoked;
|
||||||
Ok(Self {
|
Ok(Self {
|
||||||
updater_binding: update.updater.clone(),
|
updater_binding,
|
||||||
predecessor: update.predecessor.clone(),
|
predecessor,
|
||||||
protected,
|
protected,
|
||||||
policy,
|
policy,
|
||||||
installed,
|
installed,
|
||||||
@@ -255,6 +341,25 @@ impl TrustState {
|
|||||||
self.recheck_crypto(original, clock)
|
self.recheck_crypto(original, clock)
|
||||||
}
|
}
|
||||||
fn recheck_crypto(&self, original: &Original, clock: &NativeClock) -> Result<()> {
|
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!(
|
ensure!(
|
||||||
!self.baseline_signer_revoked,
|
!self.baseline_signer_revoked,
|
||||||
"UPDATE_BASELINE_SIGNER_REVOKED"
|
"UPDATE_BASELINE_SIGNER_REVOKED"
|
||||||
@@ -262,7 +367,7 @@ impl TrustState {
|
|||||||
verify_installed_release(
|
verify_installed_release(
|
||||||
&self.keyring,
|
&self.keyring,
|
||||||
&self.installed,
|
&self.installed,
|
||||||
original.update().updater.keyring_generation,
|
update.updater.keyring_generation,
|
||||||
)?;
|
)?;
|
||||||
let active = self
|
let active = self
|
||||||
.installed
|
.installed
|
||||||
@@ -271,11 +376,11 @@ impl TrustState {
|
|||||||
.map_err(anyhow::Error::msg)?;
|
.map_err(anyhow::Error::msg)?;
|
||||||
verify(
|
verify(
|
||||||
&self.keyring,
|
&self.keyring,
|
||||||
&original.update().release_envelope,
|
&update.release_envelope,
|
||||||
&TrustedContext {
|
&TrustedContext {
|
||||||
platform: ReleasePlatform::LinuxX64,
|
platform: ReleasePlatform::LinuxX64,
|
||||||
now_utc_seconds: u64::try_from(clock.now()?.timestamp())?,
|
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,
|
protocol_major: active.manifest.protocol_major,
|
||||||
state_schema: active.manifest.state_schema,
|
state_schema: active.manifest.state_schema,
|
||||||
updater_version: 1,
|
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
|
vorbereitet; er ist noch nicht ausgeführt. Details, frühere fehlgeschlagene
|
||||||
Fixtureprüfung und verbleibende MVP-Gates stehen im
|
Fixtureprüfung und verbleibende MVP-Gates stehen im
|
||||||
[Readercensusnachweis](agent-updater-reader-census-results.md).
|
[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