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 }