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 }