myc

Self-custodial remote signer for Radroots apps
git clone https://radroots.dev/git/myc.git
Log | Files | Refs | README | LICENSE

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 }