lib

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

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 }