crypto.rs (4252B)
1 use js_sys::Reflect; 2 use radroots_domain::{GrantId, WorkspaceId}; 3 use radroots_secrets::{ 4 EncryptedEnvelope, SecretRef, 5 context::{EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId}, 6 envelope::{Nonce, SealMaterial, SealRequest}, 7 provider::SecretProvider, 8 wrapping::SecretMaterial, 9 }; 10 use radroots_storage::workspace::grant::grant_envelope_subject; 11 use radroots_storage::workspace::{WorkspaceError, grant::GRANT_BYTES_MAX}; 12 use wasm_bindgen::{JsCast, JsValue}; 13 use zeroize::Zeroizing; 14 15 pub(super) const PROTECTED_MAX: usize = 32 * 1024; 16 pub(super) fn random<const N: usize>() -> Result<Zeroizing<[u8; N]>, WorkspaceError> { 17 let crypto = Reflect::get(&js_sys::global(), &JsValue::from_str("crypto")) 18 .map_err(|_| WorkspaceError::Unavailable)? 19 .dyn_into::<web_sys::Crypto>() 20 .map_err(|_| WorkspaceError::Unavailable)?; 21 let mut bytes = Zeroizing::new([0; N]); 22 crypto 23 .get_random_values_with_u8_array(bytes.as_mut()) 24 .map_err(|_| WorkspaceError::Unavailable)?; 25 Ok(bytes) 26 } 27 fn context(workspace: WorkspaceId, grant: GrantId) -> Result<EnvelopeContext, WorkspaceError> { 28 Ok(EnvelopeContext::new( 29 EnvelopePurpose::parse("radroots.browser.workspace.grant") 30 .map_err(|_| WorkspaceError::InvalidInput)?, 31 EnvelopeSubject::parse("workspace_grant", grant_envelope_subject(workspace, grant)) 32 .map_err(|_| WorkspaceError::InvalidInput)?, 33 PayloadSchemaId::parse("radroots.browser.workspace.grant.v2") 34 .map_err(|_| WorkspaceError::InvalidInput)?, 35 )) 36 } 37 pub(super) async fn seal( 38 provider: &dyn SecretProvider, 39 reference: &SecretRef, 40 workspace: WorkspaceId, 41 grant: GrantId, 42 plaintext: &[u8], 43 ) -> Result<Vec<u8>, WorkspaceError> { 44 seal_bound(provider, reference, context(workspace, grant)?, plaintext).await 45 } 46 pub(super) async fn seal_bound( 47 provider: &dyn SecretProvider, 48 reference: &SecretRef, 49 context: EnvelopeContext, 50 plaintext: &[u8], 51 ) -> Result<Vec<u8>, WorkspaceError> { 52 if plaintext.len() > GRANT_BYTES_MAX { 53 return Err(WorkspaceError::InvalidInput); 54 } 55 let key = random::<32>()?; 56 let material = 57 SecretMaterial::from_slice(key.as_ref()).map_err(|_| WorkspaceError::Unavailable)?; 58 let plaintext = 59 SecretMaterial::from_slice(plaintext).map_err(|_| WorkspaceError::InvalidInput)?; 60 let nonce = random::<24>()?; 61 let result = EncryptedEnvelope::seal( 62 provider, 63 SealRequest::new( 64 SecretRef::new( 65 reference.id().clone(), 66 reference.backend(), 67 reference.key_version(), 68 ), 69 context, 70 &plaintext, 71 SealMaterial::new(material, Nonce::new(*nonce)), 72 ), 73 ) 74 .await 75 .map_err(|_| WorkspaceError::Unavailable)? 76 .encode() 77 .map_err(|_| WorkspaceError::StorageFailure)?; 78 if result.len() > PROTECTED_MAX { 79 return Err(WorkspaceError::InvalidInput); 80 } 81 Ok(result) 82 } 83 pub(super) async fn open( 84 provider: &dyn SecretProvider, 85 reference: &SecretRef, 86 workspace: WorkspaceId, 87 grant: GrantId, 88 protected: &[u8], 89 ) -> Result<SecretMaterial, WorkspaceError> { 90 open_bound(provider, reference, context(workspace, grant)?, protected).await 91 } 92 pub(super) async fn open_bound( 93 provider: &dyn SecretProvider, 94 reference: &SecretRef, 95 context: EnvelopeContext, 96 protected: &[u8], 97 ) -> Result<SecretMaterial, WorkspaceError> { 98 if protected.len() > PROTECTED_MAX { 99 return Err(WorkspaceError::RecoveryRequired); 100 } 101 let envelope = 102 EncryptedEnvelope::decode(protected).map_err(|_| WorkspaceError::RecoveryRequired)?; 103 if envelope.reference().backend() != reference.backend() 104 || envelope.reference().id() != reference.id() 105 || envelope.reference().key_version() != reference.key_version() 106 { 107 return Err(WorkspaceError::RecoveryRequired); 108 } 109 let plaintext = envelope 110 .open(provider, &context) 111 .await 112 .map_err(|_| WorkspaceError::RecoveryRequired)?; 113 if plaintext.len() > GRANT_BYTES_MAX { 114 return Err(WorkspaceError::RecoveryRequired); 115 } 116 Ok(plaintext) 117 }