Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
1.9 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use reqwest::dns::{Addrs, Name, Resolve, Resolving};
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use tokio::net::lookup_host;

type ResolveError = Box<dyn std::error::Error + Send + Sync>;

pub const BLOCKED_ADDRESS_ERROR: &str = "host resolved into blocked address space";

pub struct PublicOnlyResolver {
    private_hosts: Arc<[String]>,
}

impl PublicOnlyResolver {
    pub fn new(private_hosts: &[String]) -> Self {
        Self {
            private_hosts: private_hosts.into(),
        }
    }
}

impl Resolve for PublicOnlyResolver {
    fn resolve(&self, name: Name) -> Resolving {
        let host = name.as_str().to_owned();
        let allow_private = is_private_host(&host, &self.private_hosts);
        Box::pin(async move {
            let resolved: Vec<SocketAddr> = lookup_host((host.as_str(), 0)).await?.collect();
            screen(resolved, allow_private)
        })
    }
}

pub fn is_private_host(host: &str, private_hosts: &[String]) -> bool {
    let host = host.strip_suffix('.').unwrap_or(host);
    private_hosts
        .iter()
        .any(|private| private.eq_ignore_ascii_case(host))
}

fn screen(resolved: Vec<SocketAddr>, allow_private: bool) -> Result<Addrs, ResolveError> {
    if resolved.is_empty() {
        return Err("host resolved to no addresses".into());
    }
    if !allow_private && resolved.iter().any(|addr| is_blocked(addr.ip())) {
        return Err(BLOCKED_ADDRESS_ERROR.into());
    }
    Ok(Box::new(resolved.into_iter()))
}

pub fn is_blocked(ip: IpAddr) -> bool {
    !fluxer_common::public_ip::is_public_ip(ip)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn lan_address() -> Vec<SocketAddr> {
        vec![SocketAddr::from(([192, 168, 1, 20], 0))]
    }

    #[test]
    fn a_private_address_is_refused_by_default() {
        let error = screen(lan_address(), false).err().unwrap();
        assert_eq!(error.to_string(), BLOCKED_ADDRESS_ERROR);
    }
}