Files
rust-discovery/crates/server/src/windows_system_nonstart.rs
T
2026-11-16 17:46:54 +01:00

736 lines
34 KiB
Rust

//! 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<T> = std::result::Result<T, Error>;
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<crate::State>) -> Router<crate::State> {
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<u8>,
permit_bytes: Vec<u8>,
signature: Vec<u8>,
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<i64>,
) -> Result<i64> {
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::<Uuid, _>("asset_id") != ASSET
|| dev.get::<i64, _>("enrollment_generation") != 1
|| dev.get::<i64, _>("assignment_version") != 1
|| dev.get::<i64, _>("connection_generation") < 221
|| expected_transport.is_some_and(|g| dev.get::<i64, _>("connection_generation") != g)
|| dev.get::<Option<Uuid>, _>("connection_boot_id") != Some(BOOT)
|| dev
.get::<Option<chrono::DateTime<Utc>>, _>("revoked_at")
.is_some()
|| dev.get::<bool, _>("sequence_regressed")
|| dev.get::<bool, _>("sync_recovery_required")
|| !dev.get::<bool, _>("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::<Uuid, _>("journal_id") != w.agent_journal_id
|| state.get::<i64, _>("checkpoint") != 10784
|| state.get::<Uuid, _>("decision_id") != SECOND
|| state.get::<Option<Uuid>, _>("helper_journal_id") != Some(w.helper_journal_id)
|| state.get::<i64, _>("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::<String, _>("request_hash") != hash(&r.encode_to_vec())
|| row.get::<Uuid, _>("journal_id") != w.agent_journal_id
|| row.get::<i64, _>("checkpoint")
!= i64::try_from(d.checkpoint).map_err(|_| mismatch())?
|| row.get::<i64, _>("connection_generation") != 221
|| row.get::<Vec<u8>, _>("payload") != w.original_responses[i].decision_bytes
|| row.get::<Vec<u8>, _>("signature") != w.original_responses[i].signature
{
return Err(mismatch());
}
}
validate_job(tx, s, w).await?;
Ok(dev.get::<i64, _>("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::<Uuid, _>("job_id").to_string() != j
|| r.get::<Uuid, _>("attempt_id").to_string() != a
|| r.get::<String, _>("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<u8> = 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::<Uuid, _>("operation_id") != Uuid::from_u128(0xce1b969b66b24548a28c7e81943507c4)
|| row.get::<Uuid, _>("asset_id") != ASSET
|| !row.get::<bool, _>("start_reserved")
|| row.get::<bool, _>("cancel_requested")
|| row.get::<Vec<u8>, _>("payload") != offer.payload_bytes
|| row.get::<String, _>("payload_hash") != hash(&offer.payload_bytes)
|| offer.job_payload_hash != hash(&offer.payload_bytes)
|| offer.authorization_id != row.get::<Uuid, _>("authorization_id").to_string()
|| offer.plan_hash != row.get::<String, _>("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<u8> = grant.get("payload");
let signature: Vec<u8> = grant.get("signature");
verify(s, &raw, &signature)?;
let g: ExecutionPermitPayload = serde_json::from_slice(&raw)?;
if g.grant_id != GRANT
|| grant.get::<Uuid, _>("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::<Option<Value>, _>("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<Option<(Uuid, Witness, i64)>> {
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<Value> {
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::<Value>(&r.get::<Vec<u8>, _>("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<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, "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<crate::State>,
Path(t): Path<Uuid>,
h: HeaderMap,
Json(w): Json<Witness>,
) -> Result<Json<Value>> {
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<crate::State>,
Path((t, id)): Path<(Uuid, Uuid)>,
h: HeaderMap,
Json(input): Json<Confirmation>,
) -> Result<Json<Value>> {
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::<Option<Value>, _>("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<u8>=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::<String, _>("original_job_state") == "unknown"
&& row.get::<Value, _>("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::<Vec<u8>, _>("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::<bool, _>("start_reserved") && !row.get::<bool, _>("cancel_requested"),
"WINDOWS_SYSTEM_NONSTART_ORIGINAL_RESERVATION"
);
if row.get::<String, _>("state") == "failed" {
ensure!(
row.get::<i64, _>("revision") == 3
&& row.get::<Option<Value>, _>("result") == Some(expected),
"WINDOWS_SYSTEM_NONSTART_FINAL_IDENTITY"
);
return Ok(());
}
ensure!(
row.get::<String, _>("state") == "unknown"
&& row.get::<i64, _>("revision") == archive.get::<i64, _>("original_job_revision")
&& row.get::<i64, _>("revision") == 2
&& row.get::<Option<Value>, _>("result")
== Some(archive.get::<Value, _>("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::<Option<Value>,_>("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<crate::State>,
Path((t, id)): Path<(Uuid, 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 (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);
}
}
}