nip46_work.rs (47349B)
1 //! Transaction-free NIP-46 decryption, method admission, and provider work. 2 3 use core::fmt; 4 use std::error::Error; 5 6 use nostr::UnsignedEvent as NostrUnsignedEvent; 7 use radroots_nostr_connect::{ 8 message::{Request, RequestMessage, UnsignedEvent as ConnectUnsignedEvent}, 9 server::required_permission, 10 }; 11 use sha2::{Digest, Sha256}; 12 13 use crate::{ 14 MycConnectionAdmissionPolicy, MycConnectionAdmissionRequest, MycConnectionNonce, 15 MycConnectionPermission, MycConnectionPermissionSet, MycConnectionPolicyGeneration, 16 MycConnectionRecord, MycConnectionStatus, MycConnectionTimeUnixMs, MycNip46AdmissionLimits, 17 MycNip46EncryptionContext, MycProviderBinding, MycProviderContract, MycProviderCorrelationId, 18 MycProviderDeadlineUnixMs, MycProviderNip44Version, MycProviderOperation, 19 MycProviderOperationId, MycProviderOperationInput, MycProviderPublicIdentity, MycProviderRole, 20 MycRateRelayId, MycReplayBoundNip46Request, MycRequestReceivedAtUnixMs, 21 MycSignerOperationNonce, MycSignerRequest, MycSignerRequestMethod, MycSignerRequestRecord, 22 MycVerifiedNip46Event, MycVerifiedProviderResponse, admit_myc_nip46_request, 23 bind_myc_nip46_replay, verify_myc_nip46_request, 24 }; 25 26 const DECRYPT_OPERATION_ID_DOMAIN: &[u8] = b"radroots.myc.nip46.decrypt.operation.v1\0"; 27 const DECRYPT_CORRELATION_ID_DOMAIN: &[u8] = b"radroots.myc.nip46.decrypt.correlation.v1\0"; 28 29 /// Stable source-free Step 145 failure classification. 30 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 31 pub enum MycNip46WorkErrorKind { 32 InvalidBinding, 33 DecryptionRejected, 34 UnsupportedMethod, 35 PermissionDenied, 36 ConnectionExpired, 37 ProviderWorkRejected, 38 } 39 40 impl MycNip46WorkErrorKind { 41 /// Returns the stable machine-facing safe code. 42 #[must_use] 43 pub const fn code(self) -> &'static str { 44 match self { 45 Self::InvalidBinding => "nip46_work_binding_invalid", 46 Self::DecryptionRejected => "nip46_decryption_rejected", 47 Self::UnsupportedMethod => "nip46_method_unsupported", 48 Self::PermissionDenied => "nip46_permission_denied", 49 Self::ConnectionExpired => "nip46_connection_inactive", 50 Self::ProviderWorkRejected => "nip46_provider_work_rejected", 51 } 52 } 53 54 const fn message(self) -> &'static str { 55 match self { 56 Self::InvalidBinding => "NIP-46 work binding is invalid", 57 Self::DecryptionRejected => "NIP-46 decrypted request was rejected", 58 Self::UnsupportedMethod => "NIP-46 method is unsupported", 59 Self::PermissionDenied => "NIP-46 permission was denied", 60 Self::ConnectionExpired => "NIP-46 connection is not active", 61 Self::ProviderWorkRejected => "NIP-46 provider work was rejected", 62 } 63 } 64 } 65 66 /// One redacted source-free Step 145 failure. 67 #[derive(Clone, Copy, PartialEq, Eq)] 68 pub struct MycNip46WorkError { 69 kind: MycNip46WorkErrorKind, 70 } 71 72 impl MycNip46WorkError { 73 /// Returns the stable failure classification. 74 #[must_use] 75 pub const fn kind(self) -> MycNip46WorkErrorKind { 76 self.kind 77 } 78 79 /// Returns the stable machine-facing safe code. 80 #[must_use] 81 pub const fn code(self) -> &'static str { 82 self.kind.code() 83 } 84 } 85 86 impl fmt::Debug for MycNip46WorkError { 87 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 88 formatter 89 .debug_struct("MycNip46WorkError") 90 .field("kind", &self.kind) 91 .finish() 92 } 93 } 94 95 impl fmt::Display for MycNip46WorkError { 96 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 97 formatter.write_str(self.kind.message()) 98 } 99 } 100 101 impl Error for MycNip46WorkError {} 102 103 const fn work_error(kind: MycNip46WorkErrorKind) -> MycNip46WorkError { 104 MycNip46WorkError { kind } 105 } 106 107 /// Provider-bound work that must complete before plaintext request admission. 108 pub struct MycNip46DecryptWork { 109 event: MycVerifiedNip46Event, 110 operation: MycProviderOperation, 111 } 112 113 impl MycNip46DecryptWork { 114 /// Returns the exact transport-provider operation for external execution. 115 #[must_use] 116 pub const fn operation(&self) -> &MycProviderOperation { 117 &self.operation 118 } 119 120 /// Binds an independently verified provider result to the exact event. 121 pub fn complete( 122 self, 123 response: MycVerifiedProviderResponse, 124 limits: MycNip46AdmissionLimits, 125 ) -> Result<MycDecryptedNip46Request, MycNip46WorkError> { 126 let expected_capability = self.operation.input().capability(); 127 if response.operation_id() != self.operation.operation_id() 128 || response.correlation_id() != self.operation.correlation_id() 129 || response.instance() != self.operation.instance() 130 || response.role() != MycProviderRole::Transport 131 || response.capability() != expected_capability 132 || response.nip44_version() != self.operation.input().nip44_version() 133 || !response.matches_operation(&self.operation) 134 { 135 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 136 } 137 let plaintext = response 138 .protected_payload() 139 .ok_or_else(|| work_error(MycNip46WorkErrorKind::DecryptionRejected))?; 140 let bounded = admit_myc_nip46_request(limits, plaintext) 141 .map_err(|_| work_error(MycNip46WorkErrorKind::DecryptionRejected))?; 142 let request = verify_myc_nip46_request(bounded) 143 .map_err(|_| work_error(MycNip46WorkErrorKind::DecryptionRejected))?; 144 let replay = bind_myc_nip46_replay(self.event, request) 145 .map_err(|_| work_error(MycNip46WorkErrorKind::DecryptionRejected))?; 146 Ok(MycDecryptedNip46Request { replay }) 147 } 148 } 149 150 impl fmt::Debug for MycNip46DecryptWork { 151 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 152 formatter 153 .debug_struct("MycNip46DecryptWork") 154 .field("event", &"[redacted]") 155 .field("operation", &self.operation) 156 .finish() 157 } 158 } 159 160 /// Constructs the exact transport-provider decryption work for one verified event. 161 pub fn prepare_myc_nip46_decrypt_work( 162 event: MycVerifiedNip46Event, 163 transport: &MycProviderBinding, 164 deadline: MycProviderDeadlineUnixMs, 165 ) -> Result<MycNip46DecryptWork, MycNip46WorkError> { 166 if transport.role() != MycProviderRole::Transport 167 || transport.expected_identity() != event.receiver_public_key() 168 { 169 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 170 } 171 let operation_id = MycProviderOperationId::from_bytes(derive_decrypt_identity( 172 DECRYPT_OPERATION_ID_DOMAIN, 173 event.event_id().as_bytes(), 174 )); 175 let correlation_id = MycProviderCorrelationId::from_bytes(derive_decrypt_identity( 176 DECRYPT_CORRELATION_ID_DOMAIN, 177 event.event_id().as_bytes(), 178 )); 179 let peer = MycProviderPublicIdentity::new(event.client_public_key().as_hex()) 180 .map_err(|_| work_error(MycNip46WorkErrorKind::InvalidBinding))?; 181 let input = match event.encryption_context() { 182 MycNip46EncryptionContext::Nip04 => { 183 MycProviderOperationInput::nip04_decrypt(peer, event.encrypted_content().as_bytes()) 184 } 185 MycNip46EncryptionContext::Nip44V2 => MycProviderOperationInput::nip44_decrypt( 186 peer, 187 MycProviderNip44Version::V2, 188 event.encrypted_content().as_bytes(), 189 ), 190 } 191 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?; 192 let operation = 193 MycProviderOperation::new(transport, operation_id, correlation_id, deadline, input) 194 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?; 195 Ok(MycNip46DecryptWork { event, operation }) 196 } 197 198 fn derive_decrypt_identity(domain: &[u8], event_id: &[u8; 32]) -> [u8; 32] { 199 let mut hasher = Sha256::new(); 200 hasher.update(domain); 201 hasher.update(event_id); 202 hasher.finalize().into() 203 } 204 205 /// Non-forgeable proof that the typed request came from the exact decrypt work. 206 pub struct MycDecryptedNip46Request { 207 replay: MycReplayBoundNip46Request, 208 } 209 210 impl fmt::Debug for MycDecryptedNip46Request { 211 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 212 formatter.write_str("MycDecryptedNip46Request([redacted])") 213 } 214 } 215 216 /// Exact request ready for durable admission but not provider execution. 217 pub struct MycPreparedNip46Request { 218 signer_request: MycSignerRequest, 219 request: Request, 220 encryption_context: MycNip46EncryptionContext, 221 } 222 223 impl MycPreparedNip46Request { 224 /// Returns the exact input for the short durable request-admission transaction. 225 #[must_use] 226 pub const fn signer_request(&self) -> &MycSignerRequest { 227 &self.signer_request 228 } 229 230 /// Returns the exact closed method admitted before persistence. 231 #[must_use] 232 pub const fn method(&self) -> MycSignerRequestMethod { 233 self.signer_request.method() 234 } 235 } 236 237 impl fmt::Debug for MycPreparedNip46Request { 238 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 239 formatter 240 .debug_struct("MycPreparedNip46Request") 241 .field("method", &self.method()) 242 .field("request", &"[redacted]") 243 .finish() 244 } 245 } 246 247 /// Converts one proven decrypted request into exact durable-admission input. 248 pub fn prepare_myc_nip46_request( 249 decrypted: MycDecryptedNip46Request, 250 nonce: MycSignerOperationNonce, 251 received_at: MycRequestReceivedAtUnixMs, 252 ) -> Result<MycPreparedNip46Request, MycNip46WorkError> { 253 let encryption_context = decrypted.replay.encryption_context(); 254 let method = MycSignerRequestMethod::parse(decrypted.replay.method()) 255 .ok_or_else(|| work_error(MycNip46WorkErrorKind::UnsupportedMethod))?; 256 let message: RequestMessage = serde_json::from_slice(decrypted.replay.canonical_request()) 257 .map_err(|_| work_error(MycNip46WorkErrorKind::InvalidBinding))?; 258 if message.payload().method().as_str() != method.as_str() 259 || message 260 .request_id() 261 .map(|request_id| request_id.as_str() != decrypted.replay.request_id().as_str()) 262 .unwrap_or(true) 263 { 264 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 265 } 266 let signer_request = MycSignerRequest::new( 267 decrypted.replay.client_public_key().clone(), 268 decrypted.replay.request_id().clone(), 269 decrypted.replay.event_id(), 270 method, 271 decrypted.replay.request_digest(), 272 nonce, 273 received_at, 274 ); 275 Ok(MycPreparedNip46Request { 276 signer_request, 277 request: message.request, 278 encryption_context, 279 }) 280 } 281 282 /// Exact Step 145 work classification. 283 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 284 pub enum MycNip46WorkKind { 285 Connect, 286 Local, 287 Provider, 288 } 289 290 enum Nip46WorkPayload { 291 Connect { 292 client: crate::MycNip46ClientPublicKey, 293 permissions: MycConnectionPermissionSet, 294 }, 295 Local, 296 Provider(MycProviderOperation), 297 } 298 299 /// Sealed request work constructed only after durable request admission. 300 pub struct MycNip46Work { 301 request: MycSignerRequestRecord, 302 connection: Option<MycConnectionRecord>, 303 method: MycSignerRequestMethod, 304 encryption_context: MycNip46EncryptionContext, 305 payload: Nip46WorkPayload, 306 } 307 308 impl MycNip46Work { 309 #[cfg(all(test, any(target_os = "linux", target_os = "macos")))] 310 pub(crate) fn local_for_test( 311 request: MycSignerRequestRecord, 312 connection: MycConnectionRecord, 313 method: MycSignerRequestMethod, 314 ) -> Self { 315 assert!(matches!( 316 method, 317 MycSignerRequestMethod::GetPublicKey 318 | MycSignerRequestMethod::GetSessionCapability 319 | MycSignerRequestMethod::Ping 320 | MycSignerRequestMethod::SwitchRelays 321 | MycSignerRequestMethod::Logout 322 )); 323 Self { 324 request, 325 connection: Some(connection), 326 method, 327 encryption_context: MycNip46EncryptionContext::Nip44V2, 328 payload: Nip46WorkPayload::Local, 329 } 330 } 331 332 /// Returns the exact admitted durable request record. 333 #[must_use] 334 pub const fn request_record(&self) -> &MycSignerRequestRecord { 335 &self.request 336 } 337 338 /// Returns the exact active connection used for non-connect work. 339 #[must_use] 340 pub const fn connection(&self) -> Option<&MycConnectionRecord> { 341 self.connection.as_ref() 342 } 343 344 /// Returns the exact admitted request method. 345 #[must_use] 346 pub const fn method(&self) -> MycSignerRequestMethod { 347 self.method 348 } 349 350 pub(crate) const fn encryption_context(&self) -> MycNip46EncryptionContext { 351 self.encryption_context 352 } 353 354 /// Returns the work class without exposing protected parameters. 355 #[must_use] 356 pub const fn kind(&self) -> MycNip46WorkKind { 357 match &self.payload { 358 Nip46WorkPayload::Connect { .. } => MycNip46WorkKind::Connect, 359 Nip46WorkPayload::Local => MycNip46WorkKind::Local, 360 Nip46WorkPayload::Provider(_) => MycNip46WorkKind::Provider, 361 } 362 } 363 364 /// Returns the provider operation only for provider-bearing work. 365 #[must_use] 366 pub const fn provider_operation(&self) -> Option<&MycProviderOperation> { 367 match &self.payload { 368 Nip46WorkPayload::Provider(operation) => Some(operation), 369 Nip46WorkPayload::Connect { .. } | Nip46WorkPayload::Local => None, 370 } 371 } 372 373 /// Constructs the exact Step 144 admission request for connect work. 374 pub fn connection_admission_request( 375 &self, 376 policy_generation: MycConnectionPolicyGeneration, 377 nonce: MycConnectionNonce, 378 observed_at: MycConnectionTimeUnixMs, 379 authorized_until: Option<MycConnectionTimeUnixMs>, 380 policy: MycConnectionAdmissionPolicy, 381 relay_id: MycRateRelayId, 382 ) -> Result<MycConnectionAdmissionRequest, MycNip46WorkError> { 383 let Nip46WorkPayload::Connect { 384 client, 385 permissions, 386 } = &self.payload 387 else { 388 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 389 }; 390 MycConnectionAdmissionRequest::new( 391 self.request.operation_id(), 392 client.clone(), 393 permissions.clone(), 394 policy_generation, 395 nonce, 396 observed_at, 397 authorized_until, 398 policy, 399 relay_id, 400 ) 401 .map_err(|_| work_error(MycNip46WorkErrorKind::InvalidBinding)) 402 } 403 } 404 405 impl fmt::Debug for MycNip46Work { 406 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 407 formatter 408 .debug_struct("MycNip46Work") 409 .field("method", &self.method) 410 .field("kind", &self.kind()) 411 .field("request", &"[redacted]") 412 .field( 413 "connection", 414 &self.connection.as_ref().map(|_| "[redacted]"), 415 ) 416 .finish() 417 } 418 } 419 420 /// Binds an admitted request and optional active connection to exact work. 421 /// 422 /// This function accepts no repository, host, transaction, provider executor, 423 /// clock, or entropy source. Provider execution therefore starts only after 424 /// the caller's durable request-admission transaction has ended. 425 pub fn prepare_myc_nip46_work( 426 prepared: MycPreparedNip46Request, 427 record: MycSignerRequestRecord, 428 connection: Option<MycConnectionRecord>, 429 providers: &MycProviderContract, 430 observed_at: MycConnectionTimeUnixMs, 431 provider_deadline: Option<MycProviderDeadlineUnixMs>, 432 ) -> Result<MycNip46Work, MycNip46WorkError> { 433 let MycPreparedNip46Request { 434 signer_request, 435 request, 436 encryption_context, 437 } = prepared; 438 if !record.matches_request(&signer_request) || observed_at.get() < record.received_at().get() { 439 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 440 } 441 let method = signer_request.method(); 442 let request = match request { 443 Request::Connect { 444 remote_signer_public_key, 445 secret, 446 requested_permissions, 447 client_metadata: _, 448 } => { 449 if connection.is_some() || provider_deadline.is_some() || secret.is_some() { 450 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 451 } 452 let transport = transport_binding(providers)?; 453 if remote_signer_public_key.to_hex() != transport.expected_identity().as_hex() { 454 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 455 } 456 let permissions = connect_permissions(requested_permissions.as_slice())?; 457 return Ok(MycNip46Work { 458 request: record, 459 connection: None, 460 method, 461 encryption_context, 462 payload: Nip46WorkPayload::Connect { 463 client: signer_request.client_public_key().clone(), 464 permissions, 465 }, 466 }); 467 } 468 Request::Custom { .. } => { 469 return Err(work_error(MycNip46WorkErrorKind::UnsupportedMethod)); 470 } 471 request => request, 472 }; 473 474 let connection = connection.ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding))?; 475 if connection.client_public_key() != signer_request.client_public_key() { 476 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 477 } 478 if connection.status() != MycConnectionStatus::Active 479 || connection 480 .authorized_until() 481 .is_some_and(|until| observed_at > until) 482 { 483 return Err(work_error(MycNip46WorkErrorKind::ConnectionExpired)); 484 } 485 if let Some(permission) = required_permission(&request) { 486 let permission = protocol_permission(&permission.to_string())?; 487 if !connection.granted_permissions().contains(permission) { 488 return Err(work_error(MycNip46WorkErrorKind::PermissionDenied)); 489 } 490 } 491 492 let payload = match request { 493 Request::GetPublicKey 494 | Request::GetSessionCapability 495 | Request::Ping 496 | Request::SwitchRelays 497 | Request::Logout => { 498 if provider_deadline.is_some() { 499 return Err(work_error(MycNip46WorkErrorKind::InvalidBinding)); 500 } 501 Nip46WorkPayload::Local 502 } 503 Request::SignEvent(event) => { 504 let input = sign_event_input(&event, providers)?; 505 provider_work( 506 providers, 507 &record, 508 observed_at, 509 provider_deadline, 510 Ok(input), 511 )? 512 } 513 Request::Nip04Encrypt { 514 public_key, 515 plaintext, 516 } => provider_work( 517 providers, 518 &record, 519 observed_at, 520 provider_deadline, 521 MycProviderOperationInput::nip04_encrypt( 522 provider_identity(&public_key.to_hex())?, 523 plaintext.as_bytes(), 524 ), 525 )?, 526 Request::Nip04Decrypt { 527 public_key, 528 ciphertext, 529 } => provider_work( 530 providers, 531 &record, 532 observed_at, 533 provider_deadline, 534 MycProviderOperationInput::nip04_decrypt( 535 provider_identity(&public_key.to_hex())?, 536 ciphertext.as_bytes(), 537 ), 538 )?, 539 Request::Nip44Encrypt { 540 public_key, 541 plaintext, 542 } => provider_work( 543 providers, 544 &record, 545 observed_at, 546 provider_deadline, 547 MycProviderOperationInput::nip44_encrypt( 548 provider_identity(&public_key.to_hex())?, 549 MycProviderNip44Version::V2, 550 plaintext.as_bytes(), 551 ), 552 )?, 553 Request::Nip44Decrypt { 554 public_key, 555 ciphertext, 556 } => provider_work( 557 providers, 558 &record, 559 observed_at, 560 provider_deadline, 561 MycProviderOperationInput::nip44_decrypt( 562 provider_identity(&public_key.to_hex())?, 563 MycProviderNip44Version::V2, 564 ciphertext.as_bytes(), 565 ), 566 )?, 567 Request::Connect { .. } | Request::Custom { .. } => { 568 return Err(work_error(MycNip46WorkErrorKind::UnsupportedMethod)); 569 } 570 }; 571 572 Ok(MycNip46Work { 573 request: record, 574 connection: Some(connection), 575 method, 576 encryption_context, 577 payload, 578 }) 579 } 580 581 fn provider_work( 582 providers: &MycProviderContract, 583 record: &MycSignerRequestRecord, 584 observed_at: MycConnectionTimeUnixMs, 585 deadline: Option<MycProviderDeadlineUnixMs>, 586 input: Result<MycProviderOperationInput, crate::MycProviderContractError>, 587 ) -> Result<Nip46WorkPayload, MycNip46WorkError> { 588 let deadline = deadline.ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding))?; 589 if deadline.get() <= observed_at.get() { 590 return Err(work_error(MycNip46WorkErrorKind::ProviderWorkRejected)); 591 } 592 let input = input.map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?; 593 let operation = MycProviderOperation::new( 594 user_binding(providers)?, 595 MycProviderOperationId::from_bytes(*record.operation_id().as_bytes()), 596 MycProviderCorrelationId::from_bytes(*record.correlation_id().as_bytes()), 597 deadline, 598 input, 599 ) 600 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?; 601 Ok(Nip46WorkPayload::Provider(operation)) 602 } 603 604 fn user_binding(providers: &MycProviderContract) -> Result<&MycProviderBinding, MycNip46WorkError> { 605 providers 606 .binding(MycProviderRole::User) 607 .ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding)) 608 } 609 610 fn transport_binding( 611 providers: &MycProviderContract, 612 ) -> Result<&MycProviderBinding, MycNip46WorkError> { 613 providers 614 .binding(MycProviderRole::Transport) 615 .ok_or_else(|| work_error(MycNip46WorkErrorKind::InvalidBinding)) 616 } 617 618 fn sign_event_input( 619 event: &ConnectUnsignedEvent, 620 providers: &MycProviderContract, 621 ) -> Result<MycProviderOperationInput, MycNip46WorkError> { 622 let canonical = event.as_json(); 623 let unsigned: NostrUnsignedEvent = serde_json::from_str(&canonical) 624 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?; 625 let reencoded = serde_json::to_vec(&unsigned) 626 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected))?; 627 if reencoded.as_slice() != canonical.as_bytes() 628 || unsigned.verify_id().is_err() 629 || unsigned.pubkey.to_hex() != user_binding(providers)?.expected_identity().as_hex() 630 { 631 return Err(work_error(MycNip46WorkErrorKind::ProviderWorkRejected)); 632 } 633 MycProviderOperationInput::sign_event(canonical.as_bytes()) 634 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected)) 635 } 636 637 fn provider_identity(value: &str) -> Result<MycProviderPublicIdentity, MycNip46WorkError> { 638 MycProviderPublicIdentity::new(value) 639 .map_err(|_| work_error(MycNip46WorkErrorKind::ProviderWorkRejected)) 640 } 641 642 fn protocol_permission(value: &str) -> Result<MycConnectionPermission, MycNip46WorkError> { 643 MycConnectionPermission::parse(value) 644 .ok_or_else(|| work_error(MycNip46WorkErrorKind::UnsupportedMethod)) 645 } 646 647 fn connect_permissions( 648 permissions: &[radroots_nostr_connect::permission::Permission], 649 ) -> Result<MycConnectionPermissionSet, MycNip46WorkError> { 650 let permissions = permissions 651 .iter() 652 .map(connect_permission) 653 .collect::<Result<Vec<_>, _>>()?; 654 if permissions.iter().any(|permission| { 655 !matches!( 656 permission, 657 MycConnectionPermission::SignEvent(_) 658 | MycConnectionPermission::Nip04Encrypt 659 | MycConnectionPermission::Nip04Decrypt 660 | MycConnectionPermission::Nip44Encrypt 661 | MycConnectionPermission::Nip44Decrypt 662 | MycConnectionPermission::SwitchRelays 663 ) 664 }) { 665 return Err(work_error(MycNip46WorkErrorKind::PermissionDenied)); 666 } 667 MycConnectionPermissionSet::new(&permissions) 668 .map_err(|_| work_error(MycNip46WorkErrorKind::PermissionDenied)) 669 } 670 671 fn connect_permission( 672 permission: &radroots_nostr_connect::permission::Permission, 673 ) -> Result<MycConnectionPermission, MycNip46WorkError> { 674 if permission.method() == &radroots_nostr_connect::Method::SignEvent { 675 let parameter = permission 676 .parameter() 677 .ok_or_else(|| work_error(MycNip46WorkErrorKind::PermissionDenied))?; 678 let kind = parameter.strip_prefix("kind:").unwrap_or(parameter); 679 let parsed = kind 680 .parse::<u32>() 681 .ok() 682 .filter(|parsed| kind == parsed.to_string()) 683 .ok_or_else(|| work_error(MycNip46WorkErrorKind::PermissionDenied))?; 684 return Ok(MycConnectionPermission::SignEvent(parsed)); 685 } 686 if permission.parameter().is_some() { 687 return Err(work_error(MycNip46WorkErrorKind::PermissionDenied)); 688 } 689 protocol_permission(permission.method().as_str()) 690 } 691 692 #[cfg(test)] 693 mod tests { 694 use nostr::{ 695 EventBuilder, JsonUtil as _, Keys, Kind, Tag, Timestamp, 696 UnsignedEvent as NostrUnsignedEvent, 697 nips::{nip04, nip44}, 698 }; 699 use radroots_nostr_connect::{ 700 Method, 701 message::{Request, RequestMessage, UnsignedEvent as ConnectUnsignedEvent}, 702 }; 703 704 use crate::{ 705 MycConfigDocumentV1, MycConfigProfile, MycNip46AuthoredTimePolicy, 706 MycNip46ObservedAtUnixSeconds, MycProviderCapability, MycProviderResponseObservedAtUnixMs, 707 admit_myc_nip46_event, parse_myc_config_v1, 708 provider_verification::verify_protected_response_for_test, verify_myc_nip46_event, 709 }; 710 711 use super::*; 712 713 const CONFIG: &str = include_str!("../contracts/services_hardening/config.v1.example.toml"); 714 const OBSERVED_AT_SECONDS: u64 = 1_725_000_000; 715 const RECEIVED_AT_MS: u64 = 1_725_000_000_000; 716 const PROVIDER_DEADLINE_MS: u64 = RECEIVED_AT_MS + 10_000; 717 718 fn keys(seed: u8) -> Keys { 719 Keys::parse(&format!("{seed:02x}{}", "00".repeat(31))).expect("test keys") 720 } 721 722 fn configuration() -> MycConfigDocumentV1 { 723 let source = CONFIG 724 .replacen( 725 "4444444444444444444444444444444444444444444444444444444444444444", 726 &keys(2).public_key().to_hex(), 727 1, 728 ) 729 .replacen( 730 "2222222222222222222222222222222222222222222222222222222222222222", 731 &keys(3).public_key().to_hex(), 732 1, 733 ); 734 parse_myc_config_v1(source.as_bytes(), MycConfigProfile::RepoLocal) 735 .expect("test configuration") 736 } 737 738 fn verified_event( 739 request: &Request, 740 nip44_v2: bool, 741 created_at: u64, 742 ) -> (MycVerifiedNip46Event, Vec<u8>) { 743 let client = keys(1); 744 let transport = keys(2); 745 let message = RequestMessage::try_new(format!("request-{created_at}"), request.clone()) 746 .expect("request message"); 747 let plaintext = serde_json::to_vec(&message).expect("canonical request"); 748 let content = if nip44_v2 { 749 nip44::encrypt( 750 client.secret_key(), 751 &transport.public_key(), 752 &plaintext, 753 nip44::Version::V2, 754 ) 755 .expect("NIP-44 encryption") 756 } else { 757 nip04::encrypt(client.secret_key(), &transport.public_key(), &plaintext) 758 .expect("NIP-04 encryption") 759 }; 760 let event = EventBuilder::new(Kind::Custom(24_133), content) 761 .tag(Tag::public_key(transport.public_key())) 762 .custom_created_at(Timestamp::from_secs(created_at)) 763 .sign_with_keys(&client) 764 .expect("signed request event"); 765 let config = configuration(); 766 let limits = MycNip46AdmissionLimits::from_config(&config).expect("admission limits"); 767 let wire = serde_json::to_vec(&event).expect("event wire"); 768 let event = verify_myc_nip46_event( 769 admit_myc_nip46_event(limits, &wire).expect("bounded event"), 770 config 771 .provider_contract() 772 .binding(MycProviderRole::Transport) 773 .expect("transport binding"), 774 MycNip46ObservedAtUnixSeconds::new(OBSERVED_AT_SECONDS).expect("observation"), 775 MycNip46AuthoredTimePolicy::new(120, 120).expect("authored-time policy"), 776 ) 777 .expect("verified event"); 778 (event, plaintext) 779 } 780 781 fn decrypted(request: &Request, nip44_v2: bool, created_at: u64) -> MycDecryptedNip46Request { 782 let (event, plaintext) = verified_event(request, nip44_v2, created_at); 783 let config = configuration(); 784 let transport = config 785 .provider_contract() 786 .binding(MycProviderRole::Transport) 787 .expect("transport binding"); 788 let work = prepare_myc_nip46_decrypt_work( 789 event, 790 transport, 791 MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"), 792 ) 793 .expect("decrypt work"); 794 let response = verify_protected_response_for_test(transport, work.operation(), &plaintext) 795 .expect("verified provider response"); 796 work.complete( 797 response, 798 MycNip46AdmissionLimits::from_config(&config).expect("admission limits"), 799 ) 800 .expect("decrypted request") 801 } 802 803 fn prepared_request(request: Request, seed: u8) -> MycPreparedNip46Request { 804 prepare_myc_nip46_request( 805 decrypted(&request, true, OBSERVED_AT_SECONDS + u64::from(seed)), 806 MycSignerOperationNonce::from_injected_entropy([seed; 32]), 807 MycRequestReceivedAtUnixMs::new(RECEIVED_AT_MS + u64::from(seed)) 808 .expect("received time"), 809 ) 810 .expect("prepared request") 811 } 812 813 fn active_connection( 814 prepared: &MycPreparedNip46Request, 815 permissions: &[MycConnectionPermission], 816 authorized_until: Option<u64>, 817 ) -> MycConnectionRecord { 818 MycConnectionRecord::active_for_test( 819 prepared.signer_request.client_public_key().clone(), 820 MycConnectionPermissionSet::new(permissions).expect("permissions"), 821 authorized_until 822 .map(|value| MycConnectionTimeUnixMs::new(value).expect("authorization deadline")), 823 ) 824 } 825 826 fn unsigned_sign_event() -> ConnectUnsignedEvent { 827 unsigned_sign_event_for(3) 828 } 829 830 fn unsigned_sign_event_for(author_seed: u8) -> ConnectUnsignedEvent { 831 let event = NostrUnsignedEvent::new( 832 keys(author_seed).public_key(), 833 Timestamp::from_secs(OBSERVED_AT_SECONDS), 834 Kind::TextNote, 835 Vec::<Tag>::new(), 836 "bounded test event", 837 ); 838 ConnectUnsignedEvent::from_json(&event.as_json()).expect("connect unsigned event") 839 } 840 841 fn protocol_request(method: Method, params: Vec<String>) -> Request { 842 Request::from_parts(method, params).expect("protocol request") 843 } 844 845 #[test] 846 fn verified_decryption_is_bound_to_the_exact_event_and_context() { 847 let request = Request::Ping; 848 for (nip44_v2, expected_capability, expected_version) in [ 849 (false, MycProviderCapability::Nip04Decrypt, None), 850 ( 851 true, 852 MycProviderCapability::Nip44Decrypt, 853 Some(MycProviderNip44Version::V2), 854 ), 855 ] { 856 let (event, plaintext) = verified_event(&request, nip44_v2, OBSERVED_AT_SECONDS); 857 let config = configuration(); 858 let transport = config 859 .provider_contract() 860 .binding(MycProviderRole::Transport) 861 .expect("transport binding"); 862 let work = prepare_myc_nip46_decrypt_work( 863 event, 864 transport, 865 MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"), 866 ) 867 .expect("decrypt work"); 868 assert_eq!(work.operation().role(), MycProviderRole::Transport); 869 assert_eq!(work.operation().input().capability(), expected_capability); 870 assert_eq!(work.operation().input().nip44_version(), expected_version); 871 let response = 872 verify_protected_response_for_test(transport, work.operation(), &plaintext) 873 .expect("verified response"); 874 work.complete( 875 response, 876 MycNip46AdmissionLimits::from_config(&config).expect("limits"), 877 ) 878 .expect("exact event completion"); 879 } 880 881 let (first_event, plaintext) = verified_event(&request, true, OBSERVED_AT_SECONDS + 1); 882 let (second_event, _) = verified_event(&request, true, OBSERVED_AT_SECONDS + 2); 883 let config = configuration(); 884 let transport = config 885 .provider_contract() 886 .binding(MycProviderRole::Transport) 887 .expect("transport binding"); 888 let first = prepare_myc_nip46_decrypt_work( 889 first_event, 890 transport, 891 MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"), 892 ) 893 .expect("first work"); 894 let second = prepare_myc_nip46_decrypt_work( 895 second_event, 896 transport, 897 MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline"), 898 ) 899 .expect("second work"); 900 let response = verify_protected_response_for_test(transport, first.operation(), &plaintext) 901 .expect("first response"); 902 assert_ne!( 903 first.operation().operation_id(), 904 second.operation().operation_id() 905 ); 906 assert_eq!( 907 second 908 .complete( 909 response, 910 MycNip46AdmissionLimits::from_config(&config).expect("limits"), 911 ) 912 .expect_err("cross-event response"), 913 work_error(MycNip46WorkErrorKind::InvalidBinding) 914 ); 915 } 916 917 #[test] 918 fn exact_method_inventory_maps_to_local_and_user_provider_work() { 919 let peer = keys(4).public_key().to_hex(); 920 let cases = vec![ 921 (Request::GetPublicKey, None, MycNip46WorkKind::Local, None), 922 ( 923 Request::GetSessionCapability, 924 None, 925 MycNip46WorkKind::Local, 926 None, 927 ), 928 (Request::Ping, None, MycNip46WorkKind::Local, None), 929 (Request::Logout, None, MycNip46WorkKind::Local, None), 930 ( 931 Request::SwitchRelays, 932 Some(MycConnectionPermission::SwitchRelays), 933 MycNip46WorkKind::Local, 934 None, 935 ), 936 ( 937 Request::SignEvent(unsigned_sign_event()), 938 Some(MycConnectionPermission::SignEvent(1)), 939 MycNip46WorkKind::Provider, 940 Some(MycProviderCapability::SignEvent), 941 ), 942 ( 943 protocol_request(Method::Nip04Encrypt, vec![peer.clone(), "bounded".into()]), 944 Some(MycConnectionPermission::Nip04Encrypt), 945 MycNip46WorkKind::Provider, 946 Some(MycProviderCapability::Nip04Encrypt), 947 ), 948 ( 949 protocol_request( 950 Method::Nip04Decrypt, 951 vec![ 952 peer.clone(), 953 "QUFBQUFBQUFBQUFBQUFBQQ==?iv=QUFBQUFBQUFBQUFBQUFBQQ==".into(), 954 ], 955 ), 956 Some(MycConnectionPermission::Nip04Decrypt), 957 MycNip46WorkKind::Provider, 958 Some(MycProviderCapability::Nip04Decrypt), 959 ), 960 ( 961 protocol_request(Method::Nip44Encrypt, vec![peer.clone(), "bounded".into()]), 962 Some(MycConnectionPermission::Nip44Encrypt), 963 MycNip46WorkKind::Provider, 964 Some(MycProviderCapability::Nip44Encrypt), 965 ), 966 ( 967 protocol_request( 968 Method::Nip44Decrypt, 969 vec![ 970 peer, 971 "AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(), 972 ], 973 ), 974 Some(MycConnectionPermission::Nip44Decrypt), 975 MycNip46WorkKind::Provider, 976 Some(MycProviderCapability::Nip44Decrypt), 977 ), 978 ]; 979 for (index, (request, permission, expected_kind, expected_capability)) in 980 cases.into_iter().enumerate() 981 { 982 let prepared = prepared_request(request, u8::try_from(index + 1).expect("seed")); 983 let record = prepared.signer_request.admitted_record_for_test(); 984 let permissions = permission.into_iter().collect::<Vec<_>>(); 985 let connection = 986 active_connection(&prepared, &permissions, Some(RECEIVED_AT_MS + 100_000)); 987 let provider_deadline = (expected_kind == MycNip46WorkKind::Provider) 988 .then(|| MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")); 989 let work = prepare_myc_nip46_work( 990 prepared, 991 record, 992 Some(connection), 993 configuration().provider_contract(), 994 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 995 provider_deadline, 996 ) 997 .expect("governed work"); 998 assert_eq!(work.kind(), expected_kind); 999 assert_eq!( 1000 work.provider_operation() 1001 .map(|operation| operation.input().capability()), 1002 expected_capability 1003 ); 1004 if let Some(operation) = work.provider_operation() { 1005 assert_eq!(operation.role(), MycProviderRole::User); 1006 assert_eq!( 1007 operation.operation_id().as_bytes(), 1008 work.request_record().operation_id().as_bytes() 1009 ); 1010 } 1011 } 1012 } 1013 1014 #[test] 1015 fn connect_and_nonconnect_authorization_fail_closed() { 1016 let connect = protocol_request( 1017 Method::Connect, 1018 vec![ 1019 keys(2).public_key().to_hex(), 1020 String::new(), 1021 "nip44_encrypt,sign_event:1".into(), 1022 ], 1023 ); 1024 let prepared = prepared_request(connect, 20); 1025 let record = prepared.signer_request.admitted_record_for_test(); 1026 let work = prepare_myc_nip46_work( 1027 prepared, 1028 record, 1029 None, 1030 configuration().provider_contract(), 1031 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1032 None, 1033 ) 1034 .expect("connect work"); 1035 assert_eq!(work.kind(), MycNip46WorkKind::Connect); 1036 work.connection_admission_request( 1037 MycConnectionPolicyGeneration::new(1).expect("generation"), 1038 MycConnectionNonce::from_injected_entropy([0x44; 32]), 1039 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1040 None, 1041 MycConnectionAdmissionPolicy::ExplicitApproval, 1042 MycRateRelayId::new("primary").expect("relay"), 1043 ) 1044 .expect("admission request"); 1045 1046 for (request_seed, remote_signer_seed) in [(21, 3), (22, 4)] { 1047 let wrong_identity_connect = protocol_request( 1048 Method::Connect, 1049 vec![ 1050 keys(remote_signer_seed).public_key().to_hex(), 1051 String::new(), 1052 ], 1053 ); 1054 let prepared = prepared_request(wrong_identity_connect, request_seed); 1055 let record = prepared.signer_request.admitted_record_for_test(); 1056 assert_eq!( 1057 prepare_myc_nip46_work( 1058 prepared, 1059 record, 1060 None, 1061 configuration().provider_contract(), 1062 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1063 None, 1064 ) 1065 .expect_err("connect remote signer identity mismatch"), 1066 work_error(MycNip46WorkErrorKind::InvalidBinding) 1067 ); 1068 } 1069 1070 let secret_connect = protocol_request( 1071 Method::Connect, 1072 vec![keys(3).public_key().to_hex(), "forbidden-secret".into()], 1073 ); 1074 let prepared = prepared_request(secret_connect, 21); 1075 let record = prepared.signer_request.admitted_record_for_test(); 1076 assert_eq!( 1077 prepare_myc_nip46_work( 1078 prepared, 1079 record, 1080 None, 1081 configuration().provider_contract(), 1082 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1083 None, 1084 ) 1085 .expect_err("connect secret"), 1086 work_error(MycNip46WorkErrorKind::InvalidBinding) 1087 ); 1088 1089 let prepared = prepared_request( 1090 protocol_request( 1091 Method::Nip44Encrypt, 1092 vec![keys(4).public_key().to_hex(), "protected-marker".into()], 1093 ), 1094 22, 1095 ); 1096 let record = prepared.signer_request.admitted_record_for_test(); 1097 let denied = active_connection(&prepared, &[], Some(RECEIVED_AT_MS + 100_000)); 1098 assert_eq!( 1099 prepare_myc_nip46_work( 1100 prepared, 1101 record, 1102 Some(denied), 1103 configuration().provider_contract(), 1104 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1105 Some(MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")), 1106 ) 1107 .expect_err("missing permission"), 1108 work_error(MycNip46WorkErrorKind::PermissionDenied) 1109 ); 1110 1111 let prepared = prepared_request(Request::Ping, 24); 1112 let record = prepared.signer_request.admitted_record_for_test(); 1113 let expired = active_connection(&prepared, &[], Some(RECEIVED_AT_MS + 500)); 1114 assert_eq!( 1115 prepare_myc_nip46_work( 1116 prepared, 1117 record, 1118 Some(expired), 1119 configuration().provider_contract(), 1120 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1121 None, 1122 ) 1123 .expect_err("expired connection"), 1124 work_error(MycNip46WorkErrorKind::ConnectionExpired) 1125 ); 1126 1127 let prepared = prepared_request( 1128 protocol_request( 1129 Method::Nip04Encrypt, 1130 vec![keys(4).public_key().to_hex(), "bounded".into()], 1131 ), 1132 25, 1133 ); 1134 let record = prepared.signer_request.admitted_record_for_test(); 1135 let connection = active_connection( 1136 &prepared, 1137 &[MycConnectionPermission::Nip04Encrypt], 1138 Some(RECEIVED_AT_MS + 100_000), 1139 ); 1140 assert_eq!( 1141 prepare_myc_nip46_work( 1142 prepared, 1143 record, 1144 Some(connection), 1145 configuration().provider_contract(), 1146 MycConnectionTimeUnixMs::new(PROVIDER_DEADLINE_MS).expect("observation"), 1147 Some(MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")), 1148 ) 1149 .expect_err("nonfuture provider deadline"), 1150 work_error(MycNip46WorkErrorKind::ProviderWorkRejected) 1151 ); 1152 1153 let prepared = prepared_request(Request::SignEvent(unsigned_sign_event_for(4)), 28); 1154 let record = prepared.signer_request.admitted_record_for_test(); 1155 let connection = active_connection( 1156 &prepared, 1157 &[MycConnectionPermission::SignEvent(1)], 1158 Some(RECEIVED_AT_MS + 100_000), 1159 ); 1160 assert_eq!( 1161 prepare_myc_nip46_work( 1162 prepared, 1163 record, 1164 Some(connection), 1165 configuration().provider_contract(), 1166 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1167 Some(MycProviderDeadlineUnixMs::new(PROVIDER_DEADLINE_MS).expect("deadline")), 1168 ) 1169 .expect_err("wrong signing author"), 1170 work_error(MycNip46WorkErrorKind::ProviderWorkRejected) 1171 ); 1172 1173 let prepared = prepared_request(Request::Ping, 26); 1174 let mismatched = prepared_request(Request::Ping, 27) 1175 .signer_request 1176 .admitted_record_for_test(); 1177 let connection = active_connection(&prepared, &[], Some(RECEIVED_AT_MS + 100_000)); 1178 assert_eq!( 1179 prepare_myc_nip46_work( 1180 prepared, 1181 mismatched, 1182 Some(connection), 1183 configuration().provider_contract(), 1184 MycConnectionTimeUnixMs::new(RECEIVED_AT_MS + 1_000).expect("observation"), 1185 None, 1186 ) 1187 .expect_err("mismatched durable request"), 1188 work_error(MycNip46WorkErrorKind::InvalidBinding) 1189 ); 1190 1191 let custom = Request::Custom { 1192 method: Method::custom("vendor_method").expect("custom method"), 1193 params: vec!["protected-marker".to_owned()], 1194 }; 1195 assert_eq!( 1196 prepare_myc_nip46_request( 1197 decrypted(&custom, true, OBSERVED_AT_SECONDS + 23), 1198 MycSignerOperationNonce::from_injected_entropy([23; 32]), 1199 MycRequestReceivedAtUnixMs::new(RECEIVED_AT_MS).expect("received"), 1200 ) 1201 .expect_err("custom method"), 1202 work_error(MycNip46WorkErrorKind::UnsupportedMethod) 1203 ); 1204 } 1205 1206 #[test] 1207 fn errors_and_work_debug_are_source_free_and_redacted() { 1208 for kind in [ 1209 MycNip46WorkErrorKind::InvalidBinding, 1210 MycNip46WorkErrorKind::DecryptionRejected, 1211 MycNip46WorkErrorKind::UnsupportedMethod, 1212 MycNip46WorkErrorKind::PermissionDenied, 1213 MycNip46WorkErrorKind::ConnectionExpired, 1214 MycNip46WorkErrorKind::ProviderWorkRejected, 1215 ] { 1216 let error = work_error(kind); 1217 assert_eq!(error.kind(), kind); 1218 assert!(!error.code().is_empty()); 1219 assert!(!error.to_string().is_empty()); 1220 assert!(error.source().is_none()); 1221 } 1222 1223 let prepared = prepared_request(Request::Ping, 30); 1224 assert!(!format!("{prepared:?}").contains("request-")); 1225 assert!(!format!("{prepared:?}").contains("protected-marker")); 1226 assert!(MycProviderResponseObservedAtUnixMs::new(PROVIDER_DEADLINE_MS).is_ok()); 1227 } 1228 }