Viết một VPN đơn giản sử dụng Rust

Viết một VPN (Virtual Private Network) từ đầu là một nhiệm vụ khá phức tạp, đòi hỏi sự hiểu biết sâu về mạng, bảo mật, giao thức truyền thông, và mã hóa. Tuy nhiên, tôi sẽ hướng dẫn bạn cách xây dựng một VPN đơn giản bằng Rust, sử dụng giao thức như WireGuard hoặc một cơ chế tunneling cơ bản. Ở đây, tôi sẽ tập trung vào việc tạo một VPN tunneling đơn giản với TCP để bạn có thể bắt đầu.

Tổng quan

Chúng ta sẽ xây dựng một VPN với hai thành phần chính:

VPN Server: Chạy trên một máy chủ và lắng nghe kết nối từ client.
VPN Client: Kết nối đến server và tạo một đường hầm (tunnel) để truyền dữ liệu.

Dữ liệu sẽ được mã hóa trước khi gửi qua đường hầm để đảm bảo bảo mật. Chúng ta sẽ sử dụng Rust và một số thư viện cơ bản như tokio (cho xử lý bất đồng bộ), tun-tap (để tạo giao diện mạng ảo), và aes-gcm (cho mã hóa).

Bước 1: Chuẩn bị môi trường

Cài đặt Rust: Nếu bạn chưa cài Rust, hãy cài qua lệnh:
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
Thêm các thư viện cần thiết vào dự án:
Tạo một dự án mới bằng lệnh:
```
cargo new simple_vpn
cd simple_vpn
```
Chỉnh sửa file Cargo.toml để thêm các dependency:
```
[dependencies]
tokio = { version = "1.0", features = ["full"] }
tun-tap = "0.1"
aes-gcm = "0.10"
rand = "0.8"
```

Bước 2: Thiết kế VPN cơ bản

2.1. VPN Server

VPN server sẽ:

Lắng nghe kết nối từ client qua TCP.
Tạo một giao diện TUN để gửi/nhận gói tin từ mạng.
Mã hóa và giải mã dữ liệu trước khi gửi qua đường hầm.

Dưới đây là mã cơ bản cho server:

use aes_gcm::{
    aead::{Aead, KeyInit},
    Aes256Gcm, Nonce,
};
use rand::Rng;
use std::net::{IpAddr, Ipv4Addr};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tun_tap::{Iface, Mode};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Tạo giao diện TUN
    let iface = Iface::new("tun0", Mode::Tun)?;
    println!("TUN interface created: {}", iface.name());

    // Cấu hình địa chỉ IP cho giao diện TUN
    // (Bạn cần cấu hình thủ công trên hệ điều hành hoặc dùng lệnh `ifconfig`/`ip`)
    let ip = Ipv4Addr::new(10, 0, 0, 1);
    println!("Set IP for tun0 to {}", ip);

    // Khóa mã hóa (256-bit key cho AES-GCM)
    let key = Aes256Gcm::generate_key(&mut rand::thread_rng());
    let cipher = Aes256Gcm::new(&key);

    // Lắng nghe trên cổng 8080
    let listener = TcpListener::bind("0.0.0.0:8080").await?;
    println!("VPN Server listening on 0.0.0.0:8080");

    loop {
        let (socket, addr) = listener.accept().await?;
        println!("New client connected: {}", addr);

        // Xử lý client trong một task riêng
        let iface = iface.clone();
        let cipher = cipher.clone();
        tokio::spawn(async move {
            handle_client(socket, iface, cipher).await.unwrap_or_else(|e| {
                eprintln!("Error handling client {}: {}", addr, e);
            });
        });
    }
}

async fn handle_client(
    mut socket: TcpStream,
    mut iface: Iface,
    cipher: Aes256Gcm,
) -> Result<(), Box<dyn std::error::Error>> {
    let mut tun_buf = [0u8; 1500]; // Buffer cho gói tin từ TUN
    let mut socket_buf = [0u8; 1500]; // Buffer cho dữ liệu từ socket

    loop {
        tokio::select! {
            // Đọc từ giao diện TUN và gửi đến client
            Ok(n) = iface.recv(&mut tun_buf) => {
                let nonce = Nonce::from_slice(&rand::thread_rng().gen::<[u8; 12]>());
                let encrypted = cipher.encrypt(nonce, &tun_buf[..n]).unwrap();
                socket.write_all(&nonce).await?;
                socket.write_all(&encrypted).await?;
            }

            // Đọc từ client và gửi đến giao diện TUN
            Ok(n) = socket.read(&mut socket_buf) => {
                if n == 0 {
                    break; // Client ngắt kết nối
                }
                // Giả sử dữ liệu từ client đã được mã hóa
                let nonce = Nonce::from_slice(&socket_buf[..12]);
                let decrypted = cipher.decrypt(nonce, &socket_buf[12..n]).unwrap();
                iface.send(&decrypted)?;
            }
        }
    }
    Ok(())
}

2.2. VPN Client

VPN client sẽ:

Kết nối đến server qua TCP.
Tạo giao diện TUN trên máy client.
Chuyển tiếp gói tin qua đường hầm đến server.

Dưới đây là mã cơ bản cho client:

use aes_gcm::{
    aead::{Aead, KeyInit},
    Aes256Gcm, Nonce,
};
use rand::Rng;
use std::net::Ipv4Addr;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tun_tap::{Iface, Mode};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Tạo giao diện TUN
    let iface = Iface::new("tun1", Mode::Tun)?;
    println!("TUN interface created: {}", iface.name());

    // Cấu hình địa chỉ IP cho giao diện TUN
    let ip = Ipv4Addr::new(10, 0, 0, 2);
    println!("Set IP for tun1 to {}", ip);

    // Khóa mã hóa (phải giống với server)
    let key = Aes256Gcm::generate_key(&mut rand::thread_rng());
    let cipher = Aes256Gcm::new(&key);

    // Kết nối đến server
    let mut socket = TcpStream::connect("127.0.0.1:8080").await?;
    println!("Connected to VPN server");

    let mut tun_buf = [0u8; 1500];
    let mut socket_buf = [0u8; 1500];

    loop {
        tokio::select! {
            // Đọc từ giao diện TUN và gửi đến server
            Ok(n) = iface.recv(&mut tun_buf) => {
                let nonce = Nonce::from_slice(&rand::thread_rng().gen::<[u8; 12]>());
                let encrypted = cipher.encrypt(nonce, &tun_buf[..n]).unwrap();
                socket.write_all(&nonce).await?;
                socket.write_all(&encrypted).await?;
            }

            // Đọc từ server và gửi đến giao diện TUN
            Ok(n) = socket.read(&mut socket_buf) => {
                if n == 0 {
                    break; // Server ngắt kết nối
                }
                let nonce = Nonce::from_slice(&socket_buf[..12]);
                let decrypted = cipher.decrypt(nonce, &socket_buf[12..n]).unwrap();
                iface.send(&decrypted)?;
            }
        }
    }
    Ok(())
}

Bước 3: Cấu hình mạng

Trên server:

Sau khi chạy server, bạn cần cấu hình giao diện TUN:

sudo ip addr add 10.0.0.1/24 dev tun0
sudo ip link set tun0 up

Nếu muốn chuyển tiếp gói tin ra Internet, bật IP forwarding:

sudo sysctl -w net.ipv4.ip_forward=1
sudo iptables -t nat -A POSTROUTING -s 10.0.0.0/24 -o eth0 -j MASQUERADE

Trên client:

Sau khi chạy client, cấu hình giao diện TUN:

sudo ip addr add 10.0.0.2/24 dev tun1
sudo ip link set tun1 up
sudo ip route add default via 10.0.0.1 dev tun1

Bước 4: Chạy thử

Chạy server:
```
cargo run --bin server
```
Chạy client:
```
cargo run --bin client
```

💡

Lưu ý

Đây là một triển khai rất cơ bản, không tối ưu cho sản xuất. Để sử dụng thực tế, bạn cần:
- Xử lý lỗi tốt hơn.
- Thêm giao thức xác thực (VD: sử dụng HMAC hoặc TLS).
- Tối ưu hiệu suất với UDP thay vì TCP.
- Sử dụng các giao thức VPN chuẩn như WireGuard hoặc OpenVPN.
Thư viện tun-tap yêu cầu quyền root để tạo giao diện TUN/TAP.
Bạn có thể tham khảo các dự án mã nguồn mở như wireguard-rs để học hỏi thêm.

Viết một VPN đơn giản sử dụng Rust