signer_session.rs (28956B)
1 #![cfg(feature = "signer_session")] 2 3 use core::task::Poll; 4 #[cfg(not(target_arch = "wasm32"))] 5 use core::{future::Future, pin::pin, task::Context}; 6 #[cfg(not(target_arch = "wasm32"))] 7 use futures::task::noop_waker_ref; 8 use futures::{channel::oneshot, executor::block_on, task::AtomicWaker}; 9 use radroots_execution::session::{SessionState, SignerSession}; 10 use radroots_identity::PublicKey; 11 use radroots_signing::host::Shared; 12 use radroots_signing::{ 13 SignReceipt, SignRequest, Signer, SignerStatus, 14 provider::{ 15 ParticipantProvider, PrivateCiphertext, PrivateCryptoCapability, PrivateText, ProviderCall, 16 ProviderError, ProviderState, SignerCallbacks, SignerHandle, 17 }, 18 recovery::ReplayCapability, 19 signer::BoxFuture, 20 }; 21 use std::sync::{ 22 Mutex, 23 atomic::{AtomicBool, AtomicUsize, Ordering}, 24 }; 25 #[cfg(all(feature = "commerce", not(target_arch = "wasm32")))] 26 #[path = "support/signer_commerce.rs"] 27 mod commerce; 28 #[cfg(not(target_arch = "wasm32"))] 29 #[path = "support/signer_recovery.rs"] 30 mod recovery; 31 32 fn key(second: bool) -> PublicKey { 33 PublicKey::from_hex(if second { 34 "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5" 35 } else { 36 "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" 37 }) 38 .unwrap() 39 } 40 41 fn state(second: bool, encrypt: bool) -> ProviderState { 42 ProviderState::new( 43 key(second), 44 if encrypt { 45 PrivateCryptoCapability::Nip44V2 46 } else { 47 PrivateCryptoCapability::Unavailable 48 }, 49 PrivateCryptoCapability::Nip44V2, 50 ReplayCapability::NonReplayable, 51 ) 52 } 53 54 struct Control { 55 commerce_plaintext: Mutex<Option<String>>, 56 recovery_calls: AtomicUsize, 57 recovery_response: 58 Mutex<Option<oneshot::Receiver<radroots_signing::issuance::ExactRecoveryOutcome>>>, 59 recovery_binding: Mutex<Option<radroots_signing::issuance::IntentBinding>>, 60 current: Mutex<ProviderState>, 61 calls: AtomicUsize, 62 sign_calls: AtomicUsize, 63 crypto_calls: AtomicUsize, 64 crypto_response: Mutex<Option<oneshot::Receiver<()>>>, 65 sign_response: Mutex<Option<oneshot::Receiver<radroots_signing::issuance::SigningOutcome>>>, 66 sign_binding: Mutex<Option<radroots_signing::issuance::IntentBinding>>, 67 response: Mutex<Option<oneshot::Receiver<()>>>, 68 quiesces: AtomicUsize, 69 quiesced: AtomicBool, 70 close_attempts: AtomicUsize, 71 closes: AtomicUsize, 72 close_ready: AtomicBool, 73 fail_close_once: AtomicBool, 74 wake: AtomicWaker, 75 #[cfg(target_arch = "wasm32")] 76 _local: std::rc::Rc<std::cell::Cell<u8>>, 77 } 78 79 struct Provider(Shared<Control>); 80 struct Callbacks(Shared<Control>); 81 82 impl Signer for Provider { 83 fn status(&self) -> BoxFuture<'_, Result<SignerStatus, radroots_signing::Error>> { 84 Box::pin(async { Ok(SignerStatus::unavailable()) }) 85 } 86 fn sign(&self, _: SignRequest) -> BoxFuture<'_, Result<SignReceipt, radroots_signing::Error>> { 87 Box::pin(async { 88 Err(radroots_signing::Error::new( 89 radroots_signing::error::Kind::SignerUnavailable, 90 )) 91 }) 92 } 93 } 94 95 impl ParticipantProvider for Provider { 96 fn recover_exact( 97 &self, 98 request: radroots_signing::issuance::ExactRecoveryRequest, 99 ) -> BoxFuture<'_, radroots_signing::issuance::ExactRecoveryOutcome> { 100 use radroots_signing::issuance::ExactRecoveryOutcome; 101 Box::pin(async move { 102 self.0.recovery_calls.fetch_add(1, Ordering::SeqCst); 103 let binding = self 104 .0 105 .recovery_binding 106 .lock() 107 .unwrap() 108 .unwrap_or(request.binding()); 109 let response = self.0.recovery_response.lock().unwrap().take(); 110 if let Some(response) = response { 111 response.await.unwrap_or_else(|_| { 112 ExactRecoveryOutcome::indeterminate(binding, ProviderError::ProviderFailure) 113 }) 114 } else { 115 ExactRecoveryOutcome::indeterminate(binding, ProviderError::ProviderFailure) 116 } 117 }) 118 } 119 fn sign_exact( 120 &self, 121 intent: radroots_signing::issuance::SigningIntent, 122 ) -> BoxFuture<'_, radroots_signing::issuance::SigningOutcome> { 123 use radroots_signing::issuance::SigningOutcome; 124 Box::pin(async move { 125 self.0.sign_calls.fetch_add(1, Ordering::SeqCst); 126 let binding = self 127 .0 128 .sign_binding 129 .lock() 130 .unwrap() 131 .unwrap_or(intent.binding()); 132 let response = self.0.sign_response.lock().unwrap().take(); 133 if let Some(response) = response { 134 response.await.unwrap_or_else(|_| { 135 SigningOutcome::unknown(binding, ProviderError::ProviderFailure) 136 }) 137 } else { 138 SigningOutcome::unknown(binding, ProviderError::ProviderFailure) 139 } 140 }) 141 } 142 143 fn provider_state(&self) -> BoxFuture<'_, Result<ProviderState, ProviderError>> { 144 Box::pin(async move { 145 self.0.calls.fetch_add(1, Ordering::SeqCst); 146 let response = self.0.response.lock().unwrap().take(); 147 if let Some(response) = response { 148 response.await.map_err(|_| ProviderError::Cancelled)?; 149 } 150 if self.0.quiesced.load(Ordering::SeqCst) { 151 return Err(ProviderError::Cancelled); 152 } 153 Ok(*self.0.current.lock().unwrap()) 154 }) 155 } 156 fn encrypt_private( 157 &self, 158 _: ProviderCall, 159 _: PublicKey, 160 _: PrivateText, 161 ) -> BoxFuture<'_, Result<PrivateCiphertext, ProviderError>> { 162 Box::pin(async move { 163 self.0.crypto_calls.fetch_add(1, Ordering::SeqCst); 164 let response = self.0.crypto_response.lock().unwrap().take(); 165 if let Some(response) = response { 166 response.await.map_err(|_| ProviderError::Cancelled)?; 167 } 168 Err(ProviderError::ProviderFailure) 169 }) 170 } 171 fn decrypt_private( 172 &self, 173 _: ProviderCall, 174 _: PublicKey, 175 _: PrivateCiphertext, 176 ) -> BoxFuture<'_, Result<PrivateText, ProviderError>> { 177 Box::pin(async move { 178 self.0.crypto_calls.fetch_add(1, Ordering::SeqCst); 179 let response = self.0.crypto_response.lock().unwrap().take(); 180 if let Some(response) = response { 181 response.await.map_err(|_| ProviderError::Cancelled)?; 182 } 183 self.0 184 .commerce_plaintext 185 .lock() 186 .unwrap() 187 .as_deref() 188 .map(PrivateText::new) 189 .unwrap_or(Err(ProviderError::ProviderFailure)) 190 }) 191 } 192 } 193 194 impl SignerCallbacks for Callbacks { 195 fn quiesce(&self) -> BoxFuture<'_, Result<(), ProviderError>> { 196 Box::pin(async move { 197 self.0.quiesces.fetch_add(1, Ordering::SeqCst); 198 self.0.quiesced.store(true, Ordering::SeqCst); 199 Ok(()) 200 }) 201 } 202 fn close(&self) -> BoxFuture<'_, Result<(), ProviderError>> { 203 Box::pin(async move { 204 self.0.close_attempts.fetch_add(1, Ordering::SeqCst); 205 if self.0.fail_close_once.swap(false, Ordering::SeqCst) { 206 return Err(ProviderError::CapabilityUnavailable); 207 } 208 core::future::poll_fn(|cx| { 209 self.0.wake.register(cx.waker()); 210 if self.0.close_ready.load(Ordering::SeqCst) { 211 Poll::Ready(()) 212 } else { 213 Poll::Pending 214 } 215 }) 216 .await; 217 self.0.closes.fetch_add(1, Ordering::SeqCst); 218 Ok(()) 219 }) 220 } 221 } 222 223 #[cfg(not(target_arch = "wasm32"))] 224 struct Fixture { 225 session: SignerSession, 226 control: Shared<Control>, 227 provider: std::sync::Weak<Provider>, 228 callbacks: std::sync::Weak<Callbacks>, 229 } 230 231 #[cfg(not(target_arch = "wasm32"))] 232 fn scope() -> Fixture { 233 // Native weak handles make root release independently observable. 234 let control = control(); 235 let provider = Shared::new(Provider(control.clone())); 236 let callbacks = Shared::new(Callbacks(control.clone())); 237 let weak_provider = Shared::downgrade(&provider); 238 let weak_callbacks = Shared::downgrade(&callbacks); 239 Fixture { 240 session: SignerSession::new(SignerHandle::new(provider, callbacks)), 241 control, 242 provider: weak_provider, 243 callbacks: weak_callbacks, 244 } 245 } 246 247 fn control() -> Shared<Control> { 248 Shared::new(Control { 249 commerce_plaintext: Mutex::new(None), 250 recovery_calls: AtomicUsize::new(0), 251 recovery_response: Mutex::new(None), 252 recovery_binding: Mutex::new(None), 253 current: Mutex::new(state(false, false)), 254 calls: AtomicUsize::new(0), 255 sign_calls: AtomicUsize::new(0), 256 crypto_calls: AtomicUsize::new(0), 257 crypto_response: Mutex::new(None), 258 sign_response: Mutex::new(None), 259 sign_binding: Mutex::new(None), 260 response: Mutex::new(None), 261 quiesces: AtomicUsize::new(0), 262 quiesced: AtomicBool::new(false), 263 close_attempts: AtomicUsize::new(0), 264 closes: AtomicUsize::new(0), 265 close_ready: AtomicBool::new(true), 266 fail_close_once: AtomicBool::new(false), 267 wake: AtomicWaker::new(), 268 #[cfg(target_arch = "wasm32")] 269 _local: std::rc::Rc::new(std::cell::Cell::new(0)), 270 }) 271 } 272 273 #[cfg(not(target_arch = "wasm32"))] 274 #[test] 275 fn construction_is_inert_and_clones_share_identity_and_revocation() { 276 let Fixture { 277 session, 278 control, 279 provider, 280 callbacks, 281 } = scope(); 282 assert_eq!(session.state(), SessionState::Ready); 283 assert!(session.observed().is_none()); 284 assert_eq!(control.calls.load(Ordering::SeqCst), 0); 285 assert_eq!(control.quiesces.load(Ordering::SeqCst), 0); 286 let close = session.close(); 287 drop(close); 288 assert_eq!(session.state(), SessionState::Ready); 289 let clone = session.clone(); 290 assert_eq!(block_on(session.observe()).unwrap().identity(), key(false)); 291 *control.current.lock().unwrap() = state(false, true); 292 assert_eq!( 293 block_on(clone.observe()).unwrap().encryption(), 294 PrivateCryptoCapability::Nip44V2 295 ); 296 *control.current.lock().unwrap() = state(true, false); 297 assert_eq!( 298 block_on(session.observe()), 299 Err(ProviderError::IdentityChanged) 300 ); 301 assert_eq!(session.observed().unwrap().identity(), key(false)); 302 assert!(session.identity_changed()); 303 *control.current.lock().unwrap() = state(false, false); 304 assert_eq!( 305 block_on(session.observe()), 306 Err(ProviderError::IdentityChanged) 307 ); 308 assert_eq!(control.calls.load(Ordering::SeqCst), 3); 309 block_on(clone.close()).unwrap(); 310 assert_eq!(session.state(), SessionState::Closed); 311 assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); 312 assert_eq!( 313 block_on(session.observe()), 314 Err(ProviderError::CapabilityUnavailable) 315 ); 316 block_on(session.close()).unwrap(); 317 assert_eq!(control.quiesces.load(Ordering::SeqCst), 1); 318 assert_eq!(control.closes.load(Ordering::SeqCst), 1); 319 } 320 321 #[cfg(not(target_arch = "wasm32"))] 322 #[test] 323 fn close_before_observation_disposes_roots_without_querying_identity() { 324 let Fixture { 325 session, 326 control, 327 provider, 328 callbacks, 329 } = scope(); 330 block_on(session.close()).unwrap(); 331 assert_eq!(control.calls.load(Ordering::SeqCst), 0); 332 assert_eq!(control.quiesces.load(Ordering::SeqCst), 1); 333 assert_eq!(control.closes.load(Ordering::SeqCst), 1); 334 assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); 335 assert!(session.observed().is_none()); 336 assert_eq!(session.state(), SessionState::Closed); 337 } 338 339 #[cfg(not(target_arch = "wasm32"))] 340 #[test] 341 fn close_quiesces_before_draining_and_retains_inflight_roots() { 342 let Fixture { 343 session, 344 control, 345 provider, 346 .. 347 } = scope(); 348 let (send, receive) = oneshot::channel(); 349 *control.response.lock().unwrap() = Some(receive); 350 let mut observe = pin!(session.observe()); 351 let mut cx = Context::from_waker(noop_waker_ref()); 352 assert!(observe.as_mut().poll(&mut cx).is_pending()); 353 assert_eq!( 354 block_on(session.observe()), 355 Err(ProviderError::CapabilityUnavailable) 356 ); 357 assert_eq!(control.calls.load(Ordering::SeqCst), 1); 358 let mut close = pin!(session.close()); 359 assert!(close.as_mut().poll(&mut cx).is_pending()); 360 assert_eq!(control.quiesces.load(Ordering::SeqCst), 1); 361 assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0); 362 assert!(provider.upgrade().is_some()); 363 send.send(()).unwrap(); 364 assert_eq!( 365 observe.as_mut().poll(&mut cx), 366 Poll::Ready(Err(ProviderError::Cancelled)) 367 ); 368 assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(())))); 369 assert!(provider.upgrade().is_none()); 370 assert!(session.observed().is_none()); 371 } 372 373 #[cfg(not(target_arch = "wasm32"))] 374 #[test] 375 fn failed_and_cancelled_callback_disposal_keep_the_unfinished_stage() { 376 for fail in [false, true] { 377 let Fixture { 378 session, 379 control, 380 provider, 381 callbacks, 382 } = scope(); 383 block_on(session.observe()).unwrap(); 384 if fail { 385 control.fail_close_once.store(true, Ordering::SeqCst); 386 assert!(block_on(session.close()).is_err()); 387 } else { 388 control.close_ready.store(false, Ordering::SeqCst); 389 let mut close = Box::pin(session.close()); 390 assert!( 391 close 392 .as_mut() 393 .poll(&mut Context::from_waker(noop_waker_ref())) 394 .is_pending() 395 ); 396 drop(close); 397 } 398 assert_eq!(session.state(), SessionState::Closing); 399 assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some()); 400 control.close_ready.store(true, Ordering::SeqCst); 401 control.wake.wake(); 402 block_on(session.close()).unwrap(); 403 assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); 404 assert_eq!(control.quiesces.load(Ordering::SeqCst), 1); 405 assert_eq!(control.close_attempts.load(Ordering::SeqCst), 2); 406 assert_eq!(control.closes.load(Ordering::SeqCst), 1); 407 } 408 } 409 410 #[cfg(not(target_arch = "wasm32"))] 411 #[test] 412 fn failed_observation_does_not_freeze_a_key_and_lost_observer_keeps_host_roots() { 413 let Fixture { 414 session, 415 control, 416 provider, 417 callbacks, 418 } = scope(); 419 let (send, receive) = oneshot::channel(); 420 drop(send); 421 *control.response.lock().unwrap() = Some(receive); 422 assert_eq!(block_on(session.observe()), Err(ProviderError::Cancelled)); 423 assert!(session.observed().is_none()); 424 *control.current.lock().unwrap() = state(true, false); 425 assert_eq!(block_on(session.observe()).unwrap().identity(), key(true)); 426 427 let (send, receive) = oneshot::channel(); 428 *control.response.lock().unwrap() = Some(receive); 429 let mut observe = Box::pin(session.observe()); 430 let mut cx = Context::from_waker(noop_waker_ref()); 431 assert!(observe.as_mut().poll(&mut cx).is_pending()); 432 drop(observe); 433 control.close_ready.store(false, Ordering::SeqCst); 434 let mut close = Box::pin(session.close()); 435 assert!(close.as_mut().poll(&mut cx).is_pending()); 436 assert_eq!(control.close_attempts.load(Ordering::SeqCst), 1); 437 assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some()); 438 assert!(send.send(()).is_err()); 439 control.close_ready.store(true, Ordering::SeqCst); 440 control.wake.wake(); 441 assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(())))); 442 assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); 443 } 444 445 #[cfg(not(target_arch = "wasm32"))] 446 #[test] 447 fn native_scope_and_owned_futures_retain_thread_guarantees() { 448 fn send_sync<T: Send + Sync>() {} 449 fn send<T: Send>(_: T) {} 450 send_sync::<SignerHandle>(); 451 send_sync::<SignerSession>(); 452 let Fixture { session, .. } = scope(); 453 send(session.observe()); 454 send(session.close()); 455 } 456 457 #[cfg(target_arch = "wasm32")] 458 #[test] 459 fn browser_scope_accepts_rc_local_provider_and_callbacks() { 460 let control = control(); 461 let session = SignerSession::new(SignerHandle::new( 462 Shared::new(Provider(control.clone())), 463 Shared::new(Callbacks(control)), 464 )); 465 assert_eq!(block_on(session.observe()).unwrap().identity(), key(false)); 466 assert!(matches!( 467 block_on(session.sign_exact(exact_intent(false, 1))).kind(), 468 radroots_signing::issuance::OutcomeKind::NotDispatched( 469 ProviderError::CapabilityUnavailable 470 ) 471 )); 472 block_on(session.close()).unwrap(); 473 assert_eq!(session.state(), SessionState::Closed); 474 } 475 476 #[cfg(all(target_arch = "wasm32", feature = "client_session"))] 477 #[test] 478 fn browser_client_composes_local_host_and_retained_callback_scope() { 479 use radroots_execution::session::{ClientSession, HostFuture, SessionHost}; 480 struct LocalHost(std::rc::Rc<std::cell::Cell<u8>>); 481 impl LocalHost { 482 fn run(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 483 Box::pin(async move { 484 self.0.set(self.0.get() + 1); 485 Ok(()) 486 }) 487 } 488 } 489 impl SessionHost for LocalHost { 490 fn start(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 491 self.run() 492 } 493 fn quiesce(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 494 self.run() 495 } 496 fn disconnect(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 497 self.run() 498 } 499 fn dispose_callbacks(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 500 self.run() 501 } 502 fn close_storage(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 503 self.run() 504 } 505 } 506 let observations = std::rc::Rc::new(std::cell::Cell::new(0)); 507 let client = ClientSession::new(LocalHost(observations.clone()), core::num::NonZeroU16::MIN); 508 let control = control(); 509 block_on(client.attach_signer(SignerHandle::new( 510 Shared::new(Provider(control.clone())), 511 Shared::new(Callbacks(control)), 512 ))) 513 .unwrap(); 514 assert_eq!(observations.get(), 0); 515 block_on(client.start()).unwrap(); 516 block_on(client.close()).unwrap(); 517 assert_eq!(observations.get(), 5); 518 } 519 520 fn exact_intent(second: bool, operation: u8) -> radroots_signing::issuance::SigningIntent { 521 use radroots_signing::issuance::{ArtifactRole, SigningIntent}; 522 let plan = radroots_event_codec::authoring::AuthoredEventPlan::from_generic( 523 radroots_event::GenericEventDraft::new( 524 "radroots.social.geochat.v1", 525 20_000, 526 1_700_000_000, 527 vec![], 528 "synthetic captured scope", 529 key(second).to_hex(), 530 ) 531 .unwrap(), 532 ) 533 .unwrap(); 534 SigningIntent::new( 535 radroots_domain::OperationId::from_bytes([operation; 32]), 536 [9; 32], 537 plan, 538 ArtifactRole::PublicEvent, 539 None, 540 ProviderCall::new( 541 key(second), 542 core::num::NonZeroU64::new(1_700_000_010_000).unwrap(), 543 radroots_signing::request::CancellationSignal::new(), 544 ), 545 ) 546 .unwrap() 547 } 548 549 #[cfg(not(target_arch = "wasm32"))] 550 #[test] 551 fn exact_issuance_requires_successful_observation_actual_support_and_the_frozen_key() { 552 use radroots_signing::issuance::ExactIssuer; 553 use radroots_signing::issuance::OutcomeKind; 554 let Fixture { 555 session, control, .. 556 } = scope(); 557 assert!(matches!( 558 block_on(ExactIssuer::issue_exact(&session, exact_intent(false, 1))).kind(), 559 OutcomeKind::NotDispatched(ProviderError::CapabilityUnavailable) 560 )); 561 block_on(session.observe()).unwrap(); 562 assert!(matches!( 563 block_on(session.sign_exact(exact_intent(false, 1))).kind(), 564 OutcomeKind::NotDispatched(ProviderError::CapabilityUnavailable) 565 )); 566 assert_eq!(control.sign_calls.load(Ordering::SeqCst), 0); 567 *control.current.lock().unwrap() = 568 state(false, false).with_exact_issuance(Some(ReplayCapability::NonReplayable)); 569 block_on(session.observe()).unwrap(); 570 assert!(matches!( 571 block_on(session.sign_exact(exact_intent(true, 1))).kind(), 572 OutcomeKind::NotDispatched(ProviderError::IdentityChanged) 573 )); 574 assert!(!session.identity_changed()); 575 assert!(matches!( 576 block_on(ExactIssuer::issue_exact(&session, exact_intent(false, 1))).kind(), 577 OutcomeKind::Unknown(_) 578 )); 579 assert_eq!(control.sign_calls.load(Ordering::SeqCst), 1); 580 *control.current.lock().unwrap() = 581 state(true, false).with_exact_issuance(Some(ReplayCapability::NonReplayable)); 582 assert_eq!( 583 block_on(session.observe()), 584 Err(ProviderError::IdentityChanged) 585 ); 586 assert!(matches!( 587 block_on(session.sign_exact(exact_intent(false, 1))).kind(), 588 OutcomeKind::NotDispatched(ProviderError::IdentityChanged) 589 )); 590 assert_eq!(control.sign_calls.load(Ordering::SeqCst), 1); 591 block_on(session.close()).unwrap(); 592 593 let Fixture { 594 session, control, .. 595 } = scope(); 596 let (send, receive) = oneshot::channel(); 597 drop(send); 598 *control.response.lock().unwrap() = Some(receive); 599 assert!(block_on(session.observe()).is_err()); 600 assert!(matches!( 601 block_on(session.sign_exact(exact_intent(false, 1))).kind(), 602 OutcomeKind::NotDispatched(ProviderError::CapabilityUnavailable) 603 )); 604 assert_eq!(control.sign_calls.load(Ordering::SeqCst), 0); 605 block_on(session.close()).unwrap(); 606 } 607 608 #[cfg(not(target_arch = "wasm32"))] 609 #[test] 610 fn pending_exact_issuance_retains_callbacks_until_its_bound_outcome_is_observed() { 611 use radroots_signing::issuance::ExactIssuer; 612 use radroots_signing::issuance::{OutcomeKind, SigningOutcome}; 613 let Fixture { 614 session, 615 control, 616 provider, 617 callbacks, 618 } = scope(); 619 *control.current.lock().unwrap() = 620 state(false, false).with_exact_issuance(Some(ReplayCapability::NonReplayable)); 621 block_on(session.observe()).unwrap(); 622 let input = exact_intent(false, 1); 623 let binding = input.binding(); 624 let (send, receive) = oneshot::channel(); 625 *control.sign_response.lock().unwrap() = Some(receive); 626 let mut issue = ExactIssuer::issue_exact(&session, input); 627 let mut cx = Context::from_waker(noop_waker_ref()); 628 assert!(issue.as_mut().poll(&mut cx).is_pending()); 629 let mut close = Box::pin(session.close()); 630 assert!(close.as_mut().poll(&mut cx).is_pending()); 631 assert_eq!(session.state(), SessionState::Closing); 632 assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0); 633 assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some()); 634 send.send(SigningOutcome::unknown( 635 binding, 636 ProviderError::ProviderFailure, 637 )) 638 .unwrap(); 639 let Poll::Ready(outcome) = issue.as_mut().poll(&mut cx) else { 640 panic!("outcome not received"); 641 }; 642 assert_eq!(outcome.binding(), binding); 643 assert!(matches!(outcome.kind(), OutcomeKind::Unknown(_))); 644 assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(())))); 645 assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); 646 } 647 648 #[cfg(not(target_arch = "wasm32"))] 649 #[test] 650 fn exact_callback_binding_cannot_claim_another_operations_result() { 651 use radroots_signing::issuance::{OutcomeKind, RejectionReason}; 652 let Fixture { 653 session, control, .. 654 } = scope(); 655 *control.current.lock().unwrap() = 656 state(false, false).with_exact_issuance(Some(ReplayCapability::NonReplayable)); 657 block_on(session.observe()).unwrap(); 658 *control.sign_binding.lock().unwrap() = Some(exact_intent(false, 2).binding()); 659 let input = exact_intent(false, 1); 660 let expected = input.binding(); 661 let outcome = block_on(session.sign_exact(input)); 662 assert_eq!(outcome.binding(), expected); 663 let OutcomeKind::Rejected(rejected) = outcome.kind() else { 664 panic!("wrong binding promoted"); 665 }; 666 assert_eq!(rejected.reason(), RejectionReason::BindingMismatch); 667 assert!(rejected.fingerprint().is_none()); 668 block_on(session.close()).unwrap(); 669 } 670 671 fn crypto_call(second: bool) -> ProviderCall { 672 ProviderCall::new( 673 key(second), 674 core::num::NonZeroU64::new(1_700_000_010_000).unwrap(), 675 radroots_signing::request::CancellationSignal::new(), 676 ) 677 } 678 679 #[cfg(not(target_arch = "wasm32"))] 680 #[test] 681 fn private_crypto_reobserves_the_attached_identity_and_capability_without_fallback() { 682 let Fixture { 683 session, control, .. 684 } = scope(); 685 assert_eq!( 686 block_on(session.encrypt_private( 687 crypto_call(false), 688 key(true), 689 PrivateText::new("private model").unwrap() 690 )) 691 .unwrap_err(), 692 ProviderError::CapabilityUnavailable 693 ); 694 assert_eq!(control.calls.load(Ordering::SeqCst), 0); 695 block_on(session.observe()).unwrap(); 696 assert_eq!( 697 block_on(session.encrypt_private( 698 crypto_call(false), 699 key(true), 700 PrivateText::new("private model").unwrap() 701 )) 702 .unwrap_err(), 703 ProviderError::CapabilityUnavailable 704 ); 705 assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 0); 706 *control.current.lock().unwrap() = state(false, true); 707 assert_eq!( 708 block_on(session.encrypt_private( 709 crypto_call(true), 710 key(true), 711 PrivateText::new("private model").unwrap() 712 )) 713 .unwrap_err(), 714 ProviderError::IdentityChanged 715 ); 716 assert!(!session.identity_changed()); 717 assert_eq!( 718 block_on(session.encrypt_private( 719 crypto_call(false), 720 key(true), 721 PrivateText::new("private model").unwrap() 722 )) 723 .unwrap_err(), 724 ProviderError::ProviderFailure 725 ); 726 // This is structural port data, not authenticated NIP-44 ciphertext. 727 assert_eq!( 728 block_on(session.decrypt_private( 729 crypto_call(false), 730 key(true), 731 PrivateCiphertext::parse(&"A".repeat(132)).unwrap() 732 )) 733 .unwrap_err(), 734 ProviderError::ProviderFailure 735 ); 736 assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 2); 737 *control.current.lock().unwrap() = state(true, true); 738 assert_eq!( 739 block_on(session.encrypt_private( 740 crypto_call(false), 741 key(true), 742 PrivateText::new("private model").unwrap() 743 )) 744 .unwrap_err(), 745 ProviderError::IdentityChanged 746 ); 747 *control.current.lock().unwrap() = state(false, true); 748 assert_eq!( 749 block_on(session.decrypt_private( 750 crypto_call(false), 751 key(true), 752 PrivateCiphertext::parse(&"A".repeat(132)).unwrap() 753 )) 754 .unwrap_err(), 755 ProviderError::IdentityChanged 756 ); 757 assert_eq!(control.crypto_calls.load(Ordering::SeqCst), 2); 758 block_on(session.close()).unwrap(); 759 assert_eq!( 760 block_on(session.encrypt_private( 761 crypto_call(false), 762 key(true), 763 PrivateText::new("private model").unwrap() 764 )) 765 .unwrap_err(), 766 ProviderError::CapabilityUnavailable 767 ); 768 } 769 770 #[cfg(not(target_arch = "wasm32"))] 771 #[test] 772 fn scoped_private_crypto_retains_callbacks_until_the_issued_call_finishes() { 773 let Fixture { 774 session, 775 control, 776 provider, 777 callbacks, 778 } = scope(); 779 *control.current.lock().unwrap() = state(false, true); 780 block_on(session.observe()).unwrap(); 781 let (send, receive) = oneshot::channel(); 782 *control.crypto_response.lock().unwrap() = Some(receive); 783 let mut encrypt = Box::pin(session.encrypt_private( 784 crypto_call(false), 785 key(true), 786 PrivateText::new("private model").unwrap(), 787 )); 788 let mut cx = Context::from_waker(noop_waker_ref()); 789 assert!(encrypt.as_mut().poll(&mut cx).is_pending()); 790 let mut close = Box::pin(session.close()); 791 assert!(close.as_mut().poll(&mut cx).is_pending()); 792 assert_eq!(session.state(), SessionState::Closing); 793 assert_eq!(control.close_attempts.load(Ordering::SeqCst), 0); 794 assert!(provider.upgrade().is_some() && callbacks.upgrade().is_some()); 795 send.send(()).unwrap(); 796 assert!(matches!( 797 encrypt.as_mut().poll(&mut cx), 798 Poll::Ready(Err(ProviderError::ProviderFailure)) 799 )); 800 assert!(matches!(close.as_mut().poll(&mut cx), Poll::Ready(Ok(())))); 801 assert!(provider.upgrade().is_none() && callbacks.upgrade().is_none()); 802 }