lib

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

rewrap.rs (7675B)


      1 //! Explicit rewrap invocation identity and non-authoritative recovery reports.
      2 use super::*;
      3 use core::fmt;
      4 use radroots_domain::{Sequence, UnixSeconds};
      5 
      6 pub struct StockRewrapRequest {
      7     source: StockEnvelopeRequest,
      8     id: OperationId,
      9 }
     10 impl StockRewrapRequest {
     11     pub const fn new(source: StockEnvelopeRequest, id: OperationId) -> Self {
     12         Self { source, id }
     13     }
     14     pub const fn source(&self) -> &StockEnvelopeRequest {
     15         &self.source
     16     }
     17     pub const fn rewrap_id(&self) -> OperationId {
     18         self.id
     19     }
     20     pub fn with_envelope(mut self, event: radroots_domain::EnvelopeEventId) -> Self {
     21         self.source = self.source.with_envelope(event);
     22         self
     23     }
     24     pub fn attempt(&self) -> CommitAttempt {
     25         self.source.attempt()
     26     }
     27 }
     28 impl fmt::Debug for StockRewrapRequest {
     29     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     30         f.write_str("StockRewrapRequest(<redacted>)")
     31     }
     32 }
     33 
     34 /// Original confirmed wrapping admission. Only a qualified concrete owner's
     35 /// newly confirmed Claimed outcome can qualify an invocation. This report,
     36 /// an existing admission or an uncertain commit cannot do so.
     37 #[derive(Clone, Copy, Eq, PartialEq)]
     38 pub struct StockRewrapAdmission {
     39     id: OperationId,
     40     original: StockEnvelopeReceipt,
     41     transaction: TransactionId,
     42     at: UnixSeconds,
     43     expires: UnixSeconds,
     44     checkpoint: InventoryCheckpointRef,
     45 }
     46 impl StockRewrapAdmission {
     47     pub fn from_store_report(
     48         request: &StockRewrapRequest,
     49         original: StockEnvelopeReceipt,
     50         transaction: TransactionId,
     51         at: UnixSeconds,
     52         expires: UnixSeconds,
     53         checkpoint: InventoryCheckpointRef,
     54     ) -> Result<Self, OperationError> {
     55         let source = request.source();
     56         let attempt = original.attempt();
     57         if source.envelope_event_id().is_some()
     58             || original.rewrap_admission_transaction_id().is_some()
     59             || attempt.workspace_id() != source.binding().input().workspace_id()
     60             || attempt.operation_id() != source.operation_id()
     61             || attempt.command_digest() != source.command_digest()
     62             || original.recipient() != source.recipient()
     63             || at.get() == 0
     64             || expires <= at
     65             || expires
     66                 .get()
     67                 .checked_sub(at.get())
     68                 .is_none_or(|seconds| seconds > 30)
     69             || checkpoint.authority() != source.binding().input().authority()
     70             || original.checkpoint().authority() != checkpoint.authority()
     71             || checkpoint.revision() <= original.checkpoint().revision()
     72         {
     73             return Err(OperationError::RecoveryRequired);
     74         }
     75         Ok(Self {
     76             id: request.id,
     77             original,
     78             transaction,
     79             at,
     80             expires,
     81             checkpoint,
     82         })
     83     }
     84     pub const fn rewrap_id(&self) -> OperationId {
     85         self.id
     86     }
     87     pub const fn original(&self) -> StockEnvelopeReceipt {
     88         self.original
     89     }
     90     pub const fn transaction_id(&self) -> TransactionId {
     91         self.transaction
     92     }
     93     pub const fn prepared_at(&self) -> UnixSeconds {
     94         self.at
     95     }
     96     pub const fn expires_at(&self) -> UnixSeconds {
     97         self.expires
     98     }
     99     pub const fn checkpoint(&self) -> InventoryCheckpointRef {
    100         self.checkpoint
    101     }
    102 }
    103 impl fmt::Debug for StockRewrapAdmission {
    104     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    105         f.write_str("StockRewrapAdmission(<redacted>)")
    106     }
    107 }
    108 #[derive(Debug)]
    109 pub enum StockRewrapOutcome {
    110     Claimed(Box<StockRewrapAdmission>),
    111     Retained(Box<StockRewrapAdmission>),
    112     Unknown(CommitAttempt),
    113 }
    114 
    115 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
    116 pub struct StockRewrapState {
    117     admission: StockRewrapAdmission,
    118     envelope: Option<StockEnvelopeReceipt>,
    119 }
    120 impl StockRewrapState {
    121     /// Validates shape only. The host must authenticate the actual F13/F14
    122     /// link. Missing bytes convey no proof of nonissuance or new wrapping right.
    123     pub fn from_store_report(
    124         admission: StockRewrapAdmission,
    125         envelope: Option<StockEnvelopeReceipt>,
    126     ) -> Result<Self, OperationError> {
    127         if let Some(envelope) = envelope
    128             && (envelope.rewrap_admission_transaction_id() != Some(admission.transaction_id())
    129                 || envelope.evidence() != admission.original().evidence()
    130                 || envelope.installation_transaction_id()
    131                     != admission.original().installation_transaction_id()
    132                 || envelope.checkpoint().authority() != admission.checkpoint().authority()
    133                 || envelope.checkpoint().revision() <= admission.checkpoint().revision())
    134         {
    135             return Err(OperationError::RecoveryRequired);
    136         }
    137         Ok(Self {
    138             admission,
    139             envelope,
    140         })
    141     }
    142     pub const fn admission(&self) -> StockRewrapAdmission {
    143         self.admission
    144     }
    145     pub const fn envelope(&self) -> Option<StockEnvelopeReceipt> {
    146         self.envelope
    147     }
    148 }
    149 
    150 #[derive(Debug)]
    151 pub struct StockRewrapPage {
    152     entries: Box<[StockRewrapState]>,
    153     next: Option<Sequence>,
    154     checkpoint: InventoryCheckpointRef,
    155 }
    156 impl StockRewrapPage {
    157     pub fn from_store_report(
    158         request: &StockEnvelopeRequest,
    159         entries: Vec<StockRewrapState>,
    160         more: bool,
    161         checkpoint: InventoryCheckpointRef,
    162     ) -> Result<Self, OperationError> {
    163         if entries.len() > 16
    164             || (more && entries.len() != 16)
    165             || request.envelope_event_id().is_some()
    166             || checkpoint.authority() != request.binding().input().authority()
    167             || checkpoint.revision() < request.minimum_checkpoint().revision()
    168             || entries.windows(2).any(|pair| {
    169                 pair[0].admission.checkpoint().revision()
    170                     >= pair[1].admission.checkpoint().revision()
    171             })
    172         {
    173             return Err(OperationError::RecoveryRequired);
    174         }
    175         for (index, state) in entries.iter().enumerate() {
    176             let original = state.admission.original();
    177             if original.attempt().workspace_id() != request.binding().input().workspace_id()
    178                 || original.attempt().operation_id() != request.operation_id()
    179                 || original.attempt().command_digest() != request.command_digest()
    180                 || original.recipient() != request.recipient()
    181                 || state.admission.checkpoint().authority() != checkpoint.authority()
    182                 || state.admission.checkpoint().revision() > checkpoint.revision()
    183                 || state.envelope.is_some_and(|envelope| {
    184                     envelope.checkpoint().revision() > checkpoint.revision()
    185                 })
    186                 || entries[..index].iter().any(|prior| {
    187                     prior.admission.rewrap_id() == state.admission.rewrap_id()
    188                         || prior.admission.transaction_id() == state.admission.transaction_id()
    189                 })
    190             {
    191                 return Err(OperationError::RecoveryRequired);
    192             }
    193         }
    194         let next = if more {
    195             entries
    196                 .last()
    197                 .map(|state| state.admission.checkpoint().revision())
    198         } else {
    199             None
    200         };
    201         Ok(Self {
    202             entries: entries.into_boxed_slice(),
    203             next,
    204             checkpoint,
    205         })
    206     }
    207     pub fn entries(&self) -> &[StockRewrapState] {
    208         &self.entries
    209     }
    210     pub const fn next_after(&self) -> Option<Sequence> {
    211         self.next
    212     }
    213     pub const fn checkpoint(&self) -> InventoryCheckpointRef {
    214         self.checkpoint
    215     }
    216 }