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 }