lib

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

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 }