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 }