diff --git a/src/db.rs b/src/db.rs index d0832f5..ace795d 100644 --- a/src/db.rs +++ b/src/db.rs @@ -5,15 +5,14 @@ use std::path::Path; use std::sync::Arc; use arc_swap::ArcSwap; -use maxminddb::Reader; +use maxminddb::{MaxMindDbError, PathElement, Reader}; use serde::Deserialize; -use crate::models::{ - IpInfo, MmdbAsn, MmdbCity, MmdbCountry, MmdbProxy, MmdbRecord, ProxyInfo, from_mmdb_record, -}; +use crate::models::{IpInfo, MmdbProxy, MmdbRecord, ProxyInfo, from_mmdb_record}; pub type DbReader = Reader>; pub type SharedDb = Arc>>; +pub type LookupOutcome = Result, MaxMindDbError>; pub fn load_db(path: &Path) -> Result { Reader::open_readfile(path) @@ -31,29 +30,40 @@ pub fn is_ready(db: &SharedDb) -> bool { db.load().is_some() } -pub fn lookup(db: &SharedDb, ip: IpAddr) -> Option { +pub fn lookup(db: &SharedDb, ip: IpAddr) -> LookupOutcome { with_reader(db, ip, |result| { - let record: MmdbRecord<'_> = result.decode().ok()??; - Some(from_mmdb_record(ip, &record)) - })? + let Some(record) = result.decode::>()? else { + return Ok(None); + }; + Ok(Some(from_mmdb_record(ip, &record))) + }) } /// Loads the shared reader, performs a lookup, and passes the raw lookup result /// to `f` for decoding. This eliminates the repeated load-guard-lookup boilerplate -/// while letting callers choose their own deserialization type and lifetime. -fn with_reader( +/// while preserving lookup/decode errors for callers that need HTTP error mapping. +fn with_reader( db: &SharedDb, ip: IpAddr, - f: impl FnOnce(maxminddb::LookupResult<'_, Vec>) -> R, -) -> Option { + f: impl FnOnce(maxminddb::LookupResult<'_, Vec>) -> LookupOutcome, +) -> LookupOutcome { let guard = db.load(); - let reader = Option::as_ref(&guard)?; - let result = reader.lookup(ip).ok()?; - Some(f(result)) + let Some(reader) = Option::as_ref(&guard) else { + return Ok(None); + }; + let result = reader.lookup(ip)?; + f(result) } -// Lightweight deserialization structs for single-field endpoints. -// These avoid deserializing the full MMDB record when only one field is needed. +fn lookup_path(db: &SharedDb, ip: IpAddr, path: &[PathElement<'_>]) -> LookupOutcome +where + T: for<'de> Deserialize<'de>, +{ + with_reader(db, ip, |result| result.decode_path(path)) +} + +// Lightweight deserialization struct for the full proxy object. +// Single-flag endpoints use `decode_path` below instead. #[derive(Deserialize, Default)] struct ProxyOnly { @@ -61,57 +71,83 @@ struct ProxyOnly { proxy: MmdbProxy, } -#[derive(Deserialize, Default)] -struct AsnOnly<'a> { - #[serde(borrow, default)] - asn: MmdbAsn<'a>, -} - -#[derive(Deserialize, Default)] -struct CountryOnly<'a> { - #[serde(borrow, default)] - country: MmdbCountry<'a>, -} - -#[derive(Deserialize, Default)] -struct CityOnly<'a> { - #[serde(borrow, default)] - city: MmdbCity<'a>, -} - -pub fn lookup_proxy(db: &SharedDb, ip: IpAddr) -> Option { +pub fn lookup_proxy(db: &SharedDb, ip: IpAddr) -> LookupOutcome { with_reader(db, ip, |result| { - let record: ProxyOnly = result.decode().ok()??; - Some(record.proxy.into()) - })? + let Some(record) = result.decode::()? else { + return Ok(None); + }; + Ok(Some(record.proxy.into())) + }) } -pub fn lookup_asn_number(db: &SharedDb, ip: IpAddr) -> Option { - with_reader(db, ip, |result| { - let record: AsnOnly<'_> = result.decode().ok()??; - record.asn.autonomous_system_number - })? +fn lookup_proxy_flag(db: &SharedDb, ip: IpAddr, field: &'static str) -> LookupOutcome { + lookup_path( + db, + ip, + &[PathElement::Key("proxy"), PathElement::Key(field)], + ) } -pub fn lookup_asn_org(db: &SharedDb, ip: IpAddr) -> Option { - with_reader(db, ip, |result| { - let record: AsnOnly<'_> = result.decode().ok()??; - record.asn.autonomous_system_organization.map(str::to_owned) - })? +pub(crate) fn lookup_is_proxy(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_proxy_flag(db, ip, "is_proxy") } -pub fn lookup_country_name(db: &SharedDb, ip: IpAddr) -> Option { - with_reader(db, ip, |result| { - let record: CountryOnly<'_> = result.decode().ok()??; - record.country.names.english.map(str::to_owned) - })? +pub(crate) fn lookup_is_vpn(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_proxy_flag(db, ip, "is_vpn") } -pub fn lookup_city_name(db: &SharedDb, ip: IpAddr) -> Option { - with_reader(db, ip, |result| { - let record: CityOnly<'_> = result.decode().ok()??; - record.city.names.english.map(str::to_owned) - })? +pub(crate) fn lookup_is_hosting(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_proxy_flag(db, ip, "is_hosting") +} + +pub(crate) fn lookup_is_tor(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_proxy_flag(db, ip, "is_tor") +} + +pub fn lookup_asn_number(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_path( + db, + ip, + &[ + PathElement::Key("asn"), + PathElement::Key("autonomous_system_number"), + ], + ) +} + +pub fn lookup_asn_org(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_path( + db, + ip, + &[ + PathElement::Key("asn"), + PathElement::Key("autonomous_system_organization"), + ], + ) +} + +pub fn lookup_country_name(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_path( + db, + ip, + &[ + PathElement::Key("country"), + PathElement::Key("names"), + PathElement::Key("en"), + ], + ) +} + +pub fn lookup_city_name(db: &SharedDb, ip: IpAddr) -> LookupOutcome { + lookup_path( + db, + ip, + &[ + PathElement::Key("city"), + PathElement::Key("names"), + PathElement::Key("en"), + ], + ) } #[cfg(test)] @@ -166,7 +202,7 @@ mod tests { fn lookup_returns_some_for_known_ip() { let shared = test_shared_db(); let ip: IpAddr = "1.1.1.1".parse().unwrap(); - let result = lookup(&shared, ip); + let result = lookup(&shared, ip).unwrap(); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.ip, "1.1.1.1"); @@ -176,7 +212,7 @@ mod tests { fn lookup_returns_none_for_unroutable_ip() { let shared = test_shared_db(); let ip: IpAddr = "0.0.0.0".parse().unwrap(); - let result = lookup(&shared, ip); + let result = lookup(&shared, ip).unwrap(); assert!(result.is_none()); } @@ -184,14 +220,14 @@ mod tests { fn lookup_returns_none_when_db_not_loaded() { let shared = new_empty(); let ip: IpAddr = "1.1.1.1".parse().unwrap(); - assert!(lookup(&shared, ip).is_none()); + assert!(lookup(&shared, ip).unwrap().is_none()); } #[test] fn lookup_proxy_returns_none_for_unroutable_ip() { let shared = test_shared_db(); let ip: IpAddr = "0.0.0.0".parse().unwrap(); - let proxy = lookup_proxy(&shared, ip); + let proxy = lookup_proxy(&shared, ip).unwrap(); assert!(proxy.is_none()); } @@ -199,7 +235,7 @@ mod tests { fn lookup_asn_number_for_known_ip() { let shared = test_shared_db(); let ip: IpAddr = "1.1.1.1".parse().unwrap(); - let asn = lookup_asn_number(&shared, ip); + let asn = lookup_asn_number(&shared, ip).unwrap(); assert_eq!(asn, Some(13335)); } @@ -207,7 +243,7 @@ mod tests { fn lookup_asn_number_returns_none_for_unroutable_ip() { let shared = test_shared_db(); let ip: IpAddr = "0.0.0.0".parse().unwrap(); - let asn = lookup_asn_number(&shared, ip); + let asn = lookup_asn_number(&shared, ip).unwrap(); assert!(asn.is_none()); } @@ -215,7 +251,7 @@ mod tests { fn lookup_asn_org_for_known_ip() { let shared = test_shared_db(); let ip: IpAddr = "1.1.1.1".parse().unwrap(); - let org = lookup_asn_org(&shared, ip); + let org = lookup_asn_org(&shared, ip).unwrap(); assert!(org.is_some()); assert_eq!(org.unwrap(), "Cloudflare, Inc."); } @@ -224,7 +260,7 @@ mod tests { fn lookup_asn_org_returns_none_for_unroutable_ip() { let shared = test_shared_db(); let ip: IpAddr = "0.0.0.0".parse().unwrap(); - let org = lookup_asn_org(&shared, ip); + let org = lookup_asn_org(&shared, ip).unwrap(); assert!(org.is_none()); } @@ -232,7 +268,7 @@ mod tests { fn lookup_country_name_for_known_ip() { let shared = test_shared_db(); let ip: IpAddr = "45.77.77.77".parse().unwrap(); - let country = lookup_country_name(&shared, ip); + let country = lookup_country_name(&shared, ip).unwrap(); assert_eq!(country.as_deref(), Some("United States")); } @@ -240,7 +276,7 @@ mod tests { fn lookup_country_name_returns_none_for_unroutable_ip() { let shared = test_shared_db(); let ip: IpAddr = "0.0.0.0".parse().unwrap(); - let country = lookup_country_name(&shared, ip); + let country = lookup_country_name(&shared, ip).unwrap(); assert!(country.is_none()); } @@ -248,7 +284,7 @@ mod tests { fn lookup_city_name_for_known_ip() { let shared = test_shared_db(); let ip: IpAddr = "45.77.77.77".parse().unwrap(); - let city = lookup_city_name(&shared, ip); + let city = lookup_city_name(&shared, ip).unwrap(); assert_eq!(city.as_deref(), Some("Piscataway")); } @@ -256,7 +292,7 @@ mod tests { fn lookup_city_name_returns_none_for_unroutable_ip() { let shared = test_shared_db(); let ip: IpAddr = "0.0.0.0".parse().unwrap(); - let city = lookup_city_name(&shared, ip); + let city = lookup_city_name(&shared, ip).unwrap(); assert!(city.is_none()); } @@ -264,7 +300,7 @@ mod tests { fn lookup_works_with_ipv6() { let shared = test_shared_db(); let ip: IpAddr = "2606:4700:4700::1111".parse().unwrap(); - let result = lookup(&shared, ip); + let result = lookup(&shared, ip).unwrap(); assert!(result.is_some()); let info = result.unwrap(); assert_eq!(info.ip, "2606:4700:4700::1111"); @@ -279,8 +315,8 @@ mod tests { fn partial_lookups_work_with_ipv6() { let shared = test_shared_db(); let ip: IpAddr = "2606:4700:4700::1111".parse().unwrap(); - assert_eq!(lookup_asn_number(&shared, ip), Some(13335)); - assert!(lookup_asn_org(&shared, ip).is_some()); - assert!(lookup_proxy(&shared, ip).is_some()); + assert_eq!(lookup_asn_number(&shared, ip).unwrap(), Some(13335)); + assert!(lookup_asn_org(&shared, ip).unwrap().is_some()); + assert!(lookup_proxy(&shared, ip).unwrap().is_some()); } } diff --git a/src/handlers/api.rs b/src/handlers/api.rs index 8a705e4..5980bd5 100644 --- a/src/handlers/api.rs +++ b/src/handlers/api.rs @@ -65,27 +65,15 @@ fn field_handler( state: &AppState, headers: &HeaderMap, query: &IpQuery, - lookup: impl FnOnce(&SharedDb, IpAddr) -> Option, + lookup: impl FnOnce(&SharedDb, IpAddr) -> db::LookupOutcome, ) -> Result { + let ip = resolve_ip(headers, query, state.dev_mode)?; if !db::is_ready(&state.db) { return Err(AppError::DbNotReady); } - let ip = resolve_ip(headers, query, state.dev_mode)?; - let value = lookup(&state.db, ip).unwrap_or_default(); - Ok(format!("{value}\n")) -} - -fn proxy_field_handler( - state: &AppState, - headers: &HeaderMap, - query: &IpQuery, - field: impl FnOnce(&crate::models::ProxyInfo) -> bool, -) -> Result { - if !db::is_ready(&state.db) { - return Err(AppError::DbNotReady); - } - let ip = resolve_ip(headers, query, state.dev_mode)?; - let value = db::lookup_proxy(&state.db, ip).is_some_and(|p| field(&p)); + let value = lookup(&state.db, ip) + .map_err(|_| AppError::DbLookupFailed)? + .unwrap_or_default(); Ok(format!("{value}\n")) } @@ -95,7 +83,7 @@ pub async fn asn_handler( Query(query): Query, ) -> Result { field_handler(&state, &headers, &query, |db, ip| { - db::lookup_asn_number(db, ip).map(|n| format!("AS{n}")) + db::lookup_asn_number(db, ip).map(|n| n.map(|n| format!("AS{n}"))) }) } @@ -128,7 +116,7 @@ pub async fn proxy_handler( headers: HeaderMap, Query(query): Query, ) -> Result { - proxy_field_handler(&state, &headers, &query, |p| p.is_proxy) + field_handler(&state, &headers, &query, db::lookup_is_proxy) } pub async fn vpn_handler( @@ -136,7 +124,7 @@ pub async fn vpn_handler( headers: HeaderMap, Query(query): Query, ) -> Result { - proxy_field_handler(&state, &headers, &query, |p| p.is_vpn) + field_handler(&state, &headers, &query, db::lookup_is_vpn) } pub async fn hosting_handler( @@ -144,7 +132,7 @@ pub async fn hosting_handler( headers: HeaderMap, Query(query): Query, ) -> Result { - proxy_field_handler(&state, &headers, &query, |p| p.is_hosting) + field_handler(&state, &headers, &query, db::lookup_is_hosting) } pub async fn tor_handler( @@ -152,5 +140,5 @@ pub async fn tor_handler( headers: HeaderMap, Query(query): Query, ) -> Result { - proxy_field_handler(&state, &headers, &query, |p| p.is_tor) + field_handler(&state, &headers, &query, db::lookup_is_tor) } diff --git a/src/handlers/mod.rs b/src/handlers/mod.rs index b68dee8..ca51d19 100644 --- a/src/handlers/mod.rs +++ b/src/handlers/mod.rs @@ -7,7 +7,7 @@ mod seo; use std::net::IpAddr; use std::sync::Arc; -use axum::http::HeaderMap; +use axum::http::{HeaderMap, header}; use axum::response::{IntoResponse, Response}; use crate::db::{self, SharedDb}; @@ -83,7 +83,9 @@ fn lookup_ip(db: &SharedDb, ip: IpAddr) -> Result { if !db::is_ready(db) { return Err(AppError::DbNotReady); } - db::lookup(db, ip).ok_or(AppError::DbLookupFailed) + db::lookup(db, ip) + .map_err(|_| AppError::DbLookupFailed)? + .ok_or(AppError::IpNotFound) } fn handle_non_browser_request( @@ -118,9 +120,35 @@ fn handle_non_browser_request( fn wants_json(headers: &HeaderMap) -> bool { headers - .get("Accept") + .get(header::ACCEPT) .and_then(|v| v.to_str().ok()) - .is_some_and(|v| v.contains("application/json")) + .is_some_and(accepts_application_json) +} + +fn accepts_application_json(accept: &str) -> bool { + accept.split(',').any(|part| { + let mut pieces = part.split(';'); + let media_type = pieces.next().unwrap_or_default().trim(); + if !media_type.eq_ignore_ascii_case("application/json") { + return false; + } + + let mut quality = 1.0; + for param in pieces { + let param = param.trim(); + if let Some((name, value)) = param.split_once('=') + && name.trim().eq_ignore_ascii_case("q") + { + quality = value + .trim() + .parse::() + .ok() + .filter(|q| (0.0..=1.0).contains(q)) + .unwrap_or(0.0); + } + } + quality > 0.0 + }) } fn append_ip_query(path: &mut String, query: &IpQuery) { diff --git a/src/i18n.rs b/src/i18n.rs index 195ab41..1edb722 100644 --- a/src/i18n.rs +++ b/src/i18n.rs @@ -262,27 +262,43 @@ pub fn negotiate_locale(headers: &HeaderMap) -> Locale { None => return Locale::En, }; - let mut candidates: Vec<(&str, f32)> = Vec::new(); + let mut best_locale = None; + let mut best_quality = 0.0_f32; for part in accept.split(',') { - let part = part.trim(); - if let Some((lang, q_part)) = part.split_once(";q=") { - let quality: f32 = q_part.trim().parse().unwrap_or(0.0); - candidates.push((lang.trim(), quality)); - } else { - candidates.push((part, 1.0)); + let (tag, quality) = parse_accept_language_part(part); + if quality <= 0.0 || quality <= best_quality { + continue; } - } - - candidates.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal)); - - for (tag, _) in &candidates { if let Some(locale) = match_language_tag(tag) { - return locale; + best_locale = Some(locale); + best_quality = quality; } } - Locale::En + best_locale.unwrap_or(Locale::En) +} + +fn parse_accept_language_part(part: &str) -> (&str, f32) { + let mut pieces = part.split(';'); + let tag = pieces.next().unwrap_or_default().trim(); + let mut quality = 1.0; + + for param in pieces { + let param = param.trim(); + if let Some((name, value)) = param.split_once('=') + && name.trim().eq_ignore_ascii_case("q") + { + quality = value + .trim() + .parse::() + .ok() + .filter(|q| (0.0..=1.0).contains(q)) + .unwrap_or(0.0); + } + } + + (tag, quality) } fn match_language_tag(tag: &str) -> Option { @@ -416,6 +432,23 @@ mod tests { assert_eq!(negotiate_locale(&headers), Locale::De); } + #[test] + fn negotiate_locale_ignores_zero_quality() { + let mut headers = HeaderMap::new(); + headers.insert("Accept-Language", "de;q=0,en;q=0.8".parse().unwrap()); + assert_eq!(negotiate_locale(&headers), Locale::En); + } + + #[test] + fn negotiate_locale_accepts_spaced_quality_param() { + let mut headers = HeaderMap::new(); + headers.insert( + "Accept-Language", + "en; q = 0.5, fr; q = 0.8".parse().unwrap(), + ); + assert_eq!(negotiate_locale(&headers), Locale::Fr); + } + #[test] fn negotiate_locale_unknown_falls_back_to_english() { let mut headers = HeaderMap::new(); diff --git a/src/ip_validate.rs b/src/ip_validate.rs index 40d6b33..6c53223 100644 --- a/src/ip_validate.rs +++ b/src/ip_validate.rs @@ -42,7 +42,13 @@ fn is_global_ipv4(ip: Ipv4Addr) -> bool { return false; } - // 192.0.0.0/24 - IETF protocol assignments (RFC 6890) + // 192.0.0.9/32 and 192.0.0.10/32 are globally reachable anycast + // exceptions inside the IETF protocol-assignment block. + if first == 192 && second == 0 && octets[2] == 0 && (octets[3] == 9 || octets[3] == 10) { + return true; + } + + // 192.0.0.0/24 - IETF protocol assignments (RFC 6890), except above. if first == 192 && second == 0 && octets[2] == 0 { return false; } @@ -90,8 +96,8 @@ fn is_global_ipv4(ip: Ipv4Addr) -> bool { /// /// Rejects: unspecified (::), loopback (::1), IPv4-mapped, IPv4-compatible, /// link-local, site-local (deprecated), unique local (ULA), multicast, -/// documentation, discard, Teredo, 6to4, ORCHID, and all other -/// non-globally-routable ranges. +/// documentation, discard, Teredo, 6to4, benchmarking, local-use NAT64, +/// ORCHID, SRv6 SID, and all other non-globally-routable ranges. fn is_global_ipv6(ip: Ipv6Addr) -> bool { // Unspecified address (::) if ip.is_unspecified() { @@ -106,7 +112,7 @@ fn is_global_ipv6(ip: Ipv6Addr) -> bool { let segments = ip.segments(); let first = segments[0]; - // IPv4-mapped (::ffff:0:0/96) - check the embedded IPv4 part + // IPv4-mapped (::ffff:0:0/96) is not globally reachable as IPv6. if first == 0 && segments[1] == 0 && segments[2] == 0 @@ -114,13 +120,7 @@ fn is_global_ipv6(ip: Ipv6Addr) -> bool { && segments[4] == 0 && segments[5] == 0xFFFF { - let ipv4 = Ipv4Addr::new( - (segments[6] >> 8) as u8, - segments[6] as u8, - (segments[7] >> 8) as u8, - segments[7] as u8, - ); - return is_global_ipv4(ipv4); + return false; } // IPv4-compatible (deprecated, ::/96 excluding :: and ::1) @@ -154,38 +154,96 @@ fn is_global_ipv6(ip: Ipv6Addr) -> bool { return false; } + // 64:ff9b::/96 - Well-known IPv4/IPv6 translation prefix. Treat it as + // global only when the embedded IPv4 address is global. + if first == 0x0064 + && segments[1] == 0xFF9B + && segments[2] == 0 + && segments[3] == 0 + && segments[4] == 0 + && segments[5] == 0 + { + return is_global_ipv4(ipv4_from_segments(segments[6], segments[7])); + } + + // 64:ff9b:1::/48 - Local-use IPv4/IPv6 translation prefix. + if first == 0x0064 && segments[1] == 0xFF9B && segments[2] == 1 { + return false; + } + // 100::/64 - Discard prefix (RFC 6666) if first == 0x0100 && segments[1] == 0 && segments[2] == 0 && segments[3] == 0 { return false; } + // 100:0:0:1::/64 - Dummy IPv6 prefix. + if first == 0x0100 && segments[1] == 0 && segments[2] == 0 && segments[3] == 1 { + return false; + } + + // Outside 2000::/3, IPv6 addresses are not global unicast unless handled + // by a globally reachable special-purpose prefix above. + if (first & 0xE000) != 0x2000 { + return false; + } + + // 2001::/23 - IETF protocol assignments. The broad block is not globally + // reachable unless a more specific IANA allocation says it is. + if first == 0x2001 && (segments[1] & 0xFE00) == 0 { + return is_global_2001_special(segments); + } + // 2001:db8::/32 - Documentation (RFC 3849) if first == 0x2001 && segments[1] == 0x0DB8 { return false; } - // 2001::/23 - IETF protocol assignments (RFC 2928) - // This includes 2001::/32 (Teredo) and 2001:10::/28 (ORCHID v2) - // but also encompasses globally routable 2001::/32 allocations. - // We specifically block Teredo (2001:0000::/32) which tunnels arbitrary IPv4. - if first == 0x2001 && segments[1] == 0x0000 { + // 2002::/16 - 6to4 (RFC 3056) + if first == 0x2002 { return false; } - // 2002::/16 - 6to4 (RFC 3056) - check embedded IPv4 for public-ness - if first == 0x2002 { - let ipv4 = Ipv4Addr::new( - (segments[1] >> 8) as u8, - segments[1] as u8, - (segments[2] >> 8) as u8, - segments[2] as u8, - ); - return is_global_ipv4(ipv4); + // 3fff::/20 - Documentation + if first == 0x3FFF && (segments[1] & 0xF000) == 0 { + return false; + } + + // 5f00::/16 - Segment Routing (SRv6) SIDs + if first == 0x5F00 { + return false; } true } +fn ipv4_from_segments(high: u16, low: u16) -> Ipv4Addr { + Ipv4Addr::new((high >> 8) as u8, high as u8, (low >> 8) as u8, low as u8) +} + +fn is_global_2001_special(segments: [u16; 8]) -> bool { + match (segments[1], segments[2]) { + // 2001:1::1/128, 2001:1::2/128, 2001:1::3/128 + (0x0001, 0) + if segments[3] == 0 + && segments[4] == 0 + && segments[5] == 0 + && segments[6] == 0 + && matches!(segments[7], 1..=3) => + { + true + } + // 2001:3::/32 - AMT + (0x0003, _) => true, + // 2001:4:112::/48 - AS112-v6 + (0x0004, 0x0112) => true, + // 2001:20::/28 - ORCHIDv2 + (0x0020..=0x002F, _) => true, + // 2001:30::/28 - Drone Remote ID Protocol Entity Tags + (0x0030..=0x003F, _) => true, + _ => false, + } +} + /// Returns `true` if the IP address is a globally routable public address /// suitable for geolocation lookup. Works for both IPv4 and IPv6. pub fn is_global_ip(ip: IpAddr) -> bool { @@ -323,6 +381,18 @@ mod tests { } } + #[test] + fn ietf_anycast_exceptions_accepted() { + let ips = ["192.0.0.9", "192.0.0.10"]; + for s in ips { + let ip: IpAddr = s.parse().unwrap(); + assert!( + is_global_ip(ip), + "{s} should be accepted (IETF anycast exception)" + ); + } + } + #[test] fn relay_6to4_rejected() { let ips = ["192.88.99.0", "192.88.99.1", "192.88.99.255"]; @@ -366,6 +436,15 @@ mod tests { "2606:4700:4700::1111", "2001:4860:4860::8888", "2400:cb00:2048:1::c629:d7a2", + "64:ff9b::808:808", + "2001:1::1", + "2001:1::2", + "2001:1::3", + "2001:3::1", + "2001:4:112::1", + "2001:20::1", + "2001:30::1", + "2620:4f:8000::1", ]; for s in public_ips { let ip: IpAddr = s.parse().unwrap(); @@ -432,6 +511,9 @@ mod tests { "2001:db8::", "2001:db8::1", "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff", + "3fff::", + "3fff::1", + "3fff:0fff:ffff:ffff:ffff:ffff:ffff:ffff", ]; for s in ips { let ip: IpAddr = s.parse().unwrap(); @@ -454,7 +536,14 @@ mod tests { #[test] fn ipv6_discard_rejected() { - let ips = ["100::", "100::1", "100::ffff:ffff:ffff:ffff"]; + let ips = [ + "100::", + "100::1", + "100::ffff:ffff:ffff:ffff", + "100:0:0:1::", + "100:0:0:1::1", + "100:0:0:1:ffff:ffff:ffff:ffff", + ]; for s in ips { let ip: IpAddr = s.parse().unwrap(); assert!(!is_global_ip(ip), "{s} should be rejected (discard)"); @@ -462,25 +551,18 @@ mod tests { } #[test] - fn ipv6_ipv4_mapped_private_rejected() { + fn ipv6_ipv4_mapped_rejected() { let ips = [ "::ffff:127.0.0.1", "::ffff:10.0.0.1", "::ffff:192.168.1.1", "::ffff:0.0.0.0", + "::ffff:1.1.1.1", + "::ffff:8.8.8.8", ]; for s in ips { let ip: IpAddr = s.parse().unwrap(); - assert!(!is_global_ip(ip), "{s} should be rejected (mapped private)"); - } - } - - #[test] - fn ipv6_ipv4_mapped_public_accepted() { - let ips = ["::ffff:1.1.1.1", "::ffff:8.8.8.8"]; - for s in ips { - let ip: IpAddr = s.parse().unwrap(); - assert!(is_global_ip(ip), "{s} should be accepted (mapped public)"); + assert!(!is_global_ip(ip), "{s} should be rejected (IPv4-mapped)"); } } @@ -507,9 +589,34 @@ mod tests { } #[test] - fn ipv6_6to4_with_public_ipv4_accepted() { + fn ipv6_6to4_with_public_ipv4_rejected() { // 2002:0101:0101:: embeds 1.1.1.1 let ip: IpAddr = "2002:0101:0101::".parse().unwrap(); - assert!(is_global_ip(ip), "6to4 with public IPv4 should be accepted"); + assert!( + !is_global_ip(ip), + "6to4 with public IPv4 should still be rejected" + ); + } + + #[test] + fn ipv6_special_purpose_non_global_rejected() { + let ips = [ + "64:ff9b::10.0.0.1", + "64:ff9b:1::", + "64:ff9b:1::1", + "2001:1::", + "2001:1::4", + "2001:2::1", + "2001:10::1", + "5f00::1", + "4000::1", + ]; + for s in ips { + let ip: IpAddr = s.parse().unwrap(); + assert!( + !is_global_ip(ip), + "{s} should be rejected (special-purpose non-global)" + ); + } } } diff --git a/src/updater.rs b/src/updater.rs index 86981f4..7132a5b 100644 --- a/src/updater.rs +++ b/src/updater.rs @@ -39,8 +39,14 @@ pub async fn init_db( db_path: &Path, update_url: &str, ) -> Result<(), Box> { - ensure_db_exists(db_path, update_url).await?; - let reader = load_db(db_path)?; + let reader = if db_path.exists() { + load_db(db_path)? + } else { + if let Some(parent) = db_path.parent() { + fs::create_dir_all(parent).await?; + } + download_db(update_url, db_path).await? + }; shared_db.store(Arc::new(Some(reader))); info!("database loaded successfully"); Ok(()) diff --git a/tests/integration.rs b/tests/integration.rs index 60b99e1..53a034d 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -24,6 +24,10 @@ fn build_test_app() -> axum::Router { fn build_test_app_with_dev_mode(dev_mode: bool) -> axum::Router { let reader = db::load_db(Path::new(&test_db_path())).expect("failed to load test DB"); let shared_db = db::new_shared(reader); + build_test_app_with_db(shared_db, dev_mode) +} + +fn build_test_app_with_db(shared_db: db::SharedDb, dev_mode: bool) -> axum::Router { let site_domain: std::sync::Arc = "test.example.com".into(); let openapi_json = build_openapi_json(&site_domain); let ipv4_domain: std::sync::Arc = "noipv6.test.example.com".into(); @@ -81,17 +85,7 @@ async fn health_returns_200() { #[tokio::test] async fn health_returns_503_when_db_not_loaded() { let shared_db = db::new_empty(); - let site_domain: std::sync::Arc = "test.example.com".into(); - let openapi_json = build_openapi_json(&site_domain); - let ipv4_domain: std::sync::Arc = "noipv6.test.example.com".into(); - let state = AppState { - db: shared_db, - site_domain, - ipv4_domain, - dev_mode: false, - openapi_json, - }; - let app = build_router(state); + let app = build_test_app_with_db(shared_db, false); let (status, _) = get(&app, "/health").await; assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE); } @@ -239,6 +233,21 @@ async fn accept_json_returns_json() { assert_eq!(json["ip"], "45.77.77.77"); } +#[tokio::test] +async fn accept_json_q_zero_does_not_return_json() { + let app = build_test_app(); + let response = get_response( + &app, + "/", + vec![ + ("Accept", "application/json; q = 0,text/html; q = 1"), + ("CF-Connecting-IP", "45.77.77.77"), + ], + ) + .await; + assert_eq!(response.status(), StatusCode::TEMPORARY_REDIRECT); +} + // The root path for browser requests now redirects to /{lang}/ #[tokio::test] async fn root_redirects_browser_to_lang_path() { @@ -644,6 +653,24 @@ async fn invalid_ip_on_field_endpoints_returns_400() { } } +#[tokio::test] +async fn invalid_ip_on_db_backed_field_endpoints_returns_400_when_db_not_loaded() { + let app = build_test_app_with_db(db::new_empty(), false); + + let endpoints = [ + "/asn", "/org", "/country", "/city", "/proxy", "/vpn", "/hosting", "/tor", + ]; + for endpoint in endpoints { + let uri = format!("{endpoint}?ip=invalid"); + let (status, _) = get(&app, &uri).await; + assert_eq!( + status, + StatusCode::BAD_REQUEST, + "expected validation to run before readiness check for {endpoint}" + ); + } +} + #[tokio::test] async fn field_endpoints_without_ip_or_header_return_400() { let app = build_test_app();