Add reviewed Windows scope completion and idle certificate renewal; deploy completion API
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -706,6 +706,8 @@ pub enum NativeService {
|
||||
Agent,
|
||||
General,
|
||||
Full,
|
||||
WindowsAgent,
|
||||
WindowsHelper,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
@@ -714,6 +716,9 @@ pub enum NativeFileRole {
|
||||
HelperBinary,
|
||||
FullConfig,
|
||||
FullPin,
|
||||
WindowsSettings,
|
||||
WindowsPin,
|
||||
WindowsTimeProfile,
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum NativeEffectStage {
|
||||
@@ -747,9 +752,9 @@ impl NativeEffectClaim {
|
||||
self.claimed_at
|
||||
}
|
||||
}
|
||||
pub struct PreparedReturnClaims {
|
||||
pub struct PreparedReturnClaims<const N: usize = 3> {
|
||||
pub return_ledger: NativeEffectClaim,
|
||||
pub starts: [NativeEffectClaim; 3],
|
||||
pub starts: [NativeEffectClaim; N],
|
||||
}
|
||||
fn native_context(
|
||||
db: &Connection,
|
||||
@@ -781,6 +786,9 @@ fn native_role(role: NativeFileRole) -> rmm_updater_handoff::FileRole {
|
||||
NativeFileRole::HelperBinary => F::HelperBinary,
|
||||
NativeFileRole::FullConfig => F::LinuxFullConfig,
|
||||
NativeFileRole::FullPin => F::LinuxFullPin,
|
||||
NativeFileRole::WindowsSettings => F::WindowsSettings,
|
||||
NativeFileRole::WindowsPin => F::WindowsPin,
|
||||
NativeFileRole::WindowsTimeProfile => F::WindowsTimeProfile,
|
||||
}
|
||||
}
|
||||
fn native_service(service: NativeService) -> rmm_updater_handoff::Service {
|
||||
@@ -789,6 +797,8 @@ fn native_service(service: NativeService) -> rmm_updater_handoff::Service {
|
||||
NativeService::Agent => S::LinuxAgent,
|
||||
NativeService::General => S::LinuxGeneralHelper,
|
||||
NativeService::Full => S::LinuxFullHelper,
|
||||
NativeService::WindowsAgent => S::WindowsAgent,
|
||||
NativeService::WindowsHelper => S::WindowsHelper,
|
||||
}
|
||||
}
|
||||
fn native_key(effect: &NativeEffect) -> Result<String> {
|
||||
@@ -976,6 +986,50 @@ pub fn prepare_return_and_starts(
|
||||
return_event: &[u8],
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<PreparedReturnClaims> {
|
||||
prepare_return_for(
|
||||
db,
|
||||
guard,
|
||||
grant,
|
||||
expected_head,
|
||||
return_event,
|
||||
now,
|
||||
[
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
],
|
||||
)
|
||||
}
|
||||
/// Windows' independently qualified SYSTEM helper returns the SAME retained
|
||||
/// ledger before exactly Helper -> Agent. No Linux Full/General identity or
|
||||
/// startup claim is invented. This is evidence, never a restart/resume token.
|
||||
pub fn prepare_windows_return_and_starts(
|
||||
db: &mut Connection,
|
||||
guard: &impl UpdateParticipantGuard,
|
||||
grant: Uuid,
|
||||
expected_head: &str,
|
||||
return_event: &[u8],
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<PreparedReturnClaims<2>> {
|
||||
prepare_return_for(
|
||||
db,
|
||||
guard,
|
||||
grant,
|
||||
expected_head,
|
||||
return_event,
|
||||
now,
|
||||
[NativeService::WindowsHelper, NativeService::WindowsAgent],
|
||||
)
|
||||
}
|
||||
fn prepare_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 j) = native_context(&tx, guard, grant, now)?;
|
||||
ensure!(
|
||||
@@ -985,8 +1039,21 @@ pub fn prepare_return_and_starts(
|
||||
"UPDATE_NATIVE_RETURN_ROLE"
|
||||
);
|
||||
ensure!(
|
||||
h.stop_set
|
||||
.contains(&rmm_updater_handoff::Service::LinuxFullHelper),
|
||||
(sequence.as_slice()
|
||||
== [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent
|
||||
]
|
||||
&& h.stop_set
|
||||
.contains(&rmm_updater_handoff::Service::LinuxFullHelper))
|
||||
|| (sequence.as_slice() == [NativeService::WindowsHelper, NativeService::WindowsAgent]
|
||||
&& h.pin_transition == rmm_updater_handoff::PinTransition::WindowsCodePairClockV1
|
||||
&& h.stop_set
|
||||
== [
|
||||
rmm_updater_handoff::Service::WindowsAgent,
|
||||
rmm_updater_handoff::Service::WindowsHelper
|
||||
]),
|
||||
"UPDATE_NATIVE_FULL_PROFILE_REQUIRED"
|
||||
);
|
||||
let missing:u64=tx.query_row("SELECT count(*) FROM agent_update_native_claims c LEFT JOIN agent_update_native_observations o ON c.grant_id=o.grant_id AND c.effect_key=o.effect_key WHERE c.grant_id=?1 AND o.effect_key IS NULL",[grant.to_string()],|r|r.get(0))?;
|
||||
@@ -1004,11 +1071,7 @@ pub fn prepare_return_and_starts(
|
||||
&NativeEffect::ReturnLedger,
|
||||
NativeEffectStage::Claim,
|
||||
)?;
|
||||
for service in [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
] {
|
||||
for service in sequence {
|
||||
guard.verify_native_effect(
|
||||
&h,
|
||||
&d,
|
||||
@@ -1021,11 +1084,7 @@ pub fn prepare_return_and_starts(
|
||||
let return_ledger =
|
||||
insert_native_claim(&tx, &h, j.head_sha256(), NativeEffect::ReturnLedger, now)?;
|
||||
let mut starts = Vec::new();
|
||||
for service in [
|
||||
NativeService::General,
|
||||
NativeService::Full,
|
||||
NativeService::Agent,
|
||||
] {
|
||||
for service in sequence {
|
||||
starts.push(insert_native_claim(
|
||||
&tx,
|
||||
&h,
|
||||
|
||||
@@ -32,6 +32,7 @@ rmm-domain = { path = "../domain" }
|
||||
rmm-agent-core = { path = "../agent-core" }
|
||||
rmm-protocol = { path = "../protocol" }
|
||||
rmm-time-attestation = { path = "../time-attestation" }
|
||||
rmm-updater-handoff = { path = "../updater-handoff" }
|
||||
rusqlite = { version = "0.32.1", features = ["bundled"] }
|
||||
fs2 = "0.4.3"
|
||||
x509-parser = { version = "=0.18.1", features = ["verify"] }
|
||||
|
||||
@@ -0,0 +1,473 @@
|
||||
//! Explicit passive-certificate qualification on a separate fixture identity.
|
||||
//! Run only as a child of the existing LocalService agent, after WebUI approval.
|
||||
//! No original agent state, certificate, service configuration or key is read.
|
||||
#[cfg(windows)]
|
||||
mod native {
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::Utc;
|
||||
use prost::Message;
|
||||
use rcgen::{CertificateParams, DnType, KeyPair};
|
||||
use rmm_agent_windows::{
|
||||
certificate_rotation::{DeviceIdentity, ProtectedKeyFiles, RotationStore},
|
||||
journal::Journal,
|
||||
native,
|
||||
};
|
||||
use rmm_protocol::{
|
||||
ClientHello, EnrollmentRequest, EnrollmentResponse, Envelope, Heartbeat, MessageBatch,
|
||||
Payload,
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{fs, io::Write, net::SocketAddr, path::Path, time::Duration};
|
||||
use uuid::Uuid;
|
||||
|
||||
const SERVER: &str = "discovery.ease-technologies.de";
|
||||
const PERMANENT_AGENT: &str = "63ea15b2-0643-403d-b5b4-cba1288dbea3";
|
||||
|
||||
fn hash(bytes: &[u8]) -> String {
|
||||
format!("{:x}", Sha256::digest(bytes))
|
||||
}
|
||||
fn read(path: &Path, maximum: usize) -> Result<Vec<u8>> {
|
||||
native::private_path(path, false)?;
|
||||
ensure!(
|
||||
fs::metadata(path)?.len() <= maximum as u64,
|
||||
"FIXTURE_FILE_LIMIT"
|
||||
);
|
||||
Ok(fs::read(path)?)
|
||||
}
|
||||
fn create(path: &Path, bytes: &[u8]) -> Result<()> {
|
||||
let mut file = fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.open(path)?;
|
||||
// The fixture directory must provide its inherited service DACL before
|
||||
// any private bytes are written, exactly like ProtectedKeyFiles.
|
||||
native::private_path(path, false)?;
|
||||
file.write_all(bytes)?;
|
||||
file.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
fn client(ca: &[u8], identity: Option<&DeviceIdentity>) -> Result<reqwest::Client> {
|
||||
let address: SocketAddr = "88.99.80.202:443".parse()?;
|
||||
let mut builder = reqwest::Client::builder()
|
||||
.https_only(true)
|
||||
.tls_built_in_root_certs(false)
|
||||
.add_root_certificate(reqwest::Certificate::from_pem(ca)?)
|
||||
.resolve(SERVER, address)
|
||||
.no_proxy()
|
||||
.redirect(reqwest::redirect::Policy::none())
|
||||
.timeout(Duration::from_secs(10));
|
||||
if let Some(identity) = identity {
|
||||
let mut pair = identity.certificate_pem.clone();
|
||||
pair.extend_from_slice(&identity.private_key_pem);
|
||||
builder = builder.identity(reqwest::Identity::from_pem(&pair)?);
|
||||
}
|
||||
Ok(builder.build()?)
|
||||
}
|
||||
async fn body(mut response: reqwest::Response, content_type: &str) -> Result<Vec<u8>> {
|
||||
ensure!(response.status().as_u16() == 200, "FIXTURE_HTTP_STATUS");
|
||||
ensure!(
|
||||
response
|
||||
.headers()
|
||||
.get(reqwest::header::CONTENT_TYPE)
|
||||
.and_then(|v| v.to_str().ok())
|
||||
== Some(content_type),
|
||||
"FIXTURE_CONTENT_TYPE"
|
||||
);
|
||||
let mut result = Vec::new();
|
||||
while let Some(chunk) = response.chunk().await? {
|
||||
ensure!(
|
||||
result.len().saturating_add(chunk.len()) <= 65536,
|
||||
"FIXTURE_RESPONSE_LIMIT"
|
||||
);
|
||||
result.extend_from_slice(&chunk);
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
fn certificate_hash(pem: &[u8]) -> Result<String> {
|
||||
let mut cursor = std::io::Cursor::new(pem);
|
||||
let mut certificates = rustls_pemfile::certs(&mut cursor);
|
||||
Ok(hash(
|
||||
certificates
|
||||
.next()
|
||||
.context("FIXTURE_CERTIFICATE")??
|
||||
.as_ref(),
|
||||
))
|
||||
}
|
||||
fn envelope(
|
||||
journal: &mut Journal,
|
||||
agent: &str,
|
||||
boot: &str,
|
||||
generation: u64,
|
||||
payload: Payload,
|
||||
) -> Result<Envelope> {
|
||||
Ok(Envelope {
|
||||
protocol_major: 1,
|
||||
protocol_minor: 0,
|
||||
message_id: Uuid::new_v4().to_string(),
|
||||
agent_id: agent.into(),
|
||||
enrollment_generation: 1,
|
||||
connection_generation: generation,
|
||||
boot_id: boot.into(),
|
||||
sequence: journal.next_sequence()?,
|
||||
observed_at: Utc::now().timestamp_millis(),
|
||||
payload: Some(payload),
|
||||
})
|
||||
}
|
||||
async fn send(client: &reqwest::Client, envelope: &Envelope) -> Result<Envelope> {
|
||||
let bytes = body(
|
||||
client
|
||||
.post(format!("https://{SERVER}/agent/v1/messages"))
|
||||
.header(reqwest::header::CONTENT_TYPE, "application/x-protobuf")
|
||||
.body(
|
||||
MessageBatch {
|
||||
protocol_major: 1,
|
||||
messages: vec![envelope.clone()],
|
||||
}
|
||||
.encode_to_vec(),
|
||||
)
|
||||
.send()
|
||||
.await?,
|
||||
"application/x-protobuf",
|
||||
)
|
||||
.await?;
|
||||
let replies = MessageBatch::decode(bytes.as_slice())?;
|
||||
ensure!(
|
||||
replies.protocol_major == 1 && replies.messages.len() == 1,
|
||||
"FIXTURE_EXACT_REPLY"
|
||||
);
|
||||
let reply = replies
|
||||
.messages
|
||||
.into_iter()
|
||||
.next()
|
||||
.context("FIXTURE_REPLY")?;
|
||||
ensure!(
|
||||
reply.protocol_major == 1
|
||||
&& reply.protocol_minor == 0
|
||||
&& reply.agent_id == envelope.agent_id
|
||||
&& reply.enrollment_generation == 1
|
||||
&& reply.boot_id == envelope.boot_id
|
||||
&& reply.sequence == envelope.sequence,
|
||||
"FIXTURE_REPLY_BINDING"
|
||||
);
|
||||
Ok(reply)
|
||||
}
|
||||
async fn connect(
|
||||
client: &reqwest::Client,
|
||||
journal: &mut Journal,
|
||||
agent: &str,
|
||||
boot: &str,
|
||||
) -> Result<u64> {
|
||||
let hello = envelope(
|
||||
journal,
|
||||
agent,
|
||||
boot,
|
||||
0,
|
||||
Payload::ClientHello(ClientHello {
|
||||
agent_version: "certificate-acceptance/1".into(),
|
||||
capabilities: vec!["heartbeat/1".into()],
|
||||
}),
|
||||
)?;
|
||||
let reply = send(client, &hello).await?;
|
||||
let Some(Payload::ServerHello(server)) = reply.payload else {
|
||||
anyhow::bail!("FIXTURE_HELLO_REQUIRED")
|
||||
};
|
||||
ensure!(
|
||||
server.connection_generation > 0
|
||||
&& reply.connection_generation == server.connection_generation,
|
||||
"FIXTURE_GENERATION"
|
||||
);
|
||||
let heartbeat = envelope(
|
||||
journal,
|
||||
agent,
|
||||
boot,
|
||||
server.connection_generation,
|
||||
Payload::Heartbeat(Heartbeat {
|
||||
instance_id: Uuid::new_v4().to_string(),
|
||||
uptime_seconds: 1,
|
||||
}),
|
||||
)?;
|
||||
let acknowledgement = send(client, &heartbeat).await?;
|
||||
ensure!(
|
||||
matches!(acknowledgement.payload, Some(Payload::Ack(ref a)) if a.message_id == heartbeat.message_id),
|
||||
"FIXTURE_HEARTBEAT_ACK"
|
||||
);
|
||||
ensure!(
|
||||
acknowledgement.connection_generation == server.connection_generation,
|
||||
"FIXTURE_ACK_GENERATION"
|
||||
);
|
||||
Ok(server.connection_generation)
|
||||
}
|
||||
async fn renew(root: &Path, phase: &mut &'static str) -> Result<Value> {
|
||||
*phase = "enrollment";
|
||||
create(
|
||||
&root.join("started.json"),
|
||||
b"{\"schema_version\":1,\"no_restart\":true}",
|
||||
)?;
|
||||
let ca = read(&root.join("ca.pem"), 32768)?;
|
||||
let key = KeyPair::generate()?;
|
||||
create(&root.join("device.key"), key.serialize_pem().as_bytes())?;
|
||||
let mut parameters = CertificateParams::default();
|
||||
parameters
|
||||
.distinguished_name
|
||||
.push(DnType::CommonName, "certificate-acceptance");
|
||||
let csr = parameters.serialize_request(&key)?.pem()?;
|
||||
let token = String::from_utf8(read(&root.join("enrollment-token"), 128)?)?
|
||||
.trim()
|
||||
.to_owned();
|
||||
ensure!(
|
||||
token.len() == 64 && token.bytes().all(|b| b.is_ascii_hexdigit()),
|
||||
"FIXTURE_ENROLLMENT_TOKEN"
|
||||
);
|
||||
let enrolled: EnrollmentResponse = serde_json::from_slice(
|
||||
&body(
|
||||
client(&ca, None)?
|
||||
.post(format!("https://{SERVER}/agent/v1/enroll"))
|
||||
.json(&EnrollmentRequest {
|
||||
token,
|
||||
csr_pem: csr,
|
||||
})
|
||||
.send()
|
||||
.await?,
|
||||
"application/json",
|
||||
)
|
||||
.await?,
|
||||
)?;
|
||||
let agent = Uuid::parse_str(&enrolled.agent_id)?;
|
||||
ensure!(
|
||||
!agent.is_nil()
|
||||
&& enrolled.agent_id != PERMANENT_AGENT
|
||||
&& !Uuid::parse_str(&enrolled.asset_id)?.is_nil(),
|
||||
"SEPARATE_FIXTURE_IDENTITY"
|
||||
);
|
||||
create(
|
||||
&root.join("device.pem"),
|
||||
enrolled.certificate_pem.as_bytes(),
|
||||
)?;
|
||||
create(&root.join("identity.json"), &serde_json::to_vec(&enrolled)?)?;
|
||||
fs::remove_file(root.join("enrollment-token"))?;
|
||||
let original_key_hash = hash(&read(&root.join("device.key"), 16384)?);
|
||||
let original_certificate_hash = certificate_hash(enrolled.certificate_pem.as_bytes())?;
|
||||
let store = RotationStore::new(agent, 1, ca.clone())?;
|
||||
let mut journal = Journal::open(root)?;
|
||||
journal.pin_identity(&enrolled.agent_id)?;
|
||||
let keys = ProtectedKeyFiles::open(root)?;
|
||||
store.initialize(
|
||||
journal.connection_mut(),
|
||||
&keys,
|
||||
enrolled.certificate_pem.as_bytes(),
|
||||
Utc::now().timestamp(),
|
||||
)?;
|
||||
ensure!(
|
||||
!store.due(journal.connection(), &keys, Utc::now().timestamp())?,
|
||||
"FRESH_CERTIFICATE_NOT_DUE"
|
||||
);
|
||||
let original = store.current(journal.connection(), &keys, Utc::now().timestamp())?;
|
||||
let old_client = client(&ca, Some(&original))?;
|
||||
let boot = native::boot_id().await?;
|
||||
let original_generation =
|
||||
connect(&old_client, &mut journal, &enrolled.agent_id, &boot).await?;
|
||||
*phase = "renewal_response_discard";
|
||||
let pending = store.prepare(journal.connection_mut(), &keys, Utc::now().timestamp())?;
|
||||
let csr_hash = hash(pending.csr_pem.as_bytes());
|
||||
let first = body(
|
||||
old_client
|
||||
.post(format!("https://{SERVER}/agent/v1/certificates/renew"))
|
||||
.json(&json!({"csr_pem":pending.csr_pem}))
|
||||
.send()
|
||||
.await?,
|
||||
"application/json",
|
||||
)
|
||||
.await?;
|
||||
let first_hash = hash(&first);
|
||||
// Deliberately do not install the first real server response. Close the
|
||||
// actual SQLite/key handles; a reopened journal must reuse the CSR.
|
||||
drop(pending);
|
||||
drop(first);
|
||||
drop(keys);
|
||||
drop(journal);
|
||||
*phase = "renewal_reopen";
|
||||
let mut journal = Journal::open(root)?;
|
||||
let keys = ProtectedKeyFiles::open(root)?;
|
||||
let pending = store.prepare(journal.connection_mut(), &keys, Utc::now().timestamp())?;
|
||||
ensure!(
|
||||
hash(pending.csr_pem.as_bytes()) == csr_hash,
|
||||
"EXACT_PENDING_CSR_AFTER_REOPEN"
|
||||
);
|
||||
let second = body(
|
||||
client(&ca, Some(&pending.identity))?
|
||||
.post(format!("https://{SERVER}/agent/v1/certificates/renew"))
|
||||
.json(&json!({"csr_pem":pending.csr_pem}))
|
||||
.send()
|
||||
.await?,
|
||||
"application/json",
|
||||
)
|
||||
.await?;
|
||||
ensure!(
|
||||
hash(&second) == first_hash,
|
||||
"EXACT_IDEMPOTENT_SERVER_RESPONSE"
|
||||
);
|
||||
store.install(
|
||||
journal.connection_mut(),
|
||||
&keys,
|
||||
&pending,
|
||||
&second,
|
||||
Utc::now().timestamp(),
|
||||
)?;
|
||||
ensure!(
|
||||
!store.has_pending(journal.connection())?,
|
||||
"RENEWAL_COMMIT_PENDING"
|
||||
);
|
||||
drop(pending);
|
||||
drop(keys);
|
||||
drop(journal);
|
||||
*phase = "new_certificate_connection";
|
||||
let mut journal = Journal::open(root)?;
|
||||
let keys = ProtectedKeyFiles::open(root)?;
|
||||
let current = store.current(journal.connection(), &keys, Utc::now().timestamp())?;
|
||||
let renewed_hash = certificate_hash(¤t.certificate_pem)?;
|
||||
ensure!(
|
||||
renewed_hash != original_certificate_hash,
|
||||
"NEW_CERTIFICATE_REQUIRED"
|
||||
);
|
||||
let renewed_generation = connect(
|
||||
&client(&ca, Some(¤t))?,
|
||||
&mut journal,
|
||||
&enrolled.agent_id,
|
||||
&boot,
|
||||
)
|
||||
.await?;
|
||||
ensure!(
|
||||
renewed_generation > original_generation,
|
||||
"RENEWAL_RECONNECTED_GENERATION"
|
||||
);
|
||||
ensure!(
|
||||
hash(&read(&root.join("device.key"), 16384)?) == original_key_hash
|
||||
&& certificate_hash(&read(&root.join("device.pem"), 32768)?)?
|
||||
== original_certificate_hash,
|
||||
"ORIGINAL_FIXTURE_FILES_PRESERVED"
|
||||
);
|
||||
Ok(
|
||||
json!({"schema_version":1,"verified":true,"identity_scope":"separate_fixture","agent_id":agent,
|
||||
"asset_id":enrolled.asset_id,"boot_id":boot,"execution_sid":"S-1-5-19","service_sid":native::service_sid()?,
|
||||
"original_certificate_sha256":original_certificate_hash,"renewed_certificate_sha256":renewed_hash,
|
||||
"csr_sha256":csr_hash,"response_sha256":first_hash,"same_csr_after_reopen":true,
|
||||
"same_server_response":true,"new_certificate_mtls_hello_and_heartbeat":true,
|
||||
"original_generation":original_generation,"renewed_generation":renewed_generation,
|
||||
"original_fixture_files_preserved":true,"permanent_identity_read":false,
|
||||
"scheduler_age_trigger_tested":false,"jobs_created":false,"completed_at":Utc::now()}),
|
||||
)
|
||||
}
|
||||
async fn revoked_read(root: &Path, phase: &mut &'static str) -> Result<Value> {
|
||||
*phase = "revoked_identity_denial";
|
||||
let before: Value =
|
||||
serde_json::from_slice(&read(&root.join("renewal-result.json"), 16384)?)?;
|
||||
ensure!(before["verified"] == true, "PRIOR_RENEWAL_REQUIRED");
|
||||
let enrolled: EnrollmentResponse =
|
||||
serde_json::from_slice(&read(&root.join("identity.json"), 32768)?)?;
|
||||
ensure!(
|
||||
enrolled.agent_id != PERMANENT_AGENT && before["agent_id"] == enrolled.agent_id,
|
||||
"SAME_SEPARATE_FIXTURE"
|
||||
);
|
||||
let ca = read(&root.join("ca.pem"), 32768)?;
|
||||
let store = RotationStore::new(Uuid::parse_str(&enrolled.agent_id)?, 1, ca.clone())?;
|
||||
let mut journal = Journal::open(root)?;
|
||||
let keys = ProtectedKeyFiles::open(root)?;
|
||||
let identity = store.current(journal.connection(), &keys, Utc::now().timestamp())?;
|
||||
ensure!(
|
||||
before["renewed_certificate_sha256"] == certificate_hash(&identity.certificate_pem)?,
|
||||
"SAME_RENEWED_CERTIFICATE"
|
||||
);
|
||||
let hello = envelope(
|
||||
&mut journal,
|
||||
&enrolled.agent_id,
|
||||
&native::boot_id().await?,
|
||||
0,
|
||||
Payload::ClientHello(ClientHello {
|
||||
agent_version: "certificate-acceptance/1".into(),
|
||||
capabilities: vec!["heartbeat/1".into()],
|
||||
}),
|
||||
)?;
|
||||
let response = client(&ca, Some(&identity))?
|
||||
.post(format!("https://{SERVER}/agent/v1/messages"))
|
||||
.header(reqwest::header::CONTENT_TYPE, "application/x-protobuf")
|
||||
.body(
|
||||
MessageBatch {
|
||||
protocol_major: 1,
|
||||
messages: vec![hello],
|
||||
}
|
||||
.encode_to_vec(),
|
||||
)
|
||||
.send()
|
||||
.await?;
|
||||
// A TLS or network failure is not accepted as proof of revocation.
|
||||
ensure!(
|
||||
response.status().as_u16() == 401,
|
||||
"EXACT_AUTHENTICATED_REVOCATION_DENIAL"
|
||||
);
|
||||
Ok(
|
||||
json!({"schema_version":1,"verified":true,"agent_id":enrolled.agent_id,
|
||||
"execution_sid":"S-1-5-19","http_status":401,"permanent_identity_read":false,
|
||||
"jobs_created":false,"completed_at":Utc::now()}),
|
||||
)
|
||||
}
|
||||
pub fn main() -> Result<()> {
|
||||
native::require_local_service()?;
|
||||
let arguments: Vec<_> = std::env::args().skip(1).collect();
|
||||
ensure!(arguments.len() == 2, "FIXTURE_ARGUMENTS");
|
||||
let id = Uuid::parse_str(&arguments[1])?;
|
||||
ensure!(
|
||||
!id.is_nil() && id.to_string() == arguments[1],
|
||||
"FIXTURE_CASE_UUID"
|
||||
);
|
||||
let root = std::path::PathBuf::from(r"C:\ProgramData\RustDiscovery\certificate-acceptance")
|
||||
.join(id.to_string());
|
||||
native::private_path(&root, true)?;
|
||||
let report = match arguments[0].as_str() {
|
||||
"renew" => root.join("renewal-result.json"),
|
||||
"revoked-read" => root.join("revocation-result.json"),
|
||||
_ => anyhow::bail!("FIXTURE_MODE"),
|
||||
};
|
||||
ensure!(!report.try_exists()?, "FIXTURE_REPORT_ALREADY_PRESENT");
|
||||
let mut phase = "initialization";
|
||||
let runtime = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()?;
|
||||
let result = runtime.block_on(async {
|
||||
if arguments[0] == "renew" {
|
||||
renew(&root, &mut phase).await
|
||||
} else {
|
||||
revoked_read(&root, &mut phase).await
|
||||
}
|
||||
});
|
||||
match result {
|
||||
Ok(value) => {
|
||||
create(&report, &serde_json::to_vec(&value)?)?;
|
||||
println!("{}", serde_json::to_string(&value)?);
|
||||
Ok(())
|
||||
}
|
||||
Err(_) => {
|
||||
// No network/library error text, credential or private key goes
|
||||
// into the approved job's output or its public receipt.
|
||||
let failure = json!({"schema_version":1,"verified":false,"phase":phase,
|
||||
"error_code":"CERTIFICATE_ACCEPTANCE_FAILED","restart_allowed":false});
|
||||
create(&report, &serde_json::to_vec(&failure)?)?;
|
||||
println!("{}", serde_json::to_string(&failure)?);
|
||||
anyhow::bail!("CERTIFICATE_ACCEPTANCE_FAILED")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn main() {
|
||||
if native::main().is_err() {
|
||||
eprintln!("CERTIFICATE_ACCEPTANCE_FAILED");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
fn main() {
|
||||
eprintln!("Native Windows LocalService fixture only");
|
||||
std::process::exit(1);
|
||||
}
|
||||
@@ -160,8 +160,134 @@ mod windows {
|
||||
ensure!(bytes.len() as u64 <= max, "public file changed");
|
||||
Ok(bytes)
|
||||
}
|
||||
fn complete_echo(apply: bool) -> Result<()> {
|
||||
let readers = [ipc::service_sid(SERVICE_NAME)?];
|
||||
let _root = PinnedFile::open(Path::new(ROOT), true, &readers, &[], false)?;
|
||||
let mut pin = PinnedFile::open(
|
||||
&Path::new(ROOT).join("binding.json"),
|
||||
false,
|
||||
&readers,
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let bytes = data(&mut pin.file, 8192)?;
|
||||
ensure!(hash(&bytes) == BINDING_SHA256, "changed job binding");
|
||||
let binding: Binding = serde_json::from_slice(&bytes)?;
|
||||
let (settings, _pins) = helper_system::read_settings()?;
|
||||
let mut config = PinnedFile::open(
|
||||
&Path::new(ROOT).join("config.json"),
|
||||
false,
|
||||
&readers,
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
ensure!(
|
||||
config.sha256()? == PASSIVE && !settings.enable_effects && !settings.allow_reboot,
|
||||
"restore original passive pair first"
|
||||
);
|
||||
let stopped = both_stopped()?;
|
||||
ensure!(
|
||||
!apply || stopped,
|
||||
"both services must be stopped by the operator"
|
||||
);
|
||||
let mut locks = vec![];
|
||||
if stopped {
|
||||
for path in [
|
||||
Path::new(STATE).join("agent.lock"),
|
||||
Path::new(helper_system::STATE_ROOT).join("executor.lock"),
|
||||
] {
|
||||
let file = leaf(&path)?;
|
||||
file.try_lock_exclusive().context("service lock busy")?;
|
||||
locks.push(file);
|
||||
}
|
||||
ensure!(both_stopped()?, "service started during completion");
|
||||
}
|
||||
native::private_path(Path::new(STATE), true)?;
|
||||
for p in [AGENT_DB, LOCAL_DB] {
|
||||
native::private_path(Path::new(p), false)?;
|
||||
}
|
||||
let helper_sid = [ipc::service_sid(ipc::HELPER_SERVICE)?];
|
||||
let _helper_state = PinnedFile::open_read_shared(
|
||||
Path::new(helper_system::STATE_ROOT),
|
||||
true,
|
||||
&[],
|
||||
&helper_sid,
|
||||
)?;
|
||||
let helper_file =
|
||||
PinnedFile::open_read_shared(Path::new(HELPER_DB), false, &[], &helper_sid)?;
|
||||
let mut agent = Db::open(AGENT_DB, apply, stopped)?;
|
||||
let consumption = Db::open(LOCAL_DB, false, stopped)?;
|
||||
let helper = Db::open(HELPER_DB, false, stopped)?;
|
||||
let (ledger, lock, pin): (Vec<u8>, Vec<u8>, String) = helper.db.query_row(
|
||||
"SELECT ledger,executor_lock,binding_sha256 FROM windows_helper_files WHERE id=1",
|
||||
[],
|
||||
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
||||
)?;
|
||||
ensure!(
|
||||
serde_json::from_slice::<ipc::FileIdentity>(&ledger)? == helper_file.identity
|
||||
&& pin == ipc::binding_hash(&settings.binding)?,
|
||||
"helper journal or binding changed"
|
||||
);
|
||||
let witness = rmm_agent_windows::echo_completion::witness(
|
||||
&agent.db,
|
||||
&consumption.db,
|
||||
&helper.db,
|
||||
&binding,
|
||||
&settings.binding,
|
||||
)?;
|
||||
println!("{}", serde_json::to_string(&witness)?);
|
||||
if apply {
|
||||
ensure!(
|
||||
serde_json::from_slice::<ipc::FileIdentity>(&lock)?
|
||||
== ipc::file_identity(&locks[1])?,
|
||||
"helper lock identity changed"
|
||||
);
|
||||
let path =
|
||||
Path::new(r"C:\ProgramData\RustDiscoveryBootstrap\windows-echo-completion.json");
|
||||
let _folder = PinnedFile::open(
|
||||
path.parent().context("completion folder")?,
|
||||
true,
|
||||
&[],
|
||||
&[],
|
||||
false,
|
||||
)?;
|
||||
let mut file = PinnedFile::open(path, false, &[], &[], false)?;
|
||||
let receipt = data(&mut file.file, 131072)?;
|
||||
let boot = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()?
|
||||
.block_on(native::boot_id())?;
|
||||
let boot = uuid::Uuid::parse_str(&boot)?;
|
||||
ensure!(both_stopped()?, "service started during completion");
|
||||
let pair = rmm_agent_windows::echo_completion::LocalPair {
|
||||
consumption: &consumption.db,
|
||||
helper: &helper.db,
|
||||
binding: &binding,
|
||||
helper_binding: &settings.binding,
|
||||
};
|
||||
rmm_agent_windows::echo_completion::apply(
|
||||
&mut agent.db,
|
||||
pair,
|
||||
&receipt,
|
||||
boot,
|
||||
chrono::Utc::now(),
|
||||
)?;
|
||||
println!(
|
||||
"additional echo restriction retired; original history retained; ordinary signed pair sync and each WebUI job approval remain required"
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn run() -> Result<()> {
|
||||
let args: Vec<_> = std::env::args().skip(1).collect();
|
||||
if args.len() == 1
|
||||
&& matches!(
|
||||
args[0].as_str(),
|
||||
"echo-completion-read" | "echo-completion-apply"
|
||||
)
|
||||
{
|
||||
return complete_echo(args[0] == "echo-completion-apply");
|
||||
}
|
||||
ensure!(
|
||||
args.len() == 1
|
||||
&& matches!(
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
//! Read-only native updater OS-port preflight. No activation/capability proof.
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
fn main() -> anyhow::Result<()> {
|
||||
use rmm_agent_core::helper_reconcile::BootSource;
|
||||
use rmm_agent_windows::{
|
||||
helper_system,
|
||||
update_native::{Budget, Role, files, services::Running},
|
||||
};
|
||||
use std::time::Duration;
|
||||
use uuid::Uuid;
|
||||
struct Boot(Uuid);
|
||||
impl BootSource for Boot {
|
||||
fn current_boot(&self) -> anyhow::Result<Uuid> {
|
||||
Ok(self.0)
|
||||
}
|
||||
}
|
||||
let runtime = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()?;
|
||||
let boot = Boot(
|
||||
runtime
|
||||
.block_on(rmm_agent_windows::native::boot_id())?
|
||||
.parse()?,
|
||||
);
|
||||
let budget = Budget::new(&boot, boot.0, Duration::from_secs(30))?;
|
||||
let (settings, _guards) = helper_system::read_settings()?;
|
||||
let mut running = Running::observe([settings.agent.clone(), settings.helper.clone()], &budget)?;
|
||||
let mut files = Vec::new();
|
||||
for role in [
|
||||
Role::Agent,
|
||||
Role::Helper,
|
||||
Role::Settings,
|
||||
Role::Pin,
|
||||
Role::TimeProfile,
|
||||
] {
|
||||
files.push(serde_json::json!({"role":role,"proof":files::observe(role, &budget)?}));
|
||||
}
|
||||
running.check(&budget)?;
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string(&serde_json::json!({
|
||||
"schema_version":1,"read_only":true,"boot_id":boot.0,
|
||||
"services":running.proofs(),"files":files,"native_apply_tested":false,
|
||||
"job_created":false,"capability_qualified":false
|
||||
}))?
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
#[cfg(not(all(windows, feature = "system-helper")))]
|
||||
fn main() {
|
||||
eprintln!("Windows with system-helper feature required; no test executed");
|
||||
std::process::exit(2);
|
||||
}
|
||||
@@ -3,7 +3,7 @@
|
||||
//! The caller must retain the existing exclusive agent-state journal lock.
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use rcgen::{CertificateParams, DnType, KeyPair};
|
||||
use rusqlite::{Connection, params};
|
||||
use rusqlite::{Connection, OptionalExtension, params};
|
||||
use rustls::{RootCertStore, pki_types::UnixTime, sign::CertifiedKey};
|
||||
use serde::Deserialize;
|
||||
use std::{io::Cursor, sync::Arc, time::Duration};
|
||||
@@ -61,7 +61,10 @@ impl RotationStore {
|
||||
) -> Result<()> {
|
||||
let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
|
||||
tx.execute_batch("CREATE TABLE IF NOT EXISTS tls_versions(version TEXT PRIMARY KEY,certificate BLOB,csr TEXT);
|
||||
CREATE TABLE IF NOT EXISTS tls_rotation(id INTEGER PRIMARY KEY CHECK(id=1),schema_version INTEGER NOT NULL,agent TEXT NOT NULL,enrollment INTEGER NOT NULL,current_version TEXT NOT NULL REFERENCES tls_versions(version),pending_version TEXT REFERENCES tls_versions(version));")?;
|
||||
CREATE TABLE IF NOT EXISTS tls_rotation(id INTEGER PRIMARY KEY CHECK(id=1),schema_version INTEGER NOT NULL,agent TEXT NOT NULL,enrollment INTEGER NOT NULL,current_version TEXT NOT NULL REFERENCES tls_versions(version),pending_version TEXT REFERENCES tls_versions(version));
|
||||
CREATE TABLE IF NOT EXISTS tls_idle_admission(version TEXT PRIMARY KEY REFERENCES tls_versions(version),witness BLOB NOT NULL CHECK(length(witness) BETWEEN 1 AND 32768));
|
||||
CREATE TRIGGER IF NOT EXISTS tls_idle_no_update BEFORE UPDATE ON tls_idle_admission BEGIN SELECT RAISE(ABORT,'ROTATION_IDLE_IMMUTABLE');END;
|
||||
CREATE TRIGGER IF NOT EXISTS tls_idle_no_delete BEFORE DELETE ON tls_idle_admission BEGIN SELECT RAISE(ABORT,'ROTATION_IDLE_IMMUTABLE');END;")?;
|
||||
let present: bool = tx.query_row("SELECT EXISTS(SELECT 1 FROM tls_rotation)", [], |r| {
|
||||
r.get(0)
|
||||
})?;
|
||||
@@ -173,6 +176,20 @@ impl RotationStore {
|
||||
pub fn has_pending(&self, db: &Connection) -> Result<bool> {
|
||||
Ok(self.selector(db)?.1.is_some())
|
||||
}
|
||||
/// Retained local maintenance context, never readiness or job authority.
|
||||
/// Legacy passive requests deliberately have no active-idle admission.
|
||||
pub fn pending_idle_admission(&self, db: &Connection) -> Result<Option<Vec<u8>>> {
|
||||
let Some(version) = self.selector(db)?.1 else {
|
||||
return Ok(None);
|
||||
};
|
||||
Ok(db
|
||||
.query_row(
|
||||
"SELECT witness FROM tls_idle_admission WHERE version=?1",
|
||||
[version.to_string()],
|
||||
|r| r.get(0),
|
||||
)
|
||||
.optional()?)
|
||||
}
|
||||
/// A crash before the transaction leaves only an unselected key file. A
|
||||
/// response loss reuses the committed CSR/key and still-valid old mTLS leaf.
|
||||
pub fn prepare(
|
||||
@@ -181,9 +198,37 @@ impl RotationStore {
|
||||
keys: &impl KeyFiles,
|
||||
now: i64,
|
||||
) -> Result<PendingRequest> {
|
||||
self.prepare_with_idle_admission(db, keys, now, None)
|
||||
}
|
||||
/// Commit a caller-verified idle witness in the SAME transaction as the
|
||||
/// pending CSR/selector. A resumed active request must retain exact bytes.
|
||||
pub fn prepare_with_idle_admission(
|
||||
&self,
|
||||
db: &mut Connection,
|
||||
keys: &impl KeyFiles,
|
||||
now: i64,
|
||||
admission: Option<&[u8]>,
|
||||
) -> Result<PendingRequest> {
|
||||
ensure!(
|
||||
admission.is_none_or(|bytes| !bytes.is_empty() && bytes.len() <= 32768),
|
||||
"ROTATION_IDLE_ADMISSION_LIMIT"
|
||||
);
|
||||
let identity = self.current(db, keys, now)?;
|
||||
let tx = db.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
|
||||
let (base, pending) = self.selector(&tx)?;
|
||||
if let (Some(version), Some(expected)) = (pending, admission) {
|
||||
let saved: Option<Vec<u8>> = tx
|
||||
.query_row(
|
||||
"SELECT witness FROM tls_idle_admission WHERE version=?1",
|
||||
[version.to_string()],
|
||||
|r| r.get(0),
|
||||
)
|
||||
.optional()?;
|
||||
ensure!(
|
||||
saved.as_deref() == Some(expected),
|
||||
"ROTATION_IDLE_ADMISSION_CHANGED"
|
||||
);
|
||||
}
|
||||
let (version, csr_pem) = if let Some(version) = pending {
|
||||
ensure!(
|
||||
!version.is_nil() && version != base,
|
||||
@@ -231,6 +276,12 @@ impl RotationStore {
|
||||
"UPDATE tls_rotation SET pending_version=?1 WHERE id=1",
|
||||
[version.to_string()],
|
||||
)?;
|
||||
if let Some(witness) = admission {
|
||||
tx.execute(
|
||||
"INSERT INTO tls_idle_admission VALUES(?1,?2)",
|
||||
params![version.to_string(), witness],
|
||||
)?;
|
||||
}
|
||||
(version, csr)
|
||||
};
|
||||
tx.commit()?;
|
||||
@@ -299,6 +350,71 @@ impl RotationStore {
|
||||
}
|
||||
}
|
||||
|
||||
/// A local idle witness for certificate maintenance, not an execution grant.
|
||||
/// All accepted/unknown work and missing effect evidence block rotation. The
|
||||
/// caller retains both existing database guards while computing this digest.
|
||||
pub fn idle_history_sha256(journal: &Connection, ledger: &Connection) -> Result<String> {
|
||||
use rusqlite::types::ValueRef;
|
||||
use sha2::{Digest, Sha256};
|
||||
let safe: bool = journal.query_row("SELECT count(*)=1 AND min(last_decision IS NOT NULL AND pending_request IS NULL AND fault IS NULL AND generation>0) FROM reconcile_meta WHERE id=1", [], |r| r.get(0))?;
|
||||
let idle: bool = journal.query_row("SELECT NOT EXISTS(SELECT 1 FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')) AND NOT EXISTS(SELECT 1 FROM job_events) AND NOT EXISTS(SELECT 1 FROM events)", [], |r| r.get(0))?;
|
||||
let resolved: bool = ledger.query_row("SELECT NOT EXISTS(SELECT 1 FROM consumed c LEFT JOIN execution_evidence e USING(grant_id) WHERE c.result IS NULL OR e.start IS NULL OR e.outcome IS NULL) AND NOT EXISTS(SELECT 1 FROM execution_evidence e LEFT JOIN consumed c USING(grant_id) WHERE c.grant_id IS NULL)", [], |r| r.get(0))?;
|
||||
ensure!(
|
||||
safe && idle && resolved,
|
||||
"ROTATION_EFFECT_OR_CONTROL_UNRESOLVED"
|
||||
);
|
||||
let mut hash = Sha256::new();
|
||||
hash.update(b"rmm.windows.tls-idle.v1\0");
|
||||
for (db, sql) in [
|
||||
(journal, "SELECT seq FROM counter WHERE id=1"),
|
||||
(
|
||||
journal,
|
||||
"SELECT journal_id,checkpoint,high_sequence,generation,last_decision,pending_request,helper_id,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",
|
||||
),
|
||||
(
|
||||
journal,
|
||||
"SELECT job,attempt,offer,state,revision,grant_id,cancel_requested FROM job_attempts ORDER BY job,attempt",
|
||||
),
|
||||
(
|
||||
ledger,
|
||||
"SELECT c.grant_id,c.agent,c.generation,c.job,c.attempt,c.result,e.start,e.outcome FROM consumed c JOIN execution_evidence e USING(grant_id) ORDER BY c.grant_id",
|
||||
),
|
||||
] {
|
||||
hash.update(sql.as_bytes());
|
||||
let mut query = db.prepare(sql)?;
|
||||
let columns = query.column_count();
|
||||
let mut rows = query.query([])?;
|
||||
let mut count = 0u64;
|
||||
while let Some(row) = rows.next()? {
|
||||
count += 1;
|
||||
ensure!(count <= 256, "ROTATION_HISTORY_LIMIT");
|
||||
hash.update([0xff]);
|
||||
for column in 0..columns {
|
||||
match row.get_ref(column)? {
|
||||
ValueRef::Null => hash.update([0]),
|
||||
ValueRef::Integer(value) => {
|
||||
hash.update([1]);
|
||||
hash.update(value.to_be_bytes());
|
||||
}
|
||||
ValueRef::Text(bytes) | ValueRef::Blob(bytes) => {
|
||||
ensure!(bytes.len() <= 1048576, "ROTATION_HISTORY_BLOB_LIMIT");
|
||||
hash.update([if matches!(row.get_ref(column)?, ValueRef::Text(_)) {
|
||||
2
|
||||
} else {
|
||||
3
|
||||
}]);
|
||||
hash.update((bytes.len() as u64).to_be_bytes());
|
||||
hash.update(bytes);
|
||||
}
|
||||
ValueRef::Real(_) => anyhow::bail!("ROTATION_HISTORY_TYPE"),
|
||||
}
|
||||
}
|
||||
}
|
||||
hash.update(count.to_be_bytes());
|
||||
}
|
||||
Ok(format!("{:x}", hash.finalize()))
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
pub struct ProtectedKeyFiles {
|
||||
root: std::path::PathBuf,
|
||||
@@ -474,6 +590,146 @@ mod tests {
|
||||
.unwrap()
|
||||
}
|
||||
#[test]
|
||||
fn active_idle_admission_is_atomic_retained_and_cannot_adopt_legacy_pending() {
|
||||
let (mut db, keys, store, _, _) = setup();
|
||||
let witness = b"exact independently checked idle context";
|
||||
db.execute_batch("CREATE TEMP TRIGGER deny_idle BEFORE INSERT ON tls_idle_admission BEGIN SELECT RAISE(ABORT,'TEST_IDLE_COMMIT_DENIED');END;").unwrap();
|
||||
assert!(
|
||||
store
|
||||
.prepare_with_idle_admission(&mut db, &keys, now(), Some(witness))
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(store.selector(&db).unwrap(), (Uuid::nil(), None));
|
||||
assert_eq!(
|
||||
db.query_row("SELECT count(*) FROM tls_versions", [], |r| r
|
||||
.get::<_, u64>(0))
|
||||
.unwrap(),
|
||||
1
|
||||
);
|
||||
db.execute_batch("DROP TRIGGER deny_idle").unwrap();
|
||||
let original = store
|
||||
.prepare_with_idle_admission(&mut db, &keys, now(), Some(witness))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
store.pending_idle_admission(&db).unwrap().as_deref(),
|
||||
Some(witness.as_slice())
|
||||
);
|
||||
assert!(
|
||||
store
|
||||
.prepare_with_idle_admission(&mut db, &keys, now(), Some(b"changed context"))
|
||||
.is_err()
|
||||
);
|
||||
let retained = store
|
||||
.prepare_with_idle_admission(&mut db, &keys, now(), Some(witness))
|
||||
.unwrap();
|
||||
assert_eq!(original.version, retained.version);
|
||||
assert_eq!(original.csr_pem, retained.csr_pem);
|
||||
assert!(
|
||||
db.execute(
|
||||
"UPDATE tls_idle_admission SET witness=?1",
|
||||
[b"replacement".as_slice()]
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(db.execute("DELETE FROM tls_idle_admission", []).is_err());
|
||||
let (mut legacy, legacy_keys, legacy_store, _, _) = setup();
|
||||
legacy_store
|
||||
.prepare(&mut legacy, &legacy_keys, now())
|
||||
.unwrap();
|
||||
assert!(
|
||||
legacy_store
|
||||
.pending_idle_admission(&legacy)
|
||||
.unwrap()
|
||||
.is_none()
|
||||
);
|
||||
assert!(
|
||||
legacy_store
|
||||
.prepare_with_idle_admission(&mut legacy, &legacy_keys, now(), Some(witness))
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn idle_history_rejects_unfinished_jobs_missing_effect_evidence_and_changed_heads() {
|
||||
let root = std::env::temp_dir().join(format!("rmm-rotation-idle-{}", Uuid::new_v4()));
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
let journal = crate::journal::Journal::open(&root).unwrap();
|
||||
let ledger = Connection::open_in_memory().unwrap();
|
||||
rmm_agent_core::ledger::initialize_ledger(&ledger).unwrap();
|
||||
assert!(idle_history_sha256(journal.connection(), &ledger).is_err());
|
||||
journal
|
||||
.connection()
|
||||
.execute(
|
||||
"UPDATE reconcile_meta SET generation=1,last_decision=?1 WHERE id=1",
|
||||
[Uuid::new_v4().to_string()],
|
||||
)
|
||||
.unwrap();
|
||||
let clean = idle_history_sha256(journal.connection(), &ledger).unwrap();
|
||||
journal.connection().execute("INSERT INTO job_attempts(job,attempt,offer,state) VALUES('fixture','attempt',x'01','accepted')",[]).unwrap();
|
||||
for state in [
|
||||
"queued",
|
||||
"accepted",
|
||||
"requesting",
|
||||
"running",
|
||||
"verifying",
|
||||
"unknown",
|
||||
"awaiting_reboot",
|
||||
] {
|
||||
journal
|
||||
.connection()
|
||||
.execute("UPDATE job_attempts SET state=?1", [state])
|
||||
.unwrap();
|
||||
assert!(
|
||||
idle_history_sha256(journal.connection(), &ledger).is_err(),
|
||||
"{state}"
|
||||
);
|
||||
}
|
||||
journal
|
||||
.connection()
|
||||
.execute("UPDATE job_attempts SET state='succeeded'", [])
|
||||
.unwrap();
|
||||
let finished = idle_history_sha256(journal.connection(), &ledger).unwrap();
|
||||
assert_ne!(clean, finished);
|
||||
ledger
|
||||
.execute(
|
||||
"INSERT INTO consumed VALUES('grant','agent',1,'fixture','attempt',NULL)",
|
||||
[],
|
||||
)
|
||||
.unwrap();
|
||||
assert!(idle_history_sha256(journal.connection(), &ledger).is_err());
|
||||
ledger
|
||||
.execute("UPDATE consumed SET result=x'02'", [])
|
||||
.unwrap();
|
||||
assert!(idle_history_sha256(journal.connection(), &ledger).is_err());
|
||||
ledger
|
||||
.execute(
|
||||
"INSERT INTO execution_evidence VALUES('grant',x'01',x'02')",
|
||||
[],
|
||||
)
|
||||
.unwrap();
|
||||
let resolved = idle_history_sha256(journal.connection(), &ledger).unwrap();
|
||||
journal
|
||||
.connection()
|
||||
.execute(
|
||||
"UPDATE reconcile_meta SET checkpoint=checkpoint+1 WHERE id=1",
|
||||
[],
|
||||
)
|
||||
.unwrap();
|
||||
assert_ne!(
|
||||
resolved,
|
||||
idle_history_sha256(journal.connection(), &ledger).unwrap()
|
||||
);
|
||||
journal
|
||||
.connection()
|
||||
.execute(
|
||||
"UPDATE reconcile_meta SET pending_request='pending' WHERE id=1",
|
||||
[],
|
||||
)
|
||||
.unwrap();
|
||||
assert!(idle_history_sha256(journal.connection(), &ledger).is_err());
|
||||
drop(journal);
|
||||
std::fs::remove_dir_all(root).unwrap();
|
||||
}
|
||||
#[test]
|
||||
fn response_loss_reuses_exact_pending_csr_and_private_key_stays_outside_sqlite() {
|
||||
let (mut db, keys, store, issuer, old) = setup();
|
||||
assert!(store.due(&db, &keys, now()).unwrap());
|
||||
|
||||
@@ -0,0 +1,463 @@
|
||||
//! Append-only retirement of the additional development echo restriction.
|
||||
//! Preserves all original scope, journal, fault history and consumption bytes.
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use chrono::{DateTime, Utc};
|
||||
use prost::Message;
|
||||
use rmm_agent_core::{
|
||||
auth::{Binding, Request},
|
||||
crypto::{DalekVerifier, Ed25519Verifier},
|
||||
};
|
||||
use rmm_domain::{
|
||||
checkpoint_repair::{SignedReceipt, inventory_sha256},
|
||||
jobs::{ExecutionPermitPayload, JobPayload, hash},
|
||||
windows_echo_completion::{Receipt, Witness, successful_outcome},
|
||||
windows_echo_probe::{ProbeReceipt, ProbeScope},
|
||||
};
|
||||
use rmm_protocol::JobOffer;
|
||||
use rusqlite::{Connection, TransactionBehavior, params};
|
||||
use serde_json::Value;
|
||||
|
||||
const TABLE: &str = "windows_echo_scope_completion";
|
||||
const DDL: &str = "CREATE TABLE windows_echo_scope_completion(id INTEGER PRIMARY KEY CHECK(id=1),original_receipt BLOB NOT NULL,witness_sha256 TEXT NOT NULL,applied_at TEXT NOT NULL)";
|
||||
fn schema() -> [String; 4] {
|
||||
[DDL.into(),
|
||||
"CREATE TRIGGER windows_echo_completion_no_replace BEFORE INSERT ON windows_echo_scope_completion WHEN EXISTS(SELECT 1 FROM windows_echo_scope_completion) BEGIN SELECT RAISE(ABORT,'WINDOWS_ECHO_COMPLETION_IMMUTABLE'); END".into(),
|
||||
"CREATE TRIGGER windows_echo_completion_no_change BEFORE UPDATE ON windows_echo_scope_completion BEGIN SELECT RAISE(ABORT,'WINDOWS_ECHO_COMPLETION_IMMUTABLE'); END".into(),
|
||||
"CREATE TRIGGER windows_echo_completion_no_delete BEFORE DELETE ON windows_echo_scope_completion BEGIN SELECT RAISE(ABORT,'WINDOWS_ECHO_COMPLETION_IMMUTABLE'); END".into()]
|
||||
}
|
||||
fn verify(binding: &Binding, bytes: &[u8], signature: &[u8]) -> Result<()> {
|
||||
let b = &binding.public_key_hex;
|
||||
ensure!(
|
||||
b.len() == 64 && b.is_ascii() && bytes.len() <= 65536 && signature.len() == 64,
|
||||
"completion pin/size"
|
||||
);
|
||||
let key = (0..64)
|
||||
.step_by(2)
|
||||
.map(|i| u8::from_str_radix(&b[i..i + 2], 16))
|
||||
.collect::<std::result::Result<Vec<_>, _>>()?;
|
||||
ensure!(
|
||||
DalekVerifier.verify(&key, bytes, signature)?,
|
||||
"completion original signature"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn receipt(raw: &[u8], binding: &Binding) -> Result<Receipt> {
|
||||
ensure!(raw.len() <= 131072, "completion envelope size");
|
||||
let signed: SignedReceipt = serde_json::from_slice(raw)?;
|
||||
verify(binding, &signed.payload, &signed.signature)?;
|
||||
let r: Receipt = serde_json::from_slice(&signed.payload)?;
|
||||
ensure!(r.valid(r.issued_at), "completion historical profile");
|
||||
let key = (0..64)
|
||||
.step_by(2)
|
||||
.map(|i| u8::from_str_radix(&binding.public_key_hex[i..i + 2], 16))
|
||||
.collect::<std::result::Result<Vec<_>, _>>()?;
|
||||
ensure!(r.key_id == hash(&key), "completion signing key");
|
||||
Ok(r)
|
||||
}
|
||||
fn matches_original(r: &Receipt, scope: &ProbeScope, original: &[u8]) -> Result<()> {
|
||||
let old: SignedReceipt = serde_json::from_slice(original)?;
|
||||
let p: ProbeReceipt = serde_json::from_slice(&old.payload)?;
|
||||
ensure!(
|
||||
&r.witness.scope == scope
|
||||
&& r.witness.probe_receipt_id == p.receipt_id
|
||||
&& r.witness.probe_receipt_sha256 == hash(&old.payload)
|
||||
&& r.witness.probe_signature_sha256 == hash(&old.signature),
|
||||
"completion retained scope"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
pub fn installed(
|
||||
db: &Connection,
|
||||
binding: &Binding,
|
||||
scope: &ProbeScope,
|
||||
original: &[u8],
|
||||
) -> Result<bool> {
|
||||
let exists: bool = db.query_row(
|
||||
"SELECT EXISTS(SELECT 1 FROM sqlite_schema WHERE name=?)",
|
||||
[TABLE],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
if !exists {
|
||||
return Ok(false);
|
||||
}
|
||||
let names = [
|
||||
TABLE,
|
||||
"windows_echo_completion_no_replace",
|
||||
"windows_echo_completion_no_change",
|
||||
"windows_echo_completion_no_delete",
|
||||
];
|
||||
for (name, expected) in names.iter().zip(schema()) {
|
||||
let actual: String =
|
||||
db.query_row("SELECT sql FROM sqlite_schema WHERE name=?", [name], |r| {
|
||||
r.get(0)
|
||||
})?;
|
||||
ensure!(actual == expected, "completion schema");
|
||||
}
|
||||
let (raw, digest): (Vec<u8>, String) = db.query_row(
|
||||
"SELECT original_receipt,witness_sha256 FROM windows_echo_scope_completion WHERE id=1",
|
||||
[],
|
||||
|r| Ok((r.get(0)?, r.get(1)?)),
|
||||
)?;
|
||||
let r = receipt(&raw, binding)?;
|
||||
matches_original(&r, scope, original)?;
|
||||
ensure!(digest == r.witness_sha256, "completion archive digest");
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Independent read of original native start, signatures and exact successful outcome.
|
||||
pub fn witness(
|
||||
db: &Connection,
|
||||
consumption: &Connection,
|
||||
helper: &Connection,
|
||||
binding: &Binding,
|
||||
helper_binding: &Binding,
|
||||
) -> Result<Witness> {
|
||||
let (scope, original) =
|
||||
crate::echo_probe::archive(db, binding)?.context("original echo scope missing")?;
|
||||
let old: SignedReceipt = serde_json::from_slice(&original)?;
|
||||
verify(helper_binding, &old.payload, &old.signature)?;
|
||||
let probe: ProbeReceipt = serde_json::from_slice(&old.payload)?;
|
||||
ensure!(
|
||||
(
|
||||
helper_binding.tenant_id,
|
||||
helper_binding.asset_id,
|
||||
helper_binding.agent_id,
|
||||
helper_binding.enrollment_generation,
|
||||
helper_binding.assignment_version
|
||||
) == (
|
||||
binding.tenant_id,
|
||||
binding.asset_id,
|
||||
binding.agent_id,
|
||||
binding.enrollment_generation,
|
||||
binding.assignment_version
|
||||
),
|
||||
"completion independent helper identity"
|
||||
);
|
||||
for journal in [db, consumption, helper] {
|
||||
let check: String = journal.query_row("PRAGMA integrity_check", [], |r| r.get(0))?;
|
||||
ensure!(check == "ok", "completion journal integrity");
|
||||
}
|
||||
let fault: Option<String> =
|
||||
db.query_row("SELECT fault FROM reconcile_meta WHERE id=1", [], |r| {
|
||||
r.get(0)
|
||||
})?;
|
||||
ensure!(fault.is_none(), "current reconciliation fault");
|
||||
let jobs: u64 = db.query_row("SELECT count(*) FROM job_attempts", [], |r| r.get(0))?;
|
||||
ensure!(jobs == 1, "completion requires exact native single probe");
|
||||
let (offer, state, grant): (Vec<u8>, String, String) = db.query_row(
|
||||
"SELECT offer,state,grant_id FROM job_attempts WHERE job=? AND attempt=?",
|
||||
params![scope.job_id.to_string(), scope.attempt_id.to_string()],
|
||||
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
||||
)?;
|
||||
let offer = JobOffer::decode(offer.as_slice())?;
|
||||
let job: JobPayload = serde_json::from_slice(&offer.payload_bytes)?;
|
||||
ensure!(
|
||||
state == "succeeded" && crate::echo_probe::permits_offer(&scope, &offer, &job),
|
||||
"native completed echo offer"
|
||||
);
|
||||
let count: u64 = consumption.query_row("SELECT count(*) FROM consumed", [], |r| r.get(0))?;
|
||||
let evidence: u64 =
|
||||
consumption.query_row("SELECT count(*) FROM execution_evidence", [], |r| r.get(0))?;
|
||||
let helper_count: u64 = helper.query_row("SELECT count(*) FROM consumed", [], |r| r.get(0))?;
|
||||
ensure!(
|
||||
count == 1 && evidence == 1 && helper_count == 0,
|
||||
"completion original consumption inventory"
|
||||
);
|
||||
let (start,outcome,result):(Vec<u8>,Vec<u8>,Vec<u8>)=consumption.query_row("SELECT e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.grant_id=? AND c.agent=? AND c.generation=? AND c.job=? AND c.attempt=?",params![grant,binding.agent_id.to_string(),binding.enrollment_generation,scope.job_id.to_string(),scope.attempt_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
|
||||
let start: Value = serde_json::from_slice(&start)?;
|
||||
let request: Request = serde_json::from_value(start["request"].clone())?;
|
||||
verify(binding, &request.permit_bytes, &request.signature)?;
|
||||
verify(helper_binding, &request.permit_bytes, &request.signature)?;
|
||||
let g: ExecutionPermitPayload = serde_json::from_slice(&request.permit_bytes)?;
|
||||
ensure!(
|
||||
g.domain == "rmm.execution-permit"
|
||||
&& g.schema_version == 1
|
||||
&& g.agent_update_plan_id.is_none()
|
||||
&& g.start_before - g.not_before <= chrono::Duration::seconds(60)
|
||||
&& request.job_bytes == offer.payload_bytes
|
||||
&& request.authorization_id.to_string() == offer.authorization_id
|
||||
&& request.plan_hash == scope.plan_hash
|
||||
&& g.grant_id.to_string() == grant
|
||||
&& g.plan_hash == scope.plan_hash
|
||||
&& g.authorization_id == request.authorization_id
|
||||
&& g.job_payload_hash == scope.job_payload_hash
|
||||
&& (g.tenant_id, g.asset_id, g.agent_id, g.job_id, g.attempt_id)
|
||||
== (
|
||||
scope.tenant_id,
|
||||
scope.asset_id,
|
||||
scope.agent_id,
|
||||
scope.job_id,
|
||||
scope.attempt_id
|
||||
)
|
||||
&& (g.enrollment_generation, g.assignment_version)
|
||||
== (scope.enrollment_generation, scope.assignment_version)
|
||||
&& g.execution_identity == "agent_service"
|
||||
&& g.action == "run_script"
|
||||
&& g.not_before >= scope.not_before
|
||||
&& g.start_before <= scope.start_before
|
||||
&& g.not_before < g.start_before
|
||||
&& g.max_runtime_seconds == scope.max_runtime_seconds,
|
||||
"completion retained signed grant"
|
||||
);
|
||||
let outcome: Value = serde_json::from_slice(&outcome)?;
|
||||
let result: Value = serde_json::from_slice(&result)?;
|
||||
ensure!(
|
||||
outcome == result && successful_outcome(&outcome),
|
||||
"completion exact native outcome"
|
||||
);
|
||||
let boot_id = serde_json::from_value(start["previous_boot_id"].clone())?;
|
||||
let w = Witness {
|
||||
scope,
|
||||
probe_receipt_id: probe.receipt_id,
|
||||
probe_receipt_sha256: hash(&old.payload),
|
||||
probe_signature_sha256: hash(&old.signature),
|
||||
grant_id: g.grant_id,
|
||||
grant_payload_sha256: hash(&request.permit_bytes),
|
||||
grant_signature_sha256: hash(&request.signature),
|
||||
outcome_sha256: inventory_sha256(&outcome)?,
|
||||
boot_id,
|
||||
};
|
||||
ensure!(w.valid(), "completion witness profile");
|
||||
Ok(w)
|
||||
}
|
||||
pub struct LocalPair<'a> {
|
||||
pub consumption: &'a Connection,
|
||||
pub helper: &'a Connection,
|
||||
pub binding: &'a Binding,
|
||||
pub helper_binding: &'a Binding,
|
||||
}
|
||||
pub fn apply(
|
||||
db: &mut Connection,
|
||||
pair: LocalPair<'_>,
|
||||
raw: &[u8],
|
||||
boot: uuid::Uuid,
|
||||
now: DateTime<Utc>,
|
||||
) -> Result<()> {
|
||||
let LocalPair {
|
||||
consumption,
|
||||
helper,
|
||||
binding,
|
||||
helper_binding,
|
||||
} = pair;
|
||||
let r = receipt(raw, binding)?;
|
||||
let signed: SignedReceipt = serde_json::from_slice(raw)?;
|
||||
verify(helper_binding, &signed.payload, &signed.signature)?;
|
||||
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
|
||||
let expected = witness(&tx, consumption, helper, binding, helper_binding)?;
|
||||
ensure!(
|
||||
r.witness == expected && expected.boot_id == boot,
|
||||
"completion differs from native evidence"
|
||||
);
|
||||
let (scope, original) = crate::echo_probe::archive(&tx, binding)?.context("original scope")?;
|
||||
if installed(&tx, binding, &scope, &original)? {
|
||||
let prior: Vec<u8> = tx.query_row(
|
||||
"SELECT original_receipt FROM windows_echo_scope_completion WHERE id=1",
|
||||
[],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(prior == raw, "different completion already applied");
|
||||
return Ok(());
|
||||
}
|
||||
ensure!(r.valid(now), "completion expired or premature");
|
||||
for sql in schema() {
|
||||
tx.execute_batch(&sql)?;
|
||||
}
|
||||
tx.execute(
|
||||
"INSERT INTO windows_echo_scope_completion VALUES(1,?,?,?)",
|
||||
params![raw, r.witness_sha256, now.to_rfc3339()],
|
||||
)?;
|
||||
crate::echo_probe::retire_triggers(&tx)?;
|
||||
ensure!(
|
||||
crate::echo_probe::installed(&tx, binding)?.is_none(),
|
||||
"completion did not retire additional scope"
|
||||
);
|
||||
tx.commit()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ed25519_dalek::{Signer, SigningKey};
|
||||
use rmm_domain::{
|
||||
jobs::{Action, PlanPayload, PlannedJob, WindowsExecutionProfile},
|
||||
windows_echo_probe as echo,
|
||||
};
|
||||
use uuid::Uuid;
|
||||
#[test]
|
||||
fn scope_retirement_is_append_only_and_does_not_rewrite_history() -> Result<()> {
|
||||
let key = SigningKey::from_bytes(&[24; 32]);
|
||||
let now = Utc::now();
|
||||
let binding = Binding {
|
||||
tenant_id: echo::TENANT,
|
||||
asset_id: echo::ASSET,
|
||||
agent_id: echo::AGENT,
|
||||
enrollment_generation: 1,
|
||||
assignment_version: 1,
|
||||
public_key_hex: key
|
||||
.verifying_key()
|
||||
.to_bytes()
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect(),
|
||||
};
|
||||
let job = JobPayload {
|
||||
schema_version: 1,
|
||||
tenant_id: echo::TENANT,
|
||||
asset_id: echo::ASSET,
|
||||
agent_id: echo::AGENT,
|
||||
enrollment_generation: 1,
|
||||
assignment_version: 1,
|
||||
job_id: Uuid::new_v4(),
|
||||
attempt_id: Uuid::new_v4(),
|
||||
action: Action::RunScript {
|
||||
interpreter: "powershell".into(),
|
||||
script_utf8: echo::SCRIPT.into(),
|
||||
arguments: vec![],
|
||||
expected_stdout: Some(echo::OUTPUT.into()),
|
||||
windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned),
|
||||
privileged_script_profile: None,
|
||||
},
|
||||
execution_identity: "agent_service".into(),
|
||||
not_before: now,
|
||||
start_before: now + chrono::Duration::minutes(15),
|
||||
max_runtime_seconds: 60,
|
||||
max_output_bytes: 65536,
|
||||
};
|
||||
let job_bytes = serde_json::to_vec(&job)?;
|
||||
let plan = PlanPayload {
|
||||
schema_version: 1,
|
||||
tenant_id: echo::TENANT,
|
||||
plan_id: Uuid::new_v4(),
|
||||
principal: format!("automation:{}", echo::TENANT),
|
||||
reason: "fixture".into(),
|
||||
jobs: vec![PlannedJob {
|
||||
payload: job.clone(),
|
||||
job_payload_hash: hash(&job_bytes),
|
||||
script_sha256: Some(hash(echo::SCRIPT.as_bytes())),
|
||||
}],
|
||||
max_parallel: 1,
|
||||
halt_after_failures: 1,
|
||||
recipe_references: vec![],
|
||||
artifact_references: vec![],
|
||||
};
|
||||
let scope = ProbeScope::from_plan(&plan, Uuid::new_v4()).context("fixture fixed scope")?;
|
||||
let probe = ProbeReceipt {
|
||||
domain: echo::DOMAIN.into(),
|
||||
schema_version: 1,
|
||||
request_id: Uuid::new_v4(),
|
||||
receipt_id: Uuid::new_v4(),
|
||||
witness: Value::Null,
|
||||
witness_sha256: "0".repeat(64),
|
||||
scope: scope.clone(),
|
||||
scope_sha256: scope.digest().unwrap(),
|
||||
job_payload_bytes: job_bytes.clone(),
|
||||
key_id: hash(&key.verifying_key().to_bytes()),
|
||||
issued_at: now,
|
||||
valid_until: now + chrono::Duration::minutes(10),
|
||||
confirmed_by: echo::TEST_PRINCIPAL.into(),
|
||||
approval_origin: "dev_test_browser_simulation".into(),
|
||||
testsimulation: true,
|
||||
};
|
||||
let probe_payload = serde_json::to_vec(&probe)?;
|
||||
let old = SignedReceipt {
|
||||
signature: key.sign(&probe_payload).to_bytes().to_vec(),
|
||||
payload: probe_payload,
|
||||
};
|
||||
let original = serde_json::to_vec(&old)?;
|
||||
let mut db = Connection::open_in_memory()?;
|
||||
db.execute_batch("CREATE TABLE job_attempts(job TEXT,attempt TEXT,offer BLOB,state TEXT);CREATE TABLE original_history(raw BLOB);INSERT INTO original_history VALUES(x'00ff2a')")?;
|
||||
let tx = db.transaction()?;
|
||||
crate::echo_probe::install(&tx, &scope, &job_bytes, &original)?;
|
||||
tx.commit()?;
|
||||
let w = Witness {
|
||||
scope: scope.clone(),
|
||||
probe_receipt_id: probe.receipt_id,
|
||||
probe_receipt_sha256: hash(&old.payload),
|
||||
probe_signature_sha256: hash(&old.signature),
|
||||
grant_id: Uuid::new_v4(),
|
||||
grant_payload_sha256: "1".repeat(64),
|
||||
grant_signature_sha256: "2".repeat(64),
|
||||
outcome_sha256: "3".repeat(64),
|
||||
boot_id: Uuid::new_v4(),
|
||||
};
|
||||
let r = Receipt {
|
||||
domain: rmm_domain::windows_echo_completion::DOMAIN.into(),
|
||||
schema_version: 1,
|
||||
receipt_id: Uuid::new_v4(),
|
||||
witness_sha256: w.digest().unwrap(),
|
||||
witness: w,
|
||||
key_id: hash(&key.verifying_key().to_bytes()),
|
||||
issued_at: now,
|
||||
valid_until: now + chrono::Duration::minutes(10),
|
||||
confirmed_by: echo::TEST_PRINCIPAL.into(),
|
||||
approval_origin: "dev_test_browser_simulation".into(),
|
||||
testsimulation: true,
|
||||
ready: false,
|
||||
helper_ready: false,
|
||||
unlock: false,
|
||||
};
|
||||
let seal = |r: &Receipt| -> Result<Vec<u8>> {
|
||||
let payload = serde_json::to_vec(r)?;
|
||||
Ok(serde_json::to_vec(&SignedReceipt {
|
||||
signature: key.sign(&payload).to_bytes().to_vec(),
|
||||
payload,
|
||||
})?)
|
||||
};
|
||||
let raw = seal(&r)?;
|
||||
for field in 0..4 {
|
||||
let mut bad = r.clone();
|
||||
match field {
|
||||
0 => bad.ready = true,
|
||||
1 => bad.helper_ready = true,
|
||||
2 => bad.unlock = true,
|
||||
_ => bad.testsimulation = false,
|
||||
};
|
||||
assert!(receipt(&seal(&bad)?, &binding).is_err());
|
||||
}
|
||||
assert!(
|
||||
receipt(
|
||||
&raw,
|
||||
&Binding {
|
||||
public_key_hex: "00".repeat(32),
|
||||
..binding.clone()
|
||||
}
|
||||
)
|
||||
.is_err()
|
||||
);
|
||||
assert!(!installed(&db, &binding, &scope, &original)?);
|
||||
let tx = db.transaction()?;
|
||||
for sql in schema() {
|
||||
tx.execute_batch(&sql)?;
|
||||
}
|
||||
tx.execute(
|
||||
"INSERT INTO windows_echo_scope_completion VALUES(1,?,?,?)",
|
||||
params![raw, r.witness_sha256, now.to_rfc3339()],
|
||||
)?;
|
||||
crate::echo_probe::retire_triggers(&tx)?;
|
||||
tx.commit()?;
|
||||
assert!(installed(&db, &binding, &scope, &original)?);
|
||||
crate::echo_probe::check(&db, &scope, &job_bytes, &original)?;
|
||||
assert_eq!(
|
||||
db.query_row("SELECT raw FROM original_history", [], |r| r
|
||||
.get::<_, Vec<u8>>(0))?,
|
||||
vec![0, 255, 42]
|
||||
);
|
||||
for sql in [
|
||||
"DELETE FROM windows_echo_scope_completion",
|
||||
"UPDATE windows_echo_scope_completion SET applied_at='other'",
|
||||
"INSERT OR REPLACE INTO windows_echo_scope_completion SELECT * FROM windows_echo_scope_completion",
|
||||
"DELETE FROM windows_echo_probe_scope",
|
||||
] {
|
||||
assert!(db.execute(sql, []).is_err());
|
||||
}
|
||||
let tx = db.transaction()?;
|
||||
tx.execute_batch("DROP TRIGGER windows_echo_completion_no_change")?;
|
||||
assert!(installed(&tx, &binding, &scope, &original).is_err());
|
||||
tx.rollback()?;
|
||||
let mut changed = scope.clone();
|
||||
changed.attempt_id = Uuid::new_v4();
|
||||
assert!(installed(&db, &binding, &changed, &original).is_err());
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -24,17 +24,26 @@ const IMMUTABLE: &str = "CREATE TRIGGER windows_echo_probe_no_change BEFORE UPDA
|
||||
const RETAIN: &str = "CREATE TRIGGER windows_echo_probe_no_delete BEFORE DELETE ON windows_echo_probe_scope BEGIN SELECT RAISE(ABORT,'WINDOWS_ECHO_SCOPE_IMMUTABLE'); END";
|
||||
const BOUND: &str = "WHEN NOT EXISTS(SELECT 1 FROM windows_echo_probe_scope s WHERE s.id=1 AND s.job=NEW.job AND s.attempt=NEW.attempt AND typeof(NEW.offer)='blob' AND length(NEW.offer)=length(s.prefix)+36+length(s.suffix) AND substr(NEW.offer,1,length(s.prefix))=s.prefix AND substr(NEW.offer,-length(s.suffix))=s.suffix) BEGIN SELECT RAISE(ABORT,'WINDOWS_ECHO_OFFER_OUT_OF_SCOPE'); END";
|
||||
|
||||
fn schema() -> [String; 6] {
|
||||
fn schema(completed: bool) -> [String; 6] {
|
||||
let bound = if completed {
|
||||
BOUND.replacen(
|
||||
"WHEN ",
|
||||
"WHEN NOT EXISTS(SELECT 1 FROM windows_echo_scope_completion WHERE id=1) AND ",
|
||||
1,
|
||||
)
|
||||
} else {
|
||||
BOUND.to_owned()
|
||||
};
|
||||
[
|
||||
POLICY.to_owned(),
|
||||
"CREATE TRIGGER windows_echo_probe_no_replace BEFORE INSERT ON windows_echo_probe_scope WHEN EXISTS(SELECT 1 FROM windows_echo_probe_scope) BEGIN SELECT RAISE(ABORT,'WINDOWS_ECHO_SCOPE_IMMUTABLE'); END".to_owned(),
|
||||
IMMUTABLE.to_owned(),
|
||||
RETAIN.to_owned(),
|
||||
format!(
|
||||
"CREATE TRIGGER windows_echo_probe_offer_insert BEFORE INSERT ON job_attempts {BOUND}"
|
||||
"CREATE TRIGGER windows_echo_probe_offer_insert BEFORE INSERT ON job_attempts {bound}"
|
||||
),
|
||||
format!(
|
||||
"CREATE TRIGGER windows_echo_probe_offer_update BEFORE UPDATE OF job,attempt,offer ON job_attempts {BOUND}"
|
||||
"CREATE TRIGGER windows_echo_probe_offer_update BEFORE UPDATE OF job,attempt,offer ON job_attempts {bound}"
|
||||
),
|
||||
]
|
||||
}
|
||||
@@ -82,7 +91,7 @@ pub fn install(
|
||||
review: &[u8],
|
||||
) -> Result<()> {
|
||||
let (prefix, suffix) = blobs(scope, payload)?;
|
||||
for sql in schema() {
|
||||
for sql in schema(false) {
|
||||
tx.execute_batch(&sql)?;
|
||||
}
|
||||
tx.execute(
|
||||
@@ -100,7 +109,12 @@ pub fn install(
|
||||
}
|
||||
pub fn check(db: &Connection, scope: &ProbeScope, payload: &[u8], review: &[u8]) -> Result<()> {
|
||||
let (prefix, suffix) = blobs(scope, payload)?;
|
||||
for (name, expected) in OBJECTS.iter().zip(schema()) {
|
||||
let completed: bool = db.query_row(
|
||||
"SELECT EXISTS(SELECT 1 FROM sqlite_schema WHERE name='windows_echo_scope_completion')",
|
||||
[],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
for (name, expected) in OBJECTS.iter().zip(schema(completed)) {
|
||||
let actual: String =
|
||||
db.query_row("SELECT sql FROM sqlite_schema WHERE name=?", [name], |r| {
|
||||
r.get(0)
|
||||
@@ -115,6 +129,20 @@ pub fn installed(
|
||||
db: &Connection,
|
||||
binding: &rmm_agent_core::auth::Binding,
|
||||
) -> Result<Option<ProbeScope>> {
|
||||
let Some((scope, raw)) = archive(db, binding)? else {
|
||||
return Ok(None);
|
||||
};
|
||||
if crate::echo_completion::installed(db, binding, &scope, &raw)? {
|
||||
return Ok(None);
|
||||
}
|
||||
Ok(Some(scope))
|
||||
}
|
||||
|
||||
/// Verify the retained original, including after the separately reviewed completion.
|
||||
pub fn archive(
|
||||
db: &Connection,
|
||||
binding: &rmm_agent_core::auth::Binding,
|
||||
) -> Result<Option<(ProbeScope, Vec<u8>)>> {
|
||||
use rmm_agent_core::crypto::{DalekVerifier, Ed25519Verifier};
|
||||
use rmm_domain::{
|
||||
checkpoint_repair::SignedReceipt, windows_echo_probe::ProbeReceipt,
|
||||
@@ -141,7 +169,17 @@ pub fn installed(
|
||||
"Echo archive signature"
|
||||
);
|
||||
check(db, &r.scope, &r.job_payload_bytes, &raw)?;
|
||||
Ok(Some(r.scope))
|
||||
Ok(Some((r.scope, raw)))
|
||||
}
|
||||
|
||||
pub(crate) fn retire_triggers(tx: &Transaction<'_>) -> Result<()> {
|
||||
for name in &OBJECTS[4..] {
|
||||
tx.execute_batch(&format!("DROP TRIGGER {name}"))?;
|
||||
}
|
||||
for ddl in &schema(true)[4..] {
|
||||
tx.execute_batch(ddl)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn permits_offer(scope: &ProbeScope, offer: &JobOffer, job: &JobPayload) -> bool {
|
||||
scope.matches_job(job)
|
||||
|
||||
@@ -26,6 +26,8 @@ const PROBE_FILE: &str = "helper-probe.json";
|
||||
pub struct Client {
|
||||
pin: ipc::Pin,
|
||||
lane: Arc<Semaphore>,
|
||||
qualified_capabilities: Vec<String>,
|
||||
probed_at: Option<std::time::Instant>,
|
||||
}
|
||||
pub struct ControlSnapshot {
|
||||
pub raw: Snapshot,
|
||||
@@ -73,7 +75,7 @@ impl Client {
|
||||
"HELPER_JOB_BINDING_MISMATCH"
|
||||
);
|
||||
}
|
||||
Ok(Some(Self { pin, lane }))
|
||||
Ok(Some(Self { pin, lane, qualified_capabilities:vec![], probed_at:None }))
|
||||
}
|
||||
pub async fn refresh(
|
||||
agent_id: String,
|
||||
@@ -89,8 +91,8 @@ impl Client {
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let _permit = permit;
|
||||
let result=(|| {
|
||||
let client=Self::discover(&agent_id,&asset_id,binding.as_ref(),lane).context(ipc::Stage::DiscoverPin)?;
|
||||
if let Some(client)=&client {client.probe_blocking(&state)?;}
|
||||
let mut client=Self::discover(&agent_id,&asset_id,binding.as_ref(),lane).context(ipc::Stage::DiscoverPin)?;
|
||||
if let Some(client)=&mut client {client.probe_blocking(&state)?;}
|
||||
Ok(client)
|
||||
})();
|
||||
if result.is_err() || matches!(&result,Ok(None)) && state.join(PROBE_FILE).try_exists()? {
|
||||
@@ -338,7 +340,7 @@ impl Client {
|
||||
})
|
||||
.await?
|
||||
}
|
||||
fn probe_blocking(&self, state: &Path) -> Result<()> {
|
||||
fn probe_blocking(&mut self, state: &Path) -> Result<()> {
|
||||
self.check_pin().context(ipc::Stage::DiscoverPin)?;
|
||||
let pin = &self.pin;
|
||||
let call = ipc::Call::new(pin, ipc::Operation::Probe {});
|
||||
@@ -357,8 +359,16 @@ impl Client {
|
||||
};
|
||||
let value = json!({"schema_version":1,"source":"actual_local_service_runtime","agent_process_id":std::process::id(),"agent_service":crate::SERVICE_NAME,"agent_id":pin.binding.agent_id,"asset_id":pin.binding.asset_id,"challenge":reply.challenge,"observed_at":chrono::Utc::now(),"helper_service":ipc::HELPER_SERVICE,"verified_helper_user_sid":pin.helper.user_sid,"verified_helper_service_sid":pin.helper.service_sid,"helper_binary_sha256":reply.helper_binary_sha256,"policy_sha256":reply.policy_sha256,"authenticated_pipe_exchange":true,"client_service_pid_verified_by_helper":true,"ledger_file_id":ledger,"executor_lock_file_id":lock,"helper_clock_qualified":clock_qualified,"helper_ready":ready,"system_capability_advertised":false,"no_jobs":true});
|
||||
self.check_pin()?;
|
||||
self.qualified_capabilities=crate::system_capabilities::qualified(pin,clock_qualified)?;
|
||||
self.probed_at=Some(std::time::Instant::now());
|
||||
let mut value=value;
|
||||
value["system_capability_advertised"]=json!(!self.qualified_capabilities.is_empty());
|
||||
value["qualified_capabilities"]=json!(self.qualified_capabilities);
|
||||
write_current_probe(state, &value).context(ipc::Stage::ClientReport)
|
||||
}
|
||||
pub fn qualified_capabilities(&self) -> Vec<String> {
|
||||
if self.probed_at.is_some_and(|at|at.elapsed()<=Duration::from_secs(90)) {self.qualified_capabilities.clone()} else {vec![]}
|
||||
}
|
||||
/// Pure admission shape only; no capability or qualification is asserted.
|
||||
pub fn supports_system(&self, job: &JobPayload) -> bool {
|
||||
system_shape(job)
|
||||
|
||||
@@ -6,6 +6,9 @@ pub mod certificate_rotation;
|
||||
#[cfg(windows)]
|
||||
pub mod clock;
|
||||
pub mod echo_probe;
|
||||
pub mod echo_completion;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
pub mod system_capabilities;
|
||||
pub mod event_log;
|
||||
#[cfg(windows)]
|
||||
pub mod event_log_job;
|
||||
@@ -32,6 +35,8 @@ pub mod service;
|
||||
pub mod signed_clock;
|
||||
#[cfg(all(windows, feature = "system-helper"))]
|
||||
mod system_script;
|
||||
#[cfg(feature = "system-helper")]
|
||||
pub mod update_native;
|
||||
|
||||
pub const SERVICE_NAME: &str = "RmmDiscoveryWindows";
|
||||
pub const CAPABILITIES: &[&str] = &["windows.base/1", "heartbeat/1"];
|
||||
|
||||
@@ -49,6 +49,42 @@ struct Config {
|
||||
)]
|
||||
windows_execution_profile: Option<rmm_domain::jobs::WindowsExecutionProfile>,
|
||||
}
|
||||
/// Local TLS maintenance evidence only. It never restores readiness; after
|
||||
/// renewal both roles must pass their ordinary fresh signed synchronization.
|
||||
#[derive(serde::Serialize, Deserialize, PartialEq, Eq)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct RotationIdleAdmission {
|
||||
schema_version: u32,
|
||||
agent_id: String,
|
||||
binding_sha256: String,
|
||||
boot_id: String,
|
||||
journal_file_id: [u32; 3],
|
||||
ledger_file_id: [u32; 3],
|
||||
history_sha256: String,
|
||||
helper_pin_sha256: Option<String>,
|
||||
helper_anchor_sha256: Option<String>,
|
||||
intent_file_id: Option<[u32; 3]>,
|
||||
}
|
||||
fn rotation_file_id(path: &Path) -> Result<[u32; 3]> {
|
||||
use std::os::windows::io::AsRawHandle;
|
||||
use windows_sys::Win32::Storage::FileSystem::{
|
||||
BY_HANDLE_FILE_INFORMATION, GetFileInformationByHandle,
|
||||
};
|
||||
native::private_path(path, false)?;
|
||||
let file = fs::File::open(path)?;
|
||||
let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
|
||||
// SAFETY: live file handle and correctly sized writable native structure.
|
||||
ensure!(
|
||||
unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut info) } != 0
|
||||
&& info.nNumberOfLinks == 1,
|
||||
"ROTATION_FILE_IDENTITY"
|
||||
);
|
||||
Ok([
|
||||
info.dwVolumeSerialNumber,
|
||||
info.nFileIndexHigh,
|
||||
info.nFileIndexLow,
|
||||
])
|
||||
}
|
||||
impl Config {
|
||||
fn profile_enabled(&self, profile: rmm_domain::jobs::WindowsExecutionProfile) -> bool {
|
||||
self.enable_jobs
|
||||
@@ -536,6 +572,137 @@ struct Agent {
|
||||
deferred_permit: Option<(u64, ExecutionPermit)>,
|
||||
}
|
||||
impl Agent {
|
||||
fn rotation_without_effects(&self) -> Result<()> {
|
||||
ensure!(
|
||||
self.running.is_none() && self.deferred_permit.is_none() && !self.prepared,
|
||||
"ROTATION_BUSY"
|
||||
);
|
||||
let idle: bool = self.journal.connection().query_row("SELECT NOT EXISTS(SELECT 1 FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired'))", [], |r| r.get(0))?;
|
||||
ensure!(idle, "ROTATION_EFFECT_UNRESOLVED");
|
||||
if let Some(ledger) = &self.ledger {
|
||||
let resolved: bool = ledger.query_row("SELECT NOT EXISTS(SELECT 1 FROM consumed c LEFT JOIN execution_evidence e USING(grant_id) WHERE c.result IS NULL OR e.start IS NULL OR e.outcome IS NULL)", [], |r| r.get(0))?;
|
||||
ensure!(resolved, "ROTATION_CONSUMPTION_UNRESOLVED");
|
||||
}
|
||||
#[cfg(feature = "system-helper")]
|
||||
{
|
||||
ensure!(
|
||||
self.helper_control.is_none()
|
||||
&& self.helper_probe.is_none()
|
||||
&& !self.helper_apply_unconfirmed,
|
||||
"ROTATION_HELPER_CONTROL_PENDING"
|
||||
);
|
||||
if Path::new(rmm_agent_windows::helper_runtime::intent::DB).try_exists()? {
|
||||
let intents = rmm_agent_windows::helper_runtime::intent::Store::open(false)?;
|
||||
ensure!(
|
||||
intents.pending()?.is_empty(),
|
||||
"ROTATION_SYSTEM_DELEGATION_PENDING"
|
||||
);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn rotation_admission(
|
||||
&self,
|
||||
generation: Option<u64>,
|
||||
retained: Option<&[u8]>,
|
||||
) -> Result<Vec<u8>> {
|
||||
self.rotation_without_effects()?;
|
||||
let old: Option<RotationIdleAdmission> =
|
||||
retained.map(serde_json::from_slice).transpose()?;
|
||||
if let Some(generation) = generation {
|
||||
#[cfg(feature = "system-helper")]
|
||||
let helper_present = self.helper.is_some();
|
||||
#[cfg(not(feature = "system-helper"))]
|
||||
let helper_present = false;
|
||||
ensure!(
|
||||
self.ready_identity(generation, helper_present),
|
||||
"ROTATION_SIGNED_IDLE_REQUIRED"
|
||||
);
|
||||
} else {
|
||||
ensure!(
|
||||
self.fence.generation.load(Ordering::SeqCst) == 0 && old.is_some(),
|
||||
"ROTATION_PENDING_IDLE_ADMISSION_REQUIRED"
|
||||
);
|
||||
}
|
||||
#[cfg(feature = "system-helper")]
|
||||
let (helper_pin_sha256, helper_anchor_sha256, intent_file_id) = {
|
||||
use rmm_agent_windows::helper_runtime::{Client, intent};
|
||||
let helper = Client::discover(
|
||||
&self.identity.agent_id,
|
||||
&self.identity.asset_id,
|
||||
self.binding.as_ref(),
|
||||
self.helper_lane.clone(),
|
||||
)?;
|
||||
let pin = helper.as_ref().map(|h| {
|
||||
format!(
|
||||
"{:x}",
|
||||
Sha256::digest(
|
||||
format!("{}:{}", h.pin_hash(), h.helper_binary_hash()).as_bytes()
|
||||
)
|
||||
)
|
||||
});
|
||||
let anchor = if helper.is_some() {
|
||||
if generation.is_some() {
|
||||
Some(format!(
|
||||
"{:x}",
|
||||
Sha256::digest(serde_json::to_vec(
|
||||
self.helper_anchor
|
||||
.as_ref()
|
||||
.context("ROTATION_HELPER_ANCHOR_REQUIRED")?
|
||||
)?)
|
||||
))
|
||||
} else {
|
||||
let saved = old
|
||||
.as_ref()
|
||||
.and_then(|a| a.helper_anchor_sha256.clone())
|
||||
.context("ROTATION_RETAINED_HELPER_ANCHOR_REQUIRED")?;
|
||||
ensure!(
|
||||
saved.len() == 64 && saved.bytes().all(|b| b.is_ascii_hexdigit()),
|
||||
"ROTATION_RETAINED_HELPER_ANCHOR_INVALID"
|
||||
);
|
||||
Some(saved)
|
||||
}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let file = Path::new(intent::DB)
|
||||
.try_exists()?
|
||||
.then(|| rotation_file_id(Path::new(intent::DB)))
|
||||
.transpose()?;
|
||||
(pin, anchor, file)
|
||||
};
|
||||
#[cfg(not(feature = "system-helper"))]
|
||||
let (helper_pin_sha256, helper_anchor_sha256, intent_file_id) = (None, None, None);
|
||||
let admission = RotationIdleAdmission {
|
||||
schema_version: 1,
|
||||
agent_id: self.identity.agent_id.clone(),
|
||||
binding_sha256: format!(
|
||||
"{:x}",
|
||||
Sha256::digest(serde_json::to_vec(
|
||||
self.binding.as_ref().context("ROTATION_BINDING_REQUIRED")?
|
||||
)?)
|
||||
),
|
||||
boot_id: self.boot.clone(),
|
||||
journal_file_id: rotation_file_id(
|
||||
&self.config.state_directory.join("telemetry.sqlite"),
|
||||
)?,
|
||||
ledger_file_id: rotation_file_id(
|
||||
&self.config.state_directory.join("consumption.sqlite"),
|
||||
)?,
|
||||
history_sha256: rmm_agent_windows::certificate_rotation::idle_history_sha256(
|
||||
self.journal.connection(),
|
||||
self.ledger.as_ref().context("ROTATION_LEDGER_REQUIRED")?,
|
||||
)?,
|
||||
helper_pin_sha256,
|
||||
helper_anchor_sha256,
|
||||
intent_file_id,
|
||||
};
|
||||
ensure!(
|
||||
old.as_ref().is_none_or(|saved| saved == &admission),
|
||||
"ROTATION_IDLE_STATE_CHANGED"
|
||||
);
|
||||
Ok(serde_json::to_vec(&admission)?)
|
||||
}
|
||||
#[cfg(feature = "system-helper")]
|
||||
fn start_time_refresh(
|
||||
&mut self,
|
||||
@@ -958,6 +1125,12 @@ impl Agent {
|
||||
caps.push(rmm_agent_windows::actions::REMOTE_SIGNED_PROFILE_CAPABILITY.into());
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "system-helper")]
|
||||
if !self.config.windows_echo_probe_only
|
||||
&& let Some(helper) = &self.helper
|
||||
{
|
||||
caps.extend(helper.qualified_capabilities());
|
||||
}
|
||||
}
|
||||
caps
|
||||
}
|
||||
@@ -1679,11 +1852,16 @@ impl Agent {
|
||||
// Server commit may have fenced Hello even if its HTTP response was
|
||||
// lost. Recover the durable original CSR before requiring any channel.
|
||||
if self.certificates.has_pending(self.journal.connection())? {
|
||||
ensure!(
|
||||
!self.config.enable_jobs,
|
||||
"ROTATION_PENDING_REQUIRES_PASSIVE_RECOVERY"
|
||||
);
|
||||
self.renew_certificate().await?;
|
||||
let admission = if self.config.enable_jobs {
|
||||
let retained = self
|
||||
.certificates
|
||||
.pending_idle_admission(self.journal.connection())?
|
||||
.context("ROTATION_PENDING_REQUIRES_PASSIVE_RECOVERY")?;
|
||||
Some(self.rotation_admission(None, Some(&retained))?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
self.renew_certificate(admission.as_deref()).await?;
|
||||
}
|
||||
self.boot = native::boot_id().await?;
|
||||
let advertised = self.capabilities();
|
||||
@@ -1747,6 +1925,7 @@ impl Agent {
|
||||
let mut inventory = Instant::now();
|
||||
let mut update_at = Instant::now();
|
||||
let mut rotation_at = Instant::now();
|
||||
let mut rotation_after = Duration::from_secs(30);
|
||||
let mut heartbeat = Instant::now() - Duration::from_secs(60);
|
||||
let mut heartbeat_after = Duration::from_secs(30);
|
||||
let mut tick = tokio::time::interval(Duration::from_secs(1));
|
||||
@@ -1834,19 +2013,32 @@ impl Agent {
|
||||
if stop.load(Ordering::SeqCst) {
|
||||
continue;
|
||||
}
|
||||
// This slice renews only passive clients. Job admission and helper
|
||||
// lifecycle are not extended by certificate maintenance.
|
||||
if !self.config.enable_jobs && rotation_at.elapsed() >= Duration::from_secs(30) {
|
||||
// Certificate maintenance cannot interrupt accepted, ambiguous or
|
||||
// live work. Active rotation also retains its exact signed-idle
|
||||
// context for a closed, effect-free retry after response loss.
|
||||
if rotation_at.elapsed() >= rotation_after {
|
||||
rotation_at = Instant::now();
|
||||
rotation_after = Duration::from_secs(30);
|
||||
let now = Utc::now().timestamp();
|
||||
if self
|
||||
.certificates
|
||||
.due(self.journal.connection(), &self.key_files, now)?
|
||||
{
|
||||
self.renew_certificate().await?;
|
||||
// The server fences the previous connection generation.
|
||||
// A new Hello/Sync uses the newly selected pair.
|
||||
return Ok(());
|
||||
let admission = if self.config.enable_jobs {
|
||||
self.rotation_admission(Some(generation), None).map(Some)
|
||||
} else {
|
||||
self.rotation_without_effects().map(|()| None)
|
||||
};
|
||||
if let Ok(admission) = admission {
|
||||
self.renew_certificate(admission.as_deref()).await?;
|
||||
// No offers are processed during renewal. The server
|
||||
// fences this channel; fresh Hello/Sync must qualify
|
||||
// both roles again before any subsequent job starts.
|
||||
return Ok(());
|
||||
}
|
||||
// Avoid phase-locking a due renewal to the 30s helper
|
||||
// probe cadence. Busy work keeps its guard and continues.
|
||||
rotation_after = Duration::from_secs(1);
|
||||
}
|
||||
}
|
||||
if heartbeat.elapsed() >= heartbeat_after {
|
||||
@@ -1901,13 +2093,23 @@ impl Agent {
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
async fn renew_certificate(&mut self) -> Result<()> {
|
||||
ensure!(!self.config.enable_jobs, "PASSIVE_RENEWAL_ONLY");
|
||||
async fn renew_certificate(&mut self, admission: Option<&[u8]>) -> Result<()> {
|
||||
self.rotation_without_effects()?;
|
||||
ensure!(
|
||||
!self.config.enable_jobs || admission.is_some(),
|
||||
"ROTATION_ACTIVE_IDLE_REQUIRED"
|
||||
);
|
||||
self.close_gate();
|
||||
let request = self.certificates.prepare(
|
||||
#[cfg(feature = "system-helper")]
|
||||
self.stop_time_refresh().await;
|
||||
if self.config.enable_jobs {
|
||||
self.rotation_admission(None, admission)?;
|
||||
}
|
||||
let request = self.certificates.prepare_with_idle_admission(
|
||||
self.journal.connection_mut(),
|
||||
&self.key_files,
|
||||
Utc::now().timestamp(),
|
||||
admission,
|
||||
)?;
|
||||
let client = crate::https_channel::mtls_client(
|
||||
self.config.connect_address,
|
||||
|
||||
@@ -0,0 +1,154 @@
|
||||
//! Operator-provisioned native qualification intersected with a live authenticated helper.
|
||||
//! A source build or a permissive policy by itself cannot publish SYSTEM capabilities.
|
||||
use crate::{
|
||||
helper_ipc::{self as ipc, Pin, PinnedFile},
|
||||
helper_system,
|
||||
};
|
||||
use anyhow::{Result, ensure};
|
||||
use serde::Deserialize;
|
||||
use std::{collections::BTreeSet, io::Read, path::Path};
|
||||
use uuid::Uuid;
|
||||
|
||||
pub const PATH: &str = r"C:\ProgramData\RustDiscoverySystem\system-qualification.json";
|
||||
pub const RESULT_PATH: &str = r"C:\ProgramData\RustDiscoverySystem\system-native-result.json";
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Qualification {
|
||||
schema_version: u32,
|
||||
tenant_id: Uuid,
|
||||
asset_id: Uuid,
|
||||
agent_id: Uuid,
|
||||
enrollment_generation: u64,
|
||||
assignment_version: u64,
|
||||
agent_binary_sha256: String,
|
||||
helper_binary_sha256: String,
|
||||
policy_sha256: String,
|
||||
native_result_sha256: String,
|
||||
qualification_reference: Uuid,
|
||||
actions: Vec<String>,
|
||||
}
|
||||
pub fn qualified(pin: &Pin, clock_qualified: bool) -> Result<Vec<String>> {
|
||||
if !clock_qualified || !Path::new(PATH).try_exists()? {
|
||||
return Ok(vec![]);
|
||||
}
|
||||
let readers = [
|
||||
ipc::service_sid(crate::SERVICE_NAME)?,
|
||||
ipc::service_sid(ipc::HELPER_SERVICE)?,
|
||||
];
|
||||
let root = Path::new(PATH)
|
||||
.parent()
|
||||
.expect("fixed qualification parent");
|
||||
let mut dir = PinnedFile::open_read_shared(root, true, &readers, &[])?;
|
||||
let mut file = PinnedFile::open(Path::new(PATH), false, &readers, &[], false)?;
|
||||
let mut bytes = vec![];
|
||||
(&mut file.file).take(16385).read_to_end(&mut bytes)?;
|
||||
ensure!(bytes.len() <= 16384, "system qualification size");
|
||||
file.check()?;
|
||||
dir.check()?;
|
||||
let q: Qualification = serde_json::from_slice(&bytes)?;
|
||||
ensure!(
|
||||
q.schema_version == 1
|
||||
&& (
|
||||
q.tenant_id,
|
||||
q.asset_id,
|
||||
q.agent_id,
|
||||
q.enrollment_generation,
|
||||
q.assignment_version
|
||||
) == (
|
||||
pin.binding.tenant_id,
|
||||
pin.binding.asset_id,
|
||||
pin.binding.agent_id,
|
||||
pin.binding.enrollment_generation,
|
||||
pin.binding.assignment_version
|
||||
)
|
||||
&& q.agent_binary_sha256 == pin.agent.binary_sha256
|
||||
&& q.helper_binary_sha256 == pin.helper.binary_sha256
|
||||
&& q.policy_sha256 == pin.policy_sha256
|
||||
&& ipc::digest(&q.native_result_sha256)
|
||||
&& !q.qualification_reference.is_nil()
|
||||
&& !q.actions.is_empty()
|
||||
&& q.actions.len() <= 3
|
||||
&& q.actions.iter().collect::<BTreeSet<_>>().len() == q.actions.len()
|
||||
&& q.actions.iter().all(|a| matches!(
|
||||
a.as_str(),
|
||||
"run_script" | "set_service_state" | "ensure_package"
|
||||
)),
|
||||
"system qualification binding"
|
||||
);
|
||||
let mut result = PinnedFile::open(Path::new(RESULT_PATH), false, &readers, &[], false)?;
|
||||
let mut result_bytes = vec![];
|
||||
(&mut result.file)
|
||||
.take(65537)
|
||||
.read_to_end(&mut result_bytes)?;
|
||||
ensure!(
|
||||
result_bytes.len() <= 65536
|
||||
&& rmm_domain::jobs::hash(&result_bytes) == q.native_result_sha256,
|
||||
"system native qualification evidence hash"
|
||||
);
|
||||
result.check()?;
|
||||
let evidence: serde_json::Value = serde_json::from_slice(&result_bytes)?;
|
||||
ensure!(
|
||||
evidence["schema_version"] == 1
|
||||
&& evidence["platform"] == "windows-x86_64"
|
||||
&& evidence["qualification_reference"] == q.qualification_reference.to_string()
|
||||
&& evidence["helper_binary_sha256"] == q.helper_binary_sha256
|
||||
&& evidence["validated_actions"] == serde_json::to_value(&q.actions)?
|
||||
&& evidence["status"] == "passed",
|
||||
"system native qualification evidence profile"
|
||||
);
|
||||
let (settings, _handles) = helper_system::read_settings()?;
|
||||
ensure!(
|
||||
serde_json::to_vec(&settings.pin()?)? == serde_json::to_vec(pin)?
|
||||
&& settings.enable_effects,
|
||||
"system qualification effective policy"
|
||||
);
|
||||
let mut caps = vec![
|
||||
"helper.system.v1".into(),
|
||||
format!("helper.binary.sha256:{}", pin.helper.binary_sha256),
|
||||
format!("helper.policy.sha256:{}", pin.policy_sha256),
|
||||
];
|
||||
for action in q.actions {
|
||||
match action.as_str() {
|
||||
"run_script" => {
|
||||
ensure!(
|
||||
settings.schema_version == 3
|
||||
&& settings.allowed_script_profiles.as_deref()
|
||||
== Some(&[
|
||||
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1
|
||||
])
|
||||
&& crate::actions::powershell().is_ok(),
|
||||
"system script qualification policy"
|
||||
);
|
||||
caps.extend(["system:run_script", "script.full_maintenance/1"].map(str::to_string));
|
||||
}
|
||||
"set_service_state" => {
|
||||
ensure!(
|
||||
!settings.allowed_services.is_empty(),
|
||||
"system SCM qualification policy"
|
||||
);
|
||||
caps.extend(["set_service_state", "system:set_service_state"].map(str::to_string));
|
||||
}
|
||||
"ensure_package" => {
|
||||
ensure!(
|
||||
settings.schema_version >= 2
|
||||
&& settings
|
||||
.allowed_msi_recipe_sha256
|
||||
.as_ref()
|
||||
.is_some_and(|v| !v.is_empty())
|
||||
&& crate::msi_cache::stage_configured(),
|
||||
"system MSI qualification policy"
|
||||
);
|
||||
caps.extend(
|
||||
[
|
||||
"ensure_package",
|
||||
"system:ensure_package",
|
||||
rmm_domain::windows_execution::MSI_CAPABILITY,
|
||||
]
|
||||
.map(str::to_string),
|
||||
);
|
||||
}
|
||||
_ => unreachable!("validated qualification action"),
|
||||
}
|
||||
}
|
||||
Ok(caps)
|
||||
}
|
||||
@@ -0,0 +1,278 @@
|
||||
//! File-swap fence against the SAME original guarded SYSTEM helper ledger.
|
||||
//! Construction never re-enters a partial replacement or creates a handoff.
|
||||
use super::{
|
||||
Budget, DurableEffectFence, Effect, Role, digest,
|
||||
files::{self, Location, Proof},
|
||||
};
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_agent_core::{
|
||||
reconcile::SyncClock,
|
||||
update_handoff::{
|
||||
self as core, NativeEffect, NativeEffectClaim, NativeFileRole, Participant,
|
||||
UpdateParticipantGuard,
|
||||
},
|
||||
};
|
||||
use rmm_updater_handoff::{Evidence, Handoff, Phase, PinTransition};
|
||||
use rusqlite::Connection;
|
||||
|
||||
const ROLES: [Role; 5] = [
|
||||
Role::Agent,
|
||||
Role::Helper,
|
||||
Role::Settings,
|
||||
Role::Pin,
|
||||
Role::TimeProfile,
|
||||
];
|
||||
fn native(role: Role) -> NativeFileRole {
|
||||
match role {
|
||||
Role::Agent => NativeFileRole::AgentBinary,
|
||||
Role::Helper => NativeFileRole::HelperBinary,
|
||||
Role::Settings => NativeFileRole::WindowsSettings,
|
||||
Role::Pin => NativeFileRole::WindowsPin,
|
||||
Role::TimeProfile => NativeFileRole::WindowsTimeProfile,
|
||||
}
|
||||
}
|
||||
pub struct LedgerFence<'a, 'b, G, C> {
|
||||
db: &'a mut Connection,
|
||||
guard: &'a G,
|
||||
clock: &'a C,
|
||||
budget: &'a Budget<'b>,
|
||||
original: Handoff,
|
||||
originals: &'a [Proof; 5],
|
||||
staged: &'a [Proof; 5],
|
||||
pending: Option<(Effect, NativeEffectClaim)>,
|
||||
next: usize,
|
||||
saved: bool,
|
||||
poisoned: bool,
|
||||
}
|
||||
/// Bindings are independently re-read before effects; parsed/transferred Proof
|
||||
/// records never substitute for actual protected file identities/bytes.
|
||||
pub struct Inputs<'a, 'b, G, C> {
|
||||
pub db: &'a mut Connection,
|
||||
pub guard: &'a G,
|
||||
pub clock: &'a C,
|
||||
pub budget: &'a Budget<'b>,
|
||||
pub original: &'a Handoff,
|
||||
pub originals: &'a [Proof; 5],
|
||||
pub staged: &'a [Proof; 5],
|
||||
}
|
||||
impl<'a, 'b, G: UpdateParticipantGuard, C: SyncClock> LedgerFence<'a, 'b, G, C> {
|
||||
pub fn new(input: Inputs<'a, 'b, G, C>) -> Result<Self> {
|
||||
input.budget.check()?;
|
||||
input.original.validate()?;
|
||||
ensure!(
|
||||
input.original.pin_transition == PinTransition::WindowsCodePairClockV1
|
||||
&& input.guard.participant() == Participant::StableUpdater,
|
||||
"UPDATE_WINDOWS_FENCE_ROLE"
|
||||
);
|
||||
let grant = input.original.attempt.grant_id;
|
||||
let journal = core::read(input.db, input.guard, grant)?;
|
||||
ensure!(
|
||||
journal.phase() == Phase::UpdaterOwnsLedger,
|
||||
"UPDATE_NO_FENCE_RESUME"
|
||||
);
|
||||
// Retained Handoff is immutable and read through the actual executor
|
||||
// guard. No separately supplied record may stand in for those bytes.
|
||||
let raw: Vec<u8> = input.db.query_row(
|
||||
"SELECT record FROM agent_update_handoffs WHERE grant_id=?1",
|
||||
[grant.to_string()],
|
||||
|r| r.get(0),
|
||||
)?;
|
||||
ensure!(
|
||||
raw == input.original.bytes()?,
|
||||
"UPDATE_WINDOWS_ORIGINAL_HANDOFF"
|
||||
);
|
||||
for (i, role) in ROLES.iter().copied().enumerate() {
|
||||
let original = &input.original.files[i];
|
||||
ensure!(
|
||||
original.role == role.handoff_role()
|
||||
&& original.old_sha256 == input.originals[i].sha256
|
||||
&& original.new_sha256 == input.staged[i].sha256
|
||||
&& input.originals[i].identity.volume_serial
|
||||
== input.staged[i].identity.volume_serial
|
||||
&& input.originals[i].identity != input.staged[i].identity
|
||||
&& input.originals[i].security_sha256 == input.staged[i].security_sha256
|
||||
&& files::observe_bound(
|
||||
role,
|
||||
input.original.owner_nonce,
|
||||
Location::Target,
|
||||
input.budget
|
||||
)? == input.originals[i]
|
||||
&& files::observe_bound(
|
||||
role,
|
||||
input.original.owner_nonce,
|
||||
Location::Stage,
|
||||
input.budget
|
||||
)? == input.staged[i],
|
||||
"UPDATE_WINDOWS_SWAP_FILES"
|
||||
);
|
||||
}
|
||||
Ok(Self {
|
||||
db: input.db,
|
||||
guard: input.guard,
|
||||
clock: input.clock,
|
||||
budget: input.budget,
|
||||
original: input.original.clone(),
|
||||
originals: input.originals,
|
||||
staged: input.staged,
|
||||
pending: None,
|
||||
next: 0,
|
||||
saved: false,
|
||||
poisoned: false,
|
||||
})
|
||||
}
|
||||
fn append(&mut self, evidence: Evidence) -> Result<()> {
|
||||
self.budget.check()?;
|
||||
let grant = self.original.attempt.grant_id;
|
||||
let journal = core::read(self.db, self.guard, grant)?;
|
||||
let now = self.clock.reading()?.upper;
|
||||
ensure!(
|
||||
u64::try_from(now.timestamp())? < self.original.finish_before,
|
||||
"UPDATE_WINDOWS_DEADLINE"
|
||||
);
|
||||
let bytes = journal.prepare(u64::try_from(now.timestamp())?, evidence)?;
|
||||
core::append(self.db, self.guard, grant, journal.head_sha256(), &bytes)
|
||||
}
|
||||
pub fn finish(mut self) -> Result<()> {
|
||||
ensure!(
|
||||
!self.poisoned && self.pending.is_none() && self.next == ROLES.len() && !self.saved,
|
||||
"UPDATE_WINDOWS_FENCE_INCOMPLETE"
|
||||
);
|
||||
for (i, role) in ROLES.iter().copied().enumerate() {
|
||||
ensure!(
|
||||
files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
Location::Target,
|
||||
self.budget
|
||||
)? == self.staged[i]
|
||||
&& files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
Location::Previous,
|
||||
self.budget
|
||||
)? == self.originals[i],
|
||||
"UPDATE_WINDOWS_FINAL_PAIR_CHANGED"
|
||||
);
|
||||
}
|
||||
self.append(Evidence::PairVerified {
|
||||
pair: self.original.target.clone(),
|
||||
retained_state_sha256: self.original.retained_state_sha256.clone(),
|
||||
})
|
||||
}
|
||||
}
|
||||
impl<G: UpdateParticipantGuard, C: SyncClock> DurableEffectFence for LedgerFence<'_, '_, G, C> {
|
||||
fn before_effect(&mut self, effect: &Effect) -> Result<()> {
|
||||
ensure!(
|
||||
!self.poisoned && self.pending.is_none() && self.next < ROLES.len(),
|
||||
"UPDATE_WINDOWS_FENCE_REENTRY"
|
||||
);
|
||||
self.poisoned = true;
|
||||
self.budget.check()?;
|
||||
let role = ROLES[self.next];
|
||||
let native = match *effect {
|
||||
Effect::SavePredecessor { role: r } if r == role && !self.saved => {
|
||||
ensure!(
|
||||
files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
Location::Target,
|
||||
self.budget
|
||||
)? == self.originals[self.next]
|
||||
&& files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
Location::Stage,
|
||||
self.budget
|
||||
)? == self.staged[self.next],
|
||||
"UPDATE_WINDOWS_FILES_CHANGED"
|
||||
);
|
||||
self.append(Evidence::ReplaceIntent {
|
||||
role: role.handoff_role(),
|
||||
})?;
|
||||
NativeEffect::SavePredecessor { role: native(role) }
|
||||
}
|
||||
Effect::PublishReplacement { role: r } if r == role && self.saved => {
|
||||
ensure!(
|
||||
files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
Location::Previous,
|
||||
self.budget
|
||||
)? == self.originals[self.next]
|
||||
&& files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
Location::Stage,
|
||||
self.budget
|
||||
)? == self.staged[self.next],
|
||||
"UPDATE_WINDOWS_FILES_CHANGED"
|
||||
);
|
||||
NativeEffect::PublishReplacement { role: native(role) }
|
||||
}
|
||||
_ => anyhow::bail!("UPDATE_WINDOWS_SWAP_FENCE_SCOPE"),
|
||||
};
|
||||
let journal = core::read(self.db, self.guard, self.original.attempt.grant_id)?;
|
||||
let claim = core::claim_native_effect(
|
||||
self.db,
|
||||
self.guard,
|
||||
self.original.attempt.grant_id,
|
||||
journal.head_sha256(),
|
||||
&native,
|
||||
self.clock.reading()?.upper,
|
||||
)?;
|
||||
self.pending = Some((effect.clone(), claim));
|
||||
Ok(())
|
||||
}
|
||||
fn after_effect(&mut self, effect: &Effect, observation: &str) -> Result<()> {
|
||||
let (expected, claim) = self
|
||||
.pending
|
||||
.take()
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_WINDOWS_EFFECT_NOT_CLAIMED"))?;
|
||||
ensure!(
|
||||
self.poisoned && *effect == expected,
|
||||
"UPDATE_WINDOWS_EFFECT_CALLBACK_CHANGED"
|
||||
);
|
||||
self.budget.check()?;
|
||||
let role = ROLES[self.next];
|
||||
let replaced = matches!(effect, Effect::PublishReplacement { .. });
|
||||
let proof = files::observe_bound(
|
||||
role,
|
||||
self.original.owner_nonce,
|
||||
if replaced {
|
||||
Location::Target
|
||||
} else {
|
||||
Location::Previous
|
||||
},
|
||||
self.budget,
|
||||
)?;
|
||||
ensure!(
|
||||
proof
|
||||
== if replaced {
|
||||
self.staged[self.next].clone()
|
||||
} else {
|
||||
self.originals[self.next].clone()
|
||||
}
|
||||
&& digest(&serde_json::to_vec(&proof)?) == observation,
|
||||
"UPDATE_WINDOWS_EFFECT_READBACK_CHANGED"
|
||||
);
|
||||
core::observe_native_effect(
|
||||
self.db,
|
||||
self.guard,
|
||||
&claim,
|
||||
observation,
|
||||
self.clock.reading()?.upper,
|
||||
)?;
|
||||
if replaced {
|
||||
self.append(Evidence::Replaced {
|
||||
role: role.handoff_role(),
|
||||
observed_sha256: proof.sha256,
|
||||
})?;
|
||||
self.next += 1;
|
||||
self.saved = false;
|
||||
} else {
|
||||
self.saved = true;
|
||||
}
|
||||
self.poisoned = false;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,576 @@
|
||||
//! Fixed-file, same-volume native staging and one-step-at-a-time publication.
|
||||
//! No archive extraction, free target path, overwrite, replacement of journals,
|
||||
//! or implicit retry/rollback. A failed rename/readback is an uncertain effect.
|
||||
use super::{Budget, DurableEffectFence, Effect, Role, digest, valid_digest};
|
||||
use crate::{
|
||||
helper_ipc::{self as ipc, FileIdentity, PinnedFile},
|
||||
job_binding,
|
||||
};
|
||||
use anyhow::{Context, Result, ensure};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{Read, Seek, SeekFrom, Write},
|
||||
mem::{offset_of, size_of, zeroed},
|
||||
os::windows::{
|
||||
ffi::OsStrExt,
|
||||
io::{AsRawHandle, FromRawHandle},
|
||||
},
|
||||
path::{Path, PathBuf},
|
||||
ptr,
|
||||
};
|
||||
use uuid::Uuid;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{INVALID_HANDLE_VALUE, LocalFree},
|
||||
Security::{
|
||||
self,
|
||||
Authorization::{GetSecurityInfo, SE_FILE_OBJECT},
|
||||
SECURITY_ATTRIBUTES,
|
||||
},
|
||||
Storage::FileSystem::*,
|
||||
};
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Proof {
|
||||
pub identity: FileIdentity,
|
||||
pub bytes: u64,
|
||||
pub sha256: String,
|
||||
pub security_sha256: String,
|
||||
}
|
||||
/// All ancestors remain open without DELETE sharing. The protected immediate
|
||||
/// directory also remains pinned by file identity/owner/DACL throughout effects.
|
||||
struct Directory {
|
||||
root: PinnedFile,
|
||||
ancestors: Vec<File>,
|
||||
}
|
||||
fn regular(file: &File, directory: bool) -> Result<()> {
|
||||
let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { zeroed() };
|
||||
ensure!(
|
||||
unsafe { GetFileInformationByHandle(file.as_raw_handle(), &mut info) } != 0
|
||||
&& info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0
|
||||
&& (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY != 0) == directory
|
||||
&& (directory || info.nNumberOfLinks == 1),
|
||||
"UPDATE_NONREGULAR_FILE"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
fn open(
|
||||
path: &Path,
|
||||
desired: u32,
|
||||
creation: u32,
|
||||
security: *const SECURITY_ATTRIBUTES,
|
||||
) -> Result<File> {
|
||||
let handle = unsafe {
|
||||
CreateFileW(
|
||||
ipc::wide(path).as_ptr(),
|
||||
desired,
|
||||
FILE_SHARE_READ,
|
||||
security,
|
||||
creation,
|
||||
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH,
|
||||
ptr::null_mut(),
|
||||
)
|
||||
};
|
||||
ensure!(
|
||||
handle != INVALID_HANDLE_VALUE,
|
||||
"UPDATE_NATIVE_FILE_OPEN: {}",
|
||||
std::io::Error::last_os_error()
|
||||
);
|
||||
let file = unsafe { File::from_raw_handle(handle) };
|
||||
regular(&file, false)?;
|
||||
Ok(file)
|
||||
}
|
||||
impl Directory {
|
||||
fn open(role: Role) -> Result<Self> {
|
||||
let path = Path::new(role.target())
|
||||
.parent()
|
||||
.context("UPDATE_TARGET_DIRECTORY")?;
|
||||
let readers = vec![
|
||||
ipc::service_sid(crate::SERVICE_NAME)?,
|
||||
ipc::service_sid(ipc::HELPER_SERVICE)?,
|
||||
];
|
||||
let root = PinnedFile::open_read_shared(path, true, &readers, &[])?;
|
||||
let mut ancestors = Vec::new();
|
||||
for ancestor in path.ancestors().skip(1) {
|
||||
let raw = unsafe {
|
||||
CreateFileW(
|
||||
ipc::wide(ancestor).as_ptr(),
|
||||
FILE_READ_ATTRIBUTES,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||||
ptr::null(),
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
|
||||
ptr::null_mut(),
|
||||
)
|
||||
};
|
||||
ensure!(raw != INVALID_HANDLE_VALUE, "UPDATE_ANCESTOR_OPEN");
|
||||
let file = unsafe { File::from_raw_handle(raw) };
|
||||
regular(&file, true)?;
|
||||
ancestors.push(file);
|
||||
}
|
||||
Ok(Self { root, ancestors })
|
||||
}
|
||||
fn check(&mut self) -> Result<()> {
|
||||
self.root.check()?;
|
||||
for ancestor in &self.ancestors {
|
||||
regular(ancestor, true)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn child(&self, name: &str) -> PathBuf {
|
||||
self.root.path.join(name)
|
||||
}
|
||||
}
|
||||
struct SecurityDescriptor(*mut core::ffi::c_void);
|
||||
impl Drop for SecurityDescriptor {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
LocalFree(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
impl SecurityDescriptor {
|
||||
fn read(file: &File) -> Result<Self> {
|
||||
let mut descriptor = ptr::null_mut();
|
||||
ensure!(
|
||||
unsafe {
|
||||
GetSecurityInfo(
|
||||
file.as_raw_handle(),
|
||||
SE_FILE_OBJECT,
|
||||
Security::OWNER_SECURITY_INFORMATION
|
||||
| Security::GROUP_SECURITY_INFORMATION
|
||||
| Security::DACL_SECURITY_INFORMATION,
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
&mut descriptor,
|
||||
)
|
||||
} == 0
|
||||
&& !descriptor.is_null(),
|
||||
"UPDATE_FILE_SECURITY"
|
||||
);
|
||||
Ok(Self(descriptor))
|
||||
}
|
||||
fn hash(&self) -> Result<String> {
|
||||
let mut owner = ptr::null_mut();
|
||||
let mut group = ptr::null_mut();
|
||||
let mut defaulted = 0;
|
||||
let mut present = 0;
|
||||
let mut acl = ptr::null_mut();
|
||||
let mut control = 0;
|
||||
let mut revision = 0;
|
||||
ensure!(
|
||||
unsafe {
|
||||
Security::GetSecurityDescriptorOwner(self.0, &mut owner, &mut defaulted) != 0
|
||||
&& Security::GetSecurityDescriptorGroup(self.0, &mut group, &mut defaulted) != 0
|
||||
&& Security::GetSecurityDescriptorDacl(
|
||||
self.0,
|
||||
&mut present,
|
||||
&mut acl,
|
||||
&mut defaulted,
|
||||
) != 0
|
||||
&& Security::GetSecurityDescriptorControl(self.0, &mut control, &mut revision)
|
||||
!= 0
|
||||
} && !owner.is_null()
|
||||
&& !group.is_null()
|
||||
&& present != 0
|
||||
&& !acl.is_null(),
|
||||
"UPDATE_FILE_SECURITY_PARTS"
|
||||
);
|
||||
// Only actual owner, group, ACL bytes and inheritance protection are
|
||||
// hashed. Windows may clear the informational AUTO_INHERITED bit when
|
||||
// creating an explicitly protected object; that bit grants no rights.
|
||||
let mut bytes = Vec::new();
|
||||
for sid in [owner, group] {
|
||||
let len = unsafe { Security::GetLengthSid(sid) };
|
||||
ensure!((8..=256).contains(&len), "UPDATE_SECURITY_SID_SIZE");
|
||||
bytes.extend_from_slice(&len.to_le_bytes());
|
||||
bytes.extend_from_slice(unsafe {
|
||||
std::slice::from_raw_parts(sid.cast::<u8>(), len as usize)
|
||||
});
|
||||
}
|
||||
let len = unsafe { (*acl).AclSize };
|
||||
ensure!(
|
||||
(size_of::<Security::ACL>() as u16..=32768).contains(&len),
|
||||
"UPDATE_SECURITY_ACL_SIZE"
|
||||
);
|
||||
bytes.extend_from_slice(&(control & Security::SE_DACL_PROTECTED).to_le_bytes());
|
||||
bytes.extend_from_slice(unsafe {
|
||||
std::slice::from_raw_parts(acl.cast::<u8>(), len as usize)
|
||||
});
|
||||
Ok(digest(&bytes))
|
||||
}
|
||||
fn attributes(&self) -> SECURITY_ATTRIBUTES {
|
||||
SECURITY_ATTRIBUTES {
|
||||
nLength: size_of::<SECURITY_ATTRIBUTES>() as u32,
|
||||
lpSecurityDescriptor: self.0,
|
||||
bInheritHandle: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
fn hash_file(file: &mut File, max: u64) -> Result<String> {
|
||||
ensure!((1..=256 * 1024 * 1024).contains(&max), "UPDATE_FILE_LIMIT");
|
||||
file.seek(SeekFrom::Start(0))?;
|
||||
let mut hash = Sha256::new();
|
||||
let mut count = 0u64;
|
||||
let mut buf = [0u8; 65536];
|
||||
loop {
|
||||
let read = file.read(&mut buf)?;
|
||||
if read == 0 {
|
||||
break;
|
||||
}
|
||||
count = count
|
||||
.checked_add(read as u64)
|
||||
.context("UPDATE_FILE_LIMIT")?;
|
||||
ensure!(count <= max, "UPDATE_FILE_LIMIT");
|
||||
hash.update(&buf[..read]);
|
||||
}
|
||||
Ok(format!("{:x}", hash.finalize()))
|
||||
}
|
||||
fn proof(file: &mut File, path: &Path, max: u64) -> Result<Proof> {
|
||||
regular(file, false)?;
|
||||
job_binding::check_admin_readonly(path)?;
|
||||
let identity = ipc::file_identity(file)?;
|
||||
let bytes = file.metadata()?.len();
|
||||
ensure!(bytes > 0 && bytes <= max, "UPDATE_FILE_SIZE");
|
||||
let security_sha256 = SecurityDescriptor::read(file)?.hash()?;
|
||||
let sha256 = hash_file(file, max)?;
|
||||
regular(file, false)?;
|
||||
ensure!(
|
||||
ipc::file_identity(file)? == identity
|
||||
&& file.metadata()?.len() == bytes
|
||||
&& SecurityDescriptor::read(file)?.hash()? == security_sha256,
|
||||
"UPDATE_FILE_CHANGED_DURING_READ"
|
||||
);
|
||||
let named = unsafe {
|
||||
CreateFileW(
|
||||
ipc::wide(path).as_ptr(),
|
||||
FILE_READ_ATTRIBUTES,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||||
ptr::null(),
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAG_OPEN_REPARSE_POINT,
|
||||
ptr::null_mut(),
|
||||
)
|
||||
};
|
||||
ensure!(named != INVALID_HANDLE_VALUE, "UPDATE_FILE_NAME_READBACK");
|
||||
let named = unsafe { File::from_raw_handle(named) };
|
||||
regular(&named, false)?;
|
||||
ensure!(
|
||||
ipc::file_identity(&named)? == identity,
|
||||
"UPDATE_FILE_NAME_REPLACED"
|
||||
);
|
||||
Ok(Proof {
|
||||
identity,
|
||||
bytes,
|
||||
sha256,
|
||||
security_sha256,
|
||||
})
|
||||
}
|
||||
/// Read-only predecessor capture while the original services may still run.
|
||||
/// This is an observation, not an authenticated InstalledRecord or baseline.
|
||||
pub fn observe(role: Role, budget: &Budget<'_>) -> Result<Proof> {
|
||||
budget.check()?;
|
||||
let mut directory = Directory::open(role)?;
|
||||
let mut file = open(
|
||||
Path::new(role.target()),
|
||||
FILE_GENERIC_READ,
|
||||
OPEN_EXISTING,
|
||||
ptr::null(),
|
||||
)?;
|
||||
let value = proof(&mut file, Path::new(role.target()), role.max_bytes())?;
|
||||
directory.check()?;
|
||||
budget.check()?;
|
||||
Ok(value)
|
||||
}
|
||||
#[derive(Clone, Copy)]
|
||||
pub(crate) enum Location {
|
||||
Target,
|
||||
Stage,
|
||||
Previous,
|
||||
}
|
||||
/// Independent readback while the actual swap retains DELETE/write handles.
|
||||
/// Opening this read-only observer grants no write/delete access or authority.
|
||||
pub(crate) fn observe_bound(
|
||||
role: Role,
|
||||
nonce: Uuid,
|
||||
location: Location,
|
||||
budget: &Budget<'_>,
|
||||
) -> Result<Proof> {
|
||||
ensure!(!nonce.is_nil(), "UPDATE_READBACK_NONCE");
|
||||
budget.check()?;
|
||||
let mut directory = Directory::open(role)?;
|
||||
let path = match location {
|
||||
Location::Target => PathBuf::from(role.target()),
|
||||
Location::Stage => directory.child(&format!(".rmm-update-{nonce}-{}.stage", role.label())),
|
||||
Location::Previous => {
|
||||
directory.child(&format!(".rmm-update-{nonce}-{}.previous", role.label()))
|
||||
}
|
||||
};
|
||||
let raw = unsafe {
|
||||
CreateFileW(
|
||||
ipc::wide(&path).as_ptr(),
|
||||
FILE_GENERIC_READ,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
||||
ptr::null(),
|
||||
OPEN_EXISTING,
|
||||
FILE_FLAG_OPEN_REPARSE_POINT,
|
||||
ptr::null_mut(),
|
||||
)
|
||||
};
|
||||
ensure!(raw != INVALID_HANDLE_VALUE, "UPDATE_READBACK_OPEN");
|
||||
let mut file = unsafe { File::from_raw_handle(raw) };
|
||||
let result = proof(&mut file, &path, role.max_bytes())?;
|
||||
directory.check()?;
|
||||
budget.check()?;
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
pub struct StageDescriptor<'a> {
|
||||
pub role: Role,
|
||||
pub owner_nonce: Uuid,
|
||||
pub original: &'a Proof,
|
||||
pub replacement_sha256: &'a str,
|
||||
pub replacement_bytes: u64,
|
||||
}
|
||||
pub struct Staged {
|
||||
role: Role,
|
||||
nonce: Uuid,
|
||||
directory: Directory,
|
||||
path: PathBuf,
|
||||
file: File,
|
||||
original: Proof,
|
||||
staged: Proof,
|
||||
}
|
||||
impl Staged {
|
||||
/// Source is a bounded stream of already independently release-verified
|
||||
/// artifact bytes. No URL or caller-chosen destination is accepted. Both
|
||||
/// code files MUST be fully staged before original activation consumption.
|
||||
pub fn create(
|
||||
descriptor: StageDescriptor<'_>,
|
||||
source: &mut impl Read,
|
||||
budget: &Budget<'_>,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Self> {
|
||||
let StageDescriptor {
|
||||
role,
|
||||
owner_nonce: nonce,
|
||||
original,
|
||||
replacement_sha256,
|
||||
replacement_bytes,
|
||||
} = descriptor;
|
||||
ensure!(
|
||||
!nonce.is_nil()
|
||||
&& valid_digest(&original.sha256)
|
||||
&& valid_digest(replacement_sha256)
|
||||
&& replacement_bytes > 0
|
||||
&& replacement_bytes <= role.max_bytes(),
|
||||
"UPDATE_STAGE_DESCRIPTOR"
|
||||
);
|
||||
budget.check()?;
|
||||
let mut directory = Directory::open(role)?;
|
||||
let mut predecessor = open(
|
||||
Path::new(role.target()),
|
||||
FILE_GENERIC_READ,
|
||||
OPEN_EXISTING,
|
||||
ptr::null(),
|
||||
)?;
|
||||
ensure!(
|
||||
proof(&mut predecessor, Path::new(role.target()), role.max_bytes())? == *original,
|
||||
"UPDATE_PREDECESSOR_CHANGED"
|
||||
);
|
||||
let security = SecurityDescriptor::read(&predecessor)?;
|
||||
let attributes = security.attributes();
|
||||
let path = directory.child(&format!(".rmm-update-{nonce}-{}.stage", role.label()));
|
||||
let effect = Effect::StageFile { role };
|
||||
fence.before_effect(&effect)?;
|
||||
budget.check()?;
|
||||
directory.check()?;
|
||||
let mut file = open(
|
||||
&path,
|
||||
FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE,
|
||||
CREATE_NEW,
|
||||
&attributes,
|
||||
)?;
|
||||
let mut total = 0u64;
|
||||
let mut buffer = [0u8; 65536];
|
||||
loop {
|
||||
budget.check()?;
|
||||
let read = source.read(&mut buffer)?;
|
||||
if read == 0 {
|
||||
break;
|
||||
}
|
||||
total = total
|
||||
.checked_add(read as u64)
|
||||
.context("UPDATE_STAGE_LENGTH")?;
|
||||
ensure!(total <= replacement_bytes, "UPDATE_STAGE_EXTRA_BYTES");
|
||||
file.write_all(&buffer[..read])?;
|
||||
}
|
||||
ensure!(total == replacement_bytes, "UPDATE_STAGE_TRUNCATED");
|
||||
file.sync_all()?;
|
||||
let staged = proof(&mut file, &path, role.max_bytes())?;
|
||||
ensure!(
|
||||
staged.bytes == replacement_bytes
|
||||
&& staged.sha256 == replacement_sha256
|
||||
&& staged.identity != original.identity
|
||||
&& staged.identity.volume_serial == original.identity.volume_serial
|
||||
&& staged.security_sha256 == original.security_sha256,
|
||||
"UPDATE_STAGE_VERIFICATION"
|
||||
);
|
||||
directory.check()?;
|
||||
budget.check()?;
|
||||
fence.after_effect(&effect, &digest(&serde_json::to_vec(&staged)?))?;
|
||||
Ok(Self {
|
||||
role,
|
||||
nonce,
|
||||
directory,
|
||||
path,
|
||||
file,
|
||||
original: original.clone(),
|
||||
staged,
|
||||
})
|
||||
}
|
||||
pub fn original(&self) -> &Proof {
|
||||
&self.original
|
||||
}
|
||||
pub fn staged(&self) -> &Proof {
|
||||
&self.staged
|
||||
}
|
||||
/// Publication consists of TWO separately fenced native renames. This is
|
||||
/// explicitly not an atomic pair swap. Any missing reply/readback requires
|
||||
/// retained-namespace adjudication, never automatic re-entry/replacement.
|
||||
pub fn publish(
|
||||
mut self,
|
||||
stopped: &super::services::Stopped,
|
||||
budget: &Budget<'_>,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Published> {
|
||||
stopped.check(budget)?;
|
||||
self.directory.check()?;
|
||||
ensure!(
|
||||
proof(&mut self.file, &self.path, self.role.max_bytes())? == self.staged,
|
||||
"UPDATE_STAGED_FILE_CHANGED"
|
||||
);
|
||||
let target = Path::new(self.role.target());
|
||||
let mut original = open(
|
||||
target,
|
||||
FILE_GENERIC_READ | FILE_GENERIC_WRITE | DELETE,
|
||||
OPEN_EXISTING,
|
||||
ptr::null(),
|
||||
)?;
|
||||
ensure!(
|
||||
proof(&mut original, target, self.role.max_bytes())? == self.original,
|
||||
"UPDATE_PREDECESSOR_CHANGED"
|
||||
);
|
||||
let previous = self.directory.child(&format!(
|
||||
".rmm-update-{}-{}.previous",
|
||||
self.nonce,
|
||||
self.role.label()
|
||||
));
|
||||
let save = Effect::SavePredecessor { role: self.role };
|
||||
fence.before_effect(&save)?;
|
||||
budget.check()?;
|
||||
stopped.check(budget)?;
|
||||
self.directory.check()?;
|
||||
rename_new(&original, &previous)?;
|
||||
let saved = proof(&mut original, &previous, self.role.max_bytes())?;
|
||||
ensure!(saved == self.original, "UPDATE_SAVED_PREDECESSOR_CHANGED");
|
||||
fence.after_effect(&save, &digest(&serde_json::to_vec(&saved)?))?;
|
||||
let publish = Effect::PublishReplacement { role: self.role };
|
||||
fence.before_effect(&publish)?;
|
||||
budget.check()?;
|
||||
stopped.check(budget)?;
|
||||
self.directory.check()?;
|
||||
rename_new(&self.file, target)?;
|
||||
let published = proof(&mut self.file, target, self.role.max_bytes())?;
|
||||
ensure!(published == self.staged, "UPDATE_PUBLISHED_FILE_CHANGED");
|
||||
fence.after_effect(&publish, &digest(&serde_json::to_vec(&published)?))?;
|
||||
Ok(Published {
|
||||
role: self.role,
|
||||
directory: self.directory,
|
||||
original,
|
||||
predecessor: previous,
|
||||
original_proof: saved,
|
||||
replacement: self.file,
|
||||
replacement_proof: published,
|
||||
})
|
||||
}
|
||||
}
|
||||
fn rename_new(file: &File, target: &Path) -> Result<()> {
|
||||
let name: Vec<u16> = target.as_os_str().encode_wide().collect();
|
||||
ensure!(
|
||||
target.is_absolute() && name.len() <= 32767 && !name.contains(&0),
|
||||
"UPDATE_RENAME_TARGET"
|
||||
);
|
||||
let length = offset_of!(FILE_RENAME_INFO, FileName) + name.len() * 2;
|
||||
let mut bytes = vec![0usize; length.div_ceil(size_of::<usize>())];
|
||||
let info = bytes.as_mut_ptr().cast::<FILE_RENAME_INFO>();
|
||||
// SAFETY: aligned, zeroed buffer with exact capacity for the fixed header
|
||||
// and full UTF16 name. The native call is handle-relative to the already
|
||||
// held SOURCE; ReplaceIfExists=false refuses files, links or a raced target.
|
||||
unsafe {
|
||||
(*info).Anonymous.ReplaceIfExists = false;
|
||||
(*info).RootDirectory = ptr::null_mut();
|
||||
(*info).FileNameLength = (name.len() * 2) as u32;
|
||||
ptr::copy_nonoverlapping(
|
||||
name.as_ptr(),
|
||||
ptr::addr_of_mut!((*info).FileName).cast::<u16>(),
|
||||
name.len(),
|
||||
);
|
||||
}
|
||||
ensure!(
|
||||
unsafe {
|
||||
SetFileInformationByHandle(
|
||||
file.as_raw_handle(),
|
||||
FileRenameInfo,
|
||||
info.cast(),
|
||||
length as u32,
|
||||
)
|
||||
} != 0,
|
||||
"UPDATE_RENAME_UNCERTAIN: {}",
|
||||
std::io::Error::last_os_error()
|
||||
);
|
||||
// Flush the held write-through file after the rename; a power loss or
|
||||
// failed metadata observation still remains uncertain in the durable ledger.
|
||||
file.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
pub struct Published {
|
||||
role: Role,
|
||||
directory: Directory,
|
||||
original: File,
|
||||
predecessor: PathBuf,
|
||||
original_proof: Proof,
|
||||
replacement: File,
|
||||
replacement_proof: Proof,
|
||||
}
|
||||
impl Published {
|
||||
pub fn proof(&self) -> &Proof {
|
||||
&self.replacement_proof
|
||||
}
|
||||
pub fn verify(&mut self, budget: &Budget<'_>) -> Result<()> {
|
||||
budget.check()?;
|
||||
self.directory.check()?;
|
||||
ensure!(
|
||||
proof(&mut self.original, &self.predecessor, self.role.max_bytes())?
|
||||
== self.original_proof
|
||||
&& proof(
|
||||
&mut self.replacement,
|
||||
Path::new(self.role.target()),
|
||||
self.role.max_bytes()
|
||||
)? == self.replacement_proof,
|
||||
"UPDATE_PUBLISHED_PAIR_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
/// Close replacement/delete handles before SCM startup. The caller retains
|
||||
/// the proofs and must independently reopen/recheck them during Health.
|
||||
/// No predecessor is removed; this module contains no cleanup primitive.
|
||||
pub fn release(mut self, budget: &Budget<'_>) -> Result<(Proof, Proof)> {
|
||||
self.verify(budget)?;
|
||||
Ok((self.original_proof, self.replacement_proof))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
//! Native Windows primitives for the separately provisioned stable updater.
|
||||
//!
|
||||
//! This module neither approves an update nor activates a worker. The caller
|
||||
//! authenticates the approved original admission and (after staging) consumed
|
||||
//! handoff, owns the existing ledger guard, and supplies a durable effect fence.
|
||||
//! No default/permissive fence, resume,
|
||||
//! reset, shell, reboot, or arbitrary service/path operation is provided.
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_agent_core::helper_reconcile::BootSource;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::time::{Duration, Instant};
|
||||
use uuid::Uuid;
|
||||
|
||||
#[cfg(windows)]
|
||||
pub mod fence;
|
||||
#[cfg(windows)]
|
||||
pub mod files;
|
||||
#[cfg(windows)]
|
||||
pub mod services;
|
||||
pub mod transition;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum Service {
|
||||
Agent,
|
||||
Helper,
|
||||
}
|
||||
impl Service {
|
||||
pub fn name(self) -> &'static str {
|
||||
match self {
|
||||
Self::Agent => "RmmDiscoveryWindows",
|
||||
Self::Helper => "RmmDiscoverySystemHelper",
|
||||
}
|
||||
}
|
||||
pub fn handoff_service(self) -> rmm_updater_handoff::Service {
|
||||
match self {
|
||||
Self::Agent => rmm_updater_handoff::Service::WindowsAgent,
|
||||
Self::Helper => rmm_updater_handoff::Service::WindowsHelper,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub enum Role {
|
||||
Agent,
|
||||
Helper,
|
||||
Settings,
|
||||
Pin,
|
||||
TimeProfile,
|
||||
}
|
||||
impl Role {
|
||||
pub fn target(self) -> &'static str {
|
||||
match self {
|
||||
Self::Agent => r"C:\Program Files\RustDiscovery\rmm-agent-windows.exe",
|
||||
Self::Helper => r"C:\Program Files\RustDiscovery\rmm-helper-windows.exe",
|
||||
Self::Settings => r"C:\ProgramData\RustDiscoverySystem\helper.json",
|
||||
Self::Pin => r"C:\ProgramData\RustDiscoverySystem\agent-pin.json",
|
||||
Self::TimeProfile => r"C:\ProgramData\RustDiscoverySystem\time-attestation.json",
|
||||
}
|
||||
}
|
||||
pub fn handoff_role(self) -> rmm_updater_handoff::FileRole {
|
||||
match self {
|
||||
Self::Agent => rmm_updater_handoff::FileRole::AgentBinary,
|
||||
Self::Helper => rmm_updater_handoff::FileRole::HelperBinary,
|
||||
Self::Settings => rmm_updater_handoff::FileRole::WindowsSettings,
|
||||
Self::Pin => rmm_updater_handoff::FileRole::WindowsPin,
|
||||
Self::TimeProfile => rmm_updater_handoff::FileRole::WindowsTimeProfile,
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
fn label(self) -> &'static str {
|
||||
match self {
|
||||
Self::Agent => "agent",
|
||||
Self::Helper => "helper",
|
||||
Self::Settings => "settings",
|
||||
Self::Pin => "pin",
|
||||
Self::TimeProfile => "time-profile",
|
||||
}
|
||||
}
|
||||
pub fn max_bytes(self) -> u64 {
|
||||
match self {
|
||||
Self::Agent | Self::Helper => 256 * 1024 * 1024,
|
||||
Self::Settings | Self::Pin | Self::TimeProfile => 64 * 1024,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The embedding worker must additionally check its original trusted-clock
|
||||
/// interval and signed deadline at each effect. This budget cannot extend it.
|
||||
pub struct Budget<'a> {
|
||||
boot: &'a dyn BootSource,
|
||||
boot_id: Uuid,
|
||||
until: Instant,
|
||||
}
|
||||
impl<'a> Budget<'a> {
|
||||
pub fn new(boot: &'a dyn BootSource, expected: Uuid, remaining: Duration) -> Result<Self> {
|
||||
ensure!(
|
||||
!expected.is_nil() && !remaining.is_zero() && remaining <= Duration::from_secs(600),
|
||||
"UPDATE_BUDGET"
|
||||
);
|
||||
let value = Self {
|
||||
boot,
|
||||
boot_id: expected,
|
||||
until: Instant::now()
|
||||
.checked_add(remaining)
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_BUDGET"))?,
|
||||
};
|
||||
value.check()?;
|
||||
Ok(value)
|
||||
}
|
||||
pub fn check(&self) -> Result<()> {
|
||||
ensure!(Instant::now() < self.until, "UPDATE_DEADLINE");
|
||||
ensure!(
|
||||
self.boot.current_boot()? == self.boot_id,
|
||||
"UPDATE_BOOT_CHANGED"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(tag = "effect", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum Effect {
|
||||
StopService { service: Service },
|
||||
StageFile { role: Role },
|
||||
SavePredecessor { role: Role },
|
||||
PublishReplacement { role: Role },
|
||||
RestorePredecessor { role: Role },
|
||||
StartService { service: Service },
|
||||
}
|
||||
|
||||
/// Implementations MUST independently check the original approved admission
|
||||
/// for StageFile; every later effect additionally needs the consumed original
|
||||
/// handoff. Retained owner/process/boot/clock/ledger witnesses and a COMMITTED
|
||||
/// create-once intent are required. Observation failure never allows a retry.
|
||||
pub trait DurableEffectFence {
|
||||
fn before_effect(&mut self, effect: &Effect) -> Result<()>;
|
||||
fn after_effect(&mut self, effect: &Effect, observation_sha256: &str) -> Result<()>;
|
||||
}
|
||||
fn valid_digest(value: &str) -> bool {
|
||||
value.len() == 64
|
||||
&& value
|
||||
.bytes()
|
||||
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
|
||||
}
|
||||
#[cfg(windows)]
|
||||
fn digest(bytes: &[u8]) -> String {
|
||||
use sha2::{Digest, Sha256};
|
||||
Sha256::digest(bytes)
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
struct Boot(AtomicBool, Uuid);
|
||||
impl BootSource for Boot {
|
||||
fn current_boot(&self) -> Result<Uuid> {
|
||||
Ok(if self.0.load(Ordering::SeqCst) {
|
||||
Uuid::nil()
|
||||
} else {
|
||||
self.1
|
||||
})
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn budget_is_original_boot_bound_and_never_has_an_unbounded_window() {
|
||||
let boot = Boot(AtomicBool::new(false), Uuid::new_v4());
|
||||
assert!(Budget::new(&boot, boot.1, Duration::ZERO).is_err());
|
||||
assert!(Budget::new(&boot, boot.1, Duration::from_secs(601)).is_err());
|
||||
assert!(Budget::new(&boot, Uuid::nil(), Duration::from_secs(1)).is_err());
|
||||
let bound = Budget::new(&boot, boot.1, Duration::from_secs(1)).unwrap();
|
||||
bound.check().unwrap();
|
||||
boot.0.store(true, Ordering::SeqCst);
|
||||
assert!(bound.check().is_err());
|
||||
}
|
||||
#[test]
|
||||
fn windows_roles_are_closed_and_effects_reject_unknown_fields() {
|
||||
assert_eq!(Service::Agent.name(), crate::SERVICE_NAME);
|
||||
assert_eq!(
|
||||
Role::Pin.handoff_role(),
|
||||
rmm_updater_handoff::FileRole::WindowsPin
|
||||
);
|
||||
for raw in [
|
||||
r#"{"effect":"stop_service","service":"updater"}"#,
|
||||
r#"{"effect":"publish_replacement","role":"arbitrary"}"#,
|
||||
r#"{"effect":"stop_service","service":"helper","command":"extra"}"#,
|
||||
] {
|
||||
assert!(serde_json::from_str::<Effect>(raw).is_err());
|
||||
}
|
||||
assert!(valid_digest(&"ab".repeat(32)));
|
||||
assert!(!valid_digest(&"AB".repeat(32)));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
//! Closed native SCM stop/start with held original process witnesses.
|
||||
//! Service recovery actions, triggers and dependencies are refused rather than
|
||||
//! modified. Every native request is issued once after a durable caller intent.
|
||||
use super::{Budget, DurableEffectFence, Effect, Service, digest};
|
||||
use crate::helper_ipc::{PeerPin, PeerProof, utf16_pointer, wide};
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_updater_handoff::{Process, StartedService};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
mem::{size_of, zeroed},
|
||||
ptr, thread,
|
||||
time::Duration,
|
||||
};
|
||||
use windows_sys::Win32::System::Services::*;
|
||||
|
||||
struct Handle(SC_HANDLE);
|
||||
impl Drop for Handle {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
CloseServiceHandle(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Configuration {
|
||||
pub service: Service,
|
||||
pub command: String,
|
||||
pub account: String,
|
||||
pub start_type: u32,
|
||||
pub error_control: u32,
|
||||
pub sid_type: u32,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Proof {
|
||||
pub configuration: Configuration,
|
||||
pub process: Process,
|
||||
}
|
||||
struct HeldService {
|
||||
service: Service,
|
||||
handle: Handle,
|
||||
peer: PeerProof,
|
||||
proof: Proof,
|
||||
}
|
||||
fn handle(service: Service, rights: u32) -> Result<Handle> {
|
||||
let manager = Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
|
||||
ensure!(!manager.0.is_null(), "UPDATE_SCM_MANAGER");
|
||||
let value = Handle(unsafe { OpenServiceW(manager.0, wide(service.name()).as_ptr(), rights) });
|
||||
ensure!(!value.0.is_null(), "UPDATE_SCM_SERVICE");
|
||||
Ok(value)
|
||||
}
|
||||
fn status(handle: &Handle) -> Result<SERVICE_STATUS_PROCESS> {
|
||||
let mut value = unsafe { zeroed() };
|
||||
let mut needed = 0;
|
||||
ensure!(
|
||||
unsafe {
|
||||
QueryServiceStatusEx(
|
||||
handle.0,
|
||||
SC_STATUS_PROCESS_INFO,
|
||||
(&mut value as *mut SERVICE_STATUS_PROCESS).cast(),
|
||||
size_of::<SERVICE_STATUS_PROCESS>() as u32,
|
||||
&mut needed,
|
||||
)
|
||||
} != 0,
|
||||
"UPDATE_SCM_STATUS"
|
||||
);
|
||||
Ok(value)
|
||||
}
|
||||
fn config2(handle: &Handle, kind: u32) -> Result<Vec<usize>> {
|
||||
let mut needed = 0;
|
||||
unsafe {
|
||||
QueryServiceConfig2W(handle.0, kind, ptr::null_mut(), 0, &mut needed);
|
||||
}
|
||||
ensure!((1..=32768).contains(&needed), "UPDATE_SCM_CONFIG_SIZE");
|
||||
let mut bytes = vec![0usize; (needed as usize).div_ceil(size_of::<usize>())];
|
||||
ensure!(
|
||||
unsafe {
|
||||
QueryServiceConfig2W(
|
||||
handle.0,
|
||||
kind,
|
||||
bytes.as_mut_ptr().cast(),
|
||||
needed,
|
||||
&mut needed,
|
||||
)
|
||||
} != 0,
|
||||
"UPDATE_SCM_CONFIG"
|
||||
);
|
||||
Ok(bytes)
|
||||
}
|
||||
fn configuration(handle: &Handle, service: Service, pin: &PeerPin) -> Result<Configuration> {
|
||||
pin.validate(service == Service::Helper)?;
|
||||
let mut needed = 0;
|
||||
unsafe {
|
||||
QueryServiceConfigW(handle.0, ptr::null_mut(), 0, &mut needed);
|
||||
}
|
||||
ensure!((1..=32768).contains(&needed), "UPDATE_SCM_CONFIG_SIZE");
|
||||
let mut bytes = vec![0usize; (needed as usize).div_ceil(size_of::<usize>())];
|
||||
ensure!(
|
||||
unsafe { QueryServiceConfigW(handle.0, bytes.as_mut_ptr().cast(), needed, &mut needed) }
|
||||
!= 0,
|
||||
"UPDATE_SCM_CONFIG"
|
||||
);
|
||||
let cfg = unsafe { &*bytes.as_ptr().cast::<QUERY_SERVICE_CONFIGW>() };
|
||||
let command = unsafe { utf16_pointer(cfg.lpBinaryPathName) }?;
|
||||
let account = unsafe { utf16_pointer(cfg.lpServiceStartName) }?;
|
||||
let expected = if service == Service::Agent {
|
||||
format!(
|
||||
"\"{}\" --service --config \"C:\\ProgramData\\RustDiscovery\\config.json\"",
|
||||
pin.binary.display()
|
||||
)
|
||||
} else {
|
||||
format!("\"{}\" --service", pin.binary.display())
|
||||
};
|
||||
ensure!(
|
||||
cfg.dwServiceType == SERVICE_WIN32_OWN_PROCESS
|
||||
&& command == expected
|
||||
&& cfg.dwStartType
|
||||
== if service == Service::Agent {
|
||||
SERVICE_AUTO_START
|
||||
} else {
|
||||
SERVICE_DEMAND_START
|
||||
}
|
||||
&& (cfg.lpDependencies.is_null() || unsafe { *cfg.lpDependencies } == 0)
|
||||
&& (cfg.lpLoadOrderGroup.is_null() || unsafe { *cfg.lpLoadOrderGroup } == 0),
|
||||
"UPDATE_SCM_UNEXPECTED_CONFIGURATION"
|
||||
);
|
||||
let recovery = config2(handle, SERVICE_CONFIG_FAILURE_ACTIONS)?;
|
||||
let recovery = unsafe { &*recovery.as_ptr().cast::<SERVICE_FAILURE_ACTIONSW>() };
|
||||
ensure!(recovery.cActions == 0, "UPDATE_SCM_RECOVERY_ACTIONS");
|
||||
let triggers = config2(handle, SERVICE_CONFIG_TRIGGER_INFO)?;
|
||||
let triggers = unsafe { &*triggers.as_ptr().cast::<SERVICE_TRIGGER_INFO>() };
|
||||
ensure!(triggers.cTriggers == 0, "UPDATE_SCM_TRIGGERS");
|
||||
let sid = config2(handle, SERVICE_CONFIG_SERVICE_SID_INFO)?;
|
||||
let sid = unsafe { &*sid.as_ptr().cast::<SERVICE_SID_INFO>() };
|
||||
ensure!(
|
||||
sid.dwServiceSidType == SERVICE_SID_TYPE_UNRESTRICTED,
|
||||
"UPDATE_SCM_SERVICE_SID"
|
||||
);
|
||||
// Refuse active dependent services; stopping this pair cannot stop another
|
||||
// product or cause StartService's implicit dependency side effects.
|
||||
let mut dependent_bytes = 0;
|
||||
let mut dependent_count = 0;
|
||||
let no_dependents = unsafe {
|
||||
EnumDependentServicesW(
|
||||
handle.0,
|
||||
SERVICE_ACTIVE,
|
||||
ptr::null_mut(),
|
||||
0,
|
||||
&mut dependent_bytes,
|
||||
&mut dependent_count,
|
||||
)
|
||||
};
|
||||
ensure!(
|
||||
no_dependents != 0 && dependent_count == 0 && dependent_bytes == 0,
|
||||
"UPDATE_SCM_ACTIVE_DEPENDENTS"
|
||||
);
|
||||
Ok(Configuration {
|
||||
service,
|
||||
command,
|
||||
account,
|
||||
start_type: cfg.dwStartType,
|
||||
error_control: cfg.dwErrorControl,
|
||||
sid_type: sid.dwServiceSidType,
|
||||
})
|
||||
}
|
||||
fn observe(service: Service, pin: &PeerPin, budget: &Budget<'_>) -> Result<HeldService> {
|
||||
budget.check()?;
|
||||
let handle = handle(
|
||||
service,
|
||||
SERVICE_QUERY_STATUS
|
||||
| SERVICE_QUERY_CONFIG
|
||||
| SERVICE_ENUMERATE_DEPENDENTS
|
||||
| SERVICE_STOP
|
||||
| SERVICE_START,
|
||||
)?;
|
||||
let before = configuration(&handle, service, pin)?;
|
||||
let state = status(&handle)?;
|
||||
ensure!(
|
||||
state.dwCurrentState == SERVICE_RUNNING && state.dwProcessId > 0,
|
||||
"UPDATE_SERVICE_NOT_RUNNING"
|
||||
);
|
||||
let mut peer = PeerProof::for_service(pin, state.dwProcessId)?;
|
||||
peer.check()?;
|
||||
let id = peer.identity();
|
||||
let proof = Proof {
|
||||
configuration: before.clone(),
|
||||
process: Process {
|
||||
pid: id.pid,
|
||||
birth: id.creation_ticks,
|
||||
image_sha256: id.image_sha256.clone(),
|
||||
},
|
||||
};
|
||||
ensure!(
|
||||
configuration(&handle, service, pin)? == before
|
||||
&& status(&handle)?.dwProcessId == proof.process.pid,
|
||||
"UPDATE_SERVICE_OBSERVATION_CHANGED"
|
||||
);
|
||||
budget.check()?;
|
||||
Ok(HeldService {
|
||||
service,
|
||||
handle,
|
||||
peer,
|
||||
proof,
|
||||
})
|
||||
}
|
||||
|
||||
/// Observation holds both original processes/images, not a freely constructible
|
||||
/// Running flag. Drop these witnesses only after confirmed process termination.
|
||||
pub struct Running {
|
||||
pins: [PeerPin; 2],
|
||||
held: Vec<HeldService>,
|
||||
}
|
||||
impl Running {
|
||||
pub fn observe(pins: [PeerPin; 2], budget: &Budget<'_>) -> Result<Self> {
|
||||
let held = vec![
|
||||
observe(Service::Agent, &pins[0], budget)?,
|
||||
observe(Service::Helper, &pins[1], budget)?,
|
||||
];
|
||||
Ok(Self { pins, held })
|
||||
}
|
||||
pub fn proofs(&self) -> Vec<Proof> {
|
||||
self.held.iter().map(|s| s.proof.clone()).collect()
|
||||
}
|
||||
pub fn check(&mut self, budget: &Budget<'_>) -> Result<()> {
|
||||
budget.check()?;
|
||||
for (i, service) in self.held.iter_mut().enumerate() {
|
||||
service.peer.check()?;
|
||||
ensure!(
|
||||
configuration(&service.handle, service.service, &self.pins[i])?
|
||||
== service.proof.configuration,
|
||||
"UPDATE_SERVICE_CONFIG_CHANGED"
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn stop(
|
||||
mut self,
|
||||
budget: &Budget<'_>,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Stopped> {
|
||||
self.check(budget)?;
|
||||
for (i, service) in self.held.iter_mut().enumerate() {
|
||||
service.peer.check()?;
|
||||
ensure!(
|
||||
configuration(&service.handle, service.service, &self.pins[i])?
|
||||
== service.proof.configuration,
|
||||
"UPDATE_SERVICE_CONFIG_CHANGED"
|
||||
);
|
||||
let effect = Effect::StopService {
|
||||
service: service.service,
|
||||
};
|
||||
fence.before_effect(&effect)?;
|
||||
budget.check()?;
|
||||
service.peer.check()?;
|
||||
let mut stopped = unsafe { zeroed() };
|
||||
ensure!(
|
||||
unsafe { ControlService(service.handle.0, SERVICE_CONTROL_STOP, &mut stopped) }
|
||||
!= 0,
|
||||
"UPDATE_STOP_REQUEST_UNCERTAIN"
|
||||
);
|
||||
loop {
|
||||
budget.check()?;
|
||||
let state = status(&service.handle)?;
|
||||
if state.dwCurrentState == SERVICE_STOPPED
|
||||
&& state.dwProcessId == 0
|
||||
&& service.peer.exited()?
|
||||
{
|
||||
break;
|
||||
}
|
||||
ensure!(
|
||||
matches!(state.dwCurrentState, SERVICE_STOP_PENDING | SERVICE_STOPPED),
|
||||
"UPDATE_STOP_STATE_UNCERTAIN"
|
||||
);
|
||||
thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
fence.after_effect(&effect, &digest(&serde_json::to_vec(&service.proof)?))?;
|
||||
}
|
||||
let proofs = self.proofs();
|
||||
let stopped = Stopped {
|
||||
pins: self.pins,
|
||||
configurations: [
|
||||
proofs[0].configuration.clone(),
|
||||
proofs[1].configuration.clone(),
|
||||
],
|
||||
};
|
||||
// Held image handles intentionally close here, after BOTH exact original
|
||||
// processes have terminated. Neither PID reuse nor SCM state suffices.
|
||||
drop(self.held);
|
||||
stopped.check(budget)?;
|
||||
Ok(stopped)
|
||||
}
|
||||
}
|
||||
|
||||
/// Only the actual completed stop sequence constructs this token. It is not a
|
||||
/// closed-reader census or a helper-ledger lock; those remain separate gates.
|
||||
pub struct Stopped {
|
||||
pins: [PeerPin; 2],
|
||||
configurations: [Configuration; 2],
|
||||
}
|
||||
impl Stopped {
|
||||
pub fn check(&self, budget: &Budget<'_>) -> Result<()> {
|
||||
budget.check()?;
|
||||
for (i, service) in [Service::Agent, Service::Helper].into_iter().enumerate() {
|
||||
let handle = handle(
|
||||
service,
|
||||
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | SERVICE_ENUMERATE_DEPENDENTS,
|
||||
)?;
|
||||
let state = status(&handle)?;
|
||||
ensure!(
|
||||
state.dwCurrentState == SERVICE_STOPPED
|
||||
&& state.dwProcessId == 0
|
||||
&& configuration(&handle, service, &self.pins[i])? == self.configurations[i],
|
||||
"UPDATE_STOPPED_STATE_CHANGED"
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Caller MUST commit the original ledger-return/start-reservation before
|
||||
/// dropping its guard and calling this. Helper starts before agent. This
|
||||
/// function never retries a failed or uncertain native start request.
|
||||
pub fn start(
|
||||
self,
|
||||
replacement_pins: [PeerPin; 2],
|
||||
budget: &Budget<'_>,
|
||||
fence: &mut impl DurableEffectFence,
|
||||
) -> Result<Running> {
|
||||
self.check(budget)?;
|
||||
let mut started = Vec::with_capacity(2);
|
||||
for (i, service) in [(1, Service::Helper), (0, Service::Agent)] {
|
||||
replacement_pins[i].validate(service == Service::Helper)?;
|
||||
ensure!(
|
||||
replacement_pins[i].binary == self.pins[i].binary
|
||||
&& replacement_pins[i].service_name == self.pins[i].service_name
|
||||
&& replacement_pins[i].service_sid == self.pins[i].service_sid
|
||||
&& replacement_pins[i].user_sid == self.pins[i].user_sid,
|
||||
"UPDATE_REPLACEMENT_SERVICE_IDENTITY"
|
||||
);
|
||||
let handle = handle(
|
||||
service,
|
||||
SERVICE_QUERY_STATUS
|
||||
| SERVICE_QUERY_CONFIG
|
||||
| SERVICE_ENUMERATE_DEPENDENTS
|
||||
| SERVICE_START,
|
||||
)?;
|
||||
ensure!(
|
||||
configuration(&handle, service, &replacement_pins[i])? == self.configurations[i],
|
||||
"UPDATE_SERVICE_CONFIG_CHANGED"
|
||||
);
|
||||
let effect = Effect::StartService { service };
|
||||
fence.before_effect(&effect)?;
|
||||
budget.check()?;
|
||||
ensure!(
|
||||
status(&handle)?.dwCurrentState == SERVICE_STOPPED,
|
||||
"UPDATE_START_ALREADY_RUNNING"
|
||||
);
|
||||
ensure!(
|
||||
unsafe { StartServiceW(handle.0, 0, ptr::null()) } != 0,
|
||||
"UPDATE_START_REQUEST_UNCERTAIN"
|
||||
);
|
||||
loop {
|
||||
budget.check()?;
|
||||
let state = status(&handle)?;
|
||||
if state.dwCurrentState == SERVICE_RUNNING {
|
||||
break;
|
||||
}
|
||||
ensure!(
|
||||
state.dwCurrentState == SERVICE_START_PENDING,
|
||||
"UPDATE_START_STATE_UNCERTAIN"
|
||||
);
|
||||
thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
let held = observe(service, &replacement_pins[i], budget)?;
|
||||
fence.after_effect(&effect, &digest(&serde_json::to_vec(&held.proof)?))?;
|
||||
started.push(held);
|
||||
}
|
||||
started.reverse();
|
||||
let mut running = Running {
|
||||
pins: replacement_pins,
|
||||
held: started,
|
||||
};
|
||||
running.check(budget)?;
|
||||
Ok(running)
|
||||
}
|
||||
}
|
||||
impl Proof {
|
||||
pub fn started(&self) -> StartedService {
|
||||
StartedService {
|
||||
service: self.configuration.service.handoff_service(),
|
||||
process: self.process.clone(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,540 @@
|
||||
//! Closed Windows code/pin/time-profile rendering, without OS effects.
|
||||
//!
|
||||
//! Input bytes must come from protected, independently authenticated original
|
||||
//! files. Candidate time qualifications must be independently verified by the
|
||||
//! embedding admission worker BEFORE offering a release. This pure renderer
|
||||
//! binds their exact bytes/hashes; parsing a receipt hash does not qualify code.
|
||||
use super::valid_digest;
|
||||
use crate::signed_clock::{ActiveGuestOperation, TrustedOsConfiguration, TrustedPlatform};
|
||||
use anyhow::{Result, ensure};
|
||||
use rmm_agent_core::{
|
||||
auth::Binding,
|
||||
crypto::{DalekVerifier, Ed25519Verifier},
|
||||
};
|
||||
use rmm_domain::{
|
||||
agent_update::{PeerPinTransition, WindowsTimeProfileTransition},
|
||||
jobs::{PrivilegedScriptProfile, hash},
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::value::RawValue;
|
||||
use std::path::PathBuf;
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Peer {
|
||||
service_name: String,
|
||||
service_sid: String,
|
||||
user_sid: String,
|
||||
binary: PathBuf,
|
||||
binary_sha256: String,
|
||||
}
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Rule {
|
||||
name: String,
|
||||
binary: PathBuf,
|
||||
binary_sha256: String,
|
||||
}
|
||||
/// Versioned snapshot of Settings' SERIALIZATION field order. No new rights,
|
||||
/// service rules, reboot setting or interpreter policy can be introduced here.
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Settings {
|
||||
schema_version: u32,
|
||||
binding: Binding,
|
||||
agent: Peer,
|
||||
helper: Peer,
|
||||
allowed_services: Vec<Rule>,
|
||||
max_runtime_seconds: u32,
|
||||
enable_effects: bool,
|
||||
allow_reboot: bool,
|
||||
#[serde(
|
||||
default,
|
||||
skip_serializing_if = "Option::is_none",
|
||||
deserialize_with = "strict_hashes"
|
||||
)]
|
||||
allowed_msi_recipe_sha256: Option<Vec<String>>,
|
||||
#[serde(
|
||||
default,
|
||||
skip_serializing_if = "Option::is_none",
|
||||
deserialize_with = "rmm_domain::jobs::deserialize_script_profiles"
|
||||
)]
|
||||
allowed_script_profiles: Option<Vec<PrivilegedScriptProfile>>,
|
||||
}
|
||||
fn strict_hashes<'de, D: serde::Deserializer<'de>>(
|
||||
d: D,
|
||||
) -> std::result::Result<Option<Vec<String>>, D::Error> {
|
||||
Vec::<String>::deserialize(d).map(Some)
|
||||
}
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Pin {
|
||||
schema_version: u32,
|
||||
binding: Binding,
|
||||
policy_sha256: String,
|
||||
agent: Peer,
|
||||
helper: Peer,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct PeerSpan<'a> {
|
||||
#[serde(borrow)]
|
||||
binary_sha256: &'a RawValue,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct Spans<'a> {
|
||||
#[serde(borrow)]
|
||||
agent: PeerSpan<'a>,
|
||||
#[serde(borrow)]
|
||||
helper: PeerSpan<'a>,
|
||||
#[serde(default, borrow)]
|
||||
policy_sha256: Option<&'a RawValue>,
|
||||
}
|
||||
pub struct CodePairTransition {
|
||||
proof: PeerPinTransition,
|
||||
settings: Vec<u8>,
|
||||
pin: Vec<u8>,
|
||||
time_profile: Vec<u8>,
|
||||
}
|
||||
impl CodePairTransition {
|
||||
pub fn proof(&self) -> &PeerPinTransition {
|
||||
&self.proof
|
||||
}
|
||||
pub fn settings_bytes(&self) -> &[u8] {
|
||||
&self.settings
|
||||
}
|
||||
pub fn pin_bytes(&self) -> &[u8] {
|
||||
&self.pin
|
||||
}
|
||||
pub fn time_profile_bytes(&self) -> &[u8] {
|
||||
&self.time_profile
|
||||
}
|
||||
}
|
||||
pub struct Inputs<'a> {
|
||||
pub settings: &'a [u8],
|
||||
pub pin: &'a [u8],
|
||||
pub time_profile: &'a [u8],
|
||||
pub qualified_candidate_time_profile: &'a [u8],
|
||||
pub target_agent_sha256: &'a str,
|
||||
pub target_helper_sha256: &'a str,
|
||||
}
|
||||
fn bound_peer(peer: &Peer, helper: bool) -> bool {
|
||||
let service = if helper {
|
||||
super::Service::Helper
|
||||
} else {
|
||||
super::Service::Agent
|
||||
};
|
||||
let role = if helper {
|
||||
super::Role::Helper
|
||||
} else {
|
||||
super::Role::Agent
|
||||
};
|
||||
peer.service_name == service.name()
|
||||
&& peer.user_sid == if helper { "S-1-5-18" } else { "S-1-5-19" }
|
||||
&& peer.service_sid.starts_with("S-1-5-80-")
|
||||
&& peer.binary.to_str() == Some(role.target())
|
||||
&& valid_digest(&peer.binary_sha256)
|
||||
}
|
||||
fn time_configuration(
|
||||
bytes: &[u8],
|
||||
binding: &Binding,
|
||||
agent: &str,
|
||||
helper: &str,
|
||||
) -> Result<TrustedOsConfiguration> {
|
||||
let value: TrustedOsConfiguration = serde_json::from_slice(bytes)?;
|
||||
let profile = &value.trusted_os_active_guest;
|
||||
ensure!(
|
||||
value.schema_version == 2
|
||||
&& value.key_generation > 0
|
||||
&& !value.server_instance.is_nil()
|
||||
&& serde_json::to_value(&value.binding)? == serde_json::to_value(binding)?
|
||||
&& !value.public_keys_hex.is_empty()
|
||||
&& value.public_keys_hex.len() <= 8
|
||||
&& matches!(
|
||||
profile.operating_assumption,
|
||||
ActiveGuestOperation::NoPauseSaveRestoreSnapshotMigrationHostSuspend
|
||||
)
|
||||
&& matches!(profile.platform, TrustedPlatform::KvmQemuHypervClock)
|
||||
&& valid_digest(&profile.platform_provenance_sha256)
|
||||
&& profile.qualifications.len() == 2,
|
||||
"UPDATE_TIME_PROFILE_BINDING"
|
||||
);
|
||||
for (id, public) in &value.public_keys_hex {
|
||||
ensure!(
|
||||
!id.is_empty()
|
||||
&& id.len() <= 64
|
||||
&& id
|
||||
.bytes()
|
||||
.all(|b| b.is_ascii_alphanumeric() || b"_-".contains(&b))
|
||||
&& valid_digest(public)
|
||||
&& public != &binding.public_key_hex,
|
||||
"UPDATE_TIME_PROFILE_KEY"
|
||||
);
|
||||
let key = (0..32)
|
||||
.map(|i| u8::from_str_radix(&public[i * 2..i * 2 + 2], 16))
|
||||
.collect::<std::result::Result<Vec<_>, _>>()?;
|
||||
ensure!(DalekVerifier.validate_key(&key)?, "UPDATE_TIME_PROFILE_KEY");
|
||||
}
|
||||
for (role, image) in [
|
||||
(rmm_time_attestation::Role::Agent, agent),
|
||||
(rmm_time_attestation::Role::SystemHelper, helper),
|
||||
] {
|
||||
let found: Vec<_> = profile
|
||||
.qualifications
|
||||
.iter()
|
||||
.filter(|q| q.role == role)
|
||||
.collect();
|
||||
ensure!(
|
||||
found.len() == 1
|
||||
&& found[0].binary_sha256 == image
|
||||
&& valid_digest(&found[0].qualification_sha256),
|
||||
"UPDATE_TIME_PROFILE_QUALIFICATION"
|
||||
);
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
pub fn render(input: Inputs<'_>) -> Result<CodePairTransition> {
|
||||
for raw in [
|
||||
input.settings,
|
||||
input.pin,
|
||||
input.time_profile,
|
||||
input.qualified_candidate_time_profile,
|
||||
] {
|
||||
ensure!(
|
||||
!raw.is_empty() && raw.len() <= 32768,
|
||||
"UPDATE_WINDOWS_RENDER_LIMIT"
|
||||
);
|
||||
}
|
||||
ensure!(
|
||||
valid_digest(input.target_agent_sha256) && valid_digest(input.target_helper_sha256),
|
||||
"UPDATE_WINDOWS_IMAGE"
|
||||
);
|
||||
let mut settings: Settings = serde_json::from_slice(input.settings)?;
|
||||
let mut pin: Pin = serde_json::from_slice(input.pin)?;
|
||||
ensure!(
|
||||
matches!(settings.schema_version, 1..=3)
|
||||
&& !settings.allow_reboot
|
||||
&& (1..=120).contains(&settings.max_runtime_seconds)
|
||||
&& settings.allowed_services.len() <= 16
|
||||
&& (settings.schema_version >= 2 || settings.allowed_msi_recipe_sha256.is_none())
|
||||
&& (settings.schema_version == 3 || settings.allowed_script_profiles.is_none())
|
||||
&& bound_peer(&settings.agent, false)
|
||||
&& bound_peer(&settings.helper, true)
|
||||
&& !settings.binding.tenant_id.is_nil()
|
||||
&& !settings.binding.asset_id.is_nil()
|
||||
&& !settings.binding.agent_id.is_nil()
|
||||
&& settings.binding.enrollment_generation > 0
|
||||
&& settings.binding.assignment_version > 0
|
||||
&& pin.schema_version == 1
|
||||
&& pin.policy_sha256 == hash(&serde_json::to_vec(&settings)?)
|
||||
&& serde_json::to_value(&pin.binding)? == serde_json::to_value(&settings.binding)?
|
||||
&& serde_json::to_value(&pin.agent)? == serde_json::to_value(&settings.agent)?
|
||||
&& serde_json::to_value(&pin.helper)? == serde_json::to_value(&settings.helper)?,
|
||||
"UPDATE_WINDOWS_ORIGINAL_PAIR"
|
||||
);
|
||||
let old_agent = settings.agent.binary_sha256.clone();
|
||||
let old_helper = settings.helper.binary_sha256.clone();
|
||||
let old_time = time_configuration(
|
||||
input.time_profile,
|
||||
&settings.binding,
|
||||
&old_agent,
|
||||
&old_helper,
|
||||
)?;
|
||||
let candidate = time_configuration(
|
||||
input.qualified_candidate_time_profile,
|
||||
&settings.binding,
|
||||
input.target_agent_sha256,
|
||||
input.target_helper_sha256,
|
||||
)?;
|
||||
let mut unchanged_candidate = serde_json::to_value(&candidate)?;
|
||||
unchanged_candidate["trusted_os_active_guest"]["qualifications"] =
|
||||
serde_json::to_value(&old_time.trusted_os_active_guest.qualifications)?;
|
||||
ensure!(
|
||||
unchanged_candidate == serde_json::to_value(&old_time)?,
|
||||
"UPDATE_TIME_TRUST_OR_PLATFORM_CHANGE"
|
||||
);
|
||||
for new in &candidate.trusted_os_active_guest.qualifications {
|
||||
let old = old_time
|
||||
.trusted_os_active_guest
|
||||
.qualifications
|
||||
.iter()
|
||||
.find(|q| q.role == new.role)
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_TIME_ROLE"))?;
|
||||
ensure!(
|
||||
new.binary_sha256 == old.binary_sha256
|
||||
|| new.qualification_sha256 != old.qualification_sha256,
|
||||
"UPDATE_TIME_OLD_QUALIFICATION_REUSED"
|
||||
);
|
||||
}
|
||||
settings.agent.binary_sha256 = input.target_agent_sha256.into();
|
||||
settings.helper.binary_sha256 = input.target_helper_sha256.into();
|
||||
pin.agent.binary_sha256 = input.target_agent_sha256.into();
|
||||
pin.helper.binary_sha256 = input.target_helper_sha256.into();
|
||||
pin.policy_sha256 = hash(&serde_json::to_vec(&settings)?);
|
||||
let settings_spans: Spans<'_> = serde_json::from_slice(input.settings)?;
|
||||
let pin_spans: Spans<'_> = serde_json::from_slice(input.pin)?;
|
||||
let settings_bytes = replace(
|
||||
input.settings,
|
||||
vec![
|
||||
(
|
||||
settings_spans.agent.binary_sha256,
|
||||
input.target_agent_sha256,
|
||||
),
|
||||
(
|
||||
settings_spans.helper.binary_sha256,
|
||||
input.target_helper_sha256,
|
||||
),
|
||||
],
|
||||
)?;
|
||||
let pin_bytes = replace(
|
||||
input.pin,
|
||||
vec![
|
||||
(pin_spans.agent.binary_sha256, input.target_agent_sha256),
|
||||
(pin_spans.helper.binary_sha256, input.target_helper_sha256),
|
||||
(
|
||||
pin_spans
|
||||
.policy_sha256
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_PIN_POLICY_HASH"))?,
|
||||
&pin.policy_sha256,
|
||||
),
|
||||
],
|
||||
)?;
|
||||
// Confirm the span edits exactly equal the typed, closed intended objects.
|
||||
ensure!(
|
||||
serde_json::to_value(serde_json::from_slice::<Settings>(&settings_bytes)?)?
|
||||
== serde_json::to_value(&settings)?
|
||||
&& serde_json::to_value(serde_json::from_slice::<Pin>(&pin_bytes)?)?
|
||||
== serde_json::to_value(&pin)?,
|
||||
"UPDATE_WINDOWS_RENDER_CHANGED"
|
||||
);
|
||||
let quals = &candidate.trusted_os_active_guest.qualifications;
|
||||
let agent = quals
|
||||
.iter()
|
||||
.find(|q| q.role == rmm_time_attestation::Role::Agent)
|
||||
.unwrap();
|
||||
let helper = quals
|
||||
.iter()
|
||||
.find(|q| q.role == rmm_time_attestation::Role::SystemHelper)
|
||||
.unwrap();
|
||||
let transition = PeerPinTransition::WindowsCodePairV1 {
|
||||
old_settings_sha256: hash(input.settings),
|
||||
new_settings_sha256: hash(&settings_bytes),
|
||||
old_pin_sha256: hash(input.pin),
|
||||
new_pin_sha256: hash(&pin_bytes),
|
||||
time_profile: Some(WindowsTimeProfileTransition {
|
||||
schema_version: 1,
|
||||
old_time_profile_sha256: hash(input.time_profile),
|
||||
new_time_profile_sha256: hash(input.qualified_candidate_time_profile),
|
||||
agent_qualification_sha256: agent.qualification_sha256.clone(),
|
||||
helper_qualification_sha256: helper.qualification_sha256.clone(),
|
||||
}),
|
||||
};
|
||||
Ok(CodePairTransition {
|
||||
proof: transition,
|
||||
settings: settings_bytes,
|
||||
pin: pin_bytes,
|
||||
time_profile: input.qualified_candidate_time_profile.to_vec(),
|
||||
})
|
||||
}
|
||||
fn replace(bytes: &[u8], values: Vec<(&RawValue, &str)>) -> Result<Vec<u8>> {
|
||||
let mut spans = Vec::new();
|
||||
for (raw, replacement) in values {
|
||||
let raw = raw.get();
|
||||
let start = (raw.as_ptr() as usize)
|
||||
.checked_sub(bytes.as_ptr() as usize)
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_RENDER_SPAN"))?;
|
||||
let end = start
|
||||
.checked_add(raw.len())
|
||||
.ok_or_else(|| anyhow::anyhow!("UPDATE_RENDER_SPAN"))?;
|
||||
ensure!(
|
||||
bytes.get(start..end) == Some(raw.as_bytes())
|
||||
&& raw.len() == 66
|
||||
&& raw.starts_with('"')
|
||||
&& raw.ends_with('"')
|
||||
&& valid_digest(&raw[1..65])
|
||||
&& valid_digest(replacement),
|
||||
"UPDATE_RENDER_HASH_ENCODING"
|
||||
);
|
||||
spans.push((start, end, format!("\"{replacement}\"")));
|
||||
}
|
||||
spans.sort_by_key(|s| s.0);
|
||||
ensure!(
|
||||
spans.windows(2).all(|p| p[0].1 <= p[1].0),
|
||||
"UPDATE_RENDER_OVERLAP"
|
||||
);
|
||||
let mut result = Vec::with_capacity(bytes.len());
|
||||
let mut cursor = 0;
|
||||
for (start, end, value) in spans {
|
||||
result.extend_from_slice(&bytes[cursor..start]);
|
||||
result.extend_from_slice(value.as_bytes());
|
||||
cursor = end;
|
||||
}
|
||||
result.extend_from_slice(&bytes[cursor..]);
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ed25519_dalek::SigningKey;
|
||||
use serde_json::{Value, json};
|
||||
struct Fixture {
|
||||
settings: Vec<u8>,
|
||||
pin: Vec<u8>,
|
||||
time: Vec<u8>,
|
||||
candidate: Vec<u8>,
|
||||
}
|
||||
fn fixture() -> Fixture {
|
||||
let public = |byte| {
|
||||
SigningKey::from_bytes(&[byte; 32])
|
||||
.verifying_key()
|
||||
.to_bytes()
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect::<String>()
|
||||
};
|
||||
let binding = json!({"tenant_id":uuid::Uuid::from_u128(1),"asset_id":uuid::Uuid::from_u128(2),
|
||||
"agent_id":uuid::Uuid::from_u128(3),"enrollment_generation":1,"assignment_version":1,"public_key_hex":public(17)});
|
||||
let peer = |helper: bool| {
|
||||
json!({"service_name":if helper {super::super::Service::Helper.name()}else{super::super::Service::Agent.name()},
|
||||
"service_sid":if helper {"S-1-5-80-1-2-3-4-5"}else{"S-1-5-80-6-7-8-9-10"},
|
||||
"user_sid":if helper{"S-1-5-18"}else{"S-1-5-19"},
|
||||
"binary":if helper {super::super::Role::Helper.target()}else{super::super::Role::Agent.target()},
|
||||
"binary_sha256":if helper{"cd".repeat(32)}else{"ab".repeat(32)}})
|
||||
};
|
||||
let settings = json!({"schema_version":3,"binding":binding,"agent":peer(false),"helper":peer(true),
|
||||
"allowed_services":[{"name":"RmmDiscoveryFixtureUpdater","binary":"C:\\Program Files\\RustDiscoveryFixtures\\fixture.exe","binary_sha256":"ab".repeat(32)}],
|
||||
"max_runtime_seconds":120,"enable_effects":true,"allow_reboot":false,
|
||||
"allowed_msi_recipe_sha256":[],"allowed_script_profiles":["full_maintenance_v1"]});
|
||||
let typed: Settings = serde_json::from_value(settings.clone()).unwrap();
|
||||
let pin = json!({"schema_version":1,"binding":binding,"policy_sha256":hash(&serde_json::to_vec(&typed).unwrap()),"agent":peer(false),"helper":peer(true)});
|
||||
let time = json!({"schema_version":2,"key_generation":1,"server_instance":uuid::Uuid::from_u128(4),"binding":binding,
|
||||
"public_keys_hex":{"development_time_v1":public(19)},"trusted_os_active_guest":{
|
||||
"operating_assumption":"active_guest_no_pause_save_restore_snapshot_migration_host_suspend","platform":"kvm_qemu_hypervclock",
|
||||
"platform_provenance_sha256":"01".repeat(32),"qualifications":[
|
||||
{"role":"agent","binary_sha256":"ab".repeat(32),"qualification_sha256":"02".repeat(32)},
|
||||
{"role":"system_helper","binary_sha256":"cd".repeat(32),"qualification_sha256":"03".repeat(32)}]}});
|
||||
let mut candidate = time.clone();
|
||||
candidate["trusted_os_active_guest"]["qualifications"][0]["binary_sha256"] =
|
||||
json!("ef".repeat(32));
|
||||
candidate["trusted_os_active_guest"]["qualifications"][0]["qualification_sha256"] =
|
||||
json!("04".repeat(32));
|
||||
candidate["trusted_os_active_guest"]["qualifications"][1]["binary_sha256"] =
|
||||
json!("ac".repeat(32));
|
||||
candidate["trusted_os_active_guest"]["qualifications"][1]["qualification_sha256"] =
|
||||
json!("05".repeat(32));
|
||||
Fixture {
|
||||
settings: serde_json::to_vec_pretty(&settings).unwrap(),
|
||||
pin: serde_json::to_vec_pretty(&pin).unwrap(),
|
||||
time: serde_json::to_vec_pretty(&time).unwrap(),
|
||||
candidate: serde_json::to_vec_pretty(&candidate).unwrap(),
|
||||
}
|
||||
}
|
||||
fn render_fixture(f: &Fixture) -> Result<CodePairTransition> {
|
||||
render(Inputs {
|
||||
settings: &f.settings,
|
||||
pin: &f.pin,
|
||||
time_profile: &f.time,
|
||||
qualified_candidate_time_profile: &f.candidate,
|
||||
target_agent_sha256: &"ef".repeat(32),
|
||||
target_helper_sha256: &"ac".repeat(32),
|
||||
})
|
||||
}
|
||||
#[test]
|
||||
fn windows_transition_preserves_raw_policy_bytes_and_binds_prequalified_time_profile() {
|
||||
let f = fixture();
|
||||
let result = render_fixture(&f).unwrap();
|
||||
let old: Settings = serde_json::from_slice(&f.settings).unwrap();
|
||||
let new: Settings = serde_json::from_slice(result.settings_bytes()).unwrap();
|
||||
assert_eq!(
|
||||
new.allowed_services[0].binary_sha256,
|
||||
old.agent.binary_sha256
|
||||
);
|
||||
let reversed = String::from_utf8(result.settings_bytes().to_vec())
|
||||
.unwrap()
|
||||
.replace(&"ef".repeat(32), &"ab".repeat(32))
|
||||
.replace(&"ac".repeat(32), &"cd".repeat(32));
|
||||
assert_eq!(reversed.as_bytes(), f.settings);
|
||||
assert_eq!(result.time_profile_bytes(), f.candidate);
|
||||
let new_pin: Pin = serde_json::from_slice(result.pin_bytes()).unwrap();
|
||||
assert_eq!(
|
||||
new_pin.policy_sha256,
|
||||
hash(&serde_json::to_vec(&new).unwrap())
|
||||
);
|
||||
let PeerPinTransition::WindowsCodePairV1 {
|
||||
time_profile: Some(t),
|
||||
..
|
||||
} = result.proof()
|
||||
else {
|
||||
panic!("fixed clock transition")
|
||||
};
|
||||
assert_eq!(t.old_time_profile_sha256, hash(&f.time));
|
||||
assert_eq!(t.new_time_profile_sha256, hash(&f.candidate));
|
||||
assert_eq!(t.agent_qualification_sha256, "04".repeat(32));
|
||||
#[cfg(windows)]
|
||||
{
|
||||
// Both OS-native production codecs must derive the SAME policy
|
||||
// hash; a mirrored test-only serialization cannot satisfy this.
|
||||
let actual: crate::helper_system::Settings =
|
||||
serde_json::from_slice(result.settings_bytes()).unwrap();
|
||||
assert_eq!(actual.policy_sha256().unwrap(), new_pin.policy_sha256);
|
||||
let _: crate::helper_ipc::Pin = serde_json::from_slice(result.pin_bytes()).unwrap();
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn windows_transition_denies_changed_time_trust_reused_qualification_and_unbound_pin() {
|
||||
for change in [
|
||||
"key",
|
||||
"platform",
|
||||
"qualification",
|
||||
"role",
|
||||
"extra",
|
||||
"pin",
|
||||
"null",
|
||||
] {
|
||||
let mut f = fixture();
|
||||
if change == "pin" {
|
||||
let mut value: Value = serde_json::from_slice(&f.pin).unwrap();
|
||||
value["policy_sha256"] = json!("ff".repeat(32));
|
||||
f.pin = serde_json::to_vec(&value).unwrap();
|
||||
} else if change == "null" {
|
||||
let mut value: Value = serde_json::from_slice(&f.settings).unwrap();
|
||||
value["allowed_msi_recipe_sha256"] = Value::Null;
|
||||
f.settings = serde_json::to_vec(&value).unwrap();
|
||||
} else {
|
||||
let mut value: Value = serde_json::from_slice(&f.candidate).unwrap();
|
||||
match change {
|
||||
"key" => value["key_generation"] = json!(2),
|
||||
"platform" => {
|
||||
value["trusted_os_active_guest"]["platform_provenance_sha256"] =
|
||||
json!("ff".repeat(32))
|
||||
}
|
||||
"qualification" => {
|
||||
value["trusted_os_active_guest"]["qualifications"][0]["qualification_sha256"] =
|
||||
json!("02".repeat(32))
|
||||
}
|
||||
"role" => {
|
||||
value["trusted_os_active_guest"]["qualifications"][1]["role"] =
|
||||
json!("agent")
|
||||
}
|
||||
_ => value["trusted_os_active_guest"]["assume_ready"] = json!(true),
|
||||
}
|
||||
f.candidate = serde_json::to_vec(&value).unwrap();
|
||||
}
|
||||
assert!(render_fixture(&f).is_err(), "changed field {change}");
|
||||
}
|
||||
let f = fixture();
|
||||
let mut value: Value = serde_json::from_slice(&f.pin).unwrap();
|
||||
value["helper"]["binary_sha256"] = json!("ff".repeat(32));
|
||||
assert!(
|
||||
render(Inputs {
|
||||
settings: &f.settings,
|
||||
pin: &serde_json::to_vec(&value).unwrap(),
|
||||
time_profile: &f.time,
|
||||
qualified_candidate_time_profile: &f.candidate,
|
||||
target_agent_sha256: &"ef".repeat(32),
|
||||
target_helper_sha256: &"ac".repeat(32)
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -65,6 +65,7 @@ fn fixture(platform: Platform, full: bool) -> serde_json::Value {
|
||||
new_settings_sha256: "12".repeat(32),
|
||||
old_pin_sha256: "13".repeat(32),
|
||||
new_pin_sha256: "14".repeat(32),
|
||||
time_profile: None,
|
||||
},
|
||||
};
|
||||
let update = ResolvedAgentUpdate {
|
||||
|
||||
@@ -211,6 +211,15 @@ pub struct LinuxFullTransition {
|
||||
pub effective_signing_key_id: String,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct WindowsTimeProfileTransition {
|
||||
pub schema_version: u32,
|
||||
pub old_time_profile_sha256: String,
|
||||
pub new_time_profile_sha256: String,
|
||||
pub agent_qualification_sha256: String,
|
||||
pub helper_qualification_sha256: String,
|
||||
}
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
|
||||
#[serde(tag = "profile", rename_all = "snake_case", deny_unknown_fields)]
|
||||
pub enum PeerPinTransition {
|
||||
UnchangedGeneralPinV1 {
|
||||
@@ -225,8 +234,40 @@ pub enum PeerPinTransition {
|
||||
new_settings_sha256: String,
|
||||
old_pin_sha256: String,
|
||||
new_pin_sha256: String,
|
||||
#[serde(
|
||||
default,
|
||||
skip_serializing_if = "Option::is_none",
|
||||
deserialize_with = "strict_windows_time_profile"
|
||||
)]
|
||||
time_profile: Option<WindowsTimeProfileTransition>,
|
||||
},
|
||||
}
|
||||
fn strict_windows_time_profile<'de, D: serde::Deserializer<'de>>(
|
||||
d: D,
|
||||
) -> Result<Option<WindowsTimeProfileTransition>, D::Error> {
|
||||
WindowsTimeProfileTransition::deserialize(d).map(Some)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod windows_time_transition_tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn optional_windows_clock_binding_is_additive_and_null_is_never_missing() {
|
||||
let old = serde_json::json!({"profile":"windows_code_pair_v1","old_settings_sha256":"11".repeat(32),
|
||||
"new_settings_sha256":"22".repeat(32),"old_pin_sha256":"33".repeat(32),"new_pin_sha256":"44".repeat(32)});
|
||||
let decoded: PeerPinTransition = serde_json::from_value(old.clone()).unwrap();
|
||||
assert_eq!(serde_json::to_value(decoded).unwrap(), old);
|
||||
let mut invalid = old.clone();
|
||||
invalid["time_profile"] = serde_json::Value::Null;
|
||||
assert!(serde_json::from_value::<PeerPinTransition>(invalid).is_err());
|
||||
let mut current = old;
|
||||
current["time_profile"] = serde_json::json!({"schema_version":1,
|
||||
"old_time_profile_sha256":"55".repeat(32),"new_time_profile_sha256":"66".repeat(32),
|
||||
"agent_qualification_sha256":"77".repeat(32),"helper_qualification_sha256":"88".repeat(32)});
|
||||
let decoded: PeerPinTransition = serde_json::from_value(current.clone()).unwrap();
|
||||
assert_eq!(serde_json::to_value(decoded).unwrap(), current);
|
||||
}
|
||||
}
|
||||
impl PeerPinTransition {
|
||||
fn validate(&self, platform: Platform, predecessor: &Predecessor, target_helper: &str) -> bool {
|
||||
match self {
|
||||
@@ -261,6 +302,7 @@ impl PeerPinTransition {
|
||||
new_settings_sha256,
|
||||
old_pin_sha256,
|
||||
new_pin_sha256,
|
||||
time_profile,
|
||||
} => {
|
||||
platform == Platform::WindowsX64
|
||||
&& [
|
||||
@@ -273,6 +315,18 @@ impl PeerPinTransition {
|
||||
.all(|h| digest(h))
|
||||
&& old_settings_sha256 != new_settings_sha256
|
||||
&& old_pin_sha256 != new_pin_sha256
|
||||
&& time_profile.as_ref().is_none_or(|t| {
|
||||
t.schema_version == 1
|
||||
&& [
|
||||
&t.old_time_profile_sha256,
|
||||
&t.new_time_profile_sha256,
|
||||
&t.agent_qualification_sha256,
|
||||
&t.helper_qualification_sha256,
|
||||
]
|
||||
.iter()
|
||||
.all(|h| digest(h))
|
||||
&& t.old_time_profile_sha256 != t.new_time_profile_sha256
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -751,6 +805,7 @@ pub fn handoff_matches_job(
|
||||
new_settings_sha256,
|
||||
old_pin_sha256,
|
||||
new_pin_sha256,
|
||||
time_profile: None,
|
||||
},
|
||||
PinTransition::WindowsCodePairV1,
|
||||
) => {
|
||||
@@ -762,6 +817,29 @@ pub fn handoff_matches_job(
|
||||
&& f.new_sha256 == *new_settings_sha256
|
||||
})
|
||||
}
|
||||
(
|
||||
PeerPinTransition::WindowsCodePairV1 {
|
||||
old_settings_sha256,
|
||||
new_settings_sha256,
|
||||
old_pin_sha256,
|
||||
new_pin_sha256,
|
||||
time_profile: Some(time),
|
||||
},
|
||||
PinTransition::WindowsCodePairClockV1,
|
||||
) => {
|
||||
h.predecessor.pin_sha256 == *old_pin_sha256
|
||||
&& h.target.pin_sha256 == *new_pin_sha256
|
||||
&& h.files.get(2).is_some_and(|f| {
|
||||
f.role == FileRole::WindowsSettings
|
||||
&& f.old_sha256 == *old_settings_sha256
|
||||
&& f.new_sha256 == *new_settings_sha256
|
||||
})
|
||||
&& h.files.get(4).is_some_and(|f| {
|
||||
f.role == FileRole::WindowsTimeProfile
|
||||
&& f.old_sha256 == time.old_time_profile_sha256
|
||||
&& f.new_sha256 == time.new_time_profile_sha256
|
||||
})
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@ pub mod inventory_document;
|
||||
pub mod jobs;
|
||||
pub mod reconciliation;
|
||||
pub mod windows_echo_probe;
|
||||
pub mod windows_echo_completion;
|
||||
pub mod windows_execution;
|
||||
pub mod windows_sync_history;
|
||||
|
||||
|
||||
@@ -0,0 +1,100 @@
|
||||
//! Retirement of an additional development-only scope after its exact probe.
|
||||
//! This administrative receipt is neither a job approval nor a readiness lease.
|
||||
use crate::{checkpoint_repair::inventory_sha256, windows_echo_probe::ProbeScope};
|
||||
use chrono::{DateTime, Duration, Utc};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use uuid::Uuid;
|
||||
|
||||
pub const DOMAIN: &str = "rmm.dev.windows-echo-completion.v1";
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Witness {
|
||||
pub scope: ProbeScope,
|
||||
pub probe_receipt_id: Uuid,
|
||||
pub probe_receipt_sha256: String,
|
||||
pub probe_signature_sha256: String,
|
||||
pub grant_id: Uuid,
|
||||
pub grant_payload_sha256: String,
|
||||
pub grant_signature_sha256: String,
|
||||
pub outcome_sha256: String,
|
||||
pub boot_id: Uuid,
|
||||
}
|
||||
impl Witness {
|
||||
pub fn digest(&self) -> Option<String> {
|
||||
inventory_sha256(&serde_json::to_value(self).ok()?).ok()
|
||||
}
|
||||
pub fn valid(&self) -> bool {
|
||||
!self.probe_receipt_id.is_nil()
|
||||
&& !self.grant_id.is_nil()
|
||||
&& !self.boot_id.is_nil()
|
||||
&& [
|
||||
&self.probe_receipt_sha256,
|
||||
&self.probe_signature_sha256,
|
||||
&self.grant_payload_sha256,
|
||||
&self.grant_signature_sha256,
|
||||
&self.outcome_sha256,
|
||||
]
|
||||
.iter()
|
||||
.all(|h| {
|
||||
h.len() == 64
|
||||
&& h.bytes()
|
||||
.all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(&c))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Both server result and retained native Outcome use this one comparison.
|
||||
pub fn successful_outcome(v: &Value) -> bool {
|
||||
v["state"] == "succeeded"
|
||||
&& v["exit_code"] == 0
|
||||
&& v["stdout"] == json!(crate::windows_echo_probe::OUTPUT.as_bytes())
|
||||
&& v["stderr"] == json!([])
|
||||
&& v["output_truncated"] == false
|
||||
&& v["reboot_required"] == false
|
||||
&& v["error_code"] == ""
|
||||
&& v["evidence"]["postconditions_passed"] == true
|
||||
&& v["evidence"]["execution_sid"] == "S-1-5-19"
|
||||
&& v["evidence"]["execution_policy_scope"] == "process"
|
||||
&& v["evidence"]["execution_policy_requested"] == "RemoteSigned"
|
||||
&& v["evidence"]["script_sha256"]
|
||||
== crate::jobs::hash(crate::windows_echo_probe::SCRIPT.as_bytes())
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct Receipt {
|
||||
pub domain: String,
|
||||
pub schema_version: u32,
|
||||
pub receipt_id: Uuid,
|
||||
pub witness: Witness,
|
||||
pub witness_sha256: String,
|
||||
pub key_id: String,
|
||||
pub issued_at: DateTime<Utc>,
|
||||
pub valid_until: DateTime<Utc>,
|
||||
pub confirmed_by: String,
|
||||
pub approval_origin: String,
|
||||
pub testsimulation: bool,
|
||||
pub ready: bool,
|
||||
pub helper_ready: bool,
|
||||
pub unlock: bool,
|
||||
}
|
||||
impl Receipt {
|
||||
pub fn valid(&self, now: DateTime<Utc>) -> bool {
|
||||
self.domain == DOMAIN
|
||||
&& self.schema_version == 1
|
||||
&& !self.receipt_id.is_nil()
|
||||
&& self.witness.valid()
|
||||
&& self.witness.digest().as_deref() == Some(self.witness_sha256.as_str())
|
||||
&& self.confirmed_by == crate::windows_echo_probe::TEST_PRINCIPAL
|
||||
&& self.approval_origin == "dev_test_browser_simulation"
|
||||
&& self.testsimulation
|
||||
&& !self.ready
|
||||
&& !self.helper_ready
|
||||
&& !self.unlock
|
||||
&& self.issued_at <= now
|
||||
&& now < self.valid_until
|
||||
&& self.valid_until - self.issued_at <= Duration::minutes(10)
|
||||
}
|
||||
}
|
||||
@@ -372,6 +372,9 @@ impl<'a> FullUpdateGuard<'a> {
|
||||
NativeService::Agent => Service::Agent,
|
||||
NativeService::General => Service::General,
|
||||
NativeService::Full => Service::Full,
|
||||
NativeService::WindowsAgent | NativeService::WindowsHelper => {
|
||||
anyhow::bail!("UPDATE_WINDOWS_SERVICE_ON_LINUX")
|
||||
}
|
||||
};
|
||||
let held = self.services.observe(service, &self.budget)?;
|
||||
held.verify(&self.budget)?;
|
||||
@@ -550,6 +553,9 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
||||
NativeService::Agent => Service::Agent,
|
||||
NativeService::General => Service::General,
|
||||
NativeService::Full => Service::Full,
|
||||
NativeService::WindowsAgent | NativeService::WindowsHelper => {
|
||||
anyhow::bail!("UPDATE_WINDOWS_SERVICE_ON_LINUX")
|
||||
}
|
||||
};
|
||||
self.services
|
||||
.observe(service, &self.budget)?
|
||||
@@ -564,6 +570,9 @@ impl UpdateParticipantGuard for FullUpdateGuard<'_> {
|
||||
NativeService::Agent => Service::Agent,
|
||||
NativeService::General => Service::General,
|
||||
NativeService::Full => Service::Full,
|
||||
NativeService::WindowsAgent | NativeService::WindowsHelper => {
|
||||
anyhow::bail!("UPDATE_WINDOWS_SERVICE_ON_LINUX")
|
||||
}
|
||||
};
|
||||
self.services
|
||||
.observe(service, &self.budget)?
|
||||
|
||||
@@ -28,6 +28,7 @@ mod tls;
|
||||
mod update_artifact_store;
|
||||
mod windows_checkpoint_review;
|
||||
mod windows_echo_probe;
|
||||
mod windows_echo_completion;
|
||||
mod windows_msi_catalog;
|
||||
mod windows_policy;
|
||||
|
||||
@@ -187,6 +188,7 @@ async fn main() -> Result<()> {
|
||||
routes = routes.route("/auth/dev/login", post(auth::login));
|
||||
routes = windows_checkpoint_review::routes(routes);
|
||||
routes = windows_echo_probe::routes(routes);
|
||||
routes = windows_echo_completion::routes(routes);
|
||||
}
|
||||
routes = routes
|
||||
.route("/auth/config", get(auth::configuration))
|
||||
|
||||
@@ -0,0 +1,444 @@
|
||||
//! Interactive retirement of the temporary fixed-probe restriction. Never approves jobs.
|
||||
use crate::{auth::Principal, jobs::Error, windows_checkpoint_review::access};
|
||||
use axum::{
|
||||
Json, Router,
|
||||
extract::{Path, State},
|
||||
http::{HeaderMap, StatusCode},
|
||||
routing::{get, post},
|
||||
};
|
||||
use chrono::{Duration, SubsecRound, Utc};
|
||||
use openssl::{
|
||||
pkey::{Id, PKey},
|
||||
sign::Verifier,
|
||||
};
|
||||
use rmm_domain::{
|
||||
checkpoint_repair::{SignedReceipt, inventory_sha256},
|
||||
jobs::{ExecutionPermitPayload, JobPayload, hash},
|
||||
windows_echo_completion::{DOMAIN, Receipt, Witness, successful_outcome},
|
||||
windows_echo_probe::{AGENT, ASSET, ProbeReceipt, TENANT, TEST_PRINCIPAL},
|
||||
windows_sync_history::case_witness,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::{Postgres, Row, Transaction};
|
||||
use uuid::Uuid;
|
||||
type Result<T> = std::result::Result<T, Error>;
|
||||
fn mismatch() -> Error {
|
||||
Error(StatusCode::CONFLICT, "WINDOWS_ECHO_COMPLETION_MISMATCH")
|
||||
}
|
||||
fn browser(p: &Principal) -> Result<&str> {
|
||||
if p.name != TEST_PRINCIPAL
|
||||
|| p.tenant != TENANT
|
||||
|| !p.testsimulation
|
||||
|| !p.operator
|
||||
|| p.identity.is_some()
|
||||
|| p.scopes.is_some()
|
||||
|| p.csrf.is_none()
|
||||
{
|
||||
return Err(Error(StatusCode::FORBIDDEN, "DEV_TEST_WEBUI_REQUIRED"));
|
||||
}
|
||||
p.session_hash
|
||||
.as_deref()
|
||||
.ok_or(Error(StatusCode::FORBIDDEN, "DEV_TEST_WEBUI_REQUIRED"))
|
||||
}
|
||||
pub fn routes(r: Router<crate::State>) -> Router<crate::State> {
|
||||
r.route(
|
||||
"/api/v1/tenants/{tenant}/windows-echo-completion",
|
||||
get(read),
|
||||
)
|
||||
.route(
|
||||
"/api/v1/tenants/{tenant}/windows-echo-completion/confirm",
|
||||
post(confirm),
|
||||
)
|
||||
.route(
|
||||
"/api/v1/tenants/{tenant}/windows-echo-completion/receipt",
|
||||
get(download),
|
||||
)
|
||||
}
|
||||
fn verify(s: &crate::State, bytes: &[u8], signature: &[u8]) -> Result<()> {
|
||||
let key = PKey::public_key_from_raw_bytes(&s.job_signer.public_key()?, Id::ED25519)
|
||||
.map_err(|_| mismatch())?;
|
||||
if bytes.len() > 65536
|
||||
|| signature.len() != 64
|
||||
|| !Verifier::new_without_digest(&key)
|
||||
.map_err(|_| mismatch())?
|
||||
.verify_oneshot(signature, bytes)
|
||||
.map_err(|_| mismatch())?
|
||||
{
|
||||
return Err(mismatch());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
struct Review {
|
||||
witness: Witness,
|
||||
existing: Option<SignedReceipt>,
|
||||
}
|
||||
impl Review {
|
||||
fn view(&self) -> Value {
|
||||
json!({"witness":self.witness,"witness_sha256":self.witness.digest(),
|
||||
"receipt":self.existing.as_ref().and_then(|s|serde_json::from_slice::<Value>(&s.payload).ok())})
|
||||
}
|
||||
}
|
||||
async fn review(tx: &mut Transaction<'_, Postgres>, s: &crate::State) -> Result<Review> {
|
||||
review_for(tx, s, &case_witness()).await
|
||||
}
|
||||
async fn review_for(
|
||||
tx: &mut Transaction<'_, Postgres>,
|
||||
s: &crate::State,
|
||||
expected: &Value,
|
||||
) -> Result<Review> {
|
||||
crate::agent_service::control_lock(tx, TENANT, AGENT).await?;
|
||||
let dev=sqlx::query("SELECT asset_id,revoked_at IS NULL AS active,enrollment_generation,assignment_version,connection_boot_id,restore_blocked,sequence_regressed,sync_recovery_required FROM agent_installations WHERE tenant_id=$1 AND agent_id=$2 FOR UPDATE")
|
||||
.bind(TENANT).bind(AGENT).fetch_one(&mut **tx).await?;
|
||||
if dev.get::<Uuid, _>("asset_id") != ASSET
|
||||
|| !dev.get::<bool, _>("active")
|
||||
|| dev.get::<i64, _>("enrollment_generation") != 1
|
||||
|| dev.get::<i64, _>("assignment_version") != 1
|
||||
|| dev.get::<bool, _>("restore_blocked")
|
||||
|| dev.get::<bool, _>("sequence_regressed")
|
||||
|| dev.get::<bool, _>("sync_recovery_required")
|
||||
{
|
||||
return Err(mismatch());
|
||||
}
|
||||
let row = sqlx::query(
|
||||
"SELECT receipt,signature,receipt_id FROM windows_echo_probe_scopes WHERE tenant_id=$1",
|
||||
)
|
||||
.bind(TENANT)
|
||||
.fetch_one(&mut **tx)
|
||||
.await?;
|
||||
let raw: Vec<u8> = row.get("receipt");
|
||||
let sig: Vec<u8> = row.get("signature");
|
||||
verify(s, &raw, &sig)?;
|
||||
let probe: ProbeReceipt = serde_json::from_slice(&raw)?;
|
||||
if !probe.matches_reviewed_witness(expected, probe.issued_at)
|
||||
|| probe.receipt_id != row.get::<Uuid, _>("receipt_id")
|
||||
{
|
||||
return Err(mismatch());
|
||||
}
|
||||
let scope = &probe.scope;
|
||||
let job=sqlx::query("SELECT state,payload,payload_hash,result FROM jobs WHERE tenant_id=$1 AND agent_id=$2 AND asset_id=$3 AND job_id=$4 AND attempt_id=$5 AND operation_id=$6 FOR SHARE")
|
||||
.bind(TENANT).bind(AGENT).bind(ASSET).bind(scope.job_id).bind(scope.attempt_id).bind(scope.operation_id).fetch_one(&mut **tx).await?;
|
||||
let mut outcome: Value = job.get::<Option<Value>, _>("result").ok_or_else(mismatch)?;
|
||||
outcome
|
||||
.as_object_mut()
|
||||
.ok_or_else(mismatch)?
|
||||
.remove("grant_id");
|
||||
outcome["state"] = json!(job.get::<String, _>("state"));
|
||||
let job_bytes: Vec<u8> = job.get("payload");
|
||||
let payload: JobPayload = serde_json::from_slice(&job_bytes)?;
|
||||
if job_bytes != probe.job_payload_bytes
|
||||
|| !scope.matches_job(&payload)
|
||||
|| job.get::<String, _>("payload_hash") != scope.job_payload_hash
|
||||
|| !successful_outcome(&outcome)
|
||||
{
|
||||
return Err(mismatch());
|
||||
}
|
||||
let extra: bool = sqlx::query_scalar(
|
||||
"SELECT EXISTS(SELECT FROM jobs WHERE tenant_id=$1 AND agent_id=$2 AND job_id!=$3)",
|
||||
)
|
||||
.bind(TENANT)
|
||||
.bind(AGENT)
|
||||
.bind(scope.job_id)
|
||||
.fetch_one(&mut **tx)
|
||||
.await?;
|
||||
let existing =
|
||||
sqlx::query("SELECT payload,signature FROM windows_echo_completions WHERE tenant_id=$1")
|
||||
.bind(TENANT)
|
||||
.fetch_optional(&mut **tx)
|
||||
.await?;
|
||||
// Only the first transition requires the original single-job inventory.
|
||||
if extra && existing.is_none() {
|
||||
return Err(mismatch());
|
||||
}
|
||||
let grant=sqlx::query("SELECT grant_id,payload,signature FROM execution_permits WHERE tenant_id=$1 AND job_id=$2 AND attempt_id=$3")
|
||||
.bind(TENANT).bind(scope.job_id).bind(scope.attempt_id).fetch_one(&mut **tx).await?;
|
||||
let graw: Vec<u8> = grant.get("payload");
|
||||
let gsig: Vec<u8> = grant.get("signature");
|
||||
verify(s, &graw, &gsig)?;
|
||||
let g: ExecutionPermitPayload = serde_json::from_slice(&graw)?;
|
||||
if g.domain != "rmm.execution-permit"
|
||||
|| g.schema_version != 1
|
||||
|| g.action != "run_script"
|
||||
|| g.agent_update_plan_id.is_some()
|
||||
|| (g.enrollment_generation, g.assignment_version)
|
||||
!= (scope.enrollment_generation, scope.assignment_version)
|
||||
|| g.max_runtime_seconds != scope.max_runtime_seconds
|
||||
|| g.not_before < scope.not_before
|
||||
|| g.start_before > scope.start_before
|
||||
|| g.not_before >= g.start_before
|
||||
|| g.start_before - g.not_before > Duration::seconds(60)
|
||||
|| g.grant_id != grant.get::<Uuid, _>("grant_id")
|
||||
|| g.job_id != scope.job_id
|
||||
|| g.attempt_id != scope.attempt_id
|
||||
|| g.plan_hash != scope.plan_hash
|
||||
|| g.job_payload_hash != scope.job_payload_hash
|
||||
|| g.agent_id != AGENT
|
||||
|| g.tenant_id != TENANT
|
||||
|| g.asset_id != ASSET
|
||||
|| g.execution_identity != "agent_service"
|
||||
|| g.key_id != s.job_signer.key_id
|
||||
|| job.get::<Option<Value>, _>("result").unwrap_or_default()["grant_id"]
|
||||
!= g.grant_id.to_string()
|
||||
{
|
||||
return Err(mismatch());
|
||||
}
|
||||
let authorized:bool=sqlx::query_scalar("SELECT EXISTS(SELECT FROM authorizations WHERE tenant_id=$1 AND authorization_id=$2 AND operation_id=$3 AND plan_id=$4 AND plan_hash=$5 AND principal=$6 AND approval_origin='dev_test_browser_simulation' AND testsimulation AND revoked_at IS NULL)")
|
||||
.bind(TENANT).bind(g.authorization_id).bind(scope.operation_id).bind(scope.plan_id).bind(&scope.plan_hash).bind(TEST_PRINCIPAL).fetch_one(&mut **tx).await?;
|
||||
if !authorized {
|
||||
return Err(mismatch());
|
||||
}
|
||||
let boot: Uuid = serde_json::from_value(expected["boot_id"].clone())?;
|
||||
if dev.get::<Option<Uuid>, _>("connection_boot_id") != Some(boot) {
|
||||
return Err(mismatch());
|
||||
}
|
||||
let witness = Witness {
|
||||
scope: scope.clone(),
|
||||
probe_receipt_id: probe.receipt_id,
|
||||
probe_receipt_sha256: hash(&raw),
|
||||
probe_signature_sha256: hash(&sig),
|
||||
grant_id: g.grant_id,
|
||||
grant_payload_sha256: hash(&graw),
|
||||
grant_signature_sha256: hash(&gsig),
|
||||
outcome_sha256: inventory_sha256(&outcome)?,
|
||||
boot_id: boot,
|
||||
};
|
||||
let existing = existing.map(|r| SignedReceipt {
|
||||
payload: r.get("payload"),
|
||||
signature: r.get("signature"),
|
||||
});
|
||||
if let Some(signed) = &existing {
|
||||
verify(s, &signed.payload, &signed.signature)?;
|
||||
let r: Receipt = serde_json::from_slice(&signed.payload)?;
|
||||
if !r.valid(r.issued_at) || r.witness != witness || r.key_id != s.job_signer.key_id {
|
||||
return Err(mismatch());
|
||||
}
|
||||
}
|
||||
Ok(Review { witness, existing })
|
||||
}
|
||||
async fn read(
|
||||
State(s): State<crate::State>,
|
||||
Path(t): Path<Uuid>,
|
||||
h: HeaderMap,
|
||||
) -> Result<Json<Value>> {
|
||||
let p = access(&s, &h, t, false).await?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
|
||||
crate::permissions::require_principal(&mut tx, &p, "operations:read").await?;
|
||||
let result = review(&mut tx, &s).await?.view();
|
||||
tx.commit().await?;
|
||||
Ok(Json(result))
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
struct Confirmation {
|
||||
reviewed: bool,
|
||||
witness_sha256: String,
|
||||
}
|
||||
async fn confirm(
|
||||
State(s): State<crate::State>,
|
||||
Path(t): Path<Uuid>,
|
||||
h: HeaderMap,
|
||||
Json(input): Json<Confirmation>,
|
||||
) -> Result<Json<Value>> {
|
||||
let p = access(&s, &h, t, true).await?;
|
||||
confirm_review(&s, &p, input, &case_witness()).await
|
||||
}
|
||||
async fn confirm_review(
|
||||
s: &crate::State,
|
||||
p: &Principal,
|
||||
input: Confirmation,
|
||||
expected: &Value,
|
||||
) -> Result<Json<Value>> {
|
||||
let t = p.tenant;
|
||||
let session = browser(p)?;
|
||||
if !input.reviewed {
|
||||
return Err(Error(StatusCode::BAD_REQUEST, "REVIEW_REQUIRED"));
|
||||
}
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
|
||||
let allowed: bool = sqlx::query_scalar("SELECT lock_windows_echo_probe_reviewer()")
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if !allowed {
|
||||
return Err(Error(StatusCode::FORBIDDEN, "DEV_TEST_WEBUI_REQUIRED"));
|
||||
}
|
||||
let mut r = review_for(&mut tx, s, expected).await?;
|
||||
if r.witness.digest().as_deref() != Some(input.witness_sha256.as_str()) {
|
||||
return Err(mismatch());
|
||||
}
|
||||
if r.existing.is_none() {
|
||||
// SQLx binds PostgreSQL timestamps at microsecond precision. Normalize
|
||||
// before signing so JSON's parser cannot round a nanosecond differently.
|
||||
let now = Utc::now().trunc_subsecs(6);
|
||||
let receipt = Receipt {
|
||||
domain: DOMAIN.into(),
|
||||
schema_version: 1,
|
||||
receipt_id: Uuid::new_v4(),
|
||||
witness: r.witness.clone(),
|
||||
witness_sha256: input.witness_sha256,
|
||||
key_id: s.job_signer.key_id.clone(),
|
||||
issued_at: now,
|
||||
valid_until: now + Duration::minutes(10),
|
||||
confirmed_by: p.name.clone(),
|
||||
approval_origin: p.approval_origin().into(),
|
||||
testsimulation: true,
|
||||
ready: false,
|
||||
helper_ready: false,
|
||||
unlock: false,
|
||||
};
|
||||
if !receipt.valid(now) {
|
||||
return Err(mismatch());
|
||||
}
|
||||
let raw = serde_json::to_vec(&receipt)?;
|
||||
let signature = s.job_signer.sign(&raw)?;
|
||||
sqlx::query("INSERT INTO windows_echo_completions(tenant_id,receipt_id,witness_sha256,payload,signature,confirmed_by,session_hash,issued_at,valid_until) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9)")
|
||||
.bind(t).bind(receipt.receipt_id).bind(&receipt.witness_sha256).bind(&raw).bind(&signature).bind(&p.name).bind(session).bind(now).bind(receipt.valid_until).execute(&mut *tx).await?;
|
||||
sqlx::query("INSERT INTO audit_events(tenant_id,event_id,principal,event_type,data) VALUES($1,$2,$3,'windows_echo_scope_completed',$4)")
|
||||
.bind(t).bind(receipt.receipt_id).bind(&p.name).bind(json!({"witness":receipt.witness,"witness_sha256":receipt.witness_sha256,
|
||||
"receipt_sha256":hash(&raw),"approval_origin":receipt.approval_origin,"testsimulation":true,"ready":false,"helper_ready":false,"unlock":false})).execute(&mut *tx).await?;
|
||||
r.existing = Some(SignedReceipt {
|
||||
payload: raw,
|
||||
signature,
|
||||
});
|
||||
}
|
||||
tx.commit().await?;
|
||||
Ok(Json(r.view()))
|
||||
}
|
||||
async fn download(
|
||||
State(s): State<crate::State>,
|
||||
Path(t): Path<Uuid>,
|
||||
h: HeaderMap,
|
||||
) -> Result<Json<SignedReceipt>> {
|
||||
let p = access(&s, &h, t, false).await?;
|
||||
browser(&p)?;
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?;
|
||||
crate::permissions::require_principal(&mut tx, &p, "plans:approve").await?;
|
||||
let signed = review(&mut tx, &s)
|
||||
.await?
|
||||
.existing
|
||||
.ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?;
|
||||
let r: Receipt = serde_json::from_slice(&signed.payload)?;
|
||||
if !r.valid(Utc::now()) {
|
||||
return Err(Error(
|
||||
StatusCode::CONFLICT,
|
||||
"WINDOWS_ECHO_COMPLETION_EXPIRED",
|
||||
));
|
||||
}
|
||||
tx.commit().await?;
|
||||
Ok(Json(signed))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(super) async fn test_completed_echo(
|
||||
admin: &sqlx::PgPool,
|
||||
s: &crate::State,
|
||||
p: &Principal,
|
||||
expected: &Value,
|
||||
) {
|
||||
let nanosecond = chrono::DateTime::from_timestamp(1794820000, 123456789).unwrap();
|
||||
let compare = |t: chrono::DateTime<Utc>| {
|
||||
sqlx::query_scalar::<_, bool>("SELECT $1::timestamptz=$2::text::timestamptz")
|
||||
.bind(t)
|
||||
.bind(t.to_rfc3339())
|
||||
};
|
||||
assert!(!compare(nanosecond).fetch_one(admin).await.unwrap());
|
||||
assert!(
|
||||
compare(nanosecond.trunc_subsecs(6))
|
||||
.fetch_one(admin)
|
||||
.await
|
||||
.unwrap()
|
||||
);
|
||||
let row =
|
||||
sqlx::query("SELECT job_id,attempt_id,grant_id FROM execution_permits WHERE tenant_id=$1")
|
||||
.bind(TENANT)
|
||||
.fetch_one(admin)
|
||||
.await
|
||||
.unwrap();
|
||||
let grant: Uuid = row.get("grant_id");
|
||||
let job: Uuid = row.get("job_id");
|
||||
let original_counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM jobs),(SELECT count(*) FROM authorizations),(SELECT count(*) FROM execution_permits)").fetch_one(admin).await.unwrap();
|
||||
let confirm = |digest: String| Confirmation {
|
||||
reviewed: true,
|
||||
witness_sha256: digest,
|
||||
};
|
||||
assert!(
|
||||
confirm_review(s, p, confirm("0".repeat(64)), expected)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
let mut no_browser = p.clone();
|
||||
no_browser.session_hash = None;
|
||||
assert_eq!(
|
||||
confirm_review(s, &no_browser, confirm("0".repeat(64)), expected)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.0,
|
||||
StatusCode::FORBIDDEN
|
||||
);
|
||||
let outcome = json!({"exit_code":0,"stdout":rmm_domain::windows_echo_probe::OUTPUT.as_bytes(),"stderr":[],"error_code":"","output_truncated":false,"reboot_required":false,
|
||||
"evidence":{"execution_sid":"S-1-5-19","execution_policy_scope":"process","execution_policy_requested":"RemoteSigned","postconditions_passed":true,
|
||||
"script_sha256":hash(rmm_domain::windows_echo_probe::SCRIPT.as_bytes())},"grant_id":grant});
|
||||
sqlx::query("UPDATE jobs SET state='succeeded',result=$2 WHERE job_id=$1")
|
||||
.bind(job)
|
||||
.bind(outcome)
|
||||
.execute(admin)
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("UPDATE agent_installations SET restore_blocked=false WHERE agent_id=$1")
|
||||
.bind(AGENT)
|
||||
.execute(admin)
|
||||
.await
|
||||
.unwrap();
|
||||
let mut tx = rmm_persistence::tenant_tx(&s.pool, TENANT).await.unwrap();
|
||||
let r = review_for(&mut tx, s, expected).await.unwrap();
|
||||
tx.rollback().await.unwrap();
|
||||
let digest = r.witness.digest().unwrap();
|
||||
assert!(
|
||||
confirm_review(s, p, confirm("0".repeat(64)), expected)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
let first = confirm_review(s, p, confirm(digest.clone()), expected)
|
||||
.await
|
||||
.unwrap()
|
||||
.0;
|
||||
assert_eq!(first["receipt"]["ready"], false);
|
||||
assert_eq!(first["receipt"]["helper_ready"], false);
|
||||
assert_eq!(first["receipt"]["unlock"], false);
|
||||
assert_eq!(first["receipt"]["testsimulation"], true);
|
||||
assert_eq!(
|
||||
confirm_review(s, p, confirm(digest), expected)
|
||||
.await
|
||||
.unwrap()
|
||||
.0,
|
||||
first
|
||||
);
|
||||
let counts:(i64,i64,i64)=sqlx::query_as("SELECT (SELECT count(*) FROM jobs),(SELECT count(*) FROM authorizations),(SELECT count(*) FROM execution_permits)").fetch_one(admin).await.unwrap();
|
||||
assert_eq!(counts, original_counts);
|
||||
assert!(
|
||||
sqlx::query("DELETE FROM windows_echo_completions")
|
||||
.execute(admin)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert!(
|
||||
sqlx::query("UPDATE windows_echo_completions SET witness_sha256=repeat('0',64)")
|
||||
.execute(admin)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(
|
||||
sqlx::query_scalar::<_, i64>("SELECT count(*) FROM windows_echo_probe_scopes")
|
||||
.fetch_one(admin)
|
||||
.await
|
||||
.unwrap(),
|
||||
1
|
||||
);
|
||||
assert_eq!(
|
||||
sqlx::query_scalar::<_, i64>(
|
||||
"SELECT count(*) FROM audit_events WHERE event_type='windows_echo_scope_completed'"
|
||||
)
|
||||
.fetch_one(admin)
|
||||
.await
|
||||
.unwrap(),
|
||||
1
|
||||
);
|
||||
}
|
||||
@@ -515,4 +515,5 @@ pub(super) async fn test_fixed_echo(
|
||||
tx.rollback().await.unwrap();
|
||||
}
|
||||
}
|
||||
crate::windows_echo_completion::test_completed_echo(admin,s,&p,&w).await;
|
||||
}
|
||||
|
||||
@@ -67,6 +67,7 @@ pub enum PinTransition {
|
||||
UnchangedLinuxGeneralV1,
|
||||
LinuxGeneralFullV1,
|
||||
WindowsCodePairV1,
|
||||
WindowsCodePairClockV1,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -78,6 +79,7 @@ pub enum FileRole {
|
||||
LinuxFullPin,
|
||||
WindowsSettings,
|
||||
WindowsPin,
|
||||
WindowsTimeProfile,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||
@@ -197,6 +199,13 @@ impl Handoff {
|
||||
FileRole::WindowsSettings,
|
||||
FileRole::WindowsPin,
|
||||
],
|
||||
PinTransition::WindowsCodePairClockV1 => vec![
|
||||
FileRole::AgentBinary,
|
||||
FileRole::HelperBinary,
|
||||
FileRole::WindowsSettings,
|
||||
FileRole::WindowsPin,
|
||||
FileRole::WindowsTimeProfile,
|
||||
],
|
||||
};
|
||||
ensure!(roles == expected_roles, "HANDOFF_FILE_SET");
|
||||
for file in &self.files {
|
||||
@@ -210,7 +219,7 @@ impl Handoff {
|
||||
&& self.files[1].new_sha256 == self.target.helper_sha256,
|
||||
"HANDOFF_FILE_IMAGE_BINDING"
|
||||
);
|
||||
if self.files.len() == 4 {
|
||||
if self.files.len() >= 4 {
|
||||
ensure!(
|
||||
self.files[3].old_sha256 == self.predecessor.pin_sha256
|
||||
&& self.files[3].new_sha256 == self.target.pin_sha256,
|
||||
@@ -250,7 +259,7 @@ impl Handoff {
|
||||
],
|
||||
"HANDOFF_UNSUPPORTED_SERVICE_SET"
|
||||
),
|
||||
PinTransition::WindowsCodePairV1 => ensure!(
|
||||
PinTransition::WindowsCodePairV1 | PinTransition::WindowsCodePairClockV1 => ensure!(
|
||||
self.stop_set == [Service::WindowsAgent, Service::WindowsHelper],
|
||||
"HANDOFF_UNSUPPORTED_SERVICE_SET"
|
||||
),
|
||||
|
||||
@@ -96,6 +96,31 @@ fn handoff() -> Handoff {
|
||||
fn key() -> SigningKey {
|
||||
SigningKey::from_bytes(&[73; 32])
|
||||
}
|
||||
#[test]
|
||||
fn windows_clock_transition_keeps_historical_four_file_shape_and_requires_exact_new_fifth_role() {
|
||||
let mut value = handoff();
|
||||
value.pin_transition = PinTransition::WindowsCodePairV1;
|
||||
value.stop_set = vec![Service::WindowsAgent, Service::WindowsHelper];
|
||||
value.files[2].role = FileRole::WindowsSettings;
|
||||
value.files[3].role = FileRole::WindowsPin;
|
||||
value.validate().unwrap();
|
||||
let old = value.bytes().unwrap();
|
||||
value.pin_transition = PinTransition::WindowsCodePairClockV1;
|
||||
assert!(value.validate().is_err());
|
||||
value.files.push(FileTransition {
|
||||
role: FileRole::WindowsTimeProfile,
|
||||
old_sha256: h(23),
|
||||
new_sha256: h(24),
|
||||
});
|
||||
value.validate().unwrap();
|
||||
value.files[3].new_sha256 = h(25);
|
||||
assert!(value.validate().is_err());
|
||||
value.files[3].new_sha256 = value.target.pin_sha256.clone();
|
||||
value.files.swap(3, 4);
|
||||
assert!(value.validate().is_err());
|
||||
let historical: Handoff = serde_json::from_slice(&old).unwrap();
|
||||
assert_eq!(historical.bytes().unwrap(), old);
|
||||
}
|
||||
fn open(handoff: &Handoff) -> Journal {
|
||||
Journal::open(&handoff.bytes().unwrap(), key().verifying_key().to_bytes()).unwrap()
|
||||
}
|
||||
|
||||
@@ -614,6 +614,9 @@ fn complete_native_history(
|
||||
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)
|
||||
}
|
||||
@@ -682,6 +685,9 @@ fn complete_native_history(
|
||||
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))?
|
||||
}
|
||||
|
||||
@@ -37,6 +37,9 @@ fn file_role(role: NativeFileRole) -> rmm_updater_handoff::FileRole {
|
||||
NativeFileRole::HelperBinary => rmm_updater_handoff::FileRole::HelperBinary,
|
||||
NativeFileRole::FullConfig => rmm_updater_handoff::FileRole::LinuxFullConfig,
|
||||
NativeFileRole::FullPin => rmm_updater_handoff::FileRole::LinuxFullPin,
|
||||
NativeFileRole::WindowsSettings => rmm_updater_handoff::FileRole::WindowsSettings,
|
||||
NativeFileRole::WindowsPin => rmm_updater_handoff::FileRole::WindowsPin,
|
||||
NativeFileRole::WindowsTimeProfile => rmm_updater_handoff::FileRole::WindowsTimeProfile,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -189,6 +192,10 @@ impl<'a, 'stopped> OwnedLedger<'a, 'stopped> {
|
||||
update_handoff::NativeService::Full => {
|
||||
rmm_updater_linux::services::Service::Full
|
||||
}
|
||||
update_handoff::NativeService::WindowsAgent
|
||||
| update_handoff::NativeService::WindowsHelper => {
|
||||
anyhow::bail!("UPDATE_WINDOWS_SERVICE_ON_LINUX")
|
||||
}
|
||||
};
|
||||
let proof = self
|
||||
.guard
|
||||
@@ -463,6 +470,9 @@ impl UpdateParticipantGuard for OwnedGuard<'_, '_> {
|
||||
NativeFileRole::HelperBinary => rmm_updater_handoff::FileRole::HelperBinary,
|
||||
NativeFileRole::FullConfig => rmm_updater_handoff::FileRole::LinuxFullConfig,
|
||||
NativeFileRole::FullPin => rmm_updater_handoff::FileRole::LinuxFullPin,
|
||||
NativeFileRole::WindowsSettings => rmm_updater_handoff::FileRole::WindowsSettings,
|
||||
NativeFileRole::WindowsPin => rmm_updater_handoff::FileRole::WindowsPin,
|
||||
NativeFileRole::WindowsTimeProfile => rmm_updater_handoff::FileRole::WindowsTimeProfile,
|
||||
};
|
||||
match (effect, stage) {
|
||||
(NativeEffect::StopService { .. }, NativeEffectStage::Observe) => {
|
||||
|
||||
Reference in New Issue
Block a user