mod.rs (16843B)
1 //! Explicit browser-origin data-key wrapping with pinned nonextractable keys. 2 //! No participant signer, hardware/presence claim, fallback or stock authority. 3 use crate::{ 4 Error, KeyWrapping, SecretId, SecretProvider, SecretRef, 5 error::Operation, 6 id::BackendKind, 7 provider::{CapabilitySupport, ResidencySupport, SecretCapabilities}, 8 wrapping::{BoxFuture, SecretMaterial, UnwrapRequest, WrapRequest, WrappedSecret}, 9 }; 10 use futures::channel::oneshot; 11 use js_sys::Reflect; 12 use std::{ 13 cell::{Cell, RefCell}, 14 fmt, 15 future::{Future, poll_fn}, 16 rc::{Rc, Weak}, 17 task::{Poll, Waker}, 18 }; 19 use subtle::ConstantTimeEq; 20 use wasm_bindgen::{JsCast, JsValue, closure::Closure}; 21 use wasm_bindgen_futures::spawn_local; 22 use web_sys::{CryptoKey, Event, IdbDatabase, IdbFactory, SubtleCrypto}; 23 24 mod crypto; 25 mod idb; 26 27 const JOBS_MAX: usize = 32; 28 const LIVE_BYTES_MAX: usize = 4 * 1024 * 1024; 29 type Callback = Closure<dyn FnMut(Event)>; 30 type CloseSignal = RefCell<Option<Waker>>; 31 32 // Setup has no provider instance yet. Keep its accepted jobs bounded per host 33 // thread, independently of whether the caller retains the observation. 34 thread_local! { 35 static SETUP_JOBS: Cell<usize> = const { Cell::new(0) }; 36 } 37 struct Setup; 38 impl Setup { 39 fn admit() -> Result<Self, BrowserError> { 40 SETUP_JOBS.with(|jobs| { 41 if jobs.get() >= JOBS_MAX { 42 return Err(BrowserError::Capacity); 43 } 44 jobs.set(jobs.get() + 1); 45 Ok(Self) 46 }) 47 } 48 } 49 impl Drop for Setup { 50 fn drop(&mut self) { 51 SETUP_JOBS.with(|jobs| jobs.set(jobs.get() - 1)); 52 } 53 } 54 55 /// Fixed source-redacted browser setup/storage outcomes. 56 #[derive(Clone, Copy, Debug, Eq, PartialEq)] 57 #[non_exhaustive] 58 pub enum BrowserError { 59 Unavailable, 60 MissingNamespace, 61 NamespaceExists, 62 IncompatibleSchema, 63 MissingKey, 64 KeyMismatch, 65 Closed, 66 Capacity, 67 Aborted, 68 CommitUnknown, 69 Provider(Error), 70 } 71 impl BrowserError { 72 /// Returns a stable code without native exception messages or identifiers. 73 pub const fn code(self) -> &'static str { 74 match self { 75 Self::Unavailable => "browser_provider_unavailable", 76 Self::MissingNamespace => "missing_namespace", 77 Self::NamespaceExists => "namespace_exists", 78 Self::IncompatibleSchema => "incompatible_schema", 79 Self::MissingKey => "missing_key", 80 Self::KeyMismatch => "provider_key_mismatch", 81 Self::Closed => "closed", 82 Self::Capacity => "capacity_exhausted", 83 Self::Aborted => "transaction_aborted", 84 Self::CommitUnknown => "commit_unknown", 85 Self::Provider(_) => "provider_failure", 86 } 87 } 88 } 89 impl fmt::Display for BrowserError { 90 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 91 f.write_str(self.code()) 92 } 93 } 94 impl std::error::Error for BrowserError {} 95 96 struct State { 97 db: IdbDatabase, 98 subtle: SubtleCrypto, 99 namespace: SecretId, 100 reference: SecretRef, 101 fingerprint: [u8; 32], 102 closing: Cell<bool>, 103 jobs: Cell<usize>, 104 bytes: Cell<usize>, 105 waiters: RefCell<Vec<Weak<CloseSignal>>>, 106 version_change: RefCell<Option<Callback>>, 107 } 108 impl State { 109 fn detach_callbacks(&self) { 110 self.db.set_onversionchange(None); 111 self.db.set_onclose(None); 112 let retired = { self.version_change.borrow_mut().take() }; 113 drop(retired); 114 } 115 fn wake(&self) { 116 self.waiters.borrow_mut().retain(|weak| { 117 if let Some(signal) = weak.upgrade() { 118 if let Some(waker) = signal.borrow_mut().take() { 119 waker.wake(); 120 } 121 true 122 } else { 123 false 124 } 125 }); 126 } 127 fn stop(&self) { 128 self.closing.set(true); 129 if self.jobs.get() == 0 { 130 self.db.close(); 131 } 132 self.wake(); 133 } 134 fn admit(self: &Rc<Self>, bytes: usize) -> Result<Work, BrowserError> { 135 if self.closing.get() { 136 return Err(BrowserError::Closed); 137 } 138 let retained = self 139 .bytes 140 .get() 141 .checked_add(bytes) 142 .ok_or(BrowserError::Capacity)?; 143 if self.jobs.get() >= JOBS_MAX || retained > LIVE_BYTES_MAX { 144 return Err(BrowserError::Capacity); 145 } 146 self.jobs.set(self.jobs.get() + 1); 147 self.bytes.set(retained); 148 Ok(Work { 149 state: self.clone(), 150 bytes, 151 }) 152 } 153 async fn key(&self) -> Result<CryptoKey, BrowserError> { 154 let (key, binding) = idb::load(&self.db).await?; 155 let expected = binding_bytes(&self.reference, &self.fingerprint); 156 if !bool::from(binding.as_slice().ct_eq(expected.as_slice())) { 157 return Err(BrowserError::KeyMismatch); 158 } 159 let actual = 160 crypto::fingerprint(&self.subtle, &key, &self.namespace, &self.reference).await?; 161 if !bool::from(actual.ct_eq(&self.fingerprint)) { 162 return Err(BrowserError::KeyMismatch); 163 } 164 Ok(key) 165 } 166 } 167 impl Drop for State { 168 fn drop(&mut self) { 169 self.db.set_onversionchange(None); 170 self.db.set_onclose(None); 171 self.db.close(); 172 } 173 } 174 struct Work { 175 state: Rc<State>, 176 bytes: usize, 177 } 178 impl Drop for Work { 179 fn drop(&mut self) { 180 self.state.jobs.set(self.state.jobs.get() - 1); 181 self.state.bytes.set(self.state.bytes.get() - self.bytes); 182 if self.state.closing.get() && self.state.jobs.get() == 0 { 183 self.state.db.close(); 184 } 185 self.state.wake(); 186 } 187 } 188 async fn owned<T: 'static>( 189 work: Work, 190 future: impl Future<Output = Result<T, BrowserError>> + 'static, 191 ) -> Result<T, BrowserError> { 192 let (send, observe) = oneshot::channel(); 193 spawn_local(async move { 194 let _work = work; 195 let _ = send.send(future.await); 196 }); 197 observe.await.unwrap_or(Err(BrowserError::CommitUnknown)) 198 } 199 fn factory() -> Result<IdbFactory, BrowserError> { 200 Reflect::get(&js_sys::global(), &JsValue::from_str("indexedDB")) 201 .map_err(|_| BrowserError::Unavailable)? 202 .dyn_into::<IdbFactory>() 203 .map_err(|_| BrowserError::Unavailable) 204 } 205 fn name(namespace: &SecretId) -> String { 206 format!("radroots.secrets.browser.v1.{}", namespace.as_str()) 207 } 208 fn binding_bytes(reference: &SecretRef, fingerprint: &[u8; 32]) -> Vec<u8> { 209 let mut bytes = Vec::from(b"RRSB\x01".as_slice()); 210 bytes.push(reference.id().as_str().len() as u8); 211 bytes.extend_from_slice(reference.id().as_str().as_bytes()); 212 bytes.extend_from_slice(&reference.key_version().get().to_be_bytes()); 213 bytes.extend_from_slice(fingerprint); 214 bytes 215 } 216 fn selected(reference: &SecretRef) -> Result<(), BrowserError> { 217 if reference.backend() != BackendKind::External { 218 return Err(BrowserError::Provider(Error::BackendMismatch { 219 provider: BackendKind::External, 220 reference: reference.backend(), 221 })); 222 } 223 Ok(()) 224 } 225 fn normalize(error: BrowserError, operation: Operation, version: u32) -> Error { 226 match error { 227 BrowserError::Provider(error) => error, 228 BrowserError::MissingKey => Error::SecretNotFound { 229 backend: BackendKind::External, 230 key_version: version, 231 }, 232 BrowserError::Closed | BrowserError::Unavailable => Error::BackendUnavailable { 233 backend: BackendKind::External, 234 }, 235 _ => Error::BackendFailure { 236 backend: BackendKind::External, 237 operation, 238 }, 239 } 240 } 241 242 /// One immutable selected provider key in explicit origin storage. The public 243 /// fingerprint is an independently pinned identity, never signing/stock authority. 244 /// Native targets do not compile this adapter. Imports and capabilities do no IO. 245 pub struct BrowserProvider { 246 state: Rc<State>, 247 } 248 impl BrowserProvider { 249 /// Explicitly provisions a new namespace. The generated key is never used 250 /// for private payloads or exposed before its binding commits atomically. 251 /// Existing, including damaged, namespaces are never replaced. 252 pub async fn create(namespace: SecretId, reference: SecretRef) -> Result<Self, BrowserError> { 253 selected(&reference)?; 254 let setup = Setup::admit()?; 255 let factory = factory()?; 256 let (crypto, subtle) = crypto::host()?; 257 let (send, observe) = oneshot::channel(); 258 spawn_local(async move { 259 let _setup = setup; 260 let result = async { 261 match idb::open(&factory, &name(&namespace), None).await { 262 Ok(db) => { 263 db.close(); 264 return Err(BrowserError::NamespaceExists); 265 } 266 Err(BrowserError::MissingNamespace) => {} 267 Err(error) => return Err(error), 268 } 269 let key = crypto::generate(&crypto, &subtle).await?; 270 let fingerprint = 271 crypto::fingerprint(&subtle, &key, &namespace, &reference).await?; 272 let seed = idb::Seed { 273 key, 274 binding: binding_bytes(&reference, &fingerprint), 275 }; 276 let db = idb::open(&factory, &name(&namespace), Some(seed)).await?; 277 Ok(Self::assemble( 278 db, 279 subtle, 280 namespace, 281 reference, 282 fingerprint, 283 )) 284 } 285 .await; 286 let _ = send.send(result); 287 }); 288 observe.await.unwrap_or(Err(BrowserError::CommitUnknown)) 289 } 290 /// Opens an existing namespace only with the caller's independently pinned 291 /// fingerprint. Missing or changed keys never authorize fresh generation. 292 pub async fn open( 293 namespace: SecretId, 294 reference: SecretRef, 295 expected_fingerprint: [u8; 32], 296 ) -> Result<Self, BrowserError> { 297 selected(&reference)?; 298 let setup = Setup::admit()?; 299 let factory = factory()?; 300 let (_, subtle) = crypto::host()?; 301 let (send, observe) = oneshot::channel(); 302 spawn_local(async move { 303 let _setup = setup; 304 let result = async { 305 let db = idb::open(&factory, &name(&namespace), None).await?; 306 let provider = 307 Self::assemble(db, subtle, namespace, reference, expected_fingerprint); 308 provider.state.key().await?; 309 Ok(provider) 310 } 311 .await; 312 let _ = send.send(result); 313 }); 314 observe.await.unwrap_or(Err(BrowserError::CommitUnknown)) 315 } 316 fn assemble( 317 db: IdbDatabase, 318 subtle: SubtleCrypto, 319 namespace: SecretId, 320 reference: SecretRef, 321 fingerprint: [u8; 32], 322 ) -> Self { 323 let state = Rc::new(State { 324 db, 325 subtle, 326 namespace, 327 reference, 328 fingerprint, 329 closing: Cell::new(false), 330 jobs: Cell::new(0), 331 bytes: Cell::new(0), 332 waiters: RefCell::new(Vec::new()), 333 version_change: RefCell::new(None), 334 }); 335 let weak = Rc::downgrade(&state); 336 let changed = Closure::new(move |_: Event| { 337 if let Some(state) = weak.upgrade() { 338 state.stop(); 339 state.db.close(); 340 } 341 }); 342 state 343 .db 344 .set_onversionchange(Some(changed.as_ref().unchecked_ref())); 345 state.db.set_onclose(Some(changed.as_ref().unchecked_ref())); 346 *state.version_change.borrow_mut() = Some(changed); 347 Self { state } 348 } 349 /// Returns the public fingerprint that must be retained independently 350 /// for exact subsequent opening. It reveals no provider key material. 351 pub fn fingerprint(&self) -> [u8; 32] { 352 self.state.fingerprint 353 } 354 /// Stops admission, drains accepted jobs, closes the actual connection and 355 /// detaches its callbacks even while closed provider handles remain alive. 356 /// Cancellation of this observation does not cancel accepted jobs. 357 pub async fn close(&self) -> Result<(), BrowserError> { 358 self.state.stop(); 359 if self.state.jobs.get() == 0 { 360 self.state.detach_callbacks(); 361 return Ok(()); 362 } 363 let signal = Rc::new(RefCell::new(None)); 364 { 365 let mut waiters = self.state.waiters.borrow_mut(); 366 waiters.retain(|weak| weak.strong_count() > 0); 367 if waiters.len() >= JOBS_MAX { 368 return Err(BrowserError::Capacity); 369 } 370 waiters.push(Rc::downgrade(&signal)); 371 } 372 poll_fn(|cx| { 373 if self.state.jobs.get() == 0 { 374 Poll::Ready(()) 375 } else { 376 *signal.borrow_mut() = Some(cx.waker().clone()); 377 Poll::Pending 378 } 379 }) 380 .await; 381 self.state.detach_callbacks(); 382 Ok(()) 383 } 384 fn check(&self, reference: &SecretRef) -> Result<(), Error> { 385 selected(reference) 386 .map_err(|e| normalize(e, Operation::Read, reference.key_version().get()))?; 387 if reference.id() != self.state.reference.id() 388 || reference.key_version() != self.state.reference.key_version() 389 { 390 return Err(Error::SecretNotFound { 391 backend: BackendKind::External, 392 key_version: reference.key_version().get(), 393 }); 394 } 395 Ok(()) 396 } 397 } 398 impl fmt::Debug for BrowserProvider { 399 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 400 f.write_str("BrowserProvider(<redacted>)") 401 } 402 } 403 impl SecretProvider for BrowserProvider { 404 fn backend_kind(&self) -> BackendKind { 405 BackendKind::External 406 } 407 fn capabilities(&self) -> SecretCapabilities { 408 if self.state.closing.get() { 409 SecretCapabilities::unavailable() 410 } else { 411 SecretCapabilities::available( 412 ResidencySupport::UserProfile, 413 CapabilitySupport::Unavailable, 414 CapabilitySupport::Unavailable, 415 ) 416 } 417 } 418 } 419 impl KeyWrapping for BrowserProvider { 420 fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> { 421 Box::pin(async move { 422 self.check(request.reference())?; 423 if request.plaintext().len() != 32 { 424 return Err(Error::InvalidDataKeyLength { 425 actual_bytes: request.plaintext().len(), 426 }); 427 } 428 let version = request.reference().key_version().get(); 429 let work = self 430 .state 431 .admit(16 * 1024) 432 .map_err(|e| normalize(e, Operation::Wrap, version))?; 433 let plaintext = request 434 .plaintext() 435 .expose_secret(SecretMaterial::from_slice)?; 436 let context = request.context().clone(); 437 let state = self.state.clone(); 438 owned(work, async move { 439 let key = state.key().await?; 440 crypto::wrap( 441 &state.subtle, 442 &key, 443 &state.namespace, 444 &state.reference, 445 &context, 446 &plaintext, 447 ) 448 .await 449 }) 450 .await 451 .map_err(|e| normalize(e, Operation::Wrap, version)) 452 }) 453 } 454 fn unwrap<'a>( 455 &'a self, 456 request: UnwrapRequest<'a>, 457 ) -> BoxFuture<'a, Result<SecretMaterial, Error>> { 458 Box::pin(async move { 459 self.check(request.reference())?; 460 let version = request.reference().key_version().get(); 461 crypto::validate_wrapped(request.wrapped()) 462 .map_err(|e| normalize(e, Operation::Unwrap, version))?; 463 let work = self 464 .state 465 .admit(16 * 1024) 466 .map_err(|e| normalize(e, Operation::Unwrap, version))?; 467 let wrapped = request.wrapped().clone(); 468 let context = request.context().clone(); 469 let state = self.state.clone(); 470 owned(work, async move { 471 let key = state.key().await?; 472 crypto::unwrap( 473 &state.subtle, 474 &key, 475 &state.namespace, 476 &state.reference, 477 &context, 478 &wrapped, 479 ) 480 .await 481 }) 482 .await 483 .map_err(|e| normalize(e, Operation::Unwrap, version)) 484 }) 485 } 486 }