lib

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

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 }