lib

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

provider_contract.rs (10939B)


      1 use futures_executor::block_on;
      2 use radroots_secrets::context::{
      3     EnvelopeContext, EnvelopePurpose, EnvelopeSubject, PayloadSchemaId,
      4 };
      5 use radroots_secrets::error::{Operation, PolicyRequirement};
      6 use radroots_secrets::id::{BackendKind, KeyVersion};
      7 use radroots_secrets::provider::{
      8     AccessPolicy, CapabilitySupport, HardwarePolicy, ResidencyPolicy, ResidencySupport,
      9     SecretCapabilities, SelectionPolicy, UserPresencePolicy,
     10 };
     11 use radroots_secrets::wrapping::{
     12     BoxFuture, SecretMaterial, UnwrapRequest, WrapRequest, WrappedSecret,
     13 };
     14 use radroots_secrets::{Error, KeyWrapping, SecretId, SecretProvider, SecretRef};
     15 
     16 struct MockProvider {
     17     backend: BackendKind,
     18     capabilities: SecretCapabilities,
     19     fail: bool,
     20 }
     21 
     22 impl KeyWrapping for MockProvider {
     23     fn wrap<'a>(&'a self, request: WrapRequest<'a>) -> BoxFuture<'a, Result<WrappedSecret, Error>> {
     24         Box::pin(async move {
     25             self.validate_reference(request.reference())?;
     26             if self.fail {
     27                 return Err(Error::BackendFailure {
     28                     backend: self.backend,
     29                     operation: Operation::Wrap,
     30                 });
     31             }
     32             let mut encoded = Vec::from(request.context().authentication_digest());
     33             encoded.extend(request.plaintext().expose_secret(|plaintext| {
     34                 plaintext.iter().map(|byte| byte ^ 0xA5).collect::<Vec<_>>()
     35             }));
     36             WrappedSecret::from_bytes(encoded)
     37         })
     38     }
     39 
     40     fn unwrap<'a>(
     41         &'a self,
     42         request: UnwrapRequest<'a>,
     43     ) -> BoxFuture<'a, Result<SecretMaterial, Error>> {
     44         Box::pin(async move {
     45             self.validate_reference(request.reference())?;
     46             if self.fail {
     47                 return Err(Error::BackendFailure {
     48                     backend: self.backend,
     49                     operation: Operation::Unwrap,
     50                 });
     51             }
     52             let (context_digest, wrapped) = request
     53                 .wrapped()
     54                 .as_bytes()
     55                 .split_at_checked(32)
     56                 .ok_or(Error::BackendFailure {
     57                     backend: self.backend,
     58                     operation: Operation::Unwrap,
     59                 })?;
     60             let expected_digest = request.context().authentication_digest();
     61             if context_digest != expected_digest {
     62                 return Err(Error::BackendFailure {
     63                     backend: self.backend,
     64                     operation: Operation::Unwrap,
     65                 });
     66             }
     67             let decoded = wrapped.iter().map(|byte| byte ^ 0xA5).collect::<Vec<_>>();
     68             SecretMaterial::from_slice(decoded.as_slice())
     69         })
     70     }
     71 }
     72 
     73 impl SecretProvider for MockProvider {
     74     fn backend_kind(&self) -> BackendKind {
     75         self.backend
     76     }
     77 
     78     fn capabilities(&self) -> SecretCapabilities {
     79         self.capabilities
     80     }
     81 }
     82 
     83 impl MockProvider {
     84     fn validate_reference(&self, reference: &SecretRef) -> Result<(), Error> {
     85         if reference.backend() != self.backend {
     86             return Err(Error::BackendMismatch {
     87                 provider: self.backend,
     88                 reference: reference.backend(),
     89             });
     90         }
     91         Ok(())
     92     }
     93 }
     94 
     95 fn provider(backend: BackendKind, capabilities: SecretCapabilities) -> MockProvider {
     96     MockProvider {
     97         backend,
     98         capabilities,
     99         fail: false,
    100     }
    101 }
    102 
    103 fn reference(backend: BackendKind) -> SecretRef {
    104     SecretRef::new(
    105         SecretId::parse("test-wrapping-key").expect("valid id"),
    106         backend,
    107         KeyVersion::new(1).expect("valid version"),
    108     )
    109 }
    110 
    111 fn context() -> EnvelopeContext {
    112     EnvelopeContext::new(
    113         EnvelopePurpose::parse("radroots.provider_test").expect("purpose"),
    114         EnvelopeSubject::parse("provider_test", "fixture").expect("subject"),
    115         PayloadSchemaId::parse("radroots.provider_test.v1").expect("schema"),
    116     )
    117 }
    118 
    119 #[test]
    120 fn provider_traits_are_dyn_compatible_and_round_trip_opaque_material() {
    121     fn accept_dyn(_: &dyn SecretProvider) {}
    122 
    123     let provider = provider(
    124         BackendKind::Memory,
    125         SecretCapabilities::available(
    126             ResidencySupport::Volatile,
    127             CapabilitySupport::Unavailable,
    128             CapabilitySupport::Unavailable,
    129         ),
    130     );
    131     accept_dyn(&provider);
    132 
    133     let reference = reference(BackendKind::Memory);
    134     let plaintext = SecretMaterial::from_slice(b"caller-owned-data-key").expect("material");
    135     let context = context();
    136     let wrapped =
    137         block_on(provider.wrap(WrapRequest::new(&reference, &context, &plaintext))).expect("wrap");
    138     let opened = block_on(provider.unwrap(UnwrapRequest::new(&reference, &context, &wrapped)))
    139         .expect("unwrap");
    140     opened.expose_secret(|bytes| assert_eq!(bytes, b"caller-owned-data-key"));
    141 
    142     assert_eq!(format!("{plaintext:?}"), "SecretMaterial(<redacted>)");
    143     assert_eq!(format!("{wrapped:?}"), "WrappedSecret(<redacted>)");
    144 }
    145 
    146 #[cfg(not(target_arch = "wasm32"))]
    147 #[test]
    148 fn native_provider_objects_and_borrowed_futures_retain_thread_bounds() {
    149     fn thread_safe<T: Send + Sync + ?Sized>() {}
    150     fn send<T: Send>(_: T) {}
    151     thread_safe::<dyn KeyWrapping>();
    152     thread_safe::<dyn SecretProvider>();
    153     let provider = provider(BackendKind::Memory, SecretCapabilities::unavailable());
    154     let reference = reference(BackendKind::Memory);
    155     let context = context();
    156     let plaintext = SecretMaterial::from_slice(&[1; 32]).unwrap();
    157     let wrapped = WrappedSecret::from_bytes(vec![1; 32]).unwrap();
    158     send(provider.wrap(WrapRequest::new(&reference, &context, &plaintext)));
    159     send(provider.unwrap(UnwrapRequest::new(&reference, &context, &wrapped)));
    160 }
    161 
    162 #[test]
    163 fn exact_selection_never_falls_back_to_another_backend() {
    164     let memory = provider(
    165         BackendKind::Memory,
    166         SecretCapabilities::available(
    167             ResidencySupport::Volatile,
    168             CapabilitySupport::Unavailable,
    169             CapabilitySupport::Unavailable,
    170         ),
    171     );
    172     let file = provider(
    173         BackendKind::File,
    174         SecretCapabilities::available(
    175             ResidencySupport::DeviceLocal,
    176             CapabilitySupport::Unavailable,
    177             CapabilitySupport::Unavailable,
    178         ),
    179     );
    180     let candidates: [&dyn SecretProvider; 2] = [&memory, &file];
    181 
    182     let selected = SelectionPolicy::new(BackendKind::File, AccessPolicy::standard())
    183         .select(&candidates)
    184         .expect("file selected");
    185     assert_eq!(selected.backend_kind(), BackendKind::File);
    186 
    187     assert!(matches!(
    188         SelectionPolicy::new(BackendKind::Keyring, AccessPolicy::standard()).select(&candidates),
    189         Err(Error::BackendUnavailable {
    190             backend: BackendKind::Keyring
    191         })
    192     ));
    193 }
    194 
    195 #[test]
    196 fn selection_enforces_device_user_presence_and_hardware_policy() {
    197     let keyring = provider(
    198         BackendKind::Keyring,
    199         SecretCapabilities::available(
    200             ResidencySupport::UserProfile,
    201             CapabilitySupport::Unavailable,
    202             CapabilitySupport::Unavailable,
    203         ),
    204     );
    205     let candidates: [&dyn SecretProvider; 1] = [&keyring];
    206 
    207     let cases = [
    208         (
    209             AccessPolicy::new(
    210                 ResidencyPolicy::DeviceLocal,
    211                 UserPresencePolicy::NotRequired,
    212                 HardwarePolicy::Any,
    213             ),
    214             PolicyRequirement::DeviceLocal,
    215         ),
    216         (
    217             AccessPolicy::new(
    218                 ResidencyPolicy::Any,
    219                 UserPresencePolicy::Required,
    220                 HardwarePolicy::Any,
    221             ),
    222             PolicyRequirement::UserPresence,
    223         ),
    224         (
    225             AccessPolicy::new(
    226                 ResidencyPolicy::Any,
    227                 UserPresencePolicy::NotRequired,
    228                 HardwarePolicy::RequireHardwareBacked,
    229             ),
    230             PolicyRequirement::HardwareBacked,
    231         ),
    232     ];
    233 
    234     for (access, expected) in cases {
    235         assert_eq!(
    236             SelectionPolicy::new(BackendKind::Keyring, access)
    237                 .select(&candidates)
    238                 .map(SecretProvider::backend_kind),
    239             Err(Error::PolicyUnsupported {
    240                 backend: BackendKind::Keyring,
    241                 requirement: expected,
    242             })
    243         );
    244     }
    245 }
    246 
    247 #[test]
    248 fn provider_errors_are_normalized_and_secret_safe() {
    249     let provider = MockProvider {
    250         backend: BackendKind::External,
    251         capabilities: SecretCapabilities::available(
    252             ResidencySupport::DeviceLocal,
    253             CapabilitySupport::Supported,
    254             CapabilitySupport::Supported,
    255         ),
    256         fail: true,
    257     };
    258     let reference = reference(BackendKind::External);
    259     let plaintext = SecretMaterial::from_slice(b"must-not-appear").expect("material");
    260     let error = block_on(provider.wrap(WrapRequest::new(&reference, &context(), &plaintext)))
    261         .expect_err("backend failure");
    262     assert_eq!(
    263         error,
    264         Error::BackendFailure {
    265             backend: BackendKind::External,
    266             operation: Operation::Wrap,
    267         }
    268     );
    269     assert!(!error.to_string().contains("must-not-appear"));
    270     assert!(!format!("{error:?}").contains("must-not-appear"));
    271 }
    272 
    273 #[test]
    274 fn reference_backend_mismatch_fails_before_wrapping() {
    275     let provider = provider(
    276         BackendKind::Memory,
    277         SecretCapabilities::available(
    278             ResidencySupport::Volatile,
    279             CapabilitySupport::Unavailable,
    280             CapabilitySupport::Unavailable,
    281         ),
    282     );
    283     let reference = reference(BackendKind::File);
    284     let plaintext = SecretMaterial::from_slice(b"data-key").expect("material");
    285     assert_eq!(
    286         block_on(provider.wrap(WrapRequest::new(&reference, &context(), &plaintext))),
    287         Err(Error::BackendMismatch {
    288             provider: BackendKind::Memory,
    289             reference: BackendKind::File,
    290         })
    291     );
    292 }
    293 
    294 #[test]
    295 fn external_wrapping_contract_rejects_cross_context_copy() {
    296     let provider = provider(
    297         BackendKind::Memory,
    298         SecretCapabilities::available(
    299             ResidencySupport::Volatile,
    300             CapabilitySupport::Unavailable,
    301             CapabilitySupport::Unavailable,
    302         ),
    303     );
    304     let reference = reference(BackendKind::Memory);
    305     let plaintext = SecretMaterial::from_slice(b"data-key").expect("material");
    306     let wrapped = block_on(provider.wrap(WrapRequest::new(&reference, &context(), &plaintext)))
    307         .expect("wrap");
    308     let different = EnvelopeContext::new(
    309         EnvelopePurpose::parse("radroots.provider_test").expect("purpose"),
    310         EnvelopeSubject::parse("provider_test", "different").expect("subject"),
    311         PayloadSchemaId::parse("radroots.provider_test.v1").expect("schema"),
    312     );
    313     assert!(matches!(
    314         block_on(provider.unwrap(UnwrapRequest::new(&reference, &different, &wrapped,))),
    315         Err(Error::BackendFailure {
    316             backend: BackendKind::Memory,
    317             operation: Operation::Unwrap,
    318         })
    319     ));
    320 }