lib

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

persistent.rs (9020B)


      1 use futures::FutureExt;
      2 use radroots_secrets::{
      3     EncryptedEnvelope, KeyWrapping, SecretId, SecretProvider, SecretRef,
      4     browser::BrowserProvider,
      5     context::{EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId},
      6     envelope::{Nonce, SealMaterial, SealRequest},
      7     id::{BackendKind, KeyVersion},
      8     provider::{
      9         AccessPolicy, CapabilitySupport, HardwarePolicy, ResidencyPolicy, ResidencySupport,
     10         SelectionPolicy, UserPresencePolicy,
     11     },
     12     wrapping::{SecretMaterial, UnwrapRequest, WrapRequest},
     13 };
     14 use wasm_bindgen::JsCast;
     15 use wasm_bindgen::prelude::*;
     16 
     17 fn reference() -> SecretRef {
     18     SecretRef::new(
     19         SecretId::parse("persistent_fixture_key").unwrap(),
     20         BackendKind::External,
     21         KeyVersion::new(1).unwrap(),
     22     )
     23 }
     24 fn namespace(n: u8) -> SecretId {
     25     SecretId::parse(format!("persistent_fixture_{n}")).unwrap()
     26 }
     27 fn context(n: u8) -> EnvelopeContext {
     28     EnvelopeContext::new(
     29         EnvelopePurpose::parse("radroots.persistent_fixture").unwrap(),
     30         EnvelopeSubject::parse("fixture", n.to_string()).unwrap(),
     31         PayloadSchemaId::parse("radroots.persistent_fixture.v1").unwrap(),
     32     )
     33 }
     34 fn fail(_: radroots_secrets::Error) -> JsValue {
     35     JsValue::from_str("persistent_crypto_refused")
     36 }
     37 fn rng() -> web_sys::Crypto {
     38     js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("crypto"))
     39         .unwrap()
     40         .dyn_into()
     41         .unwrap()
     42 }
     43 
     44 #[wasm_bindgen]
     45 pub struct Persistent {
     46     provider: BrowserProvider,
     47     n: u8,
     48 }
     49 #[wasm_bindgen]
     50 impl Persistent {
     51     pub fn abandon_setup_batch(first: u8) -> Result<(), JsValue> {
     52         for n in first..first + 32 {
     53             Self::abandon_create(n)?;
     54         }
     55         if !matches!(
     56             BrowserProvider::create(namespace(first + 32), reference()).now_or_never(),
     57             Some(Err(radroots_secrets::browser::BrowserError::Capacity))
     58         ) {
     59             return Err(JsValue::from_str("setup_admission_was_not_bounded"));
     60         }
     61         if !matches!(
     62             BrowserProvider::open(namespace(first), reference(), [0; 32]).now_or_never(),
     63             Some(Err(radroots_secrets::browser::BrowserError::Capacity))
     64         ) {
     65             return Err(JsValue::from_str("setup_open_admission_was_not_bounded"));
     66         }
     67         Ok(())
     68     }
     69     pub fn abandon_create(n: u8) -> Result<(), JsValue> {
     70         if BrowserProvider::create(namespace(n), reference())
     71             .now_or_never()
     72             .is_some()
     73         {
     74             return Err(JsValue::from_str("unexpected_immediate_create"));
     75         }
     76         Ok(())
     77     }
     78     pub async fn create(n: u8) -> Result<Persistent, JsValue> {
     79         Ok(Self {
     80             provider: BrowserProvider::create(namespace(n), reference())
     81                 .await
     82                 .map_err(|e| JsValue::from_str(e.code()))?,
     83             n,
     84         })
     85     }
     86     pub async fn open(n: u8, fingerprint: Vec<u8>) -> Result<Persistent, JsValue> {
     87         let fingerprint = fingerprint
     88             .as_slice()
     89             .try_into()
     90             .map_err(|_| JsValue::from_str("invalid_fingerprint"))?;
     91         Ok(Self {
     92             provider: BrowserProvider::open(namespace(n), reference(), fingerprint)
     93                 .await
     94                 .map_err(|e| JsValue::from_str(e.code()))?,
     95             n,
     96         })
     97     }
     98     pub fn fingerprint(&self) -> Vec<u8> {
     99         self.provider.fingerprint().to_vec()
    100     }
    101     pub fn truthful_capabilities(&self) -> bool {
    102         let capabilities = self.provider.capabilities();
    103         assert_eq!(capabilities.residency(), ResidencySupport::UserProfile);
    104         assert_eq!(
    105             capabilities.hardware_backed(),
    106             CapabilitySupport::Unavailable
    107         );
    108         assert_eq!(capabilities.user_presence(), CapabilitySupport::Unavailable);
    109         let candidates: [&dyn SecretProvider; 1] = [&self.provider];
    110         assert!(
    111             SelectionPolicy::new(BackendKind::External, AccessPolicy::standard())
    112                 .select(&candidates)
    113                 .is_ok()
    114         );
    115         for policy in [
    116             AccessPolicy::new(
    117                 ResidencyPolicy::DeviceLocal,
    118                 UserPresencePolicy::NotRequired,
    119                 HardwarePolicy::Any,
    120             ),
    121             AccessPolicy::new(
    122                 ResidencyPolicy::Any,
    123                 UserPresencePolicy::Required,
    124                 HardwarePolicy::Any,
    125             ),
    126             AccessPolicy::new(
    127                 ResidencyPolicy::Any,
    128                 UserPresencePolicy::NotRequired,
    129                 HardwarePolicy::RequireHardwareBacked,
    130             ),
    131         ] {
    132             assert!(
    133                 SelectionPolicy::new(BackendKind::External, policy)
    134                     .select(&candidates)
    135                     .is_err()
    136             );
    137         }
    138         true
    139     }
    140     pub async fn protect(&self, bytes: Vec<u8>) -> Result<Vec<u8>, JsValue> {
    141         let mut key = [0; 32];
    142         let mut nonce = [0; 24];
    143         rng().get_random_values_with_u8_array(&mut key).unwrap();
    144         rng().get_random_values_with_u8_array(&mut nonce).unwrap();
    145         let material = SecretMaterial::from_slice(&key).map_err(fail)?;
    146         key.fill(0);
    147         let plaintext = SecretMaterial::from_slice(&bytes).map_err(fail)?;
    148         EncryptedEnvelope::seal(
    149             &self.provider,
    150             SealRequest::new(
    151                 reference(),
    152                 context(self.n),
    153                 &plaintext,
    154                 SealMaterial::new(material, Nonce::new(nonce)),
    155             ),
    156         )
    157         .await
    158         .map_err(fail)?
    159         .encode()
    160         .map_err(fail)
    161     }
    162     pub async fn reveal(&self, encoded: Vec<u8>) -> Result<Vec<u8>, JsValue> {
    163         let envelope = EncryptedEnvelope::decode(&encoded).map_err(fail)?;
    164         envelope
    165             .open(&self.provider, &context(self.n))
    166             .await
    167             .map_err(fail)
    168             .map(|plain| plain.expose_secret(|bytes| bytes.to_vec()))
    169     }
    170     pub async fn context_and_reference_refusal(&self) -> Result<bool, JsValue> {
    171         let reference = reference();
    172         let expected = context(self.n);
    173         let wrong = context(self.n.wrapping_add(1));
    174         let plaintext = SecretMaterial::from_slice(&[0x31; 32]).map_err(fail)?;
    175         let wrapped = self
    176             .provider
    177             .wrap(WrapRequest::new(&reference, &expected, &plaintext))
    178             .await
    179             .map_err(fail)?;
    180         assert!(
    181             self.provider
    182                 .unwrap(UnwrapRequest::new(&reference, &wrong, &wrapped))
    183                 .await
    184                 .is_err()
    185         );
    186         let foreign = SecretRef::new(
    187             SecretId::parse("foreign_key").unwrap(),
    188             BackendKind::External,
    189             KeyVersion::new(1).unwrap(),
    190         );
    191         assert!(
    192             self.provider
    193                 .wrap(WrapRequest::new(&foreign, &expected, &plaintext))
    194                 .await
    195                 .is_err()
    196         );
    197         let version = SecretRef::new(
    198             SecretId::parse("persistent_fixture_key").unwrap(),
    199             BackendKind::External,
    200             KeyVersion::new(2).unwrap(),
    201         );
    202         assert!(
    203             self.provider
    204                 .unwrap(UnwrapRequest::new(&version, &expected, &wrapped))
    205                 .await
    206                 .is_err()
    207         );
    208         let memory = SecretRef::new(
    209             SecretId::parse("persistent_fixture_key").unwrap(),
    210             BackendKind::Memory,
    211             KeyVersion::new(1).unwrap(),
    212         );
    213         assert!(
    214             self.provider
    215                 .wrap(WrapRequest::new(&memory, &expected, &plaintext))
    216                 .await
    217                 .is_err()
    218         );
    219         let short = SecretMaterial::from_slice(&[1; 31]).map_err(fail)?;
    220         assert!(
    221             self.provider
    222                 .wrap(WrapRequest::new(&reference, &expected, &short))
    223                 .await
    224                 .is_err()
    225         );
    226         Ok(true)
    227     }
    228     pub fn abandon_wraps(&self, count: usize) -> Result<usize, JsValue> {
    229         let reference = reference();
    230         let context = context(self.n);
    231         let plaintext = SecretMaterial::from_slice(&[1; 32]).map_err(fail)?;
    232         for index in 0..count {
    233             if let Some(result) = self
    234                 .provider
    235                 .wrap(WrapRequest::new(&reference, &context, &plaintext))
    236                 .now_or_never()
    237             {
    238                 return if result.is_err() {
    239                     Ok(index)
    240                 } else {
    241                     Err(JsValue::from_str("unexpected_immediate_wrap"))
    242                 };
    243             }
    244         }
    245         Ok(count)
    246     }
    247     pub fn abandon_close(&self) -> Result<(), JsValue> {
    248         if self.provider.close().now_or_never().is_some() {
    249             return Err(JsValue::from_str("unexpected_immediate_close"));
    250         }
    251         Ok(())
    252     }
    253     pub async fn close(&self) -> Result<(), JsValue> {
    254         self.provider
    255             .close()
    256             .await
    257             .map_err(|e| JsValue::from_str(e.code()))
    258     }
    259 }