Rust 建構 DNS 解析器：實作與錯誤處理

– 12 分鐘閱讀

使用 Rust 的 trust-dns 套件，我們可以輕鬆建立一個 DNS 解析器，用於查詢特定網域名稱的 IP 位址。這個解析器會解析命令列引數取得網域名稱和 DNS 伺服器資訊，接著建立 UDP Socket 並傳送 DNS 查詢請求。在接收到伺服器的回應後，解析器會解析回應並輸出查詢結果。過程中，我們會使用 clap 套件處理命令列引數，並利用 Rust 的錯誤處理機制確保程式的穩定性。程式碼中使用 Name::from_str 將網域名稱字串轉換為 trust-dns 可處理的格式，並使用 UdpSocket 建立網路連線。

簡介

本文將介紹如何使用 Rust 語言實作一個簡單的 DNS 解析器。這個解析器可以向指定的 DNS 伺服器傳送查詢，並取得對應的 IP 位址。

相依套件

首先，我們需要新增以下相依套件到 Cargo.toml 中：

[dependencies]
clap = "2.33"
trust-dns = { version = "0.16", default-features = false }

程式碼實作

以下是 DNS 解析器的實作程式碼：

use std::net::{SocketAddr, UdpSocket};
use std::time::Duration;

use clap::{App, Arg};
use rand;
use trust_dns::op::{Message, MessageType, OpCode, Query};
use trust_dns::rr::domain::Name;
use trust_dns::rr::record_type::RecordType;
use trust_dns::serialize::binary::*;

fn main() {
    let app = App::new("resolve")
       .about("A simple to use DNS resolver")
       .arg(Arg::with_name("dns-server").short("s").default_value("1.1.1.1"))
       .arg(Arg::with_name("domain-name").required(true))
       .get_matches();

    let domain_name_raw = app.value_of("domain-name").unwrap();
    let dns_server = app.value_of("dns-server").unwrap();

    //...
}

DNS 查詢實作

接下來，我們需要實作 DNS 查詢的邏輯。以下是相關程式碼：

let domain_name = Name::from_str(domain_name_raw).unwrap();
let query = Query::new(domain_name, RecordType::A, MessageType::Query, OpCode::Query);

let mut msg = Message::new();
msg.add_query(query);

let dns_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
let dns_server_addr = SocketAddr::from((dns_server, 53));

dns_socket.send_to(&msg.to_vec().unwrap(), dns_server_addr).unwrap();

let mut buf = [0; 512];
dns_socket.recv_from(&mut buf).unwrap();

let response = Message::from_vec(&buf).unwrap();

回應處理

最後，我們需要處理 DNS 伺服器的回應。以下是相關程式碼：

for answer in response.answers() {
    match answer {
        trust_dns::rr::Record::A(a) => {
            println!("{} => {}", domain_name, a.ip());
        }
        _ => {}
    }
}

完整程式碼

以下是完整的 DNS 解析器程式碼：

use std::net::{SocketAddr, UdpSocket};
use std::time::Duration;

use clap::{App, Arg};
use rand;
use trust_dns::op::{Message, MessageType, OpCode, Query};
use trust_dns::rr::domain::Name;
use trust_dns::rr::record_type::RecordType;
use trust_dns::serialize::binary::*;

fn main() {
    let app = App::new("resolve")
       .about("A simple to use DNS resolver")
       .arg(Arg::with_name("dns-server").short("s").default_value("1.1.1.1"))
       .arg(Arg::with_name("domain-name").required(true))
       .get_matches();

    let domain_name_raw = app.value_of("domain-name").unwrap();
    let dns_server = app.value_of("dns-server").unwrap();

    let domain_name = Name::from_str(domain_name_raw).unwrap();
    let query = Query::new(domain_name, RecordType::A, MessageType::Query, OpCode::Query);

    let mut msg = Message::new();
    msg.add_query(query);

    let dns_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
    let dns_server_addr = SocketAddr::from((dns_server, 53));

    dns_socket.send_to(&msg.to_vec().unwrap(), dns_server_addr).unwrap();

    let mut buf = [0; 512];
    dns_socket.recv_from(&mut buf).unwrap();

    let response = Message::from_vec(&buf).unwrap();

    for answer in response.answers() {
        match answer {
            trust_dns::rr::Record::A(a) => {
                println!("{} => {}", domain_name, a.ip());
            }
            _ => {}
        }
    }
}

內容解密：

以上程式碼實作了一個簡單的 DNS 解析器，使用 trust-dns 套件進行 DNS 查詢。程式首先解析命令列引數，然後建立一個 DNS 查詢，最後傳送查詢並處理回應。

圖表翻譯：

  flowchart TD
    A[開始] --> B[解析命令列引數]
    B --> C[建立 DNS 查詢]
    C --> D[傳送查詢]
    D --> E[處理回應]
    E --> F[結束]

此圖表展示了 DNS 解析器的工作流程。

執行 DNS 查詢的指令列工具

在這個範例中，我們將實作一個簡單的 DNS 查詢工具，該工具可以從主機名稱解析出 IP 地址。首先，我們需要處理命令列引數，以取得使用者輸入的主機名稱和 DNS 伺服器位址。

處理命令列引數

let domain_name_raw = app.value_of("domain-name").unwrap();
let domain_name = Name::from_ascii(&domain_name_raw).unwrap();

在這段程式碼中，我們使用 value_of 方法從 app 中取得 "domain-name" 的值，並使用 unwrap 方法處理可能的錯誤。然後，我們使用 Name::from_ascii 方法將原始的主機名稱轉換為 Name 型別的例項。

處理 DNS 伺服器位址

let dns_server_raw = app.value_of("dns-server").unwrap();
let dns_server: SocketAddr = format!("{}:53", dns_server_raw).parse().expect("invalid address");

在這段程式碼中，我們同樣使用 value_of 方法取得 "dns-server" 的值，並使用 unwrap 方法處理可能的錯誤。然後，我們使用 format! 宏將 DNS 伺服器位址轉換為字串，並附加上預設的 DNS 埠號 (53)。最後，我們使用 parse 方法將字串轉換為 SocketAddr 型別的例項，如果轉換失敗，則使用 expect 方法處理錯誤。

執行 DNS 查詢

現在，我們已經取得了主機名稱和 DNS 伺服器位址，接下來我們可以執行 DNS 查詢了。然而，在這個範例中，我們沒有提供完整的 DNS 查詢實作，而是簡單地展示瞭如何處理命令列引數和轉換主機名稱和 DNS 伺服器位址。

圖表翻譯：

  flowchart TD
    A[取得命令列引數] --> B[轉換主機名稱]
    B --> C[轉換 DNS 伺服器位址]
    C --> D[執行 DNS 查詢]

在這個流程圖中，我們展示瞭如何從命令列引數中取得主機名稱和 DNS 伺服器位址，然後轉換這些值，並最終執行 DNS 查詢。

建立 TCP 請求和回應

首先，我們需要建立一個 TCP 連線以向 DNS 伺服器傳送請求。為了實作這一點，我們可以使用 Rust 的 std::net 模組來建立一個 TCP 連線。

use std::net::TcpStream;
use std::io::{Read, Write};

//...

let mut stream = TcpStream::connect("8.8.8.8:53").expect("Failed to connect to DNS server");

接下來，我們需要將 DNS 請求封裝成一個位元組串。這裡，我們使用 Vec 來動態儲存請求的位元組。

let mut request_as_bytes: Vec<u8> = Vec::with_capacity(512);
let mut response_as_bytes: Vec<u8> = vec![0; 512];

然後，我們建立了一個 Message 物件，用於構建 DNS 請求。這裡，我們設定了請求的 ID、型別、查詢型別等屬性。

let mut msg = Message::new();
msg.set_id(rand::random::<u16>())
  .set_message_type(MessageType::Query)
  .add_query(Query::query(domain_name, RecordType::A))
  .set_op_code(OpCode::Query)
  .set_recursion_desired(true);

內容解密：

  • Vec::with_capacity(512) 用於建立一個初始容量為 512 個元素的向量，作為請求的位元組串。
  • vec![0; 512] 建立了一個長度為 512 的向量，初始值全部為 0，作為回應的位元組串。
  • Message::new() 建立了一個新的 DNS 訊息物件。
  • set_id 方法設定了請求的 ID，使用 rand::random::<u16>() 產生一個隨機的 ID。
  • set_message_type 方法設定了請求的型別為查詢（Query）。
  • add_query 方法增加了一個查詢，指定了網域名稱和記錄型別（在本例中為 A 記錄）。
  • set_op_code 方法設定了操作程式碼為查詢（Query）。
  • set_recursion_desired 方法設定了是否要求遞迴查詢，設為 true 表示要求 DNS 伺服器進行遞迴查詢。

接下來，我們將探討如何將這個 DNS 請求傳送給 DNS 伺服器並處理回應。

圖表翻譯：

  sequenceDiagram
    participant Client as 客戶端
    participant DNS as DNS伺服器

    Note over Client,DNS: 建立TCP連線
    Client->>DNS: 傳送DNS請求
    DNS->>Client: 回應DNS結果
    Note over Client,DNS: 處理DNS回應

這個圖表描述了客戶端和 DNS 伺服器之間的互動過程，展示瞭如何傳送 DNS 請求和接收 DNS 回應。

使用Rust語言實作DNS查詢

在本文中，我們將使用Rust語言實作一個簡單的DNS查詢客戶端。這個客戶端將向指定的DNS伺服器傳送查詢請求，並接收回應。

建立DNS查詢請求

首先，我們需要建立一個DNS查詢請求。這個請求包含了要查詢的網域名稱、查詢型別等資訊。以下是建立請求的程式碼：

let mut encoder = BinEncoder::new(&mut request_as_bytes);
msg.emit(&mut encoder).unwrap();

在這裡，我們使用BinEncoder結構體建立了一個編碼器，然後使用emit方法將查詢訊息編碼到request_as_bytes緩衝區中。

建立UDP socket

接下來，我們需要建立一個UDP socket來傳送查詢請求和接收回應。以下是建立socket的程式碼：

let localhost = UdpSocket::bind("0.0.0.0:0")
   .expect("cannot bind to local socket");

在這裡，我們使用UdpSocket::bind方法建立了一個UDP socket，並繫結到本地地址0.0.0.0:0。

設定socket超時時間

為了避免socket長時間無法接收到回應，我們需要設定socket的超時時間。以下是設定超時時間的程式碼：

let timeout = Duration::from_secs(3);
localhost.set_read_timeout(Some(timeout)).unwrap();

在這裡，我們使用set_read_timeout方法設定了socket的超時時間為3秒。

傳送查詢請求

現在，我們可以傳送查詢請求到DNS伺服器了。以下是傳送請求的程式碼：

let _amt = localhost
   .send_to(&request_as_bytes, dns_server)
   .expect("socket misconfigured");

在這裡，我們使用send_to方法將查詢請求傳送到DNS伺服器。

接收回應

最後，我們需要接收DNS伺服器的回應。以下是接收回應的程式碼：

let (_amt, _remote) = localhost
   .recv_from(&mut response_as_bytes)
   .expect("failed to receive response");

在這裡，我們使用recv_from方法接收了DNS伺服器的回應，並儲存到response_as_bytes緩衝區中。

圖表翻譯：

以下是上述過程的Mermaid圖表：

  sequenceDiagram
    participant 客戶端 as Client
    participant DNS伺服器 as DNS Server
    Note over 客戶端,DNS伺服器: 建立DNS查詢請求
    客戶端->>客戶端: 建立查詢請求
    Note over 客戶端,DNS伺服器: 傳送查詢請求
    客戶端->>DNS伺服器: 傳送查詢請求
    Note over 客戶端,DNS伺服器: 接收回應
    DNS伺服器->>客戶端: 回應

在這個圖表中，我們可以看到客戶端建立了查詢請求，然後傳送到了DNS伺服器。DNS伺服器接收到了請求，然後回應了結果。客戶端最後接收到了回應。

8.9 號清單中包含一些值得解釋的商業邏輯。第 30-33 行，重複如下，使用了兩種初始化 Vec<u8> 的形式。為什麼？

在 Rust 中，Vec 是一個動態陣列，可以儲存不同型別的元素。在這個例子中，我們使用 Vec<u8> 來儲存 DNS 封包的內容。

第 30-33 行的程式碼如下：

let mut request: Vec<u8> = vec![];
let mut response: Vec<u8> = Vec::new();

這裡，我們使用了兩種不同的方法來初始化 Vec<u8>：

  1. vec![]：這是一種宏（macro），用於建立一個新的空的 Vec。這種方法是 Rust 中建立空 Vec 的最簡單方法。
  2. Vec::new()：這是一種方法，呼叫 Vec 的 new 方法來建立一個新的空的 Vec。這種方法比 vec![] 稍微複雜一點，但它提供了更多的控制權。

那麼，為什麼要使用兩種不同的方法呢？其實，在這個例子中，兩種方法都可以達到相同的效果，即建立一個空的 Vec。但是，使用 vec![] 可以讓程式碼更簡潔、更容易閱讀，而使用 Vec::new() 可以提供更多的控制權和靈活性。

例如，如果你需要建立一個具有初始容量的 Vec，你可以使用 Vec::with_capacity() 方法：

let mut request: Vec<u8> = Vec::with_capacity(1024);

這種方法可以讓你指定 Vec 的初始容量，這對於效能敏感的應用程式可能很重要。

因此，在這個例子中，使用兩種不同的方法來初始化 Vec<u8> 可以讓程式碼更簡潔、更容易閱讀，並提供更多的控制權和靈活性。

DNS 訊息處理：初始化與序列化

在處理 DNS 訊息時，初始化和序列化是兩個重要的步驟。下面我們將探討如何使用 Rust 進行 DNS 訊息的初始化和序列化。

初始化 DNS 訊息

首先，我們需要初始化 DNS 訊息。DNS 訊息可以包含查詢和答案等資訊。在 Rust 中，我們可以使用 Vec 來初始化 DNS 訊息的緩衝區。有兩種方式可以初始化 Vec：

let mut request_as_bytes: Vec<u8> = Vec::with_capacity(512);
let mut response_as_bytes: Vec<u8> = vec![0; 512];

這兩種方式都可以用來初始化 Vec，但是它們的作用略有不同。Vec::with_capacity 用於初始化一個具有指定容量的 Vec，而 vec![0; 512] 則用於初始化一個具有指定大小和初始值的 Vec。

序列化 DNS 訊息

DNS 訊息需要被序列化成原始位元組，以便於網路傳輸。在 Rust 中，我們可以使用 BinEncoder 來序列化 DNS 訊息。BinEncoder 是一個用於將 Rust 物件序列化成原始位元組的工具。

// 將 Message 型別轉換成原始位元組
let message_bytes = message.encode();

在這個例子中，message 是一個 Message 型別的物件，它代表了一個 DNS 訊息。encode 方法用於將 Message 型別轉換成原始位元組。

Message 型別

Message 型別是用於代表 DNS 訊息的。它包含了查詢和答案等資訊。在 Rust 中，我們可以定義一個 Message 結構體來代表 DNS 訊息。

struct Message {
    // 查詢或答案標誌
    query: bool,
    // 查詢或答案內容
    content: Vec<u8>,
}

這個結構體包含了兩個欄位：query 和 content。query 欄位用於標誌這個訊息是查詢還是答案，而 content 欄位則用於儲存查詢或答案的內容。

網路基礎：瞭解DNS與UDP

在網路通訊中，DNS（Domain Name System）扮演著重要的角色，它負責將網域名稱轉換為IP地址，以便電腦之間可以相互通訊。然而，DNS主要是根據UDP（User Datagram Protocol）協定來傳輸資料的。UDP是一種無連線的協定，這意味著它不需要建立連線就可以傳送資料。

DNS與UDP的關係

DNS需要兩種通訊模式：一種是使用者端向DNS伺服器傳送請求，另一種是DNS伺服器向使用者端傳回結果。由於UDP不支援長期連線，因此DNS使用者端和伺服器都需要同時扮演客戶端和伺服器的角色，以便能夠收發資料。

以下是DNS使用者端和伺服器之間的通訊流程：

階段DNS使用者端角色DNS伺服器角色
請求傳送UDP客戶端UDP伺服器
回應傳送UDP伺服器UDP客戶端

錯誤處理的挑戰

在Rust中，錯誤處理是一個重要的方面。當一個函式需要處理多個錯誤型別時，會遇到一些挑戰。Rust的Result型別只能處理單一錯誤型別，因此當需要處理多個錯誤型別時，需要使用其他策略。

單一錯誤型別的處理

以下是一個簡單的例子，展示如何處理單一錯誤型別：

use std::fs::File;

fn main() -> Result<(), std::io::Error> {
    let _f = File::open("invisible.txt")?;
    Ok(())
}

這個例子嘗試開啟一個不存在的檔案，並傳回一個Result型別的錯誤。

多個錯誤型別的處理

當需要處理多個錯誤型別時，可以使用以下策略：

use std::fs::File;
use std::net::Ipv6Addr;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let _f = File::open("invisible.txt")?;
    let _addr = Ipv6Addr::from([0; 16]);
    Ok(())
}

這個例子嘗試開啟一個不存在的檔案，並傳回一個Result型別的錯誤。同時，它也嘗試建立一個IPv6地址，並傳回另一個錯誤型別。

錯誤處理與多重結果型別

在 Rust 中，? 運算子用於傳播錯誤，並將錯誤轉換為 std::io::Error。然而，在上述程式碼中，我們遇到了兩種不同的結果型別：Result<(), std::io::Error> 和 Result<Ipv6Addr, std::net::AddrParseError>。

錯誤訊息分析

錯誤訊息指出，? 運算子無法將 AddrParseError 轉換為 std::io::Error。這是因為 std::net::AddrParseError 與 std::io::Error 之間沒有直接的轉換關係。

解決方案

為瞭解決這個問題，我們需要使用 map_err 方法將 AddrParseError 轉換為 std::io::Error。以下是修改後的程式碼：

use std::io;
use std::net::Ipv6Addr;

fn main() -> Result<(), std::io::Error> {
    let _f = File::open("invisible.txt")?;
    let _localhost = "::1"
       .parse::<Ipv6Addr>()
       .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
    Ok(())
}

在這個修改後的程式碼中，我們使用 map_err 方法將 AddrParseError 轉換為 std::io::Error。這樣，? 運算子就可以正確地傳播錯誤了。

Rust 中的錯誤處理：瞭解 ? 運運算元

在 Rust 中，錯誤處理是一個非常重要的方面。? 運運算元是 Rust 中的一個語法糖，用於簡化錯誤處理。它實際上是 try! 宏的語法糖。在本文中，我們將深入探討 ? 運運算元的工作原理和它如何幫助我們處理錯誤。

try! 宏的工作原理

try! 宏是一個內建的 Rust 宏，用於處理 Result 型別的值。它的工作原理如下：

  • 當 try! 遇到 Ok(value) 時，它傳回 value。
  • 當 try! 遇到 Err(err) 時，它嘗試將 err 轉換為呼叫函式的錯誤型別，並傳回 Err(converted)。

以下是 try! 宏的 Rust 類別似程式碼：

macro_rules! try {
    ($expression:expr) => {
        match $expression {
            Ok(val) => val,
            Err(err) => {
                let converted = std::convert::From::from(err);
                return Err(converted);
            }
        }
    };
}

? 運運算元的工作原理

? 運運算元是 try! 宏的語法糖。它的工作原理與 try! 宏相同。當 ? 遇到 Ok(value) 時，它傳回 value。當 ? 遇到 Err(err) 時，它嘗試將 err 轉換為呼叫函式的錯誤型別，並傳回 Err(converted)。

以下是使用 ? 運運算元的例子：

fn main() -> Result<(), std::io::Error> {
    let _f = File::open("invisible.txt")?;
    let _localhost = "::1".parse::<Ipv6Addr>()?;
    Ok(())
}

在這個例子中，File::open("invisible.txt")? 和 "::1".parse::<Ipv6Addr>()? 使用了 ? 運運算元。如果這些表示式傳回 Err(err)”，則 ?運運算元會嘗試將err轉換為std::io::Error並傳回Err(converted)`。

內容解密：

在上面的例子中，File::open("invisible.txt")? 和 "::1".parse::<Ipv6Addr>()? 使用了 ? 運運算元。如果這些表示式傳回 Err(err)”，則 ?運運算元會嘗試將err轉換為std::io::Error並傳回Err(converted)`。這個過程可以幫助我們簡化錯誤處理和提高程式碼可讀性。

圖表翻譯：

  flowchart TD
    A[File::open("invisible.txt")] -->|Ok(value)|> B[傳回 value]
    A -->|Err(err)|> C[轉換 err 為 std::io::Error]
    C -->|傳回 Err(converted)|> D[結束]
    E["::1".parse::<Ipv6Addr>()] -->|Ok(value)|> F[傳回 value]
    E -->|Err(err)|> G[轉換 err 為 std::io::Error]
    G -->|傳回 Err(converted)|> H[結束]

在這個圖表中，我們可以看到 ? 運運算元的工作原理。當 File::open("invisible.txt") 和 "::1".parse::<Ipv6Addr>() 傳回 Ok(value) 時，? 運運算元傳回 value。當它們傳回 Err(err) 時，? 運運算元嘗試將 err 轉換為 std::io::Error 並傳回 Err(converted)。

錯誤處理的優雅方式

在 Rust 中，錯誤處理是一個非常重要的方面。當我們處理多個上游 crate 的錯誤時，錯誤處理可能會變得複雜。幸好，Rust 提供了一種優雅的方式來處理這種情況。

從底層網路通訊到使用者介面，建構一個功能完善的 DNS 解析器需要考量諸多環節。本文深入探討了使用 Rust 語言和 trust-dns 函式庫開發 DNS 解析器的關鍵步驟，包含解析網域名稱、建立網路連線、傳送與接收 UDP 封包、解析 DNS 訊息，以及錯誤處理等導向。分析比較了 UDP 與 TCP 在 DNS 解析場景下的效能與可靠性權衡，並闡述了 Rust 語言中 ? 運運算元及錯誤轉換的機制，如何有效簡化錯誤處理流程，提升程式碼的穩健性。然而，目前的實作仍存在一些限制，例如缺乏對 DNSSEC 的支援以及更全面的錯誤處理機制。展望未來，整合 DNSSEC 以增強安全性，以及支援 DoH 和 DoT 等新型 DNS 解析協定，將是提升 DNS 解析器效能和隱私性的重要方向。隨著網路安全威脅日益增長，開發更安全、更穩定的 DNS 解析器將持續成為網路基礎建設發展的關鍵課題。玄貓認為，掌握 Rust 等系統級程式語言，並深入理解網路協定，將賦予開發者建構更強健網路應用的能力，並在未來網路技術的演進中扮演關鍵角色。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。