target_contract.rs (17182B)
1 use core::str::FromStr; 2 3 use radroots_transport::{ 4 Error, TARGET_SET_MAX_ITEMS, Target, TargetNetworkPolicy, TargetSet, TransportId, 5 endpoint::{ 6 ENDPOINT_URI_MAX_BYTES, EndpointUri, TARGET_LABEL_MAX_BYTES, TARGET_SCOPE_MAX_BYTES, 7 TargetLabel, TargetScope, 8 }, 9 target::TargetFingerprint, 10 }; 11 use serde_json::Value; 12 13 #[test] 14 fn captured_relay_matching_preserves_canonical_identity_and_original_network_policy() { 15 let target = Target::nostr_relay("wss://relay.example").unwrap(); 16 for raw in [ 17 "wss://relay.example/", 18 "WSS://RELAY.EXAMPLE:443/", 19 "wss://relay.example:443", 20 ] { 21 assert!(target.matches_nostr_relay(raw).unwrap()); 22 } 23 for raw in [ 24 "wss://other.example/", 25 "wss://relay.example:444/", 26 "wss://relay.example/path", 27 ] { 28 assert!(!target.matches_nostr_relay(raw).unwrap()); 29 } 30 for raw in [ 31 "ws://relay.example/", 32 "wss://relay.example/?q=1", 33 "wss://relay.example/#fragment", 34 "wss://user@relay.example/", 35 ] { 36 assert!(target.matches_nostr_relay(raw).is_err()); 37 } 38 let private = 39 Target::nostr_relay_with_policy("ws://192.168.1.2", TargetNetworkPolicy::PrivateDevice) 40 .unwrap(); 41 assert!(private.matches_nostr_relay("WS://192.168.1.2:80/").unwrap()); 42 assert!(private.matches_nostr_relay("ws://public.example/").is_err()); 43 let ipv6 = Target::nostr_relay("wss://[2001:db8::1]").unwrap(); 44 assert!( 45 ipv6.matches_nostr_relay("wss://[2001:0DB8:0:0:0:0:0:1]:443/") 46 .unwrap() 47 ); 48 assert!( 49 !Target::local("local:preview") 50 .unwrap() 51 .matches_nostr_relay("wss://relay.example/") 52 .unwrap() 53 ); 54 } 55 56 #[test] 57 fn endpoint_scope_and_label_values_are_canonical_and_bounded() { 58 let endpoint = EndpointUri::from_str("MESH://Node.Example/path").expect("endpoint"); 59 assert_eq!(endpoint.as_ref(), "mesh://node.example/path"); 60 assert_eq!(EndpointUri::try_from(endpoint.as_str()).unwrap(), endpoint); 61 assert_eq!( 62 EndpointUri::parse("a".repeat(ENDPOINT_URI_MAX_BYTES + 1)).unwrap_err(), 63 Error::InvalidTargetUri 64 ); 65 66 let scope = TargetScope::from_str("farm_1.alpha-beta").expect("scope"); 67 assert_eq!(scope.as_ref(), "farm_1.alpha-beta"); 68 assert_eq!(TargetScope::try_from(scope.as_str()).unwrap(), scope); 69 assert_eq!( 70 TargetScope::parse("a".repeat(TARGET_SCOPE_MAX_BYTES + 1)).unwrap_err(), 71 Error::InvalidTargetScope 72 ); 73 74 let label = TargetLabel::from_str(" Relay One ").expect("label"); 75 assert_eq!(label.as_ref(), "Relay One"); 76 assert_eq!(TargetLabel::try_from(label.as_str()).unwrap(), label); 77 assert_eq!( 78 TargetLabel::parse("a".repeat(TARGET_LABEL_MAX_BYTES + 1)).unwrap_err(), 79 Error::InvalidTargetLabel 80 ); 81 } 82 83 #[test] 84 fn fingerprints_and_target_sets_are_deterministic_unique_and_bounded() { 85 let target = Target::new(TransportId::LOCAL, "local:node-0").expect("target"); 86 let fingerprint = 87 TargetFingerprint::from_str(target.fingerprint().as_str()).expect("target fingerprint"); 88 assert_eq!(&fingerprint, target.fingerprint()); 89 assert_eq!( 90 TargetFingerprint::try_from(fingerprint.as_str()).unwrap(), 91 fingerprint 92 ); 93 94 let targets = (0..TARGET_SET_MAX_ITEMS) 95 .map(|index| { 96 Target::new(TransportId::LOCAL, format!("local:node-{index}")).expect("bounded target") 97 }) 98 .collect(); 99 let target_set = TargetSet::new(targets).expect("maximum target set"); 100 assert_eq!(target_set.len(), TARGET_SET_MAX_ITEMS); 101 102 let oversized = (0..=TARGET_SET_MAX_ITEMS) 103 .map(|index| { 104 Target::new(TransportId::LOCAL, format!("local:oversized-{index}")) 105 .expect("oversized target member") 106 }) 107 .collect(); 108 assert_eq!( 109 TargetSet::new(oversized).unwrap_err(), 110 Error::TargetSetTooLarge 111 ); 112 113 assert_eq!( 114 TargetSet::new(vec![target.clone(), target]).unwrap_err(), 115 Error::DuplicateTargetFingerprint 116 ); 117 } 118 119 #[test] 120 fn transport_target_uri_vectors_match_the_canonical_parser() { 121 let document: Value = serde_json::from_str(include_str!("fixtures/target_uri.v1.json")) 122 .expect("transport target vectors"); 123 let vectors = document["vectors"].as_array().expect("vector array"); 124 125 for vector in vectors { 126 let kind = vector["kind"].as_str().expect("vector kind"); 127 let raw = vector["input"]["uri"].as_str().expect("input URI"); 128 match kind { 129 "transport.target_uri.valid" => assert_eq!( 130 EndpointUri::parse(raw).expect("valid endpoint").as_str(), 131 vector["expected"]["canonical_uri"] 132 .as_str() 133 .expect("canonical URI") 134 ), 135 "transport.target_uri.invalid" => assert!(EndpointUri::parse(raw).is_err()), 136 "transport.nostr_relay_target.valid" => assert_eq!( 137 Target::nostr_relay(raw) 138 .expect("valid relay") 139 .uri() 140 .as_str(), 141 vector["expected"]["canonical_uri"] 142 .as_str() 143 .expect("canonical URI") 144 ), 145 "transport.nostr_relay_target.invalid" => { 146 assert!(Target::nostr_relay(raw).is_err()) 147 } 148 "transport.nostr_relay_private_device.valid" => assert_eq!( 149 Target::nostr_relay_with_policy(raw, TargetNetworkPolicy::PrivateDevice) 150 .expect("valid private-device relay") 151 .uri() 152 .as_str(), 153 vector["expected"]["canonical_uri"] 154 .as_str() 155 .expect("canonical URI") 156 ), 157 "transport.nostr_relay_private_device.invalid" => assert!( 158 Target::nostr_relay_with_policy(raw, TargetNetworkPolicy::PrivateDevice).is_err() 159 ), 160 other => panic!("unknown vector kind {other}"), 161 } 162 } 163 } 164 165 #[test] 166 fn generic_endpoint_parser_covers_opaque_authority_and_scheme_edges() { 167 let schemeless = EndpointUri::parse("transport-target").expect("schemeless URI"); 168 assert_eq!(schemeless.as_str(), "transport-target"); 169 assert_eq!(schemeless.to_string(), "transport-target"); 170 assert_eq!( 171 EndpointUri::parse("RNS:PeerA") 172 .expect("opaque URI") 173 .as_str(), 174 "rns:PeerA" 175 ); 176 assert_eq!( 177 EndpointUri::parse("MESH://Node.Example/path?q=1#frag") 178 .expect("authority URI") 179 .as_str(), 180 "mesh://node.example/path?q=1#frag" 181 ); 182 assert_eq!(EndpointUri::parse(" ").unwrap_err(), Error::EmptyTargetUri); 183 184 for invalid in [ 185 "bad target", 186 " transport-target ", 187 ":target", 188 "1bad:target", 189 "bad_scheme://target", 190 "bad\ttarget", 191 "bad\ntarget", 192 ] { 193 assert_eq!( 194 EndpointUri::parse(invalid).unwrap_err(), 195 Error::InvalidTargetUri, 196 "{invalid:?} must fail" 197 ); 198 } 199 } 200 201 #[test] 202 fn nostr_targets_canonicalize_identity_and_local_websocket_endpoints() { 203 let root = Target::nostr_relay("wss://relay.example").expect("root relay"); 204 let slash = Target::nostr_relay("WSS://RELAY.EXAMPLE/").expect("root slash relay"); 205 let default_port = Target::nostr_relay("wss://relay.example:443").expect("default port relay"); 206 let path = Target::nostr_relay("wss://relay.example/Events").expect("path relay"); 207 let generic = 208 Target::new(TransportId::NOSTR, "wss://relay.example/").expect("generic Nostr target"); 209 210 assert_eq!(root.uri().as_str(), "wss://relay.example"); 211 assert_eq!(root.fingerprint(), slash.fingerprint()); 212 assert_eq!(root.fingerprint(), default_port.fingerprint()); 213 assert_eq!(root.fingerprint(), generic.fingerprint()); 214 assert_ne!(root.fingerprint(), path.fingerprint()); 215 assert_eq!(path.uri().as_str(), "wss://relay.example/Events"); 216 assert_eq!( 217 TargetSet::new(vec![root, slash]).unwrap_err(), 218 Error::DuplicateTargetFingerprint 219 ); 220 221 for (raw, expected) in [ 222 ("ws://LOCALHOST:80/", "ws://localhost"), 223 ("ws://127.0.0.1:7777", "ws://127.0.0.1:7777"), 224 ("ws://[0:0:0:0:0:0:0:1]:7777", "ws://[::1]:7777"), 225 ("wss://[2001:0DB8::1]:443", "wss://[2001:db8::1]"), 226 ( 227 "wss://relay.example:7443/a%20b", 228 "wss://relay.example:7443/a%20b", 229 ), 230 ] { 231 assert_eq!( 232 Target::nostr_relay(raw) 233 .expect("valid relay") 234 .uri() 235 .as_str(), 236 expected 237 ); 238 } 239 } 240 241 #[test] 242 fn nostr_targets_reject_ambiguous_authorities_hosts_ports_and_paths() { 243 let overlong = format!("wss://{}", "a".repeat(ENDPOINT_URI_MAX_BYTES)); 244 let overlong_dns_label = format!("wss://{}.example", "a".repeat(64)); 245 let overlong_host = format!("wss://{}.example", "a.".repeat(124)); 246 assert_eq!(Target::nostr_relay("").unwrap_err(), Error::EmptyTargetUri); 247 let invalid = [ 248 " wss://relay.example", 249 "wss://relay.example ", 250 "https://relay.example", 251 "wss:relay.example", 252 "wss://", 253 "wss://user@relay.example", 254 "wss://user:password@relay.example", 255 "wss://relay.example?subscription=1", 256 "wss://relay.example#fragment", 257 "wss://relay.example\\path", 258 "wss://relay.example:", 259 "wss://relay.example:0", 260 "wss://relay.example:01", 261 "wss://relay.example:65536", 262 "wss://relay.example:999999999999999999999999999999999999", 263 "wss://:443", 264 "wss://[", 265 "wss://[]", 266 "wss://[::1", 267 "wss://[::1]suffix", 268 "wss://[::1]:", 269 "wss://[not-ipv6]", 270 "wss://[::ffff:127.0.0.1x]", 271 "wss://relay[.]example", 272 "wss://127.0.0.01", 273 "wss://127.0.0.256", 274 "wss://127.0.0", 275 "wss://127.0.0.1.2", 276 "wss://-relay.example", 277 "wss://relay-.example", 278 "wss://relay..example", 279 "wss://xn--relay.example", 280 "wss://relay.123", 281 "wss://relay.0x10", 282 "wss://relay.ex_ample", 283 "ws://relay.example", 284 "ws://192.168.1.2", 285 "wss://relay.example/.", 286 "wss://relay.example/..", 287 "wss://relay.example/%2E", 288 "wss://relay.example/%2E%2E", 289 "wss://relay.example/%2e", 290 "wss://relay.example/%", 291 "wss://relay.example/%2", 292 "wss://relay.example/a[b", 293 ]; 294 for raw in invalid.into_iter().chain([ 295 overlong.as_str(), 296 overlong_dns_label.as_str(), 297 overlong_host.as_str(), 298 ]) { 299 assert_eq!( 300 Target::nostr_relay(raw).unwrap_err(), 301 Error::InvalidTargetUri, 302 "{raw:?} must fail" 303 ); 304 } 305 } 306 307 #[test] 308 fn private_device_relay_targets_require_an_explicit_literal_policy() { 309 for (raw, canonical, requires_explicit_policy) in [ 310 ("ws://10.0.0.1:7447", "ws://10.0.0.1:7447", true), 311 ("ws://172.16.0.1", "ws://172.16.0.1", true), 312 ("wss://192.168.1.2", "wss://192.168.1.2", false), 313 ("ws://[FD00::1]:7447", "ws://[fd00::1]:7447", true), 314 ] { 315 assert_eq!( 316 Target::nostr_relay(raw).is_err(), 317 requires_explicit_policy, 318 "{raw}" 319 ); 320 assert_eq!( 321 Target::nostr_relay_with_policy(raw, TargetNetworkPolicy::PrivateDevice) 322 .expect("private-device target") 323 .uri() 324 .as_str(), 325 canonical 326 ); 327 } 328 329 for denied in [ 330 "ws://relay.example", 331 "ws://8.8.8.8", 332 "ws://127.0.0.1", 333 "ws://169.254.1.1", 334 "ws://224.0.0.1", 335 "ws://[::1]", 336 "ws://[fe80::1]", 337 "ws://[ff02::1]", 338 ] { 339 assert!( 340 Target::nostr_relay_with_policy(denied, TargetNetworkPolicy::PrivateDevice).is_err(), 341 "{denied}" 342 ); 343 } 344 } 345 346 #[test] 347 fn target_metadata_identity_and_collection_accessors_are_explicit() { 348 let scope = TargetScope::parse("local").expect("scope"); 349 let label = TargetLabel::parse(" Local node ").expect("label"); 350 let local = 351 Target::local_with_metadata("local:node-1", Some(scope.clone()), Some(label.clone())) 352 .expect("local target"); 353 let relabeled = Target::new_with_metadata( 354 TransportId::LOCAL, 355 "local:node-1", 356 Some(scope), 357 Some(TargetLabel::parse("Renamed node").expect("label")), 358 ) 359 .expect("relabeled target"); 360 let unscoped = Target::local("local:node-1").expect("unscoped target"); 361 362 assert_eq!(local.kind(), &TransportId::LOCAL); 363 assert_eq!(local.uri().as_ref(), "local:node-1"); 364 assert_eq!(local.scope().map(TargetScope::as_str), Some("local")); 365 assert_eq!(local.label().map(TargetLabel::as_str), Some("Local node")); 366 assert_eq!(local.fingerprint(), relabeled.fingerprint()); 367 assert_ne!(local.fingerprint(), unscoped.fingerprint()); 368 369 let set = TargetSet::new(vec![local.clone(), unscoped]).expect("target set"); 370 assert!(set.contains(local.fingerprint())); 371 assert!(!set.is_empty()); 372 assert_eq!(set.targets().len(), 2); 373 let foreign = Target::local("local:foreign").expect("foreign target"); 374 assert!(!set.contains(foreign.fingerprint())); 375 376 assert_eq!(TargetScope::parse("").unwrap_err(), Error::EmptyTargetScope); 377 for value in [" scope", "scope ", "bad scope", "bad/scope", "bad\nscope"] { 378 assert_eq!( 379 TargetScope::parse(value).unwrap_err(), 380 Error::InvalidTargetScope 381 ); 382 } 383 assert_eq!( 384 TargetLabel::parse(" ").unwrap_err(), 385 Error::EmptyTargetLabel 386 ); 387 assert_eq!( 388 TargetLabel::parse("bad\nlabel").unwrap_err(), 389 Error::InvalidTargetLabel 390 ); 391 assert_eq!( 392 TargetFingerprint::parse("abc").unwrap_err(), 393 Error::InvalidTargetFingerprint 394 ); 395 assert_eq!( 396 TargetFingerprint::parse("g".repeat(64)).unwrap_err(), 397 Error::InvalidTargetFingerprint 398 ); 399 let uppercase = TargetFingerprint::parse(local.fingerprint().as_str().to_ascii_uppercase()) 400 .expect("uppercase fingerprint"); 401 assert_eq!(uppercase.as_str(), local.fingerprint().as_str()); 402 assert_eq!(uppercase.to_string(), local.fingerprint().as_str()); 403 assert_eq!( 404 TargetSet::new(Vec::new()).unwrap_err(), 405 Error::EmptyTargetSet 406 ); 407 } 408 409 #[test] 410 #[cfg(feature = "serde")] 411 fn target_deserialization_revalidates_every_canonical_identity_field() { 412 let target = Target::nostr_relay_with_metadata( 413 "wss://relay.example/path", 414 Some(TargetScope::parse("public").expect("scope")), 415 Some(TargetLabel::parse("Relay").expect("label")), 416 ) 417 .expect("target"); 418 let value = serde_json::to_value(&target).expect("target JSON"); 419 assert_eq!( 420 serde_json::from_value::<Target>(value.clone()).expect("target round trip"), 421 target 422 ); 423 424 for (field, forged) in [ 425 ("uri", Value::String("WSS://RELAY.EXAMPLE/path".into())), 426 ("scope", Value::String("bad scope".into())), 427 ("label", Value::String(" Relay ".into())), 428 ("fingerprint", Value::String("A".repeat(64))), 429 ("fingerprint", Value::String("0".repeat(64))), 430 ] { 431 let mut invalid = value.clone(); 432 invalid[field] = forged; 433 assert!( 434 serde_json::from_value::<Target>(invalid).is_err(), 435 "{field}" 436 ); 437 } 438 439 let set = TargetSet::new(vec![target]).expect("target set"); 440 let encoded = serde_json::to_value(&set).expect("target set JSON"); 441 assert_eq!( 442 serde_json::from_value::<TargetSet>(encoded.clone()).expect("set round trip"), 443 set 444 ); 445 let mut duplicate = encoded; 446 let first = duplicate["targets"][0].clone(); 447 duplicate["targets"].as_array_mut().unwrap().push(first); 448 assert!(serde_json::from_value::<TargetSet>(duplicate).is_err()); 449 } 450 451 #[test] 452 #[cfg(feature = "serde")] 453 fn private_device_cleartext_target_round_trip_remains_explicit_and_validated() { 454 let target = 455 Target::nostr_relay_with_policy("ws://[fd00::5]:7447", TargetNetworkPolicy::PrivateDevice) 456 .expect("private-device target"); 457 let value = serde_json::to_value(&target).expect("private-device target JSON"); 458 assert_eq!(value["private_device_cleartext"], Value::Bool(true)); 459 assert_eq!( 460 serde_json::from_value::<Target>(value.clone()).expect("private-device round trip"), 461 target 462 ); 463 464 let mut false_marker = value.clone(); 465 false_marker["private_device_cleartext"] = Value::Bool(false); 466 assert!(serde_json::from_value::<Target>(false_marker).is_err()); 467 468 let mut public_address = value.clone(); 469 public_address["uri"] = Value::String("ws://8.8.8.8:7447".into()); 470 assert!(serde_json::from_value::<Target>(public_address).is_err()); 471 472 let mut named = value; 473 named["uri"] = Value::String("ws://relay.internal:7447".into()); 474 assert!(serde_json::from_value::<Target>(named).is_err()); 475 }