lib

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

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 }