lib

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

crypto.rs (7912B)


      1 use super::BrowserError;
      2 use crate::{
      3     SecretId, SecretRef,
      4     context::EnvelopeContext,
      5     wrapping::{SecretMaterial, WrappedSecret},
      6 };
      7 use js_sys::{Array, ArrayBuffer, Reflect, Uint8Array};
      8 use sha2::{Digest, Sha256};
      9 use wasm_bindgen::{JsCast, JsValue};
     10 use wasm_bindgen_futures::JsFuture;
     11 use web_sys::{AesKeyGenParams, Crypto, CryptoKey, HkdfParams, SubtleCrypto};
     12 
     13 const HEADER: &[u8; 5] = b"RRBW\x01";
     14 const ENCODED_BYTES: usize = 45;
     15 
     16 struct PlainBytes(Uint8Array);
     17 impl Drop for PlainBytes {
     18     fn drop(&mut self) {
     19         self.0.fill(0, 0, self.0.length());
     20     }
     21 }
     22 fn usages(names: &[&str]) -> Array {
     23     names.iter().map(|name| JsValue::from_str(name)).collect()
     24 }
     25 pub(super) fn host() -> Result<(Crypto, SubtleCrypto), BrowserError> {
     26     let crypto = Reflect::get(&js_sys::global(), &JsValue::from_str("crypto"))
     27         .map_err(|_| BrowserError::Unavailable)?
     28         .dyn_into::<Crypto>()
     29         .map_err(|_| BrowserError::Unavailable)?;
     30     let subtle = Reflect::get(crypto.as_ref(), &JsValue::from_str("subtle"))
     31         .map_err(|_| BrowserError::Unavailable)?
     32         .dyn_into::<SubtleCrypto>()
     33         .map_err(|_| BrowserError::Unavailable)?;
     34     Ok((crypto, subtle))
     35 }
     36 pub(super) async fn generate(
     37     crypto: &Crypto,
     38     subtle: &SubtleCrypto,
     39 ) -> Result<CryptoKey, BrowserError> {
     40     let seed = PlainBytes(Uint8Array::new_with_length(32));
     41     crypto
     42         .get_random_values_with_js_u8_array(&seed.0)
     43         .map_err(|_| BrowserError::Unavailable)?;
     44     let promise = subtle
     45         .import_key_with_str("raw", &seed.0, "HKDF", false, &usages(&["deriveKey"]))
     46         .map_err(|_| BrowserError::Unavailable)?;
     47     let key = JsFuture::from(promise)
     48         .await
     49         .map_err(|_| BrowserError::Unavailable)?
     50         .dyn_into::<CryptoKey>()
     51         .map_err(|_| BrowserError::KeyMismatch)?;
     52     validate(&key)?;
     53     Ok(key)
     54 }
     55 pub(super) fn validate(key: &CryptoKey) -> Result<(), BrowserError> {
     56     let algorithm = key.algorithm().map_err(|_| BrowserError::KeyMismatch)?;
     57     if key.type_() != "secret"
     58         || key.extractable()
     59         || key.usages().length() != 1
     60         || key.usages().get(0).as_string().as_deref() != Some("deriveKey")
     61         || Reflect::get(&algorithm, &JsValue::from_str("name"))
     62             .ok()
     63             .and_then(|v| v.as_string())
     64             .as_deref()
     65             != Some("HKDF")
     66     {
     67         return Err(BrowserError::KeyMismatch);
     68     }
     69     Ok(())
     70 }
     71 fn scope(namespace: &SecretId, reference: &SecretRef) -> [u8; 32] {
     72     let mut hash = Sha256::new();
     73     hash.update(b"radroots.browser.key_scope.v1\0");
     74     for value in [namespace.as_str(), reference.id().as_str()] {
     75         hash.update((value.len() as u16).to_be_bytes());
     76         hash.update(value.as_bytes());
     77     }
     78     hash.update(reference.key_version().get().to_be_bytes());
     79     hash.finalize().into()
     80 }
     81 async fn derive(
     82     subtle: &SubtleCrypto,
     83     key: &CryptoKey,
     84     namespace: &SecretId,
     85     reference: &SecretRef,
     86     context: Option<&EnvelopeContext>,
     87 ) -> Result<CryptoKey, BrowserError> {
     88     validate(key)?;
     89     let salt = Uint8Array::from(scope(namespace, reference).as_slice());
     90     let mut info = Vec::from(if context.is_some() {
     91         b"radroots.browser.key_wrap.v1\0".as_slice()
     92     } else {
     93         b"radroots.browser.key_probe.v1\0".as_slice()
     94     });
     95     if let Some(context) = context {
     96         info.extend_from_slice(&context.authentication_digest());
     97     }
     98     let params =
     99         HkdfParams::new_with_str("HKDF", "SHA-256", &Uint8Array::from(info.as_slice()), &salt);
    100     let algorithm = AesKeyGenParams::new("AES-KW", 256);
    101     let promise = subtle
    102         .derive_key_with_object_and_object(
    103             &params,
    104             key,
    105             &algorithm,
    106             false,
    107             &usages(&["wrapKey", "unwrapKey"]),
    108         )
    109         .map_err(|_| BrowserError::Unavailable)?;
    110     JsFuture::from(promise)
    111         .await
    112         .map_err(|_| BrowserError::Unavailable)?
    113         .dyn_into::<CryptoKey>()
    114         .map_err(|_| BrowserError::KeyMismatch)
    115 }
    116 async fn encode(
    117     subtle: &SubtleCrypto,
    118     wrapping: &CryptoKey,
    119     bytes: &[u8],
    120 ) -> Result<Vec<u8>, BrowserError> {
    121     if bytes.len() != 32 {
    122         return Err(BrowserError::Provider(crate::Error::InvalidDataKeyLength {
    123             actual_bytes: bytes.len(),
    124         }));
    125     }
    126     let raw = PlainBytes(Uint8Array::from(bytes));
    127     let promise = subtle
    128         .import_key_with_str("raw", &raw.0, "AES-GCM", true, &usages(&["encrypt"]))
    129         .map_err(|_| BrowserError::Unavailable)?;
    130     let data_key = JsFuture::from(promise)
    131         .await
    132         .map_err(|_| BrowserError::Unavailable)?
    133         .dyn_into::<CryptoKey>()
    134         .map_err(|_| BrowserError::KeyMismatch)?;
    135     let promise = subtle
    136         .wrap_key_with_str("raw", &data_key, wrapping, "AES-KW")
    137         .map_err(|_| BrowserError::Unavailable)?;
    138     let buffer = JsFuture::from(promise)
    139         .await
    140         .map_err(|_| BrowserError::Unavailable)?
    141         .dyn_into::<ArrayBuffer>()
    142         .map_err(|_| BrowserError::KeyMismatch)?;
    143     if buffer.byte_length() != 40 {
    144         return Err(BrowserError::KeyMismatch);
    145     }
    146     Ok(Uint8Array::new(&buffer).to_vec())
    147 }
    148 pub(super) async fn fingerprint(
    149     subtle: &SubtleCrypto,
    150     key: &CryptoKey,
    151     namespace: &SecretId,
    152     reference: &SecretRef,
    153 ) -> Result<[u8; 32], BrowserError> {
    154     let derived = derive(subtle, key, namespace, reference, None).await?;
    155     // Public fixed probe in its own KDF domain; no payload or provider key is exposed.
    156     Ok(Sha256::digest(encode(subtle, &derived, &[0xa5; 32]).await?).into())
    157 }
    158 pub(super) async fn wrap(
    159     subtle: &SubtleCrypto,
    160     key: &CryptoKey,
    161     namespace: &SecretId,
    162     reference: &SecretRef,
    163     context: &EnvelopeContext,
    164     plaintext: &SecretMaterial,
    165 ) -> Result<WrappedSecret, BrowserError> {
    166     let derived = derive(subtle, key, namespace, reference, Some(context)).await?;
    167     let raw = plaintext.expose_secret(|bytes| zeroize::Zeroizing::new(bytes.to_vec()));
    168     let mut encoded = Vec::from(HEADER.as_slice());
    169     encoded.extend_from_slice(&encode(subtle, &derived, raw.as_slice()).await?);
    170     WrappedSecret::from_bytes(encoded).map_err(BrowserError::Provider)
    171 }
    172 pub(super) fn validate_wrapped(wrapped: &WrappedSecret) -> Result<(), BrowserError> {
    173     if wrapped.as_bytes().len() != ENCODED_BYTES || !wrapped.as_bytes().starts_with(HEADER) {
    174         return Err(BrowserError::KeyMismatch);
    175     }
    176     Ok(())
    177 }
    178 pub(super) async fn unwrap(
    179     subtle: &SubtleCrypto,
    180     key: &CryptoKey,
    181     namespace: &SecretId,
    182     reference: &SecretRef,
    183     context: &EnvelopeContext,
    184     wrapped: &WrappedSecret,
    185 ) -> Result<SecretMaterial, BrowserError> {
    186     validate_wrapped(wrapped)?;
    187     let derived = derive(subtle, key, namespace, reference, Some(context)).await?;
    188     let ciphertext = Uint8Array::from(&wrapped.as_bytes()[HEADER.len()..]);
    189     let promise = subtle
    190         .unwrap_key_with_buffer_source_and_str_and_str(
    191             "raw",
    192             &ciphertext,
    193             &derived,
    194             "AES-KW",
    195             "AES-GCM",
    196             true,
    197             &usages(&["encrypt"]),
    198         )
    199         .map_err(|_| BrowserError::KeyMismatch)?;
    200     let data_key = JsFuture::from(promise)
    201         .await
    202         .map_err(|_| BrowserError::KeyMismatch)?
    203         .dyn_into::<CryptoKey>()
    204         .map_err(|_| BrowserError::KeyMismatch)?;
    205     let promise = subtle
    206         .export_key("raw", &data_key)
    207         .map_err(|_| BrowserError::KeyMismatch)?;
    208     let buffer = JsFuture::from(promise)
    209         .await
    210         .map_err(|_| BrowserError::KeyMismatch)?
    211         .dyn_into::<ArrayBuffer>()
    212         .map_err(|_| BrowserError::KeyMismatch)?;
    213     let plaintext = PlainBytes(Uint8Array::new(&buffer));
    214     if plaintext.0.length() != 32 {
    215         return Err(BrowserError::KeyMismatch);
    216     }
    217     SecretMaterial::from_owned(plaintext.0.to_vec()).map_err(BrowserError::Provider)
    218 }