provider_verification.rs (56742B)
1 //! Independent semantic verification for untrusted signer-provider responses. 2 3 use core::fmt; 4 use std::error::Error; 5 6 use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD}; 7 use nostr::{Event, UnsignedEvent}; 8 use zeroize::Zeroizing; 9 10 use crate::provider_contract::MYC_PROVIDER_NIP44_PLAINTEXT_MAX_BYTES; 11 use crate::provider_local_signer::{ 12 LocalSignerUntrustedParts, MYC_LOCAL_SIGNER_TRANSPORT_CONTRACT_VERSION, 13 MycLocalSignerUntrustedResponse, ProtectedWireHex, WireCapability, WireProviderInstance, 14 WireProviderResult, WireRole, 15 }; 16 use crate::{ 17 MYC_PROVIDER_INPUT_MAX_BYTES, MYC_PROVIDER_OUTPUT_MAX_BYTES, MycProviderBinding, 18 MycProviderCapability, MycProviderCapabilitySet, MycProviderCorrelationId, 19 MycProviderInstanceId, MycProviderKind, MycProviderNip44Version, MycProviderOperation, 20 MycProviderOperationId, MycProviderPublicIdentity, MycProviderRole, 21 }; 22 23 const NIP44_V2_VERSION: u8 = 2; 24 const NIP44_V2_FIXED_PAYLOAD_BYTES: usize = 67; 25 26 /// Positive injected completion-observation time for provider verification. 27 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] 28 pub struct MycProviderResponseObservedAtUnixMs(u64); 29 30 impl MycProviderResponseObservedAtUnixMs { 31 /// Validates a positive UTC millisecond value representable by governed time types. 32 pub fn new(value: u64) -> Result<Self, MycProviderVerificationError> { 33 if value == 0 || i64::try_from(value).is_err() { 34 return Err(verification_error( 35 MycProviderVerificationErrorKind::InvalidObservationTime, 36 )); 37 } 38 Ok(Self(value)) 39 } 40 41 /// Returns the exact injected value. 42 #[must_use] 43 pub const fn get(self) -> u64 { 44 self.0 45 } 46 } 47 48 /// Stable source-free provider-verification failure classification. 49 #[derive(Clone, Copy, Debug, PartialEq, Eq)] 50 pub enum MycProviderVerificationErrorKind { 51 InvalidObservationTime, 52 InvalidBinding, 53 LateResponse, 54 ResponseBinding, 55 ResultShape, 56 Identity, 57 Capability, 58 Size, 59 Event, 60 Nip04, 61 Nip44, 62 } 63 64 impl MycProviderVerificationErrorKind { 65 /// Returns the stable machine-facing safe code. 66 #[must_use] 67 pub const fn code(self) -> &'static str { 68 match self { 69 Self::InvalidObservationTime => "provider_observation_time_invalid", 70 Self::InvalidBinding => "provider_verification_binding_invalid", 71 Self::LateResponse => "provider_response_late", 72 Self::ResponseBinding => "provider_response_binding_invalid", 73 Self::ResultShape => "provider_result_shape_invalid", 74 Self::Identity => "provider_result_identity_invalid", 75 Self::Capability => "provider_result_capability_invalid", 76 Self::Size => "provider_result_size_invalid", 77 Self::Event => "provider_signed_event_invalid", 78 Self::Nip04 => "provider_nip04_result_invalid", 79 Self::Nip44 => "provider_nip44_result_invalid", 80 } 81 } 82 83 const fn message(self) -> &'static str { 84 match self { 85 Self::InvalidObservationTime => "provider observation time is invalid", 86 Self::InvalidBinding => "provider verification binding is invalid", 87 Self::LateResponse => "provider response missed its deadline", 88 Self::ResponseBinding => "provider response binding is invalid", 89 Self::ResultShape => "provider result shape is invalid", 90 Self::Identity => "provider result identity is invalid", 91 Self::Capability => "provider result capability is invalid", 92 Self::Size => "provider result size is invalid", 93 Self::Event => "provider signed event is invalid", 94 Self::Nip04 => "provider NIP-04 result is invalid", 95 Self::Nip44 => "provider NIP-44 result is invalid", 96 } 97 } 98 } 99 100 /// One source-free provider-verification failure. 101 #[derive(Clone, Copy, PartialEq, Eq)] 102 pub struct MycProviderVerificationError { 103 kind: MycProviderVerificationErrorKind, 104 } 105 106 impl MycProviderVerificationError { 107 /// Returns the stable failure kind. 108 #[must_use] 109 pub const fn kind(self) -> MycProviderVerificationErrorKind { 110 self.kind 111 } 112 113 /// Returns the stable machine-facing safe code. 114 #[must_use] 115 pub const fn code(self) -> &'static str { 116 self.kind.code() 117 } 118 } 119 120 impl fmt::Debug for MycProviderVerificationError { 121 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 122 formatter 123 .debug_struct("MycProviderVerificationError") 124 .field("kind", &self.kind) 125 .finish() 126 } 127 } 128 129 impl fmt::Display for MycProviderVerificationError { 130 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 131 formatter.write_str(self.kind.message()) 132 } 133 } 134 135 impl Error for MycProviderVerificationError {} 136 137 const fn verification_error( 138 kind: MycProviderVerificationErrorKind, 139 ) -> MycProviderVerificationError { 140 MycProviderVerificationError { kind } 141 } 142 143 enum VerifiedProviderResult { 144 Describe { 145 public_identity: MycProviderPublicIdentity, 146 protocol_version: u32, 147 capabilities: MycProviderCapabilitySet, 148 maximum_request_bytes: u64, 149 }, 150 PublicIdentity(MycProviderPublicIdentity), 151 SignedEvent(Zeroizing<Vec<u8>>), 152 Protected { 153 payload: Zeroizing<Vec<u8>>, 154 nip44_version: Option<MycProviderNip44Version>, 155 }, 156 } 157 158 /// One fully correlated, deadline-admitted, independently verified provider result. 159 /// 160 /// This value proves only local semantic admission. It is not publication, 161 /// durable commit evidence, or proof that a cancelled provider call had no effect. 162 pub struct MycVerifiedProviderResponse { 163 operation_id: MycProviderOperationId, 164 correlation_id: MycProviderCorrelationId, 165 instance: MycProviderInstanceId, 166 role: MycProviderRole, 167 capability: MycProviderCapability, 168 operation_binding: [u8; 32], 169 result: VerifiedProviderResult, 170 } 171 172 impl MycVerifiedProviderResponse { 173 /// Returns the exact verified operation identity. 174 #[must_use] 175 pub const fn operation_id(&self) -> MycProviderOperationId { 176 self.operation_id 177 } 178 179 /// Returns the exact verified correlation identity. 180 #[must_use] 181 pub const fn correlation_id(&self) -> MycProviderCorrelationId { 182 self.correlation_id 183 } 184 185 /// Returns the exact verified provider instance. 186 #[must_use] 187 pub const fn instance(&self) -> MycProviderInstanceId { 188 self.instance 189 } 190 191 /// Returns the exact verified provider role. 192 #[must_use] 193 pub const fn role(&self) -> MycProviderRole { 194 self.role 195 } 196 197 /// Returns the exact verified capability. 198 #[must_use] 199 pub const fn capability(&self) -> MycProviderCapability { 200 self.capability 201 } 202 203 pub(crate) fn matches_operation(&self, operation: &MycProviderOperation) -> bool { 204 self.operation_binding == operation.binding_digest() 205 } 206 207 /// Returns a verified public identity for describe/public-identity results. 208 #[must_use] 209 pub const fn public_identity(&self) -> Option<&MycProviderPublicIdentity> { 210 match &self.result { 211 VerifiedProviderResult::Describe { 212 public_identity, .. 213 } 214 | VerifiedProviderResult::PublicIdentity(public_identity) => Some(public_identity), 215 VerifiedProviderResult::SignedEvent(_) | VerifiedProviderResult::Protected { .. } => { 216 None 217 } 218 } 219 } 220 221 /// Returns the verified protocol version for a describe result. 222 #[must_use] 223 pub const fn protocol_version(&self) -> Option<u32> { 224 match &self.result { 225 VerifiedProviderResult::Describe { 226 protocol_version, .. 227 } => Some(*protocol_version), 228 _ => None, 229 } 230 } 231 232 /// Returns the verified capability set for a describe result. 233 #[must_use] 234 pub const fn capabilities(&self) -> Option<MycProviderCapabilitySet> { 235 match &self.result { 236 VerifiedProviderResult::Describe { capabilities, .. } => Some(*capabilities), 237 _ => None, 238 } 239 } 240 241 /// Returns the verified provider request bound for a describe result. 242 #[must_use] 243 pub const fn maximum_request_bytes(&self) -> Option<u64> { 244 match &self.result { 245 VerifiedProviderResult::Describe { 246 maximum_request_bytes, 247 .. 248 } => Some(*maximum_request_bytes), 249 _ => None, 250 } 251 } 252 253 /// Returns the exact canonical independently verified signed-event bytes. 254 /// 255 /// These are the bytes returned by the provider after canonical-form, 256 /// field, author, event-ID, and signature verification. Consumers that 257 /// persist or publish the result must retain these exact bytes. 258 #[must_use] 259 pub fn signed_event_bytes(&self) -> Option<&[u8]> { 260 match &self.result { 261 VerifiedProviderResult::SignedEvent(bytes) => Some(bytes), 262 _ => None, 263 } 264 } 265 266 /// Returns the verified protected operation output, if applicable. 267 #[must_use] 268 pub fn protected_payload(&self) -> Option<&[u8]> { 269 match &self.result { 270 VerifiedProviderResult::Protected { payload, .. } => Some(payload), 271 _ => None, 272 } 273 } 274 275 /// Returns the exact verified NIP-44 version, if applicable. 276 #[must_use] 277 pub const fn nip44_version(&self) -> Option<MycProviderNip44Version> { 278 match &self.result { 279 VerifiedProviderResult::Protected { nip44_version, .. } => *nip44_version, 280 _ => None, 281 } 282 } 283 } 284 285 impl fmt::Debug for MycVerifiedProviderResponse { 286 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 287 formatter 288 .debug_struct("MycVerifiedProviderResponse") 289 .field("operation_id", &"[redacted]") 290 .field("correlation_id", &"[redacted]") 291 .field("instance", &self.instance) 292 .field("role", &self.role) 293 .field("capability", &self.capability) 294 .field("result", &"[redacted]") 295 .finish() 296 } 297 } 298 299 impl MycLocalSignerUntrustedResponse { 300 /// Independently verifies this untrusted response against its original call. 301 pub fn verify( 302 self, 303 binding: &MycProviderBinding, 304 operation: &MycProviderOperation, 305 observed_at: MycProviderResponseObservedAtUnixMs, 306 ) -> Result<MycVerifiedProviderResponse, MycProviderVerificationError> { 307 verify_response(binding, operation, observed_at, self.into_parts()) 308 } 309 } 310 311 pub(crate) fn verify_encrypted_provider_response( 312 binding: &MycProviderBinding, 313 operation: &MycProviderOperation, 314 observed_at: MycProviderResponseObservedAtUnixMs, 315 result: WireProviderResult, 316 ) -> Result<MycVerifiedProviderResponse, MycProviderVerificationError> { 317 if binding.kind() != MycProviderKind::EncryptedFile 318 || operation.provider() != MycProviderKind::EncryptedFile 319 || operation.role() != binding.role() 320 || operation.instance() != binding.instance() 321 || operation.expected_identity() != binding.expected_identity() 322 || !binding 323 .required_capabilities() 324 .contains(operation.input().capability()) 325 { 326 return Err(verification_error( 327 MycProviderVerificationErrorKind::InvalidBinding, 328 )); 329 } 330 if observed_at.get() > operation.deadline().get() { 331 return Err(verification_error( 332 MycProviderVerificationErrorKind::LateResponse, 333 )); 334 } 335 let result = verify_result(binding, operation, result)?; 336 Ok(MycVerifiedProviderResponse { 337 operation_id: operation.operation_id(), 338 correlation_id: operation.correlation_id(), 339 instance: operation.instance(), 340 role: operation.role(), 341 capability: operation.input().capability(), 342 operation_binding: operation.binding_digest(), 343 result, 344 }) 345 } 346 347 fn verify_response( 348 binding: &MycProviderBinding, 349 operation: &MycProviderOperation, 350 observed_at: MycProviderResponseObservedAtUnixMs, 351 parts: LocalSignerUntrustedParts, 352 ) -> Result<MycVerifiedProviderResponse, MycProviderVerificationError> { 353 if binding.kind() != MycProviderKind::LocalSigner 354 || operation.provider() != MycProviderKind::LocalSigner 355 || operation.role() != binding.role() 356 || operation.instance() != binding.instance() 357 || operation.expected_identity() != binding.expected_identity() 358 || !binding 359 .required_capabilities() 360 .contains(operation.input().capability()) 361 { 362 return Err(verification_error( 363 MycProviderVerificationErrorKind::InvalidBinding, 364 )); 365 } 366 if observed_at.get() > operation.deadline().get() { 367 return Err(verification_error( 368 MycProviderVerificationErrorKind::LateResponse, 369 )); 370 } 371 372 let expected_operation_id = hex::encode(operation.operation_id().as_bytes()); 373 let expected_correlation_id = hex::encode(operation.correlation_id().as_bytes()); 374 let response = parts.response; 375 if response.contract_version != MYC_LOCAL_SIGNER_TRANSPORT_CONTRACT_VERSION 376 || response.provider_instance != WireProviderInstance::from(operation.instance()) 377 || response.role != WireRole::from(operation.role()) 378 || response.operation_id != expected_operation_id 379 || response.correlation_id != expected_correlation_id 380 || parts.outer_correlation_id.as_ref() != expected_correlation_id 381 || response.absolute_deadline_unix_ms != operation.deadline().get() 382 || response.expected_identity != operation.expected_identity().as_hex() 383 || response.capability != WireCapability::from(operation.input().capability()) 384 { 385 return Err(verification_error( 386 MycProviderVerificationErrorKind::ResponseBinding, 387 )); 388 } 389 390 let result = verify_result(binding, operation, response.result)?; 391 Ok(MycVerifiedProviderResponse { 392 operation_id: operation.operation_id(), 393 correlation_id: operation.correlation_id(), 394 instance: operation.instance(), 395 role: operation.role(), 396 capability: operation.input().capability(), 397 operation_binding: operation.binding_digest(), 398 result, 399 }) 400 } 401 402 #[cfg(test)] 403 pub(crate) fn verify_protected_response_for_test( 404 binding: &MycProviderBinding, 405 operation: &MycProviderOperation, 406 payload: &[u8], 407 ) -> Result<MycVerifiedProviderResponse, MycProviderVerificationError> { 408 if operation.role() != binding.role() 409 || operation.instance() != binding.instance() 410 || operation.provider() != binding.kind() 411 || operation.expected_identity() != binding.expected_identity() 412 { 413 return Err(verification_error( 414 MycProviderVerificationErrorKind::InvalidBinding, 415 )); 416 } 417 if payload.len() > MYC_PROVIDER_OUTPUT_MAX_BYTES { 418 return Err(verification_error(MycProviderVerificationErrorKind::Size)); 419 } 420 let payload = Zeroizing::new(payload.to_vec()); 421 let result = match operation.input().capability() { 422 MycProviderCapability::Nip04Decrypt => verify_nip04_decrypt_result(operation, payload)?, 423 MycProviderCapability::Nip44Decrypt => verify_nip44_decrypt_result(operation, payload)?, 424 _ => return Err(result_shape()), 425 }; 426 Ok(MycVerifiedProviderResponse { 427 operation_id: operation.operation_id(), 428 correlation_id: operation.correlation_id(), 429 instance: operation.instance(), 430 role: operation.role(), 431 capability: operation.input().capability(), 432 operation_binding: operation.binding_digest(), 433 result, 434 }) 435 } 436 437 fn verify_result( 438 binding: &MycProviderBinding, 439 operation: &MycProviderOperation, 440 result: WireProviderResult, 441 ) -> Result<VerifiedProviderResult, MycProviderVerificationError> { 442 match (operation.input().capability(), result) { 443 ( 444 MycProviderCapability::Describe, 445 WireProviderResult::Describe { 446 public_identity, 447 protocol_version, 448 capabilities, 449 maximum_request_bytes, 450 }, 451 ) => verify_describe( 452 binding, 453 public_identity, 454 protocol_version, 455 capabilities, 456 maximum_request_bytes, 457 ), 458 ( 459 MycProviderCapability::PublicIdentity, 460 WireProviderResult::PublicIdentity { public_identity }, 461 ) => { 462 verify_identity(operation.expected_identity(), &public_identity)?; 463 Ok(VerifiedProviderResult::PublicIdentity( 464 operation.expected_identity().clone(), 465 )) 466 } 467 (MycProviderCapability::SignEvent, WireProviderResult::SignEvent { payload_hex }) => { 468 verify_signed_event(operation, decode_payload(payload_hex)?) 469 } 470 ( 471 MycProviderCapability::Nip04Encrypt, 472 WireProviderResult::Nip04Encrypt { peer, payload_hex }, 473 ) => { 474 verify_peer(operation, &peer)?; 475 let payload = decode_payload(payload_hex)?; 476 let expected_plaintext = operation.input().bytes().ok_or_else(result_shape)?; 477 verify_nip04_ciphertext(&payload, Some(expected_plaintext.len()))?; 478 Ok(VerifiedProviderResult::Protected { 479 payload, 480 nip44_version: None, 481 }) 482 } 483 ( 484 MycProviderCapability::Nip04Decrypt, 485 WireProviderResult::Nip04Decrypt { peer, payload_hex }, 486 ) => { 487 verify_peer(operation, &peer)?; 488 verify_nip04_decrypt_result(operation, decode_payload_allow_empty(payload_hex)?) 489 } 490 ( 491 MycProviderCapability::Nip44Encrypt, 492 WireProviderResult::Nip44Encrypt { 493 peer, 494 version, 495 payload_hex, 496 }, 497 ) => { 498 verify_peer(operation, &peer)?; 499 let requested_version = operation.input().nip44_version().ok_or_else(result_shape)?; 500 if version != requested_version.as_u8() { 501 return Err(verification_error(MycProviderVerificationErrorKind::Nip44)); 502 } 503 let plaintext = operation.input().bytes().ok_or_else(result_shape)?; 504 let payload = decode_payload(payload_hex)?; 505 verify_nip44_ciphertext(&payload, Some(plaintext.len()), requested_version)?; 506 Ok(VerifiedProviderResult::Protected { 507 payload, 508 nip44_version: Some(requested_version), 509 }) 510 } 511 ( 512 MycProviderCapability::Nip44Decrypt, 513 WireProviderResult::Nip44Decrypt { 514 peer, 515 version, 516 payload_hex, 517 }, 518 ) => { 519 verify_peer(operation, &peer)?; 520 let requested_version = operation.input().nip44_version().ok_or_else(result_shape)?; 521 if version != requested_version.as_u8() { 522 return Err(verification_error(MycProviderVerificationErrorKind::Nip44)); 523 } 524 verify_nip44_decrypt_result(operation, decode_payload(payload_hex)?) 525 } 526 _ => Err(result_shape()), 527 } 528 } 529 530 fn verify_nip04_decrypt_result( 531 operation: &MycProviderOperation, 532 payload: Zeroizing<Vec<u8>>, 533 ) -> Result<VerifiedProviderResult, MycProviderVerificationError> { 534 let input = operation.input().bytes().ok_or_else(result_shape)?; 535 let ciphertext_length = verify_nip04_ciphertext(input, None)?; 536 if payload.len() >= ciphertext_length { 537 return Err(verification_error(MycProviderVerificationErrorKind::Nip04)); 538 } 539 Ok(VerifiedProviderResult::Protected { 540 payload, 541 nip44_version: None, 542 }) 543 } 544 545 fn verify_nip44_decrypt_result( 546 operation: &MycProviderOperation, 547 payload: Zeroizing<Vec<u8>>, 548 ) -> Result<VerifiedProviderResult, MycProviderVerificationError> { 549 let requested_version = operation.input().nip44_version().ok_or_else(result_shape)?; 550 let input = operation.input().bytes().ok_or_else(result_shape)?; 551 let padded_length = verify_nip44_ciphertext(input, None, requested_version)?; 552 if payload.len() > padded_length || payload.len() > MYC_PROVIDER_NIP44_PLAINTEXT_MAX_BYTES { 553 return Err(verification_error(MycProviderVerificationErrorKind::Nip44)); 554 } 555 Ok(VerifiedProviderResult::Protected { 556 payload, 557 nip44_version: Some(requested_version), 558 }) 559 } 560 561 fn verify_describe( 562 binding: &MycProviderBinding, 563 public_identity: String, 564 protocol_version: u32, 565 capabilities: Vec<WireCapability>, 566 maximum_request_bytes: u64, 567 ) -> Result<VerifiedProviderResult, MycProviderVerificationError> { 568 verify_identity(binding.expected_identity(), &public_identity)?; 569 if protocol_version != MYC_LOCAL_SIGNER_TRANSPORT_CONTRACT_VERSION { 570 return Err(verification_error( 571 MycProviderVerificationErrorKind::ResponseBinding, 572 )); 573 } 574 if capabilities.is_empty() || capabilities.len() > 7 { 575 return Err(verification_error( 576 MycProviderVerificationErrorKind::Capability, 577 )); 578 } 579 let capabilities: Vec<MycProviderCapability> = capabilities 580 .into_iter() 581 .map(MycProviderCapability::from) 582 .collect(); 583 let capabilities = MycProviderCapabilitySet::new(&capabilities) 584 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Capability))?; 585 if binding 586 .required_capabilities() 587 .iter() 588 .any(|capability| !capabilities.contains(capability)) 589 { 590 return Err(verification_error( 591 MycProviderVerificationErrorKind::Capability, 592 )); 593 } 594 let expected_maximum = match binding.kind() { 595 MycProviderKind::EncryptedFile => MYC_PROVIDER_INPUT_MAX_BYTES as u64, 596 MycProviderKind::LocalSigner => binding 597 .local_signer_limits() 598 .ok_or_else(|| verification_error(MycProviderVerificationErrorKind::InvalidBinding))? 599 .request_max_bytes(), 600 }; 601 if maximum_request_bytes != expected_maximum { 602 return Err(verification_error(MycProviderVerificationErrorKind::Size)); 603 } 604 Ok(VerifiedProviderResult::Describe { 605 public_identity: binding.expected_identity().clone(), 606 protocol_version, 607 capabilities, 608 maximum_request_bytes, 609 }) 610 } 611 612 fn verify_identity( 613 expected: &MycProviderPublicIdentity, 614 actual: &str, 615 ) -> Result<(), MycProviderVerificationError> { 616 if actual != expected.as_hex() { 617 return Err(verification_error( 618 MycProviderVerificationErrorKind::Identity, 619 )); 620 } 621 Ok(()) 622 } 623 624 fn verify_peer( 625 operation: &MycProviderOperation, 626 actual: &str, 627 ) -> Result<(), MycProviderVerificationError> { 628 if operation 629 .input() 630 .peer() 631 .map(MycProviderPublicIdentity::as_hex) 632 != Some(actual) 633 { 634 return Err(verification_error( 635 MycProviderVerificationErrorKind::ResponseBinding, 636 )); 637 } 638 Ok(()) 639 } 640 641 fn decode_payload( 642 payload: ProtectedWireHex, 643 ) -> Result<Zeroizing<Vec<u8>>, MycProviderVerificationError> { 644 let payload = payload 645 .into_bytes() 646 .map_err(|_| verification_error(MycProviderVerificationErrorKind::ResultShape))?; 647 if payload.is_empty() || payload.len() > MYC_PROVIDER_OUTPUT_MAX_BYTES { 648 return Err(verification_error(MycProviderVerificationErrorKind::Size)); 649 } 650 Ok(payload) 651 } 652 653 fn decode_payload_allow_empty( 654 payload: ProtectedWireHex, 655 ) -> Result<Zeroizing<Vec<u8>>, MycProviderVerificationError> { 656 let payload = payload 657 .into_bytes() 658 .map_err(|_| verification_error(MycProviderVerificationErrorKind::ResultShape))?; 659 if payload.len() > MYC_PROVIDER_OUTPUT_MAX_BYTES { 660 return Err(verification_error(MycProviderVerificationErrorKind::Size)); 661 } 662 Ok(payload) 663 } 664 665 fn verify_signed_event( 666 operation: &MycProviderOperation, 667 payload: Zeroizing<Vec<u8>>, 668 ) -> Result<VerifiedProviderResult, MycProviderVerificationError> { 669 let unsigned_bytes = operation.input().bytes().ok_or_else(result_shape)?; 670 let mut unsigned: UnsignedEvent = serde_json::from_slice(unsigned_bytes) 671 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Event))?; 672 let canonical_unsigned = serde_json::to_vec(&unsigned) 673 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Event))?; 674 if canonical_unsigned != unsigned_bytes 675 || unsigned.verify_id().is_err() 676 || unsigned.pubkey.to_hex() != operation.expected_identity().as_hex() 677 { 678 return Err(verification_error(MycProviderVerificationErrorKind::Event)); 679 } 680 let expected_id = unsigned.id(); 681 let event: Event = serde_json::from_slice(&payload) 682 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Event))?; 683 let canonical_event = serde_json::to_vec(&event) 684 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Event))?; 685 if canonical_event.as_slice() != payload.as_slice() 686 || event.pubkey != unsigned.pubkey 687 || event.created_at != unsigned.created_at 688 || event.kind != unsigned.kind 689 || event.tags != unsigned.tags 690 || event.content != unsigned.content 691 || event.id != expected_id 692 || event.verify().is_err() 693 { 694 return Err(verification_error(MycProviderVerificationErrorKind::Event)); 695 } 696 Ok(VerifiedProviderResult::SignedEvent(payload)) 697 } 698 699 fn verify_nip04_ciphertext( 700 payload: &[u8], 701 plaintext_length: Option<usize>, 702 ) -> Result<usize, MycProviderVerificationError> { 703 let rendered = core::str::from_utf8(payload) 704 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Nip04))?; 705 let (ciphertext, iv) = rendered 706 .split_once("?iv=") 707 .ok_or_else(|| verification_error(MycProviderVerificationErrorKind::Nip04))?; 708 if ciphertext.is_empty() || iv.is_empty() || iv.contains("?iv=") { 709 return Err(verification_error(MycProviderVerificationErrorKind::Nip04)); 710 } 711 let ciphertext = decode_canonical_base64(ciphertext, MycProviderVerificationErrorKind::Nip04)?; 712 let iv = decode_canonical_base64(iv, MycProviderVerificationErrorKind::Nip04)?; 713 if iv.len() != 16 || ciphertext.is_empty() || !ciphertext.len().is_multiple_of(16) { 714 return Err(verification_error(MycProviderVerificationErrorKind::Nip04)); 715 } 716 if let Some(length) = plaintext_length { 717 let expected = length 718 .checked_div(16) 719 .and_then(|blocks| blocks.checked_add(1)) 720 .and_then(|blocks| blocks.checked_mul(16)) 721 .ok_or_else(|| verification_error(MycProviderVerificationErrorKind::Size))?; 722 if ciphertext.len() != expected { 723 return Err(verification_error(MycProviderVerificationErrorKind::Nip04)); 724 } 725 } 726 Ok(ciphertext.len()) 727 } 728 729 fn verify_nip44_ciphertext( 730 payload: &[u8], 731 plaintext_length: Option<usize>, 732 version: MycProviderNip44Version, 733 ) -> Result<usize, MycProviderVerificationError> { 734 let rendered = core::str::from_utf8(payload) 735 .map_err(|_| verification_error(MycProviderVerificationErrorKind::Nip44))?; 736 let decoded = decode_canonical_base64(rendered, MycProviderVerificationErrorKind::Nip44)?; 737 if version.as_u8() != NIP44_V2_VERSION 738 || decoded.first().copied() != Some(version.as_u8()) 739 || decoded.len() < NIP44_V2_FIXED_PAYLOAD_BYTES + 32 740 { 741 return Err(verification_error(MycProviderVerificationErrorKind::Nip44)); 742 } 743 let padded = decoded 744 .len() 745 .checked_sub(NIP44_V2_FIXED_PAYLOAD_BYTES) 746 .ok_or_else(|| verification_error(MycProviderVerificationErrorKind::Nip44))?; 747 if let Some(length) = plaintext_length { 748 let expected = nip44_padding_length(length) 749 .and_then(|value| NIP44_V2_FIXED_PAYLOAD_BYTES.checked_add(value)) 750 .ok_or_else(|| verification_error(MycProviderVerificationErrorKind::Nip44))?; 751 if decoded.len() != expected { 752 return Err(verification_error(MycProviderVerificationErrorKind::Nip44)); 753 } 754 } else if !is_valid_nip44_padding_length(padded) { 755 return Err(verification_error(MycProviderVerificationErrorKind::Nip44)); 756 } 757 Ok(padded) 758 } 759 760 fn decode_canonical_base64( 761 value: &str, 762 kind: MycProviderVerificationErrorKind, 763 ) -> Result<Vec<u8>, MycProviderVerificationError> { 764 let decoded = BASE64_STANDARD 765 .decode(value) 766 .map_err(|_| verification_error(kind))?; 767 if BASE64_STANDARD.encode(&decoded) != value { 768 return Err(verification_error(kind)); 769 } 770 Ok(decoded) 771 } 772 773 fn nip44_padding_length(length: usize) -> Option<usize> { 774 if length == 0 || length > MYC_PROVIDER_NIP44_PLAINTEXT_MAX_BYTES { 775 return None; 776 } 777 if length <= 32 { 778 return Some(32); 779 } 780 let next_power = length.checked_next_power_of_two()?; 781 let chunk = if next_power <= 256 { 782 32 783 } else { 784 next_power.checked_div(8)? 785 }; 786 chunk.checked_mul(length.checked_sub(1)?.checked_div(chunk)?.checked_add(1)?) 787 } 788 789 fn is_valid_nip44_padding_length(padded: usize) -> bool { 790 if !(32..=65_536).contains(&padded) { 791 return false; 792 } 793 if padded <= 256 { 794 return padded.is_multiple_of(32); 795 } 796 let Some(next_power) = padded.checked_next_power_of_two() else { 797 return false; 798 }; 799 let chunk = next_power / 8; 800 padded.is_multiple_of(chunk) 801 } 802 803 const fn result_shape() -> MycProviderVerificationError { 804 verification_error(MycProviderVerificationErrorKind::ResultShape) 805 } 806 807 impl From<WireCapability> for MycProviderCapability { 808 fn from(capability: WireCapability) -> Self { 809 match capability { 810 WireCapability::Describe => Self::Describe, 811 WireCapability::PublicIdentity => Self::PublicIdentity, 812 WireCapability::SignEvent => Self::SignEvent, 813 WireCapability::Nip04Encrypt => Self::Nip04Encrypt, 814 WireCapability::Nip04Decrypt => Self::Nip04Decrypt, 815 WireCapability::Nip44Encrypt => Self::Nip44Encrypt, 816 WireCapability::Nip44Decrypt => Self::Nip44Decrypt, 817 } 818 } 819 } 820 821 #[cfg(test)] 822 mod tests { 823 use std::path::Path; 824 825 use nostr::nips::{nip04, nip44}; 826 use nostr::{Keys, Kind, SecretKey, Tag, Timestamp}; 827 828 use crate::provider_local_signer::{LocalSignerResponse, MycLocalSignerUntrustedResponse}; 829 use crate::{ 830 MycConfigProfile, MycProviderCorrelationId, MycProviderDeadlineUnixMs, 831 MycProviderOperationId, MycProviderOperationInput, parse_myc_config_v1, 832 }; 833 834 use super::*; 835 836 const CONFIG: &str = include_str!("../contracts/services_hardening/config.v1.example.toml"); 837 838 fn keys(seed: u8) -> Keys { 839 Keys::new(SecretKey::from_slice(&[seed; 32]).expect("test secret")) 840 } 841 842 fn binding(identity: &Keys) -> MycProviderBinding { 843 let source = CONFIG 844 .replace( 845 "/run/radroots/services/myc/primary/user-signer.sock", 846 Path::new("/run/test-verifier.sock") 847 .to_str() 848 .expect("test socket"), 849 ) 850 .replace( 851 "2222222222222222222222222222222222222222222222222222222222222222", 852 &identity.public_key().to_hex(), 853 ); 854 parse_myc_config_v1(source.as_bytes(), MycConfigProfile::RepoLocal) 855 .expect("test config") 856 .provider_contract() 857 .binding(MycProviderRole::User) 858 .expect("user binding") 859 .clone() 860 } 861 862 fn encrypted_transport_binding() -> MycProviderBinding { 863 parse_myc_config_v1(CONFIG.as_bytes(), MycConfigProfile::RepoLocal) 864 .expect("test config") 865 .provider_contract() 866 .binding(MycProviderRole::Transport) 867 .expect("transport binding") 868 .clone() 869 } 870 871 fn make_operation( 872 binding: &MycProviderBinding, 873 seed: u8, 874 input: MycProviderOperationInput, 875 ) -> MycProviderOperation { 876 MycProviderOperation::new( 877 binding, 878 MycProviderOperationId::from_bytes([seed; 32]), 879 MycProviderCorrelationId::from_bytes([seed.wrapping_add(1); 32]), 880 MycProviderDeadlineUnixMs::new(2_000_000_000_000).expect("deadline"), 881 input, 882 ) 883 .expect("operation") 884 } 885 886 fn parts( 887 operation: &MycProviderOperation, 888 result: WireProviderResult, 889 ) -> LocalSignerUntrustedParts { 890 let operation_id = hex::encode(operation.operation_id().as_bytes()); 891 let correlation_id = hex::encode(operation.correlation_id().as_bytes()); 892 LocalSignerUntrustedParts { 893 outer_correlation_id: correlation_id.clone().into(), 894 response: LocalSignerResponse { 895 contract_version: MYC_LOCAL_SIGNER_TRANSPORT_CONTRACT_VERSION, 896 provider_instance: operation.instance().into(), 897 role: operation.role().into(), 898 operation_id, 899 correlation_id, 900 absolute_deadline_unix_ms: operation.deadline().get(), 901 expected_identity: operation.expected_identity().as_hex().to_owned(), 902 capability: operation.input().capability().into(), 903 result, 904 }, 905 } 906 } 907 908 fn observed() -> MycProviderResponseObservedAtUnixMs { 909 MycProviderResponseObservedAtUnixMs::new(1_999_999_999_999).expect("observed") 910 } 911 912 fn public_identity_result(operation: &MycProviderOperation) -> WireProviderResult { 913 WireProviderResult::PublicIdentity { 914 public_identity: operation.expected_identity().as_hex().to_owned(), 915 } 916 } 917 918 fn verify( 919 binding: &MycProviderBinding, 920 operation: &MycProviderOperation, 921 result: WireProviderResult, 922 ) -> Result<MycVerifiedProviderResponse, MycProviderVerificationError> { 923 MycLocalSignerUntrustedResponse::from_parts(parts(operation, result)).verify( 924 binding, 925 operation, 926 observed(), 927 ) 928 } 929 930 fn assert_binding_rejected( 931 binding: &MycProviderBinding, 932 operation: &MycProviderOperation, 933 mutate: impl FnOnce(&mut LocalSignerUntrustedParts), 934 ) { 935 let mut untrusted = parts(operation, public_identity_result(operation)); 936 mutate(&mut untrusted); 937 let error = MycLocalSignerUntrustedResponse::from_parts(untrusted) 938 .verify(binding, operation, observed()) 939 .expect_err("binding mismatch"); 940 assert_eq!( 941 error.kind(), 942 MycProviderVerificationErrorKind::ResponseBinding 943 ); 944 } 945 946 #[test] 947 fn observed_time_and_errors_are_bounded_source_free_and_redacted() { 948 assert!(MycProviderResponseObservedAtUnixMs::new(0).is_err()); 949 assert!(MycProviderResponseObservedAtUnixMs::new(i64::MAX as u64).is_ok()); 950 assert!(MycProviderResponseObservedAtUnixMs::new(i64::MAX as u64 + 1).is_err()); 951 for kind in [ 952 MycProviderVerificationErrorKind::InvalidObservationTime, 953 MycProviderVerificationErrorKind::InvalidBinding, 954 MycProviderVerificationErrorKind::LateResponse, 955 MycProviderVerificationErrorKind::ResponseBinding, 956 MycProviderVerificationErrorKind::ResultShape, 957 MycProviderVerificationErrorKind::Identity, 958 MycProviderVerificationErrorKind::Capability, 959 MycProviderVerificationErrorKind::Size, 960 MycProviderVerificationErrorKind::Event, 961 MycProviderVerificationErrorKind::Nip04, 962 MycProviderVerificationErrorKind::Nip44, 963 ] { 964 let error = verification_error(kind); 965 assert_eq!(error.kind(), kind); 966 assert!(!error.code().is_empty()); 967 assert!(!error.to_string().is_empty()); 968 assert!(error.source().is_none()); 969 } 970 } 971 972 #[test] 973 fn every_outer_and_inner_binding_must_match_the_original_operation() { 974 let identity = keys(1); 975 let binding = binding(&identity); 976 let operation = make_operation(&binding, 3, MycProviderOperationInput::public_identity()); 977 let verified = verify(&binding, &operation, public_identity_result(&operation)) 978 .expect("verified identity"); 979 assert_eq!(verified.operation_id(), operation.operation_id()); 980 assert_eq!(verified.correlation_id(), operation.correlation_id()); 981 assert_eq!(verified.role(), MycProviderRole::User); 982 assert_eq!(verified.instance(), MycProviderInstanceId::User); 983 assert_eq!( 984 verified.public_identity(), 985 Some(operation.expected_identity()) 986 ); 987 988 let error = MycLocalSignerUntrustedResponse::from_parts(parts( 989 &operation, 990 public_identity_result(&operation), 991 )) 992 .verify(&encrypted_transport_binding(), &operation, observed()) 993 .expect_err("wrong configured binding"); 994 assert_eq!( 995 error.kind(), 996 MycProviderVerificationErrorKind::InvalidBinding 997 ); 998 999 assert_binding_rejected(&binding, &operation, |parts| { 1000 parts.outer_correlation_id = "00".into(); 1001 }); 1002 assert_binding_rejected(&binding, &operation, |parts| { 1003 parts.response.contract_version = 2; 1004 }); 1005 assert_binding_rejected(&binding, &operation, |parts| { 1006 parts.response.operation_id = "00".into(); 1007 }); 1008 assert_binding_rejected(&binding, &operation, |parts| { 1009 parts.response.correlation_id = "00".into(); 1010 }); 1011 assert_binding_rejected(&binding, &operation, |parts| { 1012 parts.response.absolute_deadline_unix_ms -= 1; 1013 }); 1014 assert_binding_rejected(&binding, &operation, |parts| { 1015 parts.response.expected_identity = keys(2).public_key().to_hex(); 1016 }); 1017 assert_binding_rejected(&binding, &operation, |parts| { 1018 parts.response.capability = WireCapability::Describe; 1019 }); 1020 assert_binding_rejected(&binding, &operation, |parts| { 1021 parts.response.role = WireRole::Transport; 1022 }); 1023 assert_binding_rejected(&binding, &operation, |parts| { 1024 parts.response.provider_instance = WireProviderInstance::Transport; 1025 }); 1026 1027 let late = MycProviderResponseObservedAtUnixMs::new(operation.deadline().get() + 1) 1028 .expect("late observation"); 1029 let error = MycLocalSignerUntrustedResponse::from_parts(parts( 1030 &operation, 1031 public_identity_result(&operation), 1032 )) 1033 .verify(&binding, &operation, late) 1034 .expect_err("late result"); 1035 assert_eq!(error.kind(), MycProviderVerificationErrorKind::LateResponse); 1036 1037 let exact = MycProviderResponseObservedAtUnixMs::new(operation.deadline().get()) 1038 .expect("exact deadline"); 1039 MycLocalSignerUntrustedResponse::from_parts(parts( 1040 &operation, 1041 public_identity_result(&operation), 1042 )) 1043 .verify(&binding, &operation, exact) 1044 .expect("exact deadline admitted"); 1045 } 1046 1047 #[test] 1048 fn describe_requires_exact_identity_protocol_capabilities_and_size() { 1049 let identity = keys(1); 1050 let binding = binding(&identity); 1051 let operation = make_operation(&binding, 4, MycProviderOperationInput::describe()); 1052 let all = [ 1053 WireCapability::Describe, 1054 WireCapability::PublicIdentity, 1055 WireCapability::SignEvent, 1056 WireCapability::Nip04Encrypt, 1057 WireCapability::Nip04Decrypt, 1058 WireCapability::Nip44Encrypt, 1059 WireCapability::Nip44Decrypt, 1060 ]; 1061 let result = || WireProviderResult::Describe { 1062 public_identity: operation.expected_identity().as_hex().to_owned(), 1063 protocol_version: 1, 1064 capabilities: all.to_vec(), 1065 maximum_request_bytes: binding 1066 .local_signer_limits() 1067 .expect("limits") 1068 .request_max_bytes(), 1069 }; 1070 let verified = verify(&binding, &operation, result()).expect("describe"); 1071 assert_eq!(verified.protocol_version(), Some(1)); 1072 assert_eq!(verified.capabilities().expect("capabilities").len(), 7); 1073 assert_eq!(verified.maximum_request_bytes(), Some(65_536)); 1074 1075 let duplicate = WireProviderResult::Describe { 1076 public_identity: operation.expected_identity().as_hex().to_owned(), 1077 protocol_version: 1, 1078 capabilities: vec![WireCapability::Describe, WireCapability::Describe], 1079 maximum_request_bytes: 65_536, 1080 }; 1081 assert_eq!( 1082 verify(&binding, &operation, duplicate).unwrap_err().kind(), 1083 MycProviderVerificationErrorKind::Capability 1084 ); 1085 let missing = WireProviderResult::Describe { 1086 public_identity: operation.expected_identity().as_hex().to_owned(), 1087 protocol_version: 1, 1088 capabilities: vec![WireCapability::Describe, WireCapability::PublicIdentity], 1089 maximum_request_bytes: 65_536, 1090 }; 1091 assert_eq!( 1092 verify(&binding, &operation, missing).unwrap_err().kind(), 1093 MycProviderVerificationErrorKind::Capability 1094 ); 1095 let wrong_size = WireProviderResult::Describe { 1096 public_identity: operation.expected_identity().as_hex().to_owned(), 1097 protocol_version: 1, 1098 capabilities: all.to_vec(), 1099 maximum_request_bytes: 65_535, 1100 }; 1101 assert_eq!( 1102 verify(&binding, &operation, wrong_size).unwrap_err().kind(), 1103 MycProviderVerificationErrorKind::Size 1104 ); 1105 let wrong_protocol = WireProviderResult::Describe { 1106 public_identity: operation.expected_identity().as_hex().to_owned(), 1107 protocol_version: 2, 1108 capabilities: all.to_vec(), 1109 maximum_request_bytes: 65_536, 1110 }; 1111 assert_eq!( 1112 verify(&binding, &operation, wrong_protocol) 1113 .unwrap_err() 1114 .kind(), 1115 MycProviderVerificationErrorKind::ResponseBinding 1116 ); 1117 let wrong_identity = WireProviderResult::Describe { 1118 public_identity: keys(2).public_key().to_hex(), 1119 protocol_version: 1, 1120 capabilities: all.to_vec(), 1121 maximum_request_bytes: 65_536, 1122 }; 1123 assert_eq!( 1124 verify(&binding, &operation, wrong_identity) 1125 .unwrap_err() 1126 .kind(), 1127 MycProviderVerificationErrorKind::Identity 1128 ); 1129 } 1130 1131 #[test] 1132 fn signed_event_must_match_every_canonical_unsigned_field_and_signature() { 1133 let identity = keys(1); 1134 let binding = binding(&identity); 1135 let unsigned = UnsignedEvent::new( 1136 identity.public_key(), 1137 Timestamp::from_secs(1_700_000_000), 1138 Kind::TextNote, 1139 Vec::<Tag>::new(), 1140 "signed content", 1141 ); 1142 let unsigned_bytes = serde_json::to_vec(&unsigned).expect("unsigned JSON"); 1143 let operation = make_operation( 1144 &binding, 1145 5, 1146 MycProviderOperationInput::sign_event(&unsigned_bytes).expect("sign input"), 1147 ); 1148 let event = unsigned 1149 .clone() 1150 .sign_with_keys(&identity) 1151 .expect("signed event"); 1152 let event_bytes = serde_json::to_vec(&event).expect("event JSON"); 1153 let verified = verify( 1154 &binding, 1155 &operation, 1156 WireProviderResult::SignEvent { 1157 payload_hex: ProtectedWireHex::from_bytes(&event_bytes), 1158 }, 1159 ) 1160 .expect("verified event"); 1161 assert_eq!(verified.signed_event_bytes(), Some(event_bytes.as_slice())); 1162 assert!(!format!("{verified:?}").contains("signed content")); 1163 1164 let altered = UnsignedEvent::new( 1165 identity.public_key(), 1166 Timestamp::from_secs(1_700_000_000), 1167 Kind::TextNote, 1168 Vec::<Tag>::new(), 1169 "altered content", 1170 ) 1171 .sign_with_keys(&identity) 1172 .expect("altered event"); 1173 let error = verify( 1174 &binding, 1175 &operation, 1176 WireProviderResult::SignEvent { 1177 payload_hex: ProtectedWireHex::from_bytes( 1178 &serde_json::to_vec(&altered).expect("altered JSON"), 1179 ), 1180 }, 1181 ) 1182 .expect_err("altered fields"); 1183 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Event); 1184 1185 let other_identity = keys(2); 1186 let wrong_author = UnsignedEvent::new( 1187 other_identity.public_key(), 1188 Timestamp::from_secs(1_700_000_000), 1189 Kind::TextNote, 1190 Vec::<Tag>::new(), 1191 "signed content", 1192 ) 1193 .sign_with_keys(&other_identity) 1194 .expect("wrong-author event"); 1195 let error = verify( 1196 &binding, 1197 &operation, 1198 WireProviderResult::SignEvent { 1199 payload_hex: ProtectedWireHex::from_bytes( 1200 &serde_json::to_vec(&wrong_author).expect("wrong-author JSON"), 1201 ), 1202 }, 1203 ) 1204 .expect_err("wrong author"); 1205 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Event); 1206 1207 let mut wrong_id = event.clone(); 1208 wrong_id.id = nostr::EventId::all_zeros(); 1209 let error = verify( 1210 &binding, 1211 &operation, 1212 WireProviderResult::SignEvent { 1213 payload_hex: ProtectedWireHex::from_bytes( 1214 &serde_json::to_vec(&wrong_id).expect("wrong-id JSON"), 1215 ), 1216 }, 1217 ) 1218 .expect_err("wrong event ID"); 1219 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Event); 1220 1221 let mut wrong_signature = event.clone(); 1222 wrong_signature.sig = altered.sig; 1223 let error = verify( 1224 &binding, 1225 &operation, 1226 WireProviderResult::SignEvent { 1227 payload_hex: ProtectedWireHex::from_bytes( 1228 &serde_json::to_vec(&wrong_signature).expect("wrong-signature JSON"), 1229 ), 1230 }, 1231 ) 1232 .expect_err("wrong signature"); 1233 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Event); 1234 1235 let noncanonical_input = format!(" {}", String::from_utf8(unsigned_bytes).unwrap()); 1236 let noncanonical_operation = make_operation( 1237 &binding, 1238 6, 1239 MycProviderOperationInput::sign_event(noncanonical_input.as_bytes()) 1240 .expect("bounded input"), 1241 ); 1242 let error = verify( 1243 &binding, 1244 &noncanonical_operation, 1245 WireProviderResult::SignEvent { 1246 payload_hex: ProtectedWireHex::from_bytes(&event_bytes), 1247 }, 1248 ) 1249 .expect_err("noncanonical unsigned event"); 1250 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Event); 1251 } 1252 1253 #[test] 1254 fn nip04_direction_peer_shape_and_padding_are_independently_bound() { 1255 let identity = keys(1); 1256 let peer = keys(2); 1257 let binding = binding(&identity); 1258 let peer_identity = 1259 MycProviderPublicIdentity::new(&peer.public_key().to_hex()).expect("peer"); 1260 let plaintext = b"nip04 plaintext"; 1261 let ciphertext = nip04::encrypt( 1262 identity.secret_key(), 1263 &peer.public_key(), 1264 plaintext.as_slice(), 1265 ) 1266 .expect("nip04 ciphertext"); 1267 let encrypt = make_operation( 1268 &binding, 1269 7, 1270 MycProviderOperationInput::nip04_encrypt(peer_identity.clone(), plaintext) 1271 .expect("encrypt input"), 1272 ); 1273 let verified = verify( 1274 &binding, 1275 &encrypt, 1276 WireProviderResult::Nip04Encrypt { 1277 peer: peer.public_key().to_hex(), 1278 payload_hex: ProtectedWireHex::from_bytes(ciphertext.as_bytes()), 1279 }, 1280 ) 1281 .expect("nip04 encrypt"); 1282 assert_eq!(verified.protected_payload(), Some(ciphertext.as_bytes())); 1283 1284 let error = verify( 1285 &binding, 1286 &encrypt, 1287 WireProviderResult::Nip04Encrypt { 1288 peer: keys(3).public_key().to_hex(), 1289 payload_hex: ProtectedWireHex::from_bytes(ciphertext.as_bytes()), 1290 }, 1291 ) 1292 .expect_err("wrong peer"); 1293 assert_eq!( 1294 error.kind(), 1295 MycProviderVerificationErrorKind::ResponseBinding 1296 ); 1297 let error = verify( 1298 &binding, 1299 &encrypt, 1300 WireProviderResult::Nip04Encrypt { 1301 peer: peer.public_key().to_hex(), 1302 payload_hex: ProtectedWireHex::from_bytes(b"not-ciphertext"), 1303 }, 1304 ) 1305 .expect_err("malformed ciphertext"); 1306 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Nip04); 1307 1308 let decrypt = make_operation( 1309 &binding, 1310 8, 1311 MycProviderOperationInput::nip04_decrypt(peer_identity, ciphertext.as_bytes()) 1312 .expect("decrypt input"), 1313 ); 1314 let verified = verify( 1315 &binding, 1316 &decrypt, 1317 WireProviderResult::Nip04Decrypt { 1318 peer: peer.public_key().to_hex(), 1319 payload_hex: ProtectedWireHex::from_bytes(plaintext), 1320 }, 1321 ) 1322 .expect("nip04 decrypt"); 1323 assert_eq!(verified.protected_payload(), Some(plaintext.as_slice())); 1324 1325 let error = verify( 1326 &binding, 1327 &decrypt, 1328 WireProviderResult::Nip04Decrypt { 1329 peer: peer.public_key().to_hex(), 1330 payload_hex: ProtectedWireHex::from_bytes(&[0; 32]), 1331 }, 1332 ) 1333 .expect_err("plaintext cannot fill the complete ciphertext block capacity"); 1334 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Nip04); 1335 } 1336 1337 #[test] 1338 fn nip44_direction_peer_version_shape_and_padding_are_independently_bound() { 1339 let identity = keys(1); 1340 let peer = keys(2); 1341 let binding = binding(&identity); 1342 let peer_identity = 1343 MycProviderPublicIdentity::new(&peer.public_key().to_hex()).expect("peer"); 1344 let plaintext = b"nip44 plaintext"; 1345 assert!( 1346 MycProviderOperationInput::nip44_encrypt( 1347 peer_identity.clone(), 1348 MycProviderNip44Version::V2, 1349 b"" 1350 ) 1351 .is_err() 1352 ); 1353 let ciphertext = nip44::encrypt( 1354 identity.secret_key(), 1355 &peer.public_key(), 1356 plaintext.as_slice(), 1357 nip44::Version::V2, 1358 ) 1359 .expect("nip44 ciphertext"); 1360 let encrypt = make_operation( 1361 &binding, 1362 9, 1363 MycProviderOperationInput::nip44_encrypt( 1364 peer_identity.clone(), 1365 MycProviderNip44Version::V2, 1366 plaintext, 1367 ) 1368 .expect("encrypt input"), 1369 ); 1370 let verified = verify( 1371 &binding, 1372 &encrypt, 1373 WireProviderResult::Nip44Encrypt { 1374 peer: peer.public_key().to_hex(), 1375 version: 2, 1376 payload_hex: ProtectedWireHex::from_bytes(ciphertext.as_bytes()), 1377 }, 1378 ) 1379 .expect("nip44 encrypt"); 1380 assert_eq!(verified.nip44_version(), Some(MycProviderNip44Version::V2)); 1381 1382 let error = verify( 1383 &binding, 1384 &encrypt, 1385 WireProviderResult::Nip44Encrypt { 1386 peer: peer.public_key().to_hex(), 1387 version: 3, 1388 payload_hex: ProtectedWireHex::from_bytes(ciphertext.as_bytes()), 1389 }, 1390 ) 1391 .expect_err("wrong version"); 1392 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Nip44); 1393 1394 let error = verify( 1395 &binding, 1396 &encrypt, 1397 WireProviderResult::Nip44Encrypt { 1398 peer: keys(3).public_key().to_hex(), 1399 version: 2, 1400 payload_hex: ProtectedWireHex::from_bytes(ciphertext.as_bytes()), 1401 }, 1402 ) 1403 .expect_err("wrong peer"); 1404 assert_eq!( 1405 error.kind(), 1406 MycProviderVerificationErrorKind::ResponseBinding 1407 ); 1408 let error = verify( 1409 &binding, 1410 &encrypt, 1411 WireProviderResult::Nip44Encrypt { 1412 peer: peer.public_key().to_hex(), 1413 version: 2, 1414 payload_hex: ProtectedWireHex::from_bytes(b"not-base64"), 1415 }, 1416 ) 1417 .expect_err("malformed ciphertext"); 1418 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Nip44); 1419 1420 let decrypt = make_operation( 1421 &binding, 1422 10, 1423 MycProviderOperationInput::nip44_decrypt( 1424 peer_identity, 1425 MycProviderNip44Version::V2, 1426 ciphertext.as_bytes(), 1427 ) 1428 .expect("decrypt input"), 1429 ); 1430 let verified = verify( 1431 &binding, 1432 &decrypt, 1433 WireProviderResult::Nip44Decrypt { 1434 peer: peer.public_key().to_hex(), 1435 version: 2, 1436 payload_hex: ProtectedWireHex::from_bytes(plaintext), 1437 }, 1438 ) 1439 .expect("nip44 decrypt"); 1440 assert_eq!(verified.protected_payload(), Some(plaintext.as_slice())); 1441 1442 let error = verify( 1443 &binding, 1444 &decrypt, 1445 WireProviderResult::Nip44Decrypt { 1446 peer: peer.public_key().to_hex(), 1447 version: 2, 1448 payload_hex: ProtectedWireHex::from_bytes(&[0; 33]), 1449 }, 1450 ) 1451 .expect_err("plaintext cannot exceed the ciphertext padding capacity"); 1452 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Nip44); 1453 } 1454 1455 #[test] 1456 fn wrong_result_shape_and_semantic_output_overflow_fail_before_exposure() { 1457 let identity = keys(1); 1458 let binding = binding(&identity); 1459 let operation = make_operation(&binding, 11, MycProviderOperationInput::public_identity()); 1460 let error = verify( 1461 &binding, 1462 &operation, 1463 WireProviderResult::SignEvent { 1464 payload_hex: ProtectedWireHex::from_bytes(b"event"), 1465 }, 1466 ) 1467 .expect_err("wrong shape"); 1468 assert_eq!(error.kind(), MycProviderVerificationErrorKind::ResultShape); 1469 1470 let peer = keys(2); 1471 let peer_identity = 1472 MycProviderPublicIdentity::new(&peer.public_key().to_hex()).expect("peer"); 1473 let decrypt = make_operation( 1474 &binding, 1475 12, 1476 MycProviderOperationInput::nip04_decrypt( 1477 peer_identity, 1478 nip04::encrypt(identity.secret_key(), &peer.public_key(), "input") 1479 .expect("ciphertext") 1480 .as_bytes(), 1481 ) 1482 .expect("decrypt input"), 1483 ); 1484 let oversized = vec![7_u8; MYC_PROVIDER_OUTPUT_MAX_BYTES + 1]; 1485 let error = verify( 1486 &binding, 1487 &decrypt, 1488 WireProviderResult::Nip04Decrypt { 1489 peer: peer.public_key().to_hex(), 1490 payload_hex: ProtectedWireHex::from_bytes(&oversized), 1491 }, 1492 ) 1493 .expect_err("oversized output"); 1494 assert_eq!(error.kind(), MycProviderVerificationErrorKind::Size); 1495 } 1496 1497 #[test] 1498 fn nip44_padding_model_matches_all_exact_protocol_boundaries() { 1499 for (length, padded) in [ 1500 (1, 32), 1501 (32, 32), 1502 (33, 64), 1503 (256, 256), 1504 (257, 320), 1505 (MYC_PROVIDER_NIP44_PLAINTEXT_MAX_BYTES, 65_536), 1506 ] { 1507 assert_eq!(nip44_padding_length(length), Some(padded)); 1508 assert!(is_valid_nip44_padding_length(padded)); 1509 } 1510 assert_eq!(nip44_padding_length(0), None); 1511 assert_eq!( 1512 nip44_padding_length(MYC_PROVIDER_NIP44_PLAINTEXT_MAX_BYTES + 1), 1513 None 1514 ); 1515 for invalid in [0, 31, 33, 288, 65_537] { 1516 assert!(!is_valid_nip44_padding_length(invalid)); 1517 } 1518 } 1519 }