Dns

clash-dns/Cargo.toml

@@ -13,5 +13,6 @@ futures = "0.3"
 async-trait = "0.1"
 
 hickory-server = { version = "0.25", default-features = false }
+hickory-proto = "0.25"
 tokio = { version = "1", features = ["full"] }
 tracing = "0.1"

clash-dns/src/handler.rs

@@ -3,9 +3,11 @@ use std::time::Duration;
 use crate::utils::new_io_error;
 use crate::{DNSListenAddr, DnsMessageExchanger};
 use async_trait::async_trait;
+use hickory_proto::op::{Header, Message, ResponseCode};
 use hickory_server::server::Request;
 use hickory_server::{
     ServerFuture,
+    authority::MessageResponseBuilder,
     server::{RequestHandler, ResponseHandler, ResponseInfo},
 };
 use thiserror::Error;
@@ -24,10 +26,10 @@ struct DnsHandler<X> {
 pub enum DNSError {
     #[error(transparent)]
     Io(#[from] std::io::Error),
-    /* #[error("invalid OP code: {0}")]
+    #[error("invalid OP query: {0}")]
     InvalidOpQuery(String),
     #[error("query failed: {0}")]
-    QueryFailed(String), */
+    QueryFailed(String),
 }
 
 #[async_trait]
@@ -38,9 +40,44 @@ where
     async fn handle_request<H: ResponseHandler>(
         &self,
         request: &Request,
-        response_handle: H,
+        mut response_handle: H,
     ) -> ResponseInfo {
-        todo!()
+        let req = match to_dns_message(request) {
+            Ok(req) => req,
+            Err(err) => {
+                error!("failed to parse dns request: {}", err);
+                return servfail_info();
+            }
+        };
+
+        let resp = match self.exchanger.exchange(&req).await {
+            Ok(resp) => resp,
+            Err(err) => {
+                warn!("dns exchange failed: {}", err);
+                build_servfail_message(&req)
+            }
+        };
+
+        let mut builder = MessageResponseBuilder::from_message_request(request);
+        if let Some(edns) = resp.extensions().clone() {
+            builder.edns(edns);
+        }
+
+        let response = builder.build(
+            resp.header().clone(),
+            resp.answers(),
+            resp.name_servers(),
+            std::iter::empty::<&hickory_proto::rr::Record>(),
+            resp.additionals(),
+        );
+
+        match response_handle.send_response(response).await {
+            Ok(info) => info,
+            Err(err) => {
+                error!("failed to send dns response: {}", err);
+                servfail_info()
+            }
+        }
     }
 }
 
@@ -84,15 +121,18 @@ where
             .is_ok();
     }
     if let Some(c) = listen.doh {
-        todo!()
+        let _ = c;
+        warn!("DoH listener is not implemented yet");
     }
 
     if let Some(c) = listen.dot {
-        todo!()
+        let _ = c;
+        warn!("DoT listener is not implemented yet");
     }
 
     if let Some(c) = listen.doh3 {
-        todo!()
+        let _ = c;
+        warn!("DoH3 listener is not implemented yet");
     }
 
     if !has_server {
@@ -109,3 +149,53 @@ where
         })
     }))
 }
+
+fn to_dns_message(request: &Request) -> Result<Message, DNSError> {
+    let mut message = Message::new();
+    message.set_id(request.id());
+    message.set_op_code(request.op_code());
+    message.set_message_type(request.message_type());
+    message.set_authoritative(request.authoritative());
+    message.set_truncated(request.truncated());
+    message.set_recursion_desired(request.recursion_desired());
+    message.set_recursion_available(request.recursion_available());
+    message.set_authentic_data(request.authentic_data());
+    message.set_checking_disabled(request.checking_disabled());
+    message.set_response_code(request.response_code());
+    message.add_queries(request.queries().iter().map(|q| q.original().clone()));
+    message.add_answers(request.answers().iter().cloned());
+    message.add_name_servers(request.name_servers().iter().cloned());
+    message.add_additionals(request.additionals().iter().cloned());
+    if let Some(edns) = request.edns().cloned() {
+        message.set_edns(edns);
+    }
+    Ok(message)
+}
+
+fn build_servfail_message(req: &Message) -> Message {
+    let mut header = Header::response_from_request(req.header());
+    header.set_response_code(ResponseCode::ServFail);
+
+    let mut message = Message::new();
+    message.set_id(header.id());
+    message.set_message_type(header.message_type());
+    message.set_op_code(header.op_code());
+    message.set_authoritative(header.authoritative());
+    message.set_truncated(header.truncated());
+    message.set_recursion_desired(header.recursion_desired());
+    message.set_recursion_available(header.recursion_available());
+    message.set_authentic_data(header.authentic_data());
+    message.set_checking_disabled(header.checking_disabled());
+    message.set_response_code(header.response_code());
+    message.add_queries(req.queries().iter().cloned());
+    if let Some(edns) = req.extensions().clone() {
+        message.set_edns(edns);
+    }
+    message
+}
+
+fn servfail_info() -> ResponseInfo {
+    let mut header = Header::new();
+    header.set_response_code(ResponseCode::ServFail);
+    header.into()
+}

clash-dns/src/lib.rs

@@ -1,5 +1,8 @@
 use std::{net::SocketAddr, path::Path};
 
+use async_trait::async_trait;
+use hickory_proto::op::Message;
+
 mod handler;
 
 mod utils;
@@ -26,7 +29,8 @@ pub struct DNSListenAddr {
     pub doh3: Option<DoH3Config>,
 }
 
+#[async_trait]
 pub trait DnsMessageExchanger: Send + Sync {
     fn ipv6(&self) -> bool;
-    // async fn exchange(&self, message: &Message) -> Result<Message, DNSError>;
+    async fn exchange(&self, message: &Message) -> Result<Message, DNSError>;
 }

clash-lib/Cargo.toml

@@ -37,8 +37,10 @@ h3-quinn = { version = "0.0.10", optional = true }
 quinn-proto = { version = "0.11.13", default-features = false, optional = true }
 maxminddb = "0.27"
 hickory-proto = "0.25"
-url = { version = "2", optional = true }
+hickory-resolver = { version = "0.25", features = ["tokio", "system-config", "webpki-roots", "tls-aws-lc-rs", "https-aws-lc-rs"] }
+url = { version = "2" }
 ipnet = { version = "2" }
+lru_time_cache = "0.11"
 network-interface = { version = "2", optional = true }
 
 serde = { version = "1", features = ["derive"] }
@@ -154,7 +156,7 @@ tun = [
     "dep:watfaq-netstack",
     "dep:smoltcp",
     "dep:network-interface",
-    "dep:url",
+    # "dep:url",
 ]
 tproxy = ["dep:etherparse"]
 redir = []

clash-lib/src/app/dispatcher/dispatcher_impl.rs

@@ -1,7 +1,7 @@
 use std::{fmt, sync::Arc, time::Duration};
 
 use tokio::{io::AsyncWriteExt, sync::RwLock};
-use tracing::{Instrument, debug, info_span, instrument, trace, warn};
+use tracing::{Instrument, debug, error, info_span, instrument, trace, warn};
 use tracing_log::log;
 
 use crate::{
@@ -228,7 +228,31 @@ async fn reverse_lookup(
 ) -> Option<SocksAddr> {
     let dst = match dst {
         crate::session::SocksAddr::Ip(socket_addr) => {
-            todo!()
+            if resolver.fake_ip_enabled() {
+                let ip = socket_addr.ip();
+                if resolver.is_fake_ip(ip).await {
+                    trace!("looking up fake ip: {}", socket_addr.ip());
+                    match resolver.reverse_lookup(ip).await {
+                        Some(host) => (host, socket_addr.port())
+                            .try_into()
+                            .expect("must be valid domain"),
+                        None => {
+                            error!("failed to reverse lookup fake ip: {}", ip);
+                            return None;
+                        }
+                    }
+                } else {
+                    (*socket_addr).into()
+                }
+            } else {
+                trace!("looking up resolve cache ip: {}", socket_addr.ip());
+                match resolver.cached_for(socket_addr.ip()).await {
+                    Some(host) => (host, socket_addr.port())
+                        .try_into()
+                        .expect("must be valid domain"),
+                    None => (*socket_addr).into(),
+                }
+            }
         }
         crate::session::SocksAddr::Domain(host, port) => (host.to_owned(), *port)
             .try_into()