observation.rs (5966B)
1 //! First normalized target facts under independent expected v2 contexts. 2 use super::{Slot, context, json}; 3 use crate::workspace::{State, address, crypto, journal::storage_error}; 4 use crate::{Mutation, ReadSnapshot, RecordKey}; 5 use core::num::NonZeroU64; 6 use radroots_domain::{EnvelopeEventId, TransactionId}; 7 use radroots_secrets::context::{ 8 EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId, 9 }; 10 use radroots_storage::command::{DeliveryAttempt, DeliveryObservation, OperationError}; 11 use radroots_transport::sink::DeliveryTargetReceipt; 12 use serde::{Deserialize, Serialize}; 13 use sha2::{Digest, Sha256}; 14 use std::collections::BTreeMap; 15 use zeroize::Zeroizing; 16 17 #[derive(Serialize, Deserialize)] 18 #[serde(deny_unknown_fields)] 19 struct Wire<'a> { 20 version: u8, 21 work: [u8; 32], 22 #[serde(borrow)] 23 request: &'a str, 24 event: EnvelopeEventId, 25 envelope_digest: [u8; 32], 26 transaction: TransactionId, 27 target: DeliveryTargetReceipt, 28 kind: u8, 29 ordinal: u8, 30 observed_at: Option<NonZeroU64>, 31 } 32 fn scoped( 33 state: &State, 34 slot: Slot, 35 attempt: &DeliveryAttempt, 36 target: u8, 37 kind: u8, 38 ) -> Result<EnvelopeContext, OperationError> { 39 let base = context(state, slot, 0, false)?; 40 let target = attempt 41 .intent() 42 .targets() 43 .targets() 44 .get(target as usize) 45 .ok_or(OperationError::RecoveryRequired)?; 46 let subject = Sha256::new() 47 .chain_update(b"radroots.browser.local_outbox.delivery_observation.context.v2\0") 48 .chain_update(base.authentication_digest()) 49 .chain_update(attempt.intent().request_id().as_str().as_bytes()) 50 .chain_update(attempt.transaction_id().as_bytes()) 51 .chain_update(attempt.envelope_digest()) 52 .chain_update(target.fingerprint().as_str().as_bytes()) 53 .chain_update([kind]) 54 .finalize() 55 .iter() 56 .map(|b| format!("{b:02x}")) 57 .collect::<String>(); 58 Ok(EnvelopeContext::new( 59 EnvelopePurpose::parse("radroots.browser.workspace.delivery_observation") 60 .map_err(|_| OperationError::InvalidCommand)?, 61 EnvelopeSubject::parse("delivery_observation", subject) 62 .map_err(|_| OperationError::InvalidCommand)?, 63 PayloadSchemaId::parse("radroots.browser.workspace.delivery_observation.v2") 64 .map_err(|_| OperationError::InvalidCommand)?, 65 )) 66 } 67 fn checked( 68 attempt: &DeliveryAttempt, 69 wire: Wire<'_>, 70 slot: Slot, 71 target: u8, 72 kind: u8, 73 ) -> Result<DeliveryObservation, OperationError> { 74 if wire.version != 2 75 || wire.work != slot.commitment 76 || wire.request != attempt.intent().request_id().as_str() 77 || wire.event != attempt.intent().event_id() 78 || &wire.envelope_digest != attempt.envelope_digest() 79 || wire.transaction != attempt.transaction_id() 80 || wire.kind != kind 81 || attempt.intent().targets().targets().get(target as usize) != Some(wire.target.target()) 82 { 83 return Err(OperationError::RecoveryRequired); 84 } 85 let value = DeliveryObservation::from_store_report(attempt, &wire.target, wire.observed_at) 86 .map_err(|_| OperationError::RecoveryRequired)?; 87 if value.kind().code() != kind || value.target_ordinal() != wire.ordinal { 88 return Err(OperationError::RecoveryRequired); 89 } 90 Ok(value) 91 } 92 pub(super) async fn read( 93 state: &State, 94 view: &ReadSnapshot, 95 slot: Slot, 96 attempt: &DeliveryAttempt, 97 positions: BTreeMap<(u8, u8), RecordKey>, 98 ) -> Result<Vec<DeliveryObservation>, OperationError> { 99 let mut reports = Vec::with_capacity(positions.len()); 100 for ((target, kind), key) in positions { 101 let raw = state 102 .read_view_key(view, key) 103 .await? 104 .ok_or(OperationError::RecoveryRequired)?; 105 let clear = crypto::open_bound( 106 state.provider.as_ref(), 107 &state.reference, 108 scoped(state, slot, attempt, target, kind)?, 109 &raw, 110 ) 111 .await?; 112 let report = clear.expose_secret(|raw| { 113 if raw.len() > 16384 || !json::bounded(raw, 32) { 114 return Err(OperationError::RecoveryRequired); 115 } 116 let wire: Wire<'_> = 117 serde_json::from_slice(raw).map_err(|_| OperationError::RecoveryRequired)?; 118 checked(attempt, wire, slot, target, kind) 119 })?; 120 reports.push(report); 121 } 122 Ok(reports) 123 } 124 pub(super) async fn protect( 125 state: &State, 126 slot: Slot, 127 attempt: &DeliveryAttempt, 128 value: &DeliveryObservation, 129 ) -> Result<Mutation, OperationError> { 130 let target = attempt 131 .intent() 132 .targets() 133 .targets() 134 .iter() 135 .position(|target| target == value.target_receipt().target()) 136 .ok_or(OperationError::InvalidEvidence)? as u8; 137 let wire = Wire { 138 version: 2, 139 work: slot.commitment, 140 request: value.request_id().as_str(), 141 event: value.event_id(), 142 envelope_digest: *value.envelope_digest(), 143 transaction: attempt.transaction_id(), 144 target: value.target_receipt().clone(), 145 kind: value.kind().code(), 146 ordinal: value.target_ordinal(), 147 observed_at: value.observed_at_unix_ms(), 148 }; 149 let clear = 150 Zeroizing::new(serde_json::to_vec(&wire).map_err(|_| OperationError::InvalidEvidence)?); 151 if clear.len() > 16384 { 152 return Err(OperationError::InvalidEvidence); 153 } 154 let protected = crypto::seal_bound( 155 state.provider.as_ref(), 156 &state.reference, 157 scoped(state, slot, attempt, target, value.kind().code())?, 158 &clear, 159 ) 160 .await?; 161 Mutation::new( 162 address::observation_key( 163 slot.operation, 164 slot.recipient, 165 slot.ordinal, 166 target, 167 value.kind().code(), 168 ), 169 None, 170 Some(protected), 171 ) 172 .map_err(storage_error) 173 }