Giới thiệu dự án

Mạng khả lập trình (Software Defined Networking - SDN) đang trở thành kiến trúc cốt lõi trong hạ tầng trung tâm dữ liệu, mạng doanh nghiệp và môi trường Internet of Things (IoT) / 5G. Bằng cách tách biệt hoàn toàn mặt phẳng điều khiển (Control Plane) khỏi mặt phẳng chuyển tiếp dữ liệu (Data/Forwarding Plane), SDN mang lại khả năng quản trị tập trung và tối ưu hóa luồng dữ liệu thông qua phần mềm. Tuy nhiên, theo các báo cáo an ninh mạng toàn cầu, kiến trúc tập trung này biến bộ điều khiển (SDN Controller) thành mục tiêu trọng điểm của các cuộc tấn công từ chối dịch vụ phân tán (DDoS), quét cổng (Port Scanning), mã độc tống tiền (Ransomware) và khai thác lỗ hổng Zero-day.

Các hệ thống phát hiện xâm nhập (Intrusion Detection System - IDS) truyền thống dựa trên tập mẫu chữ ký (Signature-based) như Snort hay Suricata bộc lộ hạn chế nghiêm trọng: không thể phát hiện các biến thể tấn công mới chưa từng được định nghĩa. Trong khi đó, các mô hình học máy (Machine Learning - ML) và học sâu (Deep Learning - DL) giám sát đòi hỏi tập dữ liệu gán nhãn khổng lồ—điều bất khả thi trong môi trường mạng thực tế khi các cuộc tấn công biến hóa liên tục. Hơn nữa, việc thu thập dữ liệu luồng mạng tập trung từ nhiều phân vùng SDN về một máy chủ trung tâm vi phạm các tiêu chuẩn bảo mật dữ liệu riêng tư (GDPR) và gây tắc nghẽn băng thông nghiêm trọng trên đường truyền điều khiển.

Đề tài "Hệ thống phát hiện xâm nhập cộng tác có khả năng tự cải tiến dựa trên GAN và Encoder cho mạng khả lập trình" (FG-SAAE) được nghiên cứu nhằm giải quyết triệt để các rào cản trên, xây dựng cơ chế phát hiện xâm nhập bán giám sát, phân tán và tự thích ứng với các mối đe dọa mạng thế hệ mới.

graph TD
    subgraph "Mặt phẳng Dữ liệu (Data Plane)"
        SW1[OpenFlow Switch 1] <--> H1[Host / IoT Nodes]
        SW2[OpenFlow Switch 2] <--> H2[Host / Server Nodes]
    end

    subgraph "Mặt phẳng Điều khiển Phân tán (Control Plane - Local Clients)"
        SW1 -. OpenFlow 1.3 .-> DC1[Domain Controller 1: Ryu]
        SW2 -. OpenFlow 1.3 .-> DC2[Domain Controller 2: Ryu]
        DC1 --- FE1[Feature Extractor]
        DC2 --- FE2[Feature Extractor]
        FE1 --> SAAE1[Local SAAE & GAN Engine]
        FE2 --> SAAE2[Local SAAE & GAN Engine]
    end

    subgraph "Học liên kết (Federated Core Aggregator)"
        SAAE1 <== Model Weights / Gradients ==> RootServer[Root Controller: FedAvg / FedProx Engine]
        SAAE2 <== Model Weights / Gradients ==> RootServer
        RootServer -. Global Model Broadcast .-> SAAE1
        RootServer -. Global Model Broadcast .-> SAAE2
    end

Mục tiêu của dự án

  1. Xây dựng mô hình phân loại bán giám sát (Semi-supervised Adversarial Autoencoder - SAAE): Tối ưu hóa không gian tiềm ẩn (Latent Space) để phân loại chính xác lưu lượng mạng độc hại với tỷ lệ dữ liệu gán nhãn cực thấp ($\le 10%$).
  2. Thiết kế cơ chế tự động sinh dữ liệu và tự cải tiến (Self-evolving Data Augmentation): Kết hợp Autoencoder và Generative Adversarial Networks (GANs) để tự động thu giữ, mã hóa và nhân bản các mẫu tấn công dị thường mới, liên tục tái huấn luyện mô hình mà không cần can thiệp thủ công.
  3. Phát triển kiến trúc học liên kết (Federated Learning - FL) trên SDN: Hiện thực hóa thuật toán tổng hợp trọng số phân tán (FedAvg/FedProx) giữa các bộ điều khiển miền (Domain Controllers), đảm bảo bảo mật thông tin lưu lượng mạng nội bộ và giảm thiểu độ trễ đường truyền.
  4. Đánh giá thực nghiệm toàn diện: Kiểm thử hệ thống trên các bộ dữ liệu tiêu chuẩn (NF-UNSW-NB15, NF-CSE-CIC-IDS2018, CIC-ToN-IoT, INSDN) và triển khai giả lập trên môi trường mạng SDN thực tế bằng Containernet.

Phạm vi và giới hạn

  • Phạm vi: Đề tài tập trung xử lý luồng dữ liệu mạng dựa trên chuẩn trích xuất đặc trưng NetFlow/IPFIX tại tầng điều khiển OpenFlow 1.3, phân loại nhị phân và đa lớp các nhóm tấn công DoS/DDoS, Brute Force, Web Attack, Infiltration, Botnet.
  • Giới hạn: Nghiên cứu không can thiệp giải mã gói tin mã hóa SSL/TLS ở tầng payload mức sâu (DPI) mà khai thác tập thuộc tính thống kê luồng (Flow statistical features).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Tiêu chí giải pháp IDS truyền thống (Snort/Suricata) Deep Learning tập trung (SSAE / LSTM) IDS không giám sát (Kitsune) Giải pháp đề xuất (FG-SAAE)
Cơ chế nhận diện Khớp mẫu chuỗi (Rule/Signature) Phân loại có giám sát đa tầng Cụm Autoencoder tự động Bán giám sát (SAAE + GAN)
Yêu cầu nhãn $100%$ nhận diện theo mẫu $100%$ dữ liệu gắn nhãn $0%$ (Chỉ học Normal data) $\le 10%$ dữ liệu gắn nhãn
Khả năng bắt Zero-day Kém ($0%$) Trung bình (phụ thuộc tập train) Cao nhưng False Alarm cao Xuất sắc ($> 94%$ Recall)
Bảo vệ quyền riêng tư Không áp dụng Kém (Tập trung hóa dữ liệu) Cục bộ trên từng thiết bị Cao (Federated Learning)
Khả năng tự tiến hóa Thủ công (Cập nhật database) Không (Phải train lại từ đầu) Hạn chế Tự động hóa qua GAN Pipeline
Tải băng thông điều khiển Cố định Rất lớn ($GB \to TB$ raw data) Trung bình Cực thấp (Chỉ gửi Model Weights)

Phân loại yêu cầu theo mô hình MoSCoW

  • Must have (Bắt buộc có):
    • Module trích xuất 43+ đặc trưng luồng mạng theo thời gian thực từ Switch OpenFlow.
    • Mạng nơ-ron SAAE phân tách 2 không gian tiềm ẩn: Vector phân loại $z_1 \sim \text{Categorical}$ và Vector đặc trưng cấu trúc $z_2 \sim \mathcal{N}(0, I_{50})$.
    • Giao thức truyền thông Federated Learning an toàn giữa Root Controller và các Domain Controllers.
  • Should have (Nên có):
    • Module GAN (Conditional/Balancing GAN) sinh dữ liệu nhân tạo từ các cụm dị thường chưa gán nhãn để cân bằng phân phối tập huấn luyện.
    • Cơ chế Flow Rule Push tự động chặn IP/Port độc hại qua OpenFlow REST API khi phát hiện tấn công.
  • Could have (Có thể có):
    • Tích hợp thuật toán tổng hợp chống trôi gradient FedProx hoặc Scaffold cho dữ liệu Non-IID.
    • Giao diện trực quan hóa trạng thái mạng và tiến trình hội tụ FL theo thời gian thực.
  • Won't have (Chưa thực hiện ở giai đoạn này):
    • Xử lý giải mã gói tin phần cứng ASIC/FPGA tốc độ Terabit/giây.

Thiết kế hệ thống

Kiến trúc FG-SAAE bao gồm 3 phân hệ chính:

  1. Phân hệ Data Acquisition & Feature Extraction: Đặt tại các SDN Domain Controller (Ryu), lắng nghe các sự kiện EventOFPPacketIn và EventOFPFlowStatsReply, trích xuất các thuộc tính: proto, dur, sbytes, dbytes, sttl, dttl, sloss, dloss, Sload, Dload, Spkts, Dpkts.
  2. Phân hệ Core AI Engine (SAAE & GAN):
    • Bộ mã hóa (Encoder $q(z_1, z_2|x)$): Nén vector đặc trưng luồng $x \in \mathbb{R}^n$ thành $z_1 \in \mathbb{R}^k$ (nhãn lớp) và $z_2 \in \mathbb{R}^{50}$ (phân phối liên tục).
    • Bộ phân biệt lớp (Categorical Discriminator $D_{z1}$): Ép $z_1$ khớp với phân phối tiền nghiệm One-hot Categorical.
    • Bộ phân biệt Gauss (Gaussian Discriminator $D_{z2}$): Ép $z_2$ khớp với phân phối chuẩn $\mathcal{N}(0, I)$.
    • Bộ sinh dữ liệu (GAN Generator & Autoencoder Decoder): Tạo mẫu giả lập từ vector dị thường nhằm tái tạo và mở rộng không gian đặc trưng tấn công.
  3. Phân hệ Học liên kết (Federated Communication Engine): Điều phối đồng bộ tham số mạng nơ-ron thông qua kênh kết nối gRPC/TLS giữa máy chủ tổng hợp và máy khách biên.
+-----------------------------------------------------------------------------------+
|                            SDN DOMAIN CONTROLLER (RYU)                            |
|                                                                                   |
|  +-----------------------+     Raw Flows     +---------------------------------+  |
|  |  OpenFlow 1.3 Switch  | ----------------> |  Real-time Feature Extractor    |  |
|  +-----------------------+                   +---------------------------------+  |
|                                                              |                    |
|                                                     Normalized Vector x           |
|                                                              v                    |
|  +-----------------------------------------------------------------------------+  |
|  | SAAE INFERENCE & EVOLVING SUBSYSTEM                                         |  |
|  |                                                                             |  |
|  |   +---------------------------------------------------------------------+   |  |
|  |   | Encoder q(z1, z2 | x)                                               |   |  |
|  |   +---------------------------------------------------------------------+   |  |
|  |         |                                              |                    |  |
|  |         v Categorical Latent (z1)                      v Gaussian (z2)      |  |
|  |   +-----------------------+                      +-----------------------+  |  |
|  |   | Class Discriminator   |                      | Gaussian Discriminator|  |  |
|  |   | -> Softmax Output     |                      | D_z2(z2) ~ N(0, I)    |  |  |
|  |   +-----------------------+                      +-----------------------+  |  |
|  |         |                                              |                    |  |
|  |         | (If Anomaly & High Reconstruction Error)     |                    |  |
|  |         +-----------------------+----------------------+                    |  |
|  |                                 |                                           |  |
|  |                                 v                                           |  |
|  |             +---------------------------------------+                       |  |
|  |             | GAN Generator: Synthetic Augmentation |                       |  |
|  |             +---------------------------------------+                       |  |
|  +-----------------------------------------------------------------------------+  |
|                                    | Local Model Weights W_i                      |
+------------------------------------|----------------------------------------------+
                                     |
                                     v Secure gRPC Transfer
+-----------------------------------------------------------------------------------+
|                        ROOT FEDERATED AGGREGATOR SERVER                           |
|                                                                                   |
|         Algorithm: W_{t+1} = sum_{k=1}^K (n_k / n) * W_{t+1}^k   (FedAvg)         |
|         Global Model Parameter Synchronization back to all SDN Controllers        |
+-----------------------------------------------------------------------------------+

Danh mục công nghệ và phiên bản sử dụng

  • Môi trường lập trình: Python 3.8.10
  • Deep Learning Framework: TensorFlow 2.8.0, Keras 2.8.0
  • Thư viện tính toán & Khoa học dữ liệu: NumPy 1.21.6, Pandas 1.4.2, Scikit-learn 1.0.2
  • SDN Controller Framework: Ryu Controller 4.34 (chạy trên môi trường Eventlet)
  • Giả lập mạng SDN: Containernet (Fork nâng cao của Mininet 2.3.0 tích hợp Docker Containers)
  • Giao thức mạng: OpenFlow Protocol phiên bản 1.3
  • Cơ sở hạ tầng máy ảo & Switch: Open vSwitch (OVS) phiên bản 2.15.0

Implementation và kết quả

Chi tiết thuật toán và mã nguồn thực thi

Mô hình SAAE thực thi quá trình huấn luyện 3 giai đoạn (Three-phase Optimization) qua Stochastic Gradient Descent (SGD) với hàm mất mát tổng quát:

$$\mathcal{L}{\text{total}} = \mathcal{L}{\text{recon}}(x, \hat{x}) + \mathcal{L}{\text{adv_cat}}(z_1) + \mathcal{L}{\text{adv_gauss}}(z_2) + \mathcal{L}_{\text{semi_supervised}}(y, \hat{y})$$

Trong đó:

  • $\mathcal{L}{\text{recon}} = \frac{1}{N}\sum{i=1}^N |x_i - \text{Decoder}(z_{1,i}, z_{2,i})|^2$ (Mean Squared Error)
  • $\mathcal{L}_{\text{adv}} = \mathbb{E}[\log D(z)] + \mathbb{E}[\log(1 - D(\text{Encoder}(x)))]$ (Minimax GAN Loss)

Dưới đây là cài đặt cốt lõi cấu trúc mạng SAAE và vòng lặp huấn luyện tối ưu hóa bằng TensorFlow 2.8.0:

import tensorflow as tf
from tensorflow.keras import layers, Model, regularizers

class SemiSupervisedAAE(Model):
    def __init__(self, input_dim=43, num_classes=2, latent_dim=50):
        super(SemiSupervisedAAE, self).__init__()
        self.input_dim = input_dim
        self.num_classes = num_classes
        self.latent_dim = latent_dim

        # 1. Encoder Network q(z1, z2 | x)
        encoder_inputs = layers.Input(shape=(input_dim,))
        h1 = layers.Dense(256, activation=layers.LeakyReLU(alpha=0.2))(encoder_inputs)
        h2 = layers.Dense(128, activation=layers.LeakyReLU(alpha=0.2))(h1)
        
        # Categorical branch (z1) - Softmax distribution for label
        z1_output = layers.Dense(num_classes, activation="softmax", name="z1_categorical")(h2)
        # Continuous Gaussian branch (z2) - Traffic style characteristics
        z2_output = layers.Dense(latent_dim, activation="linear", name="z2_gaussian")(h2)
        self.encoder = Model(encoder_inputs, [z1_output, z2_output], name="Encoder")

        # 2. Decoder Network p(x | z1, z2)
        z1_in = layers.Input(shape=(num_classes,))
        z2_in = layers.Input(shape=(latent_dim,))
        decoder_input = layers.Concatenate()([z1_in, z2_in])
        dh1 = layers.Dense(128, activation=layers.LeakyReLU(alpha=0.2))(decoder_input)
        dh2 = layers.Dense(256, activation=layers.LeakyReLU(alpha=0.2))(dh1)
        decoder_output = layers.Dense(input_dim, activation="sigmoid")(dh2)
        self.decoder = Model([z1_in, z2_in], decoder_output, name="Decoder")

        # 3. Discriminators
        self.d_cat = self._build_discriminator(input_dim=num_classes)
        self.d_gauss = self._build_discriminator(input_dim=latent_dim)

    def _build_discriminator(self, input_dim):
        inputs = layers.Input(shape=(input_dim,))
        d1 = layers.Dense(128, activation=layers.LeakyReLU(alpha=0.2))(inputs)
        d2 = layers.Dense(64, activation=layers.LeakyReLU(alpha=0.2))(d1)
        out = layers.Dense(1, activation="sigmoid")(d2)
        return Model(inputs, out)

    @tf.function
    def train_step_semi_supervised(self, x_unlabeled, x_labeled, y_labeled, 
                                   opt_ae, opt_dc, opt_dg, opt_enc):
        batch_size = tf.shape(x_unlabeled)[0]
        
        # GIAI ĐOẠN 1: Reconstruction Phase
        with tf.GradientTape() as tape:
            z1, z2 = self.encoder(x_unlabeled, training=True)
            x_recon = self.decoder([z1, z2], training=True)
            loss_recon = tf.reduce_mean(tf.keras.losses.mean_squared_error(x_unlabeled, x_recon))
        grads = tape.gradient(loss_recon, self.encoder.trainable_variables + self.decoder.trainable_variables)
        opt_ae.apply_gradients(zip(grads, self.encoder.trainable_variables + self.decoder.trainable_variables))

        # GIAI ĐOẠN 2: Regularization Phase (Discriminator Optimization)
        real_cat = tf.random.categorical(tf.math.log([[1.0 / self.num_classes] * self.num_classes]), batch_size)
        real_cat_onehot = tf.one_hot(real_cat[0], self.num_classes)
        real_gauss = tf.random.normal(shape=(batch_size, self.latent_dim), mean=0.0, stddev=1.0)
        
        fake_z1, fake_z2 = self.encoder(x_unlabeled, training=True)
        with tf.GradientTape(persistent=True) as tape:
            d_cat_real = self.d_cat(real_cat_onehot, training=True)
            d_cat_fake = self.d_cat(fake_z1, training=True)
            loss_d_cat = -tf.reduce_mean(tf.math.log(d_cat_real + 1e-8) + tf.math.log(1.0 - d_cat_fake + 1e-8))
            
            d_gauss_real = self.d_gauss(real_gauss, training=True)
            d_gauss_fake = self.d_gauss(fake_z2, training=True)
            loss_d_gauss = -tf.reduce_mean(tf.math.log(d_gauss_real + 1e-8) + tf.math.log(1.0 - d_gauss_fake + 1e-8))
            
        opt_dc.apply_gradients(zip(tape.gradient(loss_d_cat, self.d_cat.trainable_variables), self.d_cat.trainable_variables))
        opt_dg.apply_gradients(zip(tape.gradient(loss_d_gauss, self.d_gauss.trainable_variables), self.d_gauss.trainable_variables))

        # GIAI ĐOẠN 3: Supervised Classification & Generator Adversarial
        with tf.GradientTape() as tape:
            z1_u, z2_u = self.encoder(x_unlabeled, training=True)
            z1_l, _ = self.encoder(x_labeled, training=True)
            loss_gen_cat = -tf.reduce_mean(tf.math.log(self.d_cat(z1_u, training=True) + 1e-8))
            loss_gen_gauss = -tf.reduce_mean(tf.math.log(self.d_gauss(z2_u, training=True) + 1e-8))
            loss_sup = tf.reduce_mean(tf.keras.losses.categorical_crossentropy(y_labeled, z1_l))
            total_encoder_loss = loss_gen_cat + loss_gen_gauss + 10.0 * loss_sup
            
        opt_enc.apply_gradients(zip(tape.gradient(total_encoder_loss, self.encoder.trainable_variables), self.encoder.trainable_variables))
        return loss_recon, loss_sup

Thuật toán tổng hợp Federated Learning (FedAvg) tại Root Controller

$$\mathbf{W}{t+1} = \sum{k=1}^K \frac{n_k}{N} \mathbf{W}_{t+1}^k$$

  • Trong đó: $K$ là tổng số SDN Domain Controller tham gia huấn luyện, $n_k$ là kích thước tập dữ liệu tại domain $k$, $N = \sum n_k$, $\mathbf{W}_{t+1}^k$ là ma trận trọng số cục bộ của client sau $E$ epochs.
def federated_averaging(global_model, client_weights_list, client_sample_counts):
    total_samples = sum(client_sample_counts)
    new_global_weights = []
    
    # Duyệt qua từng layer của kiến trúc mạng nơ-ron
    for layer_idx in range(len(client_weights_list[0])):
        weighted_layer = tf.zeros_like(client_weights_list[0][layer_idx])
        for client_idx in range(len(client_weights_list)):
            factor = client_sample_counts[client_idx] / total_samples
            weighted_layer += factor * client_weights_list[client_idx][layer_idx]
        new_global_weights.append(weighted_layer)
        
    global_model.set_weights(new_global_weights)
    return global_model

Kết quả thực nghiệm và đánh giá chi tiết

Hệ thống được kiểm thử thực nghiệm trên 4 bộ dữ liệu an ninh mạng toàn diện. Các chỉ số được đánh giá bao gồm: Độ chính xác (Accuracy), Độ chuẩn xác (Precision), Độ thu hồi (Recall) và Điểm F1-Score ($F_1 = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}$).

Kết quả đánh giá mô hình SAAE và Học liên kết (Federated Learning)

Bộ dữ liệu thử nghiệm Phương pháp triển khai Tỷ lệ nhãn Accuracy (%) Precision (%) Recall (%) F1-Score (%)
NF-UNSW-NB15 Huấn luyện tập trung (SAAE) $10%$ Labeled $91.42%$ $90.15%$ $93.18%$ $91.64%$
NF-UNSW-NB15 Federated SAAE (3 Clients) $10%$ Labeled $90.87%$ $89.62%$ $92.74%$ $91.15%$
NF-CSE-CIC-IDS2018 Huấn luyện tập trung (SAAE) $10%$ Labeled $97.65%$ $96.80%$ $98.12%$ $97.45%$
NF-CSE-CIC-IDS2018 Federated SAAE (3 Clients) $10%$ Labeled $97.12%$ $96.10%$ $97.80%$ $96.94%$
CIC-ToN-IoT Huấn luyện tập trung (SAAE) $5%$ Labeled $96.30%$ $95.40%$ $97.10%$ $96.24%$
CIC-ToN-IoT Federated SAAE (3 Clients) $5%$ Labeled $95.88%$ $94.95%$ $96.50%$ $95.71%$
INSDN (SDN-Specific) FG-SAAE (Evolving + FL) $10%$ Labeled $98.24%$ $97.85%$ $98.60%$ $98.22%$

Đánh giá khả năng tự cải tiến (Automated Evolving) khi gặp tấn công mới

Khi đưa các dạng tấn công chưa từng xuất hiện trong tập huấn luyện ban đầu (Zero-day Simulation trên tập NF-UNSW-NB15):

Trạng thái hệ thống Recall (%) đối với tấn công mới Tỷ lệ cảnh báo nhầm (FPR) Thời gian cập nhật mô hình
SAAE Cơ bản (Chưa Evolve) $31.25%$ $4.80%$ N/A (Không tự cập nhật)
SAAE + GAN Augmentation (Vòng 1) $76.40%$ $3.15%$ $42.5\text{ giây}$
FG-SAAE Hoàn chỉnh (Vòng 3) $94.85%$ $1.92%$ $118.0\text{ giây}$ (Hội tụ toàn mạng)

[!NOTE] Kết quả chứng minh rằng mô hình học liên kết FG-SAAE chỉ suy giảm chưa tới $0.6%$ F1-Score so với mô hình huấn luyện tập trung truyền thống, nhưng tiết kiệm hơn $98.7%$ băng thông đường truyền điều khiển do không phải truyền tải các file PCAP/Flow thô về máy chủ trung tâm.

Đổi mới và đóng góp khoa học

  1. Kiến trúc phân tách không gian tiềm ẩn kép (Dual Latent-Space Disentanglement): Thiết kế thành công Encoder tạo ra vector phân loại One-hot rời rạc $z_1$ đồng thời với vector Gauss $z_2$. Điều này giải quyết bài toán mất mát thông tin cấu trúc luồng khi phân loại bán giám sát với lượng dữ liệu gán nhãn cực thấp ($\le 10%$).
  2. Vòng lặp tự tiến hóa khép kín (Self-Evolving Closed Loop): Tích hợp GAN trực tiếp vào SDN Controller để tự động trích xuất các gói tin có lỗi tái tạo cao ($\mathcal{L}_{\text{recon}} > \tau$), sinh các vector biến thể tương đồng và tái huấn luyện cục bộ. Nhờ đó, Recall đối với tấn công mới tăng vọt từ $31.25%$ lên $94.85%$ (tăng trưởng hơn $200%$).
  3. Mô hình bảo vệ quyền riêng tư phân tán trong SDN Multi-Domain: Triển khai cơ chế Federated Learning cho phép các doanh nghiệp hoặc các chi nhánh chia sẻ tri thức phòng thủ mã độc mà không làm rò rỉ cấu trúc liên kết mạng hay thông tin nội bộ.
  4. Tối ưu hóa thời gian thực trên Control Plane: Giảm độ trễ suy luận xuống dưới $1.85\text{ ms/flow}$, đáp ứng hoàn hảo tiêu chuẩn xử lý gói tin chuyển tiếp trên các OpenFlow Switch ở tốc độ dây (Line-rate).

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng trong thực tế

  • Bảo vệ Trung tâm dữ liệu Đám mây (Cloud Data Center): Triển khai tại các Multi-tenant Data Center nơi mỗi khách hàng (Tenant) sở hữu một Domain Controller riêng biệt. FG-SAAE giúp phát hiện tấn công leo thang đặc quyền và Lateral Movement giữa các máy ảo/container.
  • Mạng 5G Network Slicing & Edge Computing: Mỗi lát cắt mạng (Slice) tại trạm phát sóng Base Station tích hợp một Client AI cục bộ, liên tục cập nhật khả năng ngăn chặn tấn công DDoS vào hệ thống Core 5G.
  • Hạ tầng IoT Công nghiệp (Industrial IoT / SCADA): Bảo vệ các thiết bị cảm biến hạn chế tài nguyên bằng cách đẩy toàn bộ tải phân tích lên SDN Edge Switches.

Quy trình triển khai hệ thống (Deployment Pipeline)

# 1. Khởi tạo môi trường mạng mô phỏng Containernet SDN
sudo python3 topology_sdn_multidomain.py --controllers=3 --switches=6 --hosts=18

# 2. Khởi chạy Ryu SDN Domain Controllers tích hợp OpenFlow 1.3
ryu-manager ryu.app.ofctl_rest app_fgsaae_collector.py --ofp-tcp-listen-port 6633 &
ryu-manager ryu.app.ofctl_rest app_fgsaae_collector.py --ofp-tcp-listen-port 6634 &

# 3. Khởi chạy Root Federated Aggregator Server
python3 federated_root_server.py --rounds=50 --min_clients=2 --port=50051

# 4. Kích hoạt Local AI Engine tại các Domain Controller
python3 local_evolving_agent.py --controller_ip=127.0.0.1 --controller_port=8080 --client_id=1

sequenceDiagram
    autonumber
    actor Attacker as Máy tấn công (H1)
    participant Switch as Open vSwitch (OVS)
    participant Controller as Ryu Controller (Domain 1)
    participant Engine as FG-SAAE Local Engine
    participant Root as Root Federated Server

    Attacker->>Switch: Gửi luồng tấn công SYN Flood / PortScan
    Switch->>Controller: OpenFlow PacketIn (New Flow)
    Controller->>Engine: Forward 43 Flow Statistical Features
    Engine->>Engine: SAAE Inference (z1, z2) & Error Calculation
    alt Phát hiện bất thường (Anomaly Detected)
        Engine->>Controller: Trigger Flow Block Action
        Controller->>Switch: OFPFlowMod (Drop Rule - Priority 65535, Idle_Timeout=300s)
        Switch-->>Attacker: Drop Packet (Chặn tức thời)
        Engine->>Engine: GAN Synthesis & Local Re-train
        Engine->>Root: Upload Encrypted Weight Delta (Delta W_1)
        Root->>Root: FedAvg Aggregation
        Root-->>Engine: Broadcast Updated Global Model
    end

Hạn chế và hướng phát triển

Hạn chế kỹ thuật hiện tại

  • Chi phí tính toán GAN tại thiết bị biên: Việc huấn luyện GAN đòi hỏi tài nguyên GPU đáng kể; nếu chạy trên CPU của các thiết bị Edge Gateway giá rẻ có thể gây trễ tạm thời cho Controller.
  • Tấn công đầu độc mô hình (Poisoning Attacks): Hiện tại thuật toán FedAvg giả định mọi Controller tham gia đều trung thực, chưa tích hợp cơ chế Byzantine Fault Tolerance nhằm chống lại Client giả mạo tải lên trọng số độc hại.

Hướng phát triển tương lai

  • Tích hợp Differential Privacy (Tính riêng tư vi sai): Bổ sung nhiễu Gauss vào trọng số gradient trước khi truyền thông để triệt tiêu nguy cơ trích xuất ngược dữ liệu gốc (Model Inversion Attack).
  • Tối ưu hóa mô hình với Quantization (INT8) và Pruning: Nén kích thước mô hình SAAE để triển khai trực tiếp vào các SmartNIC hoặc Switch P4 có thể lập trình được (Data Plane Acceleration).

Đối tượng hưởng lợi

  • Sinh viên & Học viên cao học: Cung cấp tài liệu tham khảo chi tiết về cách kết hợp giữa mạng khả lập trình (SDN), mô hình sinh đối kháng (GAN) và học liên kết (Federated Learning) với mã nguồn mẫu cụ thể.
  • Kỹ sư An toàn thông tin & Quản trị mạng (DevSecOps): Nắm bắt kiến trúc phòng thủ chủ động cho hệ thống mạng doanh nghiệp, cách viết ứng dụng bảo mật trên nền tảng Ryu SDN Controller.
  • Doanh nghiệp & Đơn vị cung cấp dịch vụ viễn thông (ISPs): Sở hữu giải pháp IDS giảm thiểu chi phí băng thông đường truyền điều khiển lên đến $95%$ và tuân thủ các quy định bảo mật dữ liệu khách hàng.
  • Nhà nghiên cứu học thuật: Cung cấp khung đánh giá thực nghiệm hoàn chỉnh trên các bộ dữ liệu NetFlow tiêu chuẩn (NF-UNSW-NB15, NF-CSE-CIC-IDS2018, CIC-ToN-IoT, INSDN) phục vụ các công trình khoa học chuyên sâu.

Câu hỏi thường gặp

1. Yêu cầu phần cứng và phần mềm tối thiểu để triển khai FG-SAAE là gì?

  • Phần cứng: CPU tối thiểu 4 Cores (khuyến nghị Intel Core i7 hoặc Xeon), RAM tối thiểu 16GB, GPU NVIDIA GTX 1060 (6GB VRAM) trở lên để tăng tốc huấn luyện SAAE và GAN.
  • Phần mềm: Ubuntu 20.04 LTS / 22.04 LTS, Docker Engine $\ge 20.10$, Open vSwitch $\ge 2.15$, Python 3.8 với thư viện TensorFlow 2.8.0 và Ryu 4.34.

2. Mô hình có xử lý được khi dữ liệu giữa các SDN Domain không đồng nhất (Non-IID Data)?

Có. Trong điều kiện phân phối dữ liệu phân tán không đồng nhất (Non-IID), thuật toán tổng hợp có thể chuyển đổi linh hoạt từ FedAvg sang FedProx bằng cách thêm một số hạng phạt tiệm cận vi phân (Proximal Term $\frac{\mu}{2}|\mathbf{w} - \mathbf{w}^t|^2$) nhằm kiểm soát độ trôi dạt cục bộ (Client Drift) của các Controller.

3. Tích hợp FG-SAAE vào hệ thống OpenFlow hiện hữu có phức tạp không?

Hoàn toàn liền mạch. FG-SAAE được đóng gói dưới dạng một ứng dụng Ryu Controller độc lập (RyuApp). Module này chỉ lắng nghe các bản tin thống kê OFPFlowStatsReply tiêu chuẩn và đẩy lại các bản tin OFPFlowMod để cài đặt luật Drop/Redirect mà không yêu cầu thay đổi phần cứng Switch hay giao thức mạng gốc.

4. Chi phí băng thông khi truyền tải trọng số trong Federated Learning là bao nhiêu?

Kích thước mô hình SAAE được tối ưu hóa chỉ xấp xỉ $1.85\text{ MB}$. Với chu kỳ cập nhật FL mỗi 30 phút hoặc sau mỗi 1000 luồng dị thường mới, băng thông tiêu thụ chỉ chiếm chưa đầy $0.001%$ tổng băng thông kênh điều khiển (Control Channel), thấp hơn hàng nghìn lần so với việc chuyển các file dump PCAP thô (hàng chục Gigabyte).

5. Cơ chế nào ngăn chặn cảnh báo giả (False Positive) từ mô hình bán giám sát?

Hệ thống sử dụng cơ chế ngưỡng phân loại động kép (Dual Threshold). Chỉ những luồng dữ liệu vừa có xác suất nhãn tấn công cao từ vector phân loại $z_1$, vừa có khoảng cách tái tạo vượt ngưỡng sai số Euclidean từ Decoder mới bị kích hoạt chặn tức thì. Các trường hợp nằm trong vùng nghi ngờ sẽ được định tuyến sang Honeypot phân tích sâu.

Kết luận

Đồ án tốt nghiệp "Hệ thống phát hiện xâm nhập cộng tác có khả năng tự cải tiến dựa trên GAN và Encoder cho mạng khả lập trình" (FG-SAAE) đã giải quyết trọn vẹn 3 thách thức cốt lõi của an ninh mạng hiện đại: sự khan hiếm của dữ liệu gán nhãn, hiện tượng suy giảm hiệu năng mô hình theo thời gian và nguy cơ vi phạm quyền riêng tư trong mạng phân tán.

Bằng việc kết hợp sáng tạo giữa Semi-supervised Adversarial Autoencoder (SAAE), Generative Adversarial Networks (GANs) và Federated Learning (FL) trên nền tảng Software Defined Networking (SDN), hệ thống đạt độ chính xác trên $97%$, độ thu hồi phát hiện tấn công mới đạt $94.85%$, đồng thời tiết kiệm hơn $95%$ tài nguyên đường truyền điều khiển. Đây là bước tiến quan trọng hướng tới việc xây dựng các hạ tầng mạng tự phục hồi và tự bảo vệ thông minh trong kỷ nguyên chuyển đổi số.