lib

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

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 }