lib

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

network_hardening.rs (3160B)


      1 use radroots_transport::{Target, TargetSet, source::FetchBounds};
      2 use radroots_transport_nostr::{
      3     RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrl, RelayUrlPolicy,
      4 };
      5 
      6 const WORKSPACE_MANIFEST: &str = include_str!("../../../Cargo.toml");
      7 const RELAY_SOURCE: &str = include_str!("../src/relay.rs");
      8 const CLIENT_SOURCE: &str = include_str!("../src/client.rs");
      9 
     10 #[test]
     11 fn tls_verification_and_pinned_dns_are_non_configurable_live_defaults() {
     12     assert!(WORKSPACE_MANIFEST.contains("rustls-tls-webpki-roots"));
     13     let socket = include_str!("../src/session_socket.rs");
     14     let native = include_str!("../../transport_nostr_native/src/connector.rs");
     15     for required in [
     16         "client_async_with_config(",
     17         "roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned())",
     18         ".with_no_client_auth()",
     19         "rustls::pki_types::ServerName::try_from(host.to_owned())",
     20         "MeteredIo::new(plaintext, metering, max_message_bytes.get())",
     21         ".max_message_size(Some(max_message_bytes.get()))",
     22         ".max_frame_size(Some(max_message_bytes.get()))",
     23         "admission.permits_address(address.ip())",
     24         "connect_pinned(&addresses)",
     25     ] {
     26         assert!(
     27             native.contains(required),
     28             "missing native policy witness `{required}`"
     29         );
     30     }
     31     assert!(socket.contains("if proxy.is_some()"));
     32     for forbidden in [
     33         "tokio::net::",
     34         "tokio_tungstenite",
     35         "TlsConnector",
     36         "lookup_host",
     37         "MeteredIo",
     38     ] {
     39         assert!(!RELAY_SOURCE.contains(forbidden));
     40         assert!(!socket.contains(forbidden));
     41     }
     42     for forbidden in [
     43         "danger_accept_invalid_certs",
     44         "danger_accept_invalid_hostnames",
     45         "NoCertificateVerification",
     46     ] {
     47         assert!(!RELAY_SOURCE.contains(forbidden));
     48         assert!(!CLIENT_SOURCE.contains(forbidden));
     49         assert!(!native.contains(forbidden));
     50     }
     51 
     52     assert!(RelayUrl::parse("ws://relay.example.com", RelayUrlPolicy::Public).is_err());
     53     assert!(RelayUrl::parse("wss://relay.example.com", RelayUrlPolicy::Public).is_ok());
     54     assert!(RelayUrl::parse("ws://127.0.0.1", RelayUrlPolicy::Local).is_ok());
     55 }
     56 
     57 #[test]
     58 fn page_and_target_limits_reject_oversized_requests() {
     59     assert!(FetchBounds::new(1_001, u64::MAX).is_err());
     60 
     61     let targets = (0..=64)
     62         .map(|index| Target::nostr_relay(format!("wss://r{index}.example.com")).expect("target"))
     63         .collect::<Vec<_>>();
     64     assert!(TargetSet::new(targets).is_err());
     65 
     66     let relays = (0..=64)
     67         .map(|index| {
     68             RelayEndpoint::new(
     69                 format!("wss://r{index}.example.com"),
     70                 RelayUrlPolicy::Public,
     71                 RelayAccess::ReadWrite,
     72             )
     73             .expect("relay endpoint")
     74         })
     75         .collect::<Vec<_>>();
     76     assert!(RelayProfile::explicit(RelayProfileKind::Public, relays).is_err());
     77 }
     78 
     79 #[test]
     80 fn oversized_wire_payload_is_rejected_before_delivery() {
     81     let oversized = "x".repeat(radroots_event_codec::decode::MAX_EVENT_JSON_BYTES + 1);
     82     assert!(radroots_event_codec::decode::signed_event(oversized.as_str()).is_err());
     83 }