protected.rs (7850B)
1 //! Volatile fixture provider. No persistent custody or hardware claim. 2 use radroots_secrets::context::{ 3 EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId, 4 }; 5 use radroots_secrets::envelope::{LegacyV1ResealAuthority, Nonce, SealMaterial, SealRequest}; 6 use radroots_secrets::id::{BackendKind, KeyVersion}; 7 use radroots_secrets::memory::MemoryProvider; 8 use radroots_secrets::provider::SecretCapabilities; 9 use radroots_secrets::wrapping::{ 10 BoxFuture, LegacyV1UnwrapRequest, SecretMaterial, UnwrapRequest, WrapRequest, WrappedSecret, 11 }; 12 use radroots_secrets::{ 13 EncryptedEnvelope, Error, KeyWrapping, SecretId, SecretProvider, SecretRef, 14 }; 15 use radroots_storage::event::SourceGeneration; 16 use radroots_storage_indexeddb::{Batch, Database, Mutation, Namespace, OpenMode, RecordKey}; 17 use std::{cell::RefCell, rc::Rc}; 18 use wasm_bindgen::prelude::*; 19 use wasm_bindgen_futures::JsFuture; 20 21 #[derive(Default)] 22 struct Calls { 23 wraps: usize, 24 unwraps: usize, 25 legacy: usize, 26 } 27 struct LocalProvider { 28 inner: MemoryProvider, 29 calls: Rc<RefCell<Calls>>, 30 } 31 async fn pause() { 32 JsFuture::from(js_sys::Promise::resolve(&JsValue::UNDEFINED)) 33 .await 34 .expect("fixture microtask"); 35 } 36 impl KeyWrapping for LocalProvider { 37 fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> { 38 let calls = self.calls.clone(); 39 Box::pin(async move { 40 pause().await; 41 calls.borrow_mut().wraps += 1; 42 self.inner.wrap(request).await 43 }) 44 } 45 fn unwrap<'a>( 46 &'a self, 47 request: UnwrapRequest<'a>, 48 ) -> BoxFuture<'a, Result<SecretMaterial, Error>> { 49 let calls = self.calls.clone(); 50 Box::pin(async move { 51 pause().await; 52 calls.borrow_mut().unwraps += 1; 53 self.inner.unwrap(request).await 54 }) 55 } 56 fn unwrap_legacy_v1<'a>( 57 &'a self, 58 request: LegacyV1UnwrapRequest<'a>, 59 ) -> BoxFuture<'a, Result<SecretMaterial, Error>> { 60 let calls = self.calls.clone(); 61 Box::pin(async move { 62 pause().await; 63 calls.borrow_mut().legacy += 1; 64 // Exact frozen envelope_contract.rs vector, never a runtime key. 65 if request.reference().id().as_str() != "envelope-key" 66 || request.reference().backend() != BackendKind::Memory 67 || request.reference().key_version().get() != 7 68 || request.wrapped().as_bytes() != [0x4b; 32] 69 { 70 return Err(Error::LegacyEnvelopeDenied); 71 } 72 SecretMaterial::from_slice(&[0x11; 32]) 73 }) 74 } 75 } 76 impl SecretProvider for LocalProvider { 77 fn backend_kind(&self) -> BackendKind { 78 self.inner.backend_kind() 79 } 80 fn capabilities(&self) -> SecretCapabilities { 81 self.inner.capabilities() 82 } 83 } 84 fn reference() -> SecretRef { 85 SecretRef::new( 86 SecretId::parse("local-fixture-key").unwrap(), 87 BackendKind::Memory, 88 KeyVersion::new(1).unwrap(), 89 ) 90 } 91 fn context(subject: &str) -> EnvelopeContext { 92 EnvelopeContext::new( 93 EnvelopePurpose::parse("radroots.browser_fixture").unwrap(), 94 EnvelopeSubject::parse("fixture", subject).unwrap(), 95 PayloadSchemaId::parse("radroots.browser_fixture.v1").unwrap(), 96 ) 97 } 98 fn secret_error(_: Error) -> JsValue { 99 JsValue::from_str("protected_fixture_failure") 100 } 101 102 #[wasm_bindgen] 103 pub async fn protected_round_trip(n: u8) -> Result<(), JsValue> { 104 let calls = Rc::new(RefCell::new(Calls::default())); 105 let provider = LocalProvider { 106 inner: MemoryProvider::new(), 107 calls: calls.clone(), 108 }; 109 provider 110 .inner 111 .provision( 112 &reference(), 113 SecretMaterial::from_slice(&[0x41; 32]).map_err(secret_error)?, 114 ) 115 .map_err(secret_error)?; 116 let plaintext = 117 SecretMaterial::from_slice(b"browser protected fixture").map_err(secret_error)?; 118 let expected = context(&n.to_string()); 119 let encoded = EncryptedEnvelope::seal( 120 &provider, 121 SealRequest::new( 122 reference(), 123 expected.clone(), 124 &plaintext, 125 SealMaterial::new( 126 SecretMaterial::from_slice(&[0x41; 32]).map_err(secret_error)?, 127 Nonce::new([0x24; 24]), 128 ), 129 ), 130 ) 131 .await 132 .map_err(secret_error)? 133 .encode() 134 .map_err(secret_error)?; 135 assert!( 136 !encoded 137 .windows(plaintext.len()) 138 .any(|value| plaintext.expose_secret(|plain| plain == value)) 139 ); 140 let namespace = Namespace::new(SourceGeneration::new([n; 32]).unwrap()); 141 let record = RecordKey::new([1; 32]); 142 let db = Database::open(namespace, OpenMode::CreateNew) 143 .await 144 .map_err(super::failure)?; 145 db.compare_exchange( 146 Batch::new(vec![ 147 Mutation::new(record, None, Some(encoded)).map_err(super::failure)?, 148 ]) 149 .map_err(super::failure)?, 150 ) 151 .await 152 .map_err(super::failure)?; 153 db.close().await.map_err(super::failure)?; 154 let reopened = Database::open(namespace, OpenMode::Existing) 155 .await 156 .map_err(super::failure)?; 157 let mut stored = reopened 158 .get(record) 159 .await 160 .map_err(super::failure)? 161 .ok_or_else(|| JsValue::from_str("missing_protected_fixture"))?; 162 let envelope = EncryptedEnvelope::decode(&stored).map_err(secret_error)?; 163 let opened = envelope 164 .open(&provider, &expected) 165 .await 166 .map_err(secret_error)?; 167 opened.expose_secret(|bytes| assert_eq!(bytes, b"browser protected fixture")); 168 assert_eq!( 169 envelope.open(&provider, &context("foreign")).await.err(), 170 Some(Error::ContextMismatch) 171 ); 172 *stored.last_mut().unwrap() ^= 1; 173 let tampered = EncryptedEnvelope::decode(&stored).map_err(secret_error)?; 174 assert_eq!( 175 tampered.open(&provider, &expected).await.err(), 176 Some(Error::DecryptFailed) 177 ); 178 reopened.close().await.map_err(super::failure)?; 179 180 // Existing independently frozen v1 ciphertext and its public fixture key. 181 let legacy=hex::decode("52525331000101010100000007000c656e76656c6f70652d6b6579222222222222222222222222222222222222222222222222000000204b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b4b00000028f106837e33d690e7c5287abdd815ce9257b7b5b176ea9596abf3b7fe745aec5a8c2487a553d4659d").unwrap(); 182 let legacy = EncryptedEnvelope::decode(&legacy).map_err(secret_error)?; 183 assert_eq!( 184 legacy.open(&provider, &expected).await.err(), 185 Some(Error::LegacyEnvelopeDenied) 186 ); 187 let authority = LegacyV1ResealAuthority::new(); 188 let original = SecretRef::new( 189 SecretId::parse("envelope-key").unwrap(), 190 BackendKind::Memory, 191 KeyVersion::new(7).unwrap(), 192 ); 193 let validations = Rc::new(RefCell::new(0)); 194 let validator = |bytes: &[u8]| { 195 *validations.borrow_mut() += 1; 196 bytes == b"radroots envelope vector" 197 }; 198 let resealed = legacy 199 .reseal_legacy_v1( 200 &provider, 201 &authority, 202 &original, 203 reference(), 204 expected.clone(), 205 &validator, 206 SealMaterial::new( 207 SecretMaterial::from_slice(&[0x41; 32]).map_err(secret_error)?, 208 Nonce::new([0x55; 24]), 209 ), 210 ) 211 .await 212 .map_err(secret_error)? 213 .into_envelope(); 214 assert_eq!(*validations.borrow(), 1); 215 resealed 216 .open(&provider, &expected) 217 .await 218 .map_err(secret_error)? 219 .expose_secret(|bytes| assert_eq!(bytes, b"radroots envelope vector")); 220 let calls = calls.borrow(); 221 assert_eq!((calls.wraps, calls.unwraps, calls.legacy), (2, 3, 1)); 222 Ok(()) 223 }