lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }