736 lines
34 KiB
Rust
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);
|
|
}
|
|
}
|
|
}
|