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 }