mirror of
https://github.com/NetworkCats/rustyip.git
synced 2026-11-17 08:16:04 +00:00
Fix IP validation and MMDB lookup handling
This commit is contained in:
@@ -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<Vec<u8>>;
|
||||
pub type SharedDb = Arc<ArcSwap<Option<DbReader>>>;
|
||||
pub type LookupOutcome<T> = Result<Option<T>, MaxMindDbError>;
|
||||
|
||||
pub fn load_db(path: &Path) -> Result<DbReader, maxminddb::MaxMindDbError> {
|
||||
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<IpInfo> {
|
||||
pub fn lookup(db: &SharedDb, ip: IpAddr) -> LookupOutcome<IpInfo> {
|
||||
with_reader(db, ip, |result| {
|
||||
let record: MmdbRecord<'_> = result.decode().ok()??;
|
||||
Some(from_mmdb_record(ip, &record))
|
||||
})?
|
||||
let Some(record) = result.decode::<MmdbRecord<'_>>()? 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<R>(
|
||||
/// while preserving lookup/decode errors for callers that need HTTP error mapping.
|
||||
fn with_reader<T>(
|
||||
db: &SharedDb,
|
||||
ip: IpAddr,
|
||||
f: impl FnOnce(maxminddb::LookupResult<'_, Vec<u8>>) -> R,
|
||||
) -> Option<R> {
|
||||
f: impl FnOnce(maxminddb::LookupResult<'_, Vec<u8>>) -> LookupOutcome<T>,
|
||||
) -> LookupOutcome<T> {
|
||||
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<T>(db: &SharedDb, ip: IpAddr, path: &[PathElement<'_>]) -> LookupOutcome<T>
|
||||
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<ProxyInfo> {
|
||||
pub fn lookup_proxy(db: &SharedDb, ip: IpAddr) -> LookupOutcome<ProxyInfo> {
|
||||
with_reader(db, ip, |result| {
|
||||
let record: ProxyOnly = result.decode().ok()??;
|
||||
Some(record.proxy.into())
|
||||
})?
|
||||
let Some(record) = result.decode::<ProxyOnly>()? else {
|
||||
return Ok(None);
|
||||
};
|
||||
Ok(Some(record.proxy.into()))
|
||||
})
|
||||
}
|
||||
|
||||
pub fn lookup_asn_number(db: &SharedDb, ip: IpAddr) -> Option<u32> {
|
||||
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<bool> {
|
||||
lookup_path(
|
||||
db,
|
||||
ip,
|
||||
&[PathElement::Key("proxy"), PathElement::Key(field)],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn lookup_asn_org(db: &SharedDb, ip: IpAddr) -> Option<String> {
|
||||
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<bool> {
|
||||
lookup_proxy_flag(db, ip, "is_proxy")
|
||||
}
|
||||
|
||||
pub fn lookup_country_name(db: &SharedDb, ip: IpAddr) -> Option<String> {
|
||||
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<bool> {
|
||||
lookup_proxy_flag(db, ip, "is_vpn")
|
||||
}
|
||||
|
||||
pub fn lookup_city_name(db: &SharedDb, ip: IpAddr) -> Option<String> {
|
||||
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<bool> {
|
||||
lookup_proxy_flag(db, ip, "is_hosting")
|
||||
}
|
||||
|
||||
pub(crate) fn lookup_is_tor(db: &SharedDb, ip: IpAddr) -> LookupOutcome<bool> {
|
||||
lookup_proxy_flag(db, ip, "is_tor")
|
||||
}
|
||||
|
||||
pub fn lookup_asn_number(db: &SharedDb, ip: IpAddr) -> LookupOutcome<u32> {
|
||||
lookup_path(
|
||||
db,
|
||||
ip,
|
||||
&[
|
||||
PathElement::Key("asn"),
|
||||
PathElement::Key("autonomous_system_number"),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn lookup_asn_org(db: &SharedDb, ip: IpAddr) -> LookupOutcome<String> {
|
||||
lookup_path(
|
||||
db,
|
||||
ip,
|
||||
&[
|
||||
PathElement::Key("asn"),
|
||||
PathElement::Key("autonomous_system_organization"),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn lookup_country_name(db: &SharedDb, ip: IpAddr) -> LookupOutcome<String> {
|
||||
lookup_path(
|
||||
db,
|
||||
ip,
|
||||
&[
|
||||
PathElement::Key("country"),
|
||||
PathElement::Key("names"),
|
||||
PathElement::Key("en"),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
pub fn lookup_city_name(db: &SharedDb, ip: IpAddr) -> LookupOutcome<String> {
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
+10
-22
@@ -65,27 +65,15 @@ fn field_handler<T: std::fmt::Display + Default>(
|
||||
state: &AppState,
|
||||
headers: &HeaderMap,
|
||||
query: &IpQuery,
|
||||
lookup: impl FnOnce(&SharedDb, IpAddr) -> Option<T>,
|
||||
lookup: impl FnOnce(&SharedDb, IpAddr) -> db::LookupOutcome<T>,
|
||||
) -> Result<String, AppError> {
|
||||
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<String, AppError> {
|
||||
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<IpQuery>,
|
||||
) -> Result<String, AppError> {
|
||||
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<IpQuery>,
|
||||
) -> Result<String, AppError> {
|
||||
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<IpQuery>,
|
||||
) -> Result<String, AppError> {
|
||||
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<IpQuery>,
|
||||
) -> Result<String, AppError> {
|
||||
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<IpQuery>,
|
||||
) -> Result<String, AppError> {
|
||||
proxy_field_handler(&state, &headers, &query, |p| p.is_tor)
|
||||
field_handler(&state, &headers, &query, db::lookup_is_tor)
|
||||
}
|
||||
|
||||
+32
-4
@@ -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<IpInfo, AppError> {
|
||||
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::<f32>()
|
||||
.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) {
|
||||
|
||||
+47
-14
@@ -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::<f32>()
|
||||
.ok()
|
||||
.filter(|q| (0.0..=1.0).contains(q))
|
||||
.unwrap_or(0.0);
|
||||
}
|
||||
}
|
||||
|
||||
(tag, quality)
|
||||
}
|
||||
|
||||
fn match_language_tag(tag: &str) -> Option<Locale> {
|
||||
@@ -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();
|
||||
|
||||
+146
-39
@@ -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)"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+8
-2
@@ -39,8 +39,14 @@ pub async fn init_db(
|
||||
db_path: &Path,
|
||||
update_url: &str,
|
||||
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
||||
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(())
|
||||
|
||||
+38
-11
@@ -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<str> = "test.example.com".into();
|
||||
let openapi_json = build_openapi_json(&site_domain);
|
||||
let ipv4_domain: std::sync::Arc<str> = "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<str> = "test.example.com".into();
|
||||
let openapi_json = build_openapi_json(&site_domain);
|
||||
let ipv4_domain: std::sync::Arc<str> = "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();
|
||||
|
||||
Reference in New Issue
Block a user