plans.rs (13302B)
1 //! Actual protected T1 storage; no participant issuance or network effects. 2 use super::journal::{OperationChange, Records, storage_error}; 3 use super::{BrowserWorkspace, Mutation, RecordKey, State, WorkspaceError, crypto, owned}; 4 use crate::ReadSnapshot; 5 use radroots_domain::{CommandDigest, OperationId, TransactionId}; 6 use radroots_secrets::context::{ 7 EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId, 8 }; 9 use radroots_storage::{ 10 command::{ 11 BoundSigningPlan, CapturedSigningPlan, CommitAttempt, OperationError, PlanBindingOutcome, 12 PreparedOperation, 13 protected::{ 14 self, 15 plan::{PART_BYTES, PARTS_MAX, PlanManifest}, 16 }, 17 }, 18 workspace::{AttachmentProof, WorkspaceBinding}, 19 }; 20 use sha2::{Digest, Sha256}; 21 use zeroize::Zeroizing; 22 23 const SLOTS: usize = PARTS_MAX + 1; 24 fn key(operation: OperationId, slot: usize) -> RecordKey { 25 super::address::key(operation, super::address::PLAN, 0, slot as u8) 26 } 27 28 fn context( 29 state: &State, 30 operation: OperationId, 31 part: Option<(usize, CommandDigest)>, 32 ) -> Result<EnvelopeContext, WorkspaceError> { 33 let mut h = Sha256::new(); 34 h.update(b"radroots.browser.local_outbox.plan.context.v2\0"); 35 h.update(state.selected.workspace_id().as_bytes()); 36 h.update(operation.as_bytes()); 37 if let Some((index, digest)) = part { 38 h.update(b"part\0"); 39 h.update((index as u32).to_be_bytes()); 40 h.update(digest.as_bytes()); 41 } else { 42 h.update(b"manifest\0"); 43 } 44 let subject = h 45 .finalize() 46 .iter() 47 .map(|b| format!("{b:02x}")) 48 .collect::<String>(); 49 Ok(EnvelopeContext::new( 50 EnvelopePurpose::parse("radroots.browser.workspace.plan") 51 .map_err(|_| WorkspaceError::InvalidInput)?, 52 EnvelopeSubject::parse("workspace_plan", subject) 53 .map_err(|_| WorkspaceError::InvalidInput)?, 54 PayloadSchemaId::parse("radroots.browser.workspace.plan.v2") 55 .map_err(|_| WorkspaceError::InvalidInput)?, 56 )) 57 } 58 fn comparisons( 59 operation: OperationId, 60 before: Records, 61 after: Option<Records>, 62 ) -> Result<Vec<Mutation>, OperationError> { 63 before 64 .into_iter() 65 .enumerate() 66 .map(|(slot, old)| { 67 let new = after 68 .as_ref() 69 .map_or_else(|| old.clone(), |values| values[slot].clone()); 70 Mutation::new(key(operation, slot), old, new).map_err(storage_error) 71 }) 72 .collect() 73 } 74 impl State { 75 pub(super) async fn plan_records( 76 &self, 77 view: &ReadSnapshot, 78 operation: OperationId, 79 ) -> Result<Records, OperationError> { 80 let mut records = Vec::with_capacity(SLOTS); 81 for slot in 0..SLOTS { 82 let value = self.read_view_key(view, key(operation, slot)).await?; 83 if value 84 .as_ref() 85 .is_some_and(|v| v.len() > crypto::PROTECTED_MAX) 86 { 87 return Err(OperationError::RecoveryRequired); 88 } 89 records.push(value); 90 } 91 Ok(records) 92 } 93 pub(super) async fn absent_plans( 94 &self, 95 view: &ReadSnapshot, 96 operation: OperationId, 97 ) -> Result<Vec<Mutation>, OperationError> { 98 let before = self.plan_records(view, operation).await?; 99 if before.iter().any(Option::is_some) 100 || view.keys().any(|key| { 101 !matches!( 102 super::address::fields(key), 103 Ok((super::address::PREPARED, _, _)) 104 ) 105 }) 106 { 107 return Err(OperationError::RecoveryRequired); 108 } 109 comparisons(operation, before, None) 110 } 111 pub(super) async fn retained_plan( 112 &self, 113 prepared: &PreparedOperation, 114 records: &Records, 115 ) -> Result<Option<(PlanManifest, CapturedSigningPlan)>, OperationError> { 116 let Some(manifest) = &records[0] else { 117 if records.iter().any(Option::is_some) { 118 return Err(OperationError::RecoveryRequired); 119 } 120 return Ok(None); 121 }; 122 let operation = prepared.identity().operation_id(); 123 let clear = crypto::open_bound( 124 self.provider.as_ref(), 125 &self.reference, 126 context(self, operation, None)?, 127 manifest, 128 ) 129 .await?; 130 let manifest = clear.expose_secret(|bytes| PlanManifest::decode(bytes, prepared))?; 131 let mut wire = Zeroizing::new(Vec::with_capacity(manifest.byte_count())); 132 for index in 0..PARTS_MAX { 133 if index >= manifest.part_count() { 134 if records[index + 1].is_some() { 135 return Err(OperationError::RecoveryRequired); 136 } 137 continue; 138 } 139 let protected = records[index + 1] 140 .as_ref() 141 .ok_or(OperationError::RecoveryRequired)?; 142 let bytes = crypto::open_bound( 143 self.provider.as_ref(), 144 &self.reference, 145 context(self, operation, Some((index + 1, manifest.plan_digest())))?, 146 protected, 147 ) 148 .await?; 149 let expected = (manifest.byte_count() - index * PART_BYTES).min(PART_BYTES); 150 bytes.expose_secret(|bytes| { 151 if bytes.len() != expected { 152 return Err(OperationError::RecoveryRequired); 153 } 154 wire.extend_from_slice(bytes); 155 Ok(()) 156 })?; 157 } 158 let plan = CapturedSigningPlan::parse(prepared.request().command(), &wire) 159 .map_err(|_| OperationError::RecoveryRequired)?; 160 if plan.digest() != manifest.plan_digest().as_bytes() { 161 return Err(OperationError::RecoveryRequired); 162 } 163 Ok(Some((manifest, plan))) 164 } 165 async fn protect_plan( 166 &self, 167 operation: OperationId, 168 manifest: &PlanManifest, 169 plan: &CapturedSigningPlan, 170 ) -> Result<Records, OperationError> { 171 let mut records = Vec::with_capacity(SLOTS); 172 let bytes = manifest.encode()?; 173 records.push(Some( 174 crypto::seal_bound( 175 self.provider.as_ref(), 176 &self.reference, 177 context(self, operation, None)?, 178 &bytes, 179 ) 180 .await?, 181 )); 182 for (index, part) in plan.protected_wire().chunks(PART_BYTES).enumerate() { 183 records.push(Some( 184 crypto::seal_bound( 185 self.provider.as_ref(), 186 &self.reference, 187 context(self, operation, Some((index + 1, manifest.plan_digest())))?, 188 part, 189 ) 190 .await?, 191 )); 192 } 193 records.resize_with(SLOTS, || None); 194 Ok(records) 195 } 196 } 197 impl BrowserWorkspace { 198 /// Atomically binds a complete original plan before any participant issuance. 199 /// Exact retained replay preserves its transaction/observation after expiry. 200 pub async fn bind_signing_intents( 201 &self, 202 binding: WorkspaceBinding, 203 supplied: CapturedSigningPlan, 204 proof: AttachmentProof, 205 ) -> Result<PlanBindingOutcome, OperationError> { 206 let fallback = CommitAttempt::new( 207 binding.input().workspace_id(), 208 supplied.operation_id(), 209 supplied.command_digest(), 210 None, 211 ); 212 let work = self.state.admit()?; 213 let state = self.state.clone(); 214 let result = owned(work, async move { 215 let access = state.operation_access(&binding, proof).await?; 216 let operation = supplied.operation_id(); 217 let view = state.read_view(operation).await?; 218 let t0 = state.operation_records(&view, operation).await?; 219 let prepared = state 220 .preparation(operation, &t0) 221 .await? 222 .ok_or(OperationError::RecoveryRequired)?; 223 protected::check_digest(&prepared, binding.actor(), Some(supplied.command_digest()))?; 224 protected::same_binding(prepared.request().binding(), &binding)?; 225 let before = state.plan_records(&view, operation).await?; 226 let (manifest, plan, after, fresh) = if let Some((manifest, plan)) = 227 state.retained_plan(&prepared, &before).await? 228 { 229 if plan.protected_wire() != supplied.protected_wire() { 230 return Err(OperationError::IdempotencyConflict); 231 } 232 (manifest, plan, None, false) 233 } else { 234 if view.keys().any(|key| { 235 !matches!( 236 super::address::fields(key), 237 Ok((super::address::PREPARED, _, _)) 238 ) 239 }) { 240 return Err(OperationError::RecoveryRequired); 241 } 242 let window = prepared.issuance_window(); 243 let observed = access.binding.observed_at(); 244 if observed < window.prepared_at() { 245 return Err(WorkspaceError::Unavailable.into()); 246 } 247 if observed >= window.first_issue_not_after() { 248 return Err(OperationError::DeadlineExceeded); 249 } 250 let checked = CapturedSigningPlan::parse( 251 prepared.request().command(), 252 supplied.protected_wire(), 253 ) 254 .map_err(|_| OperationError::InvalidCommand)?; 255 drop(supplied); 256 let transaction = TransactionId::from_bytes(*crypto::random::<32>()?); 257 let manifest = PlanManifest::capture(&prepared, &checked, transaction, observed)?; 258 let records = state.protect_plan(operation, &manifest, &checked).await?; 259 (manifest, checked, Some(records), true) 260 }; 261 let attempt = CommitAttempt::new( 262 prepared.identity().workspace_id(), 263 operation, 264 prepared.identity().command_digest(), 265 Some(manifest.transaction_id()), 266 ); 267 let change = OperationChange { 268 before: t0, 269 after: None, 270 window: fresh.then(|| prepared.issuance_window()), 271 delivery_deadline: None, 272 extra: comparisons(operation, before, after)?, 273 }; 274 match state.check_operation(access, operation, change, view).await { 275 Ok(()) => Ok(PlanBindingOutcome::Committed( 276 manifest.bind(prepared, plan)?, 277 )), 278 Err(OperationError::Workspace(WorkspaceError::CommitUnknown)) => { 279 state.mark_unknown(); 280 Ok(PlanBindingOutcome::Unknown(attempt)) 281 } 282 Err(error) => Err(error), 283 } 284 }) 285 .await; 286 match result { 287 Err(OperationError::Workspace(WorkspaceError::CommitUnknown)) => { 288 self.state.mark_unknown(); 289 Ok(PlanBindingOutcome::Unknown(fallback)) 290 } 291 other => other, 292 } 293 } 294 /// Authenticates and confirms the original plan without issuance or replay. 295 pub async fn signing_plan( 296 &self, 297 binding: WorkspaceBinding, 298 operation: OperationId, 299 digest: CommandDigest, 300 proof: AttachmentProof, 301 ) -> Result<Option<BoundSigningPlan>, OperationError> { 302 let work = self.state.admit()?; 303 let state = self.state.clone(); 304 owned(work, async move { 305 let access = state.operation_access(&binding, proof).await?; 306 let view = state.read_view(operation).await?; 307 let t0 = state.operation_records(&view, operation).await?; 308 let prepared = state.preparation(operation, &t0).await?; 309 let records = state.plan_records(&view, operation).await?; 310 let retained = if let Some(prepared) = prepared { 311 protected::check_digest(&prepared, binding.actor(), Some(digest))?; 312 protected::same_binding(prepared.request().binding(), &binding)?; 313 let plan = state.retained_plan(&prepared, &records).await?; 314 if plan.is_none() { 315 state.absent_plans(&view, operation).await?; 316 } 317 Some((prepared, plan)) 318 } else { 319 if !view.is_empty() { 320 return Err(OperationError::RecoveryRequired); 321 } 322 None 323 }; 324 let change = OperationChange { 325 before: t0, 326 after: None, 327 window: None, 328 delivery_deadline: None, 329 extra: comparisons(operation, records, None)?, 330 }; 331 state 332 .check_operation(access, operation, change, view) 333 .await?; 334 match retained { 335 Some((prepared, Some((manifest, plan)))) => manifest.bind(prepared, plan).map(Some), 336 _ => Ok(None), 337 } 338 }) 339 .await 340 } 341 }