Giao thức bảo mật tầng truyền vận (TLS 1.3) đóng vai trò là trụ cột mật mã học cho hầu hết kết nối mạng hiện đại. Trong các kiến trúc mạng riêng ảo (VPN), cổng trung chuyển biên (edge relay) và các đường hầm bảo vệ dữ liệu (như DNS-over-HTTPS hoặc chuyển tiếp luồng dữ liệu đóng gói TLS), mã hóa tầng truyền vận giúp ngăn chặn nguy cơ nghe lén và can thiệp nội dung.

Tuy nhiên, các thư viện TLS truyền thống vận hành trong không gian người dùng (userspace)—bao gồm OpenSSL, BoringSSL hay Rustls—đang bộc lộ những điểm nghẽn nghiêm trọng khi triển khai trên các cổng mạng có lưu lượng lớn. Trong mô hình thông thường, mỗi gói tin đi qua cổng chuyển tiếp buộc phải sao chép qua lại giữa bộ đệm socket của nhân hệ thống và bộ nhớ không gian người dùng thông qua nhiều lần chuyển đổi ngữ cảnh (context switch).

Khi hệ thống nâng cấp lên băng thông 40GbE, 100GbE và xử lý hàng triệu gói tin mỗi giây, việc sao chép bộ nhớ liên tục và xử lý mã hoá đối xứng bằng CPU sẽ làm tắc nghẽn bộ nhớ đệm (cache), nghẽn bus hệ thống và giới hạn tốc độ truyền tải.

Để loại bỏ hoàn toàn các bước sao chép bộ nhớ dư thừa và chuyển giao tính toán mã hoá đối xứng trực tiếp cho phần cứng card mạng, nhân Linux đã giới thiệu giải pháp Kernel TLS (kTLS, CONFIG_TLS) kết hợp với cơ chế tăng tốc phần cứng SmartNIC.

+--------------------------------------------------------------------------+
|          SO SÁNH LUỒNG DỮ LIỆU: USERSPACE TLS VÀ LINUX KTLS              |
+--------------------------------------------------------------------------+
|                                                                          |
|  [ MÔ HÌNH CHUYỂN TIẾP TLS TRUYỀN THỐNG TRONG USERSPACE ]                |
|                                                                          |
|      Vào từ NIC ──> sk_buff ──(Sao chép 1)──> Bộ nhớ Userspace           |
|                                                  │                       |
|                                      CPU giải mã & mã hóa lại            |
|                                      (Nghẽn bộ đệm L1/L2)                |
|                                                  v                       |
|      Ra tới NIC  <── sk_buff <──(Sao chép 2)── Bộ nhớ Userspace          |
|      (Tốn 4 lần sao chép bộ nhớ & 2 lần đổi ngữ cảnh mỗi chu kỳ)         |
|                                                                          |
|  ----------------------------------------------------------------------  |
|                                                                          |
|  [ MÔ HÌNH LINUX KTLS ZERO-COPY VÀ TĂNG TỐC PHẦN CỨNG ]                  |
|                                                                          |
|      Vào từ NIC (DMA)                                                    |
|           │                                                              |
|           v (Bộ đệm trang trong nhân / sk_buff)                          |
|      +-------------------------------------------------------------+     |
|      |                  NGĂN XẾP MẠNG NHÂN LINUX                   |     |
|      |                                                             |     |
|      |   Bộ máy kTLS (CONFIG_TLS) / Điều hướng eBPF Sockmap        |     |
|      |   - Hoàn toàn không sao chép lên Userspace                  |     |
|      |   - Chuyển tiếp trực tiếp trong nhân qua splice()           |     |
|      +-------------------------------------------------------------+     |
|           │                                                              |
|           v (Xuất dữ liệu Zero-Copy qua DMA)                             |
|      Bộ tăng tốc mã hoá phần cứng trên NIC (Mellanox / Intel)            |
|           │                                                              |
|           v                                                              |
|      Dữ liệu mã hoá đẩy thẳng lên sợi quang (Đạt tốc độ 100GbE)           |
|                                                                          |
+--------------------------------------------------------------------------+

Gánh nặng tài nguyên của mô hình xử lý truyền thống

Trong kiến trúc dịch vụ mạng thông thường, việc chuyển tiếp lưu lượng mã hoá qua TLS tạo ra chi phí xử lý rất lớn. Khi một cổng chuyển tiếp tiếp nhận dữ liệu và đẩy tiếp qua đường hầm bảo mật:

  1. Tần suất gọi hàm hệ thống: Ứng dụng liên tục thực hiện read() hoặc SSL_read(), gây ra các đợt chuyển đổi qua lại giữa không gian người dùng và nhân hệ thống.
  2. Sao chép dữ liệu hai chiều: Dữ liệu đi vào từ card mạng nằm trong bộ đệm nhân phải được sao chép vào bộ nhớ heap của ứng dụng. Sau khi xử lý, lệnh write() hoặc SSL_write() lại sao chép gói tin ngược vào bộ đệm socket ra của nhân.
  3. Mất hiệu lực bộ nhớ đệm CPU: Việc liên tục tính toán thuật toán mã hoá đối xứng (AES-GCM hoặc ChaCha20-Poly1305) chiếm dụng toàn bộ bộ nhớ đệm L1 và L2 của CPU, làm suy giảm năng lực xử lý khi lưu lượng đạt hàng triệu gói tin mỗi giây.

Trên các máy chủ trang bị card mạng 100GbE, rào cản này giới hạn băng thông thực tế của một lõi CPU ở mức khoảng 18–25 Gbps dù phần cứng chưa đạt ngưỡng tối đa.

Kiến trúc Linux kTLS: Tách biệt pha bắt tay và pha truyền vận

Cơ chế Kernel TLS giải quyết bài toán trên bằng cách phân định rành mạch trách nhiệm:

  • Mặt bằng điều khiển trong Userspace: Các tác vụ phức tạp, giàu trạng thái—như xác thực chuỗi chứng chỉ X.509, đàm phán tham số ALPN và trao đổi khóa bất đối xứng (ECDHE hoặc các thuật toán hậu lượng tử)—tiếp tục được xử lý an toàn bởi các thư viện quen thuộc (OpenSSL hoặc GnuTLS).
  • Mặt bằng dữ liệu trong Nhân hệ thống: Sau khi bắt tay hoàn tất và suy xuất ra khoá phiên đối xứng, ứng dụng người dùng chuyển các thông số mật mã này vào tầng socket của nhân thông qua lời gọi setsockopt().

Kể từ thời điểm đó, nhân Linux tự đảm nhiệm việc đóng khung bản ghi TLS (record framing), tăng chỉ số tuần tự (sequence number) và tính toán mã hoá/giải mã trực tiếp trong tiến trình I/O của socket (tcp_sendmsg và tcp_recvmsg).

+--------------------------------------------------------------------------+
|                  QUY TRÌNH KÍCH HOẠT KTLS TRONG NHÂN LINUX               |
+--------------------------------------------------------------------------+
|                                                                          |
|    1. Thiết lập bắt tay TCP ban đầu (Socket tiêu chuẩn)                  |
|                                                                          |
|    2. Hoàn tất bắt tay TLS 1.3 phía Userspace (OpenSSL / BoringSSL)      |
|       - Đàm phán bộ mã: TLS_AES_256_GCM_SHA384                           |
|       - Trích xuất khoá phiên đối xứng & vector khởi tạo (IV)            |
|                                                                          |
|    3. Kích hoạt giao thức kTLS qua hàm setsockopt():                     |
|       setsockopt(fd, SOL_TCP, TCP_ULP, "tls", sizeof("tls"));            |
|                                                                          |
|    4. Đẩy thông số khoá vào nhân hệ thống:                               |
|       setsockopt(fd, SOL_TLS, TLS_TX, &crypto_info, sizeof(info));       |
|       setsockopt(fd, SOL_TLS, TLS_RX, &crypto_info, sizeof(info));       |
|                                                                          |
|    5. Truyền vận trực tiếp ở tầng nhân:                                 |
|       Nhân tự đóng gói, mã hoá và kiểm tra tính toàn vẹn gói tin         |
|       Ứng dụng tận dụng các hàm splice(), sendfile(), MSG_ZEROCOPY       |
|                                                                          |
+--------------------------------------------------------------------------+

Kích hoạt kTLS trên các ứng dụng C / Rust hiện đại

Ví dụ dưới đây mô tả cách một tiến trình chuyển tiếp kích hoạt kTLS trên một socket đang hoạt động thông qua OpenSSL 3.0+:

#include <sys/socket.h>
#include <netinet/tcp.h>
#include <linux/tls.h>
#include <openssl/ssl.h>

int enable_ktls_session(SSL *ssl, int socket_fd) {
    /* Bước 1: Yêu cầu OpenSSL sử dụng kTLS nếu nhân hệ thống hỗ trợ */
    SSL_set_options(ssl, SSL_OP_ENABLE_KTLS);

    /* Bước 2: Hoàn thành bắt tay mật mã học TLS 1.3 */
    if (SSL_accept(ssl) <= 0) {
        return -1; /* Lỗi bắt tay */
    }

    /* Bước 3: Kiểm tra trạng thái kích hoạt kTLS trên chiều gửi và nhận */
    if (BIO_get_ktls_send(SSL_get_wbio(ssl))) {
        /* Nhân Linux đang trực tiếp xử lý đóng gói và mã hoá chiều gửi */
    }
    if (BIO_get_ktls_recv(SSL_get_rbio(ssl))) {
        /* Nhân Linux đang trực tiếp giải mã và xác thực chiều nhận */
    }

    return 0;
}

Chuyển tiếp dữ liệu Zero-Copy bằng splice() và sendfile()

Lợi ích cấu trúc lớn nhất của kTLS là mở khóa khả năng truyền dữ liệu zero-copy cho các kết nối mã hoá.

Trong mô hình cũ, lệnh splice() không thể áp dụng cho socket TLS vì dữ liệu thô cần được mã hoá trước khi đẩy vào đường truyền. Nhờ kTLS thực hiện mã hoá ngay tại tầng truyền vận của nhân, dữ liệu có thể di chuyển giữa hai giao diện mạng mà không cần trung chuyển lên bộ nhớ người dùng:

/* Chuyển tiếp zero-copy giữa socket tiếp nhận và đường hầm đẩy ra */
int pipefd[2];
pipe(pipefd);

while (1) {
    /* Chuyển trực tiếp từ socket đã giải mã vào bộ đệm ống dẫn trong nhân */
    ssize_t bytes = splice(inbound_fd, NULL, pipefd[1], NULL, 65536, SPLICE_F_MOVE);
    if (bytes <= 0) break;

    /* Chuyển tiếp từ ống dẫn vào socket kTLS mã hoá đẩy ra */
    splice(pipefd[0], NULL, outbound_fd, NULL, bytes, SPLICE_F_MOVE);
}

Phương pháp này giúp gói tin di chuyển mượt mà từ bộ đệm vào sang bộ đệm ra, giải phóng hoàn toàn băng thông bộ nhớ RAM máy chủ.

Tăng tốc phần cứng: Chuyển giao tính toán mật mã cho SmartNIC

Bên cạnh giải pháp kTLS chạy trên CPU máy chủ, các dòng card mạng doanh nghiệp cao cấp (như NVIDIA Mellanox ConnectX-6 Dx / BlueField và Intel Ethernet 800 Series) còn hỗ trợ tính năng kTLS Device Offload.

Ba cấp độ vận hành của kTLS

Nhân Linux phân chia khả năng vận hành của kTLS thành ba cấp bậc rõ rệt:

+--------------------------------------------------------------------------+
|                  SO SÁNH CÁC CẤP ĐỘ VẬN HÀNH CỦA KTLS                    |
+--------------------------------------------------------------------------+
| Chế độ hoạt động     | Đơn vị thực thi       | Mức tải CPU | Đạt 100GbE  |
+---------------------+-----------------------+-------------+-------------+
| Userspace truyền thống| CPU máy chủ (Ứng dụng)| 100%        | Bị nghẽn    |
| kTLS phần mềm (SW)   | CPU máy chủ (Nhân ASM)| 35-50%      | Đạt đa lõi  |
| kTLS Device Offload  | Chip chuyên dụng trên NIC | <2%     | Đạt tối đa  |
+--------------------------------------------------------------------------+

Khi kích hoạt tăng tốc phần cứng:

  1. Nhân Linux chỉ đính kèm thông tin ngữ cảnh mật mã vào bộ mô tả sk_buff mà không tự tính toán mã hoá dữ liệu.
  2. Bộ điều khiển DMA trên card mạng chủ động đọc dữ liệu thô từ RAM máy chủ.
  3. Bộ tăng tốc AES chuyên dụng trên card mạng mã hoá dữ liệu trực tiếp theo tốc độ phần cứng ngay trước khi chuyển thành tín hiệu quang.

Kiểm tra và kích hoạt tính năng tăng tốc phần cứng trên giao diện mạng:

# Kiểm tra khả năng hỗ trợ kTLS của phần cứng
ethtool -k eth0 | grep tls-hw

# Kích hoạt tăng tốc phần cứng chiều gửi và chiều nhận
ethtool -K eth0 tls-hw-tx-offload on
ethtool -K eth0 tls-hw-rx-offload on

Kết hợp với eBPF Sockmap để điều hướng nội bộ trong nhân

Để tối đa hoá hiệu suất chuyển tiếp, kTLS kết hợp hoàn hảo cùng công nghệ eBPF sockmap (BPF_MAP_TYPE_SOCKMAP và BPF_PROG_TYPE_SK_MSG).

Một chương trình eBPF được gắn vào socket kTLS có thể đọc dữ liệu vừa giải mã trong hàng đợi nhân, phân tích tiêu đề gói tin và gọi hàm bpf_msg_redirect_map() để đẩy thẳng gói tin sang socket đường hầm ra mà không cần đánh thức tiến trình ứng dụng:

NIC đầu vào ──> kTLS Giải mã ──> Bộ lọc eBPF sk_msg ──> kTLS Mã hoá ──> NIC đầu ra
               [ Xử lý 100% trong nhân mà không đổi ngữ cảnh ]

Ứng dụng thực tiễn trên hạ tầng RiceGuard và VPNRice

Tại hệ thống phân phối của VPNRice, kTLS và công nghệ tăng tốc phần cứng đem lại những giá trị hạ tầng thực tế:

  1. Xử lý khối lượng truy vấn lớn tại biên: Các nút mạng biên xử lý các kết nối DoH và DoT ứng dụng kTLS để phục vụ hàng trăm nghìn truy vấn đồng thời với độ trễ phản hồi dưới 1 mili-giây.
  2. Tiết kiệm điện năng và giảm tải nhiệt: Việc chuyển tính toán AES-GCM sang phần cứng mạng giúp hạ tải CPU máy chủ tới 80%, loại bỏ nguy cơ sụt giảm xung nhịp do quá nhiệt trên các cụm máy chủ mật độ cao.
  3. Bảo vệ luồng dữ liệu khách hàng: Do dữ liệu sau khi giải mã được luân chuyển trực tiếp giữa các hàng đợi của nhân, thông tin của người dùng không tồn tại trên bộ nhớ ứng dụng người dùng, loại bỏ nguy cơ rò rỉ qua các lỗ hổng đọc bộ nhớ.

Khuyến nghị vận hành khi triển khai

Khi đưa kTLS vào môi trường sản xuất quy mô lớn, đội ngũ quản trị cần lưu ý:

  • Phiên bản nhân hệ thống: Sử dụng nhân Linux 5.15 LTS trở lên để đảm bảo tính hoàn thiện của TLS 1.3, hoặc nhân 6.1+ nếu sử dụng tăng tốc phần cứng SmartNIC.
  • Quyền hạn tiến trình: Cấp quyền quản lý socket ULP hoặc gán năng lực CAP_NET_ADMIN cho các tiến trình mạng.
  • Lựa chọn bộ mã: Ưu tiên các thuật toán TLS_AES_128_GCM_SHA256 hoặc TLS_AES_256_GCM_SHA384 để tương thích hoàn toàn với các chip tăng tốc trên card mạng.

Sự kết hợp giữa Linux kTLS, kỹ thuật zero-copy và phần cứng SmartNIC tạo nên nền tảng công nghệ vững chắc, mang lại hiệu năng băng thông vượt trội cho các cổng VPN thế hệ mới.