lib

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

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 }