lib

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

crypto.rs (33295B)


      1 use super::WorkspaceError;
      2 use radroots_domain::{GrantId, OperationId, WorkspaceId};
      3 use radroots_secrets::{
      4     EncryptedEnvelope, SecretRef,
      5     context::{EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId},
      6     envelope::{ENVELOPE_MAX_BYTES, Nonce, SealMaterial, SealRequest},
      7     provider::{AccessPolicy, ResidencySupport, SecretProvider, SelectionPolicy},
      8     wrapping::SecretMaterial,
      9 };
     10 use radroots_storage::workspace::grant::{
     11     GRANT_ENVELOPE_PURPOSE, GRANT_PAYLOAD_SCHEMA, grant_envelope_subject,
     12 };
     13 use std::{fmt, sync::Arc};
     14 
     15 pub(super) const PRIVATE_PAYLOAD_MAX_BYTES: usize = 16 * 1024;
     16 pub(super) const PROTECTED_MAX_BYTES: usize = ENVELOPE_MAX_BYTES;
     17 
     18 #[derive(Clone, Copy)]
     19 pub(super) struct IssuanceScope {
     20     pub workspace: WorkspaceId,
     21     pub operation: OperationId,
     22     pub plan_digest: [u8; 32],
     23     pub attempt: radroots_domain::SigningAttemptId,
     24     pub target: radroots_storage::command::SigningTarget,
     25 }
     26 #[derive(Clone, Copy)]
     27 pub(super) enum IssuancePayload {
     28     Attempt,
     29     Evidence,
     30     Publication,
     31     ListingInstallation,
     32 }
     33 
     34 #[derive(Clone, Copy)]
     35 pub(super) struct DeliveryScope {
     36     pub workspace: WorkspaceId,
     37     pub operation: OperationId,
     38     pub target: radroots_storage::command::SigningTarget,
     39     pub request: [u8; 32],
     40 }
     41 #[derive(Clone, Copy)]
     42 pub(super) enum DeliveryPayload {
     43     Attempt,
     44     Observation,
     45 }
     46 
     47 /// Explicit host-owned encryption material. This is a data-encryption key,
     48 /// independent of the participant signer and the scoped bearer credential.
     49 /// The host chooses its qualified provider and access policy; no fallback or
     50 /// credential installation occurs here.
     51 pub struct WorkspaceCrypto {
     52     provider: Arc<dyn SecretProvider>,
     53     reference: SecretRef,
     54     key: SecretMaterial,
     55 }
     56 impl WorkspaceCrypto {
     57     pub(super) async fn seal_delivery(
     58         &self,
     59         scope: DeliveryScope,
     60         payload: DeliveryPayload,
     61         part: u8,
     62         plaintext: &[u8],
     63     ) -> Result<Vec<u8>, WorkspaceError> {
     64         self.seal_bound(
     65             delivery_context(scope, payload, part)?,
     66             PRIVATE_PAYLOAD_MAX_BYTES,
     67             plaintext,
     68         )
     69         .await
     70     }
     71     pub(super) async fn open_delivery(
     72         &self,
     73         scope: DeliveryScope,
     74         payload: DeliveryPayload,
     75         part: u8,
     76         protected: &[u8],
     77     ) -> Result<SecretMaterial, WorkspaceError> {
     78         self.open_bound(
     79             delivery_context(scope, payload, part)?,
     80             PRIVATE_PAYLOAD_MAX_BYTES,
     81             protected,
     82         )
     83         .await
     84     }
     85     pub(super) async fn seal_message(
     86         &self,
     87         workspace: WorkspaceId,
     88         operation: OperationId,
     89         plan: &[u8; 32],
     90         plaintext: &[u8],
     91     ) -> Result<Vec<u8>, WorkspaceError> {
     92         self.seal_bound(
     93             message_context(workspace, operation, plan)?,
     94             PRIVATE_PAYLOAD_MAX_BYTES,
     95             plaintext,
     96         )
     97         .await
     98     }
     99     pub(super) async fn open_message(
    100         &self,
    101         workspace: WorkspaceId,
    102         operation: OperationId,
    103         plan: &[u8; 32],
    104         protected: &[u8],
    105     ) -> Result<SecretMaterial, WorkspaceError> {
    106         self.open_bound(
    107             message_context(workspace, operation, plan)?,
    108             PRIVATE_PAYLOAD_MAX_BYTES,
    109             protected,
    110         )
    111         .await
    112     }
    113     /// Binds protected host input to one exact persistent provider/ref. Actual
    114     /// provider access and context authentication still execute at seal/open.
    115     pub fn new(
    116         provider: Arc<dyn SecretProvider>,
    117         reference: SecretRef,
    118         key: SecretMaterial,
    119         policy: AccessPolicy,
    120     ) -> Result<Self, WorkspaceError> {
    121         if key.len() != 32 || provider.capabilities().residency() == ResidencySupport::Volatile {
    122             return Err(WorkspaceError::Unavailable);
    123         }
    124         SelectionPolicy::new(reference.backend(), policy)
    125             .select(&[provider.as_ref()])
    126             .map_err(|_| WorkspaceError::Unavailable)?;
    127         Ok(Self {
    128             provider,
    129             reference,
    130             key,
    131         })
    132     }
    133     pub(super) async fn seal(
    134         &self,
    135         workspace: WorkspaceId,
    136         grant: GrantId,
    137         plaintext: &[u8],
    138     ) -> Result<Vec<u8>, WorkspaceError> {
    139         self.seal_bound(
    140             context(workspace, grant)?,
    141             PRIVATE_PAYLOAD_MAX_BYTES,
    142             plaintext,
    143         )
    144         .await
    145     }
    146     pub(super) async fn seal_stock_root(
    147         &self,
    148         input: &super::AttachmentInput,
    149         version: i64,
    150         clear: &[u8],
    151     ) -> Result<Vec<u8>, WorkspaceError> {
    152         self.seal_bound(
    153             stock_root_context(input, version)?,
    154             PRIVATE_PAYLOAD_MAX_BYTES,
    155             clear,
    156         )
    157         .await
    158     }
    159     pub(super) async fn open_stock_root(
    160         &self,
    161         input: &super::AttachmentInput,
    162         version: i64,
    163         protected: &[u8],
    164     ) -> Result<SecretMaterial, WorkspaceError> {
    165         self.open_bound(
    166             stock_root_context(input, version)?,
    167             PRIVATE_PAYLOAD_MAX_BYTES,
    168             protected,
    169         )
    170         .await
    171     }
    172     pub(super) async fn seal_stock_record_for_catalog(
    173         &self,
    174         input: &super::AttachmentInput,
    175         kind: &str,
    176         id: &[u8; 32],
    177         catalog: i64,
    178         clear: &[u8],
    179     ) -> Result<Vec<u8>, WorkspaceError> {
    180         self.seal_bound(
    181             stock_record_context_for_catalog(input, kind, id, catalog)?,
    182             PRIVATE_PAYLOAD_MAX_BYTES,
    183             clear,
    184         )
    185         .await
    186     }
    187     pub(super) async fn open_stock_record_for_catalog(
    188         &self,
    189         input: &super::AttachmentInput,
    190         kind: &str,
    191         id: &[u8; 32],
    192         catalog: i64,
    193         protected: &[u8],
    194     ) -> Result<SecretMaterial, WorkspaceError> {
    195         self.open_bound(
    196             stock_record_context_for_catalog(input, kind, id, catalog)?,
    197             PRIVATE_PAYLOAD_MAX_BYTES,
    198             protected,
    199         )
    200         .await
    201     }
    202     pub(super) async fn seal_stock_record(
    203         &self,
    204         input: &super::AttachmentInput,
    205         kind: &str,
    206         id: &[u8; 32],
    207         clear: &[u8],
    208     ) -> Result<Vec<u8>, WorkspaceError> {
    209         self.seal_bound(
    210             stock_record_context(input, kind, id)?,
    211             PRIVATE_PAYLOAD_MAX_BYTES,
    212             clear,
    213         )
    214         .await
    215     }
    216     pub(super) async fn open_stock_record(
    217         &self,
    218         input: &super::AttachmentInput,
    219         kind: &str,
    220         id: &[u8; 32],
    221         protected: &[u8],
    222     ) -> Result<SecretMaterial, WorkspaceError> {
    223         self.open_bound(
    224             stock_record_context(input, kind, id)?,
    225             PRIVATE_PAYLOAD_MAX_BYTES,
    226             protected,
    227         )
    228         .await
    229     }
    230     pub(super) async fn seal_stock(
    231         &self,
    232         input: &super::AttachmentInput,
    233         authority: bool,
    234         plaintext: &[u8],
    235     ) -> Result<Vec<u8>, WorkspaceError> {
    236         self.seal_bound(
    237             stock_context(input, authority)?,
    238             PRIVATE_PAYLOAD_MAX_BYTES,
    239             plaintext,
    240         )
    241         .await
    242     }
    243     pub(super) async fn open_stock(
    244         &self,
    245         input: &super::AttachmentInput,
    246         authority: bool,
    247         protected: &[u8],
    248     ) -> Result<SecretMaterial, WorkspaceError> {
    249         self.open_bound(
    250             stock_context(input, authority)?,
    251             PRIVATE_PAYLOAD_MAX_BYTES,
    252             protected,
    253         )
    254         .await
    255     }
    256     pub(super) async fn seal_operation(
    257         &self,
    258         workspace: WorkspaceId,
    259         operation: OperationId,
    260         plaintext: &[u8],
    261     ) -> Result<Vec<u8>, WorkspaceError> {
    262         self.seal_bound(operation_context(workspace, operation)?, 65_536, plaintext)
    263             .await
    264     }
    265     pub(super) async fn seal_plan_part(
    266         &self,
    267         workspace: WorkspaceId,
    268         operation: OperationId,
    269         digest: &[u8; 32],
    270         part: u8,
    271         plaintext: &[u8],
    272     ) -> Result<Vec<u8>, WorkspaceError> {
    273         self.seal_bound(
    274             plan_context(workspace, operation, digest, part)?,
    275             PRIVATE_PAYLOAD_MAX_BYTES,
    276             plaintext,
    277         )
    278         .await
    279     }
    280     pub(super) async fn open_plan_part(
    281         &self,
    282         workspace: WorkspaceId,
    283         operation: OperationId,
    284         digest: &[u8; 32],
    285         part: u8,
    286         protected: &[u8],
    287     ) -> Result<SecretMaterial, WorkspaceError> {
    288         self.open_bound(
    289             plan_context(workspace, operation, digest, part)?,
    290             PRIVATE_PAYLOAD_MAX_BYTES,
    291             protected,
    292         )
    293         .await
    294     }
    295     pub(super) async fn seal_listing(
    296         &self,
    297         scope: ListingScope,
    298         plaintext: &[u8],
    299     ) -> Result<Vec<u8>, WorkspaceError> {
    300         self.seal_bound(
    301             listing_context(scope)?,
    302             PRIVATE_PAYLOAD_MAX_BYTES,
    303             plaintext,
    304         )
    305         .await
    306     }
    307     pub(super) async fn open_listing(
    308         &self,
    309         scope: ListingScope,
    310         protected: &[u8],
    311     ) -> Result<SecretMaterial, WorkspaceError> {
    312         self.open_bound(
    313             listing_context(scope)?,
    314             PRIVATE_PAYLOAD_MAX_BYTES,
    315             protected,
    316         )
    317         .await
    318     }
    319     pub(super) async fn seal_issuance(
    320         &self,
    321         scope: IssuanceScope,
    322         payload: IssuancePayload,
    323         part: u8,
    324         plaintext: &[u8],
    325     ) -> Result<Vec<u8>, WorkspaceError> {
    326         self.seal_bound(
    327             issuance_context(scope, payload, part)?,
    328             PRIVATE_PAYLOAD_MAX_BYTES,
    329             plaintext,
    330         )
    331         .await
    332     }
    333     pub(super) async fn open_issuance(
    334         &self,
    335         scope: IssuanceScope,
    336         payload: IssuancePayload,
    337         part: u8,
    338         protected: &[u8],
    339     ) -> Result<SecretMaterial, WorkspaceError> {
    340         self.open_bound(
    341             issuance_context(scope, payload, part)?,
    342             PRIVATE_PAYLOAD_MAX_BYTES,
    343             protected,
    344         )
    345         .await
    346     }
    347     async fn seal_bound(
    348         &self,
    349         context: EnvelopeContext,
    350         max_bytes: usize,
    351         plaintext: &[u8],
    352     ) -> Result<Vec<u8>, WorkspaceError> {
    353         if plaintext.len() > max_bytes {
    354             return Err(WorkspaceError::InvalidInput);
    355         }
    356         let plaintext =
    357             SecretMaterial::from_slice(plaintext).map_err(|_| WorkspaceError::InvalidInput)?;
    358         let key = self
    359             .key
    360             .expose_secret(SecretMaterial::from_slice)
    361             .map_err(|_| WorkspaceError::Unavailable)?;
    362         let mut nonce = [0; 24];
    363         getrandom::getrandom(&mut nonce).map_err(|_| WorkspaceError::Unavailable)?;
    364         let envelope = EncryptedEnvelope::seal(
    365             self.provider.as_ref(),
    366             SealRequest::new(
    367                 SecretRef::new(
    368                     self.reference.id().clone(),
    369                     self.reference.backend(),
    370                     self.reference.key_version(),
    371                 ),
    372                 context,
    373                 &plaintext,
    374                 SealMaterial::new(key, Nonce::new(nonce)),
    375             ),
    376         )
    377         .await
    378         .map_err(|_| WorkspaceError::Unavailable)?;
    379         envelope
    380             .encode()
    381             .map_err(|_| WorkspaceError::StorageFailure)
    382     }
    383     pub(super) async fn open(
    384         &self,
    385         workspace: WorkspaceId,
    386         grant: GrantId,
    387         protected: &[u8],
    388     ) -> Result<SecretMaterial, WorkspaceError> {
    389         self.open_bound(
    390             context(workspace, grant)?,
    391             PRIVATE_PAYLOAD_MAX_BYTES,
    392             protected,
    393         )
    394         .await
    395     }
    396     pub(super) async fn open_operation(
    397         &self,
    398         workspace: WorkspaceId,
    399         operation: OperationId,
    400         protected: &[u8],
    401     ) -> Result<SecretMaterial, WorkspaceError> {
    402         self.open_bound(operation_context(workspace, operation)?, 65_536, protected)
    403             .await
    404     }
    405     async fn open_bound(
    406         &self,
    407         context: EnvelopeContext,
    408         max_bytes: usize,
    409         protected: &[u8],
    410     ) -> Result<SecretMaterial, WorkspaceError> {
    411         if protected.len() > PROTECTED_MAX_BYTES {
    412             return Err(WorkspaceError::RecoveryRequired);
    413         }
    414         // A wrong explicitly supplied key cannot silently fall back to a
    415         // different provider-held key, including on a read-only observation.
    416         self.provider
    417             .wrap(radroots_secrets::wrapping::WrapRequest::new(
    418                 &self.reference,
    419                 &context,
    420                 &self.key,
    421             ))
    422             .await
    423             .map_err(|_| WorkspaceError::Unavailable)?;
    424         let envelope =
    425             EncryptedEnvelope::decode(protected).map_err(|_| WorkspaceError::RecoveryRequired)?;
    426         if envelope.reference().id() != self.reference.id()
    427             || envelope.reference().backend() != self.reference.backend()
    428             || envelope.reference().key_version() != self.reference.key_version()
    429         {
    430             return Err(WorkspaceError::RecoveryRequired);
    431         }
    432         let plaintext = envelope
    433             .open(self.provider.as_ref(), &context)
    434             .await
    435             .map_err(|_| WorkspaceError::RecoveryRequired)?;
    436         if plaintext.len() > max_bytes {
    437             return Err(WorkspaceError::RecoveryRequired);
    438         }
    439         Ok(plaintext)
    440     }
    441 }
    442 
    443 fn delivery_context(
    444     scope: DeliveryScope,
    445     payload: DeliveryPayload,
    446     part: u8,
    447 ) -> Result<EnvelopeContext, WorkspaceError> {
    448     use sha2::{Digest, Sha256};
    449     let (tag, mut purpose, mut schema) = match payload {
    450         DeliveryPayload::Attempt => (
    451             0u8,
    452             "radroots.workspace.delivery_attempt",
    453             "radroots.workspace.delivery_attempt.v1",
    454         ),
    455         DeliveryPayload::Observation => (
    456             1u8,
    457             "radroots.workspace.delivery_observation",
    458             "radroots.workspace.delivery_observation.v1",
    459         ),
    460     };
    461     let mut hash = Sha256::new();
    462     hash.update(b"radroots.workspace.delivery.context.v1\0");
    463     hash.update([tag, part]);
    464     hash.update(scope.workspace.as_bytes());
    465     hash.update(scope.operation.as_bytes());
    466     match scope.target {
    467         radroots_storage::command::SigningTarget::BusinessSeal(peer) => {
    468             hash.update(peer.as_bytes())
    469         }
    470         radroots_storage::command::SigningTarget::PublicEvent => {
    471             hash.update(b"public_event.no_recipient.v1\0");
    472             (purpose, schema) = match payload {
    473                 DeliveryPayload::Attempt => (
    474                     "radroots.workspace.public_delivery_attempt",
    475                     "radroots.workspace.public_delivery_attempt.v1",
    476                 ),
    477                 DeliveryPayload::Observation => (
    478                     "radroots.workspace.public_delivery_observation",
    479                     "radroots.workspace.public_delivery_observation.v1",
    480                 ),
    481             };
    482         }
    483     }
    484     hash.update(scope.request);
    485     let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
    486     Ok(EnvelopeContext::new(
    487         EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?,
    488         EnvelopeSubject::parse("workspace_delivery", subject.to_string())
    489             .map_err(|_| WorkspaceError::InvalidInput)?,
    490         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?,
    491     ))
    492 }
    493 impl fmt::Debug for WorkspaceCrypto {
    494     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    495         f.write_str("WorkspaceCrypto(<redacted>)")
    496     }
    497 }
    498 
    499 fn context(workspace: WorkspaceId, grant: GrantId) -> Result<EnvelopeContext, WorkspaceError> {
    500     // Both values are fixed-width lowercase hex; their 128-byte concatenation
    501     // is unambiguous and binds the complete IDs without truncation.
    502     Ok(EnvelopeContext::new(
    503         EnvelopePurpose::parse(GRANT_ENVELOPE_PURPOSE).map_err(|_| WorkspaceError::InvalidInput)?,
    504         EnvelopeSubject::parse("workspace_grant", grant_envelope_subject(workspace, grant))
    505             .map_err(|_| WorkspaceError::InvalidInput)?,
    506         PayloadSchemaId::parse(GRANT_PAYLOAD_SCHEMA).map_err(|_| WorkspaceError::InvalidInput)?,
    507     ))
    508 }
    509 
    510 fn operation_context(
    511     workspace: WorkspaceId,
    512     operation: OperationId,
    513 ) -> Result<EnvelopeContext, WorkspaceError> {
    514     Ok(EnvelopeContext::new(
    515         EnvelopePurpose::parse("radroots.workspace.operation")
    516             .map_err(|_| WorkspaceError::InvalidInput)?,
    517         EnvelopeSubject::parse("workspace_operation", format!("{workspace}{operation}"))
    518             .map_err(|_| WorkspaceError::InvalidInput)?,
    519         PayloadSchemaId::parse("radroots.workspace.operation.v2")
    520             .map_err(|_| WorkspaceError::InvalidInput)?,
    521     ))
    522 }
    523 
    524 fn plan_context(
    525     workspace: WorkspaceId,
    526     operation: OperationId,
    527     digest: &[u8; 32],
    528     part: u8,
    529 ) -> Result<EnvelopeContext, WorkspaceError> {
    530     use sha2::{Digest, Sha256};
    531     let mut hash = Sha256::new();
    532     hash.update(b"radroots.workspace.signing_plan.part.v1\0");
    533     hash.update(workspace.as_bytes());
    534     hash.update(operation.as_bytes());
    535     hash.update(digest);
    536     hash.update([part]);
    537     let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
    538     Ok(EnvelopeContext::new(
    539         EnvelopePurpose::parse("radroots.workspace.signing_plan")
    540             .map_err(|_| WorkspaceError::InvalidInput)?,
    541         EnvelopeSubject::parse("workspace_plan_part", subject.to_string())
    542             .map_err(|_| WorkspaceError::InvalidInput)?,
    543         PayloadSchemaId::parse("radroots.workspace.signing_plan.v1")
    544             .map_err(|_| WorkspaceError::InvalidInput)?,
    545     ))
    546 }
    547 
    548 fn issuance_context(
    549     scope: IssuanceScope,
    550     payload: IssuancePayload,
    551     part: u8,
    552 ) -> Result<EnvelopeContext, WorkspaceError> {
    553     use sha2::{Digest, Sha256};
    554     let (tag, mut purpose, mut schema) = match payload {
    555         IssuancePayload::Attempt => (
    556             0u8,
    557             "radroots.workspace.signing_attempt",
    558             "radroots.workspace.signing_attempt.v1",
    559         ),
    560         IssuancePayload::Evidence => (
    561             1u8,
    562             "radroots.workspace.seal_evidence",
    563             "radroots.workspace.seal_evidence.v1",
    564         ),
    565         IssuancePayload::Publication => (
    566             2u8,
    567             "radroots.workspace.chat_publication_work",
    568             "radroots.workspace.chat_publication_work.v1",
    569         ),
    570         IssuancePayload::ListingInstallation => (
    571             3u8,
    572             "radroots.workspace.listing_installation",
    573             "radroots.workspace.listing_installation.v1",
    574         ),
    575     };
    576     let mut hash = Sha256::new();
    577     hash.update(b"radroots.workspace.issuance.context.v1\0");
    578     hash.update([tag, part]);
    579     hash.update(scope.workspace.as_bytes());
    580     hash.update(scope.operation.as_bytes());
    581     hash.update(scope.plan_digest);
    582     hash.update(scope.attempt.as_bytes());
    583     match scope.target {
    584         radroots_storage::command::SigningTarget::BusinessSeal(recipient) => {
    585             if matches!(payload, IssuancePayload::ListingInstallation) {
    586                 return Err(WorkspaceError::InvalidInput);
    587             }
    588             hash.update(recipient.as_bytes())
    589         }
    590         radroots_storage::command::SigningTarget::PublicEvent => {
    591             (purpose, schema) = match payload {
    592                 IssuancePayload::Attempt => (
    593                     "radroots.workspace.public_signing_attempt",
    594                     "radroots.workspace.public_signing_attempt.v1",
    595                 ),
    596                 IssuancePayload::Evidence => (
    597                     "radroots.workspace.public_artifact_evidence",
    598                     "radroots.workspace.public_artifact_evidence.v1",
    599                 ),
    600                 IssuancePayload::Publication => (
    601                     "radroots.workspace.public_publication_work",
    602                     "radroots.workspace.public_publication_work.v1",
    603                 ),
    604                 IssuancePayload::ListingInstallation => (
    605                     "radroots.workspace.listing_installation",
    606                     "radroots.workspace.listing_installation.v1",
    607                 ),
    608             };
    609             hash.update(b"public_event.no_recipient.v1\0");
    610         }
    611     }
    612     let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
    613     Ok(EnvelopeContext::new(
    614         EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?,
    615         EnvelopeSubject::parse("workspace_issuance", subject.to_string())
    616             .map_err(|_| WorkspaceError::InvalidInput)?,
    617         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?,
    618     ))
    619 }
    620 
    621 fn message_context(
    622     workspace: WorkspaceId,
    623     operation: OperationId,
    624     plan: &[u8; 32],
    625 ) -> Result<EnvelopeContext, WorkspaceError> {
    626     use sha2::{Digest, Sha256};
    627     let mut hash = Sha256::new();
    628     hash.update(b"radroots.workspace.chat_message.context.v1\0");
    629     hash.update(workspace.as_bytes());
    630     hash.update(operation.as_bytes());
    631     hash.update(plan);
    632     let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
    633     Ok(EnvelopeContext::new(
    634         EnvelopePurpose::parse("radroots.workspace.chat_message")
    635             .map_err(|_| WorkspaceError::InvalidInput)?,
    636         EnvelopeSubject::parse("workspace_chat_message", subject.to_string())
    637             .map_err(|_| WorkspaceError::InvalidInput)?,
    638         PayloadSchemaId::parse("radroots.workspace.chat_message.v1")
    639             .map_err(|_| WorkspaceError::InvalidInput)?,
    640     ))
    641 }
    642 
    643 #[derive(Clone, Copy)]
    644 pub(super) enum ListingScope {
    645     Decision {
    646         workspace: WorkspaceId,
    647         operation: OperationId,
    648     },
    649 }
    650 fn listing_context(scope: ListingScope) -> Result<EnvelopeContext, WorkspaceError> {
    651     use sha2::{Digest, Sha256};
    652     let mut hash = Sha256::new();
    653     hash.update(b"radroots.workspace.listing.state.context.v1\0");
    654     let (purpose, schema) = match scope {
    655         ListingScope::Decision {
    656             workspace,
    657             operation,
    658         } => {
    659             hash.update([0]);
    660             hash.update(workspace.as_bytes());
    661             hash.update(operation.as_bytes());
    662             (
    663                 "radroots.workspace.listing_decision",
    664                 "radroots.workspace.listing_decision.v1",
    665             )
    666         }
    667     };
    668     let digest = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
    669     Ok(EnvelopeContext::new(
    670         EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?,
    671         EnvelopeSubject::parse("workspace_listing", digest.to_string())
    672             .map_err(|_| WorkspaceError::InvalidInput)?,
    673         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?,
    674     ))
    675 }
    676 
    677 fn stock_context(
    678     input: &super::AttachmentInput,
    679     authority: bool,
    680 ) -> Result<EnvelopeContext, WorkspaceError> {
    681     let (purpose, schema) = if authority {
    682         (
    683             "radroots.seller_stock.authority",
    684             "radroots.seller_stock.authority.v1",
    685         )
    686     } else {
    687         (
    688             "radroots.seller_stock.grant",
    689             "radroots.seller_stock.grant.v1",
    690         )
    691     };
    692     use sha2::{Digest, Sha256};
    693     let mut subject = Sha256::new();
    694     subject.update(b"radroots.seller_stock.context.v1\0");
    695     subject.update(input.workspace_id().as_bytes());
    696     subject.update(input.authority().executor_id().as_bytes());
    697     subject.update(input.authority().generation().get().to_be_bytes());
    698     subject.update(input.grant_id().as_bytes());
    699     let subject = radroots_domain::CommandDigest::from_bytes(subject.finalize().into());
    700     Ok(EnvelopeContext::new(
    701         EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?,
    702         EnvelopeSubject::parse("seller_stock", subject.to_string())
    703             .map_err(|_| WorkspaceError::InvalidInput)?,
    704         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?,
    705     ))
    706 }
    707 
    708 fn stock_root_context(
    709     input: &super::AttachmentInput,
    710     version: i64,
    711 ) -> Result<EnvelopeContext, WorkspaceError> {
    712     if matches!(version, 4..=20) {
    713         use sha2::{Digest, Sha256};
    714         let namespace =
    715             radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment(
    716                 input,
    717             );
    718         let wire = zeroize::Zeroizing::new(
    719             serde_json::to_vec(&namespace).map_err(|_| WorkspaceError::InvalidInput)?,
    720         );
    721         if wire.len() > PRIVATE_PAYLOAD_MAX_BYTES {
    722             return Err(WorkspaceError::InvalidInput);
    723         }
    724         let mut hash = Sha256::new();
    725         hash.update(if version == 4 {
    726             b"radroots.seller_stock.authority_context.v4\0"
    727         } else if version == 5 {
    728             b"radroots.seller_stock.authority_context.v5\0"
    729         } else if version == 6 {
    730             b"radroots.seller_stock.authority_context.v6\0"
    731         } else if version == 7 {
    732             b"radroots.seller_stock.authority_context.v7\0"
    733         } else if version == 8 {
    734             b"radroots.seller_stock.authority_context.v8\0"
    735         } else if version == 9 {
    736             b"radroots.seller_stock.authority_context.v9\0"
    737         } else if version == 10 {
    738             b"radroots.seller_stock.authority_context.v10\0".as_slice()
    739         } else if version == 11 {
    740             b"radroots.seller_stock.authority_context.v11\0".as_slice()
    741         } else if version == 12 {
    742             b"radroots.seller_stock.authority_context.v12\0".as_slice()
    743         } else if version == 13 {
    744             b"radroots.seller_stock.authority_context.v13\0".as_slice()
    745         } else if version == 14 {
    746             b"radroots.seller_stock.authority_context.v14\0".as_slice()
    747         } else if version == 15 {
    748             b"radroots.seller_stock.authority_context.v15\0".as_slice()
    749         } else if version == 16 {
    750             b"radroots.seller_stock.authority_context.v16\0".as_slice()
    751         } else if version == 17 {
    752             b"radroots.seller_stock.authority_context.v17\0".as_slice()
    753         } else if version == 18 {
    754             b"radroots.seller_stock.authority_context.v18\0".as_slice()
    755         } else if version == 19 {
    756             b"radroots.seller_stock.authority_context.v19\0".as_slice()
    757         } else {
    758             b"radroots.seller_stock.authority_context.v20\0".as_slice()
    759         });
    760         hash.update(wire.as_slice());
    761         let subject = radroots_domain::CommandDigest::from_bytes(hash.finalize().into());
    762         return Ok(EnvelopeContext::new(
    763             EnvelopePurpose::parse("radroots.seller_stock.authority")
    764                 .map_err(|_| WorkspaceError::InvalidInput)?,
    765             EnvelopeSubject::parse("seller_stock", subject.to_string())
    766                 .map_err(|_| WorkspaceError::InvalidInput)?,
    767             PayloadSchemaId::parse(if version == 4 {
    768                 "radroots.seller_stock.authority.v4"
    769             } else if version == 5 {
    770                 "radroots.seller_stock.authority.v5"
    771             } else if version == 6 {
    772                 "radroots.seller_stock.authority.v6"
    773             } else if version == 7 {
    774                 "radroots.seller_stock.authority.v7"
    775             } else if version == 8 {
    776                 "radroots.seller_stock.authority.v8"
    777             } else if version == 9 {
    778                 "radroots.seller_stock.authority.v9"
    779             } else if version == 10 {
    780                 "radroots.seller_stock.authority.v10"
    781             } else if version == 11 {
    782                 "radroots.seller_stock.authority.v11"
    783             } else if version == 12 {
    784                 "radroots.seller_stock.authority.v12"
    785             } else if version == 13 {
    786                 "radroots.seller_stock.authority.v13"
    787             } else if version == 14 {
    788                 "radroots.seller_stock.authority.v14"
    789             } else if version == 15 {
    790                 "radroots.seller_stock.authority.v15"
    791             } else if version == 16 {
    792                 "radroots.seller_stock.authority.v16"
    793             } else if version == 17 {
    794                 "radroots.seller_stock.authority.v17"
    795             } else if version == 18 {
    796                 "radroots.seller_stock.authority.v18"
    797             } else if version == 19 {
    798                 "radroots.seller_stock.authority.v19"
    799             } else {
    800                 "radroots.seller_stock.authority.v20"
    801             })
    802             .map_err(|_| WorkspaceError::InvalidInput)?,
    803         ));
    804     }
    805     let schema = match version {
    806         1 => "radroots.seller_stock.authority.v1",
    807         2 => "radroots.seller_stock.authority.v2",
    808         3 => "radroots.seller_stock.authority.v3",
    809         _ => return Err(WorkspaceError::RecoveryRequired),
    810     };
    811     let original = stock_context(input, true)?;
    812     Ok(EnvelopeContext::new(
    813         original.purpose().clone(),
    814         original.subject().clone(),
    815         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?,
    816     ))
    817 }
    818 fn stock_record_context(
    819     input: &super::AttachmentInput,
    820     kind: &str,
    821     id: &[u8; 32],
    822 ) -> Result<EnvelopeContext, WorkspaceError> {
    823     use sha2::{Digest, Sha256};
    824     let (purpose, schema) = match kind {
    825         "grant_change" => (
    826             "radroots.seller_stock.grant_change",
    827             "radroots.seller_stock.grant_change.v1",
    828         ),
    829         "mapping" => (
    830             "radroots.seller_stock.mapping",
    831             "radroots.seller_stock.mapping.v1",
    832         ),
    833         "source_record" => (
    834             "radroots.seller_stock.source_record",
    835             "radroots.seller_stock.source_record.v1",
    836         ),
    837         "public_event" => (
    838             "radroots.seller_stock.public_source_event",
    839             "radroots.seller_stock.public_source_event.v1",
    840         ),
    841         "public_head" => (
    842             "radroots.seller_stock.public_source_head",
    843             "radroots.seller_stock.public_source_head.v1",
    844         ),
    845         "public_part" => (
    846             "radroots.seller_stock.public_source_part",
    847             "radroots.seller_stock.public_source_part.v1",
    848         ),
    849         "order" => (
    850             "radroots.seller_stock.order",
    851             "radroots.seller_stock.order.v1",
    852         ),
    853         "abort_movement" => (
    854             "radroots.seller_stock.abort_movement",
    855             "radroots.seller_stock.abort_movement.v1",
    856         ),
    857         "installation_movement" => (
    858             "radroots.seller_stock.installation_movement",
    859             "radroots.seller_stock.installation_movement.v1",
    860         ),
    861         "acceptance_movement" => (
    862             "radroots.seller_stock.acceptance_movement",
    863             "radroots.seller_stock.acceptance_movement.v1",
    864         ),
    865         "operation_part" => (
    866             "radroots.seller_stock.operation_part",
    867             "radroots.seller_stock.operation_part.v1",
    868         ),
    869         "source_evidence" => (
    870             "radroots.seller_stock.source_evidence",
    871             "radroots.seller_stock.source_evidence.v1",
    872         ),
    873         "source_part" => (
    874             "radroots.seller_stock.source_part",
    875             "radroots.seller_stock.source_part.v1",
    876         ),
    877         "grant" => (
    878             "radroots.seller_stock.grant",
    879             "radroots.seller_stock.grant.v2",
    880         ),
    881         "replacement_movement" => (
    882             "radroots.seller_stock.installation_movement",
    883             "radroots.seller_stock.installation_movement.v2",
    884         ),
    885         "pool" => (
    886             "radroots.seller_stock.pool",
    887             "radroots.seller_stock.pool.v1",
    888         ),
    889         "operation" => (
    890             "radroots.seller_stock.operation",
    891             "radroots.seller_stock.operation.v1",
    892         ),
    893         "movement" => (
    894             "radroots.seller_stock.movement",
    895             "radroots.seller_stock.movement.v1",
    896         ),
    897         _ => return Err(WorkspaceError::InvalidInput),
    898     };
    899     let mut h = Sha256::new();
    900     h.update(b"radroots.seller_stock.record_context.v1\0");
    901     h.update(input.workspace_id().as_bytes());
    902     h.update(input.authority().executor_id().as_bytes());
    903     h.update(input.authority().generation().get().to_be_bytes());
    904     h.update(id);
    905     let id = radroots_domain::CommandDigest::from_bytes(h.finalize().into());
    906     Ok(EnvelopeContext::new(
    907         EnvelopePurpose::parse(purpose).map_err(|_| WorkspaceError::InvalidInput)?,
    908         EnvelopeSubject::parse("stock_record", id.to_string())
    909             .map_err(|_| WorkspaceError::InvalidInput)?,
    910         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::InvalidInput)?,
    911     ))
    912 }
    913 
    914 fn stock_record_context_for_catalog(
    915     input: &super::AttachmentInput,
    916     kind: &str,
    917     id: &[u8; 32],
    918     catalog: i64,
    919 ) -> Result<EnvelopeContext, WorkspaceError> {
    920     let original = stock_record_context(input, kind, id)?;
    921     let schema = match (catalog, kind) {
    922         (2, _) | (3..=20, "pool") => return Ok(original),
    923         (3, "operation") => "radroots.seller_stock.operation.v2",
    924         (4, "operation") => "radroots.seller_stock.operation.v3",
    925         (5 | 6, "operation") => "radroots.seller_stock.operation.v4",
    926         (7..=20, "operation") => "radroots.seller_stock.operation.v5",
    927         (3..=20, "movement") => "radroots.seller_stock.movement.v2",
    928         _ => return Err(WorkspaceError::RecoveryRequired),
    929     };
    930     Ok(EnvelopeContext::new(
    931         original.purpose().clone(),
    932         original.subject().clone(),
    933         PayloadSchemaId::parse(schema).map_err(|_| WorkspaceError::RecoveryRequired)?,
    934     ))
    935 }