exact_recovery.rs (7266B)
1 //! Original-bound observations, not authorization or durable effect tests. 2 use super::*; 3 use radroots_signing::{ 4 Error, SignReceipt, SignRequest, Signer, SignerStatus, 5 provider::{ 6 ParticipantProvider, PrivateCiphertext, PrivateCryptoCapability, PrivateText, ProviderState, 7 }, 8 recovery::ReplayCapability, 9 signer::BoxFuture, 10 }; 11 use std::{ 12 sync::atomic::{AtomicUsize, Ordering}, 13 task::{Context, Poll, Waker}, 14 }; 15 16 fn call(identity: PublicKey, deadline: u64) -> ProviderCall { 17 ProviderCall::new( 18 identity, 19 NonZeroU64::new(deadline).unwrap(), 20 CancellationSignal::new(), 21 ) 22 } 23 24 #[test] 25 fn recovery_data_preserves_original_binding_and_rejects_foreign_or_unbounded_call_budget() { 26 let original = intent("private retained original", vec![], 7, 8); 27 let binding = original.binding(); 28 let request = ExactRecoveryRequest::new( 29 original, 30 call( 31 PublicKey::from_str(AUTHOR).unwrap(), 32 CREATED * 1000 + 20_000, 33 ), 34 ) 35 .unwrap(); 36 assert_eq!(request.binding(), binding); 37 assert_eq!(request.original().binding(), binding); 38 assert_eq!( 39 request.call().deadline_unix_ms().get(), 40 CREATED * 1000 + 20_000 41 ); 42 assert_eq!(format!("{request:?}"), "ExactRecoveryRequest(<redacted>)"); 43 let other = 44 PublicKey::from_hex("c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5") 45 .unwrap(); 46 assert!(matches!( 47 ExactRecoveryRequest::new( 48 intent("x", vec![], 7, 8), 49 call(other, CREATED * 1000 + 20_000) 50 ), 51 Err(ProviderError::IdentityChanged) 52 )); 53 assert!(matches!( 54 ExactRecoveryRequest::new( 55 intent("x", vec![], 7, 8), 56 call(PublicKey::from_str(AUTHOR).unwrap(), u64::MAX) 57 ), 58 Err(ProviderError::InvalidInput) 59 )); 60 } 61 62 #[test] 63 fn refusal_of_this_recovery_invocation_never_proves_original_nonissuance() { 64 let binding = intent("private retained original", vec![], 7, 8).binding(); 65 for reason in [ 66 ProviderError::CapabilityUnavailable, 67 ProviderError::Cancelled, 68 ProviderError::DeadlineExceeded, 69 ProviderError::ProviderFailure, 70 ] { 71 for observed in [ 72 SigningOutcome::not_dispatched(binding, reason), 73 SigningOutcome::unknown(binding, reason), 74 ] { 75 let converted = ExactRecoveryOutcome::from_recovery_verification(observed); 76 assert_eq!(converted.binding(), binding); 77 assert!( 78 matches!(converted.kind(), ExactRecoveryKind::Indeterminate(value) if *value==reason) 79 ); 80 } 81 } 82 } 83 84 #[test] 85 fn foreign_recovery_callback_keeps_only_bounded_forensics_and_never_becomes_expected_success() { 86 let expected = intent("private retained original", vec![], 7, 8).binding(); 87 let foreign = intent("private retained original", vec![], 9, 8); 88 let raw = signed(&foreign); 89 let result = ExactRecoveryOutcome::from_recovery_verification(SigningOutcome::capture( 90 &foreign, 91 raw.clone(), 92 None, 93 )) 94 .enforce_binding(expected); 95 assert_eq!(result.binding(), expected); 96 let ExactRecoveryKind::Rejected(rejected) = result.kind() else { 97 panic!("foreign callback promoted") 98 }; 99 assert_eq!(rejected.reason(), RejectionReason::BindingMismatch); 100 assert_eq!(rejected.fingerprint().unwrap().total_bytes(), raw.len()); 101 assert!(!format!("{result:?}").contains("private retained original")); 102 let result = 103 ExactRecoveryOutcome::indeterminate(foreign.binding(), ProviderError::ProviderFailure) 104 .enforce_binding(expected); 105 let ExactRecoveryKind::Rejected(rejected) = result.kind() else { 106 panic!("foreign uncertainty rebound") 107 }; 108 assert!(rejected.fingerprint().is_none()); 109 } 110 111 #[test] 112 fn verified_original_bytes_and_tampering_keep_distinct_recovery_observations() { 113 let original = intent("private retained original", vec![], 7, 8); 114 let raw = signed(&original); 115 let expected = original.binding(); 116 let recovered = ExactRecoveryOutcome::from_recovery_verification(SigningOutcome::capture( 117 &original, 118 raw.clone(), 119 None, 120 )); 121 assert_eq!(recovered.binding(), expected); 122 let (_, ExactRecoveryKind::Obtained(artifact)) = recovered.into_parts() else { 123 panic!("actual original bytes lost") 124 }; 125 assert_eq!(artifact.with_json(str::to_owned), raw); 126 assert!(artifact.observed_at_unix_ms().is_none()); 127 let wrong = signed(&intent("different fields", vec![], 7, 8)); 128 let rejected = ExactRecoveryOutcome::from_recovery_verification(SigningOutcome::capture( 129 &original, wrong, None, 130 )); 131 assert!(matches!(rejected.kind(), ExactRecoveryKind::Rejected(_))); 132 assert!(!format!("{rejected:?}").contains("private retained original")); 133 } 134 135 struct Unsupported(AtomicUsize); 136 impl Signer for Unsupported { 137 fn status(&self) -> BoxFuture<'_, Result<SignerStatus, Error>> { 138 panic!("unexpected legacy status") 139 } 140 fn sign(&self, _request: SignRequest) -> BoxFuture<'_, Result<SignReceipt, Error>> { 141 self.0.fetch_add(1, Ordering::SeqCst); 142 panic!("legacy fallback") 143 } 144 } 145 impl ParticipantProvider for Unsupported { 146 fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> { 147 Box::pin(async { 148 Ok(ProviderState::new( 149 PublicKey::from_str(AUTHOR).unwrap(), 150 PrivateCryptoCapability::Unavailable, 151 PrivateCryptoCapability::Unavailable, 152 ReplayCapability::LocalReplaySafe, 153 )) 154 }) 155 } 156 fn sign_exact(&self, _intent: SigningIntent) -> BoxFuture<'_, SigningOutcome> { 157 self.0.fetch_add(1, Ordering::SeqCst); 158 panic!("first-dispatch fallback") 159 } 160 fn encrypt_private( 161 &self, 162 _call: ProviderCall, 163 _recipient: PublicKey, 164 _text: PrivateText, 165 ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> { 166 panic!("unexpected encryption") 167 } 168 fn decrypt_private( 169 &self, 170 _call: ProviderCall, 171 _sender: PublicKey, 172 _text: PrivateCiphertext, 173 ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> { 174 panic!("unexpected decryption") 175 } 176 } 177 178 #[test] 179 fn an_unsupported_recovery_method_never_falls_back_to_declared_legacy_replay_or_signing() { 180 let provider = Unsupported(AtomicUsize::new(0)); 181 let original = intent("private retained original", vec![], 7, 8); 182 let expected = original.binding(); 183 let request = ExactRecoveryRequest::new( 184 original, 185 call( 186 PublicKey::from_str(AUTHOR).unwrap(), 187 CREATED * 1000 + 20_000, 188 ), 189 ) 190 .unwrap(); 191 let mut future = provider.recover_exact(request); 192 let Poll::Ready(value) = future 193 .as_mut() 194 .poll(&mut Context::from_waker(Waker::noop())) 195 else { 196 panic!("unsupported method waited") 197 }; 198 assert_eq!(value.binding(), expected); 199 assert!(matches!( 200 value.kind(), 201 ExactRecoveryKind::Indeterminate(ProviderError::CapabilityUnavailable) 202 )); 203 assert_eq!(provider.0.load(Ordering::SeqCst), 0); 204 }