//! Exact connection-221 interactive administrative closure. No job/readiness writes. 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 prost::Message; use rmm_domain::{ checkpoint_repair::{SignedReceipt, inventory_sha256}, jobs::{ExecutionPermitPayload, JobPayload, PlanPayload, encode, hash}, reconciliation::ReconcileDecisionPayload, windows_echo_probe::{AGENT, ASSET, TENANT, TEST_PRINCIPAL}, windows_system_nonstart::{self as profile, Receipt, Witness}, }; use rmm_protocol::{JobOffer, SyncRequest}; use serde::Deserialize; use serde_json::{Value, json}; use sqlx::{Postgres, Row, Transaction}; use uuid::Uuid; type Result = std::result::Result; fn mismatch() -> Error { Error(StatusCode::CONFLICT, "WINDOWS_SYSTEM_NONSTART_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) -> Router { r.route( "/api/v1/tenants/{tenant}/windows-system-nonstart-221", get(read).post(submit), ) .route( "/api/v1/tenants/{tenant}/windows-system-nonstart-221/{request}/confirm", post(confirm), ) .route( "/api/v1/tenants/{tenant}/windows-system-nonstart-221/{request}/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() > profile::MAX_WITNESS_BYTES + 8192 || signature.len() != 64 || !Verifier::new_without_digest(&key) .map_err(|_| mismatch())? .verify_oneshot(signature, bytes) .map_err(|_| mismatch())? { return Err(mismatch()); } Ok(()) } const JOB: Uuid = Uuid::from_u128(0x940478735088433bbc1b490d3eafe0da); const ATTEMPT: Uuid = Uuid::from_u128(0xf071e6d6863542f792fa533c681edd8b); const GRANT: Uuid = Uuid::from_u128(0x97e705b8fb2b415884d9d90595d1ce6e); const FIRST: Uuid = Uuid::from_u128(0x193b951ba3aa46e29f481a57f315078e); const SECOND: Uuid = Uuid::from_u128(0x0442c73282264c2596157f007e24b269); const BOOT: Uuid = Uuid::from_u128(0xa9ad08955a968f2c8fb6cfdc2d5225ea); const UNKNOWN_SHA: &str = "1f284b66578d61c4364cc0060a67ce9b467e1d661ed8885804391b51a6f18b1a"; #[derive(Deserialize, serde::Serialize)] #[serde(deny_unknown_fields)] struct OriginalRequest { job_bytes: Vec, permit_bytes: Vec, signature: Vec, plan_hash: String, authorization_id: Uuid, } fn original(w: &Witness, i: usize) -> Result<(SyncRequest, ReconcileDecisionPayload)> { let raw = &w.original_requests[i]; let r = SyncRequest::decode(raw.as_slice()).map_err(|_| mismatch())?; let d: ReconcileDecisionPayload = serde_json::from_slice(&w.original_responses[i].decision_bytes)?; let (id, rid, cp, hcp) = if i == 0 { ( FIRST, Uuid::from_u128(0xf07ea08e84f248f484766921057db9af), 10783, 412, ) } else { ( SECOND, Uuid::from_u128(0x09952f6d45f3433082f387ebf363eb3b), 10784, 413, ) }; if r.encode_to_vec() != *raw || r.request_id != rid.to_string() || r.journal_id != w.agent_journal_id.to_string() || r.helper_journal_id != w.helper_journal_id.to_string() || r.assignment_version != 1 || r.checkpoint != cp || r.helper_checkpoint != hcp || !r.journal_complete || (i == 1 && r.previous_decision_id != FIRST.to_string()) || !d.valid_profile(d.issued_at) || d.decision_id != id || d.request_id != rid || d.request_hash != hash(raw) || (d.tenant_id, d.asset_id, d.agent_id) != (TENANT, ASSET, AGENT) || d.enrollment_generation != 1 || d.assignment_version != 1 || d.boot_id != BOOT || d.connection_generation != 221 || d.journal_id != w.agent_journal_id || d.helper_journal_id != Some(w.helper_journal_id) || d.checkpoint != cp || d.helper_checkpoint != hcp || d.key_id != w.verification_key_id || !d.attempts.iter().any(|a| { a.job_id == JOB && a.attempt_id == ATTEMPT && a.grant_id == Some(GRANT) && a.outcome_state == "unknown" && !a.unlock }) || d.attempts.iter().any(|a| a.update_inflight.is_some()) { return Err(mismatch()); } Ok((r, d)) } async fn validate( tx: &mut Transaction<'_, Postgres>, s: &crate::State, w: &Witness, expected_transport: Option, ) -> Result { if !w.valid() || w.verification_key_id != s.job_signer.key_id || hex::encode(s.job_signer.public_key()?) != w.verification_public_key_hex { return Err(mismatch()); } crate::agent_service::control_lock(tx, TENANT, AGENT).await?; let dev=sqlx::query("SELECT asset_id,enrollment_generation,assignment_version,connection_generation,connection_boot_id,revoked_at,sequence_regressed,sync_recovery_required,restore_blocked 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::("asset_id") != ASSET || dev.get::("enrollment_generation") != 1 || dev.get::("assignment_version") != 1 || dev.get::("connection_generation") < 221 || expected_transport.is_some_and(|g| dev.get::("connection_generation") != g) || dev.get::, _>("connection_boot_id") != Some(BOOT) || dev .get::>, _>("revoked_at") .is_some() || dev.get::("sequence_regressed") || dev.get::("sync_recovery_required") || !dev.get::("restore_blocked") { return Err(mismatch()); } let state=sqlx::query("SELECT journal_id,checkpoint,decision_id,helper_journal_id,helper_checkpoint FROM agent_sync_state WHERE tenant_id=$1 AND agent_id=$2 FOR SHARE").bind(TENANT).bind(AGENT).fetch_one(&mut **tx).await?; if state.get::("journal_id") != w.agent_journal_id || state.get::("checkpoint") != 10784 || state.get::("decision_id") != SECOND || state.get::, _>("helper_journal_id") != Some(w.helper_journal_id) || state.get::("helper_checkpoint") != 413 { return Err(mismatch()); } for i in 0..2 { let (r, d) = original(w, i)?; verify( s, &w.original_responses[i].decision_bytes, &w.original_responses[i].signature, )?; let row=sqlx::query("SELECT request_hash,journal_id,checkpoint,connection_generation,payload,signature FROM sync_checkpoints WHERE tenant_id=$1 AND agent_id=$2 AND decision_id=$3 AND request_id=$4").bind(TENANT).bind(AGENT).bind(d.decision_id).bind(d.request_id).fetch_one(&mut **tx).await?; if row.get::("request_hash") != hash(&r.encode_to_vec()) || row.get::("journal_id") != w.agent_journal_id || row.get::("checkpoint") != i64::try_from(d.checkpoint).map_err(|_| mismatch())? || row.get::("connection_generation") != 221 || row.get::, _>("payload") != w.original_responses[i].decision_bytes || row.get::, _>("signature") != w.original_responses[i].signature { return Err(mismatch()); } } validate_job(tx, s, w).await?; Ok(dev.get::("connection_generation")) } async fn validate_job( tx: &mut Transaction<'_, Postgres>, s: &crate::State, w: &Witness, ) -> Result<()> { let jobs=sqlx::query("SELECT job_id,attempt_id,state FROM jobs WHERE tenant_id=$1 AND agent_id=$2 ORDER BY job_id FOR SHARE").bind(TENANT).bind(AGENT).fetch_all(&mut **tx).await?; let expected = [ ( "0a50aae9-a784-4535-b62f-ef24c301d546", "78295f74-4565-459a-87b0-641a8b95feec", "expired", ), ( "5f1ffef4-2bb6-4c7e-a3a0-fb619144b4f8", "ebb387cf-ebb1-4609-a318-32f44d774d11", "succeeded", ), ( "645ad11b-9ecd-4efe-8f92-8ad2fb6ed5cf", "e2ee25cd-0e23-4c3c-aaa2-3048d232622a", "succeeded", ), ( "94047873-5088-433b-bc1b-490d3eafe0da", "f071e6d6-8635-42f7-92fa-533c681edd8b", "unknown", ), ]; if jobs.len() != 4 || jobs.iter().zip(expected).any(|(r, (j, a, state))| { r.get::("job_id").to_string() != j || r.get::("attempt_id").to_string() != a || r.get::("state") != state }) { return Err(mismatch()); } let n:i64=sqlx::query_scalar("SELECT count(*) FROM execution_permits p JOIN jobs j ON j.tenant_id=p.tenant_id AND j.job_id=p.job_id WHERE j.tenant_id=$1 AND j.agent_id=$2").bind(TENANT).bind(AGENT).fetch_one(&mut **tx).await?; if n != 3 { return Err(mismatch()); } let row=sqlx::query("SELECT j.operation_id,j.asset_id,j.payload,j.payload_hash,j.start_reserved,j.cancel_requested,j.result,a.authorization_id,p.payload AS plan_payload,p.plan_hash FROM jobs j JOIN authorizations a ON a.tenant_id=j.tenant_id AND a.operation_id=j.operation_id JOIN operation_plans p ON p.tenant_id=a.tenant_id AND p.plan_id=a.plan_id AND p.plan_hash=a.plan_hash WHERE j.tenant_id=$1 AND j.agent_id=$2 AND j.job_id=$3 AND j.attempt_id=$4 AND a.revoked_at IS NULL AND a.principal=$5 AND a.approval_origin='dev_test_browser_simulation' AND a.testsimulation FOR SHARE OF j,a").bind(TENANT).bind(AGENT).bind(JOB).bind(ATTEMPT).bind(TEST_PRINCIPAL).fetch_one(&mut **tx).await?; let offer = JobOffer::decode(w.target_job_offer.as_slice()).map_err(|_| mismatch())?; let job: JobPayload = serde_json::from_slice(&offer.payload_bytes)?; let plan_raw: Vec = row.get("plan_payload"); let plan: PlanPayload = serde_json::from_slice(&plan_raw)?; if offer.encode_to_vec() != w.target_job_offer || offer.job_id != JOB.to_string() || offer.attempt_id != ATTEMPT.to_string() || row.get::("operation_id") != Uuid::from_u128(0xce1b969b66b24548a28c7e81943507c4) || row.get::("asset_id") != ASSET || !row.get::("start_reserved") || row.get::("cancel_requested") || row.get::, _>("payload") != offer.payload_bytes || row.get::("payload_hash") != hash(&offer.payload_bytes) || offer.job_payload_hash != hash(&offer.payload_bytes) || offer.authorization_id != row.get::("authorization_id").to_string() || offer.plan_hash != row.get::("plan_hash") || offer.plan_hash != "9afc2bacefd937199bf6407c12b1f7c5cad933cd875514f651afcca9eb9fae43" || hash(&plan_raw) != offer.plan_hash || encode(&plan)? != plan_raw || plan.tenant_id != TENANT || plan.jobs.len() != 1 || plan.jobs[0].payload != job || plan.jobs[0].job_payload_hash != offer.job_payload_hash || ( job.tenant_id, job.asset_id, job.agent_id, job.job_id, job.attempt_id, ) != (TENANT, ASSET, AGENT, JOB, ATTEMPT) || job.enrollment_generation != 1 || job.assignment_version != 1 || job.execution_identity != "system" { return Err(mismatch()); } let rmm_domain::jobs::Action::RunScript { script_utf8, .. } = &job.action else { return Err(mismatch()); }; if hash(script_utf8.as_bytes()) != "880930d2b5d903a8ee8f4a9d3acad6162ef994b1822d7381c8468230bcf4a86c" { 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(JOB).bind(ATTEMPT).fetch_one(&mut **tx).await?; let raw: Vec = grant.get("payload"); let signature: Vec = grant.get("signature"); verify(s, &raw, &signature)?; let g: ExecutionPermitPayload = serde_json::from_slice(&raw)?; if g.grant_id != GRANT || grant.get::("grant_id") != GRANT || g.key_id != w.verification_key_id || (g.tenant_id, g.asset_id, g.agent_id, g.job_id, g.attempt_id) != (TENANT, ASSET, AGENT, JOB, ATTEMPT) || g.enrollment_generation != 1 || g.assignment_version != 1 || g.execution_identity != "system" || g.action != "run_script" || g.agent_update_plan_id.is_some() || g.job_payload_hash != offer.job_payload_hash || g.plan_hash != offer.plan_hash || g.authorization_id.to_string() != offer.authorization_id { return Err(mismatch()); } for (start, known) in [ ( &w.agent_start, "f6134c00143b0939a92d2690b8c3a034d332d47241c65a812dcf8f78ead9cfcc", ), ( &w.helper_start, "cf83fc9acbfc1429cca452498c44282f7748d852d73b8221bc0721af60e276d9", ), ] { let value: Value = serde_json::from_slice(start)?; let request: OriginalRequest = serde_json::from_value(value["request"].clone())?; if hash(start) != known || hash(&serde_json::to_vec(&request)?) != "09aa6be3617017e4169f9d83fbfc4cbef43712513a02229a8360dd6a708ee69c" || request.job_bytes != offer.payload_bytes || request.permit_bytes != raw || request.signature != signature || request.plan_hash != offer.plan_hash || request.authorization_id != g.authorization_id { return Err(mismatch()); } } for raw in [&w.agent_outcome, &w.helper_outcome] { let outcome: Value = serde_json::from_slice(raw)?; if hash(raw) != UNKNOWN_SHA || outcome["state"] != "unknown" || outcome["error_code"] != "SYSTEM_SCRIPT_EFFECT_UNRESOLVED" || outcome["exit_code"] != Value::Null || outcome["stdout"] != json!([]) || outcome["stderr"] != json!([]) || outcome["output_truncated"] != false || outcome["reboot_required"] != false || outcome["evidence"] != json!({"postconditions_passed":false}) { return Err(mismatch()); } } if hash(&w.intent) != "31c9ddc35a7c09de9e8ec75c835e3dca9e8a816bc031b4b1c1396bd3a2ea46df" || w.nonstart.helper_pid != 1304 || w.nonstart.helper_image_sha256 != "0502d6c87bd74c99f1665f3cc4b9d74b8e31d0f829d2ce1a1597d72e9be1e726" || w.nonstart.system_script_source_sha256 != "a3563e1aa8327b2e7046c7cdfb4f45ac213fec6ff7d477820ea2676a266c1695" || w.nonstart.read_share_error != 32 || !w.nonstart.read_write_share_passed { return Err(mismatch()); } let result: Value = row.get::, _>("result").ok_or_else(mismatch)?; if result["grant_id"] != GRANT.to_string() || result["stdout"] != json!([]) || result["stderr"] != json!([]) || result["exit_code"] != Value::Null || result["error_code"] != "SYNC_EFFECT_UNRESOLVED" || result["source_id"] != "authoritative_sync" { return Err(mismatch()); } Ok(()) } async fn stored(tx: &mut Transaction<'_, Postgres>) -> Result> { let row = sqlx::query( "SELECT request_id,witness,server_transport_generation FROM windows_system_nonstart_reviews WHERE tenant_id=$1", ) .bind(TENANT) .fetch_optional(&mut **tx) .await?; row.map(|r| { Ok(( r.get("request_id"), serde_json::from_value(r.get("witness"))?, r.get("server_transport_generation"), )) }) .transpose() } async fn view(tx: &mut Transaction<'_, Postgres>, id: Uuid, w: &Witness) -> Result { let row=sqlx::query("SELECT payload FROM windows_system_nonstart_receipts WHERE tenant_id=$1 AND request_id=$2 ORDER BY issued_at DESC,receipt_id DESC LIMIT 1").bind(TENANT).bind(id).fetch_optional(&mut **tx).await?; let receipt = row .map(|r| serde_json::from_slice::(&r.get::, _>("payload"))) .transpose()?; let transport:i64=sqlx::query_scalar("SELECT server_transport_generation FROM windows_system_nonstart_reviews WHERE tenant_id=$1 AND request_id=$2").bind(TENANT).bind(id).fetch_one(&mut **tx).await?; Ok( json!({"request_id":id,"witness":w,"witness_sha256":w.digest(),"server_transport_generation":transport,"receipt":receipt}), ) } async fn read( State(s): State, Path(t): Path, h: HeaderMap, ) -> Result> { 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, "inventory:read").await?; let result = if let Some((id, w, transport)) = stored(&mut tx).await? { validate(&mut tx, &s, &w, Some(transport)).await?; view(&mut tx, id, &w).await? } else { json!({"request_id":null}) }; tx.commit().await?; Ok(Json(result)) } async fn submit( State(s): State, Path(t): Path, h: HeaderMap, Json(w): Json, ) -> Result> { let p = access(&s, &h, t, true).await?; browser(&p)?; let mut tx = rmm_persistence::tenant_tx(&s.pool, t).await?; crate::permissions::require_principal(&mut tx, &p, "inventory:read").await?; let transport = validate(&mut tx, &s, &w, None).await?; let id = if let Some((id, old, old_transport)) = stored(&mut tx).await? { if old != w || old_transport != transport { return Err(mismatch()); } id } else { let id = Uuid::new_v4(); let digest = w.digest().ok_or_else(mismatch)?; sqlx::query("INSERT INTO windows_system_nonstart_reviews(tenant_id,request_id,agent_id,witness,witness_sha256,submitted_by,server_transport_generation) VALUES($1,$2,$3,$4,$5,$6,$7)").bind(t).bind(id).bind(AGENT).bind(serde_json::to_value(&w)?).bind(&digest).bind(&p.name).bind(transport).execute(&mut *tx).await?; sqlx::query("INSERT INTO audit_events(tenant_id,event_id,principal,event_type,data) VALUES($1,$2,$3,'windows_system_nonstart_submitted',$4)").bind(t).bind(id).bind(&p.name).bind(json!({"witness_sha256":digest,"connection_generation":221,"server_transport_generation":transport,"job_id":JOB,"attempt_id":ATTEMPT,"grant_id":GRANT,"approval_origin":p.approval_origin(),"testsimulation":true,"ready":false,"helper_ready":false,"unlock":false})).execute(&mut *tx).await?; id }; let result = view(&mut tx, id, &w).await?; 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, Path((t, id)): Path<(Uuid, Uuid)>, h: HeaderMap, Json(input): Json, ) -> Result> { let p = access(&s, &h, t, true).await?; 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 (actual, w, transport) = stored(&mut tx) .await? .ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?; if actual != id || w.digest().as_deref() != Some(input.witness_sha256.as_str()) { return Err(mismatch()); } validate(&mut tx, &s, &w, Some(transport)).await?; let now = Utc::now().trunc_subsecs(6); let original=sqlx::query("SELECT state,revision,result FROM jobs WHERE tenant_id=$1 AND agent_id=$2 AND job_id=$3 AND attempt_id=$4 FOR SHARE").bind(t).bind(AGENT).bind(JOB).bind(ATTEMPT).fetch_one(&mut *tx).await?; let original_state: String = original.get("state"); let original_revision: i64 = original.get("revision"); let original_result: Value = original .get::, _>("result") .ok_or_else(mismatch)?; if original_state != "unknown" { return Err(mismatch()); } let r = Receipt { domain: profile::DOMAIN.into(), schema_version: 1, receipt_id: Uuid::new_v4(), request_id: id, witness: w.clone(), server_transport_generation: u64::try_from(transport).map_err(|_| mismatch())?, witness_sha256: input.witness_sha256, key_id: s.job_signer.key_id.clone(), issued_at: now, valid_until: now + Duration::minutes(5), confirmed_by: p.name.clone(), approval_origin: p.approval_origin().into(), testsimulation: true, ready: false, helper_ready: false, unlock: false, }; if !r.valid(now) { return Err(mismatch()); } let payload = serde_json::to_vec(&r)?; let signature = s.job_signer.sign(&payload)?; sqlx::query("INSERT INTO windows_system_nonstart_receipts(tenant_id,request_id,receipt_id,witness_sha256,payload,signature,confirmed_by,session_hash,issued_at,valid_until,original_job_state,original_job_revision,original_job_result) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)").bind(t).bind(id).bind(r.receipt_id).bind(&r.witness_sha256).bind(&payload).bind(signature).bind(&p.name).bind(session).bind(now).bind(r.valid_until).bind(&original_state).bind(original_revision).bind(&original_result).execute(&mut *tx).await?; sqlx::query("INSERT INTO audit_events(tenant_id,event_id,principal,event_type,data) VALUES($1,$2,$3,'windows_system_nonstart_confirmed',$4)").bind(t).bind(r.receipt_id).bind(&p.name).bind(json!({"request_id":id,"witness_sha256":r.witness_sha256,"receipt_sha256":hash(&payload),"approval_origin":r.approval_origin,"testsimulation":true,"ready":false,"helper_ready":false,"unlock":false,"connection_generation":221,"server_transport_generation":transport,"job_id":JOB,"attempt_id":ATTEMPT,"grant_id":GRANT,"original_job_state":original_state,"original_job_revision":original_revision,"original_job_result":original_result,"original_job_result_sha256":inventory_sha256(&original_result)?})).execute(&mut *tx).await?; let result = view(&mut tx, id, &w).await?; tx.commit().await?; Ok(Json(result)) } /// Validate only the newly explicit administrative FAILED/nonstart result. /// The immutable original permit anchors its signing key. Historical receipt /// validity is checked at issuance; it is never interpreted as a current lease. pub async fn validate_result( tx: &mut Transaction<'_, Postgres>, tenant: Uuid, agent: Uuid, result: &rmm_protocol::JobResult, evidence: &Value, ) -> anyhow::Result<()> { use anyhow::{Context, ensure}; ensure!( (tenant, agent) == (TENANT, AGENT) && result.job_id == JOB.to_string() && result.attempt_id == ATTEMPT.to_string() && result.grant_id == GRANT.to_string(), "WINDOWS_SYSTEM_NONSTART_RESULT_BINDING" ); let id: Uuid = evidence["administrative_receipt_id"] .as_str() .context("WINDOWS_SYSTEM_NONSTART_RECEIPT_REQUIRED")? .parse()?; let row=sqlx::query("SELECT payload,signature,original_job_state,original_job_result FROM windows_system_nonstart_receipts WHERE tenant_id=$1 AND receipt_id=$2").bind(tenant).bind(id).fetch_one(&mut **tx).await?; let signed = SignedReceipt { payload: row.get("payload"), signature: row.get("signature"), }; let r: Receipt = serde_json::from_slice(&signed.payload)?; let permit:Vec=sqlx::query_scalar("SELECT payload FROM execution_permits WHERE tenant_id=$1 AND job_id=$2 AND attempt_id=$3 AND grant_id=$4").bind(tenant).bind(JOB).bind(ATTEMPT).bind(GRANT).fetch_one(&mut **tx).await?; let permit: ExecutionPermitPayload = serde_json::from_slice(&permit)?; let public = hex::decode(&r.witness.verification_public_key_hex)?; ensure!( r.valid(r.issued_at) && r.receipt_id == id && r.key_id == permit.key_id && hash(&public) == permit.key_id && permit.grant_id == GRANT && serde_json::to_vec(&r)? == signed.payload && signed.signature.len() == 64, "WINDOWS_SYSTEM_NONSTART_RECEIPT_BINDING" ); let key = PKey::public_key_from_raw_bytes(&public, Id::ED25519)?; ensure!( Verifier::new_without_digest(&key)?.verify_oneshot(&signed.signature, &signed.payload)?, "WINDOWS_SYSTEM_NONSTART_RECEIPT_SIGNATURE" ); let receipt_sha256 = hash(&serde_json::to_vec(&signed)?); let expected = profile::failed_outcome(id, &receipt_sha256); ensure!( result.state == expected.state && result.stdout == expected.stdout && result.stderr == expected.stderr && result.exit_code == expected.exit_code && result.output_truncated == expected.output_truncated && result.reboot_required == expected.reboot_required && result.error_code == expected.error_code && *evidence == expected.evidence && row.get::("original_job_state") == "unknown" && row.get::("original_job_result")["grant_id"] == GRANT.to_string(), "WINDOWS_SYSTEM_NONSTART_EXACT_FAILED_RESULT" ); Ok(()) } /// Only a new, otherwise valid normal Sync may derive this exact FAILED result. /// Both native ledgers' independently checked derived snapshot is represented by /// the canonical outcome bytes. The old Unknown rows and server result remain /// archived in the signed witness/immutable receipt and the audit below. pub async fn reconcile_failed( tx: &mut Transaction<'_, Postgres>, tenant: Uuid, agent: Uuid, local: &rmm_protocol::SyncAttempt, request: &SyncRequest, normal_chain: bool, ) -> anyhow::Result<()> { use anyhow::{Context, ensure}; use rmm_domain::reconciliation::{ReconciledOutcome, canonical_outcome_bytes}; ensure!( normal_chain && (tenant, agent) == (TENANT, AGENT) && local.job_id == JOB.to_string() && local.attempt_id == ATTEMPT.to_string() && local.grant_id == GRANT.to_string() && local.consumption == "consumed" && local.state == "failed" && local.revision == 3 && local.original_boot_id == BOOT.to_string(), "WINDOWS_SYSTEM_NONSTART_SYNC_BINDING" ); ensure!( !local.outcome_bytes.is_empty() && local.outcome_bytes.len() <= 65536, "WINDOWS_SYSTEM_NONSTART_SYNC_BYTES" ); let outcome: ReconciledOutcome = serde_json::from_slice(&local.outcome_bytes)?; ensure!( canonical_outcome_bytes(&outcome)? == local.outcome_bytes && hash(&local.outcome_bytes) == local.outcome_sha256 && outcome.error_code == profile::ERROR_CODE, "WINDOWS_SYSTEM_NONSTART_SYNC_CANONICAL" ); let result = rmm_protocol::JobResult { job_id: local.job_id.clone(), attempt_id: local.attempt_id.clone(), revision: local.revision, state: outcome.state.clone(), grant_id: local.grant_id.clone(), stdout: outcome.stdout.clone(), stderr: outcome.stderr.clone(), output_truncated: outcome.output_truncated, reboot_required: outcome.reboot_required, exit_code: outcome.exit_code, evidence_json: serde_json::to_string(&outcome.evidence)?, error_code: outcome.error_code.clone(), }; validate_result(tx, tenant, agent, &result, &outcome.evidence).await?; let id: Uuid = outcome.evidence["administrative_receipt_id"] .as_str() .context("WINDOWS_SYSTEM_NONSTART_RECEIPT_REQUIRED")? .parse()?; let archive=sqlx::query("SELECT payload,original_job_revision,original_job_result FROM windows_system_nonstart_receipts WHERE tenant_id=$1 AND receipt_id=$2").bind(tenant).bind(id).fetch_one(&mut **tx).await?; let receipt: Receipt = serde_json::from_slice(&archive.get::, _>("payload"))?; ensure!( request.journal_id == receipt.witness.agent_journal_id.to_string() && request.helper_journal_id == receipt.witness.helper_journal_id.to_string() && request.checkpoint > receipt.witness.agent_checkpoint && request.helper_checkpoint > receipt.witness.helper_checkpoint && request.journal_complete, "WINDOWS_SYSTEM_NONSTART_FRESH_NORMAL_SNAPSHOTS" ); let expected = json!({"stdout":result.stdout,"stderr":result.stderr,"output_truncated":false,"reboot_required":false,"exit_code":null,"evidence":outcome.evidence,"error_code":profile::ERROR_CODE,"grant_id":GRANT,"source_id":"administrative_nonstart_sync"}); let row=sqlx::query("SELECT state,revision,result,start_reserved,cancel_requested FROM jobs WHERE tenant_id=$1 AND agent_id=$2 AND job_id=$3 AND attempt_id=$4 FOR UPDATE").bind(tenant).bind(agent).bind(JOB).bind(ATTEMPT).fetch_one(&mut **tx).await?; ensure!( row.get::("start_reserved") && !row.get::("cancel_requested"), "WINDOWS_SYSTEM_NONSTART_ORIGINAL_RESERVATION" ); if row.get::("state") == "failed" { ensure!( row.get::("revision") == 3 && row.get::, _>("result") == Some(expected), "WINDOWS_SYSTEM_NONSTART_FINAL_IDENTITY" ); return Ok(()); } ensure!( row.get::("state") == "unknown" && row.get::("revision") == archive.get::("original_job_revision") && row.get::("revision") == 2 && row.get::, _>("result") == Some(archive.get::("original_job_result")) && request.helper_previous_decision_id == SECOND.to_string(), "WINDOWS_SYSTEM_NONSTART_ORIGINAL_UNKNOWN_RETAINED" ); sqlx::query("INSERT INTO audit_events(tenant_id,event_id,principal,event_type,data) VALUES($1,$2,'signed-sync','windows_system_nonstart_reconciled',$3)").bind(tenant).bind(Uuid::new_v4()).bind(json!({"job_id":JOB,"attempt_id":ATTEMPT,"grant_id":GRANT,"receipt_id":id,"original_unknown_sha256":UNKNOWN_SHA,"original_server_result":row.get::,_>("result"),"original_server_revision":2,"derived_outcome_sha256":local.outcome_sha256,"agent_checkpoint":request.checkpoint,"helper_checkpoint":request.helper_checkpoint,"job_authority":false})).execute(&mut **tx).await?; sqlx::query("UPDATE jobs SET state='failed',revision=3,result=$4,pending_reason=NULL WHERE tenant_id=$1 AND agent_id=$2 AND job_id=$3 AND attempt_id=$5 AND state='unknown' AND revision=2").bind(tenant).bind(agent).bind(JOB).bind(expected).bind(ATTEMPT).execute(&mut **tx).await?; Ok(()) } async fn download( State(s): State, Path((t, id)): Path<(Uuid, Uuid)>, h: HeaderMap, ) -> Result> { 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 (actual, w, transport) = stored(&mut tx) .await? .ok_or(Error(StatusCode::NOT_FOUND, "NOT_FOUND"))?; if actual != id { return Err(mismatch()); } validate(&mut tx, &s, &w, Some(transport)).await?; let row=sqlx::query("SELECT payload,signature FROM windows_system_nonstart_receipts WHERE tenant_id=$1 AND request_id=$2 ORDER BY issued_at DESC,receipt_id DESC LIMIT 1").bind(t).bind(id).fetch_optional(&mut *tx).await?.ok_or(Error(StatusCode::NOT_FOUND,"NOT_FOUND"))?; let signed = SignedReceipt { payload: row.get("payload"), signature: row.get("signature"), }; verify(&s, &signed.payload, &signed.signature)?; let r: Receipt = serde_json::from_slice(&signed.payload)?; if !r.valid(Utc::now()) || r.witness != w { return Err(Error( StatusCode::CONFLICT, "WINDOWS_SYSTEM_NONSTART_EXPIRED", )); } tx.commit().await?; Ok(Json(signed)) } #[cfg(test)] mod tests { use super::*; #[test] fn administrative_confirmation_requires_actual_scoped_browser_session() { let p = Principal { name: TEST_PRINCIPAL.into(), tenant: TENANT, operator: true, csrf: Some("csrf".into()), session_hash: Some("ab".repeat(32)), scopes: None, testsimulation: true, identity: None, tenants: vec![TENANT], }; assert!(browser(&p).is_ok()); for mutation in 0..5 { let mut bad = p.clone(); match mutation { 0 => bad.session_hash = None, 1 => bad.csrf = None, 2 => bad.scopes = Some(Default::default()), 3 => bad.testsimulation = false, _ => bad.operator = false, }; assert_eq!(browser(&bad).unwrap_err().0, StatusCode::FORBIDDEN); } } }