lib

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

chat_wire.rs (21054B)


      1 #![cfg(feature = "chat")]
      2 
      3 use radroots_domain::{PublicKey, UnixSeconds};
      4 use radroots_protocol::nip59::{PrivateEnvelopeBudget, nip44_v2_payload_len};
      5 use radroots_protocol::{
      6     chat::*,
      7     command::CapturedChatCommand,
      8     intent::SigningReplay,
      9     nip01::*,
     10     nip59::{CapturedDmRoute, DmRelayAdvertisement},
     11 };
     12 use serde_json::Value;
     13 
     14 fn vectors() -> Value {
     15     serde_json::from_str(include_str!("fixtures/chat_wire.v1.json")).unwrap()
     16 }
     17 fn time(value: u64) -> UnixSeconds {
     18     UnixSeconds::new(value).unwrap()
     19 }
     20 fn text<'a>(row: &'a Value, key: &str) -> &'a str {
     21     row[key].as_str().unwrap()
     22 }
     23 
     24 #[test]
     25 fn independent_wire_vectors_preserve_plaintext_tags_recipient_set_and_exact_seal() {
     26     for row in vectors()["vectors"].as_array().unwrap() {
     27         let command = CapturedChatCommand::parse(text(row, "wire").as_bytes()).unwrap();
     28         let rumor = ChatRumor::from_command(&command, time(1_700_000_000)).unwrap();
     29         assert_eq!(rumor.json(), text(row, "rumor"));
     30         assert_eq!(rumor.message_id().to_string(), text(row, "message_id"));
     31         assert_eq!(rumor.author(), command.context().actor().participant());
     32         assert_eq!(rumor.created_at(), time(1_700_000_000));
     33         let recipients: Vec<_> = rumor.recipients().iter().map(|key| key.to_hex()).collect();
     34         assert_eq!(serde_json::to_value(recipients).unwrap(), row["recipients"]);
     35         let json: Value = serde_json::from_str(rumor.json()).unwrap();
     36         assert!(json.get("sig").is_none());
     37         assert_eq!(json["content"], command.text());
     38         for recipient in rumor.recipients() {
     39             let seal = ChatSeal::new(
     40                 &rumor,
     41                 *recipient,
     42                 time(1_699_999_990),
     43                 text(row, "structural_ciphertext"),
     44             )
     45             .unwrap();
     46             assert_eq!(
     47                 canonical_preimage(&seal.fields()),
     48                 text(row, "seal_preimage")
     49             );
     50             assert_eq!(
     51                 signed_json_len(&seal.fields(), SIGNED_MAX_BYTES).unwrap() as u64,
     52                 row["signed_seal_bytes"].as_u64().unwrap()
     53             );
     54             assert_eq!(seal.recipient(), *recipient);
     55             let encoded = UnsignedEvent::encode(&seal.fields(), SIGNED_MAX_BYTES).unwrap();
     56             assert_eq!(seal.event_id(), encoded.event_id());
     57             assert_eq!(
     58                 serde_json::from_str::<Value>(encoded.json()).unwrap()["id"],
     59                 row["seal_id"]
     60             );
     61             assert!(!format!("{seal:?}").contains(text(row, "structural_ciphertext")));
     62         }
     63         assert!(!format!("{rumor:?}").contains(command.text()));
     64     }
     65 }
     66 
     67 #[test]
     68 fn complete_nested_budget_and_padding_match_independent_serialized_objects() {
     69     let data = vectors();
     70     let key = PublicKey::from_hex(text(&data["canonical"][0], "author")).unwrap();
     71     for row in data["budgets"].as_array().unwrap() {
     72         let budget =
     73             PrivateEnvelopeBudget::for_rumor(row["rumor_bytes"].as_u64().unwrap() as usize, key)
     74                 .unwrap();
     75         assert_eq!(
     76             budget.rumor_ciphertext_bytes() as u64,
     77             row["rumor_ciphertext_bytes"].as_u64().unwrap()
     78         );
     79         assert_eq!(
     80             budget.signed_seal_max_bytes() as u64,
     81             row["signed_seal_max_bytes"].as_u64().unwrap()
     82         );
     83         assert_eq!(
     84             budget.envelope_ciphertext_max_bytes() as u64,
     85             row["envelope_ciphertext_max_bytes"].as_u64().unwrap()
     86         );
     87         assert_eq!(
     88             budget.signed_envelope_max_bytes() as u64,
     89             row["signed_envelope_max_bytes"].as_u64().unwrap()
     90         );
     91     }
     92     for row in data["padding"].as_array().unwrap() {
     93         assert_eq!(
     94             nip44_v2_payload_len(row["plaintext_bytes"].as_u64().unwrap() as usize).unwrap() as u64,
     95             row["encoded_bytes"].as_u64().unwrap()
     96         );
     97     }
     98     for size in [0, 65_536, usize::MAX] {
     99         assert_eq!(nip44_v2_payload_len(size), Err(WireError::InvalidInput));
    100     }
    101     assert_eq!(
    102         PrivateEnvelopeBudget::for_rumor(0, key),
    103         Err(WireError::InvalidInput)
    104     );
    105     assert_eq!(
    106         PrivateEnvelopeBudget::for_rumor(RUMOR_MAX_BYTES + 1, key),
    107         Err(WireError::LimitExceeded)
    108     );
    109 }
    110 
    111 #[test]
    112 fn canonical_wire_preserves_original_escaping_and_full_legacy_integer_range() {
    113     for row in vectors()["canonical"].as_array().unwrap() {
    114         let tags: Vec<Vec<String>> = serde_json::from_value(row["tags"].clone()).unwrap();
    115         let fields = EventFields {
    116             author: PublicKey::from_hex(text(row, "author")).unwrap(),
    117             created_at: text(row, "created_at").parse().unwrap(),
    118             kind: row["kind"].as_u64().unwrap() as u32,
    119             tags: &tags,
    120             content: text(row, "content"),
    121         };
    122         let expected = text(row, "preimage");
    123         assert_eq!(canonical_preimage(&fields), expected);
    124         assert_eq!(
    125             preimage_len(&fields, expected.len()).unwrap(),
    126             expected.len()
    127         );
    128         assert_eq!(
    129             preimage_len(&fields, expected.len() - 1),
    130             Err(WireError::LimitExceeded)
    131         );
    132         let signed_size = row["signed_json_bytes"].as_u64().unwrap() as usize;
    133         assert_eq!(signed_json_len(&fields, signed_size).unwrap(), signed_size);
    134         assert_eq!(
    135             signed_json_len(&fields, signed_size - 1),
    136             Err(WireError::LimitExceeded)
    137         );
    138         let unsigned = UnsignedEvent::encode(&fields, expected.len() + 116).unwrap();
    139         assert_eq!(unsigned.json().len(), expected.len() + 116);
    140         assert_eq!(
    141             serde_json::from_str::<Value>(unsigned.json()).unwrap()["id"],
    142             row["event_id"]
    143         );
    144         assert!(matches!(
    145             UnsignedEvent::encode(&fields, expected.len() + 115),
    146             Err(WireError::LimitExceeded)
    147         ));
    148         assert!(matches!(
    149             UnsignedEvent::encode(&fields, 0),
    150             Err(WireError::LimitExceeded)
    151         ));
    152         assert!(
    153             !format!("{fields:?} {unsigned:?}").contains(fields.content)
    154                 || fields.content.is_empty()
    155         );
    156     }
    157 }
    158 
    159 #[test]
    160 fn noncanonical_base64_padding_version_and_alphabet_are_refused_before_seal_capture() {
    161     for row in vectors()["vectors"].as_array().unwrap() {
    162         let command = CapturedChatCommand::parse(text(row, "wire").as_bytes()).unwrap();
    163         let rumor = ChatRumor::from_command(&command, time(1_700_000_000)).unwrap();
    164         let original = text(row, "structural_ciphertext").as_bytes();
    165         let mut changes = Vec::new();
    166         let mut invalid = original.to_vec();
    167         invalid[2] = b'!';
    168         changes.push(invalid);
    169         let mut wrong_version = original.to_vec();
    170         wrong_version[1] = b'Q';
    171         changes.push(wrong_version);
    172         let padding = original
    173             .iter()
    174             .rev()
    175             .take_while(|byte| **byte == b'=')
    176             .count();
    177         if padding != 0 {
    178             let mut missing_padding = original.to_vec();
    179             *missing_padding.last_mut().unwrap() = b'A';
    180             changes.push(missing_padding);
    181             let mut nonzero_tail = original.to_vec();
    182             nonzero_tail[original.len() - padding - 1] = b'B';
    183             changes.push(nonzero_tail);
    184         }
    185         for changed in changes {
    186             assert!(matches!(
    187                 ChatSeal::new(
    188                     &rumor,
    189                     rumor.recipients()[0],
    190                     time(1_699_999_990),
    191                     core::str::from_utf8(&changed).unwrap()
    192                 ),
    193                 Err(WireError::InvalidInput)
    194             ));
    195         }
    196     }
    197 }
    198 
    199 #[test]
    200 fn rumor_and_seal_refuse_invalid_time_recipient_nested_size_and_ciphertext_shape() {
    201     let data = vectors();
    202     let row = &data["vectors"][0];
    203     let command = CapturedChatCommand::parse(text(row, "wire").as_bytes()).unwrap();
    204     assert!(matches!(
    205         ChatRumor::from_command(&command, time(0)),
    206         Err(WireError::InvalidInput)
    207     ));
    208     let rumor = ChatRumor::from_command(&command, time(1_700_000_000)).unwrap();
    209     let peer = rumor.recipients()[0];
    210     for timestamp in [0, 1_700_000_001, 1_700_000_000 - 172_801] {
    211         assert!(matches!(
    212             ChatSeal::new(
    213                 &rumor,
    214                 peer,
    215                 time(timestamp),
    216                 text(row, "structural_ciphertext")
    217             ),
    218             Err(WireError::InvalidInput)
    219         ));
    220     }
    221     let stranger =
    222         PublicKey::from_hex("f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9")
    223             .unwrap();
    224     assert!(matches!(
    225         ChatSeal::new(
    226             &rumor,
    227             stranger,
    228             time(1_699_999_990),
    229             text(row, "structural_ciphertext")
    230         ),
    231         Err(WireError::InvalidInput)
    232     ));
    233     for change in [
    234         "",
    235         "#unsupported",
    236         "AA",
    237         &"A".repeat(text(row, "structural_ciphertext").len()),
    238     ] {
    239         assert!(matches!(
    240             ChatSeal::new(&rumor, peer, time(1_699_999_990), change),
    241             Err(WireError::InvalidInput)
    242         ));
    243     }
    244     let mut wire: Value = serde_json::from_str(text(row, "wire")).unwrap();
    245     wire["input"]["text"] = Value::String("\u{0000}".repeat(4096));
    246     let expanded = CapturedChatCommand::parse(&serde_json::to_vec(&wire).unwrap()).unwrap();
    247     assert!(matches!(
    248         ChatRumor::from_command(&expanded, time(1_700_000_000)),
    249         Err(WireError::LimitExceeded)
    250     ));
    251     wire["input"]["text"] = Value::String("a".repeat(4096));
    252     let bounded = CapturedChatCommand::parse(&serde_json::to_vec(&wire).unwrap()).unwrap();
    253     assert!(ChatRumor::from_command(&bounded, time(1_700_000_000)).is_ok());
    254 }
    255 
    256 fn plan_parts(row: &Value, command: &CapturedChatCommand) -> (Vec<ChatSeal>, Vec<CapturedDmRoute>) {
    257     let rumor = ChatRumor::from_command(command, time(1_700_000_000)).unwrap();
    258     let mut seals = Vec::new();
    259     let mut routes = Vec::new();
    260     for recipient in rumor.recipients() {
    261         seals.push(
    262             ChatSeal::new(
    263                 &rumor,
    264                 *recipient,
    265                 time(1_699_999_990),
    266                 text(row, "structural_ciphertext"),
    267             )
    268             .unwrap(),
    269         );
    270         routes.push(
    271             CapturedDmRoute::from_observed_descriptor(
    272                 *recipient,
    273                 radroots_domain::EnvelopeEventId::from_bytes([9; 32]),
    274                 " { \"unverified\": true } ",
    275                 &["wss://route.example/".into()],
    276             )
    277             .unwrap(),
    278         );
    279     }
    280     (seals, routes)
    281 }
    282 #[test]
    283 fn complete_plan_roundtrip_preserves_all_exact_descriptors_and_refuses_truncation_substitution() {
    284     for row in vectors()["vectors"].as_array().unwrap() {
    285         let command = CapturedChatCommand::parse(text(row, "wire").as_bytes()).unwrap();
    286         for replay in [
    287             SigningReplay::NonReplayable,
    288             SigningReplay::LocalReplaySafe,
    289             SigningReplay::ExactReplayByRequestId,
    290         ] {
    291             let (seals, routes) = plan_parts(row, &command);
    292             let plan =
    293                 ChatSigningPlan::new(&command, time(1_700_000_000), seals, routes, replay).unwrap();
    294             assert_eq!(plan.operation_id(), command.context().operation_id());
    295             assert_eq!(plan.command_digest(), command.digest());
    296             assert_eq!(plan.message_id().to_string(), text(row, "message_id"));
    297             assert_eq!(plan.created_at(), time(1_700_000_000));
    298             assert_eq!(plan.replay(), replay);
    299             let recovered = ChatSigningPlan::parse(&command, plan.protected_wire()).unwrap();
    300             assert_eq!(recovered.protected_wire(), plan.protected_wire());
    301             assert_eq!(recovered.digest(), plan.digest());
    302             assert_eq!(recovered.seals().len(), recovered.routes().len());
    303             assert!(!format!("{plan:?}").contains("route.example"));
    304             for size in 0..plan.protected_wire().len() {
    305                 assert!(
    306                     ChatSigningPlan::parse(&command, &plan.protected_wire()[..size]).is_err(),
    307                     "truncated at {size}"
    308                 );
    309             }
    310             let mut changed = plan.protected_wire().to_vec();
    311             changed.push(0);
    312             assert!(ChatSigningPlan::parse(&command, &changed).is_err());
    313             // Prefix, original operation/digest/message and invalid replay code.
    314             for offset in [0, 28, 60, 92, 132] {
    315                 let mut changed = plan.protected_wire().to_vec();
    316                 changed[offset] = 255;
    317                 assert!(
    318                     ChatSigningPlan::parse(&command, &changed).is_err(),
    319                     "offset {offset}"
    320                 );
    321             }
    322         }
    323         let (mut seals, routes) = plan_parts(row, &command);
    324         seals.pop();
    325         assert!(
    326             ChatSigningPlan::new(
    327                 &command,
    328                 time(1_700_000_000),
    329                 seals,
    330                 routes,
    331                 SigningReplay::NonReplayable
    332             )
    333             .is_err()
    334         );
    335         let (seals, mut routes) = plan_parts(row, &command);
    336         routes.pop();
    337         assert!(
    338             ChatSigningPlan::new(
    339                 &command,
    340                 time(1_700_000_000),
    341                 seals,
    342                 routes,
    343                 SigningReplay::NonReplayable
    344             )
    345             .is_err()
    346         );
    347         if row["recipients"].as_array().unwrap().len() == 2 {
    348             let (mut seals, routes) = plan_parts(row, &command);
    349             seals.reverse();
    350             assert!(
    351                 ChatSigningPlan::new(
    352                     &command,
    353                     time(1_700_000_000),
    354                     seals,
    355                     routes,
    356                     SigningReplay::NonReplayable
    357                 )
    358                 .is_err()
    359             );
    360         }
    361     }
    362     let data = vectors();
    363     let command = CapturedChatCommand::parse(text(&data["vectors"][0], "wire").as_bytes()).unwrap();
    364     assert!(matches!(
    365         ChatSigningPlan::parse(&command, &vec![0; PLAN_MAX_BYTES + 1]),
    366         Err(WireError::LimitExceeded)
    367     ));
    368 }
    369 #[test]
    370 fn bounded_route_descriptors_refuse_invalid_shapes_before_copying_and_never_claim_verification() {
    371     let data = vectors();
    372     let command = CapturedChatCommand::parse(text(&data["vectors"][0], "wire").as_bytes()).unwrap();
    373     let key = command.peer();
    374     let source = radroots_domain::EnvelopeEventId::from_bytes([9; 32]);
    375     for raw in ["", "[]", "false", "{", "null"] {
    376         assert!(
    377             CapturedDmRoute::from_observed_descriptor(
    378                 key,
    379                 source,
    380                 raw,
    381                 &["wss://route.example/".into()]
    382             )
    383             .is_err()
    384         );
    385     }
    386     for selected in [
    387         vec![],
    388         vec!["https://wrong/".into()],
    389         vec![" wss://wrong/".into()],
    390         vec!["wss://wrong/\n".into()],
    391         vec!["ws://same/".into(), "ws://same/".into()],
    392         vec!["ws://same/".into(); 17],
    393         vec![format!("wss://{}", "a".repeat(2048))],
    394     ] {
    395         assert!(CapturedDmRoute::from_observed_descriptor(key, source, "{}", &selected).is_err());
    396     }
    397     assert!(
    398         CapturedDmRoute::from_observed_descriptor(
    399             key,
    400             source,
    401             &"x".repeat(65537),
    402             &["wss://route/".into()]
    403         )
    404         .is_err()
    405     );
    406     let tags = vec![
    407         vec!["relay".into(), "ws://one/".into()],
    408         vec!["relay".into(), "ws://one/".into()],
    409         vec!["alt".into(), "not routing".into()],
    410     ];
    411     let projection = DmRelayAdvertisement::from_tags(key, time(0), &tags).unwrap();
    412     assert_eq!(projection.advertised_relays().len(), 1);
    413     assert_eq!(projection.participant(), key);
    414     assert_eq!(projection.created_at(), time(0));
    415     assert!(!format!("{projection:?}").contains("one/"));
    416     for tags in [
    417         vec![vec![]; 1025],
    418         vec![vec!["relay".into()]],
    419         vec![vec!["relay".into(), "https://wrong/".into()]],
    420         vec![vec!["relay".into(), format!("wss://{}", "a".repeat(2048))]],
    421         vec![vec!["alt".into(), "x".repeat(65536)]],
    422     ] {
    423         assert!(DmRelayAdvertisement::from_tags(key, time(0), &tags).is_err());
    424     }
    425 }
    426 
    427 #[test]
    428 fn complete_plan_refuses_individual_provenance_field_and_combined_route_substitution() {
    429     let data = vectors();
    430     let row = &data["vectors"][0];
    431     let command = CapturedChatCommand::parse(text(row, "wire").as_bytes()).unwrap();
    432     let mut changed: Value = serde_json::from_slice(command.protected_wire()).unwrap();
    433     changed["context"]["operation_id"] = "99".repeat(32).into();
    434     let other_operation =
    435         CapturedChatCommand::parse(&serde_json::to_vec(&changed).unwrap()).unwrap();
    436     let (seals, routes) = plan_parts(row, &command);
    437     assert!(
    438         ChatSigningPlan::new(
    439             &other_operation,
    440             time(1_700_000_000),
    441             seals,
    442             routes,
    443             SigningReplay::NonReplayable
    444         )
    445         .is_err()
    446     );
    447     changed = serde_json::from_slice(command.protected_wire()).unwrap();
    448     changed["input"]["text"] = "same operation, different captured command".into();
    449     let other_digest = CapturedChatCommand::parse(&serde_json::to_vec(&changed).unwrap()).unwrap();
    450     let (seals, routes) = plan_parts(row, &command);
    451     assert!(
    452         ChatSigningPlan::new(
    453             &other_digest,
    454             time(1_700_000_000),
    455             seals,
    456             routes,
    457             SigningReplay::NonReplayable
    458         )
    459         .is_err()
    460     );
    461     let (seals, routes) = plan_parts(row, &command);
    462     assert!(
    463         ChatSigningPlan::new(
    464             &command,
    465             time(1_700_000_001),
    466             seals,
    467             routes,
    468             SigningReplay::NonReplayable
    469         )
    470         .is_err()
    471     );
    472     let (seals, mut routes) = plan_parts(row, &command);
    473     routes.reverse();
    474     assert!(
    475         ChatSigningPlan::new(
    476             &command,
    477             time(1_700_000_000),
    478             seals,
    479             routes,
    480             SigningReplay::NonReplayable
    481         )
    482         .is_err()
    483     );
    484     let (seals, routes) = plan_parts(row, &command);
    485     let routes: Vec<_> = routes
    486         .iter()
    487         .enumerate()
    488         .map(|(index, route)| {
    489             CapturedDmRoute::from_observed_descriptor(
    490                 route.participant(),
    491                 route.source_id(),
    492                 route.raw_json(),
    493                 &(0..16)
    494                     .map(|n| format!("wss://route-{index}-{n}.example/"))
    495                     .collect::<Vec<_>>(),
    496             )
    497             .unwrap()
    498         })
    499         .collect();
    500     assert!(matches!(
    501         ChatSigningPlan::new(
    502             &command,
    503             time(1_700_000_000),
    504             seals,
    505             routes,
    506             SigningReplay::NonReplayable
    507         ),
    508         Err(WireError::LimitExceeded)
    509     ));
    510     let (seals, routes) = plan_parts(row, &command);
    511     let plan = ChatSigningPlan::new(
    512         &command,
    513         time(1_700_000_000),
    514         seals,
    515         routes,
    516         SigningReplay::NonReplayable,
    517     )
    518     .unwrap();
    519     let count = b"radroots.chat.signing_plan.v1\0".len() + 32 * 3 + 8 + 1;
    520     let first = count + 1;
    521     for (offset, value) in [
    522         (count, 0),
    523         (first + 32, 255),
    524         (first + 64, 255),
    525         (first + 68, 1),
    526         (first + 69, 0),
    527         (first + 70, 255),
    528         (first + 110, 255),
    529     ] {
    530         let mut bytes = plan.protected_wire().to_vec();
    531         bytes[offset] = value;
    532         assert!(
    533             ChatSigningPlan::parse(&command, &bytes).is_err(),
    534             "field at {offset}"
    535         );
    536     }
    537     let mut wrong_peer = plan.protected_wire().to_vec();
    538     wrong_peer[first..first + 32].copy_from_slice(command.peer().as_bytes());
    539     assert!(ChatSigningPlan::parse(&command, &wrong_peer).is_err());
    540     let cipher_length = u32::from_be_bytes(
    541         plan.protected_wire()[first + 110..first + 114]
    542             .try_into()
    543             .unwrap(),
    544     ) as usize;
    545     let raw_length_offset = first + 114 + cipher_length + 32;
    546     let raw_length = u32::from_be_bytes(
    547         plan.protected_wire()[raw_length_offset..raw_length_offset + 4]
    548             .try_into()
    549             .unwrap(),
    550     ) as usize;
    551     let route_count = raw_length_offset + 4 + raw_length;
    552     for count in [0, 17] {
    553         let mut bytes = plan.protected_wire().to_vec();
    554         bytes[route_count] = count;
    555         assert!(ChatSigningPlan::parse(&command, &bytes).is_err());
    556     }
    557     for bad in ["ws://leading/ ", "wss://internal/\u{0001}x"] {
    558         assert!(
    559             DmRelayAdvertisement::from_tags(
    560                 command.peer(),
    561                 time(0),
    562                 &[vec!["relay".into(), bad.into()]]
    563             )
    564             .is_err()
    565         );
    566         assert!(
    567             CapturedDmRoute::from_observed_descriptor(
    568                 command.peer(),
    569                 radroots_domain::EnvelopeEventId::from_bytes([9; 32]),
    570                 "{}",
    571                 &[bad.into()]
    572             )
    573             .is_err()
    574         );
    575     }
    576 }